►
From YouTube: Kubernetes SIG Apps 20180604
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Welcome
everyone
to
the
June
4th
2018
kubernetes
sig
apps
weekly
meeting
this
week.
We
do
have
an
agenda
where
we're
going
to
be
focusing
on
developer
tools
into
chat
here.
I
will
pace.
This
is
the
agenda
and
any
notes
we
have
anybody
who
wants
to
help
take
notes
along
the
way
please
feel
free.
My
name
is
Matt
Farina
I'm
chairing
today
for
the
announcements,
there's
kind
of
two
things
we
wanted
to
talk
about.
A
One
is
for
those
of
you
who
haven't
seen
it
helm,
joined
the
CNC
f
as
a
top-level
project
alongside
kubernetes
Prometheus
and
others.
There
is
an
announcement
there
if
you
start
tracking
around
there's
lots
of
links
on
it.
That
means
that
things
like
charts,
monocular,
chart,
museum,
helm
and
all
of
that
stuff.
Well,
text
is
now
technically
out
of
cig
a
boner
ship
we'll
have
to
go
around
and
update
a
few
things
and
move
stuff
around
that'll
happen
in
the
coming
weeks,
and
so
it
will
now
just
be
like
any
other
project.
A
A
A
B
We
can
all
right
so
I'll
go
ahead
and
get
started
so
I'm
here
today
to
talk
about
pace
on
it,
I'm
Bryan,
Liles
from
hefty,
oh
and
we're
working
on
case
on
it,
which
is
a
declarative,
configuration
management
tool
for
for
kubernetes,
and
we
don't
actually
talk
about
it
much
in
public,
but
that
is
changing
and
I'm
thankful
that
Matt
invited
us
to
actually
do
this
today.
So
give
me
two
seconds
here
and
we
will
get
started
so
what
I'm
going
to
do
this
is
all
demo
and
but
to
get
started.
B
B
It
is
really
it's
a
language
that
is
also
a
superset
of
Jason,
so
copper,
a
ballad
Jason
document
is
valid
JSON
it,
but
it
also
gives
you
functions
and
conditionals
and
all
sorts
of
neat
things.
So
let's
talk
about
what
case
on
it
is,
and
actually
let's
just
use
it
and
see
how
it
works.
So
what
I'm
going
to
do
is
we're
gonna
start
this
all
fresh
case
on
it
has
a
binary.
B
It's
called
KS
and
we're
gonna
create
one
here,
and
what
I'm
going
to
do
is
I'm
gonna
tell
to
use
kubernetes
namespace
stem
I
want
that
I've
already
created
and
we're
gonna
create
an
environment
inside
of
a
sonic
called
demo
one,
so
they'll
just
be
the
same,
and
what
have
we
created
here?
Well,
let's
go
into
this
directory
and
we
look
at
it.
We
we
create
a
few
different
directories
and
a
few
different
files
and
I'll
just
go
through
this
real,
quick,
an
app
dot,
amo
file.
B
This
is
the
configuration
for
your
case
on
a
tap.
It
tells
us
what's
in
there
and
how
it's
all
put
together,
and
then
we
have
components,
components
describe
kubernetes
objects
and
in
a
component
file
could
be
one
many
one
to
one,
but
just
think
about
all
the
things
that
you
want
in
your
kubernetes
cluster
will
exist
in
this
components.
Directory
inside
this
directory
is
also
a
pre-emptive
sonic
file,
that
is,
parameters
or
values
for
your
components.
These
are
the
defaults
and
then
next
below
here
is
environments
and
notice.
We
created
this
demo
one.
B
So
what
this
does
is
describe
the
environment
describes
where
the
cluster
is.
It
describes
how
to
combine
environment
level
parameters
which
will
override
component-level
parameters
and
then
below
there.
There
is
something
called
lib,
and
this
is
our
a
sign
at
lib,
which
I
will
go
into
a
little
bit
later,
but
really
what
case
on
it
live
is.
B
Is
it's
a
conversion
of
kubernetes
schema
for
a
particular
version
and
in
this
case
19.6
and
to
json
it
that's
important
whenever
you
want
to
do
some,
some
interesting
things
with
kubernetes
in
the
future
and
then
there's
also
vendor
and
vendor,
is
for
extendable
extent
external
dependencies
and
we'll
look
at
some
of
those
as
well.
So,
let's
so
we're
inside
of
our
app.
What
can
we
do
so?
B
First
thing
we
probably
want
to
do
is
create
some
objects
and
one
thing
that
k
sauna
does.
Is
it
actually
gives
you
some
samples
to
start
off
with?
So
if
you
wanted
to
create
a
config
map
or
a
service
and
a
deployment
or
name
space
or
just
a
deployment
and
a
service
by
yourself,
we
actually
can
we
have
code
generators
that
will
actually
do
that.
For
you,
so
what
do
those
actually
look
like
so
yeah?
B
We
can
use
this
KS
prototype
command
to
describe
and
we'll
just
do
a
deployed
service,
because
this
one
is
the
most
comprehensive
and
what
it
does
is
it
takes
a
few
arguments
and
what
it'll
do
is
it
creates
a
deployment
and
a
service.
But
what
does
that
look
like
so
before
you
have
to
commit
to
this
thing?
B
What
we
can
do
is
we
can
actually
preview
it
and
what
I'm
doing
in
this
example
is
I'm
pre
previewing
a
deployed
service
prototype,
which
is
just
example,
some
generated
code
and
I'm
gonna,
give
it
the
name,
app,
1
and
I'm,
going
to
give
it
an
image
with
image.
Koentact,
that's
not
real,
but
it
works
for
this
because
it's
only
a
preview.
So
what
does
it
create?
So
if
we
go
from
the
top
to
the
bottom,
there
are
some
local
variables
that
are
created
inside
the
JSON
it
and
then
we're
below
this.
B
We've
created
an
array
and
in
this
array
there's
two
kubernetes
objects:
there's
a
service
and
below
that
there
is
actually
a
deployment
and
whenever
what
will
happen
is
case
on
it
will
see
this
array.
It'll
say:
oh
there's
two
objects
in
here
and
it
will
do
whatever
it
needs
to
do
to
get
them
employed
to
the
cluster.
So
now,
let's
go
ahead
and
actually
create
this
inside
of
our
inside
of
our
application.
So
in
this
example,
oops.
B
Try
some
more
time
cannery
there
you
go
so
in
this
example.
What
I'm
doing
is
I'm
creating
a
deployment
and
a
service
and
I'm
gonna
talk,
I'm
gonna
title
it
guestbook,
UI
and
I'm
gonna,
give
it
a
real
image,
and
this
is
just
a
demo
image
that
we've
been
using
and
heftier.
Ultimately,
it
shows
this
guestbook,
but
we're
not
going
to
be
running
it
really.
So
it's
just
an
image.
B
So
if
we
go
inside
of
our
app
and
we
review
it
and
we
look
at
it,
we'll
see
what
we've
generated
here
and
so
what
we've
created
are
two
things.
One
we've
created
this
guestbook
UI,
which
is
look
just
like
the
prototype
we
saw
before,
and
we've
also
created
some
parameters
that
we
can
use
as
defaults,
and
the
way
that
these
are
used
is
by
lines
like
this
params
line.
B
So
since
we've
imported
it
right
here,
we
can
actually
use
this
params
and
we're
using
params
name
all
over
these
two
things
here,
all
over
these
two
objects
and
what
we
then
get
is
we
as
we
get.
We
have
components
so
we're
really
trying
to
focus
on
the
command
line.
With
case
on
it,
so
I
created
this
component
and
now
I
get
this
list.
I
want
to
list
my
components:
I
can
see
it
there,
but
what
I
also
can
do
is
list
my
parameters
and
I
can
see.
B
These
are
the
these
are
the
knobs
that
I
can
actually
adjust
to
change,
how
how
my
objects
will
be
rendered.
So
now
we
have
this
component
here,
but
really
what
we
want
is
we
want
to
be
able
to
apply
it
to
an
environment
which
represents
kubernetes
namespace
on
a
cluster.
So
when
we
created
this
application,
we
created
a
default
environment,
and
this
and
this
for
this
particular
example,
this
particular
time
I
fired
up,
coumarin
docker
for
mac
and
its
kubernetes
cluster,
and
it's
a
1.96
version
and
it
sits
on
localhost
still
my
machine.
B
So
whatever
we
want
to
actually
look
at
what
I,
what
we
actually
want
to
generate
kubernetes
objects,
we
need
to
generate
them
off
of
a
of
a
cluster.
So
what
I'm
going
to
do
here
is
I'm,
going
to
show
my
demo
one
environment
and
what
it's
going
to
do
and
I'll
just
show
you
here
is
this
going
to
take
that
JSON
encode
that's
over
here!
B
Do
all
the
parameter
substitution
do
whatever
else
it
needs
to
do,
and
it
creates
two
kubernetes
objects
and
when
we
think
about
this
is
that
you
can
actually,
if
you're,
into
Jason
as
well,
we
will
export
it
as
Jason
and
notice
that
we
wrap
it
in
a
kubernetes
list,
because
you
can't
have
multiple
files
unless
they're
sitting
in
some
kind
of
array.
So
that's
so
that's
what
that's
what
case
on
it
is,
but
you
know
that's
only
slightly
interesting
now.
Where
do
we
get
to
the
part
where
a
case
on
it
becomes
interesting?
B
B
It's
going
to
create
these
new
objects
and
all
these
lines
so
I'll
go
ahead
and
do
that
and
notice
here
that
it
actually
says
hey
I'm,
trying
to
create
this
service
called
guestbook,
UI
and
disappointment
that
this
deployment
guestbook
UI
and
they
didn't
exist
so
I'm
creating
them
so
case
on
it
connects
you.
Lee
will
actually
apply
to
the
cluster
for
you,
so
you
know
getting
more
interested
more
interesting,
but
here's
something
else
that
case
on
it
can
do
so.
B
We
have
our
parameters
like
we
were
talking
about
before,
and
they
are
all
separate,
the
actual
configuration.
Well,
we
can
change
them,
so
I
can
actually
do
something
like
chaos,
ramsett
guestbook
UI,
and
what
we'll
do
here
is
we'll
change.
The
replica
is
the
default
replicas
and
right
here
so
now
my
default
is
my
replicas
are
now
so,
if
I
do
KS
diff
you'll
notice
that
if
I
were
going
to
apply
this
again
that
my
replicas
would
now
be
it'll.
Tell
me
exactly
what
it's
going
to
change.
So
let
us
go,
KS
apply,
Gemma
one.
B
It's
only
up
to
it
says
it's
updating
both,
but
it's
really
only
updating
the
deployment
so
what
case
on
it,
we
know
that
applications
exist
in
multiple
environments.
So
here's
here's
the
next
thing
we're
going
to
show
so
now
we're
going
to
actually
go
KSM
ad
and
we'll
create
this.
This
new
demo
environment.
So
we'll
say
that
demo,
one
is
development
or
staging
and
we'll
say
demo:
two
is
our
production.
B
B
Right
KSM
set
I'm.
Sorry,
yes,
Aram
say
we
set
the
default.
Well.
What
about
in
production?
We
want
to
be
four
groups,
we
want.
We
want
the
numbers,
because
you
know
this:
is
our
production
workload
it's
going
to
get
more
traffic,
so
we
can
actually
do
that.
So
now,
whenever
we
apply
to
demo
one
we're
actually
in
our
dev
our
staging
we're
going
to
get
the
small
amount
of
replicas,
but
whenever
we
apply
this
thing
to
our
production,
we
actually
get
four.
So
that's
just
a
quick
overview
of
that.
B
I'm
gonna
move
on
to
two
more
two,
more
quick
things
here
so
kubernetes
our
case
on
it
also
supports
llamo.
We
actually
support
ya
Mille
as
the
first
class
thing.
Let
me
give
you
an
example
of
what
I
mean.
So
just
a
lot
of
people
go
out
to
the
internet
and
what
they
do
here
is
they
they
find
the
animal
created
by
someone
else.
So
in
this
case
it's
something
off
the
kubernetes
dock
site.
It's
actually
just
a
deployment
that
was
created
well,
what
we
can
do
is
now
we
can
actually
create.
B
We
can
import
this
channel
into
our
application.
So
there's
two
things
happening
here:
one
I'm
downloading
this
sham
of
looking
inside
of
it
and
creating
splitting
it
up
and
creating
different
different
files
for
every
single
object,
I
find
in
there,
and
the
second
thing
is
that
I
also
put
it
in
a
different
location
inside
of
my
components.
Now,
why
would
we
want
to
do
that?
Well,
we
believe
that
applications
are
complex
and
applications
across
enterprises
to
lots
of
different
things,
so
we're
allowing
you
to
separate
components
of
your
application
from
other
parts.
B
So
we
actually,
we
have
the
gamal
here,
but
we
separated
it
from
our
guestbook,
so
you
can
actually
operate
them
operate
on
them
differently,
but
another
thing
we
can
do
is
we
can
do
we
can
actually
we
can
actually
operate
them
or
operate
them
on
the
environment
level,
okay,
so
demo,
one!
So
now
what
we've
done
is
we
said
that
hey
our
application
has
multiple
modules
in
it.
It
has
one
with
our
guestbook
UI
and
also
one
with
our
engine
X,
and
then
we
can
operate
on
those
together
now.
B
So
if
I
do
KS
apply
demo
one,
it's
going
to
now
add
that
in
there,
and
why
do
we
do
that?
Well,
the
reason
why
is
because,
like
I
was
saying
before
inside,
of
a
typical
Cooper
nice
cluster,
you
could
have
something
like
certain
manager
of
Prometheus
or,
let's
say
contour
from
hep
DL,
and
then
also
you
might
have
app
1
F,
2,
F,
3,
F,
4
and
F
5.
You
don't
always
wanted
to
pull
it
all
those
together
in
depth.
B
You
should
have
the
flexibility
to
be
able
to
apply
those
and
whatever
way
they
they
need
so
case
on.
It
will
allow
you
to
build
those
constructs
and
put
them
together.
So
here's
another
feature
is
one.
Other
thing
we
can
do
is
even
though
we're
accepting
the
amal.
What
we
can
do
is
we
can
modify
parameters
for
animal.
B
So
here's
a
good
example
where
I'm
actually
setting
a
new
metadata,
annotation
called
foo
with
the
value
of
bar
on
on
this
new
on
this
on
this
channel,
and
I'm
not
gonna,
actually
I'm,
not
gonna,
actually
I'm,
not
changing
the
yamo
itself.
This
is
still
the
same,
but
I'm
saying
the
parameters
are:
are
changed
so
whenever
I
do
KS
show
demo
one
what's
gonna
happen
is
case
on
its
gonna
realize
hey.
B
We
want
to
actually
update
that
thing
whenever
we're
whenever
we're
rendering
it
out,
so
we
can
have
overlays
on
top
of
a
gamble
and
we
can
do
it
for
new
or
existing
values.
Alright.
So
the
next
thing
about
said
I
will
talk
about
forgetting.
Is
this
thing
called
K
sonnet,
Lib
and
case
on
it
in
case
on
deliver
to
different
things
like
I
said,
K
sonnet
Lib
is
a
conversion
of
the
kubernetes
schema,
that's
in
Jason
to
K
Sonic
or
into
JSON
it
now?
Why
would
you
want
to
do
that?
Well,
here's
a
good
example.
B
Let's
say
we
have
objects
and
we
have
deployments
and
deployments.
We
really
want
to
be
able
to
just
apply
node
affinities
to
our
deployments.
So
what
I
could
do
is
I
could
actually
go
into
this
source
and
go
down
here
and
and
set
up
my
node
affinity,
but
what
case
on
it
live
actually
knowing
how
case
on
or
how
kubernetes
works.
There's
actually
a
much
easier
way
of
doing
this
or
actually
a
better
way,
a
more
maintainable
way.
B
So
I'm
going
to
type
some
commands
here
and
the
first
thing
I'm
doing
is
adding
an
external
dependency.
So
by
doing
ok,
it's
ridiculous
and
I'm.
Adding
this
new
thing
that
I
created
called
case
on
a
container
and
then
I'm
going
to
do
KS
package
list
and
I
have
this
new.
This
new
package
called
KSC
scheduling
installed
so
KS
package
install
KSC
scheduling
now
I
have
this
library
inside
of
my
application.
B
So
this
is
a
little
bit
more
advanced,
but
this
is
something
that
we
are
trying
to
teach
people
how
to
do,
how
to
do
it
and
instead
of
actually
typing
it
in
I'm,
going
to
cut
paste
because
I
am
NOT
a
great
typer,
and
so
we've
imported
this
thing
into
our
library
and
what
we're
gonna
do
here
is
we're
going
to
take
this
whole
deployment
object
out
of
here
and
we're
going
to
go.
We're
going
to
put
it
right
here.
B
Local
deployment
equals
that
thing
we
just
pasted
and
and
then
we're
just
going
to
go
down
here
and
then
what
we're
going
to
do
is
we're
going
to
change
our
objects,
so
we're
gonna
do
D
with
a
that's
on
deployment
affinities
and
what
we're
going
to
do
is
we're
just
going
to
add
a
new
affinity
and
if
I
were
to
type
this
out
there
actually
is.
We
wrote
we
actually
wrote
a
json
plugin
for
BS
code,
so
there
actually
is
documentation
for
this.
So
I've
now
created
this
new
deployment.
B
This
D
with
a
and
what
it
does
is
it
actually
just
puts
a
node
affinity
in
there
and
whenever
I
rendered
this
out,
what
you're
going
to
see
is
I
didn't
change
anything
inside
of
my
code,
but
Kay
sonnet
Lib
was
able
to
actually
go
inside
there
and
make
the
node
affinity
right
where
it
needed
to
be.
We
could
do
this
many
times
and
there's
lots
of
different
options
there.
B
So
Nano
I'm
gonna
take
this
advantage
and
and
Matt
I'm
only
going
to
take
three
more
minutes,
but
I
want
to
show
this
because
I
think
this
is
so
important
for
this
group.
We
are
super
into
embracing
the
community
at
hep.
Do
you
know
we?
We
have
people
who
actually,
we
have.
Two
thirds
of
the
founders
of
kubernetes
I've
been
tasked
to
not
only
just
make
case
on
it,
but
figure
out
better
ways
for
people
to
interact
inside
the
kubernetes,
an
ecosystem
when
comes
to
applications.
B
So
back
last
month,
I
mentioned
hey,
a
sauna
is
going
to
support,
helm
and
what
I'm
getting
ready
to
show.
You
is
not
production
quality
yet,
but
I
want
to
be
held
to
my
promise.
So
I
am
going
to
show
you
case
on
it,
helm,
integration
and
because
it's
not
all
integrated
in
what
I'm
going
to
have
to
do
is
nice
because
I'm
not
because
I
don't
have
a
tool
that
will
actually
add
a
case
on
it,
repo,
yet
gar
Mia,
how
to
add
a
Hellmuth
repo.
The
the
first
thing
I'm
doing
here
is
I'm.
B
B
Alright,
so
we've
added
this
this
new
we've
added
this
new,
this
new
registry.
So
now,
whenever
I
do
a
KS
package
list,
not
only
do
I
get
what's
built
in,
but
I
can
actually
see
all
the
helm,
charts
that
are
and
helm
stable
as
packages
for
case
on
it.
So
which
means
I
can
do
KS
package
install
helm
and
we're
gonna
do
Redis
and
what
it
does
downloads
Redis
into
our
environment
here.
So
let's
actually
create
a
helm,
module
or
helm
component
for
for
kubernetes
on
it.
B
B
So
I'll
tell
you
this,
while
I'm
actually
doing
this
Microsoft's
had
some
wins
today,
but
cutting
and
pasting
out
of
OneNote
is
not
one
they
had
so
now.
Whenever
I
do
a
KS
show
demo
one
I'm
getting
I'm
using
helm
to
actually
render
the
temp
the
the
templates
that
were
involved
in
the
chart
and
I'm
actually
can
do
some.
B
B
I
could
probably
do
this
for
an
hour
because
I
missed
over
a
lot
of
things,
but
I
just
wanted
to
show
you
that
what
K
sana
provides
and
really
what
we're
trying
to
do
is
have
that
declaration
of
a
declarative
configuration
which
basically
says
what
you
have
on
disk
once
you
apply
it
to
the
cluster.
That's
what
it
is.
There
are
no
conditionals
there's
nothing
like
that.
That
is
what
it
is,
and
there's
no
guessing
or
templating,
or
anything
like
that.
So
that's
what
I
want
to
show
you
all
today,
thanks
I
will
take
questions.
B
I
actually
did
not
see
the
chat
because
I'm
in
full-screen
mode
here,
but
if
you
have
some
either
reach
out
to
us
on
case
on
it
all
in
the
kubernetes
slack
or
send
me
e-mail,
be,
are
ye
in
at
hefty
o
comm
tweet
mention
case
on
it.
I'll
see
it,
but
we
want
your
input
because
we
think
this
is
a
great
idea
for
managing
complex
configurations
include
Nettie's.
So
that's
all
I
have
Thank
You
Bryan.
A
A
A
B
A
We're
trying
to
do
okay,
that
makes
sense
so
I
noticed
you
talked
in
there
about
focusing
on
the
command
line
for
the
tool.
Have
you
thought
about
JSON
outputs
as
one
of
the
ways
of
getting
output,
so
other
tools
can
wrap
it
and
build
other
complex
things
on
it
and
interact
in
a
machine
way,
so
yeah
I'm
actually.
B
Chase
on
it
is
built
to
ultimately
work
in
a
get-ups
pipeline,
so
that
means
that
command
lines
for
everything.
We
have
an
effort
right
now
to
do
Jason,
output
from
every
field
command.
There
are
certain
commands
that
do
support
it,
like
you
can
list
parameters
or
a
few
other
things,
and
you
can
get
Jason
output,
but
I
really
want
everything
to
have
Jason
outlet,
so
it
can't
operate
as
it
because
I
don't
because
taste
on
it
isn't
an
endpoint.
B
It's
a
it's
a
it's
a
journey
tool,
so
you
will
only
use
it
on
the
journey,
so
we
do
want
to
make
sure
that
we're
integrating
with
other
things
that
are
doing
things
upstream
and
one
other
thing
I
did
not
mention-
is
that
we
are
actually
we're
setting
up
to
do
linting
and
we
would
love
to
be
able
to
even
work
as
a
linting
thing
where
you
could
actually
get
Jason
coming
in
to
case
on
it.
We
could
say:
hey.
B
You
know
what
hey
this
our
back
this
this
cluster
stuff
right
here,
this
cluster
are
back
configuration
is
basically
giving
you
routes,
we're
just
going
to
say,
hey
it's
giving
you
routes
and
then
move
on,
and
you
can
decide
what
you
want
to
do
with
it.
So
we
wanna
we're
not
in
we're
not
the
beginning
of
a
journey,
we're
not
the
end
of
the
journey,
but
we
want
to
make
the
journey
nicer.
A
C
A
B
B
A
B
B
Want
to
say
one
last
thing
is
that
we
look
at
the
ecosystem,
as
you
know,
a
whole
big
thing,
and
we
see
all
the
contributions
from
all
these
great
projects,
we're
just
realizing
that
it
is
going
to
take
all
of
us
together
to
make
something
great
and
your
organization
is
going
to
need
its
own
cocktail
of
apps
to
make
it
successful.
We
just
want
to
be
in
part
of
more
of
those
and
help
people
help
make
this
thing
approachable
to
more
people.
So
we're
just
happy
to
be
a
part
of
the
environment.
A
Thank
you.
So
the
next
topic
we
had
up
was
a
discussion
and
we
were
going
to
do
developer
tools.
That's
one
of
the
things
that
we've
talked
about
doing
is
looking
at
developer
tools
every
other
week
and
this
week
it's
it's
to
chat
about
that,
and
we've
got
a
couple
of
points
that
have
been
written
in
here
to
kick
off
the
discussion.
A
D
And
they're
very
general
questions,
but,
to
be
honest,
I'm
still
trying
to
figure
out
like
the
best
use
of
everyone's
time
in
these
weekly
meetings.
I
think
one
of
the
things
is
it's
hard
because
I
don't
know
everyone
in
the
room
backgrounds
are
interested
in
and
very
possible,
so
I
just
kind
of
want
to
put
that
out.
There
too,
like
it
would
be
interesting
to
see
how
we
might
I
don't
know,
get
background
information
from
people
or
something
I
know
there.
D
E
One
thing
that
one
of
the
pieces
of
I
would
give
is
it
just
because
we
may
have
visited
a
topic
before
doesn't
mean
it's
not
important
to
revisit
it,
because
kubernetes
changes
so
much
that
the
opinions
of
a
topic
six
months
ago
might
be
very,
very
different
from
the
opinions
of
a
topic
with
that,
so
I
would
I
wouldn't
like
a
Welcome
Packet.
It
may
have
been
discussed
before
prevent
you
from
bringing
that
up.
If
it's
an
important
topic
to
discuss
now,.
A
Ya
know,
I,
think
that's
a
great
question.
Besides
the
survey
where
people
gave
in
which
we
didn't
even
I,
don't
think
we
explicitly
asked
what
tools
were
missing,
but
I'd
have
to
go
back
and
look
and
get
hints
from
it
from
the
survey.
I
don't
know
if
we
have
that,
and-
and
you
know
quite
frankly,
it's
one
of
those
interesting
conversation
topics
to
write,
because
one
of
the
things
we
used
to
say
was
missing
was
validation
tools
and
because
people
couldn't
discover
the
validation
tools
out
there
they're
actually
a
bunch
of
validation
tools.
A
Now
that
many
of
them
work
in
a
very
similar
way,
because
it
wasn't
necessarily
discoverable
and
so
that
space
can
kind
of
be
maybe
over
killed
now
I
mean
some
other
people
because
of
its
discoverability
may
still
not
know
about
all
these
validation
tools,
and
so
I
think
this.
This
is
kind
of
a
good
question
because
it
it
highlights
discoverability
how
information
sharing
is
going
on
holes
and
maybe
features
in
those
holes.
D
C
C
Asked
this
because
I'm
trying
to
work
on
some
snooping,
API
snoop
for
the
kubernetes
api
and
I
would
love
to
see
what
our
community
is
actually
using
and
and
some
sample
data
so
that,
as
we
write
our
tests,
we
can
go
and
see
what
other
people
are
doing.
Both
benefit
our
own
test.
Writing
and
for
the
centralized
280
testing
on
kubernetes.
C
A
It
comes
to
the
end-to-end
testing
that
isn't
really
uncommon
is
for
in
a
CI
pipeline.
In
fact,
this
is
even
how
we
do
their
community
charts
right.
The
home
community
charts
is
we'll,
go,
create
a
namespace,
we'll
go
spin
up
an
application
in
that
namespace
in
our
development
environment
and
then
we'll
run
a
mere
two
tests
on
it
and
tear
it
down.
Sometimes
I
kind
of
project
I
used
to
work
on
for
the
life
of
a
pull
request.
A
We'd,
keep
that
environment
up
and
keep
updating
it
other
times
it's
torn
down
right
after
the
test
run.
It
kind
of
depends
on
the
practical
things
that
you're
doing
right,
because
if
you
need
to
go
share
that
PR
with
other
people,
you
want
to
keep
it
up
for
longer,
like
if
you're
doing
a
web
app
or
something
like
that,
and
so
there's
a
lot
of
different
characteristics
of
this.
But
that's
I've
seen
this
in
I
mean
just
in
the
last
year,
I've
seen
three
or
four
environments
that
I've
personally
touched
for.
A
It's
that
same
kind
of
flow
of
a
pull
request
to
a
namespace
where
you
stand
up
the
application
in
and
then
tear
it
down,
and
it
just
depends
on
how
long
it
lives
there
I
remember.
In
one
case
we
were
doing
so
many
of
them
and
was
actually
standing
up
a
logging
solution
that
we
ended
up
killing
our
disk
system.
A
So
it
teaches
a
lot
of
things
down
the
stack
that
you
might
need
in
your
cluster,
because
it
was
a
logging
system
and
we
were
logging
so
much
stuff
and
we
had
so
many
pull
requests
open
at
the
same
time
that
we're
all
logging
and
writing
to
disk
that
we
we
had
issues,
but
that's
just
one
example:
I
don't
know,
others
may
have
something
as
well.
So.
B
What
the
first
thing
is
we
actually
so
like
I
said
before
we
want
to
be
a
part
of
your
pipeline.
We
validate
all
the
there's
a
know,
there's
a
Masonic
command
for
validating,
making
sure
that
hey
this
thing
is
valid,
that
it
can
actually
be
in
certain
and
then
it's
another
project
that
probably
will
be
separated
out
from
caisson.
It
is
the
case
on
an
end-to-end
test
and
the
reason
what
that
is
is
that
it
can
just
run
a
workload.
It
can
exercise
the
crap
out
of
that
workload
so
from
soup
to
nuts.
E
E
I've
never
been
a
hardliner
on
that
myself,
just
because
I
think
client-side
validation
is
probably
very
valuable
to
users
and
the
API
server
doesn't
necessarily
give
you
a
good
way
to
round-trip
something
to
determine
strictly
trip
allegation
without
being
without
actually
having
to
apply
the
command
so
I,
don't
know
what
to
do
for
validation.
If
you
have
on
one
side
like
pressure
from
the
API
missionary,
sighs
don't
do
client-side
validation
is.
E
Determine
what
the
effects
of
your
actual
command
are?
It's
kind
of
still
up
in
the
air
now
I
know
as
part
of
servers
that
apply
they're
trying
to
work
on
a
drive
run
command
to
allow
a
generic
way
for
clients
to
do
validation
against
the
cluster,
but
I
don't
even
know
when
that
will
be
available
so,
and
people
want
to
be
able
to
dry
run
a
command
without
well
user
zeal.
A
way
to
dry
run
a
command
to
try
to
determine
if
it
will
succeed
or
not
so
super
complicated
yeah.
A
But
I
think
some
of
this
is
getting
into
the
app
operation
right.
So
when
I
tested
it
I'm
pretty
sure
my
config
is
gonna,
go
spin
up
my
stuff
and
that's
gonna
be
the
least
of
my
problems.
I'm
then
working
features,
application
so
say
it's
a
website
right
I
may
want
to
go,
run
cross-browser
testing
and
use
something
that
runs
a
bunch
of
analysis
across
different
browsers
or
you
know,
maybe
I'm
doing
react
and
I
want
to
run.
A
We
had
some
kind
of
react,
integration
tests
or
something
or
maybe
I've
got
two
services
and
I
want
to
make
sure
that
all
the
api's
are
talking
and
I've
actually
stood
up
these
services.
But
it's
all
about
the
app
code
at
this
point
right,
I'm,
usually
going
to
assume
that
we
got
the
kubernetes
config
right
and
we're
spinning
this
up
and
pull
requests
or
stuff
many
times
a
day,
and
so
the
kubernetes
config
isn't
the
problem
and
the
operation
isn't
the
problem
I'm
now
gonna
say
now
that
I've
got
this
thing
up.
A
I
want
to
go
fire
off
some
other
tests
against
this
that
are
related
right.
Maybe
it's
an
API
server,
and
so
now
I'm
gonna
say
he's
the
integration
working
for
other
outside
clients
and
tools
and
I'm
pulling
some
other
client
and
tool,
maybe
I'm
doing
a
container
native
CI
pipeline
right
and
the
next
step
before
I
go
teardown.
My
PR
is
to
say
I'm
gonna
grab
one
of
these
outside
tools.
A
I
expect
to
integrate
with
it
and
I'm
gonna,
just
test
it
and
make
sure
the
whole
integration
works
right
because
that
other
tool
works
and
then
once
I've.
You
know
I've
now
tasked
my
app
logic
more
so
than
anything
about
the
cluster
right,
it's
running
in
the
cluster
and
it
keeps
the
config
but
you've
kind
of
tested
that
more
real-world
situation,
maybe
I'm
gonna
go.
Do
some
yell
ability,
testing
right,
maybe
I'll
go
hit
it
with
some
tool.
E
Does
but
one
thing
that
I've
seen
I
guess
from
looking
at
the
last
two
cuvee
cons
and
then
talking
to
users,
it
seems
like
see
I
in
particular,
and
testing
in
particular,
is
very
near
and
dear
to
every
organization's
heart
and
they
all
build
their
own
bespoke
system
like
there
isn't
a
standard
thing,
so
everybody,
almost
everyone,
is
building
their
own
bespoke
thing,
there's
nothing
standard
and
they
all
well.
A
fraction
of
them
tend
to
use
Jenkins
somewhere
along
the
line.
Cb.
E
Maybe
like
you
know,
if
you
look
like
look
at
weed
flux
and
code
ship,
there
are
things
out
there
that
I
would
say
or
standards
that
are
popular
at
least
and
used
by
many
people
for
continuous
deployment,
but
the
integration
piece.
The
smoke
test
can
piece
the
scalability
testing
piece,
stressing
yeah
like
there's.
No
there's
no
standard
across
the
community
that
I
have
seen
emerging
I.
A
Know
and
a
lot
of
it
is
just
get
it
up
and
then
use
existing
tools
like
if
I
want
a
load
test.
Something
there's
tools
out
there
to
do
it.
I
just
need
to
you
know,
get
it
into
an
environment
where
I
can
load
test
it
and
then
run
an
existing
load
test
tool
on
it
and
be
able
to
pass
those
parameters
around
and
a
lot
of
systems
do
it
now.
One
of
the
things
you
might
find
interesting
here
is
when
we're
looking
at
the
the
app
survey.
A
If
you
took
Jenkins,
and
then
you
took
alongside
of
it
all
the
other
cloud
native
ones,
right
get
lab,
CI,
drone,
Concours,
the
other
ones
that
use
containers
and
pipelines
to
do
it.
Besides,
Jenkins,
there
were
slightly
more
of
those
in
use
than
Jenkins.
If
you
combine
them,
I,
don't
know
how
many
people
are
using
two
of
them
or
three
different
systems,
depending
on
what
they're
doing,
but
where
Jenkins
kind
of
has
dominated
that
space.
A
A
B
A
Okay,
no,
that's
a
good
one.
Yeah
cuz
linkedin
gets
a
little
bit
more
into
opinion.
Nation
validation
says:
is
this
valid
objects
that
you
can
pass
in
linting
says?
Is
this
the
right
idea?
Do
you
have
the
right
things
there
and
and
here's
a
here's,
a
simple
thing
right:
we
are
currently
working
on
the
labels
and
annotations
to
recommend
that
all
your
application,
kubernetes
objects
have
to
to
do
that.
A
I
know
have
talked
about
writing
their
own,
but
you
know
maybe
a
space
that
lets.
You
have
flexible
rule
engines
and
and
linting
like
cuz
they'll,
like
one
of
the
yamo
linters
that
I've
used,
which
has
pass
in
certain
things,
and
then
we
will
validate
the
stuff
based
on
your
rules.
Files,
I,
don't
know
if
we
have
something
like
that,
that
really
targets
kubernetes
yeah.
B
A
You
know
we
need
more,
a
better
ability
to
debug
things
in
those
kinds
of
environments
that
we're
running
them.
In
especially,
you
know.
If
we
were
maybe
writing
it
on
a
Mac.
As
so
many
people
in
the
community
are,
and
your
POSIX
environment
is
mildly.
Differing
your
tool,
Jane
is
slightly
different
and
then
you
go
to
run
it
inside
of
a
container
say
a
Linux
container.
A
The
draft
folks
have
talked
about
it
and
then
there's
telepresence,
which
recently
demoed,
which
will
help
you
with
some
of
this
but
figuring
out
good
ways
to
debug
stuff
I
think
it's
still
a
weakness
compared
to
the
kinds
of
stuff
I
was
using
even
5-10
years
ago,
in
just
other
languages
and
other
kinds
of
pre
cloud
native
setups
that
Fisher
you
were
Oh
to
booking
for
microservices
question.
I
had
not
seen
that.
Thank
you,
but
in
chat,
Matt
Fisher
shared
something
called
squash,
which
is
debugging
for
micro
services,
which
I
had
not
seen.
Yes,.
G
What
basically,
how
it
worked
is
that
in
the
earlier
orly
versions
of
squash,
how
it
worked
is
that
it
ran
a
daemon
set
that
basically
attached
a
remote
debugger
or
at
least
a
controller
that
would
attach
a
remote
debugger
to
your
pod.
So
imagine
if
your
pod
is
written
in
go
or
your
pod
is
something
like
that
it
would
attach
a
remote
delve,
debugger
and
basically
d/s
code
would
through
this
plugin.
G
A
G
A
G
G
The
one
thing
that
actually
I
did
see
and
think
about
the
limitations
of
go
in
particular
is
that
I
believe
you
need
a
specific.
You
need
a
very
I
can't
remember
exactly
what
it
was.
It
was
like
sis
proc
or
something
like
that
that
you
need
to
attach
inside
of
your
helm,
chart
or
inside
of
your
kubernetes,
manifest
to
basically
to
allow
the
remote
debugger
to
attach
and
to
connect
to
the
local
service,
at
least
for
draft.
G
So
there
was
that
one
limitation,
I
I'm,
not
a
hundred
percent,
fully
like
I'm,
not
its
pre-coffee
for
me
this
morning,
but
I
do
recall
that
you
had
to
modify
your
kubernetes
manifest
yes,
SP
trace.
Thank
you
thanks
yeah
Brad,
who
has
more
information
on
that.
But
that
was
one
thing
that
was
a
limitation
of
the
current
debuggers
that
you
needed
that
specific
capability
inside
your
container
in
order
to
connect
and
do
a
remote
attach
of
the
existing
debuggers
out
there
today.
D
A
Yeah
and
that's
even
kind
of
how
it
is
in
a
lot
of
places
in
open
source
software
and
applications
stuff
across
the
board,
I've
taken
so
many
tools
that
were
never
thought
of
to
work
together
and
piece
them
together
in
Jenkins
pipelines
over
time
that
it's
kind
of
crazy.
So,
along
those
lines
there
was
a
second
question
of
what
internal
tools
have
you
built
that
no
one
knows
about
yet
that
you'd
like
to
chat
about?
A
Is
there
anybody
who
wants
to
do
that
or
in
the
last
couple
minutes
or
maybe
think
about
it
and
get
permission?
And
then,
in
two
weeks,
when
we
come
back
to
talk
about
these
developer
things,
you
can
say
ooh
this
internal
thing,
I,
don't
know
that
I
can
but
I
checked
on
it.
We
can
talk
about
this
neat
thing.
Do
you
have
if
you
have
something
like
that?
Think
about
it?
D
A
And
one
of
the
things
that
we
did
discover
in
the
survey
was
a
lot
of
people
have
built
their
own
in-house
tools,
I'm,
actually
kind
of
curious.
How
much
more
so
they've
done
with
kubernetes
than
with
past
platforms
to
know
whether
this
is
just
a
normal
way
they
operate
or
if
it's
something
specific
to
kubernetes
because
of
gaps,
we
are
developers.
We
do
like
to
write
things
I.
A
Yeah
yeah
I
mean
a
part
of
this
for
those
of
you
who
don't
know
what
hippy
care
hackers
up
to.
We
are
doing
things
like
conformance
testing
and
testing
in
kubernetes,
and
one
of
the
things
is
to
try
to
exercise
the
api's
and
real
world
ways.
You
know
what
applications
are
exercising
the
API
is
in
what
ways.