►
Description
Presented by: Savannah Ostrowski
Go from a local development environment to cloud in minutes—and with a single step! In this session, we’ll walk you through how the new, open source Azure Developer CLI provides developer-friendly commands that support key stages in your workflow: ideation, project initialization, local development, provisioning, deployment, application monitoring, and CI/CD.
As always, feel free to leave us a comment below and don't forget to subscribe: http://bit.ly/subgithub
Thanks!
Connect with us.
Facebook: http://fb.com/github
Twitter: http://twitter.com/github
LinkedIn: http://linkedin.com/company/github
About GitHub
GitHub is the best place to share code with friends, co-workers, classmates, and complete strangers. Millions of people use GitHub to build amazing things together. For more info, go to http://github.com
A
A
Hey
folks
welcome
to
GitHub
universe
and
thanks
for
joining
this
session
on
how
to
go
from
GitHub
to
the
cloud
in
minutes
with
the
Azure
developer,
CLI,
I'm,
Savannah,
ostroski,
a
senior
product
manager,
working
on
Azure,
Cloud
native
developer
tools
and
experience
at
Microsoft
and
I
am
super
excited
to
walk.
You
through.
My
team
has
been
working
on
so,
let's
jump
in
when
you
start
developing
a
new
application.
It
all
starts
from
an
idea.
Let's
call
this.
A
The
ideation
phase,
maybe
you're
interested
in
building
something
simple,
say:
a
to-do
web
application
where
you
can
keep
track
of
daily
tasks.
You'll,
probably
want
to
add
some
features
like
the
ability
to
add
tasks.
Add
due
dates,
take
things
off
when
you've
completed
them
and
organize
them
into
lists,
or
categories
and
right
off
the
bat.
You
might
be
able
to
identify
that.
You
need
a
front
end
for
the
user
interface,
a
backend
for
the
API
and
a
database
to
store
all
of
your
tasks
and
all
of
the
right
metadata
from
there.
A
A
After
careful
consideration,
you
decide
to
take
those
components
in
the
ideation
phase
and
choose
some
libraries
and
Frameworks
to
move
forward
with.
You
pick
react
for
the
front
end
python,
with
fast
API
for
the
back
end
and
mongodb
for
the
database.
You
also
know
that
you're
going
to
write
code
in
Visual
Studio
code
because
you're
familiar
with
it
and
there
are
extensions
there
that
make
you
your
most
productive,
so
you've
decided
on
your
idea
and
you've
chosen
a
tech
stack
to
move
forward
with
now
it's
on
to
the
implementation
phase.
A
So
let's
say
you've
been
working
on
this
for
a
little
bit
and
you've
gotten
something
that's
working
great
locally,
The
Next
Step
here
might
be
to
get
it
up
and
running
on
Azure.
However,
maybe
you
don't
have
a
ton
of
expertise
in
the
cloud.
How
do
I
get
this
up
and
running
on?
Azure
is
actually
a
really
big
question
that
requires
you
to
do
a
bunch
of
cloud-specific
research.
A
More
than
that,
as
you,
research,
more
questions
could
pop
up,
like
which
cloud
services
should
I
use
with
my
code.
How
should
I
set
up
my
local
development
environment?
How
do
I
provision
the
right
infrastructure
for
my
application?
How
do
I
know
that
what
I'm
doing
incorporates
security
best
practices,
and
some
of
these
questions
might
not
have
answers
that
are
super
straightforward
and
even
after
doing
some
research,
you
might
end
up
with
a
it
depends
on
X,
Y
or
Z
being
the
answer
to
any
one
of
these
questions,
making
things
even
more
cumbersome.
A
So
as
it
turns
out,
we've
heard
these
questions
and
others
come
up
time
and
time
again
from
developers
a
lot
of
application
developers,
don't
have
deep
expertise
in
Cloud
infrastructure
and
architecture,
which
makes
it
challenging
for
them
to
know
that
what
they're
doing
makes
sense
for
their
application
will
support
the
experience
and
performance
they
require
and
is
secure
in
using
best
practices
Okay.
So
we've
talked
a
lot
about
questions
now.
Let's
take
a
look
at
some
answers.
There
are,
of
course,
many
different
options
for
getting
this
to
do:
application
up
and
running
on
Azure.
A
But
let's
talk
through
one
option:
to
get
this
basic
web
app
up
and
running
on
Azure
with
a
front
end
back
end
and
database
and
some
monitoring
infrastructure.
We
need
to
provision
or
create
nine
different
resources.
We
need
an
app
service
plan
to
define
the
set
of
compute
resources
needed
for
the
web,
app
to
run
two
Azure
app
service
instances
for
the
front
end
and
back
end
of
the
application
key
vaults
to
store
application
Secrets,
because
inlining
tokens
and
passwords
isn't
secure.
A
All
in
all,
answering
all
these
Cloud
specific
questions
and
provisioning.
The
right
infrastructure
and
getting
the
code
deployed
on
Azure
is
a
lot
to
think
about
and
manage,
especially
if
you
aren't
well
versed
in
Cloud
architecture
and
best
practices
and,
if
you're,
an
application
developer.
This
hinders
your
productivity
and
velocity
when
you're
just
trying
to
write
app
code.
A
Thankfully
this
is
where
tooling
can
really
help
us
end
to
end
in
the
June,
from
GitHub
to
local
development
environment
to
the
cloud
the
Azure
developer,
CLI
or
azd
is
a
new
open
source
tool
that
provides
higher
level
application.
Developer
friendly
commands
that
map
to
key
stages
in
your
developer
workflow,
so
you
can
focus
on
writing
application
code
without
getting
bogged
down
by
the
nitty-gritty
of
the
cloud.
Think
code
build,
deploy,
Monitor
and
repeat
better.
A
Yet
these
commands
can
be
used
from
the
environment
that
you're
most
comfortable
in
whether
that
be
CLI,
Visual
Studio
code
or
Visual
Studio.
The
Azure
developer
CLI
uses
extensible
application
templates
that
include
everything
you
need
to
get
an
application
up
and
running
on
Azure.
The
templates
include
application
code
and
reusable
infrastructure
as
code
assets
written
in
bicep
or
terraform,
and
are
infused
with
Cloud
best
practices
more
than
that
they
cover
end-to-end
scenarios
that
go
far
past
hello
world
we're
talking,
project,
initialization,
provisioning
deployment,
monitoring
and
CI
CD.
A
These
templates
are
programming
language
idiomatic
so
that
the
conventions
used
or
the
conventions
that
you
are
most
familiar
and
comfort
with
there
are
a
host
of
templates
on
GitHub.
For
you
to
choose
from
you
can
take
a
look
by
visiting
the
azd
templates
topic.
The
Azure
developer
CLI
supports
workloads
in
Python,
JavaScript,
and.net,
and
also
as
of
this
release.
We
have
support
for
Java
workloads
as
well
in
terms
of
azure
hosts.
A
We
currently
have
support
for
Azure
container
apps
Azure
app
service,
Azure
static,
web
apps
and
Azure
functions
with
support
for
Azure
kubernetes
service
coming
soon,
and
because
all
of
this
is
open
source,
you
can
choose
from
an
existing
template
built
by
our
team
or
developers
in
the
community,
or
even
make
your
own
code
base
azd
compatible
and
share
out
the
template
with
the
community.
Now
you
might
be
familiar
with
clis
that
generate
infrastructure
as
code
assets
or
scaffold
an
application,
but
the
Azure
developer.
A
Let's
come
back
to
that
infra
directory
I
just
mentioned
this
directory
in
the
files
inside
it
are
integral
to
how
the
Azure
developer
CLI
knows
what
to
provision
for
you
and
how
to
deploy
your
code
on
Azure
if
you're
unfamiliar
infrastructure
as
code
is
a
way
that
you
can
manage
and
provision
your
Cloud
infrastructure
and
services
via
code.
The
files
in
this
directory
specify
the
services
you
want
to
create
their
configurations
and
how
they
interact
using
infrastructure.
As
code,
we
can
ensure
that
the
environment
is
generated
in
the
same
way.
A
Each
time
everything
is
deployed
to
the
cloud
infrastructure's
code
also
means
that,
instead
of
you
or
your
team
needing
to
manage
or
maintain
environment
settings
individually,
you
can
work
off
the
same
well-documented
code
that
represents
the
desired
environment,
State,
avoiding
deployment
issues
by
keeping
everything
consistent
right.
Now,
the
Azure
developer
CLI
supports
two
different
infrastructures:
code
providers,
bicep
and
terraform.
A
The
infrastructure's
code
provider
you
choose
is
up
to
you:
you'll
find
templates
that
support
both
via
the
azd
templates
tag
on
GitHub.
So
now
that
we
understand
what
the
Azure
developer
CLI
is-
and
we've
talked
a
little
bit
about
its
foundational
end-to-end
templates.
Let's
take
a
look
at
how
it
can
help
us
accelerate
the
journey
from
GitHub
to
Azure
cloud
in
just
a
couple
of
minutes
and
with
a
single
step.
All
of
the
Azure
developer.
A
Cli
templates
are
easy
to
search
for
using
the
azd
templates
topic
on
GitHub
here,
you'll
see
both
Microsoft
and
Community,
authored
templates
that
cover
common
end-to-end
developer
scenarios.
Let's
take
a
look
at
this
to
do
python
template
this
template
shows
developers
how
to
build
a
to-do
application
written
in
react
and
python
with
fast
API
that
includes
a
web
app,
an
API
and
a
database.
It
includes
everything
needed
to
deploy
to
Azure
app
service
and
to
configure
all
of
the
connections
required
for
the
web,
app
database
and
API
to
communicate
and
the
template.
A
We'll
also
see
that
there's
a
readme
that
includes
an
architecture
diagram
that
describes
the
application
and
instructions
on
how
to
get
started.
Okay,
so
I'm
going
to
start
with
this
template,
which
in
this
case
pretty
much
much
matches
my
tech
stack
and
application
perfectly,
but
even
if
it
didn't,
we
could
always
swap
out
or
modify
the
application
code
or
even
the
infrastructure
as
code
assets,
to
make
this
template
work
for
my
use
case.
So
I
have
easyd
installed
on
my
local
machine
and
I
can
take
a
look
at
what's
available
to
me
by
typing.
A
Azd-H
I
created
a
new
directory
earlier,
so
let's
double
check
that
we're
in
the
right
place
today,
I'm
going
to
use
the
Azure
developer
CLI
from
within
Visual
Studio
code.
So,
let's
open
the
editor
using
Code
dot
to
show
how
this
works
in
practice.
The
nice
thing
about
using
the
Azure
developer
CLI
is
that,
regardless
of
the
client
application
you
choose,
the
same
commands
are
used
under
the
hood,
so
I'm
in
vs
code
and
I've
installed
the
Azure
tools.
A
Extension
pack,
which
includes
the
Azure
developer
CLI,
as
well
as
other
extensions
that
we'll
touch
on
later.
That
can
help
us
manage
our
resources
from
within
the
editor.
So,
let's
start
by
opening
the
command
palette
by
using
command
shift,
p
or
Ctrl
shift
p,
depending
on
our
operating
system
and
typing
Azure,
developer
or
azd.
A
Here,
we'll
see
a
bunch
of
commands,
but
right
now
the
most
relevant
one
is
azd
up.
This
is
the
most
magical
command
that
the
Azure
developer.
Cli
has
to
offer
I
say
that,
because
we
want
everything
that
the
CLI
does
to
be
transparent
and
without
Hidden
Side
Effects,
so
that
we
can
keep
things
easy
to
reason
about
this
command
wraps
up
project,
initialization,
provisioning
and
deployment
in
one
step
by
wrapping
three
azd
commands
azdnet
azd
provision
and
azd
deploy.
So
let's
give
it
a
shot.
A
So
first
I'm
asked
for
a
template:
I
can
either
choose
one
from
the
list
or,
if
I
don't
see,
the
template
I'd
like
to
use
I
can
input
another
template
by
specifying
the
full
GitHub
URL
I
see
that
same
template.
We
looked
at
before
on
GitHub
in
the
list,
so
I'll
go
ahead
and
select
to
do
python.
Now
the
terminal
is
open
in
my
vs
code
workspace
and
we're
being
asked
for
an
environment
name
I'm
just
going
to
input
Savannah
GH
universe,
but
you
could
input
whatever
you'd
like
in
a
fully
fledged
web
app.
A
Maybe
we'd
have
Dev
tests
and
prod
environments
with
different
sets
of
resources
which
azd
does
support,
but
for
now
I'll
keep
it
simple.
Next,
we're
asked
for
a
region
where
our
resources
will
be
created
and
then
a
subscription,
so
I'll
go
ahead
and
select
those
and
that's
it
now.
The
Azure
developer
CLI
will
orchestrate
some
work
on
Azure
on
my
behalf
and
I
can
go
grab
a
coffee
while
I
wait
a
couple
of
minutes
for
all
of
our
resources
to
be
provisioned
and
our
code
to
be
deployed
on
Azure.
A
Once
this
is
done,
we
can
see
that
I've
got
application
code
now,
in
my
vs
code,
workspace
a
log
of
everything
that
was
provisioned
for
me
with
unique
identifiers
that
I
can
reference
in
the
Azure
portal
and
endpoints
for
our
front
end
and
back
end.
If
I
click,
these
I
can
see
that
I've
got
an
open,
API
schema
for
our
API
and
a
fully
functioning
web
application.
That
I
can
build
upon
and
customize
for
my
use
case,
I'll
go
ahead
and
add
a
couple
of
items
to
my
to-do
list
to
kick
things
off.
A
If
I
ever
want
to
tear
everything
I,
just
provisioned
and
deployed
down,
I
could
also
run
the
azd
down
command
and
the
Azure
developer.
Cli
would
take
care
of
that.
For
me
with
the
application
deployed
and
the
code
open
in
the
current
workspace.
Let
me
show
you
what
else
is
possible
using
the
Azure
tools.
Extension
pack,
we
recently
restructured
the
Explorer
view
to
ensure
that
all
of
your
most
important
web
resources
are
visible.
A
First,
you'll
notice
the
structure
by
Azure
service,
but
I
can
change
this
view
by
clicking
the
group
by
button
which
will
better
match
what
I
do
just
deployed
notice
that
when
I
expand
a
resource,
Group
I
can
see
everything
that
was
deployed
clicking
the
focus
button
cleans
things
up
for
me
even
more
so
I
can
focus
only
on
what's
important
to
me
in
this
workspace.
The
extensions
store
the
focus
State
per
workspace,
so
the
next
time
I
open
this
project
in
vs
code,
I'll
see
that
same
focused
view.
Expanding
the
API
resource.
A
You
can
see
that
we
have
access
to
manage
app
settings
or
environment
variables,
view
the
files
that
are
deployed
and
viewer
stream
logs
right
clicking
on
the
resource.
You
can
see
that
it's
also
possible
to
stop
and
restart
the
app
or
even
start
and
stop
streaming
logs.
Moving
on
to
the
database.
There
are
different
options:
expanding
the
cosmos,
DB
account.
A
You
can
see
the
to
do
database
for
our
app
expanding
that
we
can
see
that
the
to-do
item,
collection
and
each
document
within
the
collection
clicking
on
a
document
opens
it
in
the
editor
where
you
can,
edit.
The
value
for
State
remember
those
two
endpoints
that
were
printed
out
for
our
front
end
and
back
end
after
running
azd.
A
Up
I
can
also
access
those
at
any
time
by
right-clicking
on
the
web
or
API
resources
and
clicking
browse
website,
because
I
just
modified
the
state
of
my
database
items
in
vs
code
you'll
see
that
everything
is
now
marked
as
done
so.
We've
covered
local
development,
provisioning
and
deploying
on
Azure,
but
when
it
comes
to
building
something
meaningful
and
long,
lasting
I
know
that
it's
not
enough
to
just
have
the
application
up
and
running
in
the
cloud.
We
need
to
make
sure
that
we're
infusing
best
practices
into
our
workflow
with
azd
monitor.
A
We
can
see
the
dashboards
and
queries
that
have
been
created
on
our
behalf,
using
the
template
and
the
Azure
developer,
CLI
the
track
usage
performance
and
reliability.
Metrics
that
way,
I
know
my
app
is
performing
as
I
expect
and
if
it's
not.
This
gives
me
solid
signal
of
when
it
might
be
time
to
consider
scaling
out
my
infrastructure.
Let's
check
it
out
to
run
ACD
monitor
from
within
vs
code.
A
We
can
either
use
the
command
palette
again,
or
we
can
also
right
click
on
the
azure.yaml
in
our
project
to
open
the
context,
menu
and
see
all
of
the
available
azd
commands
from
here,
we'll
select,
monitor
from
the
menu
and
will
be
presented
with
some
options
to
look
at
live
metrics
logs
or
the
overview
dashboard
I'm,
not
sure
about
anyone
else,
but
I've
spent
a
ton
of
time
setting
up
dashboards
in
the
past.
So
this
is
a
huge
Time
Saver
speaking
of
best
practices.
A
The
Azure
developer
upper
CLI
also
allows
us
to
scaffold
the
GitHub
actions
workflow
by
running
azd
pipeline
config
in
each
template.
You'll
find
a
GitHub
directory
with
an
Azure
dev.yaml,
which
will
set
up
a
GitHub
action
to
run
against
Real
Azure
resources
on
every
commit
to
your
repo,
which
helps
give
you
some
confidence
that,
as
changes
are
being
made
to
the
code
base,
things
are
staying,
functional
and
working
as
expected
and
again
the
same
commands
that
are
run
in
the
CLI
or
in
vs
code
are
using
our
CI
CD
pipeline.
A
So
things
are
consistent,
regardless
of
the
client
application
running
them.
Let's
give
it
a
shot.
Let's
open
the
context
menu
Again
by
right-clicking
on
the
azure.yaml,
but
this
time
we'll
select
pipeline
config
and
the
Azure
developer.
Cli
will
now
use
that.github
directory
to
set
up
our
CI
CD
pipeline
first
we'll
be
asked
if
we
want
to
create
new
git
repository,
then
we'll
be
asked
to
configure
a
remote
I'm.
A
Also
now,
given
some
options,
I
can
either
use
an
existing
repo,
create
a
new
private
repo
or
enter
a
remote
URL
I'll
select
private
repo
I'm
also
asked
for
a
name
for
this
new
repo.
By
default,
the
CLI
will
use
the
name
of
the
root
directory
for
the
project.
You
could
also
type
in
a
custom
name
if
you
like
now,
the
CLI
will
go
off
and
do
some
work
to
configure
repo
secrets
for
me
to
wire
everything
up.
A
Finally,
I'll
be
asked
if
I
want
to
commit
and
push
all
my
changes
to
the
new
repo
and
kick
off
a
run
of
the
CI
CD
pipeline
hopping
over
to
GitHub
I
can
open
the
actions
tab
and
see
that
a
pipeline
run
has
been
kicked
off.
This
pipeline
will
now
run
on
every
new,
commit
I
or
anyone
else
pushes
to
this
repo
and
that's
pretty
much.
A
It
we've
gone
over
the
Azure
developer
CLI
and
its
templates
that
support
you
through
local
development
and
editors,
like
vs
code,
provisioning
infrastructure
and
deploying
code
on
Azure
and
best
practices
that
are
infused
into
your
workflow
through
application,
monitoring
and
CI
CD
with
GitHub
actions.
More
than
that,
the
support
provided
is
flexible,
yet
opinionated
without
being
overly
prescriptive
of
your
developer,
workflow
or
requirements.
So
to
wrap
this
up.
Let's
go
over
the
azd
workflow
one
last
time
to
start
the
first
question
that
comes
to
mind
might
be
what
do
I
want
to
build.
A
This
is
the
ideation
phase
of
the
development
process
that
I
mentioned
earlier
via
the
azd
template
list
command
or
by
visiting
the
azd
templates
topic
on
GitHub
you'll,
be
able
to
browse
templates
that
support
you
in
finding
the
right
foundational
recipe
for
your
application.
Next
comes
the
question
of
scaffolding,
your
project
and
iterating
on
it
with
azd
init
you're
able
to
pull
template
code
down
from
GitHub
and
get
your
local
development
environment
set
up
from
here.
You
can
modify
the
template
to
make
it
work
for
your
application,
specific
requirements.
A
Remember
these
templates
were
designed
to
be
flexible.
You
could
also
make
your
own
code
base
azd
compatible
and
create
your
own
template
by
using
the
azdnet
command.
Now
it's
onto
the
cloud
with
azd
provision
and
easy
to
deploy
using
these
commands
you're
able
to
provision
the
right
resources
for
your
application
and
deploy
code
on
Azure
based
on
infrastructure
as
code
assets
written
in
bicep
or
terraform
included
in
your
template
better.
Yet
you
can
use
azd
up
to
wrap
up
all
of
those
commands
in
a
single
step,
which
is
what
I
showed
off
earlier.
A
Finally,
let's
talk
best
practices
with
the
azd
Monitor
and
azd
pipeline
config.
We
can
set
up
monitoring
and
dashboards
as
well
as
a
CI
CD
pipeline
for
our
code
base,
if
you're
interested
in
giving
the
Azure
developer
CLI
a
shot
visit,
AKA
dot,
Ms,
azd
Universe,
that's
where
you'll
find
our
developer
Hub,
which
hosts
all
of
our
documentation,
installation
instructions
and
a
guide
on
how
to
build
your
own
Azure
developer.
Cli
template
to
install
the
Azure
tools.