►
Description
In this episode, Matt and Luke show Scott Hunter how to define cloud resources in .NET code with Pulumi.
Pulumi https://www.pulumi.com/
Get started with Pulumi and Azure https://www.pulumi.com/docs/get-started/azure/
Azure for .NET developers https://docs.microsoft.com/dotnet/azure/?WT.mc_id=dotnet-twitter-cephilli
Creating a new Pulumi project with .NET https://www.pulumi.com/docs/get-started/azure/create-project/
A
Hey
we're
back
with
Matt
and
Luke
and
to
talk
more
about
pluming
one
of
the
things
Matt
that
I
run
into
is
you
know
a
couple
years
ago
we
started
thinking
building
these
guides
for
building
more
complicated
dinette
applications,
especially
cloud-based
applications.
So
there's
an
architecture
guide
called
micro
services.
If
you
go
to
a
do
TDT
our
website,
you
can
find
a
guide
up
there
and
we
have
an
app.
We
built
called
a
shop
container
which
has
some
front-end
websites.
It's
got
some
back-end
websites.
It's
got
some
micro
services.
A
It
has
a
little
bit
of
everything
and
it's
not
too
hard
to
pull
the
git
repo
down
and
run
it
locally.
But
if
I
want
to
put
that
in
the
cloud,
I
have
to
go
and
either
manually
build
a
bunch
of
stuff
in
the
portal
or
as
I
said
earlier,
I,
don't
know
how
it
would
actually
build
an
arm
file
to
actually
Express
that,
but
you
were
telling
me
off
offline
that
I
could
build
like
a
shop
container
object.
Yeah.
B
So
that's
one
of
the
things
that
I
think
is
actually
really
exciting
about
paluma
is,
is
by
doing
all
of
this
stuff
in
a
real
language
like
C,
sharp
I
can
build
these
abstractions.
So
if
you
think
about
that
eShop
sample
I'm
sure
there's
a
lot
of
commonality
and
like
we
have
these
micro
services
and
while
the
container
that
they
may
deploy,
is
different,
there's
gonna
be
many
similarities
about
them
right.
A
B
C
Exactly
nothing
is
exactly
right
and
it's
one
of
those
core
benefits
you
from
kind
of
using
a
program,
language
using
the.net
ecosystem.
All
these
tools
from
C
sharp
to
dotnet
runtime
to
the
new
get
package
manager
you
get
to
bring
all
these
into
your
infrastructure
as
well.
I'll
show
a
quick
example
of
some
of
that.
So
you
know
one
example
that
we
have
here
in
the
paluma
examples
on
github,
for
example,
is
this
cause
most
to
be
distributed?
C
Application
and
one
of
the
interesting
things
about
this
application
is
and
I'll
just
uncomment
these
lines
is
this
application?
You
know,
if
you
look
at
this,
what
it's
doing
in
the
deployment
here,
it
looks
actually
very
simple
right.
It's
just
creating
these
functions
and
creating
this
VM
scale
sets
and
then
exporting
some
values
out
of
those
things,
but
internally
what
these
are
actually
doing.
C
These
functions
and
VM
scale
sits
there
doing
a
ton
of
work
right
to
sort
of
create
a
whole
bunch
of
things
to
deploy
a
function,
and
so,
in
this
case,
I'm
deploying
an
azure
function,
so
I'm
deploying
some
code
into
an
azure
function
here,
in
fact,
I'm
deploying
the
code.
That's
just
another
dotnet
project
right
here
right.
This
is
the
app
I'm
going
to
deploy,
but
I'm
gonna,
deploy
that
using
you
know
all
these
different
capabilities.
C
The
other
interesting
thing
is
that
in
this
application,
what
I've
done
is
I've
used
this
new
cosmos,
app
concept
that
I've
created,
which
is
another
abstraction,
which
is
a
general
idea
of
wrapping
a
sort
of
globally
distributed
application
around
cosmos,
TV,
so
I'm
gonna
allocate
one
cosmos
to
be
and
I'm
gonna
deploy
my
dotnet
app
into.
However
many
different
regions,
I
want
to
a
global
distribute
that
app
globally
should
be
along
with
its
data
and
be
able
to
access
those
things,
and
so
I
took
what
would
be
very
hard
to
Paula
G
to
create.
C
Maybe
this
is
the
kind
of
thing
you
guys
are
doing
an
example,
but
these
really
interesting
complicated
topologies
in
Azure
I'm,
giving
them
really
simple
names
right,
I'm,
giving
them
the
cosmos
app,
which
abstracts
away
all
the
complexity
of
putting
all
those
pieces
together,
making
that
a
class
I
could
put
this
in
a
new
get
by
itself
and
ship
that
so
people
could
go
and
use
this
cosmos
app
class
itself,
and
now
all
the
resources
to
great
that
I
mean
look
at
all
these
things.
There's
a
cosmos
account,
there's
a
sequel
database.
C
A
A
C
Rent
it
to-
and
now
it's
also
you
know
it's
a
sea
project
file,
so
this
is
going
to
be
something
you
have
inside
your
visual
studio.
You
can
get
access
to.
You
can
get
intellisense
through
this
thing
you
can
understand
how
it's
behaving
much
easier
than
if
there
is
just
a
5
that
was
in
line.
You
know,
Jason
file
in
the
project
right,
yeah.
B
Being
able
to
use
like
normal
code,
navigation
tools
to
jump
between
this
is
actually
a
rather
large
I.
Think
application.
If
you
think
about
the
infrastructure
right,
it
probably
creates
on
the
order
of
30,
ish
resources
right
and
so
just
being
able
to
jump
between.
Oh
I
saw
that
cosmos
app.
Let
me
see
what
what
is
that
go
into.
It
is
a
is
really
cool
to
see
sort
of
some
of
the
power
that
you
get
when
you,
when
you
leverage
a
real
language,
yeah.
C
It's
exactly
right
and
you
know,
and
you
get
the
type
checking
and
intellisense,
and
all
these
other
things
to
sort
of
make
it
more
productive
to
work.
With
this
thing
you
have
more
confidence
as
well
and,
of
course,
because
it's
just
code,
you
can
also
test
it.
So
you
know
how
often
you
do
you
test
your
you
know.