►
Description
OpenShift Commons 9 Steps to Awesome with Kubernetes
Recorded 03-04-2020
Burr Sutter (Red Hat)
slides: https://blog.openshift.com/wp-content/uploads/9-Steps-to-Awesome-with-Kubernetes.pdf
Join commons and get on the mailing list here: https://commons.openshift.org#join
A
Well,
hello,
everybody
and
welcome
again:
do
the
open
shift
Commons
briefings.
This
is
a
series
in
which
we're
sort
of
starting
to
take
a
step
back
and
do
some
introductions
to
kubernetes
and
other
things
and
other
projects,
and
first
Sutter,
who
is
with
the
Red
Hat
developer
program,
whom
I'm
sure
a
lot
of
you
already
know
has
come
to
tell
us
nine
steps
to
awesome
with
kubernetes
I'll.
Let
burr
introduce
himself
and
take
it
away.
A
B
Fantastic,
so
the
opening
slide
here,
you
can
kind
of
see
that
I
have
a
github
link
that
it
will
be
where
the
written
materials
are
and
you'll
even
see.
Me
me
pull
from
those
materials
as
an
example,
so
that
is
approximately
a
three
plus
hour
workshop,
that
I
run
with
different
outlets,
and
so
that's
the
materials
for
that
three-hour
workshop
and
we're
gonna
cover
part
of
that
today
and
the
slide
deck
itself
is
a
bit
late.
B
Nine
steps
awesome,
that'll,
get
you
access
to
the
live,
Google,
Doc
and
that'll
be
sure
you
know
you
Louie
will
land
right
here
in
this
document
and
if
I
break
out
a
document
here,
you'll
see
like
already.
Nineteen
people
are
connected
to
my
document
live
and
then
you
can
basically
say
even
couple
of
times
save
make
a
copy
or
do
a
downloads
or
pptx.
Then
you
have
your
own
version
of
that
Sisson
example,
so
I
attend
to
open-source
everything
and
we've
definitely
made
no
exception
of
this
slide
deck.
B
Also,
okay,
so
a
little
bit
about
me,
I'm.
Currently,
the
the
global
director
of
developer
experience,
meaning
I
travel.
The
world
I
talk
to
people
all
over
the
planet
and
the
thing
I
love
talking
about
the
most,
though,
is
kubernetes
kubernetes
stok
native
Tecton.
Those
are
the
subjects:
I
tend
to
focus
on
low
cost,
a
little
strategy.
Things
like
that
today.
B
We're
gonna
focus
on
the
basics,
though
just
the
basic
kind
of
getting
started:
experience
for
the
person,
who's
new
to
the
crew,
vanadis
ecosystem,
that
and
I
only
because
I
think
that's
a
fun
place
to
start
and
everybody
kind
of
needs
to
know
the
basics
in
order
to
move
down
the
fancier
path
of
this
do
or
Kaz
pufta
is
an
example,
those
more
advanced
topics.
Okay,
now
one
thing:
we
notice
I'm
a
I'm,
a
developer
and
to
be
a
Java
developers.
B
I
know
some
of
you
on
the
on
this
presentation,
or
even
watches,
recording,
like
oh,
my
god,
yep
here
for
me
of
a
person
I
respect
that
you
might
even
see
some
Java
code
just
briefly
and
I.
Don't
want
even
to
be
offended
by
that.
Java
is
still
awesome
and
doing
incredibly
well
throughout
the
enterprise,
and
so
I
may
be
a
little
JavaScript
in
there
too.
To
make
looks
happy
a
little
diversity
if
you
will,
but
the
just
keep
that
in
mind.
B
I'm
gonna
come
with
this
from
a
developer
perspective,
so
remember
that
if
you
have
operational
concerns
and
deep
dives
and
all
that
I
tend
to
ignore
all
that
I,
don't
know
how
to
configure
the
storage
and
all
the
best
ways
to
make
sure
that
you
know
it's.
It's
well
maintainable
and
incredibly
scalable
as
an
example
and
tend
to
focus
on
a
developer,
needs
to
know
to
use
kubernetes
successfully.
Okay,
so
we're
gonna
dive.
Right
into
this.
We
have
a
lot
of
learning
resources
with
my
team
here
at
Red
Hat.
B
If
you're
interested
in
the
kubernetes
tutorial
the
intro,
that's
the
first
two
links
there
as
a
high
level
right
and
then
you're
going
to
get
into
the
is
tio
stuff,
then
the
service
stuff,
but
can
native
and
the
Tecton
stuff,
actually
just
moved
out
to
its
own
tutorial.
Don't
be
a
new
link
here
on
my
deck
and
that's
another
good
thing
is:
if
you
have
access
to
the
live
deck,
you'll
see
it
as
I.
Make
changes
to
it.
I'm
not
gonna,
run
a
these
advanced
demos.
B
Today
the
blue-green
Canary
deployment
with
Sto,
which
also
includes
tech,
con
pipelines
by
side,
which
is
a
native,
auto
scaling
demo.
They
there's
a
que
made
of
Kafka
demo,
that
does
you
know,
hide
scaling
based
on
Kafka
load.
Things
like
that.
There's
also
my
hybrid
cloud
demo,
where
we
bounce
transactions
from
Amazon
to
Azure
and
Google,
not
gonna,
do
even
that
fancy
demos
today
we're
gonna
really
focus
on
just
the
basics,
but
you
have
access
to
these
links
in
case
you
need
them.
B
Your
future
reference
and
there's
plenty
of
videos
at
YouTube
and
whatnot
has
shown
me
doing
these
various
presentations
covering
those
different
demonstrations.
I
also
do
a
have
a
video
form
of
this
thing
right.
So
we're
kind
of
doing
a
live
session
today,
but
I
have
a
video
form
that
you
can
kind
of
watch
it
like
six,
seven
hours
of
all
this
stuff
as
well.
If
you
want
to
and
that's
over
on
the
rally
platform
and
then
I
tend
to
run
these
classes
with
O'reilly
every
couple
months,
sometimes
I
run
them
every
month.
B
Sometimes
I
skip
a
month,
but
you
can
kind
of
see
the
nine
steps
awesome,
which
is
our
basics
classes,
what
we'll
be
covering
in
a
short
form
today.
Okay,
now,
if
you
were
doing
this
hands-on,
we
won't
have
time
today
you
would
basically
have
to
hit
that
first
link
the
second
leak
and
kind
of
figure
out
how
to
get
started.
The
instructions
primarily
were
originally
based
on
mini
shift.
I
have
since
been
migrating
them
to
mini
cube
over
time,
as
mini
shift
has
kind
of
fallen
off
the
kubernetes
curve.
B
If
you
will
it's
on
an
older
version
of
kubernetes
and
I'm
trying
to
keep
up
closer
to,
let's
say
115
116
level
now
today,
I
think
I'll
just
use
114
mystic,
but
it
doesn't.
You
know
it
doesn't
really
matter
so
much
from
the
experience
we
need
as
a
developer.
There's
a
couple
other
things
that
you
might
have
be
impacted
with,
based
on
your
hypervisor
right,
so
the
virtualization
technology
you
have
on
your
laptop
can
greatly
impact
your
build
to
use.
B
A
mini
cube
remains
shift
and
I
know
that
many
people
fail
with
using
mini
cube
leadership
on
their
Mac
on
their
Windows
machine
on
their
Linux
machine,
based
on
the
fact
that
their
hypervisor
simply
just
isn't
configured
correctly.
So
there's
some
tips
there
for
that.
Just
to
help
you
out
all
right
now
this
is
one
slide.
B
I
tend
to
use
it
a
lot
of
my
presentations
if
you've
watched
this
before
for
me,
I
recognize
your
PI
board
of
it,
but
I'd
love,
it
that's
fun,
but
it
helps
gives
us
context,
and
that
is,
if
you're
working
your
way
to
being
awesome
when
any
new
technology
don't
look
at
the
technology
as
a
silver
bullet.
Don't
look
at
the
technology!
Guess,
oh,
it's
going
to
cure
all
kind
of
thing.
You
know
feed
the
hungry
clothe.
B
The
naked,
really
a
technology
is
just
a
tool
and
one
of
the
tools
you
might
use
to
be
more
awesome.
So
your
journey
to
awesome
is,
though,
it
really
starts
with
DevOps
and
the
principles
of
DevOps
and
a
cultural
change,
and
the
rethinking
of
the
way
you
organize
work
in
your
organization
will
really
have
a
greater
impact
on
your
journey
to
awesomeness
more
than
anything
else,
and
that's
not
really
our
focus
today,
we're
not
gonna
focus
on
DevOps
per
se.
B
We're
gonna
focus
on
a
better
tools
which,
in
this
case,
is
called
kubernetes
all
right
now
self-service
and
on-demand
elastic
infrastructure.
That's
a
key
one!
So
if
you
actually
are
weighting
filing
a
ticket
waiting
two
weeks
to
get
a
resource,
then
you
have
a
problem
in
your
organization
right.
You
know
if
you're
waiting,
two
weeks
to
get
a
virtual
machine
configured
correctly
and
then,
of
course,
it's
not
configured
correctly
when
you
receive
it
well.
Well,
that's
the
typical
life
cycle.
We
see
in
many
many
enterprises
right
file.
A
ticket
wait
a
week
get
the
resource.
B
B
We
have
a
quota
and
we
basically
just
launch
whatever
the
hell
we
want
launched
when
we
won
launched
it
as
an
example
all
right
automation,
no
more,
you
know,
feeding,
CDs
and
the
CD
trays
or
DVDs
and
a
DVD
trays,
no
more
SSH
into
a
node,
and
you
install
this
and
Yemen
stall
that
at
get
you
know,
install,
etc.
Basically,
you
need
to
have
some
fun
a
playbook
at
this
point
right
or
even
at
least
offensive
bash
shell
script.
I
hope
an
example.
B
I
see
ICD
deployment
pipeline,
another
aspect
of
being
on
your
your
journey
to
us
coast,
another
aspect
of
being
more
mature.
Can
you
automate
those
pipelines
as
an
example,
or
is
it
just
on
the
back
of
a
napkin?
Many
people
still
have
their
pipelines
on
a
whiteboard,
not
encode,
and
so
that's
the
problem
for
us
as
an
industry
deployment
techniques
like
Bluegreen
deployment,
Canary
deployment.
B
We
won't
really
get
a
chance
to
see
much
of
that
today
because
again,
it's
more
advanced,
but
it's
definitely
part
of
the
isseo
stuff
that
we
teach
and
things
of
that
nature
and
it's
definitely
a
powerful
aspect,
a
powerful
feature
that
you
take
advantage
of
to
build
out
your
next
generation
infrastructure,
your
next
generation
applications,
and
then
you
too
can
be
like
the
github
unicorn
I
love
the
Pink's
gnarly
unicorn,
with
the
rainbow
mane
right.
That's
the
github
unicorn.
B
By
the
way,
I'll
just
tell
you
our
still
at
phone
used
to
be
like
there's
503
symbol.
It
may
still
be
at
this
point,
but
I
know
everybody
wants
to
teleport
themselves
directly,
microservices,
that's
what
everyone
says:
they're
doing
we're
doing
micro
services,
but
I'm
telling
you
all
these
other
things
really
matter
and
in
our
world
we're
gonna
talk
about
the
day
is
where
kubernetes
openshift,
openshift
being
red-hats
distribution,
kubernetes
and
there's
many
flavors
of
openshift
out
there
in
the
world
right.
B
There's
open
shifts
like
and
we'll
talk
about,
some
of
those
which
OpenShift
like
the
main
one
you
get
for
production
purposes,
there's
one!
You
can
learn
your
laptop
for
development
purposes,
there's
okd
the
upstream
technology
that
you
can
basically
download
and
use
where
you
like,
write
lots
of
versions
of
that
out
there
and
available
to
you
and
this
other
symbol
you
have
on
my
chart
here
is
Sto,
which
is
a
technology.
It
helps
you
with
those
fancy
degree
deployments
of
Canary
deployments.
B
It's
an
example:
okay,
let's
kind
of
dive
into
this
all
right,
we're
gonna
live
in
this
new
school
world,
not
the
old
school
world.
Alright
new
school
says
we're.
Gonna
have
a
whole
big
bunch
of
services,
micro
services,
let's
call
them
and
we're
going
to
distribute
it
around.
A
network.
They're
gonna
make
multiple
entry
points.
We
have
to
think
about
our
API
s
or
API
gateway
or
API
management.
B
There's
gonna,
be
numerous
databases
involved
right,
there's
going
to
be
many,
many
teams
building
out
there
patient
and
having
their
own
individualized
deployment
pipeline
to
deploy
into
production
on
their
day
on
their
night
under
weekend
at
two
o'clock
on
Friday
at
nine
o'clock
on
Monday
right
all,
that
is
a
new-school
world.
If
you
live
in
the
old-school
world
right
one
deployment
every
six
months,
big
ol
team
deploy
every
six
months
and
we
deploy
every
six
months
like
clockwork
yeah.
You
can
do
that
with
your
old-school
viens.
You
don't
need
all
this
fancy
cue
ready
stuff.
B
For
that.
All
right.
Can
you
use
it
in
Kirby
Nettie's
totally,
but
you
know,
Truman
days
is
really
gonna.
Give
you
a
big
win
when
you
actually
start
living
in
this
new
fest
cycle
time
world,
where
you're
building
out
two
playing
micro-services
and
and
rockin
them
out
there.
Okay,
the
nine
steps
class
we
try
to
go
through
in
about
three
four
hours
normally
does
cover.
B
What
I
call
my
Quick
Start
that
covers
the
highest
levels
to
basically
so
you
can
see
how
what
it
means
to
build
an
application
and
get
your
application
running
on
a
kubernetes
cluster
where
that'd
be
any
kubernetes
cluster
or
an
open
chef
cluster.
It
doesn't
really
matter.
I'll
show
you
how
to
kind
of
get
started
from
that
perspective,
and
then
that
least
get
you
able
to
dive
deeper
and
just
kubernetes
world
and
into
the
open
chef
world
that
you,
you
might
be
trying
out
as
an
example.
B
Okay,
we'll
do
a
little
rolling
update,
we'll
do
a
little
live
and
ready,
because
those
are
so
critical
and
this
one
also
make
sure
you
understand
how
to
set
up
I
think
we
can
go
at
all
that
done
in
the
next
hour.
So,
okay,
but
the
introduction.
Here's
one
thing:
I
love
telling
people
about,
because
I
used
to
teach
docker
many
many
years
ago,
right
so
I
used
to
teach
people
about
the
Linux
container.
B
Docker
specifically
so
do
cke
are
bright,
was
what
we
used
way
back
in
the
day
and
then
this
is
the
magic
that
was
the
docker
solved.
That
really
blew
everyone's
mind
when
it
came
to
the
market
so
again
I'm
a
Java
person
right
so
in
a
job,
a
person
they
had
this
issue,
they
basically
had
to
figure
out
where
their
application
was
going
to
land
on
specific
server
hardware,
but
a
specific
operating
system.
B
On
that
server
hardware,
and
in
case
of
Java,
you
know,
as
Java
people
were
used
to
living
in
a
world
of
Solaris
and
AIX
and
Linux
and
Windows,
and
you
name
it
right.
Java
people
kind
of
surf
all
the
operating
systems
and
then,
of
course,
to
JVM
has
to
be
a
certain
version.
A
certain
configuration,
that's
critical,
their
application
server
really
mattered
to
us
right.
B
We
had
WebLogic
or
websphere
or
tomcat
or
JBoss
that
really
mattered
to
us
and
of
course
we
had
a
custom
configuration
set
on
top
of
that
and
on
that
stack
on
that
basis,
was
our
ear
of
war
or
Jar
our
application
code.
That
sat
on
top
of
that
stack,
but
here
was
the
problem.
This
stack
was
almost
impossible
to
maintain
it
basically
was
broken
everywhere
we
went.
We
actually
tried
to
document
the
stack
in
a
nice
email.
B
We
used
to
send
nice
emails
to
people
and
say
hey
here's,
what
my
code
needs
and
needs
this
version
of
that
and
this
version
of
that
in
this
configuration
in
that
configuration
and
four
people
got
super
fancy.
They're
like
they
took
the
email
and
it
made
a
wiki
page
out
of
it
right.
You
guys
remember
wiki
pages
when
we
stood
wiki
pages
well,
even
that
was
broken
because
the
documentation
was
always
out
of
sync
with
the
reality
of
the
codebase
right.
B
So
the
beautiful
thing
that
we
learned
in
the
world
of
docker
is
this
thing
called
the
docker
file.
The
docker
file
is
absolutely
magical
right.
The
doctor
file
is
still
what
we
loved
to
this
point
to
this
day
and
still
critical
to
how
we
have
to
think
about
the
world.
That
backer
file
is
something
we
check
in
to
source
code
repository
and
we
basically
put
in
there
exclusively
what
our
application
needs.
B
It
needs
this
operating
system
and
this
application
server
infrastructure
and
this
JVM
or
this
Python
runtime,
or
this
node.js
runtime
or
whatever
it
needs
right.
It
basically
covers
all
those
things
for
us,
including
configuration
and
copying
in
a
files
and
laying
over
you
know,
laying
in
exactly
the
application
as
we
need
it.
B
So
that
was
really
the
magic
that
turned
the
world
around,
because
I,
basically
us
to
codify
these
rules,
as
opposed
to
emailing
these
things
back
and
forth
huge
win
for
the
world
and
here's
the
challenge
right
now
we
figured
out
how
to
figure
it.
We
solved
that
one
problem
and
we
had
this
cool
thing
called
the
Linux
container
that
came
out
the
other
end.
We
didn't
have
forgot
to
manage
them
at
scale
and
I
deal
with
port
conflicts
like
if
you're
running
on
your
local
laptop
look.
I
am
right.
B
Now
you
might
have
a
concern
specifically
for
how
to
deal
with
you
know:
port
8080,
if
you're,
if
you're
living
in
the
Java
world
8080
comes
up
a
lot
right,
that's
where
all
the
Java
guys
love
to
run
8080
and
now
you
have
all
these
micro
services
and
you
got
like
14
of
them
running
and
you
have
14
things
burning
on
8080.
It
doesn't
work.
That's
an
example,
though
this
is
really
where
something
like
the
kubernetes
has
really
come
in
to
help
us.
Okay,
so
kubernetes
was
born
back
in
2014
as
an
open
source
project.
B
Ok,
so
we've
been
doing
this
for
quite
some
time
and
and
I've
been
playing
with
this
thing
for
quite
some
time
and
really
enjoying
it,
and
so
here's
kind
of
just
a
little
quick
history
on
kubernetes,
though
right
you
can
think
of
the
Greek
term,
helmsman,
a
governor,
that's
kind
of
where
people
say
this
refers
to.
Basically,
the
concept
is
kubernetes
is
the
Admiral.
If
you
will
of
your
fleet
of
ships,
that's
how
I
like
to
think
of
it.
So
you
have
all
your
fleet
of
ships
out
there
that
need
to
be
coordinated.
B
They
need
to
be
sailing
in
the
right
direction,
not
running
into
each
other.
Well,
that's
kind
of
how
I
like
to
look
at
it
from
a
tripping
news
perspective.
So
is
your
container
Orchestrator
it'll
support
multiple
cloud
environments
and
bare
metal
environments?
So
you
don't
need
a
virtualization
system.
In
many
cases,
like
openshift
will
sit
directly
on
bare
metal
as
an
example,
it's
inspired
by
kubernetes
experience
with
containers,
if
you
actually,
if
I
was
a
Google
person
back
in
the
day,
I
would
say,
and
we
launched
two
billion
containers
a
week.
B
That's
the
thing
they
used
to
love
to
say
so:
Google's
done
a
ton
with
paint
containers
over
the
last
decade
or
so
or
actually
at
this
point
15
years.
This
thing
is
all
written
and
go
in
an
open
source.
So
if
you
want
to
go
modify
it,
you
have
to
kind
of
learn
to
go
programming.
Language
and
I
can
tell
you
that
is
not
me.
I'm,
a
user
of
kubernetes,
not
an
extender
of
kubernetes.
Ok,
I'm
really
focused
on
my
applications
and
try
to
make
those
applications
run
successfully.
B
That's
what
I
care
about
as
a
developer.
So
some
key
things
out
of
the
gate:
self-healing,
horizontal
scaling,
auto
scaling,
horizontal
manual
scaling
things
like
that
automatic,
restarting,
that's,
actually
a
huge
win
by
the
way,
the
automatic
restarting
for
those
people
who
lived
in
the
job
at
ecosystem.
For
some
time
you
have
whole
operations
teams
whose
job
is
to
restart
JVMs.
So
now
it
gets
that
automatically
start
big
win
for
a
lot
of
people
with
it
in
the
Java
ecosystem
is
an
example:
load
balancing
rolling,
updates,
rolling,
upgrade,
spreads.
B
You're
gonna
see
some
of
these
things
in
action
and
I'd
rather
get
to
the
live
hacking
mode
if
we
can
okay,
huge
ecosystem
in
the
crew
Bernays
world.
So
if
you
can
probably
think
of
the
use
case,
probably
someone
trying
to
solve
that
problem
and,
as
matter
fact,
there's
probably
like
eight
people
trying
to
solve
the
same
problem.
Look
at
service
meshes
right,
there's
like
15
of
them
at
this
point,
I.
B
Think,
though,
depending
on
the
use
case,
you're
gonna
find
a
lot
of
people
adding
to
that
ecosystem
and
giving
you
to
all
these
different
options
that
does
make
it
more
complex
for
those
of
us
as
users,
though
people
who
wish
to
just
use
communities,
we
have
to
think
through
what
storage
do
we
want?
What
logging,
what
metrics?
What
this?
With
that
with
that,
though,
it
does
take
a
little
bit
effort
to
kind
of
curate
this
ecosystem
and
figure
out
what
you
need
from
them.
Okay,
now
the
concept
of
the
pod.
B
Now
we're
really
getting
into
it.
Now
we're
going
to
talk
about
pods,
we're
gonna
talk
about
the
core
components,
we're
gonna
dive
right
in
and
do
some
life
hacking
with
you
guys
here
in
this
session
today,
but
the
pod
is
somebody
you
got
to
get
your
head
around.
The
pod
is
where
your
code
rounds,
the
pod
is
your
server.
The
pod
is
your
application
host.
If
you
will,
it
is
where
your
JVM
runs.
It
is
where
your
Python
runs.
B
Your
nodejs
runs
your
go
code
or
C++
or
C
sharp,
doesn't
matter
what
it
is
pretty
much
of
it
runs
on
Linux.
This
come
running.
This
thing
called
a
pod.
Okay.
Now
the
pod
seems
like
an
odd
word,
because
normally
we
think
of
these
things
as
containers,
but
here's
the
trick
a
pod
can
have
more
than
one
container.
They
can
have
more
than
one
container
in
there.
It
can
have
two
or
three
and
if
I
actually
were
showing
you
Tecton
right
now,
you'd
see
like
11
containers
running
in
a
single
pod.
B
I
don't
mind
blowing
right,
though
pod
is
a
group
if
you
will
a
family
and
if
you
think
about
from
this
perspective
a
pod
is
a
family
of
whales,
and
you
can
see
over
on
the
right-hand
side
here.
I
have
some
way
outs.
You
might
recognize
where
those
whales
come
from,
so
more
than
one
container
running
in
a
pod.
Okay,
now
the
pod
basically
can
have
more
than
one
container
and
as
a
shared
IP
address.
So
keep
that
in
mind.
You
can
have
port
conflict
within
it
within
a
pod.
Alright.
B
B
Just
try
to
put
one
thing
in
a
pod
if
two
things
show
up
know
that
that's
not
necessarily
normal,
but
you
will
see
it
when
you
add
things
like
a
sidecar
for
Sto
or
sidecar
for
key
native,
or
maybe
you
do
the
fancy
Tecton
thing
you
might
seem
more
than
one
container
in
a
pod
today,
we're
gonna
be
one-to-one
one
container,
one
pot,
all
right:
shared
lifecycle,
shared
storage,
shared
resources,
pretty
much
the
pot.
Is
your
computer?
Okay,
your
JVM,
your
code,
your
nodejs,
whatever
it
is
thinks
the
pod
is
the
computer.
B
That's
the
easiest
way
to
think
of
it.
Now
we
have
this
other
thing
called
a
replica
set
and
employment.
We're
going
to
see
those
in
action
as
well,
and
the
replica
set
and
deployment
are
the
declarative
state
where
you
say:
I
want
X
to
heaven
and
by
X
I
want
to
run
this
lymphs
container
image.
I
want
to
run
it
three
times.
I
want
to
run
it
with
this
set
of
resources
like
memory
and
CPU.
Would
this
live
this
check
and
radiance
check?
B
So
this
is
pretty
much
a
yeah
mol
document,
a
Yambol
document
that
you
can
keep
in
your
source
code
repository
and
you're
gonna,
throw
it
over
at
kubernetes
and
and
and
koobideh
sticks
at
Yambol
document
and
makes
the
world
happen
all
right.
So
you
give
it
the
yamo
artifact
the
resource,
and
it
makes
the
magic
happen
for
you
right,
there's
also
the
concept
of
a
service.
This
is
actually
a
core
piece
of
the
magic
of
kubernetes.
B
That
I
believe
fundamentally
was
a
game
changer
for
us
as
a
world
because
they
separated
the
IP
addresses
and
those
pods
from
the
world.
Via
this
thing
called
service,
the
service
is
the
DNS
entry.
The
service
is
the
IP
address
that
the
world
talks
to
when
I,
say
world
I
mean
the
other
guys
in
your
cluster
okay,
and
they
talk
to
that
service.
Like
the
customer
service,
the
preference
service,
the
recommendation
service,
the
inventory
service
they
talk
to
that
service
and
the
service
then
talks
to
the
bugs.
B
B
So
if
you
do
need
non
ephemeral,
storage
storage
that
exists
beyond
the
pod
lifecycle,
like
a
database
as
an
example
or
kafka
broker,
then
you
want
to
set
up
the
Peavey's
and
PVCs
persistent
biome
claims
and
they
lot
of
the
magic
happens
based
on
labels.
Okay,
so
what
I
want
to
do
now
is
I
want
to
kind
of
get
here
and
start
hacking
on
some
stuff,
though,
and
showing
you
some
things,
because
we
got
we
ready
to
show
you
some
fun
stuff,
then
have
you
guys
sit
there
and
listen
to
slides?
B
B
Okay,
I've
already
set
up
my
environment
variables,
so
these
are
the
key
ones
you
would
use
if
you're,
using
mini
queue
and
I'm
gonna
use
mini
queue
today,
because
it
is
a
nice
baseline
to
get
started
with
right,
so
mini
cube
is
the
easiest
way
to
get
started
in
a
kubernetes
ecosystem.
The
beautiful
thing
is
it's
all
under
your
control
on
your
laptop
and
therefore,
if
you
want
to
burn
it
down
and
idle
it
just
burned
mine
down,
I
just
destroyed
it.
I
can
recreate
it
and
bring
it
back
to
life.
B
So
it's
a
beautiful
thing:
myself.
There
is
another
technology.
There
called
code
ready
containers
which
is
an
open
ship
for
your
laptop,
and
it
is
running
over
here.
As
an
example,
let's
see
I
do
have
it
running.
Oh
I.
Don't
have
that
in
my
pack.
So
it's
right
here.
You
know
so
it
is
running,
but
I'm,
not
I,
haven't
really
spent
a
lot
of
time
with
it
and
and
really
haven't,
had
a
chance
to
really
exercise
it.
Well,
how
about
that
as
an
example?
B
I'm
gonna,
just
let
that
be,
and
we're
gonna
focus
on
our
mini
cube.
You
can
also
do
an
okd
where
you
install
it
and
okt
for
install
it
on
one.
The
public
cloud
providers
and
normally
I
do
actually
install
an
open
shift
on
an
Amazon
on
a
Google
on
an
azure
when
I
want
to
base.
They
set
up
something
more
interesting,
but
today
I'm
going
to
just
pretty
much
use
my
mini
Cuban
heart.
Okay.
So
let
me
just
export
my
variables
into
my
terminal
here.
You
can
see
I,
basically,
a
take
you
home
path.
B
The
big
cute
cute,
config,
very
important
I.
Do
this
so
I
keep
my
worlds
separate
apart
from
each
other,
alright,
and
then
the
cube
editor
you'll
see
the
cube.
Editor
us
live
later
on,
but
it's
a
very
powerful,
very
powerful
setting
that
you
might
want
to
keep
take
advantage
of,
and
then
you
basically
can
just
run
your
mini
cube
commands
to
get
it
started
so
I'm
just
gonna
copy
and
paste
those
in,
and
so
you
kind
of
see
what
those
are
in
the
documentation
and
let's
go
here
and
I
will
bring
these
up
here.
B
Okay,
you
basically
would
just
set
up
mini
cube
two
ways,
but
how
much
remember
you
want
how
many
CPUs
you
want
in
my
case,
I
tend
to
always
use
the
VM
driver
VirtualBox.
You
can
pick
and
choose
which
one
you
want
here,
but
I
use
VirtualBox,
because
it's
available
to
me
on
Windows
and
Mac
and
Linux,
and
so
it's
a
little
more
Universal
from
that
perspective
today,
I
have
a
kind
of
hard-coded
of
114,
but
this
is
important
to
note.
B
You
will
want
to
be
specific,
think
about
your
committees
version
knowing
which
one
you
might
have
in
production.
Okay,
most
people
are
still
kind
of
114
and
older.
The
115
116
are
currently
out
every
now
and
then
you
will
see
me
use
a
later
version.
116,
though,
does
have
a
kind
of
a
feature.
If
you
will
it
will,
it
has
deprecated
some
of
the
api's
and
therefore
some
of
your
older
yam
bowls
will
fail
on
116.
So
just
be
aware
of
that,
you
know
so
you
might
actually
get
burned
on
that.
B
One
I've
actually
got
burned
on
that.
One
myself
and
then
I
couldn't
forgot.
Why
and
then
I
realized
I
was
still
using.
The
older
alpha
or
beta
versions
of
things
like
a
deployment
is
a
good
example
all
right
and
then,
of
course,
there's
this
concept
of
a
profile
here
now
the
profile
allows
you
to
have
different
mini
cubes
up
at
any
given
moment,
like
I
might
have
three
mini
cubes,
four
mini
cubes
up
at
an
ending
in
a
moment.
B
The
profile
helps
me,
keep
those
worlds
separate,
I'm
long
and
having
a
good
cute
config
and
knowing
where
the
cute
config
is
okay.
Now,
when
this
thing
is
loading,
you'll
see
that
it
basically
has
to
go
to
the
process
of
bootstrapping
itself
and
then
it'll
do
a
download
of
cube
admin
and
cube
control
than
some
other
things.
You'll
see
those
things
downloading,
since
I
had
previously
started
on
this
machine,
it's
not
going
through
that
download
process.
It's
just
simply
waiting
for
the
cluster
to
get
built
inside
that
virtual
machine
and
get
started.
B
Okay,
you
can
even
say
it's
complaining
to
me
that
114
is
a
little
bit
old
and
I
have
a
116
client,
that's
okay!
So
now,
once
it's
up,
you
say
cluster
info.
Okay,
TTL
cube
control.
Cluster
info
is
probably
the
first
command
you
want
to
run,
so
this
is
known
as
cube,
control
or
cube
CTL.
It's
one
of
the
key
to
a
lot
of
tools
that
you'll
have
an
improvement,
is
ecosystem
to
know.
What's
going
on
and
cluster
info
lets,
you
know
which
cluster
you're
connected
to.
So
that's
a
big
one.
Another
one
is
cube.
B
Control,
get
namespaces,
alright
and
we'll
talk
more
about
namespace
in
a
second,
but
I
need
to
know
what
my
namespaces
are.
These
are
these
are
folders.
If
you
will
that
you
would
load
things
into
it's
tab,
organizational
structure
now
namespaces
actually
have
some
additional
capabilities
like
settings
of
quotas
and
limit
ranges
and
our
background
role-based
access
things
like
that.
So
you
need
to
be
aware
of
those
things,
but
by
default
just
think
of
his
way
too
root,
stuff
and
you're
early
and
getting
started
experience
right.
B
So
just
keep
the
mind
of
those
things
are
out
there
and
there's
other
things
out
here,
like
cubes.
Do
grit
modes
all
right,
another
thing
and
we're
going
to
talk
about
modes
in
a
moment,
but
nodes
basically
tell
me
what
what
worker
nodes
and
master
nodes
I
have
and
a
mini
cube
or
CRC
code,
ready
containers
or
mini
shift.
B
Okay,
let's
jump
back
in
the
slide
mode
and
kind
of
explain
what
this
master
and
all
this
kind
of
stuff
is
all
right,
because
I
think
it's
important
to
kind
of
comprehend.
What
we're
looking
at
here
so
I
am
the
developer.
Using
this
tool
called
cube,
control,
cube
CTL
and
has
different
names,
cube
controls,
the
official
name
going
on.
Most
people
do
CTL,
for
maybe
older
people
like
myself,
who
just
that's
when
I
start
calling
it
before
someone
decided,
is
really
called
cube
control.
Some
people
call
it
a
cube,
cuddle
right.
B
You
know
the
cuddles
Puna,
so
it's
all
the
same
thing.
Just
a
day
today,
you're
going
to
use
this
command
line
tool
as
a
developer
and
I
want
an
Operations
person.
You're
gonna
interact
with
this
API
and
then
what's
called
a
master.
Node
typically
have
three
master
nodes
in
a
production
environment.
So
you
you're
you
have
these
threes
because
of
NCD
needs
three
for
high
availability.
So
NCD
is
the
database
where
all
those
little
Gamble's
you've
been
messing
with
we're.
Gonna
restore
okay.
So
you
basically
create
this
document.
B
This
artifact
this
resource,
a
yamo
file
and
you're,
going
to
chunk
it
over
the
wall
through
the
API
into
the
master
node.
It's
gonna
write
that
thing
to
NCD.
That's
what
keeps
it
now
once
it
has.
Your
desires
again,
define
typically
a
yeah,
more
form,
sometimes
JSON,
but
normally
Yambol
form.
It's
gonna
then
light
up
the
schedulers
and
controllers
needed
to
make
it
real
in
the
world.
B
Okay,
so
the
the
schedulers
and
controllers
are
going
to
make
it
real
and
it's
going
to
make
it
real
by
talking
to
all
the
worker
news
on
the
right-hand
side.
Here
you
have
the
concept
of
the
worker
node
and
the
worker.
Node
is
just
another
computer,
another
virtual
machine,
don't
read
a
bare-metal
server
or
a
virtual
machine
that
basically
will
run
those
pods
right.
It's
gonna,
it's
gonna
run
the
pods
for
you
and
it's
gonna
use
this
thing
called
cubelet.
B
So
basically,
the
cubelet
is
the
agent
that
lives
on
those
worker
nodes
that
talks
to
the
master.
The
master
talks
with
the
cubelet.
That's
how
those
two
things
connect
and
it's
gonna
basically
run
these
things
for
you,
okay,
I,
like
to
think
of
it
in
this
most
simplest
form
of
docker
run,
because
if
you
were
using
plain
old-school
docker,
but
you
do
your
docker
build,
you
do
your
docker
run
and
if
you
had
a
multiple
machine,
you
have
many
machines,
you
do
docker
run
docker
run
docker
run
docker
run
right.
B
You
just
issued
that
command
four
times.
If
that's
what
you
needed
in
this
case,
you
don't
worry
about
that.
It's
taking
care
of
that
for
you,
it's
doing
the
docker
run
for
you.
Now
the
modern
communities
distributions
that
are
out
there.
They
don't
use
docker
or
need
to
covers
anymore,
but
you
can
it
kind
of
it
doesn't
matter
to
you
as
a
developer
or
user.
It
just
basically
runs
your
pop.
How
about
that
runs
your
container
now
again,
you're
gonna
basically
give
it
a
declaration.
B
I
want
to
run
my
Tomcat
from
this
specific
image
that
was
created.
I
want
to
run
it
four
times,
you're
gonna
ship,
that
over
to
the
master,
it's
basically
gonna
receive
that
data
and
then
figure
out
which
worker
nodes
can
actually
handle
it
right.
So
it's
gonna
drop
those
four
Tomcats
out
there
across
my
worker
nodes
and
that's
pretty
awesome
and
it'll.
Just
make
that
happen.
For
you,
assuming
there
is
space
available,
you
will
see
a
certain
word
called
pending.
I,
don't
think
I
can
simulate
it
today.
B
It
takes
a
little
effort
to
simulate
it,
but
if
you
run
your
cluster
out
of
node
out
of
resources,
you'll
see
pending
and
you
don't
have
to
go
digging
into
that
and
then
you'll
have
to
figure
out
exactly
why
it's
pending.
Okay,
there's
a
tricky
thing
to
simulate.
Often
that
happens
to
mean
mid
presentations
that
might
happen
today,
but
otherwise
I,
don't
I,
don't
know
if
I
can
simulate
it
and
we
make
it
refrain.
Another
key
feature,
though,
of
a
criminal's
cluster
right:
it's
always
monitoring
your
environment.
B
If
you
said
you
wanted
for
Tomcats
and
one
of
your
Tomcats
dies,
it
will
ensure
that
that
Tomcat
responds
someplace
else,
I
like
to
think
of
it
as
a
responding
like
you
have
in
a
gaming
environment.
Basically,
you
know
your
character
was
killed,
but
it
responds
over
here
in
another
part
of
the
world
and
therefore
gets
back
to
the
fight.
B
You
know
have
different
flavors
of
that
capabilities
of
example.
So,
let's
kind
of
go
back
into
this
now
all
right
I
want
to
kind
of
show
you
some
things,
because
we're
gonna
have
a
little
fun
with
our
little
kubernetes
here,
so
we're
gonna
be
get
namespaces
all
right,
but
main
face
is
one
more
time
and
so
I
got
a
pen
correctly.
Mate
I
basically
have
those
out-of-the-box
namespaces
that
is
kind
of
how
the
box
for
Medi
cube.
Now,
if
I
were
doing
this
on
a
open
shift.
B
Okay,
let's
try
it
over
here
on
openshift
yeah
namespaces.
You
know
you
can
kind
of
see
that
there's
a
bunch
of
stuff
in
the
open
ship,
so
openshift
kind
of
comes
with
a
lot
of
things.
Pre-Configured
out-of-the-box,
rather
happy
you're,
Sdn
a
console.
You
know
how
to
manage
networking
all
these
things
called
operators
which
we
won't
have
time
for
today,
but
there's
all
kinds
of
magic
built
into
an
open
shift
version
of
this,
while
basic
communities
would
just
have
these
basic
ones
like
mini
cube,
has
default
right,
cube
system
things
like
that.
B
If
you
do
keep
control
get
pods,
though
all
namespaces
and
that's
a
key
command.
You
wanna
remember
because
what
is
running
in
your
cluster
well
now,
I
know
that
I
have
a
bunch
of
things
running
and
there's
an
HDD
thing.
We
talked
about
there's
the
API
thing
right,
so
this
is
where
things
are
running.
It's
running
within
the
system,
mostly
here
in
cube
system,
and
it's
good
to
know
that
those
things
are
out
there.
I'll
tell
you
as
a
new
person,
don't
go
hacking
on
those
things:
leave
them
be
they're,
fine,
don't
mess
with
them.
B
You
want
to
basically
create
your
known,
namespace
and
run
your
own
stuff.
Okay.
Now,
by
default,
this
thing
called
default.
Is
this
the
place
you're
living
in
a
and
when
it
comes
to
regular
old
cribbage,
the
default
is
the
world
you're
living
in
and
so,
as
you
create
resources
to
yourself,
you're
going
to
be
living
in
that
default.
Namespace.
Keep
that
in
mind
and
what
I'm
gonna
do
is
run
this
command
right
here
and
get
started.
So
what
we're
gonna
do
is
run.
This
thing
called
cube,
control,
create
deployment.
B
I'm
gonna,
give
it
a
name,
my
app
and
it's
gonna,
pull
it
from
this
image.
Okay
from
that
image
right
there,
so
that's
kind
of
the
fastest
way
to
get
going,
and
so
that's,
why
document
that
right,
you're
gonna,
say
create
deployment,
and
now
you
need
to
kind
of
poke
around
in
your
environment.
So
if
I
feel
oh
and
say,
watch
teams
controlled
their
pods
you'll,
see,
there's
a
pod
coming
to
life
and
it's
going
through
its
container
creating
phase.
B
Basically,
it's
pulling
the
image
down
from
the
internet
from
Kauai
over
Sutter
beat
my
boot
v1.
It's
downloading
that
image
and
fling
it
into
my
environment.
How
do
I
know
it's
pulling
the
image
you
have
another
command
hue
control,
get
events
and
I,
never
remember
sort
by
and
the
syntax
here
so
I'm
gonna
have
to
memorize
that
at
some
point,
because
you
do
want
to
see
it
sorted
because
my
default
doesn't
sort,
but
you
can
kind
of
see
it
says,
pulling
and
pulled
created
started
alright,
see
those
four
things
right
there.
B
That
is
the
magic
happening
right
now.
So
basically
it
essentially
went
out
and
found
the
image
on
the
internet
pulled
it
into
my
cluster.
Alright,
once
it
gets
a
pulled,
then
it
goes
and
schedules
that
image
against
a
worker.
No
there's
only
one
worker
known
the
space
gets
it
created
and
gets
it
started,
and
then
a
pod,
if
you
were
looking
up
here,
went
from
container
creating
to
running
all
right.
One
of
one
running
one
container
in
this
pod
is
ready
all
right.
That's
good!
Right!
B
If
you
have
a
at
these
numbers
mismatch,
you
probably
have
a
problem.
Okay,
so
if
it's
one
of
one
you're
in
good
shape,
if
it's
zero
of
one
you're,
not
in
good
shape,
if
it's
one
of
two
you're
not
in
good
shape,
all
right,
so
try
try
to
basically
get
101
here
and
running
and
then
your
your
might
be.
Okay,
I'm,
not
gonna,
say
you
are
okay,
you
might
be
okay
cuz!
Sometimes
you
can
get
your
pod
running
and
things
still
aren't
quite
right.
Okay,
so
what's
your
next
step?
B
Well,
I
have
a
pod
and
that
pilot
came
about
because
I
created
the
deployment
so
forth
over
here
see
ya
deployments
as
an
example
in
Cedars
at
the
planet
called
my
app
and
I
can
say
it
keeps
being
bit
RS
reckless.
So
here's
one
piece
of
magic
already
the
deployment
creates
a
replica
set.
A
replica
set,
creates
a
pod
right.
B
B
You
should
be
familiar
with
other
than
yet
we've
been
using
it
a
lot
here,
but
there's
one
called
describe
all
right
so
describe
deployment,
my
app
as
an
example,
and
that
may
say
pulls
out
for
you
what
that
document
was
that
was
created
right
when
I
said
basically
create
that
deployment.
Basically,
this
is
what
was
actually
created.
For
me,
a
lot
of
assumptions
were
made,
meaning
the
strategy
type
of
rolling
update.
But
this
rolling
update
strategy
was
a
was
an
assumption
was
made
for
me.
B
It
basically
used
the
image
that
I
gave
it
as
an
example:
Quay
I
/
Sutter,
my
boot
as
an
example,
and
so
it,
but
it
was
enough
information
right
to
get
this
deployment
to
run.
So
one
thing
I'd
might
like
to
do
it's
a
huge
ETL
edit
deployment,
my
boot,
okay,
yeah.
No,
my
app
all
the
same
I
hat
though
here
edit
the
deployment
and
what
that's
gonna
do
is
throw
me
in
the
visual
studio
code
and
I
can
edit
this
thing
in
real
time
here.
Right
so
I
can
basically
say
well.
B
I
want
to
change
the
replicas,
we're
gonna
know
where
to
go,
and
now
and
now
my
brain
start
working
somewhere
go
alright.
Now
they're
all
in
case
of
replicas.
To
let's
say
three
though
save
clothes
and
go
back
over
here
and
then
so
I've
basically
made
a
change,
a
replicas
to
three.
You
can
see
it
spins
up
to
other
pugs,
okay,
two
more
pods
based
on
replicas,
equal,
three
and
again
that
edit
trick
was
based
on
echo,
hope
you
editor
yeah
right.
B
There
I
sent
back
to
codes
face
W,
and
that
allows
me
to
use
Visual
Studio
code
to
do
my
editing,
as
opposed
to
via,
like
essentially
much
like
get
and
other
tools.
You
just
have
a
VI
like
experience,
otherwise,
which
is
fine.
You
know,
for
you
know,
if
you
remember,
you
know,
escape
:
WQ
things
like
that.
Of
course.
B
B
Let's
see
here,
make
it
one
they've
closed
and
say
all
right,
and
then
let's
see
here
there
we
go
and
tour
than
we're
getting
torn
down
them
so
that
declarative
nature,
kubernetes
is
kind
of
built
right
into
the
architecture.
Are
you
you
basically
just
say
what
you
want
and
it
tries
to
make
it
happen
for
you,
it's
kind
of
the
idea
there.
So
there's
my
one
running
pod
and
again,
just
kind
of
recap:
we
have
our
deployment
and
we
have
our
replica
set.
B
Okay,
the
replica
said
is
the
controller
that's
governing
how
many
those
things
do
you
want
right,
so
I'm,
not
one
or
two
or
three
replicas.
That's
what
the
replica
sets
job
is.
The
deployment
has
a
bigger
job
meant,
so
we'll
get
more
of
those
features
in
a
second.
But
now
I
have
my
one
running
pod.
B
Okay,
now
how
do
I
know
if
this
thing
is
really
doing
what
I
wanted
to
do
that
so
and
let
me
come
over
here
and
basically
say:
cue
control,
exec,
IT
and
layer,
the
pod
in
I'm,
going
to
jump
into
the
Bob
I'm
gonna
shell
into
that
pod.
Basically,
and
so
I'm
gonna
come
in
here
now
and
I
could
be
things
like
PS,
yes
and
I
can
go
through.
It
looks
like
it's
a
job
application
living
out
here
and
I
can
I
think
use
top
I
know.
B
I
can
explore
things
within
that
little
Linux
container,
if
I
wish
to,
but
I
can
also
just
simply
say,
kuroh
localhost:8080
and
see
what
I
get
uh-huh.
So
the
application
is
in
fact
running.
It
says
Aloha
from
spring
route,
and
it
also
tells
me
what
pod
is
running
on
that
is
the
hostname
from
a
Java
standpoint
or
Python,
or
go
or
no
js'.
If
you
say,
what's
your
hostname,
you
get
the
pot
identifier
which
I
think
that's
pretty
cool.
Does
that's
the
computer,
your
little
job
application,
that's
running
on
so
I?
Have
that
note?
B
I
saw
I
haven't
happened,
looks
like
it's
running,
but
the
next
thing
is
I
need
to
expose
the
app
to
the
greater
world
right.
So
it's
great
that
my
app
is
up
and
running,
but
I
need
to
go
through
different
layers
of
exposing
it
to
the
world,
and
you
might
remember
that
I
had
this
thing
called
service
that
would
had
to
be
created
and,
if
I
say
cube,
CTO
services
I,
don't
have
any
real
service
in
this
case,
and
this
one
is
again
a
default
one
that
comes
with
mini
cube.
B
You
can
kind
of
ignore
that
one.
What
you
want
is
to
expose
that
the
application
as
a
service
and
there's
actually
a
command
for
that
I'm.
Just
gonna
copy
and
paste
it
from
my
documentation,
and
that
is
Cube
control,
expose
deployment.
My
app
the
port
I
want
exposed
and
type
load
balancer
as
an
example.
Okay,
I'm
gonna
run
that
command.
That
does
get
me
a
service,
and
then
you
can
kind
of
see
it
right
there.
Okay,
so
there's
a
my
app
the
mode
balancer
and
you
can
see
right
here.
B
There
has
this
little
funny
port
right
here:
three
zero!
One
one:
seven
that
is
the
node
port:
alright,
so
if
you're
dealing
with
a
mini
cube,
no
port
is
your
friend.
In
other
words,
if
you're
dealing
with
a
local
cluster
like
I,
am
here
note
port
is
the
easiest
way
to
get
into
that
thing
and
talk
to
it.
Okay,
so
from
a
mini,
cube
or
mini
shift.
If
you're
using
the
older
mini
shift,
the
technique
is
fairly
straightforward.
B
You
need
the
business,
a
mini
cube,
IP
I,
noticed
I
got
an
error
here
and
I'm,
because
I
have
an
error.
So
what
you?
What
the
reason
I
got?
The
air
is
because
I
didn't
actually
say
what
profile.
So,
if
you
do
use
profiles,
you
do
have
to
do
a
cautious
in
this.
The
lemon
steps,
IP
and
then
I
get
the
IP
address
and
I
can
basically
know
with
the
IP
addresses
of
that
virtual
machine
or
in
my
case,
running
on
VirtualBox.
B
You
can
kind
of
tell
that
by
than
191
16,
any
nine
okay,
but
what's
this
trick,
I
can
also
make
this
profile.
Sticky,
cleaning
I'll
run
this
command,
and
now
I
can
get
to
use
a
mini
cube
IP.
As
an
example,
all
right
so
now
I
can
get
that
IP
address,
I'm,
gonna,
say
curl,
oh
wait!
Let
me
go
back
and
get
my
note
board
again
and
I
can
say:
curl
right,
192,
168,
99,.
B
1
2,
1,
alright
and
then
freeze
your
own
one,
one
time
there.
It
goes
alright,
so
now
I'm
popping
that
from
my
host
machine,
you
know
from
my
host
machine
into
that
virtual
machine
into
that
pod
example,
but
come
back
over
here
in
my
browser
if
I
want
to
use
my
browser,
also
I
can
basically
interact
with
it
from
here,
too.
Okay.
So
that's
awesome.
I
now
know
that
my
app
seems
to
be
more
or
less
running
and
again.
I
know
which
pod
is
sitting
on
notice.
A
little
counter
right
here.
B
I
tend
to
do
this
and
let
my
presentations
because
I
want
to
know
that
it's
the
JVM
has
not
been
reached.
Cycled
right,
the
runtime
is
still
up
as
and
it
holds
a
state
in
this
case
the
simple
counter.
So
it's
a
little
bit
stateful
just
so
I
add
all
in
memory
state
in
this
case,
but
it
allows
me
know
that
things
are
okay
and
nothing
weird
has
happened.
So
that's
awesome,
so
I
have
my
service
and
I
can
talk
to
it.
So
I
could
even
be
something
like
wild.
B
True,
okay,
do
and
then
we'll
do
this.
Curl
yeah
that
okay
yep,
that
looks
good
well
sleep
for
a
little
bit,
so
we
don't
just
going
to
go
too
crazy
here
and
then
we'll
put
a
done
and
have
it
back
alright.
So
there
we
go
so
now
we're
we're
basically
looping
along
hitting
that
pod,
interacting
with
it
and
if
I
come
back
now,
do
something
clever
with
it
Q
GTL
in
its
deployment.
B
My
app
has
an
example:
I
can
come
over
here
now
and
basically
hack
on
it,
some
more.
Let's
implement
fun.
I'm
gonna
go
back
to
two
replicas,
the
two
replicas
save
and
close
and
yep.
Here
it
comes
so
you
notice
right
now
that
there's
a
second
replica
coming
online
and
also
notice,
there's
an
error
message.
B
You
see
that
error,
so
it's
cool
that
it's
scaled
out
right,
I,
basically
set
out
to
it,
gave
me
two
and
I'm
kind
of
highly
available
if
you
will
and
that
load
balances
automatically,
so
the
service
load
balances
automatically
against
all
the
pods
and
meet
its
service.
Selector,
okay,
but
I
also
got
this
error
message
and
we're
gonna
get
back
to
this
in
the
next
few
minutes,
because
I
want
you
to
be
aware
that
this
error
occurs
and
how
to
address
it.
But
what
do
I
mean
by
the
service?
Okay,
the
certificate
services?
B
If
we
come
over
here
and
say,
cube
CTL
describe
service
by
app
right
here.
Duh
knows
where
it
has
endpoints
and
has
two
IP
addresses
there.
Those
are
the
pod
IP
addresses
and
then
right
here
where
it
says:
service,
selector
or
selector
at
equal,
my
app.
So
if
I
actually
come
back
to
my
watch
up
here
in
bit,
pods
I'm
gonna
say
show
labels.
B
Let's
go
show
labels
and
notice.
It
has
app
my
app
my
app
there
and
that
label,
and
this
and
the
selector,
and
what
makes
these
IP
addresses
show
up
here
for
this
service.
So
that's
how
they
end
up
in
the
load
balancer.
If
you
want
to
play
with
this
and
there's
a
whole
document,
I
have
in
my
longer
course,
where
I
basically
have
you
pack
into
that,
and
we
basically
have
a
Python
thing
and
a
go
thing.
B
A
nodejs
thing:
nobody
can
throw
anything
in
there
and
by
mid
playing
the
labels
right,
you
can
constantly
changing
the
load
balancer
and
the
service
as
an
example.
Okay,
but
that's
kind
of
the
basics
of
that.
Unfortunately,
there
have
a
lot
of
time
to
spend
on
that
today,
but
it
does
give
me
a
feel
for
how
this
works.
Now,
let
me
show
you
one
more
thing,
though,
as
it
relates
to
that
error
message.
Let
me
go
back
to
my
loop
over
here
and
watch.
B
I'm
gonna
go
back
and
just
go
back
to
replicas
one
just
to
make
it
super
simple.
Keep
it
keep
it
a
little
bit
more
saying
here,
one
all
right,
I'm
gonna
change
that
again
and
let
that
scale
down.
Okay,
there
we
go
so
you
notice
on
the
scale
down.
There
was
no
problem.
Alright,
so
that's
an
it's
a
telling
moment
like
weight
on
the
scale
up.
We
had
a
problem
or
scale
out.
We
had
a
problem,
but
on
the
back
and
we'll
be
backed
it
off,
there's
no
error.
Okay!
So
it's
important!
B
We
remember
that
one,
because
that's
part
of
the
secret
here
now
I
have
the
one
I
have
one
terminating.
We
can
ignore
that
for
now
to
get
cleaned
up
soon,
but
I
have
the
one
running.
What
I
want
to
do
next,
though,
is
do
a
live
update
of
it.
Okay,
so
the
live
update
is
where
the
real
magic
begins,
and
so
what
I'm
gonna
do
here?
There's
another
command
I'm
going
to
use
and
it's
called
cute
CTL
cute
control
set
image
deployment.
My
app
okay
and
I
believe
that
containers
my
goop.
B
Then
we
will
find
out
if
I
get
this
wrong
way,
IO
and
then
we're
gonna
base
the
safer
Center
and
we're
gonna.
Then
say
my
group
version
two:
let's
try
that
I
got
that
right,
we'll
find
out
if
we
don't,
but
if
I
don't
have
a
right
we'll
make
you
find
out
the
hard
way
when
you
see
the
container
creating
there.
Okay,
so
again,
it's
doing
its
pull.
But
if
you
would
go
look
at
cube
control,
get
events
you
would
see.
B
The
poll
was
happening
and
eventually
you
get
a
polled
and
eventually
you
get
a
created
and
started,
and
then
we
get
a
bunch
of
error
messages
all
right,
but
no
now
it's
working
wait
a
second!
So
what
happened
here?
We
have
from
this
Aloha
one
through
this
Bonjour
one
okay,
I'm
from
the
south
by
night,
so
I
say
bonjour,
horribly
I
know
that,
but
we
go
to
the
Bonjour
one
and
now
we're
okay
again,
but
we
got
a
bunch
of
errors.
What
happened
there,
so
the
magic
trick
here
is
the
liveness
probe
and
ready.
B
There
aren't
any
at
this
moment:
I'm.
Okay!
There
are
not
any
at
this
point
time
and
you
want
to
get
to
the
point
with
your
buddies,
where
you
understand
what
those
are
and
use
them
appropriately,
because
if
you
don't
have
them,
life
is
not
fun
for
you.
Okay,
you
get
all
these
error
messages.
Your
users
are
experiencing
downtime,
you
don't
know
why,
and
I
can
really
burn
you
all
right.
So
if
you
kind
of
I'm
doing
the
describe
moment,
deployment
here
and
you
kind
of
see,
there
is
no
lightness,
prober
readiness
probe
sitting
here.
B
I
don't
see
them
listed
and
that's
because
they're
not
they're,
not
in
yet
okay
they're,
just
simply
not
in
there
and
what's
funny
about
this,
though
this
is
a
subtle
kind
of
errand,
all
I
did
was
roll
from
one
version
of
spring
boot
to
another
version.
Let
me
actually
roll
it
back.
I'm
gonna
go
back
to
version
1,
okay,
I'm
gonna
go
from
Bonjour
Aloha.
Now,
in
this
case,
the
image
is
already
downloaded
so
that
it
that
time
spent
for
downloaded
image
is
no
longer
part
of
the
system,
but
the
bootstrapping
of
the
pod.
B
Getting
it
up
basically
gives
us
this
error,
because
it
does
not
yet
know
that
the
JVM
is
up
okay.
So
that's
the
funny
part
here
spring
boot
boots.
Slowly
enough
with
the
JVM
coming
online,
the
screen
boot
favorite
coming
online
and
everything
coming
online.
Those
seconds
that
it's
waiting
to
come
up
or
unbeknownst
to
convince
companies
like
the
container
came
out.
We
saw
Linux
come
up.
You
must
be
ready,
that's
its
default
thinking!
B
Okay,
though,
it
is
wrong
in
this
case,
because
our
little
spring
group
was
not
up,
and
so
let
me
flip
it
back
over
to
Bonjour
and
again
this
is
rolling
update,
you're
gonna
see
it
happen
here.
It's
gonna
flip
the
user
over,
but
it's
sending
the
user
over
too
soon,
because
the
JVM
was
not
quite
up
and
spring
boot
is
not
find
out.
The
kind
of
make
this
may
be
a
little
bit
more
subtle,
though
I'm
gonna
change
the
game.
B
It's
doing
its
pull
and
you
notice
it
flipped
right
over
and
there
was
no
error
message
because
Korkis
boots
so
fast
that
even
the
curl
did
not
get
there
and
see
the
error
message,
so
no
downtime
from
a
Korkis
standpoint,
because
it
just
boots
that
fast.
In
any
case,
you
want
to
still
fix
this
concern
because
you
don't
really
want
your
new
jurist
experience
at
an
outage
just
because
you
were
good,
smooth
and
rolling
update
as
an
example.
This
case
I'm
flicking
foot.
Let
me
back
to
spring
boot.
B
Okay,
let's
do
this
now
I
want
to
come
over
here
and
clean
this
up
a
little
bit.
We
have
a
few
minutes
left
and
I
want
to
show
you
you
kind
of
move
Kenny
at
the
high
points
so
far,
but
we
want
to
make
sure
we
cover
another
key
piece
of
ground,
and
that
is
those
two
probes,
the
lightest
Road
and
reigns
for
am
I.
Talking
about.
Let's
see
here,
I
got
the
let's.
B
Let's
clean
things
up,
I'm
gonna
do
GTL
delete
the
really
service,
my
app
okay,
we're
gonna,
remove
that
we're
gonna
move
the
deployment,
my
app
as
well
I'm
kind
of
getting
rid
that
stuff
to
free
up
space.
Okay,
there
are
no
pods,
there's
no
memory
being
used,
I'm
gonna
free
up
that
memory
free
up
those
CPUs,
just
thrid
that
stuff,
if
I
say
get
all
here,
we
kind
of
see
II
there
is
that
pod
that
is
terminating
and
there's
that
little
magical
service.
It's
part
of
the
default
namespace
and
mini
cube
again.
B
You
ignore
that
let's
kind
of
go
do
this
again,
one
more
time
but
kind
of
show
you
a
kind
of
different
perspective
mode.
We're
gonna
go
through
the
same
set
of
steps,
but
maybe
a
different
order
and
I.
Think
that'll
give
you
a
different
perspective.
Look
a
few
control
creating
space.
Let's
call
this
name:
space
birth,
we're
just
gonna,
make
that
one
up
on
the
fly
and
normally
in
crib
minetti's.
B
You
always
use
the
name
space
everywhere
you
go
so
when
you
say
QC
PL,
you
know
create
or
apply
or
whatever
you
normally
use
a
dash
in
and
BRR
and
I.
Don't
like
doing
that,
because
I'm
lazy,
so
I
have
another
little
tool
called
Cuban
s.
That
basically
makes
it
sticky.
So
now
I,
don't
have
to
say,
burn
everywhere.
I
go!
Basically,
it
assumes
for
everywhere
I
go
now
if
you're
working
with
an
overshift
cluster.
B
This
is
the
same
thing
as
saying
open
jet
project
for
which
that
doesn't
work
on
a
mini
cube,
but
there's
a
third-party
tool
that
makes
it
work
for
a
mini,
cube
or
other
kubernetes
clusters.
It's
called
human
s.
You
can
get
that
by
sending
brew,
install
boobsie
TX
as
part
of
the
kimchi
TX
and
cube
and
Cuban.
Ices
part
that's
cool.
Do
you
want
that?
One?
That's
part
of
one
of
the
tips
that
I
have
and
that
presentation
also
okay,
now
I
want
to
do,
is
actually
coming
here
and
we
haven't.
B
We
have
a
few
minutes.
Let's
see
how
fast
we
can
go.
Okay,
now
we're
gonna
have
to
pick
up
the
pace
a
little
bit.
Let
me
go
to
court.
I
said
I,
oh
I
just
want
to
kind
of
show
you
one
more
time.
This
whole
process,
but
kind
of
show
you
something
a
little
bit
more
a
little
bit
different
about.
It
start
coding.
Let's
go
here:
okay,
I'm
gonna,
say
calm
birth
center
and
let
that
get
in
there.
There
we
go
and
let's
call
this
thing-
the
die
and
Mo
how
about
that?
B
We're
hanging
out,
Diane,
Bay
right
and
we're
gonna
chart
that
application,
and
there
it's
gonna,
download,
fantastic.
It's
downloading,
I'm
gonna
come
back
over
here.
Now,
let's
go,
let's
create
a
space
rational!
Need
you
crazy
for
this.
We're
gonna,
basically
move
it
over
die
hand
mo
move
it
over
we're
gonna
unzip
it
okay!
So
there
we
go
we're
gonna
CD
into
it.
We're
gonna
do
a
code
that
for
Visual
Studio
code.
No,
this
is
truly
from
scratch.
B
Your
fame
charts
from
scratch,
I'm
gonna
cheat
along
the
way,
though
just
kind
of
show
you
what
we're
doing.
But
here's,
let's
say
my
little
java
application.
We're
using
quark
is
in
this
case
I'm
gonna.
Basically,
then
say:
I
want
to
bring
them
into
terminal
and
I'm
gonna.
Basically,
do
this
maven
compile.
B
Work
instead,
just
put
it
into
the
live
dev
mode.
So
for
you,
if
you
are
a
no
gas
person
watching
right
now,
this
is
kind
of
where
you
want
to
pay
attention,
because
even
though
I'm
not
using
javascript
I'm
using
Java
like
I,
was
using
javascript,
alright,
so
watch
out
for
this
thing
here,
I'm
gonna
come
over
here
and
say:
let's
go
to
localhost
8080
and
that's
gonna
bring
up
this
web
page.
So
that's
hard.
The
default
thing
out
of
the
box
and
my
guy
and
demo
and
I
have
hello
here.
B
Okay,
so
we
got
hello.
One
of
my
good
says
things
say
bonjour
and
you
basically
say
edit
save
refresh
write
edit,
save
refresh
edit
save
refresh
so
there's
Bonjour
I,
don't
like
to
say
in
lo
Hawks
I'm
Ridgeway
from
Hawaii,
so
I'm
Co
edit,
save
refresh
okay.
So
for
our
node
people
here,
you're,
like,
oh,
my
god,
that's
the
way
to
know
it
always
works,
and
first
job
of
people.
B
You
just
spit
out
your
coffee
on
your
computer
because
holy
crap,
that's
a
game-changer
I
respect
that
you
never
seen
anything
like
this
in
the
job
world,
so
I
just
want
to
show
you
that
briefly,
we
don't
have
a
lot
of
time
to
spend
on
it,
but
that's
the
way
we
work
here
in
the
well.
Let
me
actually
have
a
couple
of
things
here,
though,
straining,
let's
see
some
strain
me,
fifty
string,
goats,
name
and
I
want
to
say
just
yep,
B&B
yeah,
yep,
nope
get
or
default
get
or
default.
B
Yet
let's
do
what
we
want
and
yeah.
We
want
to
get
the
hostname
right
and
if
we
don't
have
a
hostname,
let
me
say
it's
unknown
unknown
known
and
little
semicolon.
There
are
Python
people
like
what
what's
the
semicolon
for
I
know:
I
know,
don't
worry
about
it.
Okay,
so
and
we're
gonna
basically
have
our
it
count
a
equal
one,
alright
and
we're
doing
speeding
down
just
make
this
a
little
fun
Brad
the
host
name
and
we'll
have
to
count
go
space.
B
Okay,
our
C
programmers
know
what's
going
on
here.
Alright,
so
well
looks
okay
and
let
me
see
the
fiddle:
let's
go
refresh
it
all
right,
let's
say
refresh:
okay,
unknown,
that's
fine,
fantastic!
Oh,
oh
I
know
what
I
want
to
change.
I
want
to
put
this
on
rich
and
I:
do
need
to
fix
the
tests
because
they're
all
there
are
tests
in
here,
I
just
really
tore
everything
up
and
I'm
gonna
be
a
very
bad
developer
and
remove
all
my
tests
as
an
example.
B
But
now
I
basically
have
my
application
and
what
the
next
step
is.
Is
you
basically
will
come
over
and
say
maven
package
if
you're
a
developer,
maven
package
that'll
get
you
the
application
that
you
need
to
build
things
with
okay
to
build
things
with
or
maybe
run
in
production.
If
you
will
so,
this
creates,
what's
called
an
uber
jar.
Fat
jar
but
in
case
of
corpus,
is
actually
a
thin
jar.
So
you
can
see
here's
my
jar
file,
Java
dash
jar,
Diane
demo,
runner!
Let's
see
this,
you
always
want
to
test
a
little
bit
here.
B
So
there
it
is
curl
localhost
8080,
oh,
oh
I'm,
making
a
steak
and
didn't
make
a
mistake.
Let's
go
back
into
Visual
Studio
code,
so
this
is
what
happens
when
you're
live
hacking.
I
left
this
page
in
here.
I!
Don't
need
that
page!
So,
let's
go
in
here
and
delete
it.
Okay
right
got
rid
of
that
fantastic.
Let's
run
our
package
again,
one
more
time!
Well
done!
B
We
don't
read
the
HTML
page.
We
just
want
the
nice
little
restful
endpoint
there
again,
if
you're,
using
node
or
Python,
it
doesn't
really
matter
all
this
works
the
same
way.
Okay,
so
let's
run
that
one
more
time
bring
that
up
and
now,
if
we
curl
it
all
right,
Aloha
unknown
there,
we
go
fantastic
all
right.
So
that's
what
we
wanted.
So
the
next
step
as
a
developer,
though,
is
you
got
your
code
right
you're
going
to
have
to
feel
of
your
image
so
typically
years,
a
dollar
bill?
B
Okay,
on
your
machine
here
who
I
oh
brother,
Sutter
I,
call
this
the
diam
demo
I
want
to
call
this.
This
call
it
Vegas
for
now,
and
then
there
is
a
doctor
file
that
you
generate
for
you
automatically
of
corpus
this
afternoon,
dr.
Lam
doctor
and
one
stop
at
the
JVM
version.
I'm
gonna
do
my
doctor
bill
okay,
so
that's
you
typically,
your
next
step
is
your
doctor
bill
and
the
next
step
is
your
doctor
Bush.
So
dr.
B
Busch
and
I'm
gonna
push
it
up
the
clay
IO
in
this
case
there
we
go
so
it's
gonna
push
up,
and
so
that's
that
process
of
build
your
code
dr.
bill
doctor
push
pretty
much
is
what
everybody
has
to
do
and
then
you're
gonna
get
that
out
here
and
you
can
find
a
look
at
it
now.
So,
if
I
come
over
here
and
build
a
query,
oh
and
you
kind
of
see
right
there,
okay,
guy
and
amla's
up
there.
Okay.
B
Now
the
next
thing
I
need
to
do
is
have
to
ya,
know
files,
so
I
kind
of
mentioned.
This
is
let's
do
this
is
copy
over
from
another
directory
starter
does
this
is
exactly
what
I
do
I,
basically
coming
here
and
copy
existing
docker
files
live
ready,
yeah?
What's
that
one
copy
that
one
over
and
I'm
gonna
copy
over
the
service?
One
thing:
okay,
so
I
got
to
jump
to
gamble
files.
B
Now,
let's
kind
of
go
check
them
out
back
into
my
little
thing
here:
okay-
and
you
can
see
that
it
has
this-
this
is
the
boot
one
that
that
will
work
a
spring
boot,
but
I
need
to
go
and
modify
it.
I
want
to
modify
it
so
works
for
not
my
boot,
but
make
it
work
for
my
app
about
that.
Something's
gonna
search
a
replace
my
boot
for
my
app
and
replace
them
that
nine
of
those
things
fantastic
and
I'm
gonna
change
this
right
here,
where
it
says
Quay
IO.
B
Now,
instead
of
the
original
enter
name,
and
then
this
was
my
die
and
demo
and
demo
latest
okay
looks
good.
That's
fine
now
noticing
some
things
here
that
are
about
the
deployment
that
we
didn't
have
before
right.
One
I'm
editing
a
yamo
file,
and
this
is
actually
the
more
proper
way
to
do
it
because
you
can
store
this
in
source
control.
Now
I
can
base.
They
say
with
replicas.
I
want
right
on
the
gate.
I
can
say
what
resources
I
think
I
believe
and
request
them.
Accordingly,
I
can
have
hard
limits
as
well.
B
This
is
a
hard
limit.
You
will
get
killed
if
you
build
beyond
the
limit
here.
That's
a
C
group
thing,
but
there's
also
the
lighting
program.
This
probe-
and
let
me
fix
this,
so
it's
actually
on
there-
both
unroot,
keep
it
very
simple
for
now.
Let's
delay
that
two
seconds
the
latest
in
three
seconds.
Okay,
so
you
have
to
be
alive
and
yet
be
ready.
Ready
means
I'm,
ready
for
in
user
mode,
meaning
put
me
in
the
load.
Balancer
send
me
traffic
from
the
user.
B
That's
what
ready
means
live
means
can
I
respond
or
not
respond
at
all.
You
have
to
be
alive
to
be
ready,
so
it
is
kind
of
a
two-step
process,
but
this
one's
very
important
for
us
Java
people
who
tend
to
have
zombie
Java
JVM
processes
where
we
don't
quite
clean
up
our
our
resources
correctly,
and
we
have
these
gbm's
that
are
running,
but
no
one
can
talk
to
them
because
our
we
base
they
sucked
all
the
connections
out
of
connection
pool
yeah.
This
is
what
this
is
good
for,
really
awesome
stuff.
B
So
we
got
our
that
we,
let
me
check
out
a
service.
Oh,
that
looks.
Ok,
let's
see
if
we
did
all
that
right,
so
we
now
we'll
come
over
and
say
you
to
do.
Apply
yes
and
then
someone
watching
right
now,
Drive
is
by
saying
nope.
You
did
it
wrong,
we'll
find
out.
Okay,
so
there's
my
oh
and
I
did
get
something
wrong.
What
did
I
get
wrong?
B
Let's
look
at
my
tags,
yeah
there's
the
latest
one,
and
so
what
you're
gonna
get
a
chance
to
see
now
it's
kind
of
a
piece
of
magic
of
kubernetes,
which
is
it
has
this
concept
of
a
reconciliation
with
them.
In
other
words,
yes,
things
have
gone
badly.
We
broke
it
I
my
demonstration
here,
but
if
we
give
it
a
little
bit
of
time,
it'll
figure
out
that
they
can
fix
it
in
a
way.
B
So
they
keep
trying
to
collect
that
image,
get
it
down
from
Quay
IO
down
to
my
local
cluster
here
and
then
get
my
stuff
running.
So
look
at
that
this
and
notice
says
running,
but
it
says
zero
of
one
notice.
It's
taking
a
little
time
to
go
one
on
one,
that
is
the
liveness
program,
readiness
probe
in
play,
and
so
now
we
have
a
library
pod.
So
let's
actually
go
get
our
server
sucker.
B
My
all
this
thing
is
still
called
my
duty
and
I
changed
it:
hey
King,
City,
I'll,
get
services;
okay,
mini
cube,
IP,
because
I
can't
remember
the
was
if
it's
121
so
yeah,
while
true
dude,
curl,
192,
168,
19
121
in
front
of
3,
1,
5,
4,
H
I.
Think
I
did
that
right.
All
right.
Let's
put
an
extra
echo
in
there
sweet
little
first,
a
little
bit
I'm
done.
B
Then
you
got
right
fantastic,
so
there's
my
application
and
now
I
can
do
all
the
rolling
updates
that
you
saw
earlier
and
have
a
little
fun
with
it
and
I'll.
Even
cheat.
Am
I
rolling
update,
I'm
gonna
come
in
here
as
I'm
cute.
Did
you
edit
deployments?
Okay,
and
then
it's
called
my
app
alright,
let's
go
we're
gonna
gonna
hack
on
it
big
time
here
and
I'm
gonna
actually
switch
back
to
that.
My
group
one
though
it's
causing
me
a
problem.
B
Ok
earlier
giving
me
outages,
it's
in
my
goofy
one
they've
closed
and
let's
watch
what
happens
here.
Okay
notice
is
container,
creating
running
it's
taking
a
little
time,
0
of
1,
because
it's
gotta
pass
the
liveness
check
I'm
reading
this
check
before
my
users
getting
pushed
over
there
and
now
it
says
Aloha
for
spring
boot
and
there
were
no
errors
and
that
cut
over
alright
I
have
done
now
still
the
entire
hour
with
your
time.
B
So
let
me
kind
of
get
back
out
of
here
and
basically
say
you
want
to
get
access
to
the
slide
deck
and
that
walks
you
through
bitly
online
steps.
Awesome.
We
kind
of
cover
a
lot
of
ground
and
all
those
9
steps.
Again.
We
normally
run
three
or
four
hours
for
this
workshop
that
I
just
covered
in
kind
of
one
hour.
Today
the
the
presentation
materials
are
available
to
you
at
the
github
repo
here,
ok,
github
burst
under
9
steps.
B
A
God
that
was
like
a
tour
de
force,
her
and
I
we
I
apologize.
We
have
run
out
of
time
in
terms
of
doing
QA,
I
promise
you
we'll
bring
burr
back
to
do
more
of
this
and
the
rest
of
his
team
as
well,
and
I
really
appreciate
you
spending
the
time
with
us
today.
It
was
awesome
and
you'll
definitely
have
you
back
soon.