►
From YouTube: OpenShift Commons Briefing #66: Microservices, .NET Core 1.1, and Kubernetes on OpenShift
Description
.NET Core 1.1 is now available (external version) and supported on both Red Hat Enterprise Linux and Red Hat OpenShift Container Platform. This second .NET Core release shows Red Hat’s continued commitment to opening up platform choices for enterprises seeking to use .NET in Linux environments, including container-centric operating systems. We’re also pleased to lead the way in the Linux world yet again with our support for .NET, as Red Hat Enterprise Linux is the only commercial Linux distribution to feature full, enterprise-grade support for .NET Core. In this session, we’ll discuss some of the new application development highlights in Microsoft’s .NET Core 1.1:
• Over 1,300 new APIs since .NET Core 1.0.
• .NET Core 1.1 docker images from Red Hat’s container registry.
• Safe side-by-side installation with .NET Core 1.0.
• Performance improvements
If your development team is using a microservices-based approach where some components are built with .NET and others with Java, you can build and deploy on your choice of Red Hat Enterprise Linux and Red Hat OpenShift Container Platform, please join us for this briefing as we want to hear from you!
It’s been 5 short months since we launched the first commercially supported distribution of .NET Core on Linux. In that time, customer interest has continued to grow. Red Hat is an original member of the .NET Foundation Technical Steering Group, and as such we’re interested in your feedback to help us determine the future direction of .NET
Speakers: Todd Mancini, Senior Principal Product Manager and Don Schenck, Developer Advocate for .NET on Linux (Red Hat)
A
A
Well,
hello,
again:
everyone
welcome
again
to
another
OpenShift
Commons
briefing
really
pleased
to
be
redoing
this
demo
with
don
shank.
We
tried
this
once
before,
and
the
demo
gods
were
not
with
us.
So
this
is
a
redo
talking
about
net
core
micro
services
and
running
all
that
good
stuff
on
open
ship,
I'm
gonna.
Let
Don
take
it
away.
The
way
we
do
these
is
on
you
can
ask
questions
in
the
chat.
If
it's
something
door,
stopping
show-stopping
rather
will
interrupt
him,
but
otherwise
you're
gonna.
Let
him
flow
through
his
demo.
A
In
this
presentation
we
have
Q&A
at
the
end,
but
you're
welcome
to
ask
questions.
You
can
chat,
there's
a
number
of
us
who
might
be
able
to
answer
and
then
blonde
and
breakfast
at
the
end
we
plead
misspoke,
so
any
rates
go
ahead,
dawn.
Take
it
away.
Let's
see
if
the
demo
gods
had
been
appeased.
I
was
praying
great.
B
Thank
you
so
somewhat
wise
person
or
crazy
person
once
said
when
you're
handed
lemons
make
lemonade.
So
that's
what
I
did
since
the
last
attempt
at
this,
the
goodness
that
came
out
of
it,
was
now
the
source
code
for
this
demo
is
not
only
in
a
repository.
If
you
see
there,
there
are
two
branches,
there's
master,
which
is
the
current
version,
of.net
tooling,
and
then
there's
version
one
tooling.
So
if
you
go
and
install
dotnet
core
through
the
proper
channels
of
Red
Hat,
you
will
be
using
the
version.
B
1
tooling
I'm,
going
ahead
because
of
reasons
I
have
to
to
the
to
the
newer
version.
The
source
code
is
the
same.
The
only
difference
is
the
way
it's
built,
so
nothing
breaks
that
way
and
when
you
go
from
version
one
to
one
point,
one
its
dotnet
migrate
and
you're
done,
but
I
just
want
to
show
you
now
that
we
do
have
two
versions
of
this,
and
this
will.
This
will
continue
this
versioning
on
the
github
repo.
B
So
here's
the
description
but
you've
seen
this
we're
talking
about
a
transition
in
the
software
industry
and,
as
you
see,
moving
from
left
to
right
top
to
bottom
from
waterfall
to
DevOps,
from
monolith
to
micro
services
from
physical
servers,
which
we
all
I'm
sure
remember
to
virtual
servers
and
containers
and
then,
of
course,
the
cloud
we
where
we
are
all
different
parts
of
this
grid.
If
you
will
the
ideal
being
at
the
bottom
and
staying
at
the
bottom,
which
is
at
the
top
of
our
game,
the
play
on
words
there.
B
So
let's
talk
about
some
of
the
technologies
in
play
in
this
demo.
Linux
containers,
kubernetes
OpenShift.
This
is
the
buzzword
slide
if
you
will
zero
downtime
deployments,
including
blue,
green
and
canary,
and
then
the
circuit
breaker
pattern,
which
is
of
great
value
not
just
for
micro
services.
But
this
is
something
you
can
use
today.
B
Some
of
the
issues
that
we're
dealing
with
and
when
addressed
deploying
software
just
takes
too
long.
It
can
take
hours
weeks
months
to
roll
out
new
versions.
I
recently
gave
this
demo
and
I
said
it
can
take
several
months
and
most
of
the
room
not
at
their
head
and
approval
so
I.
We
all
know
that
software
is
too
complex.
This
is
an
arguable
point
in
that
micro
services
can
reduce
that
complexity.
B
B
Of
course
we're
spoiled
can
be
minutes,
but
when
you
need
to
scale
you
need
to
scale
now.
So
what
we're
gonna
do
today,
we're
gonna.
Do
the
the
evolution
of
running
on
my
PC
and
then
running
in
a
Linux
container,
which
is
a
lot
of
people
I
think
want
to
stop
there,
but
we're
gonna
go
on
and
there's
an
important
reason
why
to
run
an
open
shift,
which
is
a
platform
as
a
service
and
there's
this
there's
a
couple
of
huge
benefits
here:
huge
benefits
that
should
not
be
understated
there,
I'm
gonna
do
some.
B
Then
we
will
do
some
zero
downtime
deployments
using
open
shift,
and
that
is
something
that
can
benefit
you
immediately
and
then
the
circuit
breaker
pattern,
which
again
there
is
something
you
can
use
now
and
that
circuit
breaker
is
just
one
part
of
micro-services
distributed
processing.
If
you
will
it's
just
something:
I
want
to
bring
up
to
show
you
that
hey.
There
are
some
changes.
B
The
first
thing
I
need
to
do
is
log
in
and
shift
dev
account.
It
comes
built
in
with
open
shift,
so
everything
we
do
here
today
you
can
download
the
Red
Hat
development
suite
and
get
started,
and
do
it
immediately.
The
direct
the
repo
has
instructions.
I
mean
this
is
something
you
can
replicate
later
today.
If
you
want
to
logged
in
to
a
new
project
and
I'm
gonna
call
it
my
dotnet,
it's
what's
cool
to
me.
B
Is
it
dotnet
or
as
I'm
doing
all
these
things
in
Linux
and
open
shift
and
kubernetes
and
docker
and
I
am
in
my
comfort
zone
of
C
sharp
and
F
sharp,
so
I'm?
Not
it
just
take
it
never
stops
blowing
my
mind
the
fact
that
I'm
doing
everything
in
dotnet
so
I'm
in
my
directory
from
my
repo
I
have
code
here,
and
the
first
thing
I
want
to
do
is
just
dotnet
run
and
just
to
run
the
code.
You
know
this
is,
would
be
the
evolution
right.
B
It
runs
on
my
PC,
which
is
typically
isn't
that,
where
Friday
at
4:30
isn't
that
when
you
deploy
hit
sorry,
so
if
I
go
over
to
my
browser
and
look
at
port
5,000,
which
is
where
this
is
running
and
the
IP
address
is
the
IP
address
of
my
virtual
machine
by
the
way
I'm
running
this?
This
is
a
Linux
VM
running
in
Windows
on
a
Mac.
So
we
basically
done
everything
we
can
to
break
this
or
show
you
that
it
all
works
together
and
it
does
in
fact
work
together.
B
B
B
In
other
words,
that
you
want
to
put
it
behind
a
patchy
or
nginx
Microsoft,
I've
read
and
heard
them
say
that
they
are
working
on
improving
that,
but
for
now
you'll
just
run
it
behind
again
Apache
or
nginx,
and
it
works
great,
but
it's
command
line.
So
there's
a
shift
right
there.
Ok!
So
that's
so
that's
working!
So
the
next
thing
when
you
do
is
when
you
do
a
build
and
we're
gonna
call
it
well
go
dotnet,
hello,.
B
So
we're
gonna
do
a
docker,
build
if
you're
not
familiar
with
docker
and
how
it
works.
It's
a
think
of
it
as
a
real,
tiny,
VM
I,
don't
know
how
else
to
explain
that
without
going
in
a
lot
of
detail,
but
it's
a
it's
an
image
that
is
a
small
and
compact
and
it
has
everything
it
needs
the
operating
system
all
the
dependencies.
B
B
Because
when
you
go
to
how
many
people
now
in
the
enterprise
environment
could
go
to
a
server,
whether
it's
physical
or
virtual
and
say
I'm
gonna
replicate
this
exactly
a
hundred
percent,
that's
a
tough
one,
it
shouldn't
be,
but
it
just
it
is
it's
a
fact.
You
just
need
to
understand
that
so
I've
gone
ahead
and
created
it.
The
image,
if
I,
do
a
list
of
images,
you'll
see
it
right
up
here
at
the
top.
So
there's
the
docker
image,
it's
287
megabytes.
B
C
B
It
a
name
because
if
you
don't
it
did
kind
of
funny,
it
assigns
a
name,
and
it's
one
of
these
things
where
it
it's
a
adjective
underscore
person
like
silly
Einstein
or
something
like
that.
So
now
it's
running
you
saw
how
quickly
that
started.
I
mean
just
like
that.
You
have
this
program
running
and
it's
running
in
docker
and
if
I
do
a
docker
PS
to
show
a
processees,
I
should
see
it
up
at
the
top
there.
B
It
is
it's
been
up
for
14
seconds,
another
neat
thing
I:
if
I
do
docker
logs
and
then
the
dotnet
hello
and
you
can
tab,
complete
I
can
see
the
logs.
So
if
we
ran
out
the
command
line,
you
said
you
know
ctrl
C
to
shut
down.
Now
you
just
saw
the
logs
that
verify
it's
doing
the
same
thing
inside
of
docker.
So
now
I
go
over
here
to
my
website.
When
I
refresh
this
I
should
get
the
same
thing
except
for
this.
Let's
see
what
happens
refresh
it
and
there
it
is
2-0
B
211.
B
B
How
do
I
deploy
this
and
and
update
it
and
that's
where
OpenShift
really
shines
and
kubernetes
working
together?
So
the
first
thing
I
want
to
do
is
I'm
gonna?
Stop
this.
I
know
the
name,
so
I
can
just
stop
it
and
I'm
gonna
remove
it.
Just
for
reasons
of
clogging
up,
you
know
taking
space
so
now,
I'm
at
a
command
line
and
I'm
ready
to
go
and
show
you
the
power
of
open
shift.
B
B
Let
me
just
show
you
what
it
does.
So,
if
I
do
a
watch,
the
open
shift
you'll
see
that
it
just
it
basically
does
a
curl
command
in
PowerShell
and
then
sleeps
for
a
second.
So
if
I,
if
I,
let
me
fire
that
up
and
I
should
see
service
not
available
cuz.
It's
not
that's
a
bit
of
a
problem
right.
What
you're
seeing
right
there,
because
every
time
it
does
that
it's
hitting
the
server
of
course
now
it's
not
a
problem
cuz
then
you
know
it's
just
one
of
them,
but
what?
B
If
I
was
trying
to
spin
this
up?
And
there
was
tens
of
thousands
or
hundreds
or
millions
of
people
hitting
it
think
what
that
would
do
to
my
server
we'll
talk
about
how
to
get
around
that
a
little
later
and
it's
a
really
neat
feature.
So
we
go
back
to
the
command
line
and
I
have
a
bunch
of
scripts.
So
the
first
thing
I'm
going
to
do
is
run,
create
green
one.
B
That's
going
to
create
a
build
and
put
it
into
OpenShift,
and
what
I'm
doing
here
at
this
point
is
I'm
going
down
here
to
show
you
what's
called
the
blue
green
deployment.
Sorry
about
that.
So
basically,
a
blue
green
deployment.
It
and
it's
not
a
be
testing
blue
green
deployment
says-
and
it's
just
two
colors
arbitrarily
picked
by
someone.
B
If
I'm
running
on
green
and
I
want
to
switch
immediately
to
blue
or
if
I'm
running
on
blue
I'm
gonna
switch
immediately
to
green,
that
is
to
say,
you
might
have
version
1
running
and
you
want
the
option
to
immediately
go
to
version.
2,
no
downtime
and
then
say
something
happens.
You've
tested,
you've
done
everything
right,
but
somehow
something
falls
through
the
cracks
and
version.
B
2
isn't
working
right,
you
can
immediately
go
back
to
version
1,
that's
the
beauty
of
the
Bluegreen
deployment
and
it's
it's
an
all-or-nothing
switch
which
is
important
to
know
because
a
little
later
we'll
talk
about
a
partial
switch,
but
this
is
the
this
is
the
this.
Is
the
beauty
of
kubernetes
and
openshift
and
containers
all
working
together
so
on
my
command
line?
I'm
gonna
go
ahead
and
run
this,
and
when
I
go
over
to
here,
you're
gonna
start
to
see
some
goodness
if
I
can
get
this
to
stay
in
the
background
get
my
screen
right.
B
Let
me
go
over
here
and
show
you
what
the
what
the
grip
looks
like
it's
only
four
lines
of
code
as
you
can
see,
so
what
it
does
it
actually
three.
It
creates
a
build
in
OpenShift,
which
is
it's
a
built.
Configuration
basically
says
this
is
what
we're
going
to
do
and
in
our
case
it's
a
binary,
build
that's
important
to
know,
because
you
can
also
build
some
source.
You
could
have
a
merged
pull
request
on
github
fire
off
a
build.
That's
nice!
B
B
Now
there
is
an
issue
here
is
that
we
cannot
get
to
it
so
I
have
to
create
a
route,
a
URI,
if
you
will
so
I'm
going
to
in
the
parlance
of
open,
shipped,
expose
the
service
I'm
going
to
assign
the
hostname
you
don't
have
to
but
I'm
going
to,
because
I
want
to
show
the
flexibility
that
you
can
do
this.
You
don't
have
to
go
with
the
what
it
assigns
and
I'm
gonna
sign
it
to
the
service
dot
hello
before
I
mash
enter
here
appear
in
this
corner.
B
If
you
can
see
my
cursor,
which
says
create
route,
it's
replaced
with
your
that
quickly
and
if
I
click
on
that
boom.
So
now
I
have
version
1
of
my
application
running
in
OpenShift
now
I'm,
where
I
want
to
be
you
see,
the
name
of
the
host
is
reflected
in
dotnet,
hello,
121,
F,
and
over
here
my
power
show
application.
It
springs
to
life.
It
sees
my
application
now
running
an
open
shift,
one
of
the
benefits
you
have
of
openshift
and
kubernetes
together
right
now.
It's
what's
called
service
discovery,
and
that
is
I.
B
Don't
need
to
know.
Ip
addresses
I,
don't
have
to
write
some
kind
of
script
to
go
and
find
it
or
assign
them
or
what-have-you.
I
can
write
my
code
to
look
for
the
URI.
Remember
the
host
name,
I
assigned
well,
that's
in
my
PowerShell
script.
So
on
when
that
comes
available.
It
everything
comes
to
life.
It's
discovered
I!
Don't
to
do
all
these
crazy
things
to
find
it.
That's
not
a
small
thing.
B
It
really
is
not
now
that
that's
running
I
can
go
over
to
to
openshift
and
I
can
say,
give
me
two
of
them
and
if
you
watch
in
the
background
well,
let
me
go
here,
see
boom.
It's
done
now.
I
have
to
and
see
the
different
names,
the
v47
and
the
21f.
So
now
we're
talking
about
scaling
now,
I
have
to
now.
My
traffic
goes
up.
I
have
three
thousand
one.
One
thousand
two
one
thousand
three
one
thousand
four
and
four
seconds:
I
have
three
of
them
running,
and
this
is
on
a
laptop.
B
This
isn't
even
a
server,
so,
as
you
can
see
now
we
start
getting
into
oh.
This
is
great
what
if
you
could
do
this
with
a
legacy
application?
You
can
we'll
talk
about
that
later,
which
is
fantastic.
So
now
we
have
three
pods
I'll
scale
back
to
one
just
to
save
some
CPU
cycles,
and
it's
it's
my
my
green
application.
Remember
I
ran
create
green
I'm,
gonna
I'm
gonna
change
my
code
here
just
to
further
the
impact
I'm
gonna
go
from
green
and
the
go
to
blue.
B
It's
a
build
script
that
takes
the
net
code
and
publishes
it
into
a
directory
that
I
can
then
build
from
and
put
into
an
image
over
here.
Oh,
my
I
was
in
the
wrong.
It
doesn't
matter
so
there
I
have
it
built
so
now,
I
can
do
a.
Let
me
show
you:
I
had
create
green
first
now,
I
have
create
blue
and
that's
the
second
version.
B
If
you
will
so
when
I
hit
this,
it
should
go
ahead
and
take
the
bits
that
I
just
compiled,
which
you
remember,
I
change
it
to
version
two
and
should
go
over
here
and
replace
the
one
I
have
but
create
another
instance.
There
you
go
dotnet
blue
running
within
open
shift
and
then
I
switch.
Now,
if
you
see
in
the
background
PowerShell,
did
you
see
that
service
not
available
again?
What
is
that
all
about?
How
do
we
get
around
that?
That's!
That's!
B
Apparently,
that
builds
don't
always
replace
all
the
bits
unless
you
clear
out
the
the
cache
first,
that's
okay,
that
we
have
the
blue
running
and
the
reverie
one,
and
if
I
stand
the
green
one
and
if
I
switch
back
I
have
a
script
which
two
green
and
it
immediately
switches
the
green.
Let
me
restart
this
because
there
we
go
so
there's
the
green.
Sometimes
power
show
likes
to
get
hung
up
on
me
and
if
I
could
switch
to
blue
I
want
you
to
watch
the
power
show
screen
when
I
hit
enter
boom.
B
It's
an
immediate
change!
So
that's
how
you
would
go
the
blue,
green,
so
version
one!
It's
working!
Fine
I
switched
to
version
two
uh-oh
I
have
a
problem:
I
need
to
go
back
boom,
I
go
back!
So
that's
a
blue
green
and
this
scaling
here.
If
you
have
three
scaled
up
of
each,
it's
gonna
switch
from
three
to
three.
In
other
words,
you're,
not
gonna,
lose
your
scaling,
so
to
speak.
All
you're
doing
is
changing
basically
the
route
to
point
from
one
up
one
service
to
another.
B
So
that's
the
Bluegreen
deployment,
which
is
again
made
possible
by
the
use
of
kubernetes
and
openshift.
That's
something
that
if
you
were
just
using
docker,
that
would
be
how
you
would
even
do
it
without
writing
your
own.
Basically,
and
it's
also,
if
you're,
just
deploying
apps
the
old
way,
I,
don't
even
know
how
you
would
even
come
close
to
this,
particularly
the
speed
of
it.
B
So
now,
let's
talk
about
the
canary
deployment,
this
one's
pretty
neat,
because
it's
the
the
canary
in
the
coal
mine,
if
you've
ever
heard
that
phrase
where
you
take
a
canary
into
a
coal
mine
and
if
any
gas,
carbon
monoxide
or
natural
gas,
this
is
a
public
service
announcement.
Natural
gas
has
no
odor,
that's
why
they
add
it
right,
but
if
they
didn't
think
about
that,
how
it's
deadly
so
the
canary
deployment
says
we're
gonna,
take
the
next
diversion
and
we're
gonna
deploy
it
to
some
of
our
users.
B
We're
pretty
you
mean
we
tested
it.
We
know
it
works,
but
we
all
know
everything
always
works
right,
but
it
somehow
doesn't.
But
let's
say
it
does:
okay,
well
that
we
gave
it
to
25%
of
our
users.
Let's
go
to
50%
you
just
kind
of
slowly
roll
it
out
to
some
and
if
anything
goes
wrong
you
can
back
off
quickly
and
when
things
go
right,
you
can
move
forward
quickly
at
the
same
time,
never
losing
your
original
application.
So
again,
it's
like,
as
blue
green
was
boom
boom
boom.
B
Real,
quick
canary
is
also
the
speed
at
which
you
progress.
Is
your
call
so
to
speak.
You
know
if
you
want
to
run
25%
of
users
for
a
week
and
then
scale
it
up
to
half
or
all
whatever
it's
up
to
you,
but
the
beauty
again.
Is
it
supports
it?
So,
basically
you
have
development.
Here's
my
application
moving
through
development
right
and
everything
works
out
there.
That's
great,
of
course,
you
know
how
that
is.
It
runs
my
PC,
it's
ready!
Well,
it's
not!
So
we
go
to
QA.
B
B
Okay,
now
we
have
it
connected,
so
to
speak,
to
the
users
and
they're
hitting
it
some
of
them.
That's
working!
Well,
we're
gonna,
give
it
to
some
more
users.
We're
gonna,
give
it
some
more
users
everything's
working
real.
Well,
no,
no!
No,
we
better
back
off
or
no
no,
it's
going
well!
Okay!
We
go
out,
and
next
thing
you
know
everyone
has
access
to
it.
That's
the
that's
the
diagram
with
a
canary
deployment.
Let's
go
and
actually
do
it.
Shall
we
go
over
here
and
windows
I'm
going
to
watch
canary
and
over
here,
I'm
gonna.
B
Yeah
so
I'm
gonna
delete,
and
this
is
just
to
show
you
if
your
developer
right
and
you're
and
you're
developing
and
you're
using
this
one,
your
PC
there
comes
autonomy.
You
know
how
does
he
just
think
I
need
to
start
over
and
that's
boom
done
and
you
see
in
the
background.
Everything
is
just
gonna
go
away.
So
that's
that
that's
another
neat
thing
about
using
all
that
you
don't
have
to
like.
B
Oh
my
gosh
tear
down
all
this
stuff
or
repave
my
machine
or
anything
silly
I,
just
type
to
come
in
and
wiped
out
all
my
stuff.
Now
I
start
my
source
code.
I
stole
my
binary
stuff
on
my
machine.
Don't
get
me
wrong,
but
now
we're
ready
to
do
it
again.
So
we
see
a
new
project
and
I'll
just
call
my
not
in
it
again
to
keep
it
simple.
In
the
background.
If
I
go
here,
there's
my
dotnet
and
there's
nothing
in
it.
B
So
now
I'm
going
to
create
a
service,
it's
called
dot
debt
first
and
I.
Apologize
I
need
to
name
change
the
name
to
like
darn
that
canary
just
to
make
it
simpler,
more
understandable.
But
as
you
see
here,
I
have
canary
create
one
so
I'll
run
canary,
and
at
this
point
it's
fair
for
you
to
say
well,
yeah
done,
you
have
all
this
stuff.
You
know,
you
know
scripted,
that's
that's
all
well
and
good,
but
when
you
know
when
I'm
developing
stuff
I
don't
have
that
luxury
and
you
know
it
seemed
like
well,
it's
unfair.
B
You
scripted
everything
course
it
works.
But
that's
part
of
DevOps
is
that
we
do
that
right.
This
is
where
the
shift
we
want
to
make
from
just
typing
commands
of
you
know
and
then
another
command,
another
command,
another
command
to
just
running
a
script
and
to
think
about
it
once
you
have
scripts
written,
then
you
could
start
automating.
Those
and
things
can
be
kicked
off
by
like
checking
in
source
code
or
timers.
Or
what
have
you?
So
it's
not
cheating.
B
B
See
it
didn't
so
you
see
here
the
code,
it's
it's
uncommented!
You
saw
last
time
when
I
did
the
building.
So
here's
what
I'm
gonna
do
I'm
gonna,
remove
the
object,
library
directory
and
the
bin
directory
and
give
you
a
little
inside
baseball
here.
So
now
it's
a
little
net
restore
to
pour
everything
down
because
I
just
blew
it
all
away.
So
if
you're
not
into
dotnet,
this
is
this
is
a
and
NPM
has.
What
yarn
is
that
the
new
one?
This
is
your
basically
a
package
manager
I'm
pulling
down
so
I
restored.
B
Here's
the
building
by
the
way,
if
you
see
this
build
this
is
the
newest
version.
Of.Net
that
uses
the
Microsoft
build
engine.
The
previous
one
used
a
different
build
engine.
That
was
the
change
from
dotnet,
tooling
version
100
lat
to
version
1.1
again
the
underlying
source
codes
all
the
same,
and
unfortunately
we
went
from
JSON
to
XML,
but
oh
well,
so
there's
my
output
now
I
have
this
ready
to
go
and
I
can
do
the
canary
create
two,
and
what
that's
going
to
do
is
create.
B
It
should
be
version
two
of
this
application
and
start
it
up.
So
if
you
want
to
see
what
that
is
canary,
create
two,
what
happens
here?
Is
you
create
a
build
right
and
you
you
build
it,
but
then
you,
you
start
I,
don't
want
to
say
messing
around,
but
you
you
manipulate
the
the
application,
its
path
to
it
and
the
metadata,
and
you
use
that
to
your
advantage,
where
you
put
labels
in
that
you
can
identify.
You
know
that
you
assign
and
then
you
can
manipulate
the
route
and
things
like
that.
B
So
that's
what's
happening
again,
the
service
not
available
in
the
background.
What's
that
all
about,
we
need
to
address
that
we'll
come
up
with
a
great
way
to
address
that,
so
it's
got
everything
back
now.
It's
scaling
it
up
and
you're
gonna
see
in
the
background,
come
to
life
and
what
we
should
have
is
four
versions
on
the
top
four
pods.
If
you
will
the
first
one
and
one
of
the
second
and
when
once
that
goes
to
four
I'm
gonna
scale
it
back
to
three
immediately.
B
B
Who
gets
it
now,
it's
important
to
note
that
this
isn't
going
to
control
who
gets
it.
This
just
controls
the
scaling
but
think
about
it.
If
you're
25
percent
of
your
customers
are
hitting
your
website
and
you
want
to
give
it
to
50
percent
you're,
probably
gonna
adjust
your
scaling
accordingly
right
and
that
just
makes
sense.
B
So
I
will
scale
this
one
up
and
I'm
gonna
wait
for
it
to
come
up,
and
so
so
I
have
a
little
overlap
which
nobody's
gonna
complain
about
that
right
and
then
I'm
gonna
scale
that
one
down
now
I
should
have
a
50/50
mix
and,
as
you
see,
first
and
canary
so
now,
I
have
50/50,
and
it
just
goes
on
like
that.
You
know:
I
didn't
finish
them
so
to
speak.
B
If
I
scale
this
to
4
and
up
by
the
way
that
all
the
scaling
you
can
do
at
the
command
line
or
you
can
you
can
set
thresholds
and
triggers
to
do
it
automatically.
So
you
don't.
You
know,
you're
not
sitting
here
at
a
screen.
Doing
these
things
and
now
I'm
completely
the
canary
is
flying
through
the
coal
mine.
If
you
were
everything's
great,
so
that's
the
canary
deployment
made
possible
by
open
shipped
in
kubernetes
and
containers.
This
is
this
is
something
that
would
be
really
difficult,
otherwise.
B
So
here
it's
the
open,
you're,
not
even
reaching
the
server.
You
can't
reach
it
and
it
closed
when
the
server
is
working.
Now
the
fact
is
the
closed
one.
In
reality
the
server
could
be
working
but,
let's
say
really
slow.
So,
let's
think
about
that
scenario,
where
you're
hitting
a
server
that's
down
for
some
reason
or
not
down,
but
the
application
isn't
functioning
right
and
it's
very
slow.
Let's
say
it's
overloaded!
B
Well,
if,
if
all
your
clients
keep
hitting
it,
it
kind
of
defeats
the
purpose
right,
you're,
saying
you're
saying
this
thing
is
overloaded.
So,
let's
just
keep
hammering
until
we
get
what
we
want.
That's
not
really
gonna
work.
What
you
want
to
do
is
you
want
to
back
off
and
say:
hey,
let's
give
it
a
rest
here.
So
here's
a
little
state
transition
diagram
of
the
circuit
breaker
pattern.
So
it
sounds
counterintuitive
to
me
that
closed
and
open
but
closed
is
the
good
one
right
and
opens
the
not
great
one.
B
So
when
it's
closed
you're
reaching
the
server,
everything
is
hunky-dory,
everything's,
fine,
but
when
it's
closed
and
you
have
a
failure,
whether
it
can't
reach
the
server
or
it
times
out
and
these,
and
that
is
defined
by
you
in
code.
When
you
have
a
failure
the
circuit
goes
to
open,
then
it
stays
open
for
the
a
certain
amount
of
time
and
or
attempts
again.
These
are
all
configurable
by
you
and,
as
you
see
when
the
wait
time
is
reached,
we
go
to
half
open,
which
says
all
right.
B
We
think
we're
ready
to
try
now
we're
gonna
make
one
attempt
to
reach
the
server
and
if
we
have
success,
we're
like
okay,
everything's,
fine,
we're
good,
but
if
you
don't
have
success,
it
fails
and
you
go
back
to
the
open
state
until
again,
your
wait
time
and
in
this
demo
I
think
I
have
four
attempts
for
the
failure
and
eight
seconds
for
the
wait
time.
That's
not
that's
that
the
numbers
aren't
important.
The
concept
is
and
everything
in
the
orange
box.
B
You
are
not
even
attempting
to
reach
the
server
you're,
not
even
tempting,
which
is
great,
because
now
the
server
gets
a
rest,
no
pun
intended
and
what
you
can
do
in
a
client-side.
Is
you
can
say?
Okay
if
the
circuit
is
open
and
I'm
not
reaching
the
server,
I
can
have
some
kind
of
fallback
position,
a
default
value,
a
default
action
that
I
take.
So
it
allows
you
to
graciously
handle
failures
and
the
reason
this
is
important,
because
you
can
do
this
today
in
your
existing
applications.
B
You
don't
need
to
be
using
containers
if
you
have
a
website
or
a
mobile,
app
or
whatever
that
button
that
reaches
the
server
and
a
service,
and
you
have
this
problem
can
present
itself.
You
can
implement
this
now.
You
don't
have
to
wait.
This
is
a
best
practice
in
distributed
services.
Think
about
it.
If
you
have
200
micro
services
and
they're
all
talking
to
each
other.
The
last
thing
you
want
is
109
999
them
of
them
flying
and
the
one
holding
them
all
up.
That's
what
you
want
to
avoid!
B
That's
what
this
is
really
all
about,
so
I
have
a
cool
little
application
called
howdy
and
whatever
you
don't
know,
if
you've
noticed,
but
I
have
howdy
and
Bonjour
and
Aloha.
So
what
howdy
does
is?
It
runs
a
little
a
little
website
that
just
returns
web
service.
It
returns
howdy
and
then
I
put
some
switches
in
it
to
slow
it
down
and
to
speed
it
back
up
to
mimic
an
overloaded
server
and
then
to
show
how
the
circuit
breaker
pattern
works.
B
If
I
go
into
program,
dot,
CS
there's
a
lot
there
and
I'll
scroll
back
through
it
or
over
here
we're
okay,
we're
still
building.
So
this
is
the
console
app.
It's
not
important
that
you
see
all
the
code
and
know
you
know
everything.
That's
doing
just
notice
that
there's
a
timeout
value
of
200
milliseconds
again,
you
would
configure
that
right.
B
In
fact,
in
12
factor
apps
that
would
probably
be
a
setting
that
would
come
from
an
environment
variable
that
would
be
a
best
practice.
You
have
four
seconds
before
attempts,
rather
before
it
breaks
and
it
stays
open
for
eight
seconds
and
then
here's
if
you
know
if
it's
breaking
for
the
circuit,
if
it's,
if
it's
logging,
okay,
if
it's
half
open,
you
can
see
some
of
that
in
the
code
all
these
policies
are
set
and
here's
where
it's
calling
the
it's
calling
Aloha
I
remember
earlier
when
I
mentioned
discovery.
B
This
is
a
perfect
example
of
where
you
would
benefit
from
that.
I
have
to
hard
code.
This
granted
I
could
do
it
from
an
environment
variable
but
I'm
using
an
IP
address
and
a
port.
That's
you
don't
want
to
do
that.
You
want
to
have
you
know
your
I
right
here.
That's
where
again,
the
openshift
I'm
not
running
this
an
open
ship,
but
if
I
was
I,
could
just
put
that
here
and
I
would
never
have
to
worry
about.
B
B
B
My
fingers
so
now
it's
running
in
docker
and
I
should
be
able
to
go
over
here
and
that's.
This
is
vestigial
from
before.
If
I
type
greeting
I
should
get
howdy
hey
there,
you
go
so
now
I.
Have
it
there's
a
really
interesting
dynamic
that
goes
on
here,
just
out
of
programmer
curiosity,
when
I
go
here
and
start
to
type
because
Chrome
it
does
that
forward,
fetching
to
improve
performance
so
as
I
start
to
type
it
uses
my
history
to
know
what
I'm
going
to
type
and
forward
fetches.
B
B
B
B
The
application
is
running
I
do
know
why
it's
feeling
what
I
did
the
mistake
that
I
made-
and
this
is
important-
is
I'm,
running
howdy
in
docker
and
I.
Don't
want
to
do
that
because
that
remember
I
had
the
IP
address
of
10.1
2.2
in
my
code.
That's
not
the
IP
address
of
my
docker
container.
Is
it
no?
It's
not
of
a
docker
stop
howdy.
B
B
B
Okay,
so
here
you
can
see
what's
happening,
it's
getting
the
request,
howdy
and
that's
great.
So
now,
if
I
take
that
and
and
slow
it
down
in
the
background,
you'll
see
what'll
happen.
Now
it's
failing
and
it
fails
it
times
out
and
then
it
goes
into
the
circuit
breaker
and
that's
where
it's
not
even
hitting
the
server
now
I'm
going
to
purposely
speed
it
back
up,
but
I'm
going
to
do
it
right
after
it
shuts
down
its
gonna.
Do
it
you're
gonna,
see
it
go
to
half
there,
it
is,
and
now
normal,
no.
B
B
B
B
So,
finally,
the
circuit
breaker
closes.
This
is
actually
a
great
demo
of
it,
because
this
whole
time
it's
not
been
hitting
the
server.
Now,
when
that
comes
back
up,
I
should
start
seeing
me
Howdy's
there.
It
is
there's
that
well
make
a
liar
out
of
me
and
that's
the
unless
the
slowdown
file
was
still
there.
B
B
Go
back
to
normal
speed
there
we
go
well
that
was
odd
there
and
back
to
howdy
I'll
go
figure,
so
the
idea
is
the
circuit.
Breaker
keeps
the
client
from
hammering
the
server
now
there
was
one
other
thing
that
I
wanted
to
show
you
that's
not
in
this
slides
is,
if
you
take
a
regular
application
and
run
it
regular,
not
a
microcircuits,
just
say
like
a
website
and
run
it
in
an
open,
shifter
docker.
B
So
the
point
I'm
going
to
show
you
here
is
that
you
can
take
an
existing
website.
It
just
put
it
in
darker
now
this
one
I
mean
there's.
There
are
some
things
to
consider.
This
one
uses
a
sequel
light
database,
that's
in
the
directory,
but
which
is
a
terrible
practice
right,
because
in
the
container
you
delete
the
container
you
lose
the
database.
You
would
typically
be
using
a
connection
string
to
a
database
outside
you
know
outside
the
container,
or
you
would
use
a
persistent
volume
to
make
sure
that
you
don't
lose
the
data.
B
So
there's
a
docker,
build
and
I,
and
if
I
did
this
right,
gonna
sound
funny.
If
I
did
this
right,
when
I
run
it,
it
won't
work
and
you're
good
like
what's
he
talking
about
well
docker,
run
and
I
hope
I
did
this
right,
so
it
crashes
and
now
figures
I.
Did
it
right?
The
point
I
was
trying
to
show
you
was
that
if
I
tried
to
run
it
on
port
5000
and
something
was
already
there,
it
would
crash
and
again
that
was
just
to
underscore
the
idea
that
kubernetes
and.
B
Openshift
worked
together
to
manage
those
things
when
you
run
applications
in
docker.
Yes,
you
have
to
assign
a
port
right
port
80
whatever.
If
you
try
to
run
two
of
them
in
dr
in
the
same
port,
it
won't
work,
did
they
crash,
they
collide.
But
if
you
use
kubernetes,
which
openshift
you
know
uses
as
its
tool,
it
manages
that
for
you,
so
you
can
have
multiple
applications
on
the
same
port.
I
was
hoping
to
show
you
it
fail.
B
That's
so
I
could
to
underscore,
but
it
succeeded
so
so
this
is
just
a
basic
MVC
website,
I
created
and
again
it
writes
to
a
sequel
like
database.
So
you
know
it's
just
a
throwaway,
but
the
point
of
this
is
I.
Just
took
an
application
that
you,
maybe
you
have
a
website
and
just
threw
it
in
the
docker
I
would
I
would
throw
it
and
the
OpenShift
be
able
to
scale
it.
The
point
is,
even
if
you're
not
doing
micro
services,
you
still
have
this
capability
available
to
you.
So
that
is
everything.
B
B
There
are
some
websites
red
thumbs
down
that
that's
ours,
dotnet
is
where
you
go
for
everything:
dotnet
live
dot.
Asp.Net
is
there's
a
weekly
stand
up
for
dotnet
with
Scott
Hanselman,
John,
Galloway
and
Damien
Edwards.
It's
it's
absolutely
a
must
watch
if
you're
going
to
do
anything
with
dotnet
and
core
and
then
the
poly
project
is
the
the
circuit.
B
Breaker
I
showed
you
that's
the
the
dotnet
version,
it's
a
very
mature
and
robust
project,
and
it's
ongoing
I
really
recommend
that
one
and
then
I'm
available
again
on
Twitter
or
email
and
I
encourage
you
to
get
your
own
zero
cost.
Red
Hat,
Enterprise,
Linux,
and/or
development
suite
at
this
URL
and
grab
the
github
repo
for
this
presentation,
and
that's
it
for
me.
Do
we
have
questions
yeah.
A
C
Hey
dawn,
what
is
the
ideal
style
of
dotnet
application
to
bring
from
the
old
world
to
this
new
world?
You
know
what
would
you
say
some
of
the
limitations
are
and
done
that
core
versus
done
that
framework
and
what
kind
of
apps
are
good
to
migrate
over
or
perhaps
good
old,
dotnet
apps
good
for
this
right.
B
That's
a
great
question:
if
you
have
well,
if
you
have
a
restful
service,
that's
that's
the
right
album!
That's
the
one
to
do.
That's
like
the
best
one,
an
MVC
website
you
could
bring
over
there's
there's
a
lot
involved
in
this.
It's
not
a
migration.
It's
a
port
or
the
other
way
around
I
can't
remember
how
which
one
is,
but
it's
not
a
lift
and
shift.
There's
some
work
involved.
B
There's
some
minor
things
very
minor
things
necessary
which
can
or
I
think
they
can
all
be
automated
with
that
click.
The
cloud,
but
a
number
one
would
be
a
restful
service.
Two
would
be
like
an
MVC
website
if
you
have
a
soap.
Oh
my
gosh,
a
web
service,
then
you're
gonna,
have
to
run
either
run
mono
or
run
it
through
I,
don't
know
what
you'd
have
to
use:
mono
cuz,
there's
no
there's
no
windows,
communication
framework
and
dotnet
core
ya.
B
D
A
It's
and
a
lot
other
fun
things
you
can
do
so
we're
looking
forward
to
I
think
maybe
the
sets
that
you're
mentioning
about
Todd's
migration
tools
might
be
something
that's
a
feature
three
and
then
knowing
that
and
using
moving
stuff
across
on
would
be
interesting
at
least
three
and
to
see
and
I
hope
it
is.
If
you've
Spiker
is
one
of
our
PMS.
It's
on
the
call.
Is
there
anything
Steve
if
you
want
on
you,
your
self
you
can
add
in
here
is:
there's
lots
of
information
out
there.
A
D
Was
just
going
to
add
this
Steve
great
demonstration,
we
try
to
keep
up
with
all
the
net
core
upgrades
that
are
out
there
as
well,
and
so
we
showed
a
good
way
of
demonstrating
an
offline
in
the
localized
development
suite
or
a
container
development
kit.
We
also
provide
a
hosted
on
our
developer
preview
instance
of
OpenShift
online,
which
has
dotnet
core
1.1.
D
Anyway,
we
continue
to
try
to
you
know.
Keep
pace
has
died.
The.Net
core
updates
occur,
which
kind
of
keep
closing
the
gap
between
dotnet.
I
don't
know
what
you
call
legacy,
but
prior
to
tonight,
core
keep
adding
more
features.
We
usually
have
almost
zero
wait
time
from
the
time
it's
released
the
time
it's
actually
available
from
Red
Hat
on
our
platform,
so
straight
away
to
experience
it
to
ya.
B
Next
week,
the
seventh-
what
is
that
Tuesday
Microsoft
is,
is
dropping
Visual,
Studio,
2007
and
the
official
I
believe
it's
the
official
tolling
1.1
comes
out,
then
I
think
I
may
be
mistaken,
but
it
related
that
I
wrote
a
blog
post.
I
think
it
was
just
last
week
about
the
the
versions
in
dotnet
and
some
of
the
confusion
that
could
be
around
it.
It's
a
short
blog
post,
it's
real
simple,
but
it's
one
of
those
things.
If
you
don't
know
it,
it
gets
really
confusing.
B
I
mean
I've,
heard
Scott
Hanselman
like
how
come
if
I
type
this
I
get
this
and
if
I
type
you
know,
dotnet
I
get
this
I
type
net
version.
I
get
this
so
I
talked
to
the
guys
at
Microsoft
and
said.
Let
me
codify
this
and
put
it
in
writing.
So
people
understand.
So
if
there
is
some
confusion
about
versioning
go
ahead
and
just
find
that
blog
post
it
Red
Hat
loves
dotnet
and
you'll,
you
understand
it.
Then
that
makes
sense.
So.
A
We
can
cross
post
this
on
in
both
places
so
that
you
can
find
it
something
you
will
put
this
video
up
there
and
now
I'll
find
all
those
blog
posts
and
add
it
through
the
video
when
it
gets
posted
and
we'll
have
you
back
again
soon.
You
know
it
sounds
like
there's
more
I
know
we're
going
to
ask
want
Charlotte
Elliott
to
come
on
and
do
some
dotnet
got
the
asp.net
demos
as
well,
showing
lots
of
modifications,
she's
a
new
developer,
evangelist
with
the
open
ship
game
and
comes
from
the
gaming
industry.
A
So
on
curious
to
see
what
our
demos
look
like:
they've,
probably
a
lot
cooler
than
mine,
even
your
little
speaker
thing
so,
and
a
little
bit
more
complex.
So
this
has
been
really
good.
I'm,
really
pleased
that
the
demo
gods
were
with
us
today,
dawn
and
if
you
have
anything,
if
anyone
else
is
on
the
call
and
is
listening
to
this
there's
any
other
aspect
of
dotnet
or
running
Microsoft
stuff,
just
reach
out
to
me.
A
Let
me
know
you
can
find
me
at
openshift
common
on
twitter
or
at
python
DJ,
which
is
my
rant
and
rave
channel,
and
also,
if
you're,
not
on
the
OpenShift
commons
mailing
list.
Yet
drop
me
a
note
d
Mueller
at
Red
Hat
com,
that's
the
mue
ller
at
Red,
Hat
calm,
then
you'll
get
added
to
our
mailing
list.
So
you'll
get
announcements
of
all
of
these
briefings
about
coming.
D
A
Also,
a
lot
of
us
will
be
in
Berlin
on
March,
28th
or
29th
and
30th
for
coop
con
and
I'm
hosting
a
one-day
open
ship
gathering
at
the
same
location
on
the
day
before
coupon.
So,
if
you'd
like
to
join
us
for
that,
we'll
have
a
meet-up
of
all
the
dotnet
Microsoft
II
folks
will
have
their
own
lunch
table
to
eat
together,
not.
D
A
A
So
you
know
we'll
let
you
mix
and
mingle
and
at
the
gathering
there'll
be
a
gathering
in
Berlin
in
March,
there'll
be
another
one,
the
day
before
summit
in
Boston
and
another
one
on
the
day
before
could
calm
in
Austin
the
Norfolk
North
American
one
in
December,
so
lots
of
opportunities
there
Sig
groups
at
the
other
ship
common.
So
please
do
take
a
peek
at
common
OpenShift
org
and
join
up
on
the
sig
that
you,
like
and
I'll.