►
Description
client-go: The Good, The Bad and The Ugly - Lili Cosic, Kinvolk
This talk will focus on client-go, a go client for talking to Kubernetes clusters. At Kinvolk we have used client-go in various Kubernetes projects. Lili will share the general use-case of client-go and explain how powerful it is to customize, optimize, and automate tasks with it. Furthermore she will explore the parts that client-go is great at, as well as the parts that can still be improved. Lili will end with a demo showing how easy it is to harvest the power of client-go, and showcase how it can be used to customize your Kubernetes experience and solve real problems.
About Lili Cosic
Lili is a Software Developer at Kinvolk, a Berlin-based Linux development consultancy, where she works on a variety of projects surrounding Linux. Currently she is working on a Habitat Operator, a controller to easily create and manage Habitat Services on Kubernetes. In her free time she enjoys experimenting with Kubernetes. Previously she worked at Wimdu, as a Ruby developer, helping build tools to process large amounts of data.
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
So
at
the
time
I'm
submitting
this
talk,
because
the
topic
is
titled
to
get
the
bad
and
ugly
I
was
very
frustrated
with
clang
go
so
I've
come
to
terms
with
it
a
bit
better,
but
at
a
time
we
were
trying
to
extend
some
things
that
really
didn't
work,
then
so
yeah,
but
I
will
try
to
end
on
a
positive
note
and
try
to
hopefully
do
some
constructive
criticism
rather
than
bashing
it.
So
my
name
is
Lilly
I'm
a
developer
at
kinfolk,
and
why
am
I
qualified
to
talk
about
the
client?
Go!
A
It's
basically
because
I
worked
on
a
few
personal
projects
that
in
heavily
included
Congo,
as
well
as
the
habitat
operator,
which
I
do
at
work
with
chef
and
basically
that
heavily
relies
on
it.
So,
as
I
mentioned,
I
work
at
can
Falk
we
have
a
boot.
So
do
you
come
and
see
us
and
talk
to
us
we're
basically
a
consultancy
based
in
Berlin?
So,
let's
start
a
bit
about
the
good
gifts
er
turning
out.
Okay,
sorry
for
it's
very
good
heavy,
so
I
apologize
for
that!
A
A
It
has
563
stars
which
is
the
most
important
metric
and
their
responsibility,
for
it
is
the
sick,
API
machinery
and
they're
really
nice.
So
do
you
go
over
to
their
slack
Channel
kubernetes?
If
you
have
any
questions
about
that,
so
some
of
the
use
cases
of
it's
mainly
used
in
operators,
as
you
may
have
heard,
of
them-
they're,
basically
controllers
and
kubernetes
and
they're
they're
used
to
extend
the
kubernetes
api.
A
So
let's
first
set
up
a
client,
so
basically
we
will
try
to
communicate
with
the
kubernetes
api.
So
here
we
see
we
only
need
a
few
lines
of
code
to
actually
get
all
the
functionality
and
all
the
power
from
it.
So
first
we
get
the
config
and
we
do
that
by
building
it
from
flags
and
if
the
flags
are
not
present
it
defaults
to
in
cluster.
A
So,
as
I
mentioned
before,
there
are
two
ways
to
do
that:
you
can
run
it
outside
of
the
cluster.
So
basically
that
is
if
you're
developing
for
it
or
if
you
have
some
special
use
cases
for
it
and
that
basically,
you
just
pass
in
your
path
to
the
cube
config
and
everything
works.
Fine
and
you
can
also
customize
the
master
aerial.
Has
anyone
done
that?
No
so
I
guess
no
one
uses
it
and
inside
of
the
cluster.
A
So
once
you
actually
have
the
client
set.
This
is
how
easy
it
is
to
actually
communicate.
So
this
is
used
to
list
the
deployments,
and
all
you
need
to
do
is
just
access
through
the
client
set
the
deployments
resource
and
you
just
list
all
the
resources
in
the
default
namespace.
Here
we
can
pass
in
some
different
parameters
like
the
field
selectors
or
labels.
A
So
what
actually
happens
behind
the
scene
is
that
the
list
we
saw
earlier
in
the
previous
slide.
That
is
basically
just
this:
it's
basically
just
an
extraction
or
a
helper
to
communicate
to
talk
to
the
coronaries
cluster.
So
basically,
it's
just
to
get
them
requests,
nothing
more
than
that
if
there's
no
magic
behind
it.
So
yeah,
this
is
all
this.
It
just
makes
your
life
much
easier,
so
you
don't
have
to
actually
re-implemented
rating
yourself,
it's
quite
powerful.
A
So
how
actually
client
go
goes
about
doing
all
of
this.
It's
basically
outer
generated
from
kubernetes
itself,
and
it
does
that
by
using
the
kubernetes
under
the
kubernetes
repoed,
the
staging
area
and
it's
published
by
a
bot-
and
these
are
their
repositories
that
are
generated
and
you
can
see
climb
goes
up,
one
of
them
and
we'll
see
some
of
the
other
ones
a
bit
later.
A
So
I
mentioned
earlier
that
the
kubernetes
climb,
though,
uses
indirectly
kubernetes
flying,
though
uses
covering
ideas,
uses
client
go
indirectly
and
basically
an
reality
is
all
just
a
symlink
and
the
ventura
directory.
As
you
can
see
here,
all
of
these
the
API
server
the
client
go.
There
are
all
just
some
links
to
the
same
staging
area
in
their
vendor
directory,
so
it
doesn't
import
in
a
way
that
we
vendor,
if
use
it
from
a
developer
point
of
view.
So
from
a
consumer
point
of
view.
A
A
So
that
is
basically
just
a
it's
shared
dependencies
for
servers
and
clients
to
work
with
the
coordinators
API
without
actually
using
the
direct
type
dependencies.
Basically
and
the
consumers
are
Nettie's
itself,
client
go
and
also
the
API
server,
and
now,
let's
discuss
a
bit
about
the
bad
part
or
I
would
like
to
call
it
frequent
points
of
friction
because
I
think,
like
all
of
these
things,
had
a
reason
why
they
were
done
this
way
and
some
of
the
maintainer
czar
here
and
I.
Don't
want
them
to
be
angry
at
me,
so
yeah.
A
So
this
is
mainly
when
you
first
come
across
client
go
and
when
you
first
use
it,
these
are
the
I've
noticed.
A
couple
of
people
had
the
same
pain
points.
So
in
general,
lots
of
people
agree
that
it
does
a
bit
too
much
so
meaning
that
you
end
up
importing
the
whole
world
when
you
just
want
to
communicate
with
the
kubernetes
api.
So
we'll
see
that
in
a
second
and
things
that
it
does
are
a
bit
disconnected.
A
So,
meaning
that
you
have
a
lot
of
clang
go
packages,
and
this
is
how
it
looks
so
this
is
the
minimal
example.
We
have
that
we
have
in
our
vendor
directory,
and
this
is
how
much
packages
we
imported
from
client
go,
for
example,
so,
yeah
it's,
it's
impressive,
isn't
it
and
some
of
these
packages,
like
I,
mentioned
before
they
do
quite
various
things
over
time
we
have
things
from
you
communicate,
which
is
the
purpose
right,
but
they're,
not
that
much
related
at
first
glance,
so
you
have
the
work
queue
which
is
just
a
queue:
implementation.
A
That's
in
the
package
util
we're
cute.
Then
you
have
the
tools
cache,
which
is
for
writing
controllers.
So
it's
not
really
how
you
expect
from
the
client
library,
but
once
you
get
used
to
it,
you
you
understand
another
friction
or
another.
Bad
thing
is
the
API
versions.
So
this
is
a
question
one
of
my
co-workers
had
when
he
first
started
with
it
is
that
you
can
get
quite
confused
by
what
the
different,
what
is
alpha
1-4
one
bitte
ones
table,
and
what
are
all
these
versions
like?
A
A
So
the
first
one
is
the
development
one
and
it's
not
something.
Many
people
actually
come
across
because
it's
not
actually
committed
or
available
in
the
releases.
It's
made
basically
just
for
testing
out
new
features
and
up-and-coming
features
and
doing
proof-of-concept.
Then
the
next
one
which
I'm
sure
some
of
you
have
thought
seen
as
the
alpha
level
one.
A
So,
like
mentioned,
there's
this
table
version,
which
is,
for
example,
version
1
and
that's
enabled
by
default
and
all
users
and
it's
considered
stable.
So
this
is
the
API
changes
in
the
1.9
for
Nadi's
version.
So,
as
you
see,
there's
not
that
many
documentation
and
I
think
that's
where
people
find
this
very
confusing.
There's
not
that
many
documentation
on
which
resource
is
in
which
version
in
which
kubernetes
or
client
go
version.
So
that's
one
of
the
points
where
documentation
would
be
very
helpful,
but
it's
really
hard
to
do
so.
A
For
example,
one
of
the
things
that's
surprising
to
lots
of
people
is
that
the
deployments
are
still
in
beta
and
they
have
been
so
for
I.
Think
since
3
minor
versions,
but
in
one
point
night,
they're
gonna
actually
graduate
to
this
table.
So
that's
good,
but
one
the
problems
with
that
is
that
you
actually
have
to
then
update.
But
we'll
come
back
to
that.
So
the
next
one.
A
The
next
chapter
is
the
ugly
or
things
that
are
not
so
nice,
so
basically
the
main
problem
that
lots
of
people
have
who
work
on
developer
tools
and
from
a
developer
point
of
view.
So
let's
say
operators
of
different
kind
of
controllers
that
you
use
is
that
the
kubernetes
releases
happen
every
three
months
right
and
you
have
to
then
upgrade
because
there
are
things
like
out
of
updating
clusters
and
everyone
wants
the
latest
release
and
for
the
tool
to
work
right,
but
so
for
the
1.8
release.
A
There
was
a
bit
of
a
delay
with
Kengo
so
that
didn't
quite
work
out
very
smoothly,
so
yeah
so
actually
updating
your
project.
Your
project
would
only
work
as
well
for
some
versions.
So,
as
we've
seen
earlier,
the
current
deployments
are
gonna,
be
in
1.9
stable.
But
if
you
want
your
cluster
to
work
for
1.6
and
1.9,
it's
not
really
gonna
work
that
well.
So
that's
one
of
the
pain
points,
so
our
back
is
in
beta,
but
you
have
to
actually
adapt
things
because
only
four.
A
It's
only
supported
for
two
versions:
two
consecutive
versions:
the
API
changes.
So
that's
one
of
the
pain
points,
because
when
you
have
to
actually
upgrade
your
developer
tools,
you
have
to
be
very
quick,
as
three
months
is
not
that
much
before
client
go
actually
gets
released
before
you
can
catch
up
and
test
everything.
A
So
and
one
of
the
other
things
is
this
matrix,
so
this
is
basically
how
the
climb
go
is
compatible
with
the
kubernetes
versions.
And
if
you
can
see
the
green
lines,
it's
basically
mainly
compatible
with
the
version.
Everything
else
is
either
a
breaking
change
or
not
that
well
compatible
and
you
have
to
basically
you
have
to
support
the
latest
version
of
kubernetes
or
just
support
the
earlier
version,
unless
you
want
to
do
some
magic
there.
A
Another
point
of
friction,
I
noticed,
is
that
you
so
if
we've
seen
earlier,
this
is
how
you
list
all
the
deployments
and
if
you
notice,
there's
the
in
the
red.
This
is
not
part
of
client
go
itself,
but
it's
part
of
the
API
machinery.
So
if
you
just
want
to
list
deployment-
which
is
the
simplest
thing
right,
you
have
to
actually
import
API
machinery
to
be
able
to
listen,
and
then
that
tends
to
end
up
being
looking
something
like
this.
So
this
is
actually
from
our
habitat
operator
and
yeah.
A
A
So
let's
have
a
look
at
that,
so
what
it
does
is
it
basically
takes
the
deployment
and
it
creates
it
first,
with
instance,
one
and
after
it's
been
created,
we
scale
up
to
ten
as
simple
as
that
and
what
we
do
is
we
first
create
the
deployment.
Can
you
see
that
and
we
pass
in
the
deployment
which
looks
like
this,
so
the
deployment
representation
and
after
that,
every
five
seconds?
We
basically
roll
out
a
new
deployment,
and
we
do
that
by
using
the
update.
A
So
hopefully
this
works
so,
and
you
can
use
this
to
extend
things
like
you
can
do
canary
deployments
and
extend
this
even
more
and
it's
quite
cool
and
really
simple.
It's
only
a
few
lines
of
code
that
you
use
to
be
able
to
just
make
the
kubernetes
experience.
Much
nicer,
let's
see,
okay,
so
okay
cool,
it
works,
let's
yeah,
okay,
so
basically
we
here
created
a
new
deployment
and
now
every
time
five
seconds
we're
scaling
up
by
one.
A
Hopefully
we
should
be
scaling
yeah,
okay,
so,
as
you
can
see,
you
can
do
this
whatever
you
want
with
a
very
simple
amount
of
time,
so
it
took
me
like
I.
Don't
know
five
ten
minutes
to
do
this.
So
it's
not
that
just
don't
look
at
the
code
quality,
so
yeah
and
after
10
seconds
after
10
instances
it
will
actually
shut
down
and
we
will
have
ten
deployments,
kill
them,
so
it
should
shut
down
and
we'll
have
a
look
at
the
deployments
using
cube,
CTL.
A
So,
let's
have
a
look
at
a
bit
more,
so
there
are
many
different
alternatives
or
different
implementations
of
languages.
So,
for
example,
there
is
another
go
implementation,
the
kubernetes
one
by
Eric
and
it
has
on.
It
only
brings
two
dependencies
with
it.
So
it's
a
nice
alternative
for
something
smaller
and
quicker
to
do
so,
for
example,
if
you
want
to
do
a
small
project,
but
it's
not
full-featured
yet
from
what
I'm
aware,
but
do
check
it
out.
A
A
So
a
bit
about
the
future.
I
was
speaking
to
a
few
maintainer
'he's
here
of
client
go
and
other
tools.
So
basically
the
future
is
quite
bright,
so
I
do
want
to
leave
on
a
positive
note
as
I.
There
was
lots
of
discussions
here
as
well
at
cube
con
about
this,
so
there
in
the
upcoming,
so
for
kubernetes
version
1.9
there
will
be
climb,
go
6.0
and
that
will
be
much
easier
to
update.
A
There
will
be
no
at
least
no
major
breaking
changes
planned
is
what
I
was
told.
So
hopefully
there
will
be
released
tags
there
already
introduced,
so
you
can
actually
vendor
things
much
nicer.
There
are
release
notes
for
developers,
so
they
know
what
actually
breaks.
So
you
can
change
it.
You
can
plan
things
and
also
there
are
nightly
releases.
Fixed
for
client
goes
soon,
so
that
you
can
actually
test
things
and
there
is
a
new
channel
on
the
kubernetes
slack
channel.
A
So
it's
called
klein
go
docks
and
it's
a
place
to
improve
on
the
documentation,
so
do
check
it
out.
If
you
want
to
contribute
something
something
you
know,
please
have
a
look
everyone's
really
nice.
It
should
be
a
community
effort
and
we
should
all
contribute
some
documentation
to
make
lives
easier
for
people
and
hopefully
not
need
talks
like
this
in
the
future
and
and
this
cube
con
there
was
a
bunch
of
discussions
as
well
from
different
points
of
view
and
on
the
future
of
actually
of
client
going
and
other
projects
and
their
libraries
so
yeah.
A
A
B
A
We
use
Depp
and
so
far
it
worked
fine
for
us,
so
I
am
a
bit
confused
by
everyone
complains
about
it,
but
we
haven't
switched
it
yet
we're
planning
on
switching
to
1.9
so
5.0,
because
we
haven't
had
many.
We
don't
use
our
back,
so
we
don't
need
to
switch
that.
So
we
didn't
have
to
switch
too
much
with
this
version,
but
you
know
come
and
ask
me
after
we
switch
to
1.9
but
yeah.
So
far,
Depp
works
for
us,
but
there
is
Glide
apparently,
is
also
good.
There
is
some
documentation
for
that.