►
Description
Want to view more sessions and keep the conversations going? Join us for KubeCon + CloudNativeCon North America in Seattle, December 11 - 13, 2018 (http://bit.ly/KCCNCNA18) or in Shanghai, November 14-15 (http://bit.ly/kccncchina18)
Seamless Development Environments on Kubernetes using Telepresence - Ara Pulido, Bitnami (Intermediate Skill Level)
When developing API extensions or services that deeply integrate with Kubernetes, you may find yourself juggling kubeconfig contexts or iterating through a slow build-push-deploy cycle. Telepresence allows you to develop services locally as if they were running in your cluster. It does this by proxying pods to your local machine and gives your local services seamless access to service discovery and volumes. With Telepresence, you no longer have to maintain Docker Compose files for local orchestration, and you can take full advantage of Kubernetes features such as Ingress, Secrets/ConfigMaps, RBAC and more. In this demo-led session, we’ll take a look at how Telepresence works, the different ways you can use it and how it makes iteratively developing on Kubernetes a breeze.
About Ara
Ara Pulido is an engineering manager with more than 10 years of experience working on open source companies. She manages the Kubernetes and SRE teams at Bitnami. She is a Certified Kubernetes Administrator.
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
So
thanks
thanks
a
lot
for
coming.
My
name
is
arable,
even
I'm
in
general
manager
at
bitNami.
This
is
actually
my
second
cube
cons
and
still
pretty
new
to
the
community
and
for
the
next
few
minutes,
I'm
going
to
be
talking
about
a
tool
that
we
discover
in
the
previous
cube
con
in
Austin
and
since
then
has
become
a
key
piece
of
our
development
process.
A
So,
first
of
all
who
we
are
so
bitNami
is
a
leader
in
application
packaging.
We
have
more
than
a
hundred
and
twenty
applications
on
the
cloud
market
places
like
AWS,
assured,
DCP,
etcetera
and
that's
how
a
lot
of
people
know
us
and
a
couple
of
years
ago
we
started
investing
a
lot
in
containers
and
kubernetes
and
with
the
application
packaging
in
our
DNA.
We
invested
a
lot
in
home
and
we
actually
continue
maintaining
more
than
20
of
the
Official
Charts
there,
and
but
we
also
do
a
bunch
of
open
source
projects.
A
There
are
always
on
the
application
deployment
area
of
kubernetes,
so
we
have
cublas,
which
is
a
server
list,
premiere
for
kubernetes
cube
ups,
which
is
application
dashboard
for
communities
for
your
cluster,
which
is
actually
the
application
that
we
use,
telepresence
for
and
others
like
Syl
secrets
or
cube
C
of
G
that
we
develop
with
with
Hep
C,
o-silk
secrets
and
others.
And
since
we
started
investing
a
lot
in
kubernetes,
we
also
did
that
internally.
A
So
we
run
many
of
our
workloads
in
our
kubernetes
cluster
and
we
love
kubernetes
as
a
production
environment
for
your
contrariwise
applications,
and
but
it
seems
like
the
development
process
for
it.
It
was
like
a
little
bit
of
an
afterthought
and
it's
really
when
you're
developing
full
communities.
Suddenly
it
becomes
very,
very
difficult
to
manage
so
just
to
put
an
example
of
a
very,
very
simple
cloud
native
application
very
quickly.
A
It
becomes
this
micro
survey
architecture
where
you
may
have
different
increases
rules
that
redirect
traffic
to
to
a
fronting,
maybe
a
web
UI,
and
that
web
UI
may
talk
to
one
or
different
services
on
the
back
end
and
those
services
may
talk
to
each
other
and
they
may
need
to
talk
to
you,
for
example,
an
external
database
or
another
external
service
that
may
not
be
in
your
cluster.
So
even
with
a
very,
very
simple
app,
it
suddenly
becomes
this
this
difficult
master
to
handle
on
the
development
process.
A
So
how
we've
been
doing
that
historically
is
basically
replicating
our
architecture
in
production,
in
a
docker
compose
and
and
making
this
little
trick
that
we
will
do
like.
May
we
may
have
a
config
map
in
kubernetes
and
we
may
replace
that
with
just
a
volume
mount
on
docker
compose
and
we
may
replace
our
cigarettes
with
just
an
M
variable
and
we
may
have
several
services
described
therefore,
for
service
discovery
and
we
may
have
our
volumes,
etc,
etc
and
as
the
application
grows,
you
have
to
keep
maintaining
those.
Those
two
manifests.
A
So
the
manifests
that
you
running
production,
the
ones
that
you
use
in
docker,
compose
to
to
develop
and
they
may
diverge
and
then
you
may
you,
you
may
find
regression
so
things
do
not
work
exactly
as
you
expect
and
when
you
go
to
your
cluster
and
also
there
are
things
that
are
not
that
easily
described
on
on
a
docker
compose
like
your
ingress
rules
or
jobs
and
cron
jobs
or
your
inner
containers
or
you
are
back
rules
and
your
cube,
config,
etc,
etc.
So.
A
Then
there
is
the
second
solution
with
is
having
this
development
cycle
of
you
build
your
image.
You
make
a
change,
you
will
your
image,
you
push
it
somewhere
to
a
registry,
hopefully
on
your
cluster,
maybe
somewhere
else.
You
change
your
manifest,
or
maybe
your
manifest
are
pointing
to
a
deaf
image
directly.
So
you
test
your
changes,
doesn't
work
and
you
do
that
over
and
over
again-
and
this
can
become
very,
very
slow.
A
So
obviously
this
is
a
problem
that
a
lot
of
people
are
thinking
of,
and
there
are
several
solutions
that
are
out
there
and,
as
I
said,
we
discovered
telepresence
last
cube.
Con
is
a
tool
by
a
company
called
data,
wear
and
very
very
high
level.
What
it
does
is
allows
you
to
run
a
process
that
is
fully
connected
to
a
cluster
and
that
cluster
could
be
on
your
local
environment
with
mini
cube,
but
it
also
and
ideally
will
be
elsewhere
in
the
cloud.
So
you
can
have
all
the
computer.
A
You
need
or
the
memory
that
you
need
to
run
the
different
services
that
you're
not
actually
debugging,
you're,
not
actually
developing,
but
your
application
may
need
to
talk
to
you,
so
how
it
works
is
a
telepresence
will
deploy
a
two-way
proxy
into
your
cluster
that
start
processing
data
from
your
cluster
to
client
running
or
your
local
machine
and
back
and
basically
what
it
gives
you.
It's
you
get
service
discovery
with
fool,
dns
resolution
from
your
local
machine,
so
you
can
talk
to
any
of
the
services
that
are
in
your
cluster
in
a
seamless
way.
A
A
A
Then
you
have
inject
ECP,
which
basically
injects
a
shared
library
into
the
processor
that
you
want
to
run
and
with
a
clear
limitation
that
it
doesn't
work
with
statically,
linked
processes
like
go
and
then
talker,
which
is
very
similar
to
the
VPN
process,
with
the
difference
that
instead
of
running
just
a
process
it
will,
you
can
allows
you
to
run
an
image
that
you
already
built
which
works
well.
If
you
already
have
this
container
native
development
process,
where
your
build
process
is
not
building
your
app
is
building
your
app
and
building
a
docker
image.
A
A
So
the
first
one
is:
it's
very
simple:
it's
just
to
show
you
all
these
service
service,
discovering
it
volumes,
etc
that
you
can
have
so
we
have
this
couple
of
pots
in
a
cluster
but
I
when
I'm
running
this
on
mini
cube,
just
to
avoid
using
networking
too
much.
But
yes,
the
the
idea
is
that
you
would
have
a
development
cluster
in
the
cloud
or
in
your
service
in
premise
to
do
this.
A
A
It's
just
as
simple
as
that.
We
use
it
as
an
example
of
a
service
that
may
be
running
on
your
cluster
is
not
the
one
that
you're
developing
that,
but
your
your
you
need
to
talk
to
it
as
part
of
of
your
application,
and
then
we
have
this
telepresence
test
that
let's
check
what
it
is,
it's
part
of
our
deployment.
A
It
has
an
init
container,
so
you
can
see
that
we
can
still
use
init
containers.
The
only
thing
that
it
does
is
mounting
the
the
volume
called
data
into
among
path,
slash
data
and
just
creates
just
a
simple
random
string
on
a
file,
and
then
we
have
our
main
container,
which
has
here
an
environmental
variable.
It's
not
a
real
secret
in
this
case,
but
it
could
be
a
key
breath
to
a
real
secret.
A
It
will
still
work
and
then
you
have
the
same
volume
mount
and
basically
it
reads
the
the
file
that
it
was
supposed
to
be
created
by
by
the
container
and
the
volume
is
just
simple,
empty
and
tear.
So
obviously,
if
we
check
the
logs
of
that
port,
we
have
random
data
there
as
respected,
and
now,
let's
imagine
that
there
is
something
not
going.
Okay,
we
didn't
get
random
data
there
there's
something
going
wrong.
We
may
think
that
it's
something
with
the
volumes,
something
with
the
unit
container
want
to
do
back
a
little
bit.
A
Let's
watch
here
the
the
pots
as
well,
but
I'm
not
telling
telepresence
to
run
any
process
on
top.
So
what
it's
going
to
do
is
to
start
a
a
bash
session
that
is
already
connected
to
to
my
cluster.
So,
as
you
can
see,
what
is
happening
is
it's
swapping
the
deployment
and
we
will
see
when
it
finished
what
it's
actually
doing
so
and
the
obviously
swapping
is
changing
the
deployment
and
the
deployment
controller.
The
replica
controller
is
doing
its
thing.
A
And
basically,
some
things
that
it
says
here
so
it
says
the
restarting
the
VPN
method,
that's
the
default
one.
So
that's
the
one
that
is
going
to
use.
If
you
don't
tell
it
otherwise,
and
then
it
says
volumes
are
rooted
at
telepresence
root
and
it
says
that
no
traffic
is
being
forwarded
from
from
the
deployment
through
my
pot,
we
will
see
on
the
second
demo
how
to
use
that,
and
so
let's
check.
A
We
have
our
in
it
container
still
here
and
we
have
the
main
container
with
our
important
environmental
variable,
some
special
variables
coming
from
telepresence
and,
as
you
can
see,
the
image
has
changed
from
the
busybox
image
that
I
was
using
to
the
telepresence
proxy
image
so
back
to
the
shell
that
is
connected
to
you
into
my
cluster.
So
let's,
let's
check
first
volume,
so
volumes
are
rooted
at
telepresence
root.
So
let's
go
there.
A
A
A
Lastly,
we
have
remembered
that
we
were
running
this
service
on
for
5000
called
hero,
TM
that
basically
return
a
JSON
with
a
random
code,
so
directly
from
here
from
my
local
machine.
I
can
call
Co
TM
on
and
I
can
use
the
same
DNS
service
discovering
cabrini.
So
if
it's
running
on
a
different
name,
space
that
I
have
access
to,
I
could
use
dot,
name,
space,
etc,
etc.
To
get
access
to
it
and,
as
you
can
see,
it
works,
it
feels
like
I'm
executing
into
a
container
inside
my
classifier.
A
A
A
A
A
Us
dashboard:
it's
going
to
start
this,
this
application,
that's
what
you
can
do
with
it.
You
have
access
to
your
home
deployments.
We
are
using
actually
not
only
using
Tila
directly
by
using
something
we
call
healthy
Rd,
which,
for
every
every
deployment,
increases
your
the
object,
and
there
is
a
controller
looking
after
it.
We
have
a
set
of
charts
available
on
different
red
poles.
You
can
add
repositories
if
you
need
to-
and
this
thing
for
example,
is
happening
also
with
a
different
deployment-
a
different
CRD
functions
through
cublas.
A
We
have
function
as
a
service
in
cubes
with
cublas
integration,
so
you
can
have
find
any
function
that
you
you
may
run
here.
Each
of
these
functions
in
cube
list
is
again
a
Ciardi
called
function,
and
then
also
you
can.
It
has
service
catalog
integration.
Service
catalog
is
an
API
extension
for
communities
that
allows
you
to
connect
external
services
provided
by
what
is
called
a
service
broker
into
into
your
cluster,
and
this
again
is
a
sign
extension
of
the
API.
A
A
A
Although
there
are
people
on
our
development
team
they're
using
VPN
as
well,
so
both
work
well
and
also
we
are
telling
it
to
ready,
break
all
the
traffic
to
on
the
cluster
on
port
8080
on
that
pot
to
port
3000
on
on
the
local
port
and
the
reason
why
we
are
doing
that
is
because
we
are
then
going
to
run
a
development
server
for
that
for
that
application.
That
is
running
on
on
port
3000
by
default.
A
A
A
So
it
says
now
that
is
listening
on
localhost
3000,
but
instead
we
are
going
to
access
through
this
proxy
to
our
to
our
cluster,
that
we
just
that
we
just
created
and
actually
now
that
it
refreshes
this
UI
is
actually
running
on
my
on
my
local
machine
group
for
3000,
so
and
I
still
have
access
to
all
the
service.
Catalog
classes
that
I
have
in
my
for
this
particular
broker
functions,
the
charts,
applications
etc.
A
B
Does
this
work?
Okay?
Yes!
So
thank
you
for
the
great
demo.
So
what
we're
working
on
so
telepresence,
it's
all
open
source,
we're
actually
taking
it
through
the
CNCs
sandbox
process.
Right
now,
from
from
a
sort
of
governance
and
open
sourcing
perspective,
the
the
from
a
development
perspective
were
focused
a
lot
around
robustness
and
speed.
One
of
our
use
cases
to
talk
about
is
the
Caltrain
use
case.
B
So
if
you've
been
to
Silicon
Valley,
a
lot
of
developers
take
Caltrain
from
South
Bay
up
into
the
valley,
and
there
are
bad
spots
for
Wi-Fi,
and
so
you
can't
do
reconnect
with
with
telepresence
right
now.
So
we
want
to
support
things
like
reconnect
and
better
performance
on
behavior.
When
you
have
bad
network
connections,
improving,
startup
speed,
we've
done
a
lot
of
work
around
cleaning
up.
B
You
can
see
you
saw
from
the
demo
how
we
actually
swap
out
the
deployment
put
in
a
proxy,
and
there
were
certain
situations
where
we
would
leave
that
proxy
hanging
out
on
the
cluster.
We
want
that
behavior
to
improve.
So
we've
done
a
lot
of
work
on
robustness,
we're
doing
more
deployments
at
larger
organizations
that
do
a
lot
of
have
a
lot
of
our
back
controls
in
place.
So
we've
been
doing
going
through
and
auditing
the
permissions
that
telepresence
needs,
so
you
need
to
actually
use
it.
B
We're
also
looking
at
transitioning
away
from
inject
TCP,
because
it
requires
hacking,
LD,
preload
or
didn't
live
on
your
laptop,
which
is
actually
very
difficult
for
a
maintenance
perspective.
So
we
are
actually
exploring
other
strategies,
so
you
can
actually
support
running
telepresence,
even
though
you
have
VPN
clients
so
and
then
we're
also
looking
at
some
more
future.
Looking
use
cases
around
things
like
traffic
shadowing
copying,
production
traffic
or
a
percentage
of
production
traffic
to
your
local
laptop
for
production
testing
simplifying
the
UX.
So
you
can
actually
have
a
config
file
for
configuring
it.
B
A
lot
of
people
are
asking
us
around.
How
do
I
configure
this
with
build
system?
X
like
they
want
to
run
it
automatically
part
of
Gradle
or
use
it
with
particular
IDE
s,
and
how
do
you
copy
environment
variables
from
my
local
process
into
my
IntelliJ
IDE?
So
we're
trying
to
do
a
little
bit
of
work
around
that
and
and
also
supporting,
is
Tia.
So
some
some
users
have
actually
manually
integrated
telepresence
with
sto
so
that
you
can
actually
authenticate
to
your
main
website.
B
B
B
C
B
A
D
Just
to
make
sure
that
I
understood
correctly,
the
only
usage
currently
is
for
static
files,
changes
or
it
does.
It
also
include
like
applications
that
are
developed,
let's
say
with
a
compiler
or
something
like
Java
based
applications
or
something
like
that.
I
mean
your
demo
just
cover
the
static
case
for
changing
some
HTML.
But
what
happens,
for
example,
when
I.
A
E
F
B
F
A
A
B
So
when
the
connections
dropped,
when
you
terminate
the
telepresence
proxy
on
your
laptop,
it
actually
will
clean
up
itself
in
the
cluster.
However,
if
you
go
to
sleep,
the
behavior
isn't
super
nice
and
that's
one
of
the
things
that
we're
actually
working
on
and
sort
of,
where
architectural
exploring
the
idea
of
a
a
persistent
proxy
on
the
cluster
that
you
can
actually
reconnect
to,
because
right
now
we
deploy
the
proxy
every
time
you
invoke
the
command.
H
A
I
A
So,
actually
that
one
of
the
one
of
the
things
that
ideally
you
would
move
to
is
the
container
native
where
you
build
processes,
is
you
building
an
image?
You
begin
the
document
and
then
you
use
the
the
docker
method
with
telepresence
allows
you
to
run
that
that
new
image
and
you
make
sure
you
will
still
be
able
to
make
changes
you.
So
you
can
still
do
tricks
for
faster
development
like
mounting
your
development
folder
into
that
image.