►
Description
Speaker: Tim Pepper
A
Okay,
so
Gwyn
mentioned
notifications
and
I.
Just
thought
I
would
try
to
make
it
concrete.
I'm,
not
the
most
super
active
person
in
terms
of
like
code
reviews
and
pr's,
and
things
like
that
compared
to
others,
but
might
get
hub.
Notifications
is
right
there
like
there's
10,000,
it
stops
counting
it's
what
it
just
it
at
some
point.
Everybody
gets
swamped
so
as
you're
going
through
this
process
know
that
everyone
on
the
other
side
of
the
computer
is
actually
a
human
too,
and
it's
not
like
they're
ignoring
you.
It's
just
complicated,
okay,
so.
A
Only
one
screen
this
is
gonna,
be
slightly
complicated
to
go
through,
but
hopefully
we're
able
to
bounce
between
a
little
bit
of
slide,
wear
and
some
actual
demos,
and
maybe
some
of
you
will
be
able
to
follow
along
honestly.
I
expect
a
bunch
of
failure,
and
this
is
good
like
it.
We
can
try
to
work
through
some
of
the
things.
A
It'll
give
you
if
nothing
else,
a
starting
point,
some
orientation
to
see
this
is
a
very
large
complex
project
and
if
you're
thinking
about
building
a
very
large
complex
project,
you
got
to
be
prepared
for
some
struggle
and
there
will
be
multiple
aspects
of
this
and
the
first
one.
Is
you
need
to
think
about
your
development
environment,
so
I'm
here
today
to
talk
about
local
development,
which
means
like
on
this
thing,
you're
on
your
laptop,
probably
and
realistically,
laptops
today
are
kind
of
barely
strong
enough
to
build
kubernetes.
A
So
you
want
to
have
as
much
RAM
as
possible
one
of
the
most
frequent
things
I
run
into
as
I'm
building.
If
I'm
building
things
broadly
is
I
have
link
time
failures
because
I've
run
out
of
memory
and
all
this
stuff's
building
in
parallel
and
it
just
starts
getting
killed
by
the
OS.
So
lots
of
RAM
also
lots
of
CPU,
depending
on
how
we
progress
here.
We're
gonna
make
the
room.
Warm
is
all
of
our
laptops.
A
Try
to
start
building
this
and
then
also
disk
space
I,
as
I
was
prepping,
making
sure
everything
was
set
up
to
try
and
do
some
demos.
Today,
I
ran
myself
out
of
disk
space
in
my
test,
VM
and
you
might
think
well
I'm
in
Windows,
where
I'm
on
a
Mac,
I'm
gonna
just
make
a
little
Linux
VM
to
play
around.
With
this
kubernetes
thing,
I'll
give
it
a
10
gig
hard
drive.
You
will
be
out
of
disk
extremely
quickly.
A
I
just
went
and
deleted,
like
50
gigs
worth
of
stuff,
to
make
some
room
so
that
I
could
build
again.
So
it's
like
multiple
tens
of
gigabytes
that
you
need
to
make
sure
you
have
around
and
then,
depending
on
whether
you're
familiar
with
doctor
or
not
and
Linux,
your
Varla
docker
regularly
just
explodes
full
of
images
and
volumes
and
things
you
weren't.
Even
thinking
about
and
quite
often
you'll
just
need
to
go
in
there
and
clean
that
out
to
free
up
some
space.
A
Another
may
be
opinionated,
hopefully
not
too
controversial
thing
that
I'll
throw
out
here.
Is
I
really
suggest,
starting
with
linux,
and
I've
got
a
Mac
here,
it's
possible
to
do
some
of
these
things
on
a
Mac,
it's
possible
to
do
these
things
in
Windows
with
the
Linux
subsystem,
but
a
lot
of
it
really
is
presupposing
or
expecting
that
you're
running
Linux
and
most
people
probably
are.
A
If
you
start
there,
you're
gonna
have
the
least
friction
sure
if
you're
passionate
about
a
different
OS
graduate
on
to
that
cool,
awesome,
improve
the
docs,
their
submit
PRS,
but
don't
make
your
life
extra
hard
upfront
because
there's
a
whole
bunch
of
other
things
that
you're
gonna
need
to
struggle
your
way
through
as
well.
The
very
first
one
actually
came
up
in
the
back
of
the
room
a
few
minutes
ago.
A
If
somebody
was
trying
to
do
this
on
their
own,
they
noticed
there
was
a
make
file,
hit,
mate
ran,
make
and
it
failed,
and
the
reason
it
was
failing
is
the
location
I
think,
most
of
day
to
day
get
used
to
checking
something
out
of
github
and
building
it.
I
and
my
home
directory
have
a
directory
I
call
source
on
some
of
my
computers,
because
I
used
to
do
Linux
work
and
the
Linux
kernel
used
to
assume
that
you
are
in
user
source.
A
Linux
I
check
things
out
to
user
source
Linux
or
maybe
my
home
source
kubernetes,
wants
to
and
will
fail
to
build
if
you
are
not
in
the
right
place
within
your
go
path.
So
whatever
your
go
path
is
set
to,
you
have
a
source
subdirectory,
that's
normal
beyond.
That
is
things
that
you've
done.
A
go,
get
on
and
kubernetes
wants
to
have
been
checked
out,
indicates,
do
slash
kubernetes
and
you
will
have
built
failures.
A
It'll
just
be
a
whole
spew
of
things
saying
could
not
find
packaged
something
or
other,
and
that's
a
pretty
sure
sign
that
you've
run
into
this
and
for
a
lot
of
people.
I
think
this
is
different
than
how
they
may
normally
do
their
development
and
then
another
gotcha
there
is,
if
you're
doing,
development
you're
probably
is
going
had
just
talked
about
you're
doing
it
on
a
fork,
which
means
you've.
A
Forked,
the
kaykai
repo
into
your
own,
you've
cloned
that
somewhere
onto
your
disk,
you
probably
didn't
choose
to
clone
it
into
the
same
place
that
go
get
automatically
clones
read-only
stuff.
So
you
may
need
to
deal
with
your
git
remotes
and
make
sure
that
things
are
aligned
for
this
pull
request.
Workflow
that
Gwyn
talked
about
on
on
github
and
then
finally,
you'll
want
to
start
thinking
about
what
you
might
use
for
a
test
cluster,
because
kubernetes
is
a
cluster
system.
A
If
you're
gonna
do
a
meaningful
testing,
you
need
a
cluster,
so
I'll
get
into
that
in
a
little
more
detail.
But
maybe
you
can
mentally
be
thinking
about
what
do
I
have
for
resources?
Your
company
may
have
an
affinity
to
AWS
or
GCP
or
I
work
for
VMware.
Maybe
you
use
our
stuff
or
I,
have
a
pile
of
little
Intel
nukes
on
my
desk,
with
a
switch
and
have
my
own
little
physical,
bare
metal
cluster,
there's
a
bunch
of
opportunites,
so
building
I
kind
of
started
to
get
into
this.
A
It's
go
Ling,
but
we
have
make
files.
This
is
weird,
probably
compared
to
other
go
things,
and
not
only
are
there
make
files
there's
a
bunch
of
shell
scripts.
So
if
you've
got
your
kubernetes
director,
UCD
Intuit,
you
might
do
a
dot,
slash,
build
slash,
run,
dot,
SH
make
which
doesn't
seem
like
a
normal
thing.
A
If
you're
used
to
UNIX
make
it's
not
a
normal
thing,
if
you're
used
to
go
so
there's
kind
of
a
mix
of
paradigms
here
with
make
there's
a
bunch
of
different
targets,
there's
things
like
make
quick
release
or
make
what
and
you
can
specify
a
particular
thing.
So
one
of
the
things
I
realized
I,
don't
know
that
we've
actually
presented
sort
of
an
architectural
diagram
of
what
a
kubernetes
cluster
looks
like.
So
you
have
multiple
components.
You
have
sort
of
a
control
plane
with
things
like
the
the
API
server.
A
You
have
clients
that
run
cube,
cuddle
you've
got
worker
nodes,
they're
running
cubelet,
so
all
of
these
things
are
talking
to
each
other.
Those
are
individual
binaries
that
are
running
on
machines
or
virtual
machines
somewhere,
and
you
can
build
them
individually,
and
this
can
be
a
handy
thing
and
I'll
go
into
it
a
little
bit
later,
just
a
sort
of
demo.
What
a
build
looks
like,
but
again
as
a
newcomer
you're
like
what
this
just
doesn't
make
sense
and
I'm
relatively
new
to
kubernetes.
Don't
blame
me:
it's
like!
A
Yes,
we've
got
a
bunch
of
legacy
stuff
and
we're
working
on
making
it
better
and
more
coherent
and
going
especially
as
has
done
a
lot
of
work
this
last
year,
making
that
make
sure
that
we
these
have
this
better
documented.
So,
as
you
come
to
it,
you
can
read
some
things
that
are
like
sort
of
script
play
books
to
work
your
way
through
and
then.
Finally,
all
of
this
happens
inside
a
container,
so
just
like
I
sort
of
argued
for
starting
out
with
Linux
to
keep
things
simpler.
The
core
software
build
infrastructure.
A
People
at
some
point
in
the
past
decides
like
it's
to
do
difficult
to
manage
all
of
the
possible
dependency
differences
across
everybody's
built
machine.
So
we're
just
gonna
make
a
build
container
and
part
of
the
first
build
step
is
to
download
that
container
and
run
it
just
to
give
a
level
environment
for
building
all
right.
Next
up,
testing
and
actually
I'm
gonna
in
a
pause
here
and
I'm
going
to
try.
B
A
Do
a
quick
demonstration
of
that
before
I
go
test
alright,
so
first
of
all,
I
tried
to
make
sure
this
was
relatively
readable.
Can
people
see
that?
Okay,
okay,
so
my
go
path,
happens
to
be
home,
tee
pepper,
go
and
I'm
down
and
home
tee
pepper,
go
source.
Kate's
io
kubernetes,
like
I,
said
where
it's
expected
and
then
I've
gone
into
the
subdirectory
package
cube
kettle.
A
If
I'm
at
the
top
I've
got
a
make,
file
and
I
can
do
something
like
make.
What
equals
command
cube
cuddle
and
it's
gonna
go
off
and
try
and
build
that
for
me-
and
this
is
go,
it's
usually
relatively
quick,
but
there's
some
semi
complex
things,
but
these
these
smaller
build
things
build
relatively
quickly
and
you
can
have
a
on
individual
pieces
parts.
You
can
have
a
pretty
quick
development,
deploy
test,
sort
of
workflow
and
I.
Guess,
maybe
that's
another
way
of
saying:
don't
don't
just
run,
make
or
try
to
build
the
whole
thing.
A
I
did
a
make
quick
release
on
my
laptop
and
it
took
ten
minutes.
The
last
time
I
did
like
a
full
build
because
it
does
cross
building
of
all
the
architectures.
It
took
like
45
minutes
and
I
thought.
My
laptop
was
going
to
melt
and
you
just
there's
generally
no
reason
unless
you're
like
building
a
kubernetes
distribution
to
build
the
whole
thing.
A
So
assuming
you're
getting
to
where
you
can
make
code,
modifications
and
test
things,
you're
gonna
or
make
code
modifications
and
build
things.
The
next
step
is
to
test
them
right.
So,
like
most
big
projects,
I
think
you
can't
you'll
you'll
see
a
couple
of
layers
of
tests
are
available
in
kubernetes
and
right
now
we
have
for
a
until
just
recently.
This
was
three:
we
added
the
the
bottom
one
there.
So
you've
got
unit
tests,
and
these
are
your
normal
native
golang
tests.
A
If
you're
familiar
with
go
the
next
level
up
is
integration
tests
so
go
unit
tests?
Generally
speaking,
you
just
run
go
test
on
the
command
line,
they're
isolated
right
there.
They
run
they
give
output
and
feedback,
but
an
integration
test
if
you're,
what
you're,
building
and
go
has
some
external
dependencies
so
like
kubernetes
depends
on
Etsy
D.
If
you
wanted
to
test
code
that
interacts
between
those
two,
you
actually
need
a
net
CD
running.
So
these
integration
tests
enable
those
types
of
somewhat
constrained
but
still
cross,
packaged
or
cross
component
interaction.
Testing.
A
The
next
level
up,
then,
is
going
from
some
sort
of
test
code
and
an
external
component
to
the
whole
of
a
cluster.
So
what
we
call
in
to
end
or
you'll
you'll
regularly
see
these
abbreviated
e
to
e.
The
e
to
e
tests
are
doing
the
overall
interactions
and
behaviors
of
a
full
cluster
and
that
either
means
that
you've
brought
a
cluster
ahead
of
testing,
or
you
use
some
of
the
the
test
infrastructure
to
spin
up
sort
of
an
ephemeral,
minimal
cluster
to
run
some
tests
against
and
then
the
fourth
level
conformance
testing.
A
These
are
a
subset
of
the
in
doing
tests,
and
this
is
something
new
that
the
governance
of
kubernetes
is
decided
as
necessary.
There's
like
80,
some
odd
vendors
and
distributors
of
kubernetes.
Now
and
as
a
project,
we
need
to
make
sure
that
we
have
some
coherency
when
somebody
says
this
is
kubernetes
that
it
means
something
any
of
those
80
vendors
could
potentially
have
patched
something
in
an
incompatible
way,
and
that
would
lead
to
really
bad
outcomes
for
users
if
they
don't
understand.
A
So
let's
just
see
my
bill
better.
Have
yes,
my
build
finished.
So
if
you're
doing
a
normal
go
build,
you
might
expect
to
find
your
binaries
in
a
certain
place
and
they're
not
gonna,
be
there
with
kubernetes.
These
make
commands
are
sending
outputs
to
the
output
directory
local
in
Linux,
AMD
64,
because
that's
the
platform
I'm
on
I
was
building
cube
cuddle
and
if
I
do
a
a
long
listing
of
that,
we
should
see
right
now.
I
proved
I
can
build
stuff
yay,
not
particularly
impressive
right,
but
that's
basically
what
it
looks
like.
A
So,
if
I
wanted
to
run
a
test,
a
unit
tests
or
something
again
related
to
cube,
cuddle
and
there's
a
there's.
A
couple
of
talks,
I
think
during
the
the
the
conference
that
are
sort
of
orientations
to
the
code
base.
The
code
base
is
a
big
rambling
code
base,
but
there's
for
something
like
cube
cuddle,
there's
two
directories
that
you
might
look
at:
there's
the
command
cube,
cuddle
directory
and
the
package
cue
cuddle
directory,
and
if
I
look
at
those
the
command
directory,
it
doesn't
have
any
unit
tests.
A
This
is
stuff
related,
just
simple
front
and
package.
Cube.
Cuddle,
though,
has
all
of
the
actual
stuff,
and
you
see
the
normal
go
test
files.
So
if
I
go
in
there
and
go
into
a
cube
cube
cuddle
package,
I
can
go
test,
dot,
dot,
dot
like
a
normal,
go
thing
and
again
this
is
this:
go.
It
runs
pretty
quickly
and
there
it
is
unit
tests.
So
you
have,
if
you're
used
to
go
and
doing
that
rapid
iterative
development.
You
have
that
same
ability
for
unit
tests,
oh
and
I
had
meant
I'm
sorry
did.
A
Did
you
all
catch
the
short
link
that
was
on
the
so
screen
this
one
I'd
encourage
you
to
go
to
this
right
now?
Actually,
so,
hopefully,
that's
really
easy.
Bitly
Cates
NCW
new
contributor
workshop
testing-
and
this
is
a
page
that
we
got
added
into
the
contributor
guide.
I
think
we
did
this
about
a
year
ago,
just
to
give
an
overview
of
these
testing
things
and
from
that.
So
this
is
the
page
that
you'll
land
on
after
it
resolves
the
short
link.
A
You've
got
a
little
bit
more
text
about
each
of
the
types
of
test
unit,
integration
into
end
and
conformance,
and
then
there's
also
a
number
of
links
within
here.
This
testing
guide
link
is
the
first
one.
I'd
encourage
you
to
look
at
the
go.
Tests
are
easy
right.
You
just
see
the
internet
directory.
That's
got
some
underscore
tests
and
run
go
tests,
but
the
other
ones
get
more
complicated
like
how
do
I
have
to
install
EDD
or
some
other
component,
and
how
do
I
do
all
of
that.
A
So
the
the
first
link
there
jumps
off
to
this
testing
guide
that
goes
into
a
bunch,
more
detail
on
how
to
run
more
detailed
unit
tests
and
also
how
to
start
running
the
integration
tests.
So,
for
example,
I'd
mentioned
Etsy
D.
If
you
wanted
to
install
EDD,
we
actually
have
a
subdirectory
called
hack
and
under
that
there's
all
these
little
scripts
that
are
helpful,
so
hack,
install,
Etsy
DSH
will
install
a
minimal
at
CD,
that's
sufficient
for
testing
and
his
version
matched
against
the
code
that
you
have
checked
out
all
of
that
sort
of
stuff.
A
I'm,
actually
so
I've
already
run
this
just
to
run
to
be
a
little
faster,
if
feel
free,
to
try
and
run
this
and
install
it.
It
goes
fairly
quickly,
aside
from
the
the
download
portion
and
basically,
what
what
it
wants
to
be
able
to
see
is,
if
you
do
a
if
you
do
a
witch
at
CD
that
you
have
something
so
I
happen
to
installed
one
in
my
personal
bin
directory.
So
there's
there's
an
sed
in
the
path
that's
available
to
the
test,
then
the
most
simplest
broadest
thing
would
be
to
make
integration
tests.
A
Oh
and
you
have
to
be
in
the
top
level
directory
or
the
make
file
is
so
you
do
that
it's
going
to
do
a
little
bit
of
validation
of
prerequisites.
If
you
don't
have
at
CD,
it
will
come
up
and
say:
hey,
you,
don't
have
a
CD
for
me
it
if
I
scroll
up
here
you
can
see.
One
of
the
first
thing
it
looked
for
was
is
at
CD
in
your
path
and
it
found
it.
It
started
up
at
CD
and
it's
headed
off
into
running
some
tests.
A
I
think
when
I
last
around
this,
it
took
like
a
half
hour
to
run
a
bunch
of
these
tests
and
there
are
a
variety
of
failures
and
things
because
I
hadn't
really
set
up
all
of
it,
but
you
can
at
least
get
started
from
from
that
link
there.
You
can
jump
down
into
the
this
documentation
and
it's
got
a
bunch
of
sets
of
commands
there.
These
are
all
set
up
for
you
to
copy
and
paste
and
actually
try
and
run
some
of
them
will
take
a
while.
A
You
may
have
some
some
system
dependencies
that
you
have
to
install
so
then
the
next
one
is
it
into
n
tests
and
again
this
document
from
the
table
of
contents.
You
can
jump
to
end
to
end
you'll,
see
that
we've,
those
have
gotten
so
complicated.
We've
moved
on
off
to
a
separate
document,
so
we
go
over
to
that
one,
and
this
is
in
our
developer
guide
and
again.
A
This
document
has
a
ton
of
information
and
a
ton
of
ready
to
copy
and
paste
code
for
doing
all
types
of
testing,
but
the
one
that
I
really
want
to
highlight
here
is
where
it
says
local
clusters,
as
you
start
out,
I
wonder
if
maybe
we
should
reorganize
this
file,
but,
as
you
start
out,
this
is
the
place
where
you
want
to
start
buried
down
in
the
hierarchy
of
the
table
of
contents.
So
if
you
jump
down
to
that
link,
it
says
hey.
A
A
So
it
needs
to
run
as
route,
because
some
of
the
stuff
and
running
a
control
plane
is
privileged,
but
you
run
the
simple
command
and
it's
going
to
try
to
set
up
a
cluster
for
me
for
test
purposes.
Now,
I'm
running
a
Mac
with
Mac
OS
I've
got
my
Linux
VM.
This
is
going
to
do
some
extra
stuff,
creating
some
containers
and
spinning
up
some
different
things.
So
it's
very
easy
to
start
running
low
on
resources
again
here,
and
this
is
where
you'll
start
realizing.
What
the
bounds
of
that
are.
A
A
So
this
command
local
cluster
up
feel
free
to
try
it.
It
runs
relatively
quickly,
but
it's
gonna
go
and
run
the
things
that
it
needs
or
build
the
things
that
it
needs
to
set
up
the
cluster
because
we're
talking
about
dev
tests
right,
you
don't
want
to
just
download
arbitrary
binaries
from
the
web
or
have
pre-built
ones.
It
needs
to
make
sure
that
it's
running
a
cluster
right
now
from
the
code
that
I
have
checked
out
and
I've
checked
out,
v1
dot,
13.0
right
now.
So
it's
it's
building
me
this
week's
kubernetes.
A
So
it's
gonna
take
some
time.
I
think
it.
It
takes
a
few
minutes
on
my
laptop
for
it
to
come
up,
but
I
tried
to
run
this
all
to
have
it
pre,
cached
and
warm
and
ready,
and
it's
still
you
can
see
that
it's
as
slow
once
it
gets
things
built,
there's
a
few
things
that
it
does
need
to
download
in
terms
of
common
izing,
the
the
build
requirements
and
like
I'd
mentioned
some
of
the
things
are
in
a
container.
So
it's
downloading
CF
SSL,
which
is
a
tool
for
managing
SSL
Certificates.
A
It's
going
to
actually
build
me
a
real
cluster.
It's
going
to
generate
SSL
certificates
because
we
don't
nobody
checks,
certificates
in
the
github
anymore
right,
like
that's
bad,
so
it's
gonna
actually
generate
new
certificates.
For
me,
make
a
like
a
real
cluster.
That's
secure!
The
control
plane
is
talking
over
SSL.
It's
got
a
download
the
tools
for
that
and
we're
cratering
the
internet,
probably-
and
here
all
downloading
things
so
is
once
it
gets
up
and
running.
The
next
thing
that
you
need
is
a
tool
called
cube
test
and
what
cube
test
is
gonna.
A
Do
is
manage
all
of
the
test
cases
versus
this
machine
that
you've
configured
here
and
it
needs
a
cube,
config
actually
I've.
The
slides
for
this
will
be
shared
afterwards
and
I've
tried
to
populate
them
with
a
bunch
of
helpful
links,
so
I've
gone
through
unit
testing
of
just
the
basics
and
we
did
sort
of
the
the
simple
integration
showing
make
test
integration
for
the
end
of
in
tests.
A
If
you
run
the
local
up
cluster,
you
set
your
config
based
on
what
that
did,
then
you
can
use
cube
tests
to
run
a
specific
command
and
in
the
slides,
I've
got
speaker
notes
for
you
that
have
links
to
all
of
these
docs
that
describe
each
of
them
in
detail.
So
you
can
try
to
follow
along
more
on
your
own.
A
So
uh-huh
it's
running
so,
if
I
scroll
up
here,
there
are
some
more
things
that
scrolled
by,
but
eventually
it
comes
up
and
says:
hey
your
local
kubernetes
cluster
is
running
press
control-c
to
shut
it
down.
It
gives
you
some
hints
on
where
the
logs
are
for
the
things
that
are
running,
and
it
tells
you
where
your
cube
configures
so
I'm,
just
gonna
copy.
A
Mean
it's
runnable,
I
could
I
could
say,
cube
cuddle,
get
nodes
and
there's
my
one
node
cluster.
That
was
spun
up
for
me
and
that's
running
the
cube
cuddle
that
I
just
built.
You
know
that
because
I
gave
it
an
explicit
path
right,
but
we
could
actually
force
and
prove-
and
this
is
this
is
a
pattern
that
I
like
to
encourage
people
to
do
as
they
start
out,
if
I'm
not
sure
about
my
build
test
environment.
Well,
let's
just
figure
out.
If
we're
really
doing
it,
I'm
gonna
come
in
here
and
say
thumb
prints.
B
A
B
A
So
that'll
take
just
a
few
moments
to
build
it'll
be
in
my
output
directory
and
if
I
run
this
command
again,
instead
of
just
seeing
my
one
node
cluster
I
should
see
my
little
hello
world
right
and
then
we
get
a
quick
little
validation
that
I
successfully
built
something
I've
successfully
start
up
a
cluster
I've
successfully
made
them
talk
to
each
other.
I
may
take
a
second.
Well,
that's
going!
Let's
go
back
over
to
talking
about
the
the
tests
so.
A
Okay,
so
I
made
it
I
run
that
same
command.
Again,
hello,
it
worked
I'm
a
developer.
I
can
do
something
so
I
encourage
you.
So
you
start
out
start
simple
like
this,
because
even
this,
even
though
I've
done
it
here
in
like
five
minutes,
your
first
time,
it
might
take
you
an
hour
to,
is
you
figure
out
certain
build
dependencies
or
things
in
your
environment
that
aren't
there?
If,
if
you're
on
a
brand-new
Linux
machine,
it
doesn't
have
any
tool,
Cheney
related
stuff,
all
of
that
stuff
is
gonna,
need
downloaded
and
installed.
A
As
your
guidance
of
saying,
okay,
this
this
test
was
failing,
I,
think
I've
written
some
code
or
I
want
to
try
and
reproduce
it.
I'm
gonna
run
that
as
my
command
line,
but
right
here,
I've
just
got
the
copy-pasted
the
one
from
the
the
documentation
and
it's
running
a
set
of
tests
on.
Oh,
not
can't
copy/paste.
A
It's
running
a
set
of
secrets,
related
tests,
so
I'm
running
cube
tests,
I'm,
saying
provider
local.
You
could
also
do
this
with
a
cloud
provider
I'm
telling
it
because
I
have
a
single
node
pop,
a
single
node
cluster.
Don't
try
to
start
up
a
crazy
amount
of
pods
and
then
focus
the
ginko
testing
on
this
secrets
bucket
of
tests.
So
if
I
run
that.
A
A
A
A
This
is
yeah
Mille
or
JSON.
Practically
it's
not
the
most
readable
I
feel
like
most
of
the
error.
Messages
are
actually
fairly
human,
readable
so
like
on
an
integration
test.
If
you
don't
have
at
CD,
it
will
say
you
don't
have
a
TD
and
it
will
actually
give
you
a
copy-paste
able
command
where
you
can
just
run
this,
and
you
will
now
have
an
sed
I'm
still
not
happy.
A
Well,
rather
than
trying
to
debug
it
since
we're
running
short
on
time,
I'm
going
to
continue
on
to
the
to
talk
about
briefly
the
conformance
test
and
this
one
I'm
wondering
if
I
actually
forgot
to
copy/paste
something
so
there's
a
couple
other
things
in
the
conformance
test
that
you
need
to
get
set
up
and
again
from
this
test
documentation.
If
you
go
in
there's
conformance
test
documentation,
there's
kind
of
the
high-level
overview
of
what's
what
and
then
you
get
into
a
set
of
copy-paste
welcome,
and
so
the
go
get
that
I
just
done.
A
This
make
command
to
set
up
some
basic
prerequisites
for
it
itself.
Again,
you
specify
where
your
Kube
config
is
one
slight
difference
here
is
because
these
are
all
just
into
end
tests.
You
need
to
specify
the
conformance
test
variable
in
your
environment,
say
yes,
and
that
informs
cube
tests
that
you're
actually
doing
the
conformance
related
subset
of
things.
A
A
So
I
don't
know
what
the
variable
specifically
does,
but
conformance
is
validating
that
your
output
matches
the
expected
for
the
tests
and
there's
there's
a
whole
repository,
there's
actually
a
whole
working
group
now
under
sig
testing,
that's
working
on
broadening
and
expanding
conformance
what
it
means.
One
of
the
big
questions
in
the
community
is
what
is
conformance?
What
should
it
mean?
So
some
of
that's
an
open
question.
Obviously
some
things
like
API
is
run
in
a
predictable
way,
give
the
same
types
of
outputs.
A
All
of
those
types
of
things
are
clearly
within,
but
even
at
that
we
don't
quite
know
in
detail
what
our
test
coverage
is
for
the
API
set.
So
there's
some
work
to
measure
that,
and
some
of
the
some
of
the
numbers
have
been
relatively
meager.
So
there's
is
a
new
contributor,
something
you
may
find
as
you're
running
into
a
problem,
and
it
backs
up
to
a
difference
between
your
cluster
and
some
other
cluster.
Think
about
writing
a
into
n
test
that
better
describes
that
situation
and
talk
talk
to
the
community
about.
A
Maybe
that
should
be
something
added
to
the
conformance
suite,
because
these
are
these.
Are
things
we
need
to
improve
on
so
I
already
got
my
cube,
config
exported
going
to
just
copy
paste
that
and
yeah
I
guess
in
the
the
whole
suite
I
think
the
last
time
I
ran
this.
It
took
many
hours,
maybe,
but
it's
that
copy
paste,
that
correctly,
okay.
So
it's
often
running
testing
things,
not
particularly
human
readable,
but
there
you
go
copy
pasting.
A
A
A
Environment,
mini
cube
will
be
a
standalone
VM
and
it
can
use
multiple
different
types
of
back
ends
as
well
for
the
virtualizer,
and
it
can
be
a
potential
way
to
have
a
simple
cluster
that
you
run
and
then,
if
you're
really
adventurous,
one
other
option
to
get
a
simple
cluster
running
if
you're,
if
you're
doing
just
client-side
stuff,
and
you
need
a
server
against
which
to
talk
to
and
you're
on,
Mac
or
Windows.
The
new,
newer
docker,
one
of
the
things
that
you
can
do
is
go
into
preferences
and
there's
a
kubernetes
tab.
A
If
you're
on
the
edge
repo-
and
you
can
say,
run
a
kubernetes
cluster
for
me
whenever
docker
is
running
on
the
system,
and
that
could
be
a
handy,
simple
cluster
endpoint
to
have
again.
This
is
running
in
a
VM
on
your
machine
ceiling.
Resources
from
things
needs
resources
dedicated,
but
it
may
be
an
option
for
just
it's
worth
mentioning
for
local
testability
and
with
that
I'm
gonna
hand
it
back
to
Gwen.