►
From YouTube: TGI Kubernetes 029: Developing Apps with Ksync
Description
0:00:30 Talking about YouTube problems last time
0:02:50 Intro to series on Dev workflow
0:03:41 Kubernetes 1.10
0:08:18 Apache Spark on Kubernetes
0:08:59 Jenkins X
0:09:52 Untrusted Container Building from JessFraz
0:13:56 Why do development with Kubernetes Clusters
0:19:55 Quick question on distributed monoliths
0:21:18 Factoring layers of dev/deploy workflows
0:23:15 Approaches to development in cluster
0:29:22 Looking at ksync
0:30:38 Prior art w/ docker-sync and unison
0:32:16 Other ways to pronounce of Kubernetes
0:33:16 Installing ksync
0:37:29 Aside: Fun spinners and lolgopher
0:39:37 Demo app with ksync
0:47:12 Syncing a directory
0:52:38 Syncing is working!
0:53:40 Is bidirectional sync a good idea?
0:56:41 Exec to container that is sync'd
0:58:10 Compiled languages and reload?
1:03:45 Architecture docs
1:04:25 Alternate approaches?
1:08:30 Wrapping up
(Last try was aborted due to technical problems. Hopefully this week we won't have the same issues!)
Come hang out with Joe Beda as he does a bit of hands on exploration of Kubernetes and related topics. Some of this will be Joe talking about the things he knows well. Some of this will be Joe exploring something new with the audience. Ask questions, comment and help decide where things go.
Deploying applications to Kubernetes is one thing. But what about developing on Kubernetes? How do you use Kubernetes to run your application in an environment that is similar to production?
This is a super active space with a lot of interesting tools including things like Draft or newer projects like Skaffold. In this episode we'll start to break down ways to approach this problem and look at a tool called ksync from vapor.io.
Notes/Links
* Gap between local and cluster dev experiences
* Why run dev on cluster?
* Languages/tools drive decisions
* Approaches
* Auto rebuild and deploy
* Draft - https://github.com/Azure/draft
* Skaffold - https://github.com/GoogleCloudPlatform/skaffold
* Questions around moving data/source?
* Cloud builds
* Container registry
* Non-priv builders (img, orca-build, buildah, Bazel?)
* Run on cluster, sync file system
* ksync - https://github.com/vapor-ware/ksync
* Adapt docker host volume solutions
* http://docker-sync.io/
* Unison -- https://www.cis.upenn.edu/~bcpierce/unison/
* Run locally, bridge network
* How to run locally?
* Minikube?
* Local container
* Local native
* Local node attached to remote cluster
* Telepresence https://www.telepresence.io/
* Other stuff that came up in episode:
* Kubernetes 1.10: http://blog.kubernetes.io/2018/03/first-beta-version-of-kubernetes-1-10.html
* Apache Spark on K8s: http://blog.kubernetes.io/2018/03/apache-spark-23-with-native-kubernetes.html
* Jenkins X: https://jenkins.io/blog/2018/03/19/introducing-jenkins-x/
* Jessie's work on untrusted container builds: https://blog.jessfraz.com/post/building-container-images-securely-on-kubernetes/
* docker-sync: http://docker-sync.io/
* Unison: https://www.cis.upenn.edu/~bcpierce/unison/
* Syncthing: https://syncthing.net/
* lolgopher: https://github.com/kris-nova/lolgopher
A
Hello
in
TGI
K
all
right.
We
already
have
some
folks
going
on
in
the
chat
so
two
weeks
ago,
I
tried
to
do
tjk
from
home
and
we
had
all
sorts
of
problems
with
YouTube
streaming
and
the
audio
was
all
messed
up.
So
hopefully,
hopefully
this
is
working
so
I'd
love
to
get
some
confirmation.
Yeah
it
works.
Alright,
so
Sean
is
saying
that
it
works
Thank,
You,
Sean.
A
So
here's
what
I
think
happened
last
week-
and
this
is
my
theory
and
I'm
like
a
little
confidence,
because
who
the
hell
knows
what
happened
but
I
think
75%
sure
that
we
had
a
problem
with
YouTube.
When
you
launch
one
of
these
live
streams
with
YouTube,
you
have
to
go
through
like
a
preview
stage
where
you
can
privately
see
the
stream
to
make
sure
everything's
good
and
then
you
click
from
there
to
actually
go
through
and
start
the
stream
I
was
running
late
and
so
I
just
like
boom
boom
boom
clicked
through
that
stuff.
A
So
I
wanted
to
go,
live
without
going
through
that
preview
stage
and
I
think
maybe
I
transitioned
too
fast.
There
so
I
think
we're
I
think
we're
set.
Now
so,
okay,
so
for
those
who
don't
know,
my
name
is
Joe
Beda
I'm,
the
CTO
of
a
startup
called
hep
tio
and
we're
focusing
on
bringing
kubernetes
to
the
enterprise
across
a
whole
bunch
of
different
dimensions
and
TTI.
A
K
is
a
weekly,
or
at
least
we
try
and
do
weekly
our
hour
and
a
half
two
hour
livestream,
where
I
dig
into
some
interesting
facet
of
kubernetes,
whether
that
be
covering
a
core
feature.
An
ancillary
project.
I
did
did
some
stuff
where
I
did
a
bunch
of
coding
of
a
controller,
so
just
try
and
dig
deep
into
something
and
and
hopefully
along
the
way.
I'll
learn
some
stuff.
You
know
the
folks
watching
will
learn
some
stuff
and
well.
It
will
have
fun
so
first
of
all,
I'll
say
hi
to
everybody,
let's
see!
A
So
what
do
we
have?
So
we
have
suresh
and
shawn
we're
on
beforehand,
so
things
are
looking
good
there.
Thank
you
for
confirming
that
guys.
Fernando
awesome.
Welcome.
Let's
see
ibrahim
good
to
see
you
Caleb
from
hog
country.
Sorry
ma
l'm,
addi,
jesse
in
new
york
is
done
for
the
week.
I
can
tell
that's
why
the
more
each
she
puts
at
the
end
of
my
name,
the
more
done
for
the
week.
A
She
is
Miguel
Eddie
good,
to
see
you
all
Eddie
from
Guatemala
awesome
welcome,
so
my
plan
this
this
week
is
to
start
going
into
tools
that
look
at
and
I'm
probably
gonna.
Do
like
four
four
episodes
on
this
that
look
at
a
developer
experience.
So
if
you're,
a
software
developer
and
you're
deployed
target
is
kubernetes,
why
would
you
want
to
start
integrating
kubernetes
earlier
into
your
development
workflow?
A
And
then
how
do
you
go
about
doing
that
and
what
are
some
of
the
tools
and
the
techniques
and
the
ways
to
sort
of
break
this
down
and
think
about
it?
So
that's
the
plan
for
today.
Let's
see
I
want
to
say,
let's
see
more
shoutouts
here.
So,
let's
see
so
we
have
Frederico
from
Gutenberg,
I'm
sure
I'm
freaking
butchering
it
I'm.
Sorry
Miguel
from
Mexico
good
to
see
you
alright,
but
then
one
of
the
things
that
I
like
to
do
I'm
out
of
focus
as
we
start
out
here,
is
go
over.
A
Some
what's
been
happening.
New
stuff
that's
been
going
on
in
the
kubernetes
community
and
just
here
to
give
a
few
thoughts
and
a
few
pointers
there
on
on,
what's
happening,
so
I'm
going
to
go
ahead
and
start
with
that.
Let
me
switch
to
my
screen
here,
and
so
the
first
thing
I
want
to
talk
about
is
kubernetes.
1.10
is
happening,
there's
a
blog
post.
This
was
this
was
a
couple
of
weeks
ago,
but
we've
been
going
through,
the
beta
is
I.
A
Going
on
in
110,
but
I
think
one
of
the
things
that
you'll
see
is
that
is
that
things
are
slowing
down
a
little
bit,
we're
not
seeing
as
many
new
features
as
many
changes.
That's
a
good
thing,
I
think
for
anybody
who's
building.
On
top
of
this,
there
might
be
a
few
pet
features
that
you
really
want
to
see.
I
know
there's
a
few
that
I
really
want
to
see,
but
I
think
more
than
anything
else.
A
The
biggest
feature
that
everybody
wants
to
see
is
for
the
thing
to
get
more
solid
for
for
us
to
fix,
bugs
for
us
to
simplify
things
and
concentrate
on
on
some
of
the
things
that
are
not
as
shiny
but
actually
matter
to
folks
who
are
using
this
thing
in
production,
so
yeah
so
I
think
you
know
there's
a
good
summary
here.
There's
the
the
change
notes
are
coming
along.
The
change
log
is
coming
along
too,
so
you
can
look
at
that.
A
The
TLS
bootstrap
stuff
that
starts
been
going
on
forever,
I'm
really
happy
to
see
that
get
there.
This
involves
this
is
this
is
one
of
the
mechanisms
that
cube
admin
uses
to
boot?
Up
clusters,
which
is,
is
something
that
I've
been
working
on
for
a
while
and
that
that
hefty
o
has
been
investing
in.
So
it's
really
good
to
see
that
come
along.
A
Let's
see
so
locking
down
what
access
a
node
has.
There
was
a
security
incident
where
again,
somebody
didn't
have
all
the
options
turned
on,
and
there
were
a
few
things
that
that
snuck
out
and
they
expose
some
stuff
to
the
outside
world,
and
so
it
looks
really
bad
we're
continuing
to
lock
those
things
down
and
provide
a
lot
of
options
around
that
client
go
is
continuing
to
make
progress
and
then
the
token
request
API
is
really
interesting.
A
This
is
something
that
that
that
some
of
the
folks
at
Google
have
been
working
on
and
what
this
is
is
it
allows
you
to
use.
Kubernetes
service
account
tokens
for
things
other
than
kubernetes,
and
so
what
this
you
know,
people
were
already
doing
this,
but
it
was
kind
of
a
dangerous
thing
to
do,
but
the
big
reason
why
Google
did
this
is
so
that
you
can
associate
a
kubernetes
service
account
token,
with
a
AWS
surviving
with
a
GCP
service
account.
A
But
this
can
be
used
for
other
things
like
authenticating
to
vaults
and
such
it
still
is
not
as
good
in
my
opinion
is
something
that
is
based
on
on
certificates,
because
that
lets
you
sort
of
cross
validate
in
a
very
generic
way.
So
you
don't
end
up
with
this
N
squared
set
of
N
squared
set
of
tokens
that
you
have
to
manage,
but
it's
still
still
a
very
big
step
forward.
So
let's
see
some
questions
here,
so
you
know,
Chris
is
across
the
hall,
so
yeah
thanks
for
watching
Chris.
A
Let's
see
we
have
Ned
here
from
London
Marco's
joining
us
awesome
and
then
Lou
Matty
saying
how
long
do
you
think
it'll
take
for
CSI
to
get
to
GA,
honestly
I
I,
don't
know,
I
haven't
been
tracking
a
lot
of
the
storage
stuff
very
carefully
I,
it's
it's
kind
of
like
it's
one
of
those
things
where
kubernetes
is
just
so
big.
It's
almost
impossible
to
keep
track
of
everything,
so
I
don't
have
anything
anything
concrete
to
actually
share
with
you
all
there.
A
A
I'm
trying
to
like
I'm
trying
to
remember
the
scenario
around
this
but
I-
remember
this
actually
being
a
real
blocker.
I
think
this
is
one
of
those
things
that's
necessary
for
things
like
the
cubelet
running,
you
know
container
itself,
the
local,
the
locals
persistent
storage
stuff
is
in
beta
now
and
and
that's
continuing
to
make
progress.
A
So
yeah
super
interesting
stuff
going
on
there,
oh
and
then
the
dynamic
cubelet
configuration
is
really
exciting
too,
because
right
now,
when
you're
configuring,
a
cluster,
you
have
to
sort
of
manage
the
cubelet
configuration,
which
is
a
bunch
of
command
line,
flags
that
are
usually
stored
in
the
system.
D-Unit
file.
A
But
then
the
rest
of
the
cluster,
by
and
large,
or
at
least
a
lot
of
the
rest
of
the
cluster
can
be
managed
through
kubernetes,
and
so
this
means
that
the
the
cubelet
itself
now
can
get
its
flags
or
at
least
the
bulk
of
its
flags
in
its
configuration
from
from
the
api
server.
So
that's
actually
really
interesting
too.
Alright,
so
I
don't
know
I'm
not
going
to
I'm
not
going
to
spend
too
much
time
on
this.
The
next
thing
I
want
to
talk
about
and
I
want
to
find
time
to
dig
into.
A
This
is
Apache
spark
on
kubernetes
everybody's
been
asking
about
this
I'm,
not
a
spark
expert,
but
I
know
that
a
lot
of
work
has
gone
into
this.
So
this
is
super
super
interesting
and
I
need
to
find
some
time
to
really
understand.
What's
going
on
here.
So
maybe
after
I
do
the
the
the
series
on
developer
tools.
I'll
have
to
take
a
look
at
take
a
look
at
that
all
right.
So,
oh,
let's
see
who's
having
Eric
you're
having
problems.
I'm.
A
A
Here
let
me
make
this
a
little
bit
bigger
and
so
I
think.
One
of
the
things
that's
interesting
about
this
is
that
a
lot
of
the
configurations
from
Jenkins
is
moving
from
stuff
that
you
configure
by
logging
into
jenkins
and
configuring
from
the
outside
to
something
that
can
be
discoverable
using
like
a
jenkins
file,
and
so
it's
a
way
to
make
jenkins
being
more
more
dynamic,
more
self-describing
in
terms
of
how
things
interact
with
jenkins,
and
so
also
something
I
would
love
to
look
into.
A
If
you're
running
on
privilege,
if
you're
wearing
privileged
containers,
they're
privileged
for
a
reason
that
can
pretty
much
do
whatever
they
want
on
the
host,
and
so
so
there's
been
a
bunch
of
work
about
decomposing.
All
of
the
things
that
go
into
building
a
container,
whether
it
be
running
all
the
steps
in
something
like
a
docker
file,
how
you
can
upload
and
download
and
crack
open
and
make
all
the
packages
that
get
uploaded
and
downloaded
to
repositories
but
the,
but
the
one
thing
that
I
don't
think
anybody
has
cracked
is.
A
That's
super
super
interesting
and
then
in
but
there's
there's
there
was
this
one
missing
piece
that
that
that
that
jesse
worked
with,
which
was
having
write
access
to
proc,
and
so
so
there's
a
ton
of
patches
that
Jesse's
been
working
hard
to
push
in.
Hopefully
those
things
will
make
their
way
through
both
both
with
with
docker,
slash
mobi
and
with
kubernetes,
but
as
they
make
their
way
through.
We
should
find
ourselves
in
a
situation
where
you
can
have
a
relatively
untrusted
user.
Build
containers
on
top
of
a
cluster
and
I
want
to
be
clear.
A
This
is
not
just
people
running
on
top
of
a
cluster
and
sort
of
like
how
we
do
things
by
default,
which
is
like
you've
run
as
root.
You
know,
on
a
cluster.
This
is
also
running
as
non-root
users
on
the
kubernetes
cluster,
which
is,
which
is
a
huge
step
forward
in
terms
of
the
the
composability
is
stuff
like
this.
So.
A
A
Alright,
let's
see
well
it
from
Saudi
Arabia
nice
to
see
you
make
from
Berlin
and
on
from
India
man
the
whole
world
yeah
yeah
and
Reid
Jesse's
blog
post
I'll
put
it
in
the
notes.
It's
it's
all
came
down
to
a
bet
over
pizza
with
with
some
of
her
coworkers.
So
that's
funny
all
right!
So
that's
sort
of
like
you
know,
I
I
haven't
done
TGI
K
for
a
couple
of
weeks,
but
hopefully
that's
some
of
the
exciting
stuff.
That's
happened
over
that.
A
If
there's
anything
else
that
you
all
want
to
talk
about,
maybe
we
can
find
some
time
at
the
end
to
dig
into
it
all
right.
So
today,
I'm
going
to
be
digging
into
this
project
called
K
sync,
which
allows
you
to
synchronize
files
on
you
running
on
your
local
workstation
machine
with
stuff,
that's
running
in
a
cluster,
and
this
is
a
really
useful
building
block.
But
I
want
to
dig
in
a
little
bit
in
terms
of
why
you
might
want
to
go
ahead
and
do
that.
A
So
here's
sort
of
my
outline
here
that
a
that
I've
been
thinking
about
it.
So
the
first
thing
here
is
that
why
would
you
run
a
run
your
development
process
on
cluster
right?
Because
you
know
a
lot
of
folks
the
way
they
approach
this
problem?
Is
they
write
a
bunch
of
stuff?
They
have
their
own
development
workflow
a
lot
of
times,
that's
integrated
with
like
an
IDE
or
an
editor
like
vs
code.
A
They
have
debugger
set
up.
They
have
their
own
ways
of
actually
getting
a
fast
sort
of
compiled,
retry
loop
if
you
have
a
compile
or
what-have-you
and
so
doing
anything
other
than
that
is
going
to
make
things
slower
right,
because
if
you,
you
know,
if
you're
doing
a
node
application
or
Ruby
application-
and
you
have
everything
set
up
so
that
when
you
hit
save
on
your
editor
without
even
you
know
clicking
over
to
the
browser
at
reload.
So
you
can
see
what's
happening
you.
A
Why
would
you
want
to
go
ahead
and
change
that,
and-
and
the
reality
is,
is
that
if
all
you're
doing
is
a
single
application
that
can
run
locally
on
your
machine
and
doesn't
have
a
lot
of
external
dependencies?
There's
not
a
lot
of
reasons
to
change
things
up,
I
wouldn't
run
on
cluster
just
to
run
on
cluster,
so
so
he
misses
doesn't
make
sense,
integrate
something
like
Kay
sync,
with
meta
control
that
enables
us
to
do
Bluegreen
deployments
I,
don't
think
so.
I
think
this
particular
tool
is
only
for
development.
I.
A
Don't
think
this
is
something
that
you'd
want
to
use
in
production,
so
so
I'll
get
down
to
that.
But
I
think
the
the
critical
thing
here
is
that
a
lot
of
times
when
a
lot
of
times
when
you
are
are
developing
you're,
doing
a
small
piece
of
a
larger
application
and
and
sometimes
that
application
is
small
enough
that
you
can
run
it
all
on
your
local
machine.
A
So
now
you
might
do
something
like
hey
I'm,
gonna
run
this
thing
in
mini
cube
and
then
my
component
that
I'm
working
on
well
I'm
not
going
to
run
it
in
mini
cube.
I'm
gonna
actually
run
it
outside,
but
I'll
do
enough
port
magic
to
be
able
to
talk
to
the
stuff
that's
running
in
mini
Q.
So
you
could
do
something
like
that.
A
A
You
don't
want
to
be
running
that
stuff
locally,
no
want
to
be
running
a
personal
version
of
that,
and
so
now
what
you
find
is
that
is
that
it's
difficult
to
really
develop
and
test
things
out
and
really
poke
at
things
in
isolation
when
you're
starting
to
deal
with
a
microservices
type
of
application,
and
so
you
really
want
to
develop
in
a
way
where
you
feel
like
you're,
you're
running
in
an
environment,
that's
similar
to
how
things
are
going
to
run
in
production.
So
that's
the
first
reason.
A
The
next
reason
is
that
is
that
you
know
if
you
have
to
develop
one
set
of
tooling
for
development
and
then
a
totally
new
set
of
tooling
for
how
you
deploy
there's
opportunities
to
screw
things
up.
You
know,
as
you
actually
move
from
your
development
environment,
to
your
test
environment,
to
your
production
and
you
know
and
then
rolling
it
out
across
different
geographies.
Perhaps
right
so
you
know
in
a
simple
thing
might
be
like
hey.
A
A
I,
add
it
to
my
make
file
and
then
boom
I'm
done
now,
I
go
ahead
and
not
deploy
this
into
production
or
into
staging
and
I
forgot
to
actually
duplicate
that
flag
from
my
development
setup
to
the
staging
production
setup
right.
So
what
you'll
find
is
that
every
difference
between
developments?
You
know
testing
staging
and
production.
Every
change
there
will
eventually
release
will
eventually
lead
to
an
outage
or
a
problem
or
a
hiccup
in
the
process,
and
so
I
think
that's
one
of
the
reasons
why
people
want
to
unify
this
stuff
as
much
as
possible.
A
A
If
you
find
yourself
in
this
position,
where
you
check
some
stuff
in
to
get
and
then
you
watch
CI
and
you're
like
and
then
you
do
another
check-in,
you
go
oops
and
you
have
to
check
in
again
and
then
you
have
to
have
get
to
it.
You
have
to
have
your
CI
system,
do
it
and
then
you
get
to
like
oops
number
12
right.
That's
a
bad
pattern!
Right!
That's
slowing
you
down!
That's
painful!
That's
not
the
ideal
situation
that
you
want
to
be
in.
A
Serena
says
just
that
some
of
the
services
are
just
nano
monolith.
Services
I
think,
there's
a
difference
between
having
a
dependency
that
you
have
to
talk
to
to
be
successful,
versus
building
sort
of
a
distributed
monolith.
I
think
that
in
my
mind,
that
comes
down
to
coupling
and
version
skew
right.
If
you
can
upgrade
things
without
having
to
sort
of
like
if
you
find
yourself
doing
releases
across
all
like
you
know,
30
microservices
and
you
do
it
in
a
sort
of
BIGBANG
type
of
way.
A
Then
you're
building,
in
my
mind,
a
sort
of
a
distributed
monolith,
but
but
I
don't
think
you
know
at
some
point.
You
take
a
dependency
on
the
services
that
you're
that
that
you're,
integrating
with
right
just
like,
if
you're
developing
an
application
that
takes
a
hard
dependency
on
s3.
That's
not
like
a
you're,
not
building
a
monolith
with
s3
you're
you're.
You
know
you're
taking
a
dependency
and
that's
part
of
your
and
you
have
to
factor
that
into
your
development
process.
Then
also
yeah
data
to
be
preserved.
A
So
yeah,
that's
one
of
those
things
is
that
you
want
to
have
like
you
know,
datasets
that
are
useful
during
testing
and
then
let
Manning
do
you
see
this
solely
as
a
development
tool
or
you
see
it
working
with
existing
CI,
workflows,
I
think
you
could
use
it
a
little
bit
both
now
Thomas
I
am
I,
am
I
mistaken
here.
I
think
you
are.
Are
you
involved
with
K?
Sync
I
must
be
I
want
to
do
a
lot
of
research
here
before
I.
A
Do
this
stuff,
unfortunately,
and
then
I
don't
and
then
hopefully
so
yeah
so
Thomas.
You
have
actually
know
a
lot
about
this
stuff,
so
yeah,
okay,
so
yeah.
So
you
have
the
experience
here
so
you'll
you'll
tell
me
when
I
screw
up
on
stuff,
but
but
one
of
the
other
things
I
want
to
see
here
is
is
as
we
look
at
how
to
break
down
these
workflows.
We
want
to
find
which
pieces
are
reusable
from
development
to
to
deployment
and
which
pieces
are
maybe
just
development,
and
how
can
we
start?
A
You
know
breaking
some
of
this
stuff
down,
and
so
you
know
one
of
the
gradations
that
I'd
like
to
see
split
up
is
the
way
that
you
deploy
stuff
is
different
from
or
like
how
you
describe.
Your
deployment
is
different
from
how
you
trigger
that
deployment
right.
So
I
would
love
to
see
the
you
know
when
you
describe
all
your
yeah
mole
or
something
that
sort
of
turns
into
yeah,
mole,
eventually
or
I'd,
love
to
see
that
be
something
that
you
can
run
locally
yourself.
A
If
you
have
the
permissions
to
do
it,
but
then
you
can
also
trigger
that
through
something
like
a
CD
system,
whether
you're
doing
a
get
ops
type
of
thing.
Where
it's
based
on
a
get
hook
or
maybe
you're
doing,
is
part
of
like
a
jenkins
flow.
Ideally
you
want.
You
know
your
your
your
automated
systems
to
be
using
the
same
tool
chain
that
you
get
access
to
locally,
so
that
requires
a
level
of
factoring
right
there.
Another
level
of
factoring
is
thinking
about
difference
between
continuous
integration
and
deployment.
A
Are
there
reasons
why
you
want
to
split
these
things
up,
instead
of
actually
viewing
them
as
one
one
thing
that's
actually
tightly
coupled
thinking
about?
How
do
you
reuse
your
configuration
application
configuration
for
development
also
specialized
that
may
be
scale
it
down
in
some
cases,
so
I
think
one
of
the
things
that
we're
working
through
right
now
is
how
do
we
actually
define
these
different
layers?
Where
can
you
mix
and
match?
Where
can
we
actually
do
some
innovation
around
this
stuff?
All
right?
So
all
right!
A
So
that's
so
that's
that
so
now,
when
I
start
thinking
about
active
development,
so
so
I'm
ignoring
CI
C,
D
I'm,
ignoring
the
deployment
stuff
ignoring
like
you
know,
how
do
you
manage
the
amyl
I?
Think
that's
all
really
important
stuff,
but
I
think
that's
probably
different
components
of
this
as
I.
Think
about
this.
A
I
believe
scaffold
does
also.
It
may
be
more
flexible
than
that
I
haven't
dug
in
super
deeply.
But
the
idea
here
is
that
you
hit
save
in
your
editor
and
then
some
process
behind
the
scenes
does
essentially
a
docker
billdocker
push
and
then
rolls
the
deployment
in
kubernetes,
and
so
what
that
means
is
that
you
don't
have
to
you
know
it's
very
easy,
one-click
or
automatic,
based
on
the
the
save
of
a
file
to
actually
go
ahead
and
and
and
see
your
results
running
running
in
the
cluster.
A
The
downside
to
this
is
because
you're
going
through
the
entire
build
process
and
push
process,
the
latencies
here
will
just
naturally
be
longer
because
you're
restarting
the
process
you're
doing
a
real
build
along
the
way.
Things
that
you
want
to
think
about
with
this
is,
is
you
know,
are
you
using
a
cloud
build
service?
You
know,
Google
has
one
of
these.
You
know
that
may
be
faster.
There
may
be
some
caching
there.
They
may
be
smarter
about
that,
but
that's
a
dependency,
so
you're
not
doing
stuff
locally.
A
Now
the
good
thing
is
that
you're
producing
stuff
close
to
where
you're
going
to
use
it
if
you're
running
everything
on
Google.
So
that
means
that
you
have
fast
pipes
to
actually
move
all
the
data
around.
You
have
to
set
up
a
container
registry
here.
You
can't
do
this
stuff
all
locally.
You
actually
have
to
have
something
for
this
to
be
able
to
push
to
so
that
you
can
pull
from
it
and
then
so.
A
Wrote
almost
all
of
K
sink
all
right,
so
so
Thomas
is
going
to
be
our
guide
here.
That's
good
and
I
think
there's
another
approach
here
which
is
running
on
cluster
and
then
syncing
the
filesystem.
So
this
is
probably
most
useful
for
dynamic
languages
that
have
auto
reload
on
file
changes
already
so
I'm
thinking
about
things
like
Ruby
and
node
and
Python.
These
things
are
really
set
up,
such
that
you
know.
A
If
you
change
something
on
on
the
file
automatically,
you
can
go
ahead
and
reload
it
right
away,
so
the
file
really
becomes
part
of
that,
and
people
typically
don't
use
interactive
debuggers
for
these
things
right.
They
like
they
typically
debug
by
trying
something
out
and
looking
to
see
what
happens.
A
You
know
maybe
a
little
bit
of
printf
type
of
debugging
going
on
there,
but
if
you're
doing
something
like
C++
or
Java
I
think
goes
kind
in
the
middle
here.
To
be
honest,
if
you're
doing
something
like
C++
or
Java
a
lot
of
times,
those
builds
end
up
being
heavier.
You
want
to
get
the
incremental
ISM
that
you
get
with
a
local
file
system
around
this
stuff.
You
also
typically
start
using
debuggers
and
integrated
ites,
and
so
having
your
work
load
run
remotely
then
becomes
more
challenging.
A
Instead
of
actually
you
know
sink
in
the
file
system,
you
can
find
ways
to
bridge
the
network
right
so
that
things
running
Buster
can
may
be
calling
to
you,
and
then
you
can
call
into
things
that
are
running
in
cluster.
Also
telepresence
I
believe
is
a
project
that
sits
in
in
this
category.
I
haven't
used
it
either.
So
again
it's
one
of
those
things.
I
want
to
cover
on
TGI
K
and
they
in
the
future
and
then
there's
the
question
of
like
how
do
you
run
this
stuff
locally?
A
Do
you
run
it
in
a
mini
cubed,
you
run
in
a
local
container.
Do
you
run
it
natively?
Do
you
want
one
idea
that
I
don't
think
anybody
has
done?
Maybe
I
think
Jesse
might
have
done
this
once
because
she's
crazy
enough
to
do
that
is.
Could
you
actually
run
the
cube
lid
on
your
local
machine
and
then
have
it
join
a
remote
kubernetes
cluster
so
that
you
actually
have
your
own
private
node
that
you
can
muck
with,
but
it's
also
partially
managed
by
a
remote
kubernetes
cluster.
B
A
A
All
right,
so
so
that,
in
my
mind,
that's
the
different
ways
that
we
can
skin
this
cat
yeah.
So
like
I,
think
you
know
so
so
in
terms
of
T,
gik
I
think
I
probably
want
to
do
scaffold
next
week
and
then
maybe
draft
or
telepresence
after
that,
so
so
yeah
I'm
planning
these
things
out
a
little
bit
and
I.
Don't
think!
There's
a
right
answer
here.
I
think
different
techniques
here
makes
sense
with,
depending
on
the
toolset
and
the
requirements
that
you
have
okay,
it
was
Chris
that
did
it.
A
Okay,
yeah,
that's
right,
I
seem
to
remember
somebody
was
telling
me
they
did
this,
where
they
ran
the
cubelet
on
their
makaan,
their
local
machine
and
then
did
like
some
crazy
SSH
tunneling.
So
they
could
join
it
to
a
to
a
remote
cluster
yeah,
maybe
with
the
virtual
cubelet.
There
might
be
something
to
be
done
there
also.
That
might
be
interesting,
all
right,
so
so
yeah.
So,
let's
start
exploring
this.
A
I
spent
a
lot
of
time
talking,
but
this
I
hope
at
least
gives
us
a
mental
map
for
how
some
of
these
tools
fit
in
to
the
development
process
and
how
they
compare
against
each
other,
all
right.
So
all
right.
So
let's
take
a
look
at
case.
Inc
I
haven't
used
this
yet
I've
been
so
busy.
I've
been
meaning
to
play
with
it
beforehand,
but
I
have
it
so
we're
going
to
go
ahead
and
we're
going
to
give
this
a
try.
A
The
goal
here
is
to
be
able
to
do
something
equivalent
to
the
the
docker
run,
with
a
dash
of
V,
where
I'm
at
my
local
directory
in
and
behind
the
scenes.
What
case
Inc
is
doing
is
its
setting
up
and
using
this
thing
called
sink
thing,
which
is
a
go-go
binary.
It's
written
go
thing
for
syncing
files
across
a
bunch
of
different
different
computers.
It
does
it
with.
A
A
Rewind
the
clock
like
maybe
a
year
and
and
there's
this
thing
called
docker
sync
that
people
I'm
not
sure
who
did
this.
There
was
like
somebody,
this
obviously
a
passion
project
for
somebody,
so
that
dash
of
V
that
was
mentioned
in
that
then
the
the
sync
thing
at
the
K
sync
sort
of
thing.
It
turns
out
that
that's
actually
pretty
slow
on
docker-
or
at
least
it
was
docker,
has
been
doing
more
and
more
to
cash,
this
stuff,
and
so
they
so
people
did
a
whole
bunch
of
stuff.
A
It
was
especially
slow
when
you're
doing
things
that
do
a
lot
of
like
a
lot
of
files
and
stats
on
a
lot
of
file,
which
especially
describes
things
like
node,
and
so
so
people
did
some
work
to
actually
create
other
ways
of
synchronizing
directories
across
and
so
docker
sync
was
this
tool
that
or
the
set
up
for
being
able
to
do
that?
That
was
really
interesting
behind
the
scenes
it
used.
This
other
sync
engine
called
unison,
and
this
thing
is
freakin.
A
Ancient
I
was
looking
at
this
at
one
point,
because
I
wanted
to
sort
of
do
a
remote
kubernetes,
build
machine
and
I
kind
of
got
it
set
up,
but
it
was
which
is
a
really
really
kind
of
clunky.
It
was
clearly
not
built
to
be
sort
of
used
in
this
way.
So
but
I
think
sync
thing
definitely
looks
like
it's
a
it's,
a
more
composable
solution
for
being
able
to
do
this
stuff.
So
that's
really
really
exciting.
Okay,
so
Finn
says
kubernetes
sounds
like
diabetes.
So
here's
the
thing.
A
So
we
had
a
big
engine
all
site
for
all
of
hefty.
Oh
and
one
of
our
engineers
Liz
she
likes
to
pronounce
kubernetes
as
caperna
DS
like
Copernicus,
caperna
DS.
So
from
now
on,
I'm
gonna
try
really
hard
to
try
and
pronounce
kubernetes
as
caperna
DS,
just
to
really
confuse
the
heck
out
of
people
or
maybe
I'll
just
do
it
for
this
episode.
A
So
if,
in
order
in
honor
of
you
and
Liz
I'm
gonna
say
it
caperna
DS
from
now
on,
so
it
doesn't
sound
like
diabetes
to
you
all
right,
so,
okay,
so
all
right.
Okay,
so
okay
I
mentioned
the
scaffold
draft
and-
and
this
is
telepresence
which
were
the
other
ones,
but
we're
looking
at
casing
now:
okay,
all
right
so,
and
it's
using
it's
using
sync
thing
behind
the
scenes,
all
right.
So
now,
let's
go
through.
A
So
the
first
thing
we're
doing
here
is
there's
a
curl
to
bash
going
on.
Let's
actually
see
what
that
is
doing
and
I
believe.
If
I
look
at
this,
it's
saying:
hey,
you
have
to
be
running
his
route.
We
have
to
have
root
access
and
it
installs
it
into
the
target.
Install
path
is
user,
local
bin
and
it's
assuming
that
grabbing
the
latest
version
and
putting
an
user
local
bit.
So
we're
not
going
to
do
that.
Instead,
you
can
grab
the
latest
release
here,
let's
case
Inc
Darwin
and
be
64.
A
Caperna
T's
caperna,
DS,
I,
I'm
gonna,
try,
I'm,
gonna,
try
and
retrain
myself,
man,
github,
sometimes
downloading,
is
really
slow.
Have
you
all
noticed
this?
Do
you
do
do
do
but
yeah
okay?
So
that's
what
we're
gonna
do
so
we're
gonna
download
that
and
then
it
also
knows
how
to
like
update
itself
an
upgrade
which
is
really
nice.
That's
really
good
to
see
that
I'm
kind
of
surprised
that
this
thing
doesn't
that
there's
no
like
brew
installed,
because
that
tends
to
be
my
go-to
for
this
stuff.
A
That's
why
I
tend
to
keep
like
tabs
up
and
then
after
the
episode,
I'll
go
through
and
grab
all
the
links
for
my
tabs
and
goes
ahead
and
do
that
and
then
and
then
I
also
like
what
I'll
do
is
I'll
take
a
you
know
like
these.
Well,
these
notes
are
short
enough.
I'll
probably
put
these
in
the
maybe
in
a
gist.
There
also
alright
and
then
Thomas
says
case.
Inc
has
docker
and
Kate's
clients
in
it.
So
the
binary
is
a
little
porky
yeah.
A
B
A
All
right
so
cool
all
right,
so
now
we
got
the
thing
and
all
right.
So,
let's
see
here,
initialize
casing
can
install
the
server
component
on
your
cluster.
The
server
component
is
the
daemon
set
that
provides
access
to
each
nodes
filesystem.
This
will
also
go
through
a
set
of
pre
and
post-flight
checks
to
verify
that
everything
is
working
correctly.
A
B
B
A
A
To
set
up
and
so
I'm
hoping
I'm
hoping
that
casing
can
it
will
actually
pay
attention
that
environment
variable
and
target
the
right
cluster
and-
and
it
says
initialize
case
Inc.
Well,
let's
just
see
what
it
does.
Okay,
so,
okay,
sync
and
it
should
work,
let's
see
so
fetching
extra
binaries,
ooh
I
like
this
spinner,
that's
kind
of
fun,
alright,
so
adding
casing
to
the
cluster
and
then
waiting
for
the
pods
to
be
healthy,
so
I
have
the
right
permissions
and
everything.
A
B
A
A
A
Yeah
it's
like
Lowell
Katz,
written
and
go,
but
actually
but
the
way
we
wrote
it
is
that
it's
a
it's
an
IO,
it's
an
IO
writer,
so
you
can
chain
it
in
with
other
io
writers,
really
easy.
So
that's
fun,
alright!
So,
okay!
So
now
we
have
that
thing
running
and
then
we
have
a
sample
app.
So
let's
see
the
demo
app,
but
let's,
let's
think
this
so
that
we
can
actually
like
muck
with
the
demo
app
and
see
what
happens
right.
I
probably
want
to
like
do
a
git
clone
on
this.
B
A
A
A
A
A
A
So
port
forward
in
1.10
this
is
actually
the
best
feature
of
1.10
III
need
to
find
the
the
PR
and
thank
the
person
that
did
it.
If
you
specify
a
service
there,
it'll
just
pick
one
of
the
pods
to
the
service
and
actually
forward
there
or
if
you
specify
a
deployment,
now
won't
reattach.
If
you
roll
the
deployment,
but
at
least
it
means
that
you
don't
have
to
do
this
dance
of
like
getting
pods
and
then
like
finding
the
right
pod
and
copy
and
pasting
it.
A
A
B
A
A
A
B
A
A
A
A
A
A
A
Okay
and
then
sync,
the
sync
is
bi-directional:
okay,
so
I
can
just
do
it
anywhere?
Okay,
so
so
now,
okay,
so
now,
and
if
I
bet,
if
I
do
doc,
async,
okay,
synced
yamo
there,
we
actually
talked
about
okay,
so
here's
the
spec
of
what
I
want
to
sync:
here's,
the
local
path,
here's
the
remote
path,
there's
some
other
parameters
there,
and
so
you
can
do
it
based
on
selector
pod,
or
you
can
also
specify
the
container
name,
also
I
assume
that
it
probably
just
does
it
across
all
containers
in
a
pot.
B
A
Alright
and
there's
also
a
case:
Inc
watch
daemon
option
for
full
background
that
logs
to
a
file
okay.
So
if
you
don't
want
to
see
the
spew,
you
can
go
ahead
and
set
that
up.
So
now,
if
I
do
case,
Inc
get
alright,
and
this
gives
me
the
status
of
what's
going
on
here.
So
it's
like
okay,
here's,
the
name
of
the
the
sink
local.
It's
this
directory
here
remote
is
slash
code
and
we're
actively
watching
it
and
here's
the
pod,
so
okay
cool,
and
then
we
can
do.
Oh
yeah,
hey
look
at
that!
B
A
So
this
is
oh,
the
M
times
have
been
updated,
so
okay.
So
what
I'm
confused
about?
Is
that
like
okay?
So
if
I
do
maybe
I'm
a
little
bit
confused
on
how
the
layout
I
think
it
might
be
worthwhile
to
be
a
little
bit
more
explicit
about
what
the
layout
looks
like
in
the
target
container
that
we're
talking
about
here?
So
if
I
do
a
cube,
control,
cube
control,
get
pods
and
I
do
an
exact
dash
TI
to
this.
B
A
Okay,
so
it's
a
it's
an
and
it's
an
alpine
container,
because
that's
why
Bash
wasn't
there
so
I
D
dash
instead,
okay,
so
okay,
so
this
is
the
thing
that
I
think
was
missing
from
the
tutorial.
Is
that
that
container
is
set
up
such
that
the
code
that's
running
is
in
slash
code,
and
so
when
we
start
doing
the
sync,
we're
essentially
overwriting
that
code,
so
we're
essentially
whacking
all
the
stuff-
that's
interesting
that
gets
written
in
there.
A
Maybe
we
would
see
that
if
we
actually
looked
at
the
at
the
docker
file
here,
because
oh
yeah,
the
work
Duras
slash
code,
so
the
slash
code
thing
I
thought
it
was
maybe
slash
code
was
relative
to
the
to
the
working
directory
of
the
other
things
so
I
expected.
Maybe
there
we
would
see
like
a
slash
code,
be
underneath
it,
but
no
that's
not
the
case.
A
So,
okay,
so
now,
I
should
be
able
to
do
something
like
like,
let's
see
so,
if
I
do
so,
the
demo
path
is
not
working
because
I
think
I
think
it's
conflicting
with
this
route.
I'm,
not
a
huge
flask
I'm,
not
a
huge
flask
person.
So
let's
go
through
and
do
that
and
then
you
know,
lulz
Joe
was
here
all
right.
We'll
do
that!
Save
that
yes,
I
know
pylons
not
installed,
okay.
So
now,
if
I
go
back
and
I
reload
this
all
right,
we
see
that
we
actually
modified
stuff.
A
So
that's
actually
really
really
cool.
Did
you
see
that,
like
okay,
so
I
just
want
to
like
I,
want
everybody
to
see
that
again,
because
that's
really
that
I
mean
this
is
a
great
development
workflow
now
at
this
point,
right,
I
can
go
through
here
and
I
can
change
code
I'm
hitting
save
tab
reload
and
it's
updated
right
there's.
You
know
that
is
I.
A
So
yeah,
that's
awesome
all
right!
Now,
let's
see
so
and
then
you
can
see
like
here's,
the
watching
and
it's
actually
driving
an
update.
So
there's
some
magic
going
on
here
between
the
k,
sync
watch
and
the
sync
thing
stuff
is:
it's
probably
manually
triggering
a
sync
thing
with
the
set
of
files
that
have
changed
I'm
guessing
you
said
that
this
was
bi-directional.
Also
the
bi-directional
thing
I'm
not
so
convinced
about
I'm,
not
sure
that
that's
a
good
idea,
I
mean
I'd
love
to
hear
the
scenarios
Thomas
and
Tim
about.
A
Why
bi-directional
is
a
good
idea?
I
think
it's
not
uncommon
to
have
you
create
a
bunch
of
stuff
on
the
other
side?
That's
you
know
local
temporary
stuff
and
then
copying
it
back.
I'd
also
be
afraid
that,
like
hey,
if
I
relaunched
the
container
and
some
of
the
M
times
get
screwed
up
am
I
going
to
actually
overwrite
my
local
stuff,
so
so
that
actually
would
be
a
little
bit
confusing
or
if
you
write
a
temp
temp
file
to
that
directory,
and
you
have
multiple
pods.
A
Is
it
going
to
like
go
through
and
sync
between
all
of
those
things,
so
that,
like
now,
you
end
up
with
sort
of
cross-pollination
of
state
that
won't
happen
when
you're
in
a
production
environment.
So
those
are
things
where
I'm
not
quite
sure
about
about
whether
that
would
be
a
good
idea
or
not.
Ok,
so
yeah,
that's
about
it.
So
demos
should
be
there
since
already
synced
and
reloaded
there's
a
better
visualization
later
on
in
the
demo.
Okay.
So
let's
keep
going
forward
a
little
bit
all
right,
so
we
can
add
a
new
key.
A
A
You
said
10
seconds,
I
think
it
was
faster
than
that,
so
that's
really
cool
and
then
you
said,
there's
an
ignore
file.
Okay,
so
if
you
don't
want
to
sync
it
back,
you
can
do
it
ignore
file
all
right.
You
know
my
my
gut
here
is
that
the
is
that
the
the
best
way
to
do
this
stuff
would
be
to
well,
maybe
I
mean.
A
Would
the
best
ways
to
have
it
be
one
way
to
begin
with,
to
be
honest,
all
right
and
then
there's
a
visualization,
because
sync
thing
was
made
to
be
run
was
made
to
be
run
as
sort
of
a
GUI
desktop
type
of
thing.
We
can
go
ahead
and
do
this
so
now.
What
is
this
doing
so?
This
is
going
through
so
we're
doing
the
port
forward.
Okay,
further
exploration,
so
we
have,
we
can
scale
the
app
to
two
replicas
okay.
So
let's
go
ahead
and
do
that.
A
A
A
And
then
for
go
you
trigger
the
build
remotely.
So
the
idea
is
that
you'll
be
that
you
cup
your
go
code
up
there
and
then
you
trigger
that
and
it
actually
runs
inside
the
container
or
you
could
exact
inside
the
container
right
and
now
what
happens
is
like
yeah.
That's
an
interesting
idea.
You
all
are
talking
while
I'm
exploring
too
but
I
did
that
exact
before
so
now,
I'm
inside
the
container
I
have
a
development
environment.
I
can
go
ahead
and
create
a
new
file
here
and.
A
B
A
A
I
didn't
do
that
shebang
thing,
but
there
you
go
so
yeah.
So
this
starts
feeling
like
you
have
like
a
remote
local
development
environment.
That's
really
cool
and
I.
Think
the
key
thing
here
is
that
typically,
as
long
as
you're
just
editing
code
you're
not
moving
a
ton
of
data
back
and
forth
right.
So
that's
the
latency
and
the
incremental
update
that
really
really
matters
there.
A
A
For
NGO
or
Java,
you
could
sync
only
the
binary
artifact
produced
by
a
bill,
but
the
container
would
still
need
to
be
restarted
right
because
that
things
are
rude,
I
mean
you
could
do
something
along
the
lines
of
having
a
bash
script
that
that
you
know,
kills
and
restarts
it.
You
know
so
that
your
your
route
of
the
container
your
process
ends
up
being
a
bash
script
that
says
oh
I
have
a
new
version
of
the
go
binary.
Let
me
go
ahead
and
restart
things.
That'd
be
one
way
to
do
it.
A
Ok
does
a
docker
restart
so
yeah.
So
if
you
were
doing
that
that
interactive
bash
thing,
then
you'd
go
ahead
and
you
would
do
the
docker
restart.
So
this
is
super.
Super
cool
I
think
we
got
a
good
idea.
I
was
gonna,
do
the
visualization
stuff.
So
let's
go
ahead
and
do
that
because
I
want
to
see
how
that
works.
A
A
A
Alright,
so
what
we're
talking
about
this
I'm
going
to
talk
about
some
of
the
things
that
that
I'm
not
sure
if
I
like
or
not
about
casing,
as
I've
looked
at
it?
So
the
way
that
case
Inc
works,
is
it
installs?
A
daemon
set
that
daemon
set
runs
at
elevated
privileges
and
it
reaches
behind
kubernetes
backs
to
understand,
essentially
where
things
are
being
stored
on
disk
from
a
docker
point
of
view,
and
it
synchronizes
there.
So
it
it
essentially,
you
know,
goes
through
and
is
very,
very
intertwined
with.
A
A
The
fact
that
it
works
as
a
daemon
set
makes
me
think
that
it
doesn't
work
in
a
multi-tenant
cluster
in
some
ways,
which
means
that
remember
one
of
the
whole
idea
is
that
we
want
to
be
able
to
do.
This
is
because
it
makes
sense
to
develop
remotely
when
you
have
remote
resources
that
you
need
to
take
advantage
of
and
a
lot
of
times.
A
Those
things
are
expensive
resources
and
you
want
to
share
them,
and
so
there's
questions
in
my
mind
of
how
does
think
thing
works
when
there's
multiple
people,
users
doing
it,
is
there
a
way
for
me
to
see
code
that
other
people
are
writing.
How
hard
is
the
multi-tenancy?
What
is
the
security
model
around
that
that
stuff
data
that
I
would
definitely
think
about?
So
tom
says
it
would
work
in
multi
tenant
clusters,
okay,
good,
but
then
there's
the
question
of
who's.
A
Let's
see
you
think
I
missed
the
end
Python
in
the
in
the
copy
and
paste
what
did
I
well,
these
things
are
running
yeah
and
then
I
was
going
to
do
the
bring
up
the
OIC,
and
then
this
thing
launches
the
web
bruh.
So
just
to
watch
as
a
web
browser
to
localhost
81
can't
be
reached
connection
refused.
Oh
I
didn't
read
the
ok,
so
we're
gonna
do
there.
We
have
that
running.
Okay,
now
we're
doing
80,
81
and
I
was
just
waiting
for
the
thing
to
spin
up.
A
A
A
A
So
now
you
can
say
it's
tested
on
on
the
the
hefty
Oh
AWS
QuickStart,
so
this
is
AWS
with
with
our
QuickStart
there
we're
running,
let's
see
and
I,
don't
know,
I
think
we're
running
over
late
at
this
point
all
right.
So
then
there's
a
lot
of
documentation.
There's
some
good
notes
here.
I
was
reading
through
these
on
the
on
the
on
the
life
cycle
of
how
all
this
stuff
works.
This
is
actually
really
really
well
thought
out.
A
I
love
to
see
design
Docs
like
this,
so
this
is
super
super
cool,
so
that
so
I've
been
thinking
about
this
for
a
while,
and
so
that's
why
I
was
really
excited
to
see
case
thing
come
out,
because
I
do
think
that
this
unlocks
a
lot
of
developer
workflows.
Obviously
this
is
a
development
thing:
okay
syncing!
It
won't
let
you
past
if
your
cluster
is
not
as
big
to
spec,
okay,
so
the
overlay
to
stuff
the
what
I'd
really
like
to
see
happiness
in
and
I
would
always
imagining
that
you
could
do.
A
Is
that
if
you're
running
a
pod
for
development
purposes,
you
could
do
something
along
the
lines
of
run
a
sidecar
and
and
then
use
a
shared
volume
for
the
thing
that
you're
actually
working
with
the,
and
if
you
did
that,
then
essentially
you're
talking
one-on-one,
it's
all
user-mode.
You
wouldn't
even
need
cluster
admin
in
anyway
to
be
able
to
talk
to
the
thing,
and
so
that
would
be
perfectly
acceptable
to
run
something
like
that
on
a
production
cluster
or
on
a
cluster.
That
is
a
you
know,
shared
with
harder
boundaries
right.
A
A
We
have
the
we
have
the
casing:
diamo
that
talks
about
sort
of
our
persistence
sinks.
Right
then,
you
know
it'd
be
really
interesting
in
my
mind,
to
be
able
to
say,
like
maybe
have
like
a
you
know,
a
casing
or
something
like
that
file
that
actually
sits
at
the
root
of
your
of
your
directory,
so
that
you
can,
you
know
boot
stuff
up,
and
it
actually
has
enough
context
there
that
sort
of
sits
with
your
project
for
hey
when
you're
debugging
this
project.
A
A
You
know
there's
definitely
pluses
and
minuses
between
this
that
wouldn't
work
with
the
sort
of
the
many
containers
as
well,
and
it
probably
wouldn't
be
the
type
of
thing
where
you
know
you'd
do
the
persistent
sink
back
and
stuff
like
that,
but
I
think
that
would
be
really
if
you're
just
doing
it
like
on
one
on
one
type
of
thing.
That
would
be
a
really
interesting
way
to
go
and
then
the
security
is
it's
like:
it's
all.
You
know,
user
mode,
so
there's
no
security
concerns
around
it.
So
if.
A
It
that's
probably
the
way
that
I
had
been
thinking
about
it,
but
but
this
is
really
really
super
useful.
So,
let's
see
so
okay,
so
Thomas
says
I
got
a
proof
of
concept.
That
does
that
the
downside
is
that
it
doesn't
work
with
arbitrary
containers
right
so
you'd
have
to
you'd
have
to
muck
with
the
container
and
await
it
so
that
it's
actually
ready
to
be
able
to
do
this
stuff.
A
You
know
we
might
be
able
to
like.
If
you
do
have
cluster
admin,
you
might
be
able
to
do
something
with
like
a
mutating
webhook.
You
know,
or
you
know,
and
again
this
starts
getting
to
the
application
definition
type
of
things.
I
could
imagine
with
something
like
a
sonnet
having
you
know
a
mixin
or
some
sort
of
tool.
That
says
you
know
an
sto
did
this
when
they
installed
their
sidecar
would
be
like.
Take
your
yam
I'll
run
it
through
this
thing
and
then
what
comes
out
the
other
side
is
something
that's
now
casing
compatible.
A
That's
pretty
interesting!
Alright,
moving
up
the
stack
that'd
be
doable
with
caisson
yeah.
Oh
you're
way
ahead
of
me.
There
ok,
helm
is
a
thing
I'm,
not
gonna,
say
like
here's,
the
thing:
here's
my
thoughts
on
home,
so
there's
some
really
interesting
stuff
going
on
in
terms
of
thinking
with
helm.
Three
that
I
think
solves
a
lot
of
the
concerns
that
folks
have
I
think
it's
still
there's
some
other
interesting
decisions
going
down
there,
but
I'm
really
excited
to
see
where
the
helm
folks
take
things.
A
I
think
the
critical
thing
to
recognize
is
that
number
one
you
know
helm
has
it
started
a
long
time
ago,
and
so
there's
some
history
going
on
there
I
think
the
other
thing
to
keep
in
mind
with
helm
is
that
it's
solving
a
very
important
problem.
I
think
we
can
quibble
with
the
way
that
it's
being
solved
but
I
think
the
big,
the
big
value
out
there
is
that
it
is
actually
solving
the
problem,
but
I
think
you
know
this
type
of
thing
is
one
of
those
examples
of.
A
If
we
start
looking
at
like
how
do
we
break
out
the
application
definition
from
the
way
that
we
deploy
the
application,
because,
right
now
in
helm,
those
things
are
really
conjoined
so
that
we
can
do
things
like
start
mixing
in
things
like
casing,
if
it
did
involve
running
a
sidecar?
So
that's
a
that's
kind
of
the
way
that
I've
been
thinking
about
this
with
respect
to
helm,
all
right,
so
I
am
super
super
impressed.
I
could
totally
totally
see
myself
using
something
like
this
to
do
fast,
iteration
and
again.
A
How
do
you
actually
deal
with
that
build
process?
I
think
it
I
don't
see.
It
might
be
interesting
to
actually
talk
about
what
are
the
patterns
or
how
do
you
you
know?
How
do
you
make
a
container?
That's
casing
friendly
right,
which
is
is
means
that
oh,
you
want
to
separate
your
code.
This
way,
if
you're
doing
a
compiled
thing
you
want
to
have,
you
know,
use
this
sort
of
rerun,
ER
thing
that
does
a
kill
and
a
restart
based
on
sort
of
this
file.
A
A
Well,
that
I
think
is
a
great
run
down
of
Kay
sink,
really
really
cool
and-
and
hopefully
this
also
tease
things
up
to
look
at
some
of
the
other
types
of
tools
in
this
space
figure
out
where
they
overlap,
pluses
and
minuses
that
type
of
thing
any
last
questions
before
I
go
ahead
and
sign
off
I'd
love
to
love.
To
answer
any
last
things
before
I
say
goodbye,
but
I'm
definitely
I'm
really
excited
to
be
back
doing
TGI,
k4,
copernicus,
caperna
DS.
A
You
know
I'm
missing
two
weeks,
I
really
missed
it.
So
I'm
really
look
forward
to
the
rest
of
this
series
and
covering
more
of
the
development
workflow
tools.
So
all
right!
Well,
thank
you.
Everybody
for
watching
I
will
see
you
next
week
and
keep
sending
me
ideas.
Let
me
know
what
you
think
of
this,
and
you
know
if
you
don't
already
hit
the
the
like
in
the
subscribe
button,
and
I
will
see
you
all
next
week.
Alright,
thank
you.
So
much
for
watching.