►
From YouTube: Webinar: Navigating the Sea of Local Kubernetes Clusters
Description
Your company has decided to start migrating to Kubernetes. Exciting! It is time to set up your development environment so you can quickly test your application changes in a real Kubernetes cluster. But, what should your development environment look like? Should you use minikube? kind? Something completely different?
In this demo-led session, we will have a look at some of the tools that help you locally deploy your Kubernetes application as part of your development process. We will show the differences between each tool from a technical and user experience point of view, so you can choose the ones that better fit your use case and company’s needs.
Presenter:
Ara Pulido, Developer Advocate @Datadog
A
All
right,
it's
three
past
the
hour,
so
let's
go
ahead
and
get
started.
I'd
like
to
thank
everyone
who
is
joining
us
today.
Welcome
to
today's
CN
CF
webinar,
navigating
the
sea
of
local
kubernetes
clusters,
I'm
Jeffery,
Sica
I'm,
a
senior
software
engineer
at
Red
Hat
and
a
CN
CF
ambassador
I'll
be
moderating
today's
webinar.
We
would
like
to
welcome
our
presenter
today,
Otto
Pulido,
a
developer
advocate
at
data
dog,
a
few
housekeeping
items
before
we
get
started
during
the
webinar.
You
are
not
able
to
talk
as
an
attendee.
A
There
is
a
Q&A
box
at
the
bottom
of
your
screen.
Please
feel
free
to
drop
your
questions
in
there
and
we'll
get
to
as
many
as
we
can.
At
the
end.
This
is
an
official
webinar
of
the
CNC
F
and,
as
such
is
subject
to
the
CNC
f
code
of
conduct.
Please
do
not
add
anything
to
the
chat
or
questions
that
would
be
in
violation
of
that
code
of
conduct.
Basically,
please
be
respectful
of
all
of
your
fellow
participants
and
presenters.
A
B
Thanks
you're
free,
so
yeah.
Today,
thanks
for
joining
today,
we
are
going
to
be
trying
to
help
you
navigate
the
sea
of
Canaries
local
clusters,
so
you
may
be
new
to
kubernetes
of
early
new.
You
are
still
learning
how
to
deploy
your
applications
in
kubernetes,
and
you
would
like
to
get
a
local
cluster
running
in
your
laptop
in
your
workstation
to
help
you
deploy
those
applications
and
test
those
applications,
and
you
may
wondering
what
you
should
use.
So
this
is
what
we
are
going
to
try
to
help.
You
make
a
decision
with
today.
B
So
data
dock
is
monitoring
an
analytics
platform
that
helps
companies
improve
APIs,
observability
of
their
infrastructure
and
applications,
including
kubernetes,
of
course,
the
cluster
itself,
but
also
the
applications
that
are
running
inside
your
cluster.
This
is
not
a
talk
about
data
dock
itself,
but
just
so
you
know
where
I
work
so
I'm
a
developer
and
okay
they're,
a
da
da
da
I've
been
working
on
kubernetes
projects
for
the
past
three
years.
B
I'm
a
certified,
kubernetes,
administrator
and
I
was
also
part
of
the
team
that
created
the
curriculum
and
exam
for
the
certified
kubernetes
application
developer.
Both
are
certifications
by
the
CNC
F
in
the
Linux
Foundation
and
those
are
two
ways
I'll
contact
me.
You
can
DM
me
or
ping
me
on
Twitter,
that's
my
handler,
and
that
is
also
my
mail.
So
if
you
have
any
question,
so
you
want
to
follow
up
afterwards
feel
free
to
reach
out
on
either
of
those
two
mediums.
B
But
this
is
a
talk
about
kubernetes.
What
is
kubernetes
kubernetes
an
orchestration
platform
for
your
continuous
application?
So
basically
it's
going
to
help.
You
run
your
containers
and
your
applications
as
containers
in
production
is
completely
open.
Source,
it's
a
curated,
CN
CF
project
and
it's
a
super
successful
open
source
project.
So
it's
had
19
million
releases
in
2015
when
it
was
first
released.
B
It
has
more
than
90,000
commits
on
its
Reaper
from
more
than
2,000
computers,
a
huge,
successful,
open
source
project.
It's
not
only
successful
as
the
project
itself,
it's
also
very
popular
and
it's
increasing
popularity.
So,
for
a
user
point
of
view,
this
is
the
Google
Trends
searches
for
communities
from
2015,
mid
2015,
more
less
until
January
this
year.
So
if
you
can
see
it's
a
it's
a
trend
that
keeps
on
growing
and
probably
is
going
to
continue
that
way
for
a
while.
B
Why
why
it's
so
popular
why
companies
are
choosing
kubernetes
for
their
continuous
applications?
So,
first
of
all
it's
super
extensible
and
flexible
because
everything
is
going
to
be
API
driven.
So
everything
in
kubernetes
is
an
API
object
that
you
interact
with,
but
also
that
API
is
extensible.
So
if
you
want
to
a
new
object
to
solve
an
issue
that
you
have
particular
on
your
space,
you
can
do
so.
So
it's
super
extensible.
B
The
secondary
side
of
it
is
its
large
community.
As
we
can
see,
there
is
a
lot
of
companies
putting
a
lot
of
effort
and
development
effort
to
to
kubernetes,
so
new
features,
bug
fixes,
etc,
get
ready
very
quickly,
so
something
to
take
to
take
into
account
and
another
reason
is:
it
helps
with
your
multi
cloud,
a
strategy.
So
if
you
want
to
run
your
application
with
several
clouds,
if
you
have
this
extra
abstract
extraction
layer
with
kubernetes
between
your
application
and
the
cloud,
it
may
help
you
migrate
those
applications
between
the
different
clouds.
B
So
this
is
fantastic.
It's
a
great
production
environment,
but
what
about
the
developer
experience?
How
does
that
match?
Is
that
great
production
environment?
So
this
is
how
your
production
cluster
may
look
like.
Maybe
this
is
way
too
too
abstract,
but
you
get
the
idea,
and
maybe
this
is
select
less
abstract.
So
in
your
production
cluster
or
your
staging
cluster,
you
will
have
several
nodes.
Each
of
those
is
going
to
be
running
different
workloads
and
each
of
those
nodes
are
going
to
be
connected
to
each
other
through
the
network.
B
All
in
all,
so
what
we
are
trying
to
say
is
your
production.
Cluster
is
a
disabled
system
and
I
suggested
with
the
system
it
has
its
own
needs
that
that
we
need
to
take
into
account.
But
then
you
workstation
looks
like
this
and
the
these
workstations
that
we
have,
as
developers
are
actually
very
powerful.
They
have
several
course
they
have
a
lot
of
memory
and
in
there
getting
better
and
better
every
time.
B
Unfortunately,
the
answer
is
no
production.
Your
production
is
never
going
to
be
a
be
the
same
as
your
local
cluster.
As
we
said
this
assisted
with
the
system,
it's
might
be
running
on
bare
metal.
It
might
be
running
on
a
cloud
with
its
own
different
things,
so
it's
never
going
to
be
the
same
experience
and
that's
something
that
obviously
we
need
to
acknowledge.
We
need
to
take
into
account
so
now
that
we
know
that
it's
never
going
to
be
the
same.
B
It
is
still
worth
running
a
Cabrini's
cluster
in
your
workstation,
so
I
think
the
answer
is
yes,
because
if
not
I
wouldn't
obviously
be
giving
this
talk,
and
why
I
think
it's
useful
many
things
so,
first
of
all,
it's
a
great
learning
tool.
So,
if
you,
if
you
want
to
start
deploying
your
application
synchronise,
you
need
a
way
to
learn
how
to
work
with
kubernetes.
You
need
a
way
to
learn
how
to
create
a
deployment
object,
how
to
create
a
pod.
How
do
you
mean
sorry
how
to
create
a
service?
B
All
of
that
you
will
need
to
to
learn
and
having
a
local
cluster
may
help
you
learning
all
these
concepts
very
very
easily.
The
second
is,
it
has
a
very
quick
thing,
but
look
so
if
you
have
an
application,
they
want
to
run
quickly
on
Google
is
cluster.
You
can
try
that
on
your
own
workstation
with
one
of
these
solutions
and
it's
also
very
useful
for
CI
CD
workflows.
B
Obviously
there
are
other
type
of
containers
like
Windows
containers,
but
in
general,
when
we
talk
about
containers,
we
are
talking
about
Linux
containers
and
that's
something
that
obviously
changes
everything,
because,
if
you're
not
running
Linux
natively
in
your
workstation,
everything
that
we
are
going
to
learn
here
today
is
going
to
be
virtualized
and
it's
okay,
and
we
are
going
to
see
some
of
the
examples
that
we're
going
to
see.
Some
of
them
are
going
to
be
very
transparent,
how
they
manage
the
virtualization,
and
some
of
them
are
going
to
be
less
transparent.
B
It's
going
to
be
more
specific,
but
in
from
a
technical
point
of
view,
all
of
all
of
this,
if
you're
not
running
Linux,
is
going
to
be
a
bit
wise.
Okay.
So
let's
try
to
navigate
that
see
of
local
communities
clusters.
The
goal
of
this
webinar
is
not
to
tell
you
what
you
should
use.
The
goal
of
this
webinar
is
to
give
you
an
idea
of
the
difference
between
the
technical
point
of
view
and
the
user
experience
point
of
view
all
these
tools.
B
So
you
can
make
your
own
decision
of
what
it's
best
for
your
use
case
or
if
you
want
to
try
several
ones
depending
on
the
several
scenarios
that
you
have.
So
these
are
the
ones
that
we
are
going
to
see
the
pipes,
slash
six,
that
we
are
going
to
see
today.
Our
mini
cube,
kind,
micro,
kubernetes,
k3s
and
kthleeny,
and
those
two
are
very
connected.
So
that's
why
I
put
them
together
and
for
cube,
which
is
something
a
bit
different,
but
I
thought
it
was.
It
wasn't
to
put
here
in
the
list
as
well.
B
Okay,
but
before
we
go
into
each
of
those
I,
think
it's
important
to
mention
cube
ADM,
which
is
a
project
in
psycho
binaries
to
helping
you
create
kubernetes
cluster
in
an
easier
way.
So
the
everything
that
you
have
to
do
from
an
admin
point
of
view
of
adding
nodes
managing
certificates.
All
of
that
cube,
ATM
help.
B
So
with
that,
you
don't
have
to
know
what
it
cutie
from
a
developer
point
of
view,
what
cube
D
cube
a
DM
is,
but
many
of
these
tools
are
based
on
cube
ad
n,
so
are
using
cube
a
the
end.
You
could
actually
create
the
cluster,
so
I
thought
it
was
interesting
to
just
mention
it.
So
in
case
you
see
on
some
of
the
output,
something
related
to
cube
ATM.
You
know
what
it
is.
B
Okay,
so,
let's
start
diving
in
the
first,
one
that
we
are
going
to
see
is
mini
cube
and
the
reason
why
we
are
studying
with
mini
cube
is
because
it's
the
most
popular
one
when
you
start
with
given
it
is
probably
the
first
thing
that
you
do
is
install
a
mini
cube.
Why
it's
so
popular.
So
one
of
the
reasons
why
is
so
popular
is
because
it
has
been
around
for
quite
a
while
the
project
started
in
2016
just
a
year
after
the
first
kubernetes
release.
B
It
provides
you
with
a
single
node
cluster
and
it's
also
cross-platform
in
Linux,
Mac,
OS
and
Windows,
and
in
in
those
three
it.
The
news
will
explain
exactly
the
same
because
in
those
three
it's
going
to
be
built
relies
on
and
we
will
sail
with
in
a
while
how
another
huge
feature
that
has
is
that
it
follows
Cuba
newest
releases
very
very
closely.
So
as
soon
as
there
is
a
new
companies
release
a
day
or
a
couple
of
days
after
you
are
going
to
see
a
new
mini,
cube
release
that
supports
a
new
version.
B
So
it's
it's
really
straightforward
to
be
running
the
latest
release
release.
It
also
supports
a
lot
of
features
like
features
that
you
want
to
learn
when
you're
learning
Korean
is
now
load,
balancer
and
note
port
services
ingress
different
container
runtimes.
So
it
has
a
lot
of
those
nice
features.
I
can
help
you
test
and
learn
those
concepts
and-
and
it
also
has
an
atom's
base
service
where
you
can
add
more
stuff
to
your
to
your
cluster
things
like
metrics
of
ingress
things
like
that,
you
can
add
those
installing
enabling
those
add-ons
okay.
B
Your
note,
if
we
move
to
the
three
different
OSS,
we
can
see
that
that
we're
going
to
see
for
your
workstation,
we
can
see
that
it
exactly
looks
exactly
the
same.
The
only
thing
that
changes
is
a
hypervisor
that
is
hyper
katynmike
west
by
default,
KVM
in
real
innards
and
hyper-v
in
Windows.
But
the
rest,
you
can
see
it's
it's
a
clip
saying,
okay,
so
let's
have
a
look
too
to
the
demo.
B
All
the
demos
are
pretty
cold
there
in
this
same
laptop
by
giving
the
the
presentation,
because
I
needed
to
speed
up
some
of
the
stuff,
so
it
doesn't
run
for
hours.
So
this
is
how
it
looks
from
a
user
point
of
view.
So
you
can
run
the
version.
It's
a
simple,
CLI,
CLI
tool.
You
can
check
the
list
of
clusters
that
you
have
on
your
mortgage
station.
We
don't
have
any!
So,
let's
create
one
super
simple.
B
B
We
have
all
the
logs
that
is
producing
and
if
we
check
the
list
of
processes
that
we
are
running
inside
this
node,
we
can
see
that
it's
a
system
debase
Linux
system
and
it's
running
Docherty
as
continuum
runtime
and
is
running
the
cubelet
and
those
are
running
us
OS
processes,
but
the
rest
of
the
components
that
we
need
for
kubernetes
to
run.
Let
the
controller
manager
the
api
server,
the
cube
proxy.
All
of
that
are
running
as
containers.
B
B
Obviously,
we
can
drill
down
to
see
what
command
and
how
it's
running
cube
API
server
in
general,
but
this
is
running
as
container
and
something
that
is
important
to
know.
Okay.
So
how
do
we
access
our
application?
One
of
the
things
that
we
want
to
do
obviously
a
success
and
test
our
application.
So
we
were
saying
that
one
of
the
great
thing
Minik
you
has
is
that
it
implements
very
easily
note
poor
and
load
balancer
services.
B
To
put
an
example,
we
have
here,
this
application
has
several
services
and
one
of
the
services
from
ten
is
exposed
as
a
node
port
in
order
to
access
that
application.
The
only
thing
that
we
need
to
do
is
mini
cube
service,
the
name
of
the
service,
that's
URL,
and
if
we
remove
the
dust
URL,
it's
going
to
open
for
us
our
default
browser
and
it's
going
to
load
our
application.
So
super
simple
way
to
deploy
an
app
expose
it
as
a
service
and
being
able
to
see
if
it's
running
correctly.
B
Okay,
let's
check
the
second
one
kind,
so
kind
obviously
has
the
cutest
name
for
a
tool.
Kind
stands
for
Cuban,
Edison
docker,
and
it's
already
giving
us
an
idea
of
what
we
are
going
to
see
here.
So
your
knees
and
docker
is
space
onto
a
Korean
docker,
which
means
that
you
can
you're
able
to
run
a
container
runtime
inside
a
container.
So
what
we
are
going
to
here
is
to
run
kubernetes
node
as
a
container,
so
the
container
runtime
offered.
Now
it
is
going
to
run
inside
a
container.
B
We
are
going
to
see
a
graph
to
make
this
a
little
bit
easier
to
understand,
kindly
surprised
that
I
started
in
2019,
so
it's
fairly
new,
it's
great
because
it
works
anywhere
Dugger
words
and
obviously
we
are
going
to
see
the
trick
here
because
obviously
has
to
be
virtualized.
But
one
of
the
things
that
docker
does
is
that
the
user
experience
in
Mac,
OS
and
Windows
is
very
transparent.
B
B
Ok.
So
this
is
how
it
looks
from
an
architectural
point
of
view.
So
you
have
the
hardware,
you
have
your
host
OS,
that
is
running
the
docker
runtime
and
then
for
each
node,
for
your
cluster
is
going
to
be
actual
a
container
that
gets
another
container
runtime
inside.
So
this
is
the
Joker
in
docker
experience
again.
We
know
that.
Actually,
this
is
not
what
is
happening
in
some
of
the
us's
so
in
Mac,
OS
and
windows.
B
Another
benefit
that
enhances
a
can
define,
put
all
your
configuration
in
the
AMA
files
instead
of
passing
them
on
the
command
line.
So
it's
very
good
to
have
all
this
when
you're,
for
example,
on
your
git
repo
to
help
with
the
CI
aspect
of
it.
In
this
case,
for
example,
we
are
defining
a
cluster,
then
has
two
nodes,
one
as
control
plane
once
this
worker
and
both
running
kubernetes
1:18.
B
Ok,
let's
have
a
look
to
the
demo.
So
again
we
start
with
conversion
and
we
can
get
the
list
of
clusters
and
we
are
going
to
apply
this
configuration
to
the
creation
command
the
same
one
that
we've
seen
the
slides
and
we
are
going
to
just
kind
create
cluster,
and
we
are
going
to
pass
that
configuration,
and
this
is
what
is
going
to
happen.
It's
going
to
start
creating
some
some
notes.
It's
going
to
install
CNI,
so
the
networking
plugin
for
you
in
this
case
it
uses
kind
net
which
is
specific
to
to
kind.
B
B
But
we've
said
that
this
our
actual
container
so-
and
this
is
where
you're
going
to
see
how
docker
makes
it
very
transparent,
because
I
can
get
the
list
of
containers
in
my
machine,
and
these
are
the
two
nodes
both
are
containers,
and
although
this
is
actually
inside
a
VM
I
didn't
have
to
ssh
into
that
VM
jokerman
does
all
that
heavy
lifting
for
me.
So
it's
super
easy
to
use.
Containers
outside.
B
Okay,
let's
have
a
look
again
on
how
this
looks
like
from
a
process
and
container
point
of
view.
So
if
we
check,
for
example,
the
control
plane
in
this
case,
we
have
two
hosts.
We
will
see
that
this
looks
a
little
bit
like
a
VM
because
it
has
system
D.
It
has
a
container
DEA's
runtime
a
bunch
of
containers
running,
and
it
also
has
the
cubelet.
B
So
those
are
the
couplets
on
container
D
are
the
only
two
processes
are
going
to
be
running
as
OS
processes.
If
we
check
the
list
of
containers,
the
rest
of
the
components
that
are
needed
for
CUNY's
are
going
to
be
running
as
containers,
so
we
have
the
API
server,
obviously
the
agent
to
get
the
data
controller
manager,
etcd,
cadenas
kind
net,
which
is
the
networking
plugin,
and
we
can
dig
in
to
see
the
process
information
or,
for
example,
the
API
server
in
case.
B
We
want
to
understand
how
kind
is
executing
the
API
server,
so
all
the
arguments
that
it
is
going
to
use
okay.
So
how
do
we
access
our
application?
So
you
may
think
that,
with
all
these
layers
of
abstraction,
we
have
we
have
the
B
end
and
we
have
a
container
then
another
container
for
our
application,
and
we
may
think
that
this
is
it's
going
to
be
tricky
to
access
our
app,
but
it's
again
very
transparent.
B
We
can
access
our
application
that
we
saw
before
so
pretty
great
super
lightweight
way
of
off
to
in
of
doing
cluster
of
client
clusters.
Okay,
the
third
one
that
we
are
going
to
see
is
micro
kubernetes,
which
is
a
little
bit
different
in
the
console.
Maybe
me
and
Cuban
kind
are
the
most
severe
ones,
but
definitely
not
the
only
ones.
So
let's
have
a
look
to
some
others.
Micro
kubernetes
is
a
Cooney's
distribution
by
canonical
40-below
personality.
So
it's
not
only
meant,
as
your
local
cluster
is
also
meant,
to
be
deployed
on
IOT
devices.
B
This
package
is
not,
which
is
a
packaging
system
created
for
country.
There
are
other
linux
distros
that
support
snaps,
but
really
when
you're
talking
about
the
snaps
chances
are,
you
are
talking
about
uber
Jim,
it's
using
flannel
as
CNI,
so
instead
of
using
something
specific
for
micro,
kubernetes
is
using
just
a
simple
scene,
italian
called
flannel.
B
B
You
have
a
snap
T,
which
is
a
demon
that
you
require
to
run
one
of
these
snaps,
and
then
you
are
going
to
have
all
the
components
that
you
need
for
your
note
as
OS
processes,
not
as
containers
as
we
saw
with
mini
cube
and
kind
so
you're
going
to
have
the
cube
proxy,
continue
the
API
server,
flannel
schedule,
cable,
etc.
All
of
that
as
processes
in
your
in
your
note
again,
if
you're
not
running
Linux,
this
is
going
to
be
beautiful
eyes,
and
this
is
when
we
start
to
be
less.
B
We
have
to
be
more
specific
about
creating
the
VMS
and
if
you
go
to
the
instructions
on
how
to
create
a
micro,
kubernetes
cluster
on
Mac,
OS
or
Windows,
they
recommend
using
multi
pass,
which
is
basically
it's
just
VM
management
tool
that
canonical
create
it.
It's
very
tailored
towards
window.
You
can
really
use
you
want.
B
B
So
the
first
thing
that
we
need
to
do
is
to
launch
an
Ubuntu
machine.
They
have
this
command
multi
pass
launch,
and
it's
going
to
launch
the
latest
Ubuntu
LTS
release
by
default.
I
recorded
this
before
2004
was
released.
This
is
going
to
run
1804,
and
once
we
launch
it,
we
can
SSH
into
it.
They
call
it.
Shell
is
basically
SSH
into
the
VM
in
a
more
transparent
way.
So
you
can
see
that
this
is
basically
running
normal,
Ubuntu
1804
directly
from
from
the
cloud
images.
B
So
let's
install
the
snap
so
the
way
we
install
it
is
with
it's
not
install.
This
is
how
you
saw
this
packet
in
sister
called
snaps,
and
it's
going
to
take
a
little
bit.
While
this
is
many
of
the
boring
things
of
the
demo
is,
are
a
little
bit
speed
up.
So
you
will.
If
you
do
that
yourself,
you
may
notice
that
it
takes
a
little
bit
more
and
then
once
you
install
it,
you
have
to
wait
a
little
bit
for
it
to
be
ready.
B
So
once
it's
ready,
you
can
do
cube
city
I'll,
get
notes,
you
see
a
special
command
called
micro
companies,
keep
CTL
and
then
you're
ready
to
go
so
this
list
that
we
see
here
are
the
list
of
add-ons.
That
I
was
mentioning
things
like
you,
cannot
your
cluster
in
a
very
easy
way,
so
they
already
pre
tested
to
work
on
micro
kubernetes.
B
So,
let's
use
this
to
enable
DNS,
because
DNS
is
something
that
in
general,
you
always
need
on
your
system,
and
now
we
are
going
to
have
a
look
on
how
it
looks
internally,
so
we
have
only
two
containers.
This
is
a
still.
This
is
already
different
from
what
we've
seen
before.
We
only
have
the
data
talk
agent
that
we
deployed
outside
the
recording,
but
we
deploy
it
and
core
DNS
that
we
just
enable,
where
are
the
rest
of
the
components.
B
So
if
you
go
to
the
list
of
OS
processes,
you
can
see
them
there,
like
the
API
server
controller
manager,
the
cubelet
container
deal
the
Cubist
scheduler.
All
of
that
are
running
as
OS
processes,
directly
gasps
system,
D
units
same
thing.
You
can
check
what
are
the
defaults
of
how
they
run
each
of
those
components
easily.
If
you
navigate
into
the
actual
process
and
yeah,
that's
a
little
bit
different
from
what
I've
seen
so
far.
B
Another
thing
that
it's
different
from
what
we've
seen
so
far
is
the
user
experience.
So
a
mini
Kuban
kind
I
was
able
to
access
my
cluster
without
leaving
my
workstation
in
this
case.
I
had
to
SSH
into
the
machine
an
MSc
on
the
machine,
which
is
that's
the
same
idea.
You
want
to
be
on
your
workstation
without
having
to
access
any
VM
directly,
so
the
user
experience
is
not
as
good
as
the
other
two,
but
you
can
overcome
that
quickly.
B
They
have
a
command
to
expose
your
cube
config
into
a
file,
so
we
are
going
to
do
that
now
and
then
we
are
going
to
go
back
to
our
workstation
and
copy
that
file
into
our
local
file
system,
and
once
we
do
that
there
is
a
command
called
transferring
multi
pass,
which
is
SCP
really
once
we
do
that
we
can.
We
can
expose
our
cube
config
and
then
access
that
same
node
that
same
cluster
using
cube
CTL,
so
it
can
be
done,
is
not
a
straightforward.
About
definitely
can
be
done.
B
So
we
said
this
was
Multi
multi
note.
So
how
we
add
a
note,
so,
let's
SSH
into
the
control
plane,
they
have
a
command
called,
add
note
and
that
basically,
what
it
does
it
gives
us
a
token
that
we
are
going
to
use
in
a
second
note.
Obviously,
if
you
want
these
rpms,
so
if
you
want
a
second
note,
you're
going
to
need
basically
a
second
second
VM
running
micro-communities,
so
I
super
speed
this
up,
because
we
already
see
all
these
things
once
we
have
it
up
and
running.
B
The
only
thing
that
we
need
to
do
is
to
add
that
command
into
our
worker
node,
and
once
we
do
that,
we
check
quickly
that
the
processes
that
we're
running
here
look
a
little
bit
different,
because
it's
going
to
be
a
worker
node.
So
it's
only
going
to
have
the
components
that
are
needed
for
a
worker
node
like
a
container
D
and
flannel,
keep
rocks
and
the
cubelet,
but
we
don't
have
the
API
server.
We
don't
have
cube
controller.
All
of
that
is
on
our
second.
B
So
the
fourth
and
five
4/5
on
our
list,
ir
k,
3
s
and
k
3d.
Let's
start
by
by
the
arena,
which
is
k,
3
s
and
we
will
explain
how
k
3
days
related
again
similar
to
micro.
Kubernetes
is
a
lightweight
kinase.
Distribution
for
deaths
and
IOT
devices
are
very
similar.
It
was
originally
created
by
Ranger
and
the
same
way
that
micro
kubernetes
package
kubernetes
as
single
as
now
k3s
goes
a
step
further
and
package
everything
as
a
single
binary.
B
So
you
only
have
to
download
a
binary
and
you're
ready
to
go
same
as
flannel
tee
same
as
micro
kubernetes
is
going
to
use
for
energy
for
the
CNI
and
again
as
well.
It's
multi
node
cluster.
So
how
does
it
work?
So
we
have
this
binary
that
we
run
in
our
Linux
machine
and
once
we
run
the
binary
and
we
can
run
it
in
two
different
ways-
we
can
run
it.
The
first
way
is
to
run
it
to
get
a
control
plane
node.
B
So
we
run
this
command
k3
a
server
and
it's
going
to
create
two
processes,
and
only
two
processes
is
going
to
create
the
container
D
process
and
it's
going
to
create
the
k3s
server
process
and
all
the
components
that
are
needed
to
run
kubernetes.
As
we've
been
telling
all
the
time
there
be
a
server
control
it
etc
are
going
to
be
embedded
inside
that
single
process,
so
very
out-of-the-box.
B
Thinking
when
designing
this
thing,
where
they
embedded
everything
on
a
single
process,
you
can
see
that
here
that
you
have
sickle
light,
which
is
a
little
bit
weird
to
have
in
aqueous
cluster.
Usually
the
state
is
managing
in
etcd,
but
then
they
wanted
to
make
it
very,
very
lightweight
and
they
replace
it
is
city
with
sequel
light.
The
k3s
team
is
preparing
a
release
of
k3s
with
etcd
as
an
option,
but
it's
still
not
a
fool.
So
that's
for
the
control
plane.
B
What
about
if
I
want
to
add
a
worker,
node
I
use
exactly
the
same
binary.
The
only
thing
that
I
did
differently
is
that
I
run
a
different
command
called
kiiiers
agent,
who
is
going
to
create
again
two
processes,
the
container
run
time
and
this
process
that
is
going
to
embed
all
the
components
are
needed
for
a
four
hour
working
out.
I
cube,
let
Flannan
keep
proxy
so
very,
very
interesting
cluster.
Let's
have
a
look
to
to
how
it
works
from
a
user
point
of
view.
B
B
For
this
example,
they
don't
recommend
anything
in
particular,
so
I'm
using
vagrant
and
I'm,
creating
two
to
two
VMs,
exactly
the
same
running
Ubuntu
one
I'm
going
to
call
it
note,
control,
plane
and
they're
going
to
be
connected
through
a
network,
so
I'm
going
to
do
a
vagrant
up
to
run
it
and
I'm
going
to
SSH
into
the
control
plane
and
once
I'm
on
the
machine.
It's
just
fresh
installation.
B
The
only
thing
that
I
need
to
do
is
download
a
binary,
a
single
binary
that
I
can
get
from
the
list
of
releases
and
when
I
download
it.
What
I'm
going
to
do
is
just
give
it
some
execution
permissions
and
maybe
put
it
in
a
path,
but
nothing
else.
So
how
do
I
run
my
control
plane?
So
it's
if
I
run
k3s
the
binary
I
can
see
that
I
have
two
commands:
the
server
and
the
agent.
B
This
is
the
control
plane
that
we
are
trying
to
build
so
I'm
going
to
run
k3s
server,
and
you
can
see
that
there
are
many
arguments
here
and
some
of
the
arguments
are
not
related
to
race
itself.
So,
for
example,
you
have
things
like
cube
like
arguments
and
cube
proxy
arguments,
because
all
of
these
components
are
going
to
be
embedded
on
this
process.
If
you
want
to
pass
different
different
arguments
to
to
those
components
you
have
to
through
k3s.
B
So
it's
going
to
to
run
this
so
I'm
getting
to
limit
running
in
a
terminal
and
then
I'm
going
to
SSH
again
on
to
the
same
machine
and
now
I
can
do
a
special
command
called
k3s
keep
city
I'll
get
no
it's
an
agency.
My
note
is
up
and
running,
which
is
just
great,
so
I
only
had
to
download
a
binary
run
it.
That
was
it.
B
B
Some
containers
are
not
really
part
of
the
core
Kuban
areas
components,
but
k3s
is
a
little
bit
opinionated
in
the
sense
of
what
it
thinks
that
you
will
need
anyway.
Remember
that
with
micro-communities
we
needed
to
enable
the
core
dns
planning
to
get
coordinates
here
is
by
default.
So
it
has
things
like
traffic
for
your
ingress
needs.
B
It
has
the
metric
server,
which
is
very
interesting
to
get
the
CPU
a
memory
that
each
bird
is
using
and
coordinates
so
and
also
some
storage
class.
So
all
of
that
is
done
for
you,
but
where
are
the
processes
for
my
components,
the
components
that
are
part
of
the?
So
we
can
see
that
there
are
only
two
two
of
them,
so
there
are
no
API
server.
B
There
is
no
queue
proxy,
so
the
only
the
only
ones
that
we
are
going
to
see
is
the
k3s
server
and
container
d,
and
this
process
is
the
one
that
is
going
to
contain
all
those
components.
So
something
to
I
think
it's
important
to
know
how
this
works.
In
case
you
need
to
back
something
you
need
to
understand
where
those
are
all
those
things
cool.
B
B
So
it's
all
in
the
instructions
and
then
we
only
have
to
run
the
aging
command
with
the
same
binary,
pointing
to
our
server
and
passing
the
token.
So
we
can
communicate
to
the
server
securely
and
it's
going
to
do
the
same
thing.
It's
going
to
run
that
command
and
if
I
go
back
to
the
control
plane
and
to
cube
City
I'll,
get
notes,
I
can
say
the
second
node,
oh
there
so
again,
very
straightforward.
To
add
that
second
note
and-
and
that
was
that
was
great,
but
we
saw
that
those
are
not
super.
B
B
So
it
doesn't
seem
like
a
great
great
user
experience,
but
a
lot
of
people
loved
k3
s
for
developers,
so
they
decided
to
create
this
second
project
called
k3d.
That,
basically,
is
a
wrapper
to
launch
kubernetes
cluster
k3
s
cluster,
sorry
in
Dhaka,
so
this
is
seems
to
be
looking
a
lot
like
kind.
It's
the
same
concept
so
running
containers
inside
containers.
This
is
going
to
be
instead
of
BMS.
Our
notes
are
going
to
be
containers,
it's
very
easy
to
install.
You
only
have
to
call
Bosch
an
installation
script.
B
The
only
thing
that
does
is
script
us,
if
you
check
it
so
it's
safe
to
do,
is
check.
Where
is
where
is
your
operating
system
and
unload
the
write
binary
you
want?
If
you
want
to
skip
goulash
stuff
from
the
internet,
you
can
just
go
to
the
releases
page
and
get
the
right
binary
and
it's
also
multi
multi
node.
So
let's
have
a
look
from
a
user
point
of
view,
so
we've
run
that
command
to
get
the
right
binary
again.
B
B
So,
let's
check
how
to
add
a
node
and
so
the
way
we
add
a
node
is
super
simple,
which
is
we
didn't?
Have
we
don't
have
to
create
this
second
container
ourselves
and
then
join
that
that
one
as
we
did
with
k3s,
we
just
new
k3d,
add
node
and
point
to
the
control
main
node
and
it's
going
to
just
work.
So
if
we
do
now
keep
city
I'll
get
no
sorry
about
the
alias
you
get
both
notes.
B
So
if
we
check
the
list
of
processes
very
same
thing
as
k3s,
we
only
have
the
k3s
server
and
kiiis
agent
on
each
of
those
nodes
and
the
rest
of
the
weight
is
going
to
be
embedded.
And
if
we
check
the
list
of
of
containers,
we
are
going
to
see
that
it's
going
to
have
the
same
containers
that
we
saw
on
k3s.
B
Ok,
the
final
one
that
we
are
going
to
see
is
completely
different.
It's
not
it's
not
really
meant
to
be
a
local
cluster,
but
it's
very
easy
to
deploy,
and
it's
a
little
bit,
especially
I
thought.
It
was
interesting
to
put
it
here
as
well.
If
not
a
secure
curiosity
fire
cube
is
a
geat
ops
ready
cluster.
So
what
is
key
tops
key
tops
is
a
way
of
working
with
infrastructure
and
applications
where
everything
the
source
of
truth
and
everything
is
on
a
git
repo.
B
So
all
your
infrastructure
code,
your
app
code,
your
app
configuration
everything,
some
good
developers
or
admins-
do
not
interact
with
coronaries
directly
just
through
the
git
repo
and
the
good
news
cluster
is
going
to
be
really
in
that
configuration
and
applying
the
changes.
So
it's
kind
of
similar
as
another
concept
called
infrastructure
as
code,
but
it
goes
a
little
bit
Stepfather
not
only
for
infrastructure,
but
also
for
your
apps
for
your
app
config,
even
your
secrets,
in
a
special
way.
They
have
ways
to
add
secrets
as
well
encrypted.
B
B
It's
going
to
create
your
cluster
using
firecracker
using
ignite,
which
is
a
way
for
project
this
is
fire.
Cube
was
originally
developed
by
white
we've
works
and,
if
you're
not
in
linux,
is
going
to
fall
back
to
dr.
in
docker.
So
again,
in
my
case
that
I'm
running
my
OS
is
going
to
create
this
container
nodes
and
also
its
multi-node
as
well.
So,
let's
see
the
demo
and
this
time
I
start
differently
from
the
rest
of
the
demos.
This
demo
doesn't
start
up
tourmalet.
It
is
start
of
github.
Why?
B
Because
if
this
is
key,
tops
ready.
The
first
thing
that
we
need
is
a
git
repo,
so
we
are
going
to
that,
and
this
is
the
instructions
that
they
asked
you
to
do
so
first
thing
that
you
need
to
do
is
to
forget
the
repo
we
are
going
to
do,
that
we
fork
the
repo
and
then
we
are
going
to
clone
that
repo
and
this
new
repo
that
we
have
created
that
we
have
for
is
going
to
contain
all
the
information
about
our
cluster,
our
infrastructure.
B
We
just
run
setup
it's
going
to
download
some
tools.
This
is
basically
a
wrapper
for
different
tools
that
they
have,
and
this
is
the
interesting
bit
before
creating
my
cluster.
It's
going
to
produce
some
configuration
here
and
it's
going
to
push
it
to
get
so
instead
of
creating
the
cluster
and
then
maybe
afterwards
pushing
to
gate
it's
going
to
push
to
get,
because
that
configuration
is
how
my
cluster
is
going
to
look
like
and
then
a
tool
is
going
to
bring
that
information
and
it's
going
to
create
the
cluster.
B
B
What
if
I
want
to
deploy
my
application
should
I
do
keep
city
I'll
apply?
Okay,
that
doesn't
seem
like
the
case,
because
I
want
to
do
everything
through
gate,
so
to
basically
what
I'm
going
to
do
is
to
copy
those
manifests
that
I
have
for
my
application
into
my
head,
Reaper
and
I'm,
going
to
push
that
to
my
git
repo
first
I'm,
going
to
create
my
changes
and
then
I'm
going
to
push
to
my
to
my
remote.
B
So
once
I
do
that
I
can
do
I'm
not
doing
keep
CTL
are
all
here
and
if
I
get
the
parts
and
I
watch
a
little
bit
in
a
couple
of
seconds,
you're
going
to
see
those
containers
appearing
magically.
How
did
that
happen?
It
happened
because
fire
cube
comes
by
default
with
this
component
called
flux
and
this
component.
What
it's
going
to
do
is
going
to
watch
all
the
time
for
changes
on
my
gate,
repo
and
once
that
see
any
changes,
it's
going
to
apply
those
changes
directly
so
interesting
way
of
working.
B
B
They
don't
mean
to
be
production,
but
still
they
are
very,
very
useful,
they're,
very
useful
for
CI
for
testing
for
learning
tools,
so
knowing
what
they
are
I
think
they
can
be
very,
very
useful,
also,
I,
think
it's
important,
or
at
least
is
well
important
needed
to
know
a
little
bit
of
the
architecture
of
your
local
cluster,
whether
it's
a
VMware
is
a
container
whether
it's
the
components
of
khorinis
are
running
or
containers.
All
these
things
are
going
to
help
you
debug
in
case.
Something
goes
wrong
and
my
final
takeaway
is
that
talking.
B
B
So
if
you
and
that's
why
many
of
these
tools
are
falling
back
like-kind,
we
see
on
k3d.
Many
of
these
tools
are
using
docker
for
your
nodes
and
that's
it.
Thank
you
very
much.
I
hope
you
learn
a
little
bit
how
you
how
you
work
with
these
local
clusters
feel
free
to
reach
out
anytime
and
visit
hp.com.
If
you
want
to
to
check
how
you
can
monitor
your
communities
cursor
as
well.
Thank
you
awesome.
A
B
B
So
what
you're
going
to
happen
to
have
is
several
context,
so
cube
CTL
will
point
to
each
of
those
clusters,
depending
on
the
context
that
you're
switching,
so
what
you
will
need
to
do
is
to
maintain
those
two
contexts
and
switch
between
those
two.
Depending
on
on
what
cluster
you
want
to
talk
to.
You.
B
A
A
Awesome,
unfortunately,
there
are
a
few
more
questions
left,
but
we're
running
out
of
time,
so
I'm
going
to
kind
of
cut
us
off
thanks
again
otto
for
a
great
presentation.
That's
all
the
questions
we
have
time
for
thanks
for
joining
us
today.
The
webinar,
recording
and
slides
will
be
online
later
today.
We're
looking
forward
to
seeing
you
at
future
CN
CF
webinars
have
a
great
day.
Thank.