►
Description
In this workshop, Edidiong Asikpo (Developer Advocate for Ambassador Labs) shares an overview of Kubernetes through the lens of an application developer. Tune in to learn how to configure your local development environment for Kubernetes using Kind & Kubie, package code into containers and run them on a remote cluster, and improve the coding feedback loop with Telepresence.
Follow along with the demo with the following resources:
Ambassador Cloud account: http://a8r.io/workshop
Free demo cluster: https://www.getambassador.io/docs/telepresence/latest/quick-start/demo-node/
Docker Desktop: https://www.docker.com/products/docker-desktop
A
Good
morning,
good
afternoon
and
good
evening,
everyone
thank
you
for
joining
us
today
for
our
introduction
to
kubernetes
workshop
with
our
very
own
kubernetes
expert
eddie
young
assetpo,
joining
us
today
as
well,
are
also
daniel,
bryant
and
cindy
mullins
from
ambassador
labs.
Please
join
our
developer
learning
center
slack
channel
where
daniel
and
cindy
will
be
able
to
answer
any
of
your
questions
throughout
the
workshop,
and
please
create
your
free
ambassador
cloud
account
to
follow
didion
as
she
walks
you
through
how
to
get
hands-on
with
kubernetes
tools
to
improve
your
workflow.
B
C
C
C
There
are
a
couple
of
requirements,
we'd
love
for
you
to
have
in
this
workshop
in
order
to
follow
every
single
thing
that
I'm
going
to
be
covering.
You
need
to
have
docker
installed
on
your
computer
and
also
keep
ctl
so,
like
I
mentioned
click
on
this
slide,
and
then
you
can
either
google
how
to
install
docker.
I
could
just
click
on
this
link
here,
which
would
take
you
to
the
exact
website
to
install
docker,
and
then
you
also
need
to
have
an
ambassador
cloud
account
we're
going
to
be
talking
about
a
session.
C
We
will
show
you
how
to
improve
your
coding
feedback
loop
with
telepresence,
and
that
requires
having
an
ambassador
cloud
account.
So
if
you
don't
have
one,
please
go
ahead
and
create
it
so
just
copy
a
link
to
the
to
create
an
ambassador
cloud
account.
Oh
yeah
nimra
has
already
added
that.
Thank
you
all
right,
so
go
ahead
and
create
the
ambassador
cloud
account
and
also
ensure
that
you
have
docker
installed
on
your
computer.
C
I
know
I
literally
just
said
we
should
jump
right
into
it,
but
I
believe
it
would
be
beneficial
for
me
to
explain
the
meaning
of
kubernetes
using
this
flow
rather
than
just
defining
what
kubernetes
is
on
a
very
high
level.
Building
cloud
native
applications
follow
these
formats,
where
you
have
to,
of
course,
choose
your
preferred
programming
language
to
write
that
application.
C
It's
like
writing
the
code
of
the
application
and
then
containerizing
that
application
by
so
that
it's
so
when
you
customize
an
application,
it
basically
helps
it
become
runnable
on
any
environment
and
the
way
to
do
that
is
by
creating
a
container
image.
So
what
is
the
current
container
image
you
may
act?
A
container
image
is
a
read-only
version
of
an
application
that
is
used
to
create
a
running
container,
so
it
contains
every
single
thing
that
that
application
needs
to
run.
C
So,
let's
assume
you
have
a
react,
a
react
app
that
you've
just
built
whatever
it
is
that
you
needed
that
the
react
had
needed
to
work
directly
on
your
computer.
A
container
image
would
have
all
of
those
resources
as
well.
The
code
shows
the
runtime
every
single
thing
and
then,
when
you
create
a
running
container
based
on
that
container
image,
you
can
now
run
it
on
any
environments.
Me
not
mac
os.
It
doesn't
really
matter.
So
that's
those
are
like
some
of
the
benefits
of
having
containerized
applications.
C
So
after
you've
created
this
container
image,
you
can
then
push
into
a
registry
like
docker,
hub
or
quay
by
red
hat
first
before
using
that
container
image
to
create
the
running
container
or
you
could
just
like
go
straight
up
to
creating
a
running
container
of
based
on
that
container
image.
So
now,
let's
assume
you
have
like
tons
of
tons
of
containers
running
right
and
people
can
now
assess
your
application.
C
C
And
I
mean
this
can
be
okay,
if
you
were
already
on
your
computer,
so
let's
say
we're
working
and
then
just
getting
a
lats.
Something
is
going
on,
so
you
can
go
and
fix
it
right,
but
imagine
if
you're
watching
it's
an
interesting
movie
on
netflix
or
if
you're
a
marvel
funny
watching
spider-man.
That
recently
came
out.
Let's
say
you're
playing
football
or
doing
something
you
find
interesting.
You'd
have
to
stop
doing
that
thing
and
then
run
back
to
your
computer
to
fix
the
issue,
and
you
think
about
this.
This
is
not
efficient.
C
What
if
you
were
sleeping-
and
you
are
not
aware
about
this
error
until
you
wake
up-
it
means
that
let's
say
10
000
people
are
trying
to
assess
your
application.
Can
no
longer
do
that
anymore,
and
this
is
where
netiz
comes
in.
So
kubernetes
is
a
container
orchestrator
that
helps
you
automate,
deploy
scale
and
manage
containerized
applications.
So
if
one
of
your
container
goes
down,
for
instance,
kubernetes
can
help
you
spin
that
container
back
up
again
or
if
one
of
your
containers
doesn't
follow,
the
health
check
is
set
up
for
it.
C
Kubernetes
can
stop
sending
traffic
to
that
container
and
only
start
sending
traffic
to
it
when
it's
not
following
the
health
checks
that
you've
set
up
for
it.
So
in
essence,
kubernetes
basically
helps
you
manage
your
containerized
applications
you're
like
okay
kubernetes.
I
need
you
to
do
this
and
you
need
to
do
that.
It's
like,
and
that's
all
just
tell
you
what
you
need
to
do
and
you
go
and
sleep
then
watch
your
movie.
C
So
if
the
explanation
I
just
shared
in
the
previous
slide
did
not
make
sense
for
you,
I
mean
there
is
this
myth
that
understanding
humanities
can
be
quite
hard,
so
if
that
first
part
did
not
make
sense
for
you
it's
cool,
but
then
I
I
hope-
and
I
think
that
this
example
would
actually
give
you
that
aha
moment
about
what
kubernetes
is
so
this
is
the
barcelona
team.
Oh
messi
used
to
be
this
team,
but
it's
no
longer
on
this
team
anymore.
So
I
should.
I
should
definitely
update
this
like
but
anyway.
C
So
this
is
my
favorite
football
club
right.
If
you're
listening
to
this
workshop
from
north
america
probably
know
this
as
a
soccer
team.
So
if
I
say
football,
I'm
actually
referring
to
soccer
and
if
I
say
stock,
I'm
actually
referring
to
football
or
I
could
just
say
football
and
soccer.
So
it
makes
sense,
so
this
is
a
football
or
soccer
team,
and
usually
these
football
teams
have
like
11
players
at
a
coach
right
and
what
this
coach
does.
Is
it
manages
these
different
11
players?
It
tells
the
players
what
to
do.
C
So
this
coach
kubernetes
now
is
basically
managing
these
11
different
players.
It's
telling
them
what
to
do.
It's
like.
If
anything
happens,
to
any
of
them,
it
takes
it
out
and
spins
up
another
one
or
it
just
stops
using
it
for
a
moment
and
then
brings
it
back
in
so
think
of
the
relationship
between
the
coach
and
the
players
as
kubernetes
and
containerized
applications.
C
So
now
that
you
understand
the
meaning
of
kubernetes
you're,
probably
wondering
okay
yeah.
Why
do
I
really
need
to
know
about
this,
and
how
can
it
actually
help
me
code
and
ship
faster?
And,
to
be
honest,
I
do
not
blame
you
at
all,
because
the
goal
of
every
developer
is
to
quickly
shift
code
as
fast
as
possible
to
their
end
users.
So
I'm
going
to
quickly
explain
that
here.
C
So
previously
the
developer
experience
or
the
first
cycle
is
to
be
different,
but
then
right
now,
thanks
to
kubernetes
and
micro
services
in
general,
the
life
cycle
of
building
applications
have
changed
because
developers
are
not
involved
in
like
the
testing,
the
development
and
the
shipping
as
well.
It's
no
longer
here
write
the
code,
send
it
to
someone
to
ship
it
developers
are
not
actively
involved
in
that
whole
full
lifecycle
of
an
application,
and
because
this
aspect
of
the
lifecycle
has
shifted
the
way
software
ships
are
shifted
as
well.
C
So
development
teams
now
have
the
ability
to
code
and
ship
faster
with
kubernetes,
because
it
provides
new
and
incremental
ways
that
support
increasingly
or
incrementally
shipping
new
resources
or
new,
let's
see
like
features,
for
instance,
to
end
users,
unlike
those
days
where
you
have
to
take
an
entire
month
to
ship
something.
It's
no
longer
like
that.
Thanks
to
microservices
and
kubernetes,
you
can
ship
new
features
to
your
end
users
weekly
daily.
Whatever
your
team
wants,
you
can
definitely
use
kubernetes
to
do
all
of
that.
C
So
far,
we've
covered
the
meaning
of
kubernetes,
and
we've
also
highlighted
how
kubernetes
can
help
you
codenship
faster.
So
in
this
section
we'll
be
covering
some
of
the
basic
concepts
of
kubernetes,
and
these
concepts
are
things
that
you
definitely
need
to
know
to
be
in
the
kubernetes
space
and
to
also
kick
start,
the
kubernetes
journey,
so
the
first
one
we'll
be
covering
here
is
the
ports.
C
So,
let's
take
a
step
back
right.
Remember
when
I
was
explaining
the
high
level
overview
of
cognitive
applications.
I
said
you
had
to
use
a
preferred
programming
language
to
write
that
write
the
code
for
that
application
and
then
he
had
to
like
containerize
the
application
and
then
deploy
it
into
kubernetes,
which
would
now
be
in
charge
of
orchestrating
those
different
containerized
applications.
However,
one
thing
I
did
mention
was
that,
in
order
for
a
container
to
be
deployed
into
kubernetes
needed
to
be
wrapped
around
the
port
for
that
to
happen,
so
what
is
the
port?
C
That's
that's!
Let's
use
this
example.
Imagine
if
you
wanted
to
send
your
friend
in
a
different
country
or
maybe
a
different
state.
No,
I
think
country
yeah,
but
you
want
to
send
a
snickers
to
your
friend
in
a
different
country.
Let's
say
you're
staying
in
the
u.s
and
your
friend
is
staying
in
the
uk.
What
you'd
I
really
do
is
package
that
sneakers
inside
the
box
take
it
to
a
shipping
company
who
would
then
put
it
in
a
shipping
container
and
take
it
to
your
friend
so
now.
C
Imagine
that
that
sneakers
is
the
code
and
putting
it
inside
the
box.
Is
you
containerizing
it
and
then,
in
order
for
you
to
reach
your
your
friend
in
this
case,
in
order
for
it
to
be
deployed
into
kubernetes,
you
need
to
pass
it
through,
something
which
is
the
pod.
But
in
your
friend's
case
it
was
a
shipping
container,
so
the
you
can
think
of
pods
as
containers
of
containers.
Remember,
first
of
all,
you
build
this
application.
C
You
containerize
it
yeah
in
order
for
it
to
be
deployed
into
kubernetes,
it
needed
to
wrap
around
something
again
called
the
prod.
So
that's
why
we
like
to
think
of
ports
as
containers
for
the
actual
containers,
which
is
the
containerized
applications
and
again
this
port
right
when,
when,
when
a
pod
is
deployed
into
kubernetes,
it's
being
hosted
on
something
called
a
node
right
and
in
the
world
of
kubernetes,
a
node
can
either
be
a
physical
or
virtual
machine
with
a
giving
row
with
a
given
row.
C
So
I'm
going
to
explain
more
about
that
in
next
slides
about
the
given
role
that
nodes
can
have
in
the
next
slide.
But
before
I
do
that
there
are
a
couple
of
commands
we're
running
during
this
workshop
and
what
we
did
was
we
compiled
those
different
commands
into
this
cheat
sheet.
So
if
you
have
access
to
the
slide,
I
think
number
shared
it
in
the
in
the
chat.
C
If
you
click
on
the
slide,
you'll
be
able
to
access
these
cheat
sheets
right
and
if
there's
any
points
where
you
get
lost
or
can't
really
quickly
pick
up
the
commands
that
I
wrote
down,
you
can
just
copy
that
command
here
and
run
it
directly
on
your
on
your
computer.
So
if
you
have
access
to
this
slide,
which
I
hope
that
everyone
does
please
click
on
these
cheat
sheets
because
we'll
be
running
most
comments
very
soon.
C
This
is
not
just
the
a
theoretical
talk,
we'll
be
actually
going
hands-on
with
kubernetes
in
a
couple
of
minutes,
so
do
well
to
click
on
that
link
all
right
cool,
let's
move
on
so
yeah.
Remember,
I
told
you
that
nodes
can
either
be
a
physical
or
virtual
machine
with
a
given
row.
Right,
don't
forget
that
and
then
a
combination
of
these
different
nodes
are
more
like
a
collection
of
these
nodes
is
what
makes
up
a
cluster
and
back
to
not
having
different
roles.
C
Is
that
in
a
cluster
there
are
different
nodes
that
are
centered
around
doing
different
things.
For
instance,
we
have
the
master
node,
which
is
collectively
known
as
the
control
plane,
which
is
responsible
for
managing
the
cluster.
Then
we
also
have
the
worker
nodes,
which
is
collectively
known
as
data
plane,
which
is
responsible
for
running
the
clusters,
workflow,
which
is
the
containerized
applications.
So
remember,
we
said
that
the
nodes
are
placed
on
sorry.
C
So
let's
look
at
this
quick
illustration
of
the
cuban
nexus
crosstalk
I've
just
explained
in
the
previous
slide.
You
can
see
that
the
masternode
and
control
plane
has
different
components
that
enable
you
to
control
the
entire
cluster,
and
then
we
also
have
the
worker
nodes
as
well,
which
also
has
three
different
components
that
help
you
to
perform
the
different
instructions
that
is
being
given
to
by
the
control
plane.
C
So,
in
an
ideal
situation,
if
you
wanted
to
deploy
a
container
into
kubernetes,
you'd
make
an
api
call
using
the
chip
ctl
command,
which
we'll
be
using
in
a
couple
of
seconds,
and
then
that
call
goes
to
the
cube
api
server.
Basically
saying
hey,
I
want
to
put
this
container
inside
this
kubernetes
cluster.
They
keep
api
server,
then
speak
to
the
cube
schedule
and
tells,
and
then
shadows
that
port
to
an
available
node
on
the
cubelet.
So
this
is
like
an
a
quick
overview
of
how
it
works
internally.
C
There
are
a
couple
of
things
here,
like
the
cloud
control
manager,
the
cube
control
manager
that
we
won't
be
covering
in
this
workshop,
but
we're
going
to
publish
an
article
in
some
later
today
on
our
blog,
a
blog
that
gets
ambassador.
I
o,
where
we
detail,
basically
explain
what
the
kubernetes
architecture
is
so
do
check
it
out
to
learn
more
about
these
different
components
of
the
kubernetes
cluster.
C
C
I
just
want
node
inside
the
cluster,
but
that's
not
true
kubernetes
gives
you
the
opportunity
to
have
as
many
as
possible,
so
this
diagram
represents
two
containers
inside
a
port
and
two
ports
inside
a
node.
Then
this
is
three
containers
inside
the
port
and
then
two
points
inside
it
could
be
more
than
this.
But
then
it's
advisable
to
do
things
based
on
what
your
team
is
looking
for,
based
on
what
you
want,
the
collective
application
to
actually
achieve,
but
this
is
just
the
pointer
that
it
doesn't
have
to
follow
this
flow.
C
You
could
have
more
than
one
code
inside
the
node
and
more
than
one
container
inside
the
port
awesome.
So
let's
quickly
go
to
our
terminal
to
see
how
we
can
actually
see
the
number
of
nodes
we
have
in
the
camera.
Let's
cluster,
like
I
mentioned,
every
single
command.
We're
running
in
this
workshop
is
included
in
the
cheat
sheet
that
I
shared
earlier.
So
if
I
go
to
my
terminal,
what
I
run
is
keep
ctl
gets
nodes,
and
what
that
would
do
is
push
this
out.
C
C
So
we're
looking
at
namespaces
right
namespaces
is
another
concept
that
is
very
important
to
understand
in
kubernetes
and
basically
what
it
does
is.
It
enables
you
to
have
like
a
sub
cluster
inside
one
foster,
so
imagine
that
it
so
imagine
that
we're
like
five
people
in
the
team
right
and
we're
all
using
a
kubernetes
cluster,
we're
like
a
small
team,
we're
still
trying
to
like
raise
the
first
series
of
money,
so
we're
basically
still
trying
to
like
manage
stuff
right,
so
we're
using
one
cluster
and
then
we
do
not
want.
So.
C
Let's
say
I
mean
like
the
front
end
t
and
then
the
sonos
in
the
backend
team.
We
don't
want
someone
who
is
doing
something
in
the
backend
team
to
affect
the
members
of
the
frontend
team.
So
what
you
do
now
is
create
a
namespace
that
is
focused
on
certain
people,
so
this
namespace
could
be
for,
let's
say,
ambassador
and
then
the
other
one
could
be
like
for
front
end.
C
So
if
I
don't
have
access
to
the
front-end
namespace,
then
it
means
that
I
can't
do
anything
inside
our
namespace
and
would
also
not
be
able
to
affect
whatever
another
team
is
doing
so
namespaces,
basically
give
you
an
opportunity
to
do
whatever
I
want
to
do
in
the
kubernetes
cluster,
without
the
fear
of
affecting
people
in,
but
without
the
fear
of
expecting
people
that
are
using
the
cluster
as
well.
So
if
you
wanted
to
see
the
namespaces,
you
have
available,
your
kubernetes
foster
you're,
going
to
run
and
quickly
minimize
this.
C
Keep
ctl
gets
named
spaces
and
what
that
would
do
is
show
you
the
defending
species
available
in
the
cluster.
As
you
can
see,
we
have
the
default
name
space,
the
chip
node
its
name,
space,
q,
public
and
keep
system.
This
ambassador
name
spaces,
namespace
that
I
created
by
myself,
but
the
default
namespace
comes
naturally
with
kubernetes.
So
if
there
is
any
object
that
you
create,
I
do
not
specify
where
you
want.
C
C
And
then
we
have
something
called
context,
so
the
context
in
cubanet
is
basically
a
way
to
like
for
people
to
have
or
like
have
access
to
like
a
namespace
and
a
cluster
and
a
user
at
one
time.
So,
if
I
wanted
to
see,
if
I
wanted
to
so,
let's
assume
you're
trying
to
make
changes
to
like
your
code
base
right
and
then
you're
working
in
like
the
test
environment
with
context,
you
can
easily
know
that.
Oh
hey!
This
is
the
test
environment
and
this
is
the
production
environment.
C
So
I'm
going
to
show
you
quick
examples
or
like
practical
examples
of
how
that
would
work.
So
you
actually
see
it
in
person
when
we
move
to
the
session
where
we
install
qb
and
kind
so
you'd
see
how
this
context
can
be
very
useful
visually.
So
if
I
wanted
to
look
at
the
context
in
kubernetes,
what
we'll
do
is,
let
me
quickly
go
to
this
go
to
do
keep
ctl,
config,
sorry
and
then
get
con
text.
C
So
what
this
will
do
is
show
me
the
defense
context
that
I
have
running
on
this
namespace
right.
So
you
can
see
docker
desktop
kind.
Human
nurses
workshop
kindling,
kubernetes
intro,
and
you
can
see
the
different
clusters
that
is
part
of
and
the
authentication
information
for,
each
of
them
and
ryan.
I
can
see
that
this
aesthetic
sign
shows
that
I
am
in
the
darker
desktop
context.
C
So
now
that
I
switched
to
that,
let's
try
to
see
what
frost
what
context
we
are
on
now.
So,
as
you
can
see,
the
aesthetic
sign
I
was
previously
showing
on
the
docker
desktop
context
is
now
showing
on
the
kind
kubernetes
intro
context,
meaning
that
every
single
cube,
ctl
command
I
run
here,
would
be
targeted
at
this
context
and
no
longer
the
docker
desktop
context
that
I
was
originally
in
so
to
test
that
right.
Let's
try
to
see
check
the
namespaces
in
this
context.
C
Remember
when
we
checked
the
namespaces
here
we
were
in
the
docker
desktop
context,
so
you
could
see
the
ambassador
default
cube,
node
and
the
rest
of
them.
So
it
wants
to
do
that
again
in
this
yeah.
In
this
context,
you
see
that
it's
different,
so
here
you
can
no
longer
see
the
ambassador
namespace
in
this
context,
because
it's
not
there.
So
I
don't
think
that
makes
sense.
So
if
you,
if
you're,
if
you're
other
certain
things
to
this
context,
you're
only
using
this
context,
other
people
cannot
access
it.
C
So
because
I
have
switched
to
the
juventus
intro
context
now
the
namespace
that
I
created
in
the
docker
desktop
context
is
no
longer
visible,
meaning
that
nobody
else
can
access
it,
even
though
we
are
probably
all
in
the
same
cluster.
So
let's,
let's
quickly
switch
back
to
docker,
desktop
to
continue
so
switch
back
to
docker,
desktop.
C
C
So
as
a
developer,
you
probably
had
deployment
I've
been
able
to
deploy
these
things
to
the
cloud
or
whatever,
but
then
in
kubernetes
it's
a
lot.
Different
deployments
are
basically
way
for
you
to
describe
or
define
how
you
want
the
kubernetes
object
to
look
like
describing
the
specifications
of
that
object
and
how
you
want
kubernetes
to
manage
those
objects.
So,
let's
quickly
look
at
a
deployment
file
an
example
of
the
deployment
file.
C
So
if
you
click
on
that
link
would
access
the
emoji
voter
application,
which
will
be
using
later
on
in
this
course
in
this
workshop.
But
this
is
an
application
that
has
three
services:
the
emoji
go
to
web
service,
the
emoji
bottle
emoji
service
and
the
emoji
bottle
voting
service.
Of
course,
this
is
a
very
simple
cloud
native
application.
Most
cognitive
applications
have
lots
more
services
than
that,
but
this
is
just
a
demo
right
so
to
see
the
deployment
file,
click
on
customize
and
then
click
on
deployment.
C
So
let's
click
on
one
of
them
emoji.yaml
and
another
thing
to
note
that
deployments
files
are
usually
written
in
yammer.
So
this
is
like
that's
why
you
can
see
emoji.yaml,
because
it's
like
written
in
the
ml
format,
so
you
can
see
the
different
specifications,
they're,
basically
saying
hey.
This
is
what
I
want.
This
particular
object
object
to
look
like,
of
course
you
won't
understand
every
single
thing
here
yet
because
we've
not
covered
most
of
it,
but
all
the
things
we've
covered
here
are,
for
instance,
the
namespace.
C
So
now
because
I've
specified
what
namespace
I
want
when
this
deployment
is
created,
it
would
only
be
available
in
the
emoji
returning
space.
If
I
had
not
provided
it,
it
would
have
been
put
into
the
default
name
space
and
then
another
thing
we've
also
covered
is
so,
for
instance,
the
specifications
right.
C
So
the
replicas
here
is
basically
saying
I
want
only
one
replica
of
this
deployment
of
this
deployment
right
and
then
there
are
a
couple
of
other
really
interesting
information
like
the
services,
the
name
of
the
of
the
deployments,
the
metadata,
the
spec
and
the
pot,
all
of
which
are
things
will
not
cover
in
this
workshop.
But
then
it's
just
I'm
showing
you
this
so
that
you
have
an
idea
of
what
a
deployment
file
looks
like
in
kubernetes
right.
C
D
C
C
C
So
now
that
we're
all
set
with
that
knowledge,
we
need
to
actually
dive
deep
into
setting
up
our
own
kubernetes
cluster
in
our
computer
and
just
testing
around
to
see
how
we
can
actually
use
it
so
to
do
that,
we're
going
to
be
using
this
tool
called
kind
to
create
a
kubernetes
cluster.
So
again,
I
hope
that
you
have
access
to
the
slide,
so
you
can
click
on
this
link
while
I'm
doing
it.
C
So
I'm
going
to
click
on
this,
which
will
take
me
to
the
official
kind
website,
so
kind
is
an
acronym
for
kubernetes
in
docker,
and
this
also
basically
means
that
you
need
to
have
docker
installed
on
your
computer
in
order
to
be
able
to
use
kind.
Another
important
thing
to
point
out
here
is,
if
you've
been
in
the
kubernetes
ecosystem
for
quite
some
time.
You've
probably
heard
that
kubernetes
is
about
duplicating
dockashim
and
then
I
think,
there's
like
a
lot
of
confusion
around
that
people
think
it's
actually
docker
itself,
but
then
it's
not
right.
C
So
it
means
that
you
can
actually
still
be
using
docker
and
kind.
Would
not.
I
mean
the
deportation
does
not
affect
kind
in
any
way,
meaning
that
I
can
still
use
this
so
after
this
session
to
create
your
kubernetes
cluster.
So
first
we
need
to
do
is
install
kind
into
our
local
machine,
so
I'll
click
on
quick
and
that
then
click
on
the
installation
bits.
And
then
you
see
different
ways
to
install
kind
into
your
computer,
I'm
using
a
mac
os.
C
I'm
definitely
going
to
use
the
this
bits
brew,
install
kind
I
brew
is
like
my
most
preferred
package
manager
but
feel
free
to
use
whatever
you
prefer.
So
if
you
copy
that
command,
you
go
to
your
terminal
and
if
you
click
clear
my
screen,
let
me
just
give
you
that
and
then,
if
I
want
to
install
kind,
because
I
already
have
kind
installed
on
my
computer,
it's
pretty
much
going
to
install
reinstall
brew
or
like
updating
it.
And
then
let
me
know
that
I
have
kind
installed
on
my
computer
already.
C
C
C
C
All
right
cool,
so
I
can
see
that
two
people
have
installed
it.
Yes,
I'll
just
I'll
just
go
ahead
again.
We
have
these
cheat
sheets
available.
So
if
you've
not
been
able
to
install
or
follow
along
with
some
of
the
commands,
we've
run
already
just
go
to
that
cheat
sheets
copy
links,
copy
the
command
and
run
it
directly
on
your
on
your
terminal,
all
right
cool.
We
have
about
three
people
so
go
ahead,
then
I'm
using
it.
Yes,
yes,
so
I
can
see
a
question
I'm
using
the
kubernetes
that
comes
with
docker
desktop.
C
Yes,
that's
perfectly!
Okay!
Yes!
So
for
people
who
don't
know
when
you
install
docker
into
your
computer,
what
you
need
to
do
to
enable
kubernetes
is
go
to
me.
Expand
this
go
to
zoom,
hasbro,
stuff,
okay,
go
go
to
the
settings
button
and
then
click
on
kubernetes
and
then
enable
kubernetes.
So
once
you've
enabled
this,
it
means
you
don't
have
to
like
install
kubernetes
again
directly.
Docker
desktop.
Has
that
enabled
for
you.
C
So
if
you
have
not
done
that,
yet,
please
check
it
out
all
right,
cool
I've
seen
that
we
have
like
about
five
people
who
have
installed,
which
is
absolutely
perfect,
because
someone
needs
the
cheat
sheets.
Please
danielle
and
name
wrap
to
share
the
cheat
sheet
with
person
all
right
cool.
So
I
will
just
go
ahead.
I
can
see
that
a
couple
of
web
installed,
so
let's
go
ahead
so
now
that
we
have
kind
installed
on
our
computer.
The
next
thing
we
want
to
do
is
actually
create
the
cluster.
C
Remember
we're
trying
to
make
our
computer
be
able
to
run
kubernetes
or
have
like
all
the
instruments
or
things
we
need
to
run
kubernetes
successfully,
so
we're
going
to
quickly
scroll
down
to
the
creating
a
cluster
bit
and
just
like
this
sentence
here,
says
creating
a
humanities
cluster
with
kind
it's
as
simple
as
using
kind
quit
cluster.
That's
that's!
That's
it!
So
if
you
copy
that
command
and
run
it
on
your
computer,
it's
going
to
create
a
kubernetes
cluster
named
kind.
C
C
Sorry,
if
you
see
me
moving
around
my
screen,
I'm
trying
to
move
this
zoom
all
right.
I
just
moved
it
away.
So
let
me
quickly
clear
my
screen,
so
we
go
back
to
the
top,
then
what
I
want
to
run
now
is
kind
create
cluster
and,
like
I
mentioned,
if
you
just
run
this
command,
that
is
going
to
create
a
kubernetes
cluster
named
kind.
So,
if
you're
comfortable
with
that,
then
you
can
run
this.
C
But
if
you
want
to
give
you
the
specific
name,
let's
see
intro
to
keyboard
method,
because
you're
learning
about
kubernetes
noun,
or
maybe
your
name
or
whatever
it
is
you
want
to
name
it.
You
can
add
the
dash
dash
name
flag
and
then
include
that.
So
in
my
case,
I
already
have
a
kind
cluster
which
is
named
in
sorry,
which
is
named
kubernetes
intro.
C
We
did
not
creating
super
quickly,
but
then
I'm
going
to
wait
for
a
couple
of
seconds
for
every
other
person
to
create
their
cluster,
so
I'll
just
check
the
chat
again.
If
there's
anybody
that's
been
able
to
create
it.
Please
notify
me
in
the
chat
like
a
couple
of
people,
two
three
people
and
then
we
should
be
ready
to
move
forward.
I
just
want
to
be
sure
that
there's
someone
actually
following
along
with
what
we're
doing
hold
on
okay,
so,
like
I
mentioned,
run
the
kind
create
cluster
command.
C
If
you
want
to
give
it
a
specific
name,
then
ask
the
dash
dash
name
flag
and
then
the
name
of
that
you
made
me
want
to
give
the
crosstalk
pretty
much.
Also,
I've
seen
that
one
person
is
done,
so
I
will
go
ahead
and
continue
now,
so
we
keep
the
time
all
right,
cool,
so
yeah.
I
hope
that's.
The
second
question:
is
it
okay,
all
right
cool
similar
to
people
that
are
done
with
installing
this
all
right
cool?
C
So
now
that
we
have
the
kind
cluster
ready,
it
means
that
we
can
now,
let's
say,
containerize
our
application
and
then
run
them
into
into
kubernetes
right.
Remember.
We
said
that
when
you
have
a
containerized
application,
I
want
to
deploy
into
kubernetes
it's
wrapped
around
the
port,
which
is
then
placed
in
a
node,
and
a
collection
of
this
node
is
what
makes
up
victimizes
cluster
so
meaning
that
you
need
to
have
a
kubernetes
cluster
for
you
to
be
able
to
even
deploy
or
push
the
container
inside
kubernetes.
C
So
now
that
we
have
created
this
combinator's
cluster,
the
next
thing
we
want
to
do
is
make
it
a
bit
more
easy
for
us
to
easily
switch
between
context.
Remember
when
we,
when
we
talked
about
context
gear
and
how
to
switch
between
content,
we
had
to
run
keep
ctl
config
get
context,
which
is
great,
not
a
lot
of
love
works,
but
then
there's
actually
a
way
to
make
it
much
better.
So
that's
what
we're
going
to
do
we're
going
to
be
using
this
tool
called
qb.
C
So
click
on
this
link,
if
you
have
access
to
the
slide
click
on
set
up
your
see,
I
like
to
use
qb
for
context
switching
and
then,
if
you
click
on
that
you're
going
to
access
the
github
repository
for
this
tool.
So
kiwi
is
an
alternative
to
keep
ctx
and
then
what
it
does
is
it
gives
you
a
better
experience
when
it
comes
to
context,
switching
namespace,
switching
and
couple
of
other
things,
so
we're
going
to
see
how
it
works
in
reality.
C
To
do
that,
you
need
to
install
it,
of
course,
so
I'll
click
on
installation
and
use
my
favorite
package
manager,
which
is
blue,
feel
free
to
use
mac,
pods
nyx,
whichever
platform
you're
using
you're,
going
to
see
an
option
for
all
of
that
here.
But
since
I'm
using
a
mac,
os
and
reworks
with
that,
I'm
going
to
copy
this
command
go
back
to
my
terminal
and
then
run
that
what
this
is
going
to
do
is
install
brew
into
my
computer,
so
give
that
a
few
minutes
and
we
should
be
ready
to
move
ahead
all
right.
C
It's
installing,
hey,
okay,
that
was
fast,
all
right
cool.
So
now
that
we
have
qb
installed,
let's,
let's
actually
test
it
out
and
see
if
it's
any
improvements
from
having
to
do
keep
ctl
config
get
context.
So,
let's
scroll
down
to
the
usage
bit-
and
you
see
that
in
order
for
you
to
check
the
available
context,
you
need
to
run
qb
ctx.
C
So
let's
try
to
do
that.
Oh
sorry,
that
didn't
copy
I'm
just
stuck
with
it
myself,
qb
ctx
there
you
can
see
now
that
we've
been
able
to
see
the
different
context
available
in
the
computer.
Remember
we
were
using
the
actual
kubernetes
b2
would
have
been
cube.
Ctl
config
get
contact,
which
is
quite
a
lot
more
worse
than
this,
and
as
even
though
this
seems
like
a
small
thing,
when
you
are
building
bigger
applications,
you
want
to
be
as
fast
as
possible.
C
C
Humanness
is
intro
right,
so
you
can
see
now
that
these
streamers
have
successfully
switched
into
this
particular
context.
Remember
when
I
said
I
was
going
to
show
you
how
useful
context
context
switching
can
be
so,
for
instance,
now
that
you're
using
qb
you
can
easily
see
which
context
you're
on.
So,
if
I
was
on
the
test
context,
for
instance,
I
can
see
that
hey,
I'm
actually
on
the
test
context.
So
there's
no
way
that
my
mind
will
make
me
kind
of
push
it
support
right
when
I'm
actually
test.
C
So
this
can
be
a
great
way
to
keep
you
mentally
aware
of,
where
you're
currently
in
and
prevent
you
from
doing
something
wrong.
So
this
this
is
great
to
be
honest,
but
then
there's
another
way
to
even
do
this.
That
would
make
you
not
have
to
type
any
words
when
you
want
to
switch
between
context
and
that's
to
install
another
tool
called
fzf
which
works
with
qb.
C
Again,
this
would
take
like
a
couple
of
seconds
or
minutes
depending
on
how
fast
the
internet
connection
is,
and
that
would
be
installed.
So,
as
you
can
see,
I
now
have
fcf
installed
on
my
computer,
so
now
watch
the
difference
between
not
having
fzf
not
having
qb
and
just
using
directly
with
keyboard
nexus.
So
if
I
do
qb
ctx
again
now,
you'll
see
that
he
now
shows
me
like
a
ui,
a
better
user
interface.
C
Really-
and
all
I
need
to
do
is
just
like
you
know,
move
up
or
down
to
access
the
particular
context
that
I'm
looking
at,
I
don't
need
to
type
qbctx
and
find
the
name
of
the
contacts
and
paste
it.
So
these
tools
basically
help
you
navigate
through
your
kubernetes
cloud.
Static,
manages
concepts
a
lot
faster.
So
if
I
click
on
docker
desktop,
you
can
see
that
it
has
successfully
switched
me
from
the
humanness
intro
context
to
docker
desktop
contacts
which
in
like
a
couple
of
seconds,
all
right
cool.
C
So
that's
all
all
the
spots
regarding
this,
then,
if
anybody
has
any
questions
or
experienced
any
blocker
here,
I
can
see
that
daniel
is
answering
the
questions.
Thank
you
very
much
and
thank
you
all
for
sharing
those
very
insightful
questions.
So
someone
is
asking:
what
do
you
use
to
see?
Yeah?
Okay,
thanks
for
the
question
that
answered
says:
qb
yeah.
So
if
you
have
qb
installed,
you
can
use
qbns
where
you
don't
have
to
be
installed,
you
can
use
cube,
ctl
gets
namespaces
and
that
will
work
for
you
as
well.
C
D
C
All
right
cool,
thank
you,
everyone
so
move
to
the
final
bits
before
we
go
for
our
10
minutes
break
and
come
back.
So
in
this
section
remember
when
we
talked
about
the
high
level
overview
according
to
applications,
you
have
to
write
the
code
for
it,
of
course,
and
then
containerize
an
application
and
then
use
kubernetes
to
construct
the
application.
So
in
this
section
we're
actually
going
to
learn
how
to
containerize
an
application
before
we
move
to
the
process
of
deploying
it
into
kubernetes
networks.
So
today
we're
going
to
be
using
docker
right.
C
C
C
Since
the
actual
thing
you
want
here
is
to
just
see
how
docker
works
and
how
to
concentrate
an
application,
so
I'd
recommend
just
getting
the
app
section.
So
I
already
have
this
update
on
my
computer.
So
what
I'm
going
to
do
is
quickly
navigate
into
it.
So
I
did
cd
app,
which
would
take
me
an
app
folder,
I'm
going
to
use
the
vs
code
commander,
integration,
which
is
called
code.
to
open
the
application
on
vs
code.
C
C
All
right
cool
just
be
setting
there
in
case
anyone
is
looking
for
it
all
right.
So
now
that
we
have
that
demo
repository,
what
we
want
to
do
is
create
a
container
image.
Remember
I
told
you
that,
in
order
for
you
to
containerize
an
application,
you
need
to
create
a
container
image
first
and
then
now
use
a
container
image
to
build
or
like
create
a
working,
containerized
application.
So,
in
order
to
do
that,
we're
going
to
be
first
thing
we
need
to
do
is
create
a
docker
file.
C
This
docker
file
will
then
be
used
to
build
that
container
image.
So,
like
I
mentioned
once,
you
have
access
to
your
app
folder
we're
going
to
create
a
file
named
docker
file
and
then,
when
you
do
that
you
copy
the
code
here
and
paste
it
inside
that
docker
file
you
just
created,
so
I
have
that
already
here.
So
you
can
see
this
is
the
app
folder
and
then
I've
created
a
docker
file.
Then
I've
also
copied
and
pasted
the
code
slippers.
C
I
was
available
on
that
quick
start
guide
here
as
well,
and
then
I'm
going
to
quickly
explain
what
all
of
these
things
mean
before
we
build
the
container
image
and
then
eventually
use
it
to
create
a
working
container.
So
the
first
bit
here
is
basically
saying
that
you
want
to
create
this
docker
file
from
the
existing
node
node
image
on
docker
hub.
So
docker
works
with
this
thing
called
alcohol
that
basically
has
thousands
and
millions
of
images
uploaded
by
different
people
across
the
world.
C
So
there
is
actually
a
note
image
there
and
you're
like
saying
I
don't
have
node
on
my
computer,
or
maybe
I
do,
but
I
just
want
to
use
this
specific
one
that
is
available
on
the
docker,
sorry
that
is
available
on
docker
hub
and
then
they
run
commands.
Basically,
I
want
to
run
the
dependencies
in
that
node
image.
That's
available,
then
the
work
directory,
slash
app
here
is
going
to
create
a
directory
in
this.
Your
image
called
app
and
then
move
all
the
code
base
of
your
application
into
it.
C
Whatever
this
application
needed
to
work
on
my
computer,
a
container
image
would
have
all
of
that
information
so
that,
once
I
push
that
container
image
to
docker
hub
or
create
by
red
hat,
anybody
who
runs
that
image
on
their
computer
would
be
able
to
access
this
application
without
having
or
encountering
any
issues
at
all,
and
then
the
one
command
obviously
again
running
these
dependencies
that
you
have
copied
into
the
the
image.
Then
this
is
the
final
command
that
runs.
C
After
all,
the
steps
have
been
completed
and
it's
basically
saying
hey
everything,
looks
good
now
go
ahead
and
start
this
application.
So
now
that
we
have
this
docker
image,
this
docker
file
created
we're
going
to
now
build
the
docker
file
and
to
do
it
we're
going
to
use
the
docker
builder
st
command
and
then
measure
the
name
of
the
what
we
want
to
name
our
image
as
and
then
run
it
in
our
command
line.
C
So
let
me
quickly
minimize
this,
so
it's
easier
to
navigate
and
then
what
we
want
to
do
is
copy
this
command.
Here,
like
I
mentioned,
docker,
build
that
she's,
basically
saying
hey.
This
is
the
tag
I
want
to
give
it.
I
want
to
give
it
getting
started,
meaning
that
I
want
to
name
this
docker
image
getting
started.
Let
me
tell
myself
so
once
you
copy
that
you
go
back
to
your
terminal,
so
take
note
of
this
docker
desktop.
You
can
see
that
we
have
one
two
three,
four,
five,
six,
seven,
oh
one,
two
three
yeah!
C
We
have
seven
different
images
here,
so
we
want
to
create
another
image
and
just
notice
how
that
new
image
we
added
to
docker
desktop
automatically,
so
we'll
go
back
to
our
terminal,
and
then
we
run
this
command
docker
build!
That's
t
getting
started,
which
is
I
want
this
image
container
image
that
I'm
creating
to
be
named
getting
started
it's
going
to
take
well.
That
was
definitely
faster
than
I
expected,
so
for
you
it
might
take
a
little
bit
longer.
It
might
be
very
fast.
C
It
all
depends
on
again
your
internet
connection
and
how
fast
your
computer
is.
So
once
this
image
has
been
created.
The
next
thing
I
need
to
do
is
run
that
image
right
run,
a
more
like
create
a
running
container
based
of
that
container
image.
So
if
you
go
back
to
our,
if
we
go
back
to
our
docker,
I
can
see
that
a
new
file.
So
I
just
there's
like
something
going
on
here
confirm
again.
C
All
right
cool,
so
you
can
see
that
this
has
successfully
been
created.
I
already
had
one
was
created
three
hours
ago
and
that's
why
I
didn't
show
up
there,
but
you
can
see
that
we
have
the
getting
started
and
you
can
see
when
it
was
created.
I
could
also
see
the
image
id
as
well.
So
if
we
go
back
to
the
docker
quickstart
guide,
what
we're
basically
now
going
to
do
is
create
a
running
container
based
on
that
image.
C
So
this
is
docker
run,
which
is
basically
saying,
run
this
image
that
I'm
I'm
assigning
to
it
and
then
the
dash
detach
dash
d
here
basically
means
that
you
want
it
to
run
in
the
background
and
then
dash
p
means
spots,
you're,
saying:
hey,
I'm
mapping
this
between
the
four
spots
of
three
thousand
and
the
container
spot,
which
is
three
thousand
as
well
then
getting
started
here
is
the
name
of
that
container
image.
Remember
we
have
named
our
container
image
here
getting
started.
C
So
if
we
had
named
this
a
dj,
for
instance,
we
would
replace
this
with
integer.
So
if
you
copy
this
and
go
back
to
your
terminal,
we
should
be
able
to
spin
up
this.
Yes,
so
now
that
we've
spin
this
stuff
remember
we're
exposing
this
on
3000.
So
if
we
go
to
localhost
3000
now
we
should
be
able
to
access
that
application.
Yes,
it
is
so
here
it
is.
C
If
I
try
adding
learn
kubernetes,
for
instance,
you
can
see
that
I've
been
able
to
now
run
this
application
directly
on
my
on
my
local
machine.
If
I
have,
if
I
push
this
docker
image
to
docker
hub,
for
instance,
and
share
with
you,
any
single
person
can
just
like
copy
the
docker
image,
use
it
to
create
a
running
container
and
automatically
access
that
application
in
their
local
machine
without
even
having
to
write
it
without
having
to
install
any
single
thing
at
all.
C
So
that's
like
an
example
of
what
are
the
benefits
that
containerization
gives
to
you
yeah.
So
that's
all
we're
covering
in
this
section
we're
definitely
on
time
because
we're
going
on
a
10
minutes
break
after
this.
If
there's
any
question
and
then
we'll
come
back
to
the
next
session,
we'll
be
talking
about
how
to
improve
your
accounting
feedback.
Look
with
telepresence.
C
It's
definitely
going
to
be
a
very
insightful
session
because
it's
like
a
very
important
thing
to
know.
As
someone
who
is
learning
about
kubernetes
or
trying
to
start
a
career
in
the
cloud
native
ecosystem,
so
do
take
this
10
minutes
to
rest
and
drink
a
cup
of
coffee.
We
like
coffee
or
drink
water.
Just
like
hang
around,
we
will
definitely
be
back
in
10
minutes
to
continue
doing
many
parts
of
the
workshop
all
right.
C
So
we've
covered
a
lot
of
stuffs
in
this
workshop
today,
and
we
know
that
this
is
only
lasting
for
two
hours
and
it's
like
a
lot
of
information
going
in.
So
the
goal
here
is
just
to
take
a
deep
breath
like
understand
what
we're
talking
about.
If
you
have
any
questions,
feel
free
to
share
them
in
the
slack
channel
and
we
will
gladly
respond
and
then
we
also
have
a
resource
that
I'm
going
to
share
after
this
workshop.
C
They
could
always
go
back
to
to
really
take
your
time
to
understand
exactly
what
kubernetes
is
and
really
play
around
with
it.
A
lot
a
lot
more
deeper,
so
do
stay
around
till
the
end
of
the
workshop
to
gain
access
to
that
kubernetes
learning
center
that
I'm
going
to
share
all
right.
So
let's
go
ahead
and
kick
start.
C
Users,
however,
committing
and
seeing
the
impact
of
code
changes
in
a
containerized
environment
like
kubernetes
is
not
as
straightforward
or
as
fast
as
it
would
be
in
a
monolithic
environment,
so
in
monolithic
environments
developers
were
able
to
like
and
adopt
certain
frameworks,
tools
and
ides
that
enabled
hot
speed
loading,
but
we
containerized
the
environments
like
kubernetes.
You
have
to
wait
for
the
the
code
to
build
and
then
push
to
a
registry
and
then
deploy
to
like
a
ci
or
production
environment.
C
So
it's
like
it
pretty
much
makes
the
ones
fast
feedback,
that's
a
process
where
we
could
easily
see
what
we've
changed
and
how
it
works
with
the
other
parts
of
the
application,
a
distance
memory
for
people
in
the
cloud
native
space,
so
you're
probably
wondering
how
does
one
still
enjoy
the
benefits
of
using
kubernetes
and
micro
services
right,
while
still
maintaining
a
fast
feedback
loop?
And
the
answer
to
that
question
is
using
a
cncf
sandbox
project
called
telepresence.
Even
though
a
cncf
is
it's.
C
It
stands
for
executive
community
that
basically
manages
and
ensures
that
every
cognitive
product
follows
the
right
part
and
it's
very
useful
for
like
people
in
the
community.
So
we're
going
to
be
talking
a
bit
about
telepresence
today
and
how
you
can
actually
use
it
to
set
up
an
effective
cloud
native,
in-app
development,
loop
and
just
pretty
much.
It
makes
your
development
process
a
lot
faster,
which
in
turn
makes
you
more
productive.
C
So
in
order
to
do
that,
we're
going
to
be
using
the
telepresence
quick
start
guide.
So
if
you
click
on
this
url
here
you'll
be
directed
to
ambassador
cloud.
Let
me
quickly
close
all
of
this
redirected
to
ambassador
cloud.
Remember
at
the
beginning
of
this
session.
We
said
so.
The
prerequisites
for
this
workshop
was
having
docker
installed,
keep
ctl
and
also
having
an
ambassador
cloud
account.
C
So
if
you
don't
have
the
ambassador
caller
account,
please
go
ahead
and
and
and
register
for
one,
and
I
can
also
see
that
nimr
is
adding
links
to
the
free
democrats
that
they
are
supposed
to
get.
So
what
we're
going
to
do
is
so
now
I'm
going
to
sign
into
ambassador
cloud,
so
I'm
going
to
use
my
preferred
method
which
could
either
be
github,
bitslab
or
google,
but
I'll
go
with
github
and
then
what
I'll
do
is
select.
The
team
which
I'll
just
go
ahead
and
select
my
team.
C
All
right
cool,
so
we've
talked
about
the
current
issue
in
the
cognitive
ecosystem
and
how
telepresence
can
help
resolve
that
so
telepresence
is
a
cncf
sandbox
project
like
I
mentioned
that
enables
you
to
connect
your
local
development
environment
to
a
remote
cluster.
So
this
enables
you
code
locally
while
still
running
and
like
it's
almost
like
your
you're
coding,
locally
yeah,
but
then
the
different
services
or
different
other
the
different
services
that
make
up
your
application
can
be
running
in
a
remote
cluster.
So
imagine
if
you
have
like
so
think
of
that
emoji
vote
application.
C
I
showed
you
a
couple
of
minutes
ago.
You
just
had
three
services
and,
like
I
mentioned
that
it's
like
a
very
busy
cloud
native
application,
most
administrations
have
hundreds
and
more
services
right.
So
imagine
if
you
had
to
fix
something
in
one
of
these
100
services
says
you're
working
on
one
service,
so
they're
like
other
99
services,
yeah
and
then
after
you've
fixed
or
made
a
code
change
to
this
particular
service.
You
want
to
be
sure
that
what
you've
changed
has
not
impacted
the
other
services
in
the
application
that
are
probably
communicating
with
it.
C
So
would
you
now
run
all
those
99
services
on
your
computer?
Sometimes
it
can
be
possible,
but
then
it's
very
slow
and
then
other
times
it's
not
even
possible,
because
your
laptop
is
not
capable
or
strong
enough
to
run
that
large
amount
of
services
on
your
computer.
So
what
telepresence
lets
you
do
is
connect
your
local
machine
to
remote
cluster
so
that
even
when
you're
fixing
that
board
you
can
check
or
see
how
that
code
change
you've
made
would
interact
with
the
other
99
services
in
a
remote
cluster.
C
So
that
way
you
still
get
to
enjoy
and
have
the
experience
of
debugging
locally,
even
while
your
services
are
connected
to
remote
cluster.
So
what
we're
going
to
do
to
get
this
up
and
running
is
to
create
a
free,
remote
cluster.
Like
I
mentioned
telepresence
lets,
you
connect
your
local
development
environment
to
a
remote
cluster
using
a
two-way
proxy
mechanism.
C
So
what
we're
going
to
do
now
is
use
ambassador
clouds,
free
wall
cluster,
and
in
order
to
do
that,
you
go
to
ambassador
cloud
sign
in
first
and
then
you
would
be
taken
to
this
section
currently
showing
on
the
screen.
So
I've
just
shared
a
link
to
the
master.com
welcome
page
and
if
you
are
there
and
you
need
to
click
on
get
started,
which
is
this
bit
here
so
once
you
do
that
you're
going
to
see
this
user
interface
and
we're
going
to
now
do
is
click
on
claim
a
free,
kubernetes
cluster.
C
So
you
see
now
that
I've
automatically
claimed
the
free
cluster,
and
that
is
my
demo.
Cluster
is
going
to
be
available
until
9
10
p.m.
My
time,
which
usually
takes
like
three
hours
there
are
about
for
the
cluster
to
expire,
for
you
to
create
another
one.
So
I
want
to
make
sure
that
everybody
has
a
cluster
created
so
if
you've
created
it,
please
indicate
in
the
chat
just
like
we
did
the
previous
time.
So
I
can
have
a
sense
of
how
many
people
have
this
cost
are
available.
C
Cool
cool,
seeing
good
responses
awesome!
Thank
you!
So
again
you
all
you
need
to
do
is
create
an
ambassador
cloud
account
with
the
links.
Name
are
shared
in
the
chat
and
after
you've
done
that
click
claim
a
free,
more
cluster.
Another
clip
nothing
remote.
Cluster
click,
okay,
no
after
you've
created
that
account
go
to
the
get
started,
bits
here
and
then
click
on
play
with
remote
cluster,
which
will
create
that
cluster.
For
you
automatically
all
right,
I've
seen
a
good
number
of
responses.
C
Just
wait
for
like
one
more
minute
to
see
if
we
can
get
more
people
to
join
in
before
we
start.
So,
if
you
are
still
in
the
process,
please
do
it
as
soon
as
you
can
and
let
us
know
all
right
cool,
so
one
more
minute,
one
more
minute
before
we
go
ahead,
just
give
as
many
people
the
opportunity
to
follow
along
with
this
part
of
the
workshop.
C
So
we
have
few
more
seconds
to
go
before
the
minutes
elapses
all
right
cool,
so
we've
had
like.
I
think
I
can
see
over
10
people
saying
that
they've
claimed
their
account.
So
that's
awesome.
If
you
eventually
created
the
process
of
this
workshop,
do
indicate
in
the
chat,
if
you
have
an
issue
at
all
with
this
also
indicates
there
as
well,
and
we
will
happy
to
get
you
up
to
speed
or
like
fix
the
issue
experiencing
so
now
that
you've
claimed
this
frequently
this
cluster.
C
What
I
need
you
to
do
is
click
on
this
application.
So
here
you
see
that
the
emoji
button
application
is
running
your
cluster,
with
the
bug
visits
your
application
and
notice
how
the
emojis
are
randomly
stored.
In
the
next
step,
you
will
update
you
will
update
to
a
new
version
of
the
application
running
locally,
which
has
the
emoji
sorted
alphabetically.
C
So
another
thing
to
mention
is:
if
you
there
is
a
chance
that
you
probably
click
on
this
app,
maybe
depending
on
the
part
you
check,
and
you
see
that
it
has
a
bug
in
the
donut
emoji.
So
a
couple
of
people
may
see
different
parts
of
the
app
but
other
this
file
that
I'm
currently
showing
you.
So
if
you
encounter
that
just
know
that
it's
normal,
it's
not
a
bug.
It's
just
another
experience
to
help.
C
You
understand
how
telepresence
works,
all
right
cool
so
now
I'm
going
to
click
on
this
application,
and
I
hope
that
you're
doing
that
as
well,
and
if
you
do
that,
you
see
that
we
have
different
emojis
on
this
application.
It's
called
the
emoji
vote
application.
So
I
did
you
vote
for
this.
It
will
show
on
the
leaderboard.
If
you
vote
for
the
guy
with
the
cool
glasses,
it
will
show
on
leaderboard
and
then
what
we're
going
to
see
now
is.
C
C
So,
let's
click
on
the
next
click
on
the
next
button,
and
what
this
is
accent
is:
do
you
have
docker
installed
on
your
computer
again,
talks
back
to
where
we
said.
Docker
is
important
not
just
for
running
or
creating
a
kubernetes
for
sniper
for
also,
but
also
for
this
domain
as
well.
So
if
you
have
docker
installed,
you
click.
Yes,
if
you
click
no,
it
would
direct
you
on
how
to
install
docker
on
your
computer.
C
So
now
that
we
have
docker
installed,
you
can
choose
the
current
operating
system
that
you're
using
I'm
using
a
mac
os
I'll
just
copy
the
macros
command.
If
you're
using
a
window,
they
just
need
to
click
on
windows
they're
using
a
linux.
Of
course
you
click
on
linux
and
copy
the
command.
So
if
I
go
back
to
my
terminal
now,
I'm
going
to
so
you
can
see
the
main
branch.
Okay,
let
me
quickly
clear
this
and
then
run
that
command.
C
So
what
this
is
doing
is
in
an
ideal
wall
right.
Imagine
there
was
a
bug
in
your
application,
so
let's
say
the
way
this
application
is
currently
or
that
is
not
how
it's
supposed
to
be
there's
something
wrong
and
you
want
it
to
be
ordered
in
a
different
way.
What
you
do
is
clone
the
repository
of
that
application
and
then
fix
fix
the
bug
test.
That
is
working
with
the
other
services,
push
it
and
then
gets
deployed
to
production
right.
C
But
then
we
don't
want
you
to
go
through
all
of
that
stress
for
this
workshop
over
this
demo.
So
what
we've
done
is
we've
fixed
the
ball
and
then
we
mounted
it
in
a
darker
volume
and
then
what
we're
basically
doing
now
here
is
running
that
document
in
our
in
our
cluster.
So
once
that
is
up
and
running
to
take
a
couple
of
a
couple
of
minutes.
Okay,
it's
been
created,
you'd,
see
down
that
we
are
now
connected
to
the
to
the
remote
cluster
we
had
created.
C
Remember
the
first
thing
we
did
was
create
a
remote
cluster
via
ambassador
labs
and,
like
I
said,
telepresence
lets.
You
connect
your
local
development
environment
to
this
remote
cluster.
So
now,
you've
seen
that
we've
been
able
to
successfully
connect
context
default
to
do
more
cluster
that
we
generated
on
ambassador
cloud.
Keep
in
mind
that
you
don't
have
to
use
ambassador
cloud
to
generate
this
remote
for
start
to
test
it.
It
could
be
a
cluster
that
you're
already
working
with
in
your
company.
C
C
If
we
go
back
to
this
bit,
you
can
see
that
it
says
success.
You've
been
able
to
set
up
your
local
development
environment
and
then,
if
you
click
next,
the
next
thing
we
want
to
do
now
is
create
an
intercept
and,
like
you
can
see
explained
here.
What
we
now
want
to
do
is
temporarily
replace
remote
service
responsible
for
sorting
web
with
the
version
running
in
our
local
container,
so
that
we
can
see
the
new
alphabetical
sorting
of
emojis.
C
So
what
this
is
going
to
do
in,
like
layman's
sense,
is
remember
this
emotive,
this
emotional
type,
because
you're
running
in
a
remote
cluster
has
three
services
right
and
it's
arranged
in
a
certain
alphabetical
order
right.
But
what
we
want
to
do
is
this
is
not
what
we
want
to
what
this
is
a
book.
It's
not
what
our
users
want.
We
want
to
do
something
different,
so
we're
not
going
to
fix
that
book
and
then
what
we're
not
going
to
do
is
temporarily
replace
remote
service.
C
That's
remote
step
is
here
with
the
one
running
our
local
mission
right,
which
we've
just
downloaded
via
this
docker
command,
and
then,
when
we
do
that,
we
can
now
actually
test
to
see
if
these
changes
were
made
would
actually
work
effectively
with
the
other
two
services
in
this
application
without
having
to
like
push
and
pull
and
do
the
whole
like
ci
production,
environment
thing
that
would
have
done
in
a
normal
case.
So
in
order
to
do
that,
we're
going
to
create
an
intercept.
C
So
what
we're
going
to
do
is
select
present
intercept
web,
which
is
the
name
of
the
service
we're
trying
to
temporarily
replace
and
then
we'll
mention
the
port
ones
assessed
to
8080
and
then
the
ingress
as
well
and
the
ingress
spots
as
well.
If,
if
you
don't
add
all
of
these
commands,
you
would
be
shown
like
different
questions
where
you're
supposed
to
answer,
but
all
those
commands
have
been
added
here
directly.
So
what
I'm
going
to
do
is
just
copy
this
and
go
to
my
terminal
and
run
that.
C
It
would
take
a
few
seconds
or
like
a
minute
and
as
soon
as
yeah
awesome
as
soon
as
that
works.
What
we're
now
going
to
do
is
copy
the
preview
that
it's
just
generated
for
us.
We
can
use
this
pvrl
to
actually
see
the
impact
of
our
code
changes
right.
I
don't
think
we
get
so
you're,
not
you
don't
have
to
build
the
container
first,
push
it
to
docker,
deploy
it
to
a
sierra
production
environment.
C
If
you
see
the
code
changes
with
telepresence,
you
can
actually
see
it
before
you
even
have
to
deploy
so
you're,
actually
sure
that
your
code
changes
actually
what
the
way
they're
supposed
to
work
and
if
they
don't,
you
go
back
to
the
drawing
board,
go
back
to
your
code
base
and
fix
it
up
before
you
push
it
to
your
repository.
So
I'm
going
to
copy
this
preview
url
and
go
to
my
browser
and
I'm
going
to
paste
that
and
you'd
see
now
that
this
emoji
application
here
is
ordered
in
a
different
way.
C
Just
give
it
a
few
minutes
awesome
so
previously
in
the
actual
remote
cluster,
you
could
see
that
we
had
laughing
emoji
the
glasses,
the
doughnuts
and
a
couple
of
other
stuff
arranged
from
the
top.
But
then
here
you
can
see.
We
now
have
the
hundred
the
bacon,
the
balloon
boy
playing
football
and
a
couple
of
other
interesting
images.
So
now,
without
doing
too
much,
I've
been
able
to
see
or
like
test
that
the
code
I
have
running
on
my
local
machine
works.
C
Well,
we
did
two
services
in
my
remote
cluster
so
that
way
I
know
how
this
thing
is
going
to
work.
I
have
a
clear
picture
of
if
it's
working
well
or
not,
working
well
before
I
ship
it
to
appreciate
like
a
registry.
Another
interesting
thing
that
telepresence
ambassador.cloud
gives
you
is
you
can
get.
You
can
also
share
this
preview
url
with
your
teammates
or
your
colleagues
or
your
manager.
C
All
right
cool!
Thank
you
very
much
all
right.
So
if
we
go
back
to
ambassador
cloud
following
the
quick
start
guide,
you
see
that
everything
has
been
completed
and
it's
now
saying
that
hey
click
on
this
link
to
access
your
url,
which
is
the
same
link
that
we
generated
on
our
command
line.
So
you
can
either
do
every
single
thing
directly
on
your
command
line
or
you
can
use
the
ambassador
cloud
user
interface
and
a
lot
of
people
like
using
their
cli
and
the
other
people
who,
like
using
uis.
C
So
we
pretty
much
made
it
accessible
for
everybody.
Cli
tickets,
ui
ui
taking
one,
but
they
can
just
like,
enjoy
using
the
mixture
of
both
of
them.
And
then
here
you
click
next.
So
you
can
see
here
your
ambassador
cloud
profile
that
there's
like
the
url
here
and
then
you
can
either
make
this
url
publicly
accessible
or
you
could
unlock
it
and
make
it
only
accessible
to
certain
people
in
your
team.
C
So
if
I
send
this
to,
let's
say
daniel,
for
instance,
you'd
have
to
sign
in
of
course,
because
you
want
everybody
to
be
authenticated,
you
don't
want
your
world
to
land
in
the
wrong
hands
right,
so
you
add-
and
we
add
an
authentication
for
it
to
ensure
that
everybody
who
accesses
your
url
is
properly
authenticated
and
is
actually
the
people
who
are
meant
to
assess
it
all
right.
That's
all
for
this
quick
demo
of
telepresence
ambassador
cloud.
We
do
hope.
I
give
it
a
try.
C
It
definitely
makes
your
whole
development
workflow
a
lot
faster
and
easier,
and
if
you
think
about
it,
instead
of
spending
15
minutes
waiting
for
a
container
to
build
and
be
pushed
to
docker
hub
or
quay,
or
whichever
registry
you're
using
you
can
quickly
use
telepresence
to
intercept
the
service
and
test
with
other
existing
services
to
see
how
they
would
actually
work
together
before
you
push
it
to
github,
and
it's
eventually
deployed
to
production.
For
your
end,
users.
C
Awesome,
the
final
thing
we're
going
to
talking
about
in
this
workshop
is
how
to
perform
continuous
integration
with
github
actions.
Understanding
continuous
integration
is
an
essential
part
of
being
in
the
kubernetes
or
cognitive
ecosystem,
so
we're
going
to
give
quickly
give
a
quick
overview
of
how
continuous
integration
works,
what
it
means
and
how
to
actually
create
a
lightweight
ci
pipeline
with
github
actions.
So,
of
course,
we
need
to
understand
what
exactly
continuous
integration
is.
C
First
right
before
we
dive
deeper
into
it,
and
thankfully
github
has
this
fantastic
explanation
of
continuous
integration
and
before
I
click
on
it,
I
just
wanted
to
mention
that
the
reason
why
we
added
links
to
most
of
these
explanations
is
because
we
want
you
to
have
like
a
place.
We
can
always
go
back
to
to
get
like
a
deeper
knowledge
of
every
single
thing
that
has
been
covered
here.
C
So
if
you
want
to
read
more
about
continuous
integration,
you
can
click
on
this
link,
get
like
a
better
understanding
of
how
it
works
or
a
deeper
understanding
of
how
it
works,
rather
even
after
this
workshop
has
been
completed.
So
if
I
click
on
that
url,
it
takes
me
to
the
github
documentation
explaining
what
continuous
integration
is
and
according
to
documentation.
C
Continuous
integration
is
a
software
practice
that
requires
frequently
committing
code
to
a
shared
repository.
It
helps
you
quickly
detect
errors
and
also
reduce
the
amount
of
code.
The
developer
needs
to
develop
when
finding
the
source
of
the
narrow.
So
let's
imagine
we,
let's
imagine
daniela,
I
okay,
of
course,
you're
part
of
the
same
team.
So
let
me
pick
someone
else
on
the
call.
How
do
I
find
okay?
C
So
I
can
see
femi
all
right.
So
let's
imagine
olufami
and
I
are
working
in
the
same
company
right
and
then
we're
all
working,
we're
both
working
on
this
particular
project.
So
olufami
takes
the
project
and
starts
working
on
it
doing
an
amazing
job.
Obviously,
and
then
I
am,
on
the
other
hand,
also
working
on
the
projects
trying
to
change
the
code
base,
make
things
cool
and
all
of
that,
but
then
the
issue
between
femi
and
I
is
that
we
don't
push
our
changes
like
for
the
entire
day
for
the
entire
week.
C
We
only
push
the
changes
were
made
to
that
repository
after
after
a
month,
so
it
means
that
for
an
entire
month
we
will
focus
on
improving
this
project,
but
then
we've
not
pushed
it
to
github.
So
at
the
end
of
the
month,
it's
finally
time
for
me
and
we're
filming
to
push
our
code
changes
and
then
boom.
C
We
push
it
to
github,
but
then
we
realize
that,
because
we're
working
on
this
project
for
an
entire
month
without
pushing
it
there's
so
many
merch
conflicts,
because
look
at
me
deleted
one
line
of
code
that
I
was
I
had
already
fixed
and
then
I
also
deleted,
like
five
lines
of
code
that
I
was
already
working
on.
So
basically
continuous
integration
helps
you
prevent
this
problem
instead
of
you
waiting
for
an
entire
month
or
two
weeks
before
you
push
code
changes
that
you've
already
worked
on.
C
So
there
are
a
couple
of
tools
and
services
that
provide
cut
ci
cd
service
in
the
clarity
space.
So
to
see
them.
You
click
on
this
cncf
cloud
native,
interactive
landscape,
and
what
that
will
do
is
take
you
to
this
place
where
you
see
different
projects
and
different
companies
running
tools
that
have
to
do
with
continuous
integration
and
continuous
delivery.
C
C
For
its,
I
can
see
its
lab
github
actions,
jenkins,
k-6
and
a
lot
of
them,
but
in
this
workshop
we'll
be
using
github
actions
but,
of
course,
like
we
said
we're
adding
these
links
so
that
you
have
the
full
picture
of
everything,
and
you
also
have
something
that
you
could
always
come
back
to
to
listen
to
like
read
about
when
you
have
the
time.
So,
if
you
click
on
github
actions,
you
click
on
these
bits
and
then
go
to
the
official
github
actions
website
and,
as
you
can
see,
github
actions
basically
makes
automation
easier.
C
So
it
helps
you
be
able
to
like
code,
build
and
code
build
test
and
deploy
your
code
directly
from
github,
so
we're
going
to
click
on
the
get
started
with
git
up
actions.
So
we
can
actually
use
your
quick
start
guide
and
click
on
the
quick
start
guide
so
that
we
work
through
how
to
actually
implement
this.
C
So
you
could
like
create
a
fork
of
this
application
and
use
it,
but
I
think
it
would
be
great
to
be
tried
with
you,
so
you
have.
You
can
actually
see
how
everything
works.
So
I'm
going
to
you
know
if
you
go
back
to
the
quick
start
guide,
you
see
that
the
first
thing
we
need
to
do
to
create
a
github
actions.
Workflow
is
to
actually
create
a
file
or
a
directory
name,
dot,
git
hub,
slash
workflows.
C
So,
in
order
to
do
that
directly
from
my
github,
what
I
would
do
is
click
on
add
new
file
then
create
a
new
file,
and
since
I
want
to
create
a
dot,
workflow,
sorry
dot,
github
slash,
works,
flow,
folder
I'll,
just
copy
that
in
and
paste
it
here.
So
you
can
see
that
it's
created
a
folder
name.github
and
another
file
name
workflows.
So
we've
completed
the
first
bit
of
that
part
of
the
quickstart
guide.
The
next
thing
we're
supposed
to
do
is
now
create
the
file
inside
this
directory
called
githubactions.demo.cml.
C
So
I'm
going
to
copy
that
and
go
back
here
and
add
a
slash
which
would
take
me
to
the
next
bit
and
paste
that
place
that
name
here
so
one
base.
What
I
basically
done
is
create
a
folder
called
dot
github
and
inside
this
folder
I
created
another
folder
called
workflows
and
inside
the
workflows
code
I
create
a
file
named
githubactionsdemo.yaml
and
then
in
this
yaml
file.
I
want
to
include
what
I
want
my
particular
actions
to
be
about
right.
So
this
is
like
basically
describing
what
you
want.
C
It's
like
the
deployment
file
in
kubernetes.
We
also
write
a
yaml
file
describing
what
objects
you
want
to
create.
You
want
to
create
a
service,
a
deployment.
What
do
you
want
the
specifications
of
these
deployments
to
be
how
many
replicas
you
wanted
to
create?
Should
it
be
in
a
specific
namespace
or
have
like
a
specific
name?
So
you
can
add
all
of
those
things,
so
it's
very
similar
to
this
as
well.
C
So
what
we're
going
to
do
is
copy
this
here
and
then
go
back
to
the
github
and
then
paste
that
information
so
quickly
cancel
that
so
a
quick
overview
of
the
things
that
are
being
pasted
here
is,
of
course,
the
name
like
the
name
of
this
action.
I'm
trying
to
kids
create
is
github
actions.
Demo,
then
on
here
is
like
an
event.
What
what
should
trigger
this
action?
C
Is
it
when
something
is
being
pushed
to
this
repository,
which
in
this
case
it
is
so
you
can
see
that
I
added
the
push
option
here
and
then
you
can
see
the
different
jobs
like
we
want
this
to
be
created,
or
rather
to
run
on
an
ubuntu
operating
system,
and
then
these
are
the
different
steps
you
wanted
to
follow.
So
the
first
thing
you
wanted
to
do
is
echo
that
the
job
has
automatically
triggered
successfully.
C
You
also
wanted
to
echo
that
the
job
is
now
running,
so
this
is
like
a
very
basic
descriptions
written
in
here,
but
then
it
could
be
like
a
lot
more
complex
could
be
you
checking
that
everybody
who
sends
a
prc.
This
piece
has
maybe
written
their
code
in
a
certain
format
right.
This
is
like
a
great
thing
for
open
source
projects
as
well.
You
can
use
it
like
easily
automate
the
number
of
how
your
course
how
your
code
is
being
submitted.
What
how
what?
C
C
So
if
we
go
back
to
these
bits,
let's
see
that
we're
supposed
to
do
is
create
a
new
branch
for
this
comment,
and
then
we're
going
to
do
is
click
on
create
a
new
branch
and
then
also
add
a
name,
so
it
could
be
anything
it
doesn't
have
to
be.
It
doesn't
have
to
be
kodak
to
cart
patch.
One
can
be
anything
really
so
I'm
going
to
click
on
this
and
you
can
see
it
automatically
created
a
name
called
gd
gdcode.patch.4.
C
The
job
is
now
running,
linux
ever
hosted
by
github,
and
then
a
couple
of
other
informations
that
I
listed
here.
Like
I
mentioned,
this
doesn't
have
to
be
this
basic.
It
can
be
more
very
important
things
that
are
like,
like
crucial
to
your
business
or
to
your
company
or
to
your
open
source
project.
So
this
basically
helps
you
test.
All
of
that,
and
of
course
you
don't
have
to
manually,
do
this
by
yourself
there's
a
way
to
do
this
directly.
C
That's
like
use
a
an
existing
template
on
github,
actually,
actually
so
what
we
did
now
was
created
by
ourselves.
We
wanted
to
create
a
new
workflow.
I
think
it's
a
way
to
select
yes
yeah,
so
you
can
see
the
different,
the
friends
or
positions
they
can
choose
from.
So
you
can
see
dinners
github
actions,
brands,
no
jazz
data
dog
name.
Is
you
have
so
many
options
here?
C
C
All
right
wrapping
up
we've
covered
a
lot
of
stuff
in
this
workshop
today,
a
whole
lot
severeness,
it's
like.
Can
you
grab
all
of
those
things
in
so
well?
I
know
you're
probably
concerned,
but
then
I
think
the
essence
of
this
workshop
is
to
give
you
a
quick
overview
of
how
kubernetes
works
like
a
real
life
example.
It's
not
just
you
reading
for
a
documentation
article,
it's
actually
having
access
to
people
who
are
telling
what
humanities
is
and
also
having
access
to
people
can
answer
your
questions
around
cuban
letters.
C
So
so
far,
we've
talked
about
the
meaning
of
kubernetes
and
this
basic
concept.
We've
also
learned
how
to
configure
a
local
dev
environment
for
kubernetes,
using
kind
and
qb
you've
learned
how
to
package
code
into
containers
with
docker,
basically
how
to
containerize
applications,
and
then
you've
also
learned
how
you
can
improve
your
coding
feedback
loop
with
a
cncf
tool
called
telepresence
and
finally,
you've
learned
how
to
perform
continuous
integration
with
github
actions.
C
We
know
that
learning
kubernetes
can
be
quite
challenging
to
understand
it's
a
known
fact,
there's
so
many
funny
memes
about
kubernetes
and
understanding
it,
but
then
we
just
want
to
let
you
know
that
we
are
here
for
you
and
by
we
I
mean
all
of
us
are
ambassador
labs.
We
have
a
slack
channel
called
developer
learning
center,
where
we
respond
to
questions
around
kubernetes
so
feel
free
to
join
that
channel
and
drop
your
questions.
Then
we
also
have
this
learning
resource
called
the
kubernetes
learning
center.
C
C
You
can
learn
about
it,
let's
say
one
hour
per
day
or
13
minutes
by
day,
depending
on
how
consistent
you
want
to
be,
but
then
this
resource
here
has
all
the
information
you
need
about
kubernetes
and
then
again,
like
I
mentioned,
we
have
a
slack
channel
centered
around
helping
you
answer
any
questions
you
bump
into
during
the
process
of
learning
about
this.
So
again,
it's
not
just
you
learning
about
it
by
yourself
or
getting
confused
or
not
having
anybody
to
talk
to.
C
You
have
us
on
our
slide
channel
waiting
to
respond
to
any
question
you
have
regarding
kubernetes.
Thank
you
so
much
for
joining
this
workshop.
We
really
appreciate
all
of
you
for
tuning
up
do
join
our
slack
channel.
Like
I
mentioned
at
atr
dot,
io
slack,
you
can
follow
me
on
twitter
at
dd
codes
and
also
full
ambassador.com
at
ambassador
labs.
So
if
you
click
on
this
link
here,
you'd
see
you'll
be
directed
to
our
twitter
page.
Then
you
can
also
follow
our
blog
at
blog.getambassador.io.
C
We've
been
sharing,
really
great
resources
and
how
to
get
started
with
kubernetes,
become
better
with
your
kubernetes
skills
and
a
couple
of
other
interesting
resources.
So
don't
forget
to
share
what
you've
learned
about
this
workshop
on
twitter
and
tag
ambassador
labs
and
tagging
as
well.
We'd
love
to
see
your
thoughts
about
what
you
learned
and
like
what
we
can
improve
on
and
any
other
feedback
or
information
you
have
to
share
will
be
very
helpful.
Thank
you
once
again
for
joining.
C
If
you
have
any
question,
we
can
open
up
the
flow
down
to
answer
questions
so
feel
free
to
numero.
If
you
are
here,
I
think
we
can
like
let
people
turn
on
their
mics
now,
if
there's
anybody,
that's
comfortable,
reacting
asking
a
question
with
your
audio
on,
so
we
have
like
a
few
more
minutes
before
our
time
gets
exhausted.
So
you
can
raise
your
hand
and
nima
would
give
you
access
to
speak.
A
C
B
A
E
Yes,
so
my
question
is
so
we
created
a
cluster
and
during
the
training
we
spoke
about
pods
and
nodes,
but
yeah
so
does
it
automatically
create
when
you
create
a
cluster,
because
we
didn't
because
after
we
created
the
container,
we
went
ahead
to
create
a
cluster.
So
it's
just
like
how
do
those
thing
two
things
connect,
so
I
was
thinking
to
go
a
container.
Then
a
port
then
create
a
node
then
create
a
cluster.
Yes,
that's
what
I
was
expecting
yeah,
so
how?
C
That's
that's
a
great
question
yeah.
So
when
you
create
a
cluster,
it
automatically
creates
nodes
for
you.
So,
like
I
mentioned
what
what
actually
makes
up
the
cluster
is
those
nodes
right.
So
without
the
node
there
will
be
no
cluster
and
then
ideally,
you
only
get
the
the
pods
are
not
created
automatically
it's
when
you
deploy
a
when
you
try
to
like
deploy
a
container
into
kubernetes,
that's
when
the
ports
are
created
for
you
don't
need
to
answer
your
question.
C
A
B
C
All
right
cool,
thank
you.
Everyone
once
again
for
joining.
Don't
forget
that
we
have
another
workshop
tomorrow
that
dana
will
be
leading
around
continuous
delivery.
It's
absolutely
awesome.
You
should
definitely
join
in
and,
like
I
mentioned,
don't
forget
to
join
our
slack
channel
tag
us
on
your
tweets
about
the
workshop
on
twitter
at
ambassador
labs
and
also
follow
our
blog
at
blog.getambassador.io
to
stay
updated
with
the
articles.