►
Description
Hear from Don Schenk, Director of Developer Experience, Red Hat and Scott Hunter, Microsoft in this breakout session at Red Hat Summit 2017.
In this session, we’ll show the evolution from a .NET application running on a server to a microservices architecture with zero-downtime deployments—including advanced techniques for optimizing performance. Join this session if you’re ready to apply your .NET skills to microservices and Linux containers.
https://www.redhat.com/en/summit/2017/agenda/session
A
All
right
I'm
going
to
start
because
we
got
a
lot
to
cover
and
I'm
going
to
go
as
fast
as
I.
Can
we're
going
to
talk
about
some
micro
services
on
net
for
your
just
for
to
set
the
stage
I'm
running
Windows
on
a
Mac
and
I
go
to
a
realm,
so
I
do
everything
I
can
to
break
it.
So,
let's
see
if
I
can
break
things.
A
So,
and
we
all
know
that
first
thing
I've
got
to
figure
out
how
to
use
a
slide,
so
why?
Why
are
we
doing
this?
Why?
Who
cares
about
the
net
and
containers?
I
mean
you
know?
What's
the
big
deal?
Well,
here's
why
there's
a
transition
in
the
software
industry-
and
we
all
know
this
and
I
was
just
talking
to
a
former
colleague
today
from
another
company
and
they're,
a
hardware
company-
and
she
said
everything's
software
now
like
we're
not
even
going
hardware
we're
doing
software.
A
So
there's
just
you
know,
we
talk
about
the
digital
transformation
and
we
all
that's
a
buzzword,
but
it
is
it's
true.
I
mean
everything
is
becoming
software
or
the
software
is
changing
and
I.
Think
there's
a
people
say,
don't
get
uber
eyes,
I'm,
not
sure
what
that
means
other
than
get
picked
up
and
given
a
ride
somewhere,
I
always
say:
don't
be
a
blockbuster
in
a
world
Netflix's
because
that's
to
me
that's
the
biggest
example
of
going
from
hardware
to
software
right.
A
So
if,
if
anybody
ever
worked
in
the
upper
left,
I
don't
know
that
from
right
left
quadrant
there
with
the
waterfall.
You
remember
the
the
requirements
document,
the
design
document
and
the
functional
analysis,
and
all
that
stuff
and
RuPt
and
all
that
fun
stuff.
So
we
went
down
to
DevOps
where
everything
just
happens
now
or
should,
and
we
come
from
the
monolith
to
micro
services.
A
I
was
going
micro
services
back
in
the
late
70s
only
because
the
machine
had
27
Meg's
of
RAM
in
64
cave
I
mean
27,
27,
megabytes
of
disk
and
24
K
of
RAM.
So
every
program
was
a
micro
service,
but
it
wasn't
the
same.
Obviously
we
were
from
physical
servers,
I,
remember,
standing
in
front
of
a
rack
of
servers
and
installing
dotnet
taking
all
day
or
all
weekend
or
Saturday
when
I
felt
like
all
weekend
so
where
we
did
virtual
servers
and
we
thought
that
was
cool
because
you
could
spin
something
up.
A
Few
minutes
and
I'll
cover
some
of
the
fun
stuff
with
that,
and
then
we
got
the
containers
where
everything
just
they
containers
great
works
in
a
couple
seconds.
I
can
go
home
and
then
the
data
center
down
to
the
clouds.
Everything
is
the
cloud
the
cloud
and
even
some
people
I
know
that
don't
know
any
about
technology.
It's
not
just
somebody's
computer
I'm.
Like
don't
talk
about
that.
So
some
of
the
issues
software's
too
complex,
are
there
any
dotnet
developers
here
that
use
Visual
Studio
right.
A
A
A
Is
it,
and
also
if
you
spin
up
a
VM
who
in
here
could
guarantee
that
the
VM
they
spin
up
would
be
exactly
like
the
one
that's
running
between
there's
one
right
so
there's
the
wild
exception
I
mean
that
the
same
tendency,
the
same
versions,
everything
that
go.
Will
we
use
ansible
whatever
that's
great,
that
you
are
organized,
but
typically
it's
really
interesting,
so
containers
to
the
rescue
and
as
this
question
marks,
because,
like
everything
else,
there's
issues
with
that
right,
we
have
a
tendency
as
people
just
to
look
for
the
Silver
Bullet.
A
So
I'm
going
to
do
a
very
simple
micro
service
that
returns
the
host
name.
It's
written
in
c-sharp
I,
have
examples
of
my
repos
are
written
in
F
sharp
there.
So
there's
that
I
got
that
working
going
for
me,
which
is
nice
and
then
we're
going
to
stick
it
in
a
Linux
container,
real
basic
stuff,
and
does
it
scale
it
scales
easily?
If
we
use
kubernetes
and
open
shift
its,
you
know
kind
of
like
a
the
open
ship
people
plug
your
ears.
It's
a
wrapper
around
kubernetes
from
my
standpoint.
A
If
you
aren't
familiar
with
kubernetes
at
Kate's,
that's
the
hipster
abbreviation
for
it.
So
Google
wrote
it
to
manage
containers
and
I
say
that
because
they
don't
use
it,
but
it's
still
good
I'm,
not
I'm,
not
dissing.
It
rolling
updates
are
supported,
which
is
really
cool,
which
basically
means
you
have
a
program
running
and
you
just
create
the
new
version,
and
it
just
rolls
it
into
place
with
no
downtime
and
then
zero
downtime
deployments,
and
there's
a
couple
of
models
for
doing
that.
So
let's
do
a
demo.
Let's
run
our
micro
service.
A
Put
it
in
docker
image.
Do
some
scaling
stuff,
it's
just
some
poor
comp,
licked
stuff.
So
here
I
am
in
a
VM.
It's
rel!
Seven!
This!
We
have
a
thing
called
the
red
hot
Red,
Hat
development
suite
and
if
you're
a
developer,
you
get
it
for
$0,
which
means
free
I.
Don't
we
call
it
$0
I,
don't
know
why
it
installs,
really
I
had
a
discussion
earlier
with
someone
else
at
Red
Hat
about
oh,
no,
it's
not
as
good
as
something
else.
A
I'm
like
you
know
what
from
a
windows
developer,
it's
great
I,
just
download
it
install
it
and
it
works.
So
that's
I!
Don't
want
to
mess
with
this
stuff
like
if
you're
new
to
Linux
and
you're
Microsoft
guy,
you
don't
wanna
mess
with
stuff,
and
this
you
don't
to
mess
with
it.
Just
works
and
there's
videos
how
to
use
it
and
everything.
A
So
the
first
thing
I
want
to
show
you,
which
is
really
interesting,
is
my
docker
file
if
you're
not
familiar
with
docker
and
it's
kind
of
like
a
tiny
VM
and
you
build
layers
and
I.
If
you
are
familiar
with
it
and
even
if
you're,
not
if
you
look
at
my
docker
file,
nowhere
in
here
do
I
install
net.
So
that's
the
first
thing:
I'm
going
to
run
dot,
net
programs
and
containers
and
I'm,
not
installing
dotnet.
A
That's
pretty
cool
dotnet
core
now
allows
you
to
publish
applications,
which
means
you
could
take
an
application
and
build
it
from
any
operating
system
to
any
operating
system,
and
you
don't
need
dotnet
installed
where
you're
running
it.
So
I
can
build
a
Windows
app
in
rel
and
run
it
on
a
Windows
machine
without
dotnet
being
installed.
That's
pretty
cool
and
it
works
great
with
docker,
because
I
can
just
use
rel
seven.
A
As
my
base
image
I
install
a
couple
of
dependencies,
that's
the
fact
of
life
and
then
I
just
copy
my
code
over
and
we're
ready
to
rock
and
roll
now
the
hardest
part
of
my
demo
is
getting
out
of
them.
Ok
did
it.
So
if
I
do
a
darker
build-
and
this
goes
really
fast
because
I've
done
it
so
many
times
right,
so
everything
is
cached.
So
it's
a.
We
have
a
thing
called
atomic
host,
which
is
a
smaller
version
of
rel
for
like
containers
and
I'm
experimenting
with
that
to
get
an
even
smaller
image.
A
My
image
that
I
just
built
is
I.
Think
it's
287
megabytes
yeah
like
we
can
see
that
Don.
It's
right
there
at
the
top
207
megabytes
when
I
use
the
tonic
host
I
got
it
down
to
130,
but
there
was
something
not
there
something
missing
and
someone
made
a
joke.
Yeah
I
was
missing
the
150
megabyte
part
that
you
need
so
I.
A
So
it's
going
to
run
at
Port
5,000
if
you
develop
in
this
environment,
I
have
a
VM
and
Windows
just
a
little
thing
that
caught
me
the
first
time
I
did
it.
You
can't
do
it
a
local
host,
because
your
VM
is
your
local
host.
So
when
you
go
over
like
you're
here
to
look
at
it,
you
wouldn't
see
it
so
I
have
asterisk
port
5,000.
So
it
shows
up
anywhere
one
of
the
cool
things
now
about
dotnet
core.
A
Is
you
can
specify
that
URL
as
an
environment,
variable
environment
variable
so
so
there's
the
the
first
12
bytes
of
the
docker
image?
So
that's
just
to
show
you
that
it's
running
in
docker
and
its
forget
to
v2
there's
a
longer
demo
where
I
bump
up
the
versions,
but
we're
pressed
for
time
you'll
see
that
the
versions
are
different.
It's
just
more
impressive
when
you
have
v1
v2,
so
there's
that
so
that's
just
a
proof
to
say:
hey
it
works
and
then
I
can
go
over
here
and
control
see
out
of
that.
A
So
if
I
do
a
docker
PS,
it's
not
running,
there's
a
bunch
of
stuff
running
there,
because
when
you
get
this
development
suite
you
get
kubernetes
and
you
get
OpenShift
and
all
that
so
that
stuff's
all
built
in
it's
pretty
cool
right
I
mean
you
start
up
this
development
kidding.
You
have
all
this
great
stuff
to
play
with,
and
then
you
can
just
like
wipe
it
out
and
start
over
which
I
do
all
the
time.
So
that's
a
great
environment.
So
the
next
thing
I
want
to
do
because
I
want
to
talk
about
the.
A
There's
a
deployment
scenario
called
Bluegreen
deployment
and
basically
is
the
colors
don't
matter,
but
you
have
you
have
a
version
running
and
then
you
want
to
replace
it
with
another
version.
So
let's
go
version.
You
know
4
to
5,
let's
say,
and
so
you
do
that
because
you've
tested
everything
you
know
it's
going
to
work,
it's
not
a
problem,
so
you
do
it.
The
one
thing
you
want
is
no
downtime
and
the
other
thing
that
you
want
is:
if
you
go
from
version
4
to
version
5
to
go
from
blue
to
green.
A
You
want
to
be
able
to
say:
oh
my
gosh.
If
something
bad
happened,
I
want
to
be
able
to
switch
back
instantly.
So
one
of
the
things
you
get
with
with
this
suite
with
kubernetes
and
Cova
chips
and
all
this
is
you
get
software-defined
networking
and
routing,
so
you're,
not
trying
on
Hardware
you're.
Just
it's
just
commands
so
I
have,
of
course,
I
have
everything
scripted
cuz,
it's
a
demo.
A
A
So
if
you're
not
familiar,
here's
what's
going
to
do
it
does
a
new-build
configuration
which
basically
says
I'm
going
to
build
stuff
and
here's
how
I'm
going
to
do
it
then
the
start
build
is
a
it's
a
binary,
build
I'm.
Sorry,
the
new
build
is
a
binary
build,
which
is
basically
a
docker
image.
You
can
also
do
a
build
from
source
or
quits
called
s2i
the
number
two
source
to
image
and
you
can
pool
like
from
get
so.
A
You
could
do
that
I'm
doing
binary,
because
I
have
to
pick
one
and
then
you
start
the
build
and
the
follow
just
says
it's
kind
of
like
the
verbose
thing
and
then
it
creates
an
app
in
which
is
like
a
pod
and
kubernetes.
So
over
here
the
web
console
is
where
on
I
have
this
so
open
ship
has
a
web
console
a
dashboard,
so
the
first
thing
I
need
to
do
is
I
need
to
log
into
this.
A
So
I'm
going
to
create
a
new
project.
Now
you
don't
have
to
do
everything
at
the
command
line,
but
if
you
see
in
the
background
now
I
have
it
there.
So
obviously
you
can
work
with
command
line.
It's
reflected
in
the
dashboard.
So
that's
kind
of
nice.
You
get
you
can
you
know
kind
of
get
a
visual
feedback,
but
you
can
stay
at
the
command
line,
which
is
where
you
want
to
be
right
because
you're
going
to
script
stuff.
So
if
I
go
into
this
now,
there's
nothing
there,
which
is
which
is
of
course.
A
So
if
I
do
that
again,
I
showed
you
the
how
it
feels
I,
just
let's
just
go
ahead
and
run
it
so
create
green
is
going
to
create
this
application.
So
it's
going
to
do
the
build,
which
is
the
docker
image
this
time
instead
of
the
docker
image
being
in
in
my
PC,
it's
inside
of
openshift
alright
has
its
own
repository.
A
It
just
so
happens
that
openshift
is
on
my
machine
so
physically
the
same
little
magnetic
bits
are
on
this
machine,
but
it
could
be
open
ship
running.
You
know
in
Azure.
For
that
matter,
you
understand
so
that's
where
the
build
would
be
done,
so
it's
built.
So
if
I
go
over
to
the
dashboard,
I
should
see
it
and
I
can
now.
The
problem
is
I
can't
get
to
it.
A
A
It
thought,
nut
hello
and
when
I
mash,
that
I
should
now
be
able
to
go
back
and
there
is
a
URL
and
what
I
have
over
here
is
an
application
that
just
it's,
this
powershell
on
Windows,
so
I'm
trying
to
throw
as
many
things
into
the
mix
to
show
you
that
it's
open-source
everything
works
together.
So
this
is
hitting
it
every
second
and
watching
it.
So
I
just
turns
the
host
name.
Now
remember
the
last
time
is
12
bytes
of
the
docker
image
now
I'm
getting
the
open
ship,
the
pod
from
kubernetes.
A
So
that's
this
one
right
here.
So
if
I,
if
I
scale
this
up
to
2
for
example-
and
it
takes
like
4
seconds
now-
I
have
two
of
them.
Now
it's
92,
so
the
first
thing
you
see
is
you
can
scale
real
quickly
and
you
can
script
all
that
you
can
set
configurations
that
you
know
the
scaling
kicked
up
and
down
kicks
off
automatically
and
all
that
stuff.
But
you
see
I
went
from
1
to
2
just
like
that,
and
this
is
on
a
laptop.
This
isn't
a
server
and
again
this
is
all
dotnet.
A
A
So
of
course,
I
have
a
create
blue
script
and
if
I
run
this
and
there's
things
go
well
in
the
background
you're
going
to
see
dotnet
hello,
blue
now
again
in
a
longer
time
of
our
demo,
I
would
go
in
and
edit
the
code
and
rebuild
it.
So
it
would
say,
like
version
3,
but
you'll,
see
the
change
in
the
PowerShell
window
and
there
it
is
so
now
I'm
running
on
the
new
version
notice.
There
was
no
downtime
at
no
point.
Did
I
get
like
service
not
available
or
anything.
A
A
A
And
there
it
is
so
that
is
the
scenario
where
you
say
we
declare
our
app,
but
we
want
to
kind
of
have
a
back-up
plan
in
case.
Something
goes
wrong,
I
mean
I,
know
nothing
ever
does.
If
you're
like
me,
a
developer
when
you
leave
on
Friday
and
give
it
to
the
dev
ops
to
develop
the
operations
people,
you
know
it's
going
to
be
fine,
so
there's
your
Friday
5
p.m.
deployment.
A
So
we
are
now
in
the
blue,
which
is
our
next
version
now
I'm
going
to
show
you
what's
called
the
canary
deployment.
The
canary
deployment
is
where,
because
you'll
canary
in
a
coal
mine
where
you
roll
out
well
the
canary
was
you
go
in
the
coal
mine
right.
You
have
a
little
bird
there
and
it
sings
and
everything
when
it
stops.
You
knew
to
get
out
a
coal
mine
because
there
was
either
natural
gas,
which
is
odorless,
even
though
it
seemed
like
it
is
what
it
is
actually
or
a
carbon
monoxide
or
some
poisonous
gas.
A
That
was
a
mistake,
but
if
it
works,
then
we're
going
to
give
it
to
a
little
bit
more
of
our
audience
and
if
that
works
a
little
more
eventually,
the
idea
is,
it
kind
of
overtakes
like
say
we're
going
from
Version
three
to
four
version:
four
overtakes
version
three
and
it
becomes
the
new
version.
This
is
kind
of
a
gradual
way
to
introduce
new
version
with
a
fallback
rather
than
the
blue
green,
which
is
like
all
or
nothing
that
says
yeah.
Let's
just
kind
of
give
it
out
slowly
and
you
could.
A
There
are
tools
that
I
don't
have
on
here:
I
came
out,
I
think
is
like
itse
or
something
there
was
a
tool
could
do
routing
and
it's
pretty
cool.
Now
this
isn't
doing
the
routing
per
se
I'm
just
going
to
do
the
application
and
the
scaling.
The
routing
is
a
different
story,
in
other
words,
how
you
control,
who
gets
it.
You
know
like
everyone
named
Jason
or
something
like
that
or
all
the
customers
in
this
state,
or
we
have
customers
over
certain
revenue
or
under
I.
Don't
know,
that's
that's
a
whole
nother
issue.
A
This
is
the
infrastructure
that
we're
going
to
do
with
that,
so
I
have
canary
create
now,
let's
make
sure,
I
get
this
right,
so
we're
cranking
away.
In
the
background,
that's
cool
and
by
the
way
over
here,
you
can
see
that
there's
four
here
and
two
there
and
we're
running
the
four
everything's
good.
So.
A
I
have
one
called
create
canary,
so
the
canary
build
I
start
that
off
it's
going
to
do
another
build,
and
it's
going
to
you're
going
to
see
the
word
canary
in
there
to
try
to
make
it.
You
know
noticeable
for
our
sake
now
when
this
runs
we're
talking
about
zero
downtime
deployments.
So
the
idea
is
oh,
oh,
then
the
service
went
down,
so
something
obviously
went
wrong.
If
you
see
in
the
background
you
see
it
scaling
here,
so
that
this
one's
scaling
and
stuffs
moving,
but
over
here
there's
the
weight.
Okay,
now
we're
good.
A
So
there
was
some
time
and
the
service
was
down
now.
Why
it?
What's
the
deal
with
that?
Well,
there's
a
couple
of
things:
kubernetes
has
this
thing
called
a
readiness
probe
that
you
can
tell
the
system
like
don't
even
bother
with
this
pod
until
it's
ready,
okay,
the
first
example
I
had
that
set
in
this
example.
A
I
did
not
and
I'll
show
you
why,
in
a
minute-
but
if
you
see
the
canary
now
is
just
one
of
many
in
there,
you
see
how
that's
popping
up
now,
if
I
go
over
this
dashboard
and
poke
around
there's
the
canary.
So
let's
take
this
for
I
had
to
be
careful
because
sometimes
I
bump
the
trackpad
and
takes
it
as
a
key
click.
I'm,
really
more
of
a
mouse
person
I'm
going
to
scale
this
one
down
to
two
and
scale
the
canary
up
to
three
and
see
what
it
does
to
the
mix.
A
A
So
there's
your
canary
and
you
would
adjust
it
by
doing
the
scaling
and
it
it
could
have
been
zero
downtime,
but
it
wasn't,
but
that's
by
design,
because
I
want
to
show
you
one
more
thing
before
I
turn
this
and
I'm
making
great
time
turn
this
over
to
Scott,
and
that
is
what's
known
as
the
circuit
breaker
pattern.
So,
speaking
of
breaking,
let's
break
this.
A
Let's
get
out
here,
you
know
what
here's
every
operation,
persons,
nightmare,
OC,
delete,
project
my
net
and
then
cascade,
which
basically
says
just
go
down
the
chain
and
get
rid
of
everything.
This
is
this
is
my
favorite
part
of
the
demo
and
just
kind
of
a
warped
sense
of
humor,
because
I
like
to
do
this
and
watch
everything
in
the
background
just
go
away:
I
just
I,
don't
know
I
just
get
a
kick
out
of
that.
So
it's
going
all
the
work.
A
I
did
is
gone
your
the
point
about
that,
though
all
the
work
is
gone,
but
I
still
have
look
at
this
I
wiped
everything
out
right,
no
I
didn't
I
still
have
all
the
images,
all
the
docker
images.
Here's
the
beauty
of
containers,
I,
didn't
lose
anything
I
just
stopped
running
it.
Images
are
immutable,
they
don't
change.
The
whole
idea
of
immutable
infrastructure
is
that
you
never
change
your
application
once
you
have
the
what
you
have
it
built?
Well,
you
never
do
you
always
rebuild
it,
but
they'll
be
the
point?
Is
it
damaged?
A
You
know
it
doesn't
change.
If
you
want
to
change
something,
you
rebuild
it
and
you
have
another
version,
it's
immutable
that
image
runs
the
same
everywhere.
I,
don't
have
to
worry
about
spinning
up
a
VM
and
hoping
they
match.
I
just
do
another
image,
even
though
I
blew
everything
away
so
to
speak
as
long
as
I
have
these
images,
I
can
rerun
them
and
I'm
going
to
get
the
exact
same
code.
That's
fantastic
and
again,
it's
all
in
c-sharp,
but
it
could
be
f-sharp
I'm
using
stuff
out
of
the
box.
A
If
you
heard
an
ansi
FX
that
works
great
too
so
there's
a
product,
a
project
called
the
poly
project,
I'm
going
to
go
over
that
and
show
you-
and
this
is
a
pretty
mature
project-
I-
think
it's
like
a
version
5
and
what
it
is.
It
allows
you
to
implement
the
circuit
breaker
pattern.
The
circuit
breaker
pattern
is
like
the
circuit
breaker
in
your
house.
So
I'll
give
you
an
example.
Very
real
to
me.
A
I
did
some
outside
wiring
and
I'm
a
techie,
so
there
was
a
problem
every
time
we
had
a
hard
rain
it
would.
The
ground
fault
would
throw
like
the
circuit.
Would
open
and
I
don't
have
any
lights
outside
because
I'm,
not
really
that
handy.
So
the
circuit
opens
up
so
now
nothing's
happening.
No
electricity
is
getting
to
my
light,
so
I
go
to
the
box
and
I
hit
the
reset
button
right.
A
The
circuit
closes
well,
there's
water
in
there,
it
pops
back
open,
so
I
wait
an
hour
or
I,
get
a
shop
vac
and
suck
the
air
out
of
the
stuff,
the
water
out
of
the
electrical
line,
because
I
don't
know
what
I'm
doing
and
then
I
hit
the
close
button.
Then
it
tries
again
at
a
possibly
oh,
my
gosh,
so
I
try
again
it's
a
really
funny
story
too.
It
turns
out
I,
it
was
an
extension
cord.
It
wasn't
my
wiring,
so
finally,
you
do
it
and
it
shuts
and
everything's
good
right.
A
The
power
is
good.
The
circuit
breaker
pattern
and
distributed
processing-
and
let
me
start
by
this
distributed
containers-
are
great
right
and
all
this
stuff's
great.
But
then
you
what
you're
doing
is
your
morphine
in
this
world
of
distributed
systems,
and
then
it
brings
another
they're,
not
problems,
but
they're
considerations.
You
know
logging
and
performance
monitoring
and
the
circuit
breaker
pattern
like
if
you
have
multiple
services,
one
calling
the
other,
let's
say:
ABCD
and
E
and
C
is
down
what
happens.
A
Your
system,
like
oh
man,
we're
sunk
because
the
one
stupid
micro
service
I
thought
these
things
are
supposed
to
be
great,
so
you
have
to
come
up
with
a
way
to
get
around
it
or
account
for
it.
The
circuit
breaker
says
as
long
as
I'm
hitting
the
server
and
everything's
good
we're
cool
or
everything's
great,
but
let's
see
there's
a
problem
on
the
server
end
and
not
just
that
the
server's
down.
Let's
say
that
my
favorite
one
is:
the
server
is
slow,
so
you're
hitting
the
server
and
it's
slow
and
you're
not
happy
with
that.
A
So
what
you
do
you
just
hit
it
again
right
you
keep
trying
to
try
and
try
it
so
you're,
making
the
problem
worse
right,
I
just
hurt,
so
I
just
keep
pushing
on
it
until
it
gets
worse.
So
what
you
want
to
do
is
you
want
to
say:
I
want
to
stop
access
to
the
server
for
a
certain
amount
of
time,
give
it
a
chance
to
recover
and
then
I'm
going
to
try
again
and
if
it
fails
I'm
going
to
go
back
to
my
okay,
open
state.
Wait
again,
try
wait
again,
try
success!
A
Oh
we're
good,
so
the
circuit
breaker
pattern
does
that
and
I
use
the
poly
project.
One
of
the
things
I
want
to
point
out
is:
if
you
look
down
here
in
the
right
hand,
corner
it:
targets
net
for
Oh,
net
4
or
5
in
net
standard
1.
Oh
no,
we're
in
to
say
dotnet
core
yeah
that
works
in
that
core.
That's
something
we're
mindful
of
when
you
get
into
that
core.
Just
because
something
doesn't
say
dot
in
that
core
doesn't
mean
it
won't
work
right.
A
So
keep
that
in
mind,
so
the
poly
project
is
going
to
say,
and
you
configure
this
as
a
developer.
In
my
example,
I
haven't
I.
Think
I
have
a
4
second
timeout,
that
if
the
server
takes
more
than
4
seconds
it
says
you
know
what
I'm
just
going
to
back
off
and
not
try,
and
then
it
waits
eight
seconds
of
trying
and
then
it
tries
again
and
if
it's
successful
it
keeps
going
and
it's
not,
it
goes
back.
It
starts
over
another
eight
seconds
right.
We
got
that
some
interesting
things.
A
If
you
back
off
for
eight
seconds
and
two
seconds
into
it,
the
server
recovers.
You
still
wait,
there's
other
six
seconds
right.
That's
you
program
that
in
it's
all
up
to
you
as
a
developer,
to
you
know,
put
in
what
you
want,
but
what
you
can
do,
because
it's
under
your
control,
the
circuits
open,
you
can
provide
like
a
fallback
position
or
a
default
value.
A
The
example
that
I
was
given
is,
if
you
go
into
Netflix
and
you
sign
in,
and
you
get
recommended
movies
right
and
they're,
based
on
your
your
patterns
of
watching
movies
and
before
that
number
before
they
had
that.
Now
they
have
the
different
like
who's
watching
right.
You
have
multiple
profiles
before
they
didn't
someone
away
from
the
grandkids
would
be
watching
movies
and
I'm,
like
I,
think
I'll
go
watch
a
movie
that
comes
up
like
like
Teletubbies
and
Penguins
of
Madagascar
like
and
really
kind
of
watch
Pirates
of
the
Caribbean.
A
So
if
you
doesn't
have
your
personal
recommendations,
it
will
just
give
a
default
recommendation
if
that
service
is
down,
but
you
don't
know
it
so
there's
a
good
example
like
whoa
the
circuits
closed,
but
the
user
doesn't
have
to
know
so.
I
just
want
to.
Let
you
know
about
the
pilot
project,
I
use
that
and
it
works
very
well
so
I
have
an
application
over
here.
It's
called
howdy
and
at
you
you
get
one
guess
what
it
returns
as
a
restful
interface.
A
A
Okay,
it's
running
up
there.
If
you,
if
you've,
not
used
docker
with
a
humorous
thing,
is
when
you
run
something:
if
you
don't
give
it
a
name,
it
makes
them
up
and
see
the
sad
swirls
it
makes
it
makes
up
these
awesome
names.
So
there
it
is
running
docker
I'm,
going
to
run
that
again,
just
to
make
sure
it
didn't
crash,
and
why
would
it
crash
I'm
going
to
bring
this
up?
A
Well,
we
have
this
book
or
the
spreadsheet
that
this
application
runs
a
port
80
and
this
runs
on
port
83
or
whatever
you
can
just
assign
them
all
to
port
80
and
that
it's
sorted
out.
So
that's
cool,
that's
added!
So
now
it's
up
and
running!
So,
theoretically,
if
I
go
over
here
and
the
path
is
greeting,
I
should
get
howdy.
So
this
howdy
has
two
settings
now:
I
have
a
slowdown
that
mimics
the
server
being
slow
and
then
a
normal
which
brings
it
back
so
I
have
a
watch.
A
A
That's
a
console,
app
and
I.
Don't
need
to
go
in
the
code,
because
two
reasons
one
today
is
not
to
get
greedy.
It's
to
show
you
what's
possible
and
then
you
can
run
with
it
and
everything
I
have
is
one
is
in
a
github
repo.
You
know
you
can
get
it
downloaded
and
play
around
with
it
all
you
want.
So
there
it's
doing
like
a
curl,
it's
getting
a
request.
So
it's
running
howdy.
So
how
he's
fine
everything
is
going?
My
micro
services
are
returning.
A
You
know
whatever
my
location
based
on
my
IP
address
or
whatever,
and
then
that's
just
let's
just
make
this
fail
and
then
we'll
be
done.
So
if
I
set
this
to
slow
down
and
go
back
here
now,
the
circuit,
oh
and
now
the
circuits
broken.
So
it's
every
time
it
says
broken
circuit
exception,
it's
not
hitting
the
server.
So
that's
the
an
example
of
it
and
now
I
go
back
here
and
run
normal.
A
Now
again,
it
has
to
wait
the
eight
seconds
so,
even
though
things
are
back
to
normal
speed,
the
circuits
open
that
goes
with
tasks,
clothes
that
tries
to
at
the
redness
back
up.
So
that's
the
circuit
breaker
pattern.
So
those
are
the
things
you
can
do
today
today
with
dotnet
core
and
containers
and
docker.
Now,
Scott
is
going
to
talk
about
what's
coming
up
with
dotnet
standard,
oh
and
I
think
it's
going
to
be
pretty
cool
I'm.
B
Scott
hunter
and
I
work
in
Microsoft
on
net.
We
got
a
couple
other
guys
in
the
back
of
the
room.
We
got
Matt
Ellis
over
here
hander
up.
We
got
Steven
Tove
here
as
well.
So
if
you
have
any
questions
on
dotnet
after
the
session,
please
find
those
guys
and
I'm
gonna
do
a
quick
intro
of
some
of
the
stuff
we
have
coming
up
next
week
for
you
guys.
B
The
big
goals
of
this
dotnet
standard
kind
of
replaces
something
we
had
before
called
portable
class
libraries.
This
is
the
way
we
shared
code
in
net
before
portable
class.
Libraries
had
had
a
challenge
because,
as
you
added
more
frameworks,
the
surface
area
got
smaller
and
smaller
and
smaller,
and
so
that
was
one
of
the
goals
we
want
to
solve
with
that
net
standard.
B
One,
oh,
that
we
shipped
another
thing
is
there's
a
challenge
that
we
had
with
that
in
standard
one,
which
was,
if
you're,
using
gotten
in
court
a
day
and
you're
trying
to
port
an
application
from
net
framework
you're
going
to
find
a
lot
of
api's
are
missing,
and
so
we're
working
on
that
now.
I'll
talk
about
that
in
a
second.
So
this
is
just
a
chart
kind
of
showing
you
the
goals
of
dotnet
standard,
which
is
all
the
nets
whether
it's
Windows
desktop,
whether
it's
cloud
micro
services.
B
B
70%
of
all
the
packages
in
the
nougat
gallery
actually
can
run
on
dotnet
standard
because
enough
api's
are
brought
back,
and
so,
if
you're,
a
customer,
that's
trying
to
move
some
definite
framework
code
to
done
in
core
on
RedHat.
This
is
going
to
be
a
huge
boon
for
you,
because
a
lot
of
the
stuff
it's
the
dotnet
is
going
to
run
on
red
head
at
this
point.
B
B
B
It's
got
the
notion
of
simplified
packaging.
It
used
to
be
that
you
would
acquire
dotnet
core
and
you
had
to
acquire
things
like
asp.net
and
any
new
framework
separately,
we're
going
back
to
a
model
where
everything
has
been
one
big
framework
and
you
acquire
net
core
and
you'll
get
all
of
the
all
the
technology
for
things
like
asp.net.
We
have
this
notion
what
we
call
automatic
diagnostics.
B
This
is
today,
if
you
run
a
nascent
application,
if
there's
a
whole
bunch
of
configuration,
if
you
do
for
Diagnostics,
this
will
just
happen
directly
in
vs
and
nvs,
for
Mac
and
from
command
line
and
stuff
do
some
work,
but
but
it'll
be
automatic.
In
the
IDE
s,
we're
bringing
back
a
great
framework
for
building
spa
type
applications
called
razor
pages.
It's
a
simplified
MVC.
B
We
don't
have
to
have
all
the
other
stuff,
and
we
have
another
framework
that
we
had
called
signal,
R
that
we
had
running
on
done
in
framework
that
we're
bringing
with
this
as
well.
So
a
lot
more
compatibility
and
a
lot
of
the
missing
features
that
we
had
from
the
idea
framework
are
coming
with
this.
This
is
an
example
of
what
an
asking
the
application
looks
like
today
in
net
core
1.0
and
notice.
You
have
to
know
a
lot
of
stuff
to
boot.
All
that
up.
B
That's
a
man
spin
on
application
today
with
dotnet
core
Oh,
looks
like
this.
I
reference
dotnet
core
I
reference,
asp.net
and
I'm
done
that's
kind
of
a
simplified
packaging.
I
want
to
talk
about
one
other
thing
as
well,
which
is
I,
saw
some
hands
go
up
earlier.
People
use
Visual,
Studio
people
using
vs
who
has
a
Mac.
B
So
if
you're
a
Mac
person
today,
you
know
the
typically
the
way
you
build
dotnet
core
applications
as
a
vs
code
and
command
line.
We
announced
in
November
Visual
Studio
for
Mac
and
we'll
have
a
preview
of
this
I
think
next
week
as
well,
and
this
is
a
preview
of
vs
for
Mac.
It
basically
has
a
lot
of
the
same
experiences
that
you
have
in
vs
forget
core
in
vs
for
Mac
I
before
I.
B
Even
talk
about
that
I
want
to
highlight,
we
are
going
to
try
to
make
these
products
exactly
the
same,
meaning
that
if
you're
using
you'll
get
the
same
project
templates
if
you're
using
our
HTML
CSS
or
Jason
editors
they're,
the
exact
same
code
base
from
Visual
Studio,
so
it'll
behave
exactly
the
same.
The
back
end
of
bugger
is
the
same
back
into
bugger
across
both
products,
and
all
of
our
public
infrastructure
is
the
same
as
well.
B
Sometime
later
this
year,
we
also
plan
to
bring
the
same
JavaScript
editor
from
from
Visual
Studio
for
Windows
and
the
same
razor
editor
for
asp
net
core
applications
from
Visual
Studio
for
Windows
as
well.
So
the
idea
here
is
whether
you're
on
Mac,
whether
you're
on
Windows,
you
get
the
exact
same
experience
with
that
preview.
That
will
come
out
next
week.
You're
going
to
get
all
of
the
a
snake
or
the
console
test
templates
will
be
built
in
you're,
going
to
get
container
support
with
debugging
built
in.
B
B
B
B
B
So
there
was
my
redhead
project
oops
there
I
am
running
in
a
container,
let's
go
back
to
vs
and
I,
put
that
breakpoint
on
the
about.
Let's
try
eating
about
boom,
so
I'm
actually
running
in
a
container
debugging
nvs
for
mac
on
a
Mac.
Obviously,
so
the
goal
for
us
is
there's
my
imp.
There's
my
container.
B
B
We
have
some
stuff
that
we
and
so
the
quite
now
I.
What
I've
said
answer
is
we
don't
have
any
plans
to
port
WCF,
2.8,
core
and
part
of
the
reason?
Is
you
know
if
we
keep
reporting
stuff
like
that?
Where
do
we
stop?
I
could
bring
system.
Web
I
could
bring
CC
F
right
now
we
kind
of
envision
a
snack
or
and.net
core,
and
you
have
core
to
be
the
way
to
build
new
modernized
container
applications.
That
said,
there's
lots
of
folks
with
with
legacy
code.
B
We
do
have
internally
some
shims
that
make
it
easy
to
take
some
of
your
existing
WCF
code
and
actually
run
it
on
core.
If
you
find
me
afterwards,
I
can
my
hope
is
sometime
later
this
year
to
make
those
shims
available
in
github.
So
if
you
want
to
help
porting
your
code,
it
makes
makes
porting
your
code
a
lot
easier.
Come
find
me
afterwards.
I'll
give
you
a
copy
of
the
shim
code.
I
will
have
to
defer
to
these
guys
and
when
that's
what
happened,
but
here's.
B
What
I
would
say
is
for
my
current
non
ridet
images.
I
do
actually
have
images
where
we
actually
put
the
shared
framework
into
the
container
itself
today,
so
we're
not
actually
doing
in
the
case
of
the
containers
that
we
have
outside
of
Red
Hat.
We
actually
have
the
shared
framework
there,
so
you
only
publish
your
application
to
the
containers.
I,
don't
know
if
you
guys
have
a
plan.
B
There's
there's
well,
there's
here's
the
question:
there's
two
ways
to
publish
a
dotnet
core
application.
One
is
what
we
call
a
standalone
application
where
all
the
dll's
are
part
of
the
publish
and
then
there's
one
where
you
actually
just
have
the
shared
framework
and
you
just
publish
the
actual
application
itself.
So
it's
less
stuff
to
publish
in
the
case
of
having
a
shared
framework
is
that
were
the
reason
you
want
this,
because
it's
a
faster
publish
because
there's
less
stuff
to
shove
in
the
container.
B
The
hope
is
that
we
have
the
F
sharp
stuff
done
in
the
to
o
time
frame
before
the
to
of
stuff
rtems
the
summer.
So
and
there
is
you're
right,
there
is
still
a
long
long
list
of
stuff.
It's
not
actually
is
not
that
big
I
actually
saw
the
list
right
before
I
came
here.
It
was
it
was.
It
was
pared
down
pretty
well
so,
but
the
plan
is
to
hopefully,
hopefully
have
full
left
sharp
support
by
the
summer.