►
From YouTube: Unleash the Power of Azure Bicep: A RTPSUG Presentation
Description
In this exciting YouTube video, join the Research Triangle PowerShell User Group (RTPSUG) as they welcome back Jeremy Brown for his second talk on Infrastructure as Code with Azure Bicep. Jeremy, an expert in the field, will guide viewers through the process of using Azure Bicep to automate the deployment of infrastructure resources on Microsoft Azure. Whether you are a seasoned professional or new to the world of cloud computing, this video is a must-watch for anyone interested in learning about the latest advancements in Infrastructure as Code. So sit back, grab a notebook, and get ready to take your cloud skills to the next level with Jeremy Brown and the Research Triangle PowerShell User Group!
For more information on the Research Triangle PowerShell User Group, be sure to check out their Meetup page at https://www.meetup.com/Research-Triangle-PowerShell-Users-Group/ and their official website at https://rtpsug.com/.
A
Welcome
everybody
in
the
Research
Triangle
Powershell
User
Group
we're
here
with
Jeremy
Brown,
hey
everyone.
This
is
part
two
of
his
Azure
bicep
talk.
Our
first
talk
was
in
August.
Well,
that
should
already
be
posted
if
you're
watching
this
on
YouTube.
If
you
want
to
watch
that
part
first
and
then
catch
up
with
this
part
afterwards
for
now
Jeremy
Brown
and
he's
going
to
tell
us
a
little
bit
about
what
he's
doing
and
then
get
into
his
presentation.
Jeremy
kick
her
with.
B
Hey
how's
it
going
everybody
I'm,
Jeremy,
I,
work
for
a
large
manufacturing
company.
We
have
vacated
on-premises
data
centers
and
moved
everything
into
Azure,
and
so
my
job
primarily
consists
with
the
plumbing
quote-unquote
in
within
Azure
building
resources
for
all
kinds
of
stuff,
supporting
data
scientists,
rvms
all
all
sorts
of
things,
and
so
I
thought
it'd
be
fun
to
have
a
talk
about
using
bicep
instead
of
arm
I.
B
Think
bicep
is
way
easier
to
pick
up
and
use,
and
so,
when
I'm
building
it
it
quickly,
you
know
became
a
larger
thing,
and
so
we
decided
to
break
it
into
two
parts.
So
the
first
part
that
I
gave
through
was
more
around
the
syntax
and
structure
of
bicep
and
how
bicep
Builds
an
arm
template
how
we
deploy
the
arm
template.
We
kept
the
deployments
pretty
simple
on
the
first
part
and
really
just
stuck
to
the
basics
of
understanding
how
bicep
works.
B
This
talk
is
going
to
build
on
that
and
and
we're
going
to
start
looking
at
more
real-worldy
approaches
to
the
way
that
you
deploy
templates
and
some
of
the
things
that
you
have
to
take
into
account
and
consider,
as
you
work
through.
So
I
strongly
encourage
you
if
you're
new,
to
bicep
to
go
watch
the
first
one
first
before
watching
this
one.
Otherwise,
this
one's
probably
gonna,
get
a
little
a
little
muddy
for
you.
B
B
B
So
yeah
thinking
back
to
what
we
did
on
the
first
one,
the
structure
of
a
bicep
file
is,
you,
have
parameter
blocks,
variable
blocks,
resource
blocks
and
then
output
blocks
right.
So
the
parameter
blocks
are
things
that
we
can
utilize
with
a
parameter
file
and
the
parameter
file
is
what
will
be
read
in
for
each
of
those
pieces.
So
if
we
did
a
a
value
map
right
now,
you
can
see
I've
got
admin
username
as
a
parameter
and
I've
got
admin
username
as
a
value
for
that
parameter
in
a
parameter
file.
B
So
the
same
thing
here
right,
admin,
password
and
then
we've
got
admin
password
Here.
So
that's
the
idea
right.
So
the
parameters
they
don't
always
have
to
be
empty.
So
here
you
can
see
I'm
establishing
a
default
value
for
that
parameter.
So
if
I
want
something
different,
then
I
can
come
over
here
and
add
a
value
for
that
DNS
label
prefix.
B
C
B
You
know
what
Nick
will
be
an
easier
one.
Well
there
it
is
so
here's
you
can
see
that
for
that
storage
account
that
we
built
up
top
it's
being
referenced
later
on
in
the
template
right
down
here.
So
when
you
build
an
object,
for
instance,
here
we're
calling
the
storage
account
STG
afterwards.
All
of
the
values
in
that
object
would
be
there
for
me
to
reference
later,
if
I
need
to
another
example.
That's
on
here
is
the
Nick.
So
here
you
can
see.
B
A
B
So
that's
a
that's
a
common
question
right,
so
bicep
and
bicep
is
a
domain
specific
language
that
exists
to
create
an
arm
template
the
arm
templates.
The
actual
thing
that
you're
deploying
to
azure
and
that's
Microsoft's
version
of
what
terraform
would
be
right.
So
you
know
Microsoft
has
arm
and
then
bicep
is
used
to
build.
That
AWS
has.
What
is
it
cloud?
Formation
I
think
is
what
it's
called
or
Cloud.
Something
like
that
and
then
terraform
is
a
like
an
agnostic
version
of
what
those
things
are.
B
So
it's
really
just
pick
your
poison
for
me.
I
only
work
with
Azure
I
only
deploy
Azure
stuff
and
I,
so
I
I
prefer
to
buy
into
the
ecosystem.
You
know
Microsoft
is
going
to.
Let
arm
have
arm.
Do
the
work
that
it's
supposed
to
do
for
the
for
what
it's
making
if
I
wanted
to
deploy
a
terraform.
If
I
wanted
to
make
a
terraform
the
terraform
deployment
for
azure,
it's
not
the
the
benefit
that
I'm
buying.
B
There
is
the
agnosticism,
so
I
can
use
that
same
syntax
across
Azure
and
AWS
and
gcp,
but
I
can't
deploy
it
natively
within
any
of
them.
I
have
to
do
some
work
in
each
of
those
Cloud
environments
to
even
be
able
to
consume
the
terraform
that
I
create
and
deploy
those
resources,
and
so
because
of
that,
as
those
public
Cloud
environments
change,
you
will
run
into
weird
inconsistencies
with
something
like
terraform,
because
they're
they
haven't
updated
to
fix
that
problem,
or
something
like
that
right.
So
there's
it's
not
to
say,
Azure
is
any
better.
B
B
So
I
find
that
it's
easier
and
a
little
more
consistent,
deploying
Azure
resources.
You
know
with
the
Azure
provided
deployment
tool
which
is
r
amen,
so
that's
and
because
I
don't
have
a
need
to
leave
Azure
and
do
something
else,
I'm
happy
with
that.
If
I
worked
in
both
you
know
Azure
and
AWS
or
gcp,
or
something
like
that,
then
that
would
change
you
know.
B
D
B
B
You
know:
Microsoft
treats
vs
code
like
a
first
party
thing,
so
I've
got
tons
of
stuff
inside
my
extensions
and
one
of
those
is
bicep,
and
so,
when
I
do
that,
building
everything
that
you
know
what
everything
that
I
want
to
do
for
building
a
bicep
file
is
quite
simple:
it's
come
in
and
just
start
building
and
I
get
intellisense
and
auto
completing
everything
that
I
would
want
from
an
IDE
and
building
it.
I
would
also
say:
bicep
is
not
Json
right.
B
D
B
Right
so
then
yeah!
So
let's
take
a
look
then
at
this
first
thing
talking
about
key
vaults.
So
if
we
go
take
a
look
at
my
current
subscription
here,
you
know
I've
built
this
key
Vault
and
it's
inside
a
resource
group
called
shared
resources
and
inside
here
I've
got
a
secret
and
it's
called
local
admin
password
and
here's.
My
only
time
that
I've
written
to
it-
and
you
know
I-
have
the
value
right
here
right
and
then
here's
the
identifier
for
that
secret.
B
B
So
that
goes
into
this
right
here
and
we're
defining
in
our
bicep
file
that
that's
a
secure
string.
So
once
it's
read
into
bicep,
it's
a
protected
string,
but
before
it's
read
in
before
we
deploy
that
it's
just
sitting
here
as
raw
clear
text,
which
would
not
be
a
good
thing
and
so
the
way
that
you
can
fix.
That
is
when
you
come
in
and
you
deploy
your
key
vault.
C
B
B
B
B
B
B
B
B
B
Typically,
you'll
have
some
Resource
Group
that
has
most
of
your
like
networking
and
infrastructure
parts
that
are
shared
amongst
things
and
then
from
there
you'll
Branch
out
into
the
resource
groups
that
I'm
using
to
provide
access
to
specific
groups
for
whatever
reason,
either
either
for
Access,
Control
or
chargebacks
or
whatever
it
might
be,
and
so
here
I've
built
this
shared
resources.
Ou!
That's!
What's
going
to
hold
the
network
that
we're
using
in
azure
for
everything
that
we're
going
to
deploy?
B
C
B
Where
am
I
not
right
now,
I'm
in
azure,
so
we're
going
to
go
to
bicep,
apps
gen
hold
on
and
we're
going
to
do,
bastion.json,
that's
what
we
want
to
do
and
we
would
specify
template
parameter
file
if
we
had
one
in
this
instance,
though,
I'm
not
deploying
a
parameter
everything
that
I
need
to
deploy.
This
exists
within
this
file
here,
so
we
can
just
deploy
that.
B
It
is
deploying
right
here
right
so
here
we
can
see
I'm
deploying
Azure
Bastion,
as
at
this
moment
and
like
I,
said
this
one's
going
to
take
a
minute,
so
I
want
to
go
ahead
and
kick
that
one
off
so
that
we
can
RDP
to
the
VMS
that
we
deploy
a
little
bit
later
much
all
right.
So
let's
go
back
to
talking
about
scopes.
B
So
there's
two
actual
deployments
right,
so
we
just
saw
me
use
the
new
AZ
Resource
Group
deployment,
that's
the
one
that
you'll
typically
use
because
you're
typically
deploying
resources
into
a
resource
Group.
However,
there
are
things
that
you
might
use
new
AZ
deployment
for,
for
instance,
I
can't
deploy
a
resource
Group
into
a
resource.
B
So
when
we
build
a
file
and
we
go
to
deploy
it,
you
will
only
ever
deploy
inside
a
single
scope.
So
what
that
means
is
think
about
looking
back
at
something
like
this.
So
one
of
the
examples
we're
about
to
take
a
look
at
is
deploy
a
VM
and
term
backups
on
so
I
want
to
deploy
that
VM
to
my
RTP
sub
demos,
Resource
Group.
B
So
in
doing
that,
though,
I
have
to
be
able
to
link
it
to
my
recovery,
Vault
and
shared
resources,
so
I
can't
deploy
to
the
shared
resources
OU
when
I
make
the
VM,
because
the
VM
has
scoped
itself
to
the
RTP
sub
demos.
So
and
you'll
know
this
right,
because
here
when
I
said,
new
AZ
Resource
Group
deployment
I
specified
a
resource,
Group
name
that
is
my
scope.
I
get
to
deploy
into
this
Resource
Group
I
can't
split
and
deploy
resources
into
multiple
resources
groups
from
a
single
flat
bicep
file.
B
So
you
only
get
the
one
scope.
If
you
need
to
change
Scopes,
what
we'll
have
to
use
is
we'll
have
to
use
something
called
a
module
and
a
module
is
think
of
it
like,
like
you,
would
a
Powershell
module
right.
So
I
have
my
script
with
a
bunch
of
work
in
it,
but
I
might
want
to
leverage
some
other
set
of
work.
Some
other
functions
from
somewhere
else
and
so
I
would
import
a
module
to
gain
access
to
those
functions.
B
B
In
my
scope
that
I'm
deploying
in,
if
you
know
I
just
need
to
read
the
data
from
it,
and
so
we
for
those
things
you
can
use
scope,
but
that's
not
on
every
property
or
on
every
resource
type.
So
you
have
to
be
cognizant
of
what
types
of
resources
you're
deploying
now,
whether
that's
available
to
you
or
not
so,
and
then
four
deployment,
Scopes
I've
added
a
link
down
here.
That'll.
Take
you
in
to
kind
of
talk
about
what
that
looks
like.
B
So,
let's
go
take
a
look
at
how
some
of
that
might
look
so
here.
I
have
a
template
for
building
a
recovery
vault
and
this
one
I'm
building
my
recovery
ball
called
crime,
any
backups,
so
I'm
establishing
a
backup
policy
in
that
backup,
vault
or
recovery,
vault
I'm
calling
it
or
it's
going
to
be
for
backing
VMS
up.
It's
going
to
be
a
simple
policy
and
I'm
scheduling
it
to
run
Monday
through
Friday
every
week,
and
it's
going
to
run
at
midnight
Zulu
time
for
each
one
of
them.
B
D
B
C
B
All
right,
so
we've
got
my
recovery,
Vault
dot
bicep,
so
let's
go
ahead
and
build
that
so
that
we
can
deploy
it.
So
we
use
bicep,
build
and
then
we'll
specify
recovery,
Vault,
dot,
bicep,
and
this
will
create
the
Json
file
that
we
need
for
actually
deploying
the
recovery
Vault.
So
here
we
can
see
that
that
got
created,
and
so
this
is
how
bicep
looks
nice
and
pretty
clean
and
easy
to
read,
and
then
it
generates
the
actual
raw
Json.
Which
is
far
less,
in
my
opinion,
easy
to
read
and
then
to
deploy
that.
B
Template
file
the
recovery,
Vault,
dot,
Json
and
again
I,
don't
have
any
parameter
file
for
this
one,
so
we
can
just
deploy
that
so
this
would
go
through
if
I
didn't
have
the
recovery
Vault
and
build
it
because
I
already
have
it.
So
it's
something
another
thing
that
we
can
review
real
quick
is
talk
about
the
fact
that
remember
the
arm
fabric
is
declarative.
B
You
add
the
word
existing
and
then
I'm
going
to
specify
what
the
name
of
that
network
is
and
then
use
scope
and
give
it
a
resource
Group
to
go.
Look
for
that
value,
and
so
right
here,
I'm
essentially
saying
go:
get
the
virtual
networks
resource!
That's
named!
V-Net
crime
mini
core,
that's
in
the
shared
resources,
Resource
Group
and
we're
going
to
identify
that
as
vnet
and
I'm
doing
the
same
for
subnets
right.
So
within
my
virtual
Network.
B
And
so
here,
because
we're
going
to
be
deploying
this
VM
to
the
architect,
demos,
Resource,
Group
I,
have
to
specify
scope.
Otherwise
it's
going
to
look
for
this
virtual
Network
in
the
RTP
sub
demos,
Resource
Group,
and
that
that
wouldn't
that
would
return
nothing.
So
we
that's
why
we
specify
scope
quick
question.
Yes,.
A
B
In
this
instance
it
it
would
just
fail
because
I'm
not
actually
deploying
anything.
So
if
you
know
if
I
wanted
to
make
changes
to
this,
then
well
one
I
work.
This
is
where
it
gets
like
kind
of
weird
right.
So
if
it
existed
and
I
wanted
to
deploy
changes
to
it,
then
I
would
be
able
to
go.
Look
at
the
properties
that
exist
for
this
resource
type
and
then
expand
this
thing
out.
You
know
like
let's
go
back
up
to.
B
So
here
you
know:
I'm
not
specifying
existing
and
I
ran
this
earlier
and
it
succeeded
it
ran
successfully,
but
it
did
that
because
I
I
a
deployed
it
to
the
correct
scope
right
when
we
ran
the
command
to
deploy
this
Bastion
I
didn't
deploy
it
to
RTP
sub
demos,
I
deployed
it
to
Shared
resources
so
and
then,
in
doing
so,
even
though
it
already
existed,
it
went
through
and
made
sure
that
that
Network
looked
like
I
have
identified
it
here.
So
it's
going
to
give
me
the
v-net
name
of
v-net
crime,
any
core.
B
It
would
fail
because
I
don't
have
a
v-net
crimity
core
to
deploy
they're
like
if
I
took
the
existing
out.
That
I
would
have
nothing
I'm
missing
the
requirements.
I
need
to
deploy
a
brand
new
network
called
v-net
crime,
any
core
in
the
rtb
sub
demos,
Resource,
Group
and
I
wouldn't
be
able
to
use
this
at
all.
B
So
this
works
because
I've
specified
existing.
If
we
took
that
out,
then
this
wouldn't
be
valid.
I
would
specify
scope
down
here.
When
I
did
the
new
AZ
Resource
Group
right
there,
it's
almost
through
their
parameter
set
yeah,
so
so
yeah.
So
yes,
I
I
could
make
this
work
without
existing
without
error,
but
you
have
to
deploy
it
to
the
correct
scope
with
the
correct.
You
know,
with
the
required
parameters
or
properties
of
that
resource
type,
for
it
to
be
able
to
do
anything.
In
this
instance.
B
It's
really
small,
because
I'm
just
retrieving
the
information
about
that
resource
type
and
storing
it
in
an
identifier
called
v-net
I'm,
not
actually
doing
anything
to
that
Network
same
thing
down
here.
I'm
just
retrieving
that
subnet
General
subnet
and
storing
it
in
an
identifier
called
subnet,
so
that
I
can
reference
them
later
so
and
the
existing
is.
What
lets
me
do
that
is
that
a
good
answer
is
that
clear,
yep
all
right
so
yeah.
So
that's
the
first
thing
about
scope
right.
B
B
B
All
right
so
I'm
going
to
build
a
VM,
that's
rtb,
so
I
guess
VR1.
It's
a
standard,
b2ms
VM,
the
default
low,
glad
middleby
crime,
any
admin.
The
password
is
going
to
be
that
local,
password
admin
password
and
we'll
stick
some
tags
on
it,
cool
all
right!
So
save
that
all
right!
So
then,
now
we
can
do
new
Dash,
AZ,
Resource,
Group
deployment.
B
Name
it
what
did
I
just
say:
RTP
sub,
Dash
svr1,
then
the
resource
Group
that
we're
deploying
to
that
Resource
Group.
Is
this
RTP
sub
demos,
Resource
Group
right
here,
and
so
here's
where
I'm
going
to
start
with
my
concept
of
scope
right
a
template
file
is
then
going
to
be
the
VM
deploy
with
backup,
Json
and
the
template
parameter
file.
It's
going
to
be
vmdeploy.parameter.json.
B
That's
what
we're
going
to
do
and
that's
all
I'm
going
to
run
and
when
I
run
that
it's
going
to
deploy
this
file?
Oh
well,
it
is
going
to
deploy
that
file,
but
we're
going
to
read
it
and
bicep,
and
it's
going
to
deploy
this
all
of
this
into
RTP
sub
demos,
but
when
it
gets
to
the
here,
it's
going
to
take
this
and
it's
going
to
run
another
command
of
this
all
on
its
own.
That
changes
this
name
to
be
backup
and
then
the
name
of
the
VM.
B
So
this
is
the
deployment
inside
your
shared
researchers
will
say
backup.
Rtp
sub
I
should
do
a
dash
there
RTP
sub
Dash
svr1,
and
it's
going
to
do
that
inside
the
shared
resources
right
and
if
we
take
a
look,
we
can
come
up
to
that
enable
VM,
backup,
here's
what
that
bicep
file
looks
like,
and
so
it's
just
another
bicep
file
and
that's
what's
pretty
neat
about
this
right.
So
I,
don't
there's
nothing
special
going
on.
B
So
if
we
think
back
like
to
our
power
shell
ways
when
we
build
a
module,
you're
going
to
build
these
extra
functions
and
then
you
want
to
make
sure
they're,
Advanced
functions
and
so
we're
going
to
add,
you
know
that
way
we
can
get
commandlet,
binding
and
stuff
like
that.
You
want
to
make
sure
that
you
have
appropriate
documentation
for
how
that
function
should
be
used.
B
So
when
the
module
gets
pulled
in
somebody
can
look
at
it
figure
it
all
out
right,
there's
a
lot
of
metadata
I
guess
you
could
say
around
the
work
of
the
function
that
exists
in
the
module
when
we're
doing
bicep,
because
it's
all
declarative
that
doesn't
exist.
A
module
just
means
go
run
something
else,
but
the
something
else
is
literally
just
another
bicep
file,
and
so
here
is
what
that
looks
like
right.
B
So
here
we're
taking
the
you
know
if
I
was
just
going
to
do
if
I
wasn't
going
to
build
a
VM,
but
I
already
had
a
VM
and
I
just
wanted
to
turn
backups
on
this
is
what
I
would
write.
I
would
just
run
this
piece
here
and
specify
the
name
of
the
VM,
the
resource
Group
of
the
VM,
the
name
of
the
Vault
that
I'm
deploying
to
you
know
all
of
these
things
that
I
would
need,
and
then
here
we
can
see
each
of
those
resources.
B
You
can
even
see
a
little
bit
of
cross
kind
of
linking
right
because,
where,
in
my
VM
deployment,
I
had
to
identify
things
and
shared
resources
here,
I'm
actually
going
to
be
looking
back
to
the
resource
Group
for
the
VM,
so
that
I
can
go
find
the
virtual
machine.
I
need
to
be
able
to
identify
that
VM.
So
we
have
to
build
the
VM
and
then
we're
going
to
come
over
here
inside
shared
resources
and
identify
our
brand
new
built
VM
and
then
turn
the
backup
policy
on
for
it.
B
But
if
I
give
my
directory
structure
of
that
modules,
folder
incorrect,
then
when
you
go
to
do
your
bicep,
build
it'll
just
complain
and
tell
you
that
that
bicep
file
isn't
isn't
where
you
said
it
was,
and
you'll
have
to
go
update
and
make
sure
that
you
get
your
file
location
correct,
because
we
were
able
to
do
by
set
build
just
fine
down
here.
We're
okay
and
I.
B
And
it
shouldn't
take
too
long
while
we
go
and
come
over
here.
If
we
go
take
a
look,
we
can
see
under
deployments
my
RTP
server
one
is
currently
deploying
so
I
can
see
that
I
passed
in
RTP
sub
server.
One
is
VM
name,
Cinder,
V2,
a
message
size,
we're
deploying
2019
data
center
into
East
us2.
My
tags,
admin
password
is
empty
because
we're
reading
that
out
of
the
Vault
and
then
what
my
password
name
is,
and
then
the
deployment
template
right
here,
and
so
this
is
it
right.
B
A
B
D
D
B
Now,
let's
see
if
it
runs
the
second
time
it
might
have,
maybe
there
was
some
weird
race
condition
that
happened
in
Azure,
but
even
here
we
can
still
talk
about
how
we
can
see
the
module
working
right,
so
I
didn't
deploy
to
Shared
resources.
Remember
I
ran
the
command
to
you,
know:
RTP
sub
demos
right,
let's
scroll
up
a
little
bit
just
in
front
of
this
error,.
B
Yeah
so
here
I'm
I'm
deployed
to
Resource,
Group,
name,
RTP,
sub
demos
and
and
doing
that
my
module
is
called
backup
name.
You
know
backup,
VM
name
and
that's
what
we
deployed
here.
So
we
can
see
where
that
running.
That
module
ran
that
second
deployment
here
and
then
it's
complaining
because
it
couldn't
find
some
some
item
right.
Some
object.
B
That's
a
weird
error,
though
normally,
if,
like
so
I
said,
I,
think
this
is
a
problem
with
azure
met
over
my
code,
but
we'll
see
how
this
goes
we'll,
let
that
run,
and
it
should
come
back
in
enable
backups,
we'll
take
a
look
and
see
so
that's
Scopes
right.
So
this
is
how
Scopes
work
Scopes
are
done
using
the
scope
property.
B
B
B
Very
clear
documents
on
how
this
works.
It's
not
you,
know,
functional
programming,
so
it's
this.
Is
it
right?
This
is
as
good
as
it
gets.
You
just
have
this
if
statement
and
if
that
condition
is
met,
then,
what's
inside
it
works
so
and
then
they
show
you
different
ways
that
you
can
use
that
if
statement
for
your
conditions,
so
let
me
show
you
how
I
use
it.
B
B
So
we
do
know
that
the
code
Works
everything
was
fine.
It
was
just
Azure,
did
something
funny:
okay,
so
yeah.
So
let's
go
take
a
look
at
conditions.
So
let
me
let's
show
you,
let
me
show
you
what
I
do
for
conditions
pretty
regularly,
so
I
went
ahead
and
chose
to
use
the
same
thing
here
which
is
domain
join,
and
so,
if
we
take
a
look
here,
we're
you
know
have
a
the
same
typical
we're
just
building
a
VM
template
right.
B
Let's
go
into
conditions
and
build
this
file
up.
Bicep
build
and
deploy
I
mean
join
that'll,
make
my
Json
file
and
then
let's
come
over
here
into
there
and
to
this,
and
let's
deploy
all
this
RTP
sub
Dash
svr
two
we've
already
built
one
VM
we've
turned
backups
on
for
that
VM
and
we're
going
to
build
a
second
VM
and
we're
going
to
join
it
to
the
criminy
domain,
which
is
running.
B
B
B
B
B
So
again,
we're
just
going
to
wait
for
this
VM
to
get
built.
So
if
we
go
look
it's
already
built
to
Nick,
it's
currently
making
the
VM
and
then
after
that,
we'll
get
to
see
this
extension
run,
which
will
actually
go
in
and
connect
to
the
domain
controller.
Using
this
account
for
that
domain
and
this
password
to
join
this
computer
directly
into
that
VM.
D
B
So
this
is
the
way
that
you
would,
you
know,
use
a
conditional
statement.
It's
just
if
and
then
emperor
in
the
condition
you
can
have
multiple
conditions
if
you
want
and
then
specify
the
work
that
you
want
to
do
after
that
condition
is
met
here,
and
you
know,
in
this
instance,
we've
built
the
domain
property
to
allow
two
values
criminate
or
none,
and
only
if
criminy
is
specified,
will
I
domain
join.
B
C
B
B
So
if
I
already
like,
if
I
have
an
array
of
elements,
then
I
can
just
Loop
through
the
theory
of
elements
directly
or
I
can
Loop
through
the
array
of
elements
by
the
length
or
by
Counting
an
index
while
I
Loop
through
the
array
of
elements.
So
there's
a
few
different
ways
that
you
can
do
this
and
each
one
of
these
is
unique
to
the
you
know
for
why
you
would
want
to
do
it
and
they
spell
out
a
lot
of
that
across
the
document
here.
B
So
first
we
need
to
go
deploy
that
database
server.
So
let's
go
do
that
and
that's
actually
up
top
here
and
I
would
like
to
point
out
too
inside
of
this
another
benefit
of
using
bicep
over
the
portal
is,
if
you
try
to
go,
create
a
SQL
database
today
in
the
portal,
you
won't
have
an
option
to
make
a
free
database.
B
B
D
D
B
B
B
B
B
Domain
join
runs
one
more
time
so,
like
I
said
earlier,
we're
going
to
go
ahead
and
continue
to
deploy
that
eventual
Works
database
here
I
have
an
expectation
that
the
SQL
Server
exists
already
and
I'm
just
going
to
identify
that
as
SQL
Server
and
this
one
notice
I
did
not
specify
scope.
So
that
means
that
I
expect
the
SQL
Server
to
exist
and
the
resource
Group
in
which
I'm
deploying
the
databases
which
for
this
one
has
to
happen,
and
then
here's
where
I'm
actually
going
to
deploy
the
databases.
B
So
here
we're
making
the
new
databases-
and
my
Loop
looks
like
this
right
here-
the
syntax
is
going
to
be
square
bracket
for
and
then
just
like
a
4-H
Loop
that
you
would
be
used
to
in
Powershell
item
in
Array
and
then
colon
curly
bracket,
the
the
information
for
what
you
would
deploy.
So
all
of
this
I
write
as
though
it's
a
single
a
single
resource.
B
B
I
think
that's
all
the
parameter.
I
need
right.
So
that's
going
to
default
to
the
location,
we're
deploying
to
I've
already
got
tags,
and
then
we
could
change
the
SQL
Server
database
name.
If
we
wanted
to
we'll
go
ahead.
Do
that?
Let's
do
let's
call
this,
so
we
can
identify
it
as
something
different,
we'll
call
it
RTP
sub
Dash
ADV
works
right.
So
let's
save
and
then
CD.
C
C
B
B
C
B
And
we
go
look
at
our
databases,
so
we'll
still
have
the
one
that
we
deployed
originally
the
free
one.
But
then,
on
top
of
that,
we
can
see
how
it
looped
through
and
built
me
the
QA,
the
dev
and
the
prod
database
for
each
one
as
well
off
of
the
name
that
we
specified.
So
that's
how
you
would
handle
Loops.
So
the
other
ways
that
you
could
do
loops
like
I
said,
are
just
by
counting.
B
And
I
guess
the
little
housekeeping.
So
while
this
is
finishing
up,
I
am
going
to
put
all
of
this
up
on
the
rtb
sub
GitHub.
It's
also
on
my
own
personal
GitHub,
and
that
I'll
include
the
handful
of
slides
that
have
the
links
in
them
and
then
all
of
the
bicep
files
that
you
see
down
here
today
so
and
I'll
make
sure
to
copy
the
Bastion
and
database
files
down
as
well.
Since
those
are
useful.
B
I
knew
this
was
gonna,
be
a
harder
one
as
far
as
like
Clarity
goes
just
because
it
is
what
it
is,
but
I
wanted
to
try
to
separate
things
into
multiple
resource
groups
and
then
actually
deploy
across
different
spaces,
so
that
you
can
kind
of
understand
and
see
what
it
looks
like
nope.
It
still
failed.
B
And
it's
an
ex
it's
a
problem
with
the
extension,
so
if
it
failed
like
trying
to
to
actually
connect
to
the
data
or
like
into
the
domain
controller,
you
would
get
a
different
error
and
then
we
could
just
go.
Look.
You
know
into
the
logs
on
the
DC
for
it,
but
this
isn't
that
error.
This
is
an
error
with
the
extension
itself.
C
A
B
A
Yeah
I
mean
I,
see
this
as
because
you've
talked
about
this
before
another
demonstration.
It's
like
how
cheaply
you
can
spin
up
stuff
in
Azure
and
mess
with
it.
Yeah
I
mean
spin
it
down
to
me.
This
is
like,
if
there's
something
you're
wanting
to
mess
with
this
seems
like
a
really
easy
way
to
kind
of
build
building
this
code
spin
it
up
play
with
it,
for
you
know
a
couple
hours
and
then
just
trash
the
whole
Resource
Group
or
resource
groups,
and
you
still
have
that
code.
B
A
B
I
mean
it's
I,
don't
I,
don't
ever
pay
a
lot
of
money,
but
that's
why
it's
I
I
stay
very
you
know.
Yeah
there
you
go
I
guess
in
February,
I
was
a
big
spender
yeah!
Oh
hey!
No!
Look
at
that!
April
April's
was
even
bigger
or
I.
Guess
March
the
month
of
March
I
really
went
all
out,
but
I,
don't
I!
Don't
ever
spend
a
lot
in
here,
but
I'm
really
aggressive
about
cleaning
everything
up
and
because
I
deploy
resources
using
infrastructure
as
code.
It's
not
a
problem
like
Bastion
is
expensive.
B
It's
crazy,
expensive
to
run
Bastion
if
you're
just
going
to
keep
it
up
in
perpetuity.
But
it's
awesome.
It
runs
great.
It's
an
easy
way
to
get
to
all
your
stuff.
When
you
deploy
it's
fantastic,
you
know
it's
it's
just
expensive,
but
I,
don't
keep
it
running,
I
just
build
it
when
I
want
it
and
then
I
throw
it
away
when
I'm
done
and
the
next
time
I
come
in
and
I
go
to
work.
I
just
redeploy
my
Bastion
template
this
thing
gets
run
all
the
time.
You
know
what
I
mean
Mike.
B
B
Is
this
right
here
so
I
use
this
thing?
This
is
how
I
clean
everything
up.
So,
for
instance,
let's
go,
take
a
look
at
what
we
got
right.
So
here
we've
got
this
RTP
sub
demo,
Resource
Group
right
and
we've
deployed
a
ton
of
stuff
into
it
tonight.
Right
and
a
lot
of
this
is
you
know,
built
on
itself
right,
I,
can't
deploy
or
I
can't
remove
the
Nick
until
I,
first
unlink,
the
Nick
from
the
server.
B
So
I
talked
about
this
in
part
one,
but
the
arm
fabric
has
two
modes
and
we
actually
saw
when
we
looked
at
the
at
the
Scopes
part
where
it
was
talking
about
the
mode
and
it
said
incremental,
so
the
default
way
to
deploy
something
is
always
through
the
incremental
mode,
which
means
that
I'm
always
adding
on
to
what
I
have
now.
And
so,
if
you
already
have
something-
and
you
know,
you're
changing
the
value
that
value
will
change
but
you'll
never
remove
or
delete
anything
out
of
the
resource.
B
B
Biceps
yeah
so
I
have
this
clear,
Resource
Group
Json
right
here.
So
this
isn't
an
actual
bicep
file.
This
is
just
an
empty
arm.
Template
it's!
You
know
you
can
see
the
structure
right,
so
outputs
resources,
variables,
parameters,
all
the
things
that
we
we
look
at
and
use.
So
we
make
a
when
we
make
a
bicep
file
into
a
Json
file.
B
B
Template
file,
then
we're
going
to
use
the
clear
template
file
and
then
specify
mode.
This
is
the
important
one
so
and
here
mode
like
I
was
saying,
has
incremental
and
then
has
complete,
so
by
default,
you're
always
running
as
incremental,
but
if
I
do
complete,
instead,
that
what
I'm
calling
the
arm
fabric
to
do
is
to
wipe
everything
and
deploy
exactly
what's
in
this
specific
file,
and
so
by
deploying
an
empty
file
I'm
telling
arm
to
deploy
an
empty
file.
Everything
else
goes
away
and
it's
going
to
be
like.