►
Description
Using Kubernetes API from Go [B] - Alena Prokharchyk, Rancher Labs
As Kubernetes becomes increasingly popular, the number of integration and monitoring services around it are also growing. The key component of any such service written in Golan is kubernetes/client-go – a package that is used to talk to Kubernetes cluster APIs. During this talk, we will discuss the basics of client-go usage and how they can save the developer time needed for writing an actual app logic.
We will also demonstrate the best practices for using the package and lessons learned from the perspective of a developer who does integration work with Kubernetes on a daily basis. Following items will be covered:
* Client authentication in cluster vs outside of cluster
* Basic list, create and delete operations for Kubernetes objects with client-go
* How to watch and react on Kubernetes events using ListWatch and Informers
* Package dependencies (vendor) management
About Alena Prokharchyk
Alena Prokharchyk is a Software Engineer at Rancher Labs. Before Rancher Labs, Alena joined Citrix through the Cloud.com acquisition, where she worked on CloudStack - Infrastructure as a Service (IaaS) cloud computing platform. For the past three years with Rancher Labs, Alena worked on developing infrastructure services for Docker containers, and Rancher-Kubernetes integration.
Join us for KubeCon + CloudNativeCon in Barcelona May 20 - 23, Shanghai June 24 - 26, and San Diego November 18 - 21! Learn more at https://kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy and all of the other CNCF-hosted projects.
A
A
The
transition
for
me
from
being
a
Java
developer
to
being
a
goal
and
developer
was
pretty
similar,
so
I
had
to
learn
different
language
I
had
to
understood
the
concepts
and
it
was
a
pretty
fun
journey
and
I
would
like
to
know
a
little
bit
more
about
you
like
how
many
of
you
use
kubernetes
in
any
way
as
a
user
as
a
developer,
all
right
great.
How
many
of
you
right
tools
for
kubernetes
all
right?
How
many
of
you
use
go?
A
Oh
I,
really
like
the
diversity
all
right,
so
this
session
is
going
to
be
about
using
kubernetes
api
from
go.
First,
let's
talk
about
why
we
all
love
kubernetes.
As
a
user,
you
probably
appreciate
the
feature
set,
there's
so
many
things
that
you
can
use
from
communities
for
the
workloads
for
the
node
management
and,
if
you're,
a
big
company.
You
appreciate
the
community's
ability
to
handle
the
big
workloads
in
its
performance
and
if
your
community
is
a
contributor,
you
definitely
appreciate
the
community,
which
is
very
friendly,
very
approachable,
very
helpful.
A
But
the
one
thing
that
I
wanted
to
focus
on
is
kubernetes
extensibility,
so
that
was
actually
very
useful
from
the
developer
standpoint.
You
can
extend
communities
in
so
many
ways.
You
can
develop
your
own
api's
if
it
suits
your
use
case,
you
can
use
custom
resource
definitions,
we're
going
to
talk
more
about
it
on
the
next
slide
and
that
extensibility
that
what
actually
makes
kubernetes
a
platform.
A
So
what
plus
room
means
that
is,
there's
a
core
feature
set
and
this
pretty
much
set
and
it
can
be
extended
by
the
third
parties
without
actually
disrupting
the
main
code
base.
So
you
don't
have
to.
If
you
need
something
extra,
you
don't
have
to
go
and
modify
the
kubernetes
repo.
You
can
write
it
and
push
it
to
your
own
repo.
You
can
deploy
it
and
use
it.
Even
the
EPS
can
be
plugged
and
this
new
API
that
you
plug
in
can
be
used
from
the
cube
control.
A
And
then
you
can
write
your
own
custom
controllers
if
you
want
to
control
your
own
resources
and
that
what
makes
the
kubernetes
ecosystem
all
the
tools
on
the
slide.
I
was
too
lazy
to
put
them
all,
but
there's
like
a
bunch
of
them
there
they
would
extend
kubernetes.
Those
are
basically
the
custom
controllers,
so
they
extend
the
login
functionality.
They
provide
you,
the
DNS,
the
service
mash,
the
monitoring,
and
that
is
pretty
cool.
A
A
There
are
several
ways
to
extend
kubernetes
like
on
this
slide:
I've
listed
all
the
main
communities
components.
We
should
like
the
controller,
the
API
server,
the
scheduler
and
then
in
the
worker,
there's
a
cubelet
and
their
cube
proxy.
And
if
you
look
at
the
cubelet
there's
a
way
to
extend
the
continue
around
time.
Interface,
which
is
sounds
pretty
intimidating
to
me
like
too
complicated
I've,
never
looked
into
it,
but
there
is
a
way
to
do
it.
So
you
can
do
docker.
You
can
use
rocket.
Then,
on
the
controller
manager
side
there
is
a
cloud
provider.
A
So
you
know
that
kubernetes
supports
multiple
cloud
providers,
like
google
cloud
provider,
Amazon
and
those
that
all
these
components
are
all
pluggable
and
there
is
a
big
initiative
in
the
kubernetes,
like
the
some
of
them
are
part
of
the
kubernetes
core
base,
but
they're
working
on
moving
it
out.
So
it's
going
to
be
more
flexible,
like
if
you're
a
digital
ocean,
for
example,
you
can
develop
your
own
plugin
and
you
don't
have
to
contribute
it
to
the
kubernetes
core.
A
You
can
just
keep
it
in
your
own
repo
and
handle
the
deployment,
and
then,
if
you
look
at
the
API
server
there,
it
becomes
more
interesting
and
more
user
in
developer
friendly.
You
can
build
your
own
API
extension,
so
kubernetes
name
API.
They
have
a
bunch
of
objects
like
no
spots.
You
can
design
your
own
objects
like,
for
example,
if
you
do
monitoring,
you
can
think
about
your
custom
object
that
you
can
use
just
for
monitoring
purposes,
and
then
you
can
write
custom
controllers
for
these
resources.
A
That
would
came
to
the
left
of
the
slide
and
that's
what
we
are
going
to
be
focusing
on
today.
Writing
the
custom
controllers
that
component
that
just
talks
to
the
EPI
it
can
monitor
either
existing
kubernetes
resource.
It
can
monitor
your
custom
resource.
Then
it
can
act
on
it,
modify
it.
Do
a
bunch
of
stuff
and
you'll,
hear
a
term
controller
a
lot,
and
there
is
no
exact
definition
for
it.
A
If
you,
google,
what
is
kubernetes
controller
you're
going
to
be
given
like
a
bunch
of
stuff
and
then
I
try
to
think
about
it
like
what
would
be
the
best
way
to
just
to
to
explain
it
so
have
any
one
of
you
use,
kubernetes,
ingress,
so
yeah,
so
communities
ingress
is
just
a
way
to
provide
the
entry
point
for
application
and
to
balance
it.
But
if
you
look
closer,
the
ingress
kubernetes
ingress
resource
is
just
a
shell.
A
It
doesn't
have
any
implementation,
so
you
create
kubernetes
ingress
resource
and
then
there
is
some
magic
happens
and
what
this
magic
is.
The
people
deploy
the
ingress
controllers,
which
is
a
separate
piece
of
code
that
runs,
monitors,
kubernetes,
ingress
resource
and
configures,
the
external
load
balancer
or
internal
load
balancer
to
provide
the
actual
functionality
and
then
it
modifies
ingress
resource
will
load,
bouncer
AP
address.
So
as
a
user,
you
create
your
ingress
and
then
you
magically
get
the
IP
address
back.
That's
what
ingress
controller
does
that's.
A
What
controller
is,
if
you
monitor
something
it
does
something,
and
then
it
updates
the
resource
and
gives
gives
it
back
to
the
user.
So
now,
how
does
the
control?
What
are
the
ways
to
talk
to
the
kubernetes
api?
The
most
simple
and
the
most
user-friendly
way
is,
of
course
the
UI.
The
dashboard
then
cube
CTO
is
also
very
user
friendly.
If
you
prefer
CLI,
that's
a
great
tool
and
then
there
is
a
programmatic
access.
A
So
if
you're
gonna
write
your
tool
in
any
language,
go
whatever
you'd
probably
call
this
API
is
programmatically
you're
not
gonna,
be
calling
the
cube
control,
although
it's
like
cube
control,
has
a
bunch
of
commands
that
I
actually
appreciate
a
lot
like
you
see.
Tl
apply
it's
great,
so
yeah
programmatic
access
use
an
API,
but
then
how
are
you
call?
The
CEP
is
so
community's
API
server
is
just
the
HTTP
server
that
accepts
a
request
list
resources
get
the
resource
update
remove.
A
But
how
do
you
call
them
like?
Is
it
just
a
row?
Http
request?
No,
so
well
you
can
send
us
the
Royal
City
request,
but
they're
like
a
bunch
of
libraries
out
there
that
are
developed
for
different
languages,
for
Python
Java
go
and
as
any
language
you
can
think
of.
But
those
three
are
like
the
most
popular
one,
and
today
we
are
gonna
focus
on
the
top
one
client
client
that
go
so
that's
a
great
library
I've
been
using
it
a
lot.
A
A
It's
easy
to
use
and
it's
very
easy
to
be
used
for
applications
that
are
meant
to
be
deployed
in
the
container
and
that's
something
that
we
are
going
to
do
today.
So
the
best
way
to
learn
something
is
actually
to
build
something
from
scratch.
So
today
we're
gonna
build
the
tool
that
is
going
to
monitor
kubernetes
nodes
and
it's
gonna
alert
when
the
storage
occupied
by
the
images
Changez.
A
So
here's
the
link
to
the
to
the
repo
where
the
Tory
side,
it's
a
pretty
simple
tool,
but
you're
gonna
go
from
the
very
beginning
to
the
very
end,
you're
gonna.
Do
it
like
everything
so
I
as
a
developer,
I
like
to
sneak
a
pick
up
what
people
use
for
the
development?
What
makes
their
life
easier.
So
here
are
some
tools
that
I
use
for
Democratic.
Those
are
all
internal
tools,
open-source
we
just
use
them.
A
You
just
use
them
in
rancher
to
make
the
developer
life
easier
so
that
go
scale
if
you're
not
familiar
with
go,
and
you
wonder
what
should
be
my
go
project
structure,
you
can
just
run
this
tool
and
it
will
create
the
basic
structure
for
you.
It
will
even
create
you,
the
main
class
that
you
can
actually
invoke
and
run
without
any
compile
error,
then
the
trash.
So
it's
a
tool
that
manages
the
third-party
dependencies
usually
managing
third-party
dependencies
can
be
very,
very
painful,
and
there
are
many
tools
out
there,
but
I
like
this
one.
A
Just
because
it's
very
simple
I'll
show
you
how
I
use
it
and
then
there
is
tool
called
dapper.
So
if
you
have
an
application
that
is
meant
to
run
in
the
container,
then
you
would
probably
like
to
build
image
for
it.
I
use
Mac,
but
if
I
run
the
container,
it
can
be
a
one
two.
So
I
need
to
find
some
simple
way
to
actually
build
my
application,
so
it
can
run
on
a
bunch.
So
I
used
the
upper
tool
for
that
it
will.
It
will
span
the
container
we
want
from
the
one
to
image.
A
It
will
build
your
program
in
it
and
it
will
give
you
by
recognize
docker
image.
So
what
would
be
the
first
step?
The
first
step
would
be
to
add
client
that
go
dependency,
so
you
have
to
make
sure
that
it
this
that
the
dependency
is
compatible
with
whatever
could
be
or
natus
version
you're
using
so
I'm,
currently
using
them
in
for
this
demo
I'm
using
the
I
think
it's
for
that.
Oh
so
it
works
pretty
well
with
kubernetes
1.7
and
one
that
a
but
I
think
there's
a
newer
version
of
client
that
go.
It's.
A
It
shouldn't
be
any
different.
So
what
you
do
you
just
add
this
to
the
file
mentor
conf
and
then
you
just
run
the
trash
command.
The
tool
that
I've
shared
earlier.
What
is
going
to
do
is
gonna
pull
all
the
third-party
dependencies
to
your
project
and
that's
it.
The
job
is
done.
The
tool
is
pretty
smooth.
I
haven't
had
any
problems
with
that,
then
the
second
step,
so
you
define
the
vendor.
You
got
all
the
third-party
dependencies
that
you
need
by
the
way
it's
gonna
it's
gonna.
A
If
this
client
that
go
uses
some
other
dependencies
transitive
dependencies,
it's
gonna
put
in
as
well,
you
don't
have
to
define
them
in
this
file,
so
trash
will
do
all
the
job
for
you
to
figuring
out
what
needs
to
be
pulled
extra
and
that's
it
now.
The
second
way,
if
you
look
at
the
client
that
go
dog,
the
first
thing,
you're
gonna,
you're
gonna,
see,
is
like
how
you
wanna
run
it.
Do
you
want
around
your
tool
in
cluster
or
you
want
to
run
your
tool
outside
of
the
cluster
I'm?
A
Just
like
I,
don't
know
what
are
the
advantages
of
what
approaches?
So
what
did
what
does
it
mean
to
run
in
cluster?
It
means
that
your
application
is
going
around
as
a
part
of
the
content
inside
the
container
that
is
going
to
be
deployed
as
a
part
in
kubernetes.
What
advantages
it
gives
you
cuneta
is
going
to
manage
your
application.
You
can
configure
health
check
if
your
application
dies.
Kubernetes
is
going
to
bring
it
back.
If
you
want
to
run
it
on
every
node,
you
can
you
can
deploy
it
as
a
daemon
set.
A
Then
why
would
you
choose
to
run
application
outside
of
the
cluster
one
of
the
use
cases
I'm
working
on
I'm?
One
of
my
tools
actually
monitors
multiple
kubernetes
clusters,
so
it
has
to
be
deployed
outside
so
I
deployed
the
outside
around
as
a
binary
I
monitor
it
myself
then
another
way
like
another
good
use
case.
For
that
it's
like.
Let's
say
you
develop
something,
and
you
really
like
you
want
to
test
things
fast.
A
You
don't
want
to
build
the
image
every
time
you
make
a
change,
so
you
just
run
it
as
a
binary,
just
build
run
into
the
binary
and
then
at
the
end
you
can
choose
override.
At
the
end,
my
application
is
perfect.
I'm
going
to
deploy
it
in
cluster
I'm,
going
to
use
the
first
approach
for
testing
I'm
going
to
use
the
second
approach,
all
right,
devil
time,
I'm.
Switching
to
my
ID
I'm,
using
Visual
Studio
code
for
go
development
is
that
is
the
sisal.
A
Okay
should
I
make
it
bigger
it's
great
and
before
we
move
on
to
the
IDE
fun
part,
any
questions
about
the
previous
slides?
No,
alright!
Alright,
let's
move
on.
Let's
start
from
the
top,
so
in
go
here
all
the
imports,
it's
all
the
third-party
packages
that
I'm
using
in
my
tool-
and
this
one
is
my
favorite
one,
that's
a
CLI,
so
my
application
is
going
to
accept
the
config
parameter,
which
is
going
to
be
the
path
to
the
cube
config
file,
so
my
tool
can
run
outside
of
the
cluster.
A
A
Here
we
go
so
this
is.
This
is
the
part
where
you
actually
decide
on
how
you
wanna
how
you
want
to
run
your
application?
Do
you
want
to
run
it
outside
of
the
clustering
if
the
faster
config
is
not
empty,
then
you
use
this
package
to
build
the
config
from
the
content
of
the
file
from
this
pot
or
if
the
path
is
empty,
then
you're
on
it
in
clustering.
So
what
it
is
like?
What
are
the
internals?
So
usually
people
use
service
account
for
authentication
in
the
pod.
A
What
it
means
is
that
this
default
service
account,
if
you
don't
specify
anything,
is
going
to
be
a
sent
to
the
pod,
and
it
means
that
the
credentials
are
going
to
be
saved
somewhere
in
the
pod
and
this
tool.
It
will
know
where
to
look
for
them
to
initiate
that
in
cluster
can
see
once
the
config
is
created.
A
A
A
So
the
third
basic
function.
We
know
that
for
our
application
we
need
to
monitor
the
nodes.
So
we
need
to
get
the
list
of
the
nodes
somehow
for
that
I'm
gonna
call
client
set,
which
we
just
created
and
then
I'm
going
to
call
core
kubernetes
api
is
because
I
know
that
my
nose
at
the
part
of
the
core
kubernetes
api
is
and
then
I'm
going
to
say.
A
Okay,
so
I
need
the
nodes,
object
and
then
comes
the
operation
that
you
that
you
are
calling
for
this
node
function,
I
want
to
list
them
and
the
you
can
pass
the
list
option
parameters
like,
for
example,
you
want
to
filter
the
node
that
you
want
to
check
like
in
my
case
and
running
mini
cube,
which
is
pretty
simple
to
install
and
I
know
that
the
node
name
for
them
in
your
cube
is
always
mini,
cube.
So
I'm
just
saying:
okay,
give
me
the
mini
cube
now
and
what
it
can
give
you
back.
A
It
can
give
you
either
the
nodes
or
it
can
give
you
the
area.
So
there
is
something
something
went
wrong:
I'm
just
gonna
skip.
If
my
nose
are
fine,
I
got
them,
I
can
iterate
through
them,
but
I
just
choose
override
I'm
just
going
to
get
the
first
of
them
and
then
what
you
can
do
with
the
object
that
you
get.
You
can
update
it.
So
that's
a
second,
a
creation
that
I
demo
here.
So
basically
you
can
set
any
field.
A
You
can
reset
any
field
on
the
object
and
then
you
call
client
set
very
similar
to
the
list
you
can
just
instead
of
list.
You
call
update
and
you
pass
the
reference
to
the
node
and
here's
some
commanded
code,
which
demonstrate
removal.
I
didn't
want
to
remove
the
emini
cube
now
so
I
commented
it
out,
but
it's
pretty
similar,
like
you
also
call
the
client
set
for
api's,
you
call
the
delete
and
then
you
can
pass
the
delete
options,
which
is
pretty
cool,
like
you
can
say
alright.
So
what
is
grace
period?
A
I'm
passing
the
grace
period?
That
means
delete
my
object
but
delete
it
only
after
10
seconds.
So,
okay,
so
now
we've
got
the
client.
We
know
how
to
do
the
basic
crust
now,
it's
time
to
think
about
it
like
how
we're
going
to
implement
our
node
polling
so
yeah,
and
that
I
usually
start
simple
I,
don't
think
about
like
complicated
way
of
doing
things.
So
I
start
with
boiler
like
the
basic
way
to
do.
A
It's
like
you
only
need
to
get
the
information
when
something
gets
changed
like
we
are
interested
in
the
changes
in
the
images
storage
and
what
I
would
like
to
have
ideally
I
would
like
to
I
would
like
to
get
the
notification
when
something
gets
changed
for
the
node,
so
I
want
to
watch
for
the
changes
and
I
want
to
be
notified
on
understant
if
ocation,
outside
of
what
I'm
gonna
do.
So
that's
where
the
informers
come
and
now
what
is
the
informer
Informer?
A
It's
a
very
nice
way
of
watching
for
the
resource
and
actually
passing
the
callback
function,
which
can
be
called
when
the
resource
is
modified.
So
here
is
an
example.
Here
we
are
calling
the
cache
package,
which
is
the
part
of
the
client
that
go
here.
You
go
and
then
we
say:
okay,
give
me
the
informer
and
what
we
are
passing
to
the
informant.
We
are
passing
several
things
so,
first
of
all,
we
are
passing
on
the
instructions
of
how
we
want
our
resource
to
be
listed
and
how
we
want
our
resource
to
be
watched.
A
So
you
want
to
get
the
notes
and
well
know.
The
note
is
not
namespace,
so
we
just
say:
namespace
all
and
we're
gonna
get
all
the
fields.
So
we
are
passing
the
watch
list
and
then
we
are
passing
the
object
that
we
want
to
get
so
we
want
to
get
the
API
node
and
then
we
are
passing
our
callback
functions
and
we
are
passing
the
callback
functions
for
to
handle
the
ad
and
the
remove.
We,
don't
us,
add
an
update.
We
don't
care
about
the
remove,
because
we
know
what
once
the
node
is
gone.
A
We
no
longer
care
about
the
image,
storage
capacity,
so
I'm
just
saying:
okay,
call
this
functions
whenever
the
node
gets
added
and
whenever
the
node
gets
updated
and
there
is
one
more
parameter
that
you
can
pass
in,
which
is
a
received
period.
So
what
is
the
resting
period
sometimes
like?
Well,
there
are
no
perfect
things
in
the
world
and
sometimes
the
list
or
watch
can
break.
It
would
be
nice
to
have
some
backup
mechanism,
which
will
be
called
periodically
like
what
I'm
saying
here
like
every
30
seconds.
A
Even
if
nothing
happens
to
the
nodes,
please
give
me
them
back
so
I
can
I
can
do
something.
So,
even
though,
even
when
the
watch
function
fails
by
some
reason,
I'm
still
backed
up
by
this
periodic
calling
so
I
just
I
made
it
a
bit
extreme
like
30
seconds,
you
can
do
it
five
minutes
or
anything
you
like,
then
so
you're
passing
all
this
parameters.
A
What
are
you
getting
back
so
you're
going
you're
getting
back
the
controller
that
you
have,
that
there
is
going
to
actually
do
the
watches
and
you're
getting
back
something
else,
very
nice,
the
store,
what
a
store
this
is
cash,
so
you're
getting
back
the
cash
which
will
be
for
sure,
updated
to
the
latest
objects,
so
you're
a
tool.
If,
if
it's
needed,
you
don't
have
to
call
the
kubernetes
api
is
directly.
You
can
just
retrieve
the
objects
from
the
cache
and
that
will
actually
reduce
the
memory
footprint.
A
Now
there
is
an
informer
and
there
is
something
called
shared
informer.
So
what
is
the
difference?
What
is
in
whether
you
use
one
and
whether
you
use
another?
So
you
can
see
that
in
the
informer
you
you
can
define
one
function
for
every
I
creations
like
you
define
one
callback
to
add
one
go
back
for
update
and
you
get
the
cash
back
and
the
controller
share.
Informer
allows
you
to
actually
add
more
than
one
callback
for
the
function
and
it
gives
you
back
the
shared
cash
as
well.
A
So
let's
say
you
have
your
application
consists
of
multiple
parts
and
there
are
multiple
there
mark
actually.
Here
an
example:
I
give
just
the
same
function,
but
it's
usually
the
different
function
like
different
callback,
so
different
callback
are
interested
in
the
node
information
and
ideally
they
would
like
to
share
the
same
cache
so
to
reduce
the
memory
footprint,
that's
where
I
would
use
the
shared
Informer
all
right
and
that
before
we
move
on,
I
wanted
to
share
the
way
of
accessing
the
cache
that
we
got
back
from
the
informer.
A
So
here
is
an
example,
as
our
cache
stores
the
node
objects,
there
is
a
way
to
retrieve
it
by
the
name
which
is
going
to
be
the
cache
key
and
you
get
back
and
you
get
back
the
node
and
you
can
do
whatever
you
like
with
that.
So
what
we
did
we
created
the
config.
We
created
the
client,
we
decided
on
the
most
optimal
way
of
how
to
actually
watch
for
the
node
changes
and
well
now.
It
is
time
to
actually
run
the
application.
A
A
Right
it
works
and
just
to
share
that
the
the
structure
of
the
directory
it
has
some,
so
this
is
just
one
class
made
up
go.
This
is
a
binary
that
I've
just
created,
and
this
is
a
vendor
folder
that
we
previously
populated
with
trash.
So
we
can
look
at
it.
What
is
this
directory
structure
where
this
third
party
folder
structure?
A
It
has
a
bunch
of
stuff
on
it
and
if
you
look
at
the
kubernetes
data-
oh
that's
for
our
client.
That
goes
right.
So
we've
build
it
now
we
run
it.
How
do
we
run
it
here?
We
go
so
you
run
as
a
cube
con
and
then
you're
passing
the
config,
your
to
your
cube,
config
and
then
it
starts
doing
its
job,
but
no
changes
yet
so
the
first.
A
A
A
Yeah
the
tomb
works,
okay,
but
that's
an
example
of
how
to
run
it
outside
the
cluster,
so
you
run
it
as
a
binary.
Now
it
is
time
to
deploy
it
as
a
kubernetes
application
and
that's
gonna
be
fun
all
right.
So
what
do
we
start
with?
We
start
with
the
docker
file,
so
here's
a
doctor
file
that
I
use,
so
the
base
is
gonna,
be
a
bunch
of
and
that's
the
commander
he's
got
a
cold
which
is
my
binary
basically
and
now
how
I'm
gonna
build
this
image.
A
I'm
gonna
build
it
using
that
tool
that
I've
shared
earlier
called
dapping,
and
here
is
the
way
of
how
I'm
gonna
call
it
so
I'm
gonna,
say:
okay,
my
repo,
my
doctor,
bleep
was
going
to
be
aligned
around
zero.
Eight,
my
tag,
all
right.
Let's
make
it
today's
date,
I
always
change.
The
minor
version
because,
like
my
code,
is
never
that
good
to
change
the
major
version
so
V,
zero,
seven,
zero
and
then
I'm
gonna
call
that
Bray.
A
So
what
it
does
it
creates
a
docker
container
from
Ubuntu.
It
builds
the
application
in
this
Ubuntu
container
because,
if
I
build
it
on
Mac
and
then
I
try
to
run
it
on
Ubuntu
is
gonna
complain,
so
I
have
to
build
it
in
a
bun,
I.
Don't
but
and
I
don't
want
to
create
like
a
virtual
machine
of
something
so
I
build
it
inside
a
container.
A
A
The
output
is
like
it
just
gives
the
image.
So
here
you
see
it
built
the
image
cubic
on
V,
zero,
seven,
zero
so
and
it's
on
my
machine
so
now
I
have
to
push
it
to
the
doctor.
No,
no!
It's
on
my
machine
all
right!
So
I've
built
this
image
and
I'm
gonna
push
it
and
now
to
deploy
it
on
the
kubernetes.
We
have
to
define
the
llamo
file
again.
Let
me
let
me
remove
the.
A
A
A
Okay,
so
this
is
the
one
I'm
gonna
I'm
going
to
look
at
blocks
for
this
container.
Oh,
it
doesn't
like
something.
Let's
look
at
what
it
doesn't
like
so
looks
like
some
permissions.
That
said,
which
is
an
hour
back
I
have
our
back
in
enable
in
my
mini
queue.
So
it
means
that
by
default
nobody
can
just
run
their
tools
and
execute
any
random
API
calls
I
have
to
grant
the
permissions
to
the
tool
to
actually
do
something.
So,
let's
kill
this
bad
guy.
A
All
right,
so
what
are
we
gonna?
Do
we're
gonna
create
a
cluster
row
which
is
gonna
allow
to
operate
on
the
nodes
object
and
it's
gonna
allow
to
get
watch
lists
and
update.
So
all
the
code
that
we
use
in
the
tool
and
then
we're
going
to
create
a
service
account
that
can
be
later
on
assigned
to
our
application
and
we're
gonna
call
it
cube.
Khan
I
already
have
it
deployed,
I
think
so.
I'm
just
gonna
call
apply
to
the
right
stuff,
all
right
and
now
we're
going
to
deploy
the
proper
application.
A
A
A
A
No
difference
is
just
another
definition
and
I,
usually
like
okay,
what
I
see
a
new
definition
I
think
it's
a
new
thing,
but
it's
usually
the
same
thing.
Just
you
know
explain
differently.
So
controller
is
something
that
just
does
this
custom
stuff
outside
of
the
kubernetes
so
but
it
can
be
deployed
in
the
regular
pod.
It
can
be
deployed
as
a
deployment.
Anything.
A
A
So
usually,
I
use
Alpine
actually,
but
this
tool
that
I've
shared
earlier
the
go
scale
that
actually
creates
the
basic
structure
it
uses
a
bun
I'm,
not
sure
why
I'll
find
is
my
favorite
one,
because
it's
so
tiny,
and
just
for
this,
you
don't
need
one.
You
don't
need
a
wanta
for
this
kind
of
functionality.
A
A
It
can
be
anything
can
be
monitoring.
This
is
basically
bringing
the
resource
from
the
DS
from
the
actual
state
to
the
desired
state.
That's
how
they
put
it
and
that's
how
like
I
explained
it
for
the
ingress
controller
like
ingress.
What
is
the
desired
state
of
the
ingress?
Just
give
me
the
access
to
the
load
balancer
and
what
is
the
actual
state
like
when
the
user
creates
ingress?
He
just
says
okay,
so
what
I
want
to
do?
I
want
to
balance
between
service
a
and
service,
be
my
desire.
A
A
A
A
This
watch
is
just
an
instruction
for
the
informer
on
how
to
how
to
watch
the
resources.
So
here
what
I'm
going
to
do?
I'm
gonna
watch
on
the
no
changes
like
all
the
nodes
in
my
system.
Please
watch
for
their
changes
whenever
the
add
or
update
happens,
call
these
functions
and
those
are
mine,
functions.
A
A
If
you
do
Oh
Jason,
it
will
give
you
like
the
entire
object
because
keep
CTL
doesn't
display
you
everything.
So
you
look
at
the
the
Jason
output
and
what
do
you
see
here?
You
actually
see
all
the
images
oh
yeah,
somebody
yeah.
So
it
gives
you
the
list
of
the
images
with
their
names
and
the
respective
sizes
so
and
yeah.
If,
if,
if
node
object
gets
changed
gets
changed,
it
doesn't
mean
that
the
image
gets
changed,
but
we
like,
we
are
making
our
best
effort
here.
So.
A
A
Just
it's
the
the
advantages
of
that
is
basically
a
cache.
You've
you've
said
that
cache
is
very
important
and
then
it
handles
all
the
like
a
failure
cases
like
what,
if
what,
if
the
connection
to
the
API
server
is
lost,
then
it's
going
to
handle
it
for
you,
so
you
don't
have
to
worry
about
it's
like
okay.
If
something
wrong
just
go
this
way,
so
the
inform
is
gonna
handle
it
for
you.