►
From YouTube: Community Stream #2 - The Junk Drawer Episode
Description
Broadcasted live on Twitch -- Watch live at https://www.twitch.tv/nrelabs
B
B
One
of
the
things
that's
interesting
about
syringe
is
that
not
only
are
we
not
only
are
we
interacting
with
kubernetes
directly
from
syringe
we're,
also
we're
also
using
custom
resource
definitions,
which
is
basically
like
an
API
add-on?
If
you
can
think
of
it
that
way
where,
basically,
you
define
a
new
type
of
object
that
you
want
to
be
able
to
create
instances
of
in
the
kubernetes
api,
and
then
you
have
to
create
instances
of
that.
So
it's
like
it's
like
extents,
it's
like
an
extensibility
kind
of
thing,
and
and
that's
how
multiply
the
way?
B
The
problem
with
that
is
in
order
to
also
do
the
C
Rd
generation.
We
have
to
auto-generate
the
go
to
make
that
happen
and
there's
a
lot
of
complexity
there.
It's
certainly
possible.
There's
tooling,
that
they've
provided
the
kubernetes
community
is
provided
to
make
that
all
possible,
but
it's
just
it's
very
complicated
and
that's
just
to
get
it
working
in
general.
Add
on
to
the
add
on
to
that.
B
The
idea
of
testing
are
the
scheduler
portion
of
syringe,
which
is
what
actually
interacts
with
kubernetes,
and
you
you,
you
you,
you
have
a
kind
of
a
mess,
and
so
it
took
me
a
while
to
wrap
my
head
around
how
to
refactor
this
the
scheduler
to
a
be
much
more
testable,
which
I
had
to
I
had
to
get
back
into
of
writing
testable
code
in
NGO
in
general.
I,
unfortunately,
have
the
word.
B
You
say
the
schedule:
do
you
mean
syringe,
yeah,
yeah,
sorry
so
so
syringe
is
actually
to
subcomponents.
It's
all
one
binary,
but
in
if
you
look
at
the
code,
it's
separated
out
into
two
two
sort
of
sub
components:
there's
the
scheduler,
which
is
really
just
a
bunch
of
logic
about
you,
know
what
to
create
with
the
inside
of
kubernetes
and
when
and
then
there's
the
API
layer.
B
What
is
responsible
for
interacting
directly
with
kubernetes,
and
so
that's
where
all
the
CRT
stuff
happens
and
again
it
can't
happen
with
yeah
mul,
which
is
what
you
would
normally
do
if
you're
like
an
operator,
and
you
wanted
to
use
kubernetes
and
define
your
own
CRT,
it's
actually
pretty
easy.
There's
a
there's
a
you!
Just
do
a
coop
cuddle
create
there's
a
type
of
manifest
that
you
can
create,
which
I
was
doing
by
the
way.
B
Long
time
ago,
when
we
were
testing
out
Malta's,
that's
how
I
tested
it
was
to
just
define
the
EML
files
that
I
knew
multi
in
the
documentation.
That
way,
then
I
had
the
the
difficult
task
of
converting
all
of
that
into
effectively
Native
go,
and
now
it
all
has
to
be
Auto.
You
know
automatically
generated.
So
if
we
want
to
add
a
field,
we
don't
have
to
go.
You
know
screw
around
with
the
generated
code.
We
can
just
change
the
the
model
that's
created
and
it
automatically
generates
from
there.
B
B
You
know
every
once
in
a
while,
there
would
be
an
issue
that
that
was
that
would
have
been
caught
if
I
had
proper
tests,
so
the
more
the
more
other
to
do
is
I
was
able
to
knock
off
the
more
I
was
able
to
focus
on
this
and
so
I'm.
Finally,
writing
tests
for
the
scheduler
just
because
I
had
some
time
to
dedicate
to
it
nice.
So
that's
what
I've
been
doing
lately.
Sorry,
that's
a
very
long
form
response
to
your
question.
No,
it's
fine!
It's
totally!
Fine!
That's
that's!
A
very
that's!
B
A
B
A
B
A
A
B
B
B
A
So
for
those
of
you
joining
us,
I'm
Derrick
winkworth
I'm
cloud
toad
on
Twitter-
and
this
is
Matt
Oswalt
he's
mirrored
and
on
Twitter
I
am
a
I.
Am
the
community
manager
for
energy
labs?
This
is
Energy
labs
TV.
You
don't
see
the
logo
yet
because
I
haven't
done
that
yet,
but
I
will
put
a
logo
on
here.
A
Oh,
my
goodness,
yeah
it's
it's
I
hate!
These
lights
are
super
they're
like
he
incredibly
bright,
but
they
don't
fill
the
room
up
with
light
somehow
so
we're
it.
So
today
we're
last
week
we
had
a
pretty
good
session.
It
was
recorded
if
you
missed
it.
We
talked
about
some
pretty
significant
and
positive
changes
to
self-medicate,
which
is
the
platform
you
use
to
develop
lessons
for
energy
labs.
If
you
haven't
seen
that
stream,
yet
it's
out
on
YouTube,
it's
recorded,
you
know,
go
check
it
out.
A
If
you
haven't
played
with
self
medicate,
yet
you
know
any,
and
you
have
a
machine
with
eight
gigs
of
RAM.
You
should
definitely
check
it
out.
It's
it's
a
it's!
It's
the
best
way
to
write
lessons
for
energy
labs
and
also
you
can
consume
lessons
with
NRE
labs.
If
you
want
to
consume
that
offline.
For
some
reason,
you
can
use
a
self-medicate
to
do
that
this
week.
I
think
what
we're
gonna
covers
is
some
open
issues
we
have
in
our
github
repository
and
plus
some
just
general
discussion
around
where
we're
gonna
go
with
NRE
labs.
B
A
Want
to
know
how
many
people
it'll
it'll,
build
just
give
it
time
about
time.
Yes,
okay,
so
I
can't
actually
do
anything
on
this
on
this
since
I'm
hosting
this,
this
video
conference
I
can't
do
anything
because,
if
I
switch
windows,
it'll
freeze,
oh
right,
so
if
you
can
share
the
issues
page
for
any
labs
and
then
we
can.
A
B
Can
you
see
anything
right
now
looks
like
discord
froze
on
me?
I
can.
A
B
A
B
Yeah
I
think
discord
did
crash
okay
much
better.
Can
you
see
my
screen
again?
I
do
I
see
it
alright,
yeah
I
it
it
crashed
and
and
must
have
reloaded
so
okay
anyway,
as
I
was
saying
what
we
normally
do
is
when
we're
working
on
a
release
we
have
like.
We
have
you.
We
usually
have
two
projects
up,
especially
the
closer.
We
get
to
a
release
so
like
as
we're
working
down
this
this
project
plan.
B
If
we
feel
like
punting
a
certain
issue
to
the
next
release,
will
we'll
have
a
second
we'll
have
a
second
project
spun
up
in
this
case,
it'll
be
0.32.
That
way,
we
just
sort
of
it's
a
way
of
us
punting
an
issue,
but
but
the
current
release
is
Oh.
Death
read,
oh,
and
so
that
means
the
the
release.
Planning
we're
going
through
right
now
is
not
one.
Now
we
one
thing
I
should
say
is
the
current
plan.
B
This
is
that
we
we
did
Oda
304,
NFD
and
there's
been
a
bunch
of
different
events
since
then,
so
the
current
project
plan
is
not
exactly
finalized.
Mostly
these,
mostly
the
issues
that
are
here
are
just
there,
because
a
a
because
I
felt
like
they,
they
should
be
an
Oda
3.1
or,
if
or
a
lot
of
them,
I've
hunted
from
Oda
three
Oh.
B
B
Not
not
all
of
this
is
is
accurate,
so
some
of
these
issues
will
probably
get
punted
and
also
there'll,
be
there's
actually
quite
a
few
issues
that
I've
created
recently
that
I
do
want
in
Oda
3.1,
so
they're,
not
even
in
here
yet,
but
the
URL
should
be
the
same,
slash
five,
so
you
can
go
back
here
and
see
the
state
of
things
all
right.
So
what
you
want
to
talk
about
first?
Well,
the
one
thing
is
I
I
want
to
talk
about
this
particular
thing.
B
I
have
had
this
on
my
mind,
I
open
this
just
a
little
bit
ago,
because
I
wanted
to
make
sure
I
remembered
it,
but
going
on
the
the
theme
of
I
guess
last
week
where
we
talked
about
self
medicate
being
the
development
environment
you
still.
If,
even
even
though
you
have
like
a
you
know
a
little
kubernetes
cluster,
you
could
spin
up
locally
and
it's
fully
automated
through
the
self
medicate
script.
That's
all
cool,
but
it's
still
not
super
intuitive.
How
to
build
a
lesson.
B
What
would
be
cooler
is
if
there
was
some
sort
of
a
wizard
that
allowed
you
to
basically
say:
hey
I'd
like
to
start
a
new
lesson
and
it
walks
you
through
step
by
step
every
you
know
a
bunch
of
interactive
questions
that
say,
like
you
know,
what
kind
of
what
kind
of
lesson
is?
This
is
a
fundamentals.
Lesson.
Is
this
a
you
know,
tools
lesson:
is
it
a
workflows
less
and
that
kind
of
thing?
What
would
you
like
to
call
it?
How
many?
How
many
labs
will
they
will?
Will
there
be
in
this
lesson?
B
B
Think
now
that
now
that
NRI
Labs
has
been
out
for
a
while,
it's
important
that
we
start
turning
our
attention
to
make
things
a
lot
easier
for
the
for
the
teacher,
because
there's
a
lot
of
really
great
content
out
there
and
we
just
want
to
make
sure
the
barrier
to
entry
for
contributing
content
is
as
low
as
possible,
just
like
just
like
the
spirit
of
venturi
labs
in
general,
making
sure
that
there
are
no
barriers
for
the
learner.
So.
A
B
B
That's
fair
I
mean
one
of
the
one
other
things
I
mean
I
mentally
in
my
head.
Raishin
from
there
was
a
lot
of
work
kind
of
like
this
done
back
in
my
days
when
I
worked
at
Stax
storms,
because
there
pretty
much
anything
you
defined
in
stack,
Storm
is
done
via
a
Hamel
file
which,
again,
if
you
don't
know
anything
about
stack
storm,
it's
not
intuitive.
You
kind
of
have
to
find
an
example
out
there
that
already
defines
something,
that's
kind
of
close
to
what
you
want,
and
then
you
sort
of
have
to
reverse-engineer
it.
B
There
are
a
few
commands
in
stack
storm
where
you
can
just
say,
like
hey:
I
want
to
create
a
new
X,
and
what
this,
what
the
stack
storm
utility
will
do
is
it'll
go
through
all
of
the
various
fields
that
it
knows
that
it
will
need
and
it'll
ask
you
intuitive
questions
about
each
one
where
it'll
say
something
like
okay.
Here's
that
here's
the
description
field
but
beyond.
Just
like
saying,
please
enter
the
value
for
this
field.
It'll
do
something
like
you.
B
Here
that
here's,
what
makes
a
good
description
that
kind
of
thing
so
I
think
the
first
step
would
be
to
yes,
I
think
the
first
step
would
be
to
look
at
all
of
the
all
of
the
various
fields
in
the
in
the
in
the
the
protobuf
definition
for
a
lesson,
definition
in
syringe
and
then
from
those
fields
create
an
interactive
wizard
that
makes
sure
that
all
of
those
fields
have
an
opportunity
to
get
populated.
Now
how
that's
present
it
to
the
user.
You
know
what
kind
of
like
plain
English
things
like
that
stuff.
B
A
B
B
Chrome
would
basically
just
keep
opening
tabs
until
all
of
the
icons
disappear,
which
is
normally
what
I
would
get
to
so
I'm
being
extremely
conservative
right
right
now,
but
yeah
there
are
a
few
other
things
like
one
thing,
one
thing
that
I
were
was
working
on
a
little
bit
last
week
and
then
definitely
the
week
before
was
all
of
the
self-medicate
Doc's.
So
I
still
have
this
issue
open
where
I
say
the
docs
are
outdated.
I
think
the
structure
for
the
for
the
docs
are
good.
I.
Think
that's
fine
right
now.
B
B
Less'n
networking
is
also
behind,
like
the
explanation
of
how
networking
works
is
is,
is
again
functional,
but
it's
not
really
relevant
to
what
we're
doing
like
we're
running
busybox
here.
Basically,
I
just
put
a
bunch
of
EML
files
up
here.
So
it's
it's
verbose,
but
it's
not
it's
not
exactly
clear.
I
can
put
some
more
love
into
that.
B
So
there's
some
things
that
I
want
to
do
for
from
a
documentation
perspective
to
improve
that.
Certainly
more
syringe,
Doc's,
like
the
syringe
DM
will
file.
These
are
also
extremely
old,
like
SSH
user
neces
H
password
those
are
those
fields
are
not
there
anymore.
They
don't
exist.
So
that's
that's
old
subnet!
This
field
will
go
away
because
that
field
is
actually
ignored
at
the
moment.
So
that's
not
relevant.
So
there's
a
bunch
of
stuff
in
here.
That's
that's
sort
of
extra
same
with
configs.
B
All
of
that
stuff
is
deterministic
based
on
the
directory
guide
or
the
directory
name.
So
yeah
there's
just
the
I
think
the
docs
needs
some
love
at
this
point.
They're
there
they're
showing
their
age
a
lot.
A
lot
of
these
Doc's
were
originally
created
well
before
the
release,
and
they
haven't
really
been
touched
since
seems.
B
That
that
particular
portion
of
the
docs
is
much
more
up-to-date
just
because
I
edited
that,
alongside
the
changes
to
self-medicate,
so
this
page
is,
you
know
pretty
up-to-date,
not
saying
it's
perfectly
like
you
know
totally
accurate.
There
might
be
some
typos
or
whatnot,
but
this
is
definitely
up-to-date,
because
I
dated
this
as
I
was
developing
the
changes
to
the
actual
self
medicate
script.
So
this
this
is
definitely
up-to-date.
Yes,
but
everything
else
like
I
said
everything
else
is
some
of
it.
Some
of
it's.
It's
all.
B
B
They
call
it
gke,
and
so
basically,
what
that
means
is
you
don't
manage
the
VMS.
You
just
manage
what
you
put
into
kubernetes,
so
you're,
provided
with
the
the
you
know,
the
API
server,
the
or
the
AP
you're
provided
with
a
coupon
IDs
API,
and
they
they
just
manage
all
of
it.
For
you
right
AWS,
you
have
their
ich
es
rain,
eks,
yep
yep,
it's
a
pretty
common
model,
I
mean
I,
think
I,
think
you
you
get
access
to
the
VMS
that
they
spin
up.
B
You
have
some
flexibility
there,
but
you
don't
have
any
access
to
the
API
server
or
any
of
the
the
infrastructure
for
running
it,
which
is
fine,
I,
don't
I,
don't
think
we
really
need
that.
The
the
reason
we
didn't
go
in
that
direction
is
pretty
simple.
Actually
is
because
Malta's
is
a
CNI
plugin
and,
to
my
knowledge,
no
existing
hosted
kubernetes
offering
allows
you
to
use
your
own
C&I
plugin.
It's
viewed
as
a
it's
viewed
as
a
fairly
infrastructure.
B
You
know
said
critical
infrastructure
kind
of
thing
you
you
will
use
the
networking
that
they
tell
you
to
use
again.
Normally,
this
is
okay,
because,
most
of
the
time,
the
requirements
from
a
networking
perspective
aren't
actually
that
big
of
a
deal
you
certainly
most
people
that
use
those
hosted
offerings,
certainly
don't
need
multiple
network
interfaces
per
pod
like
we
do
mostly
they're
hosting
just
you
know,
applications
and
they
just
need
an
a
network
interface
and
they
need
them
to
talk
to
each
other
which
anything
in
the
hosted
offerings
is
gonna,
provide
yeah.
B
I
did
see
that
yeah
they
have
a
partnership
there,
but
yeah
calico.
It
supports
just
that
one
CNI
plugin,
instead
of
allowing
you
to
put
in
your
own
right,
I.
Think
if
you,
if
you
I,
mean
you
you
probably
could
like
I
was
looking
at
gke
originally
and
I.
Think
you
know
you
have
access
to
the
to
the
compute
nodes.
You
could
put
your
own
in
figurations
into
place,
but
I.
You
know
at
that
point
you're
pretty
much
hosed
if
you
have
to
open
the
support
case
so
anyway,.
B
B
Now,
if
you're
familiar
with
that,
if
you're
familiar
with
service
messages
in
general
or
if
you're,
not
I,
I,
guess
if
you're
not
familiar
with
them
effectively,
what
a
service
mesh
allows
you
to
do
is
deploy
it
effectively
allows
you
to
manage
the
application,
the
the
application
flows
around
your
you
know
your
topology
or
your
around
your
you
know
your
cluster
and
allow
your
application
endpoints
to
talk
to
each
other
without
requiring
more
low-level.
Networking
like
like
at
the
CNI
layer,
it's
certainly
at
the
physical
layer.
So
it's
like
overlays
upon
overlays,
okay,.
A
B
Normally,
the
reason
this
is
useful
it
it
allows
you
to
get
telemetry
and
fine-grained
control
a
lot
closer
to
the
application.
So
normally,
what
we
would
have
is
some
sort
of
a
centralized
load.
Balancer
like
Ingenix
running
in
kubernetes
or
even
further
out.
You
might
have
a
virtual
or
a
hardware
load,
balancer,
that's
sitting
outside
the
cluster
entirely
and
then
there's
some
sort
of
API
integration
that
the
direct
application
calls
appropriately.
B
B
You
know
known,
secure,
topology,
kind
of
thing
right,
and
so,
instead
of
making
sure
that
you
know
all
of
your
applications
speak
HTTP
and
they
all
use
the
correct
version
of
TLS
and
all
these
things
you
just
deploy
a
sidecar
proxy
alongside
all
of
your
applications,
and
then
you
focus
on
the
configuration
of
that
proxy.
In
that
way,
you
know
everything
looks
like
it's
coming
from
the
same
sort
of
kind
of
application
server,
even
though
the
underlying
application
is
totally
different.
So
that's
kind
of
cool
they're
not
either
use
cases.
B
There
are
limited,
I
think
to
some
people
with
some
pretty
complicated
setups.
If
you're
really
just
looking
to
deploy
a
simple
app
you,
you
might
not
get
a
ton
of
inform
a
value
there
there's
some
other
use
case.
There's
some
other
there's
some
other
reasons
why
you
might
want
to
do
that,
specifically
around
visibility.
So
you
have
visibility
into
what
kind
of
network
traffic
is
being
sent
without
having
to
talk
to
the
networking
team,
which
you
and
I
have
a
very
different
perspective
on
I.
Think
I.
B
Think
if
anything,
the
network
at
the
networking
folks,
you
know
the
traditional
network
engineers
might
actually
be
fairly
well
served.
Learning
about
service
meshes
so
that
they
can
still
be
able
to
do
some
translation
between
what
the
I
already
know,
which
is
the
physical
network
and
the
virtual
network,
with
the
constructs
of
a
service
mesh
I'm,
not
in
favor
of
using
a
service
mesh
to
sort
of
bypass.
The
networking
team,
although
it
is
a
cool
tool
in
and
of
itself,
if,
if
it's,
if
it's
you
know,
used
appropriately
by
the
appropriate
people
anyway,.
A
B
What
service
mesh
is,
in
general,
there's
a
particular
project
called
network
service
mesh,
which
applies
the
same
kind
of
principles,
but
it
takes
it
moves
down
the
OSI
layer
instead
of
just
permitting
layer.
You
know
certain
application
layer,
types
of
traffic
like
HTTP.
It
actually
provides
l2
and
l3
connectivity
between
between
entities
that
you
that
you
deploy
very
similar
to
how
what
we
do
in
Malta
swear.
B
We
declare
effectively
virtual
networks
to
plug
people
into
darts,
plug
pods
into
you
can
create
layer,
2
layer,
3,
VPN
s
between
pods,
dynamically
and
it'll
take
care
of
connecting
them
on
your
behalf.
So
it's
effectively
a
service
mesh,
but
it
it
it
allows
it
you
the
the
way
that
it
connects
between
pods
is
not.
You
know,
basic
proxy
HTTP
routing.
It's
actually
done
via
an
l2
VPN,
which
is
kind
of
cool.
A
B
Yeah
I
closed
the
stream
because
it
was
making
me
feel
like
I
had
schizophrenia,
but
I
can
reopen
it.
B
Can
I,
can
you
there
we
go
so
that's
that's
the
the
link
that
I've
had
open,
stupid
ad
ads
within
ads
yay.
So
that's
there
I'm
the
reason
by
the
way,
the
reason
I'm
bringing
this
up
is
because
the
way
that
it
actually
does
the
connectivity
is
not
by
connecting
so
say,
let's
bring
this
into
NRE
labs.
We
have
pods
that
are
running
like
a
VQ
effects
device
again.
B
The
way
that
we
have
networking
work
right
now
is
syringe
specifies
the
various
Malta's
configurations
that
it
needs
to
and
then
attaches
each
pod
to
the
relevant
network
and
by
the
way
those
networks
are
all
this
Linux
bridge
based,
so
it
all
just
basically
gets
locally
bridged,
which
makes
that
pretty
easy
actually.
So
we
just
make
sure
that
all
the
pods
are
on
the
same
host
within
a
lesson
and
then
and
then
they
just
get
connected
to
your
bridge
and
it's
it's
actually
fairly
straightforward.
B
So
this
is
definitely
more
complicated
than
that,
but
the
benefit
to
doing
it
this
way
is
the
connectivity
is
not
actually
done
directly
to
the
pod.
It's
done
via
a
sidecar,
so
so,
just
like
just
like.
We
would
put
a
sidecar
proxy,
like
Envoy,
on
to
one
of
our
applications.
If
we're
doing
like
a
you
know,
sto
some
some
other
type
of
service
mesh.
B
It's
it's
effectively
an
overlay
at
that
point,
so
we
could
use
any
C&I
plug-in
that
was
offered
to
us,
because
again
we
just
needed
to
be
able
to
talk
between
hosts
in
order
to
make
this
overlay
work.
Now
the
the
the
cool
thing
I
think
about
this
particular
architecture.
Is
that
because
we're
not
using
C&I,
we
can
then
start
to
think
about
moving
to
some
other
host
and
offering,
instead
of
building
our
own
kubernetes
cluster.
B
Now
there's
two
things
that
I
want
to
call
out
there
a
if
we
do
and
end
up
going
down
this
path
and,
like
I
said
I
haven't
done
any
testing
yet
so
there
there's
still
a
lot
of
rnd
work.
That
needs
to
be
done
to
make
sure
this
is
viable.
But
let's
assume
that
it's
viable,
we'll
probably
think
about
moving
to
this.
B
For,
for
the
you
know,
the
NRI
labs
the
hosted
content
that
we
have,
but
the
existing
approach
won't
get
ripped
out
effectively
what
we
would
do
on
the
syringe
side,
which
is
what's
really
controlling.
All
of
this
is
provide
a
configuration
option.
Excuse
me
a
configuration
option
that
says:
hey.
You
know,
I'm
deploying
on
top
of
gke,
so
I
need
you
to
use
the
network
service
mesh
effectively
like
a
plugin.
B
We
would
develop
something
like
that
where
you
say
like
I
want
to
use
network
service
mesh
for
my
networking,
the
trade-off
being
it's
a
little
more
complicated
and
you
have
to
deploy
there's
actually
like
a
kind
of
a
controller
that
you
have
to
deploy
within
within
kubernetes
as
opposed
to
malta
switches
which
really
doesn't
need
a
controller.
It
just
needs
the
multis
binary
on
each
host,
so
network
service
mesh
is
definitely
more
complicated,
but
it
allows
you
to
run
in
environments
that
don't
let
you
screw
around
with
that
lower
level
functionality.
B
But
again,
if
we're
running
in
something
like
self-medicate
like
no
no
joke
network
service
mesh
is
total
overkill.
So
we
want
to
continue
to
provide
this
the
existing
functionality.
That's
that's
been
built
and
iterated
on
over.
You
know
the
past
few
months,
so
we
would,
we
would
effectively
be
providing
both
you
would
just
have
to
choose
in
the
syringe
configuration
which
one
you
wanted
so
we'd,
probably
default.
Tumult
is
just
because
we've
done
that
for
a
long
time,
but
then
provide
an
ability
to
say:
hey,
I
want
to
use
a
network
service
mesh.
A
Alright,
so
yeah,
this
is
very
cool
and
if
you're,
if
you're
out
there
and
you're
seeing
this,
you
should
definitely
you
should
definitely
go
to
this
website.
Network
service
meshed
at
I/o,
slash,
Doc's,
slash
concepts
and
they
have
videos
and
instructions
and
so
on,
and
you
can
see
what
that's
all
about.
That's.
B
B
Knowledgeable
guy
I
I
do
want
to
mention
the
point
of
this.
The
reason
the
reason
people
should
care
about
whether
or
not
we
use
this
in
our
production
instance
is
getting
away
from
a
model
of
having
to
run
our
own
kubernetes.
Cluster
is
a
good
thing.
We
we
have.
We
are
current
kubernetes
cluster
is
intentionally
under
under
size
like
we
don't
have
a
you
know,
multiple
nodes
for
the
sed
database
that
sits
behind
the
scenes,
so
we've
we've
just
basically
been
holding
on
on
adding
to
that,
because
we
want
to
be
going
this
direction.
B
We'd
prefer
to
go
in
this
direction
as
opposed
to
putting
a
lot
more
engineering
time
into
effectively
managing
our
own
cluster,
which
is
just
time
that
we
won't
be
able
to
spend
on.
You
know
improving
the
platform,
and
so
you
know
we.
As
a
result,
we've
we've
had
some
outages
like
the
sed
clustered.
B
As
you
know,
the
fact
that
we
don't
have
to
spend
all
of
that
time
in
in
managing
all
of
that
means
just
that
much
more
effort
can
be
committed
to
improving
the
platform
and
making
improvements
to
things
like
self
medicate
and
things
like
the
documentation
and
all
that
kind
of
stuff,
the
more
the
more
we
can
focus
on
just
that
portion
I
think
the
better
everybody
you
know
better.
Everybody
will
be.
B
There's
a
few
things
there's
some
bugs
that
need
to
get
fixed
by
the
way,
the
one
thing
that
people
might
not
notice,
because
the
the
utility
has
only
existed
for
a
little
bit
outside
of
some
really
nice
use
cases.
When
the
syringe
project,
when
you
compile
syringe,
you
actually
get
two
binaries,
you
get
syringe
D,
which
is
the
actual
syringe
component
that
orchestrates
NRA
labs.
You
know
or
really
the
the
you
know.
The
whole
project
you
know
runs
things
again:
it's
creates
resources
within
kubernetes
and
whatnot,
but
there's
actually
a
second
binary.
B
There's,
there's
also
syr
CTL.
Now
that's
existed
for
a
while,
but
again
I
haven't
really.
You
know
publicized
that
a
lot
just
because
most
of
the
things
that
that
that
that
that
binary
did
were
really
some
basic
debug
stuff
for
me.
So
I
could
you
know,
look
to
the
state
of
syringe
and
inspect
its
effect.
It's
effectively
calling
G
RPC
functions,
so
I
could
see
things
like
what
live.
Lessons
are
running.
What
lesson
definitions
exist
within
syringe
that
you
know
again.
The
running
instance
is
effectively
like
an
API
client.
B
It's
a
CLI
see
a
live
component
that
you
can
use
to
query
syringe,
but
again
most
of
the
things,
that's
that
the
sy
our
CTL
did
was
not
super
useful
to
most
people,
just
just
sort
of
me,
but
that's
sort
of
changing
I've.
In
the
past
few
months,
I
added
a
command
called
sy,
our
CTL
validate,
which
is
pretty
cool.
If
you
and
I
could
actually
run
this
now
as
long
as
I
have
it
compiled
I'm,
pretty
sure
I
do
yeah.
B
So,
as
you
can
see,
there's
a
few
things
like
the
whitelist
functionality
as
well
as
inspecting
live
lessons
in
cou
blab.
Those
are
internal,
syringe
things
that
really
nobody
really
probably
cares
about
you.
Could
you
could
see
most
things
that
you
need
from
from
that
perspective
via
the
log,
so
that's
not
as
useful,
but
one
command,
that's
very
useful
as
is
validate.
This
is
definitely
something
that
users
should
be
able
to
use
or
not
users,
but
you
know
contributors.
B
Lesson
contributors
should
definitely
become
more
familiar
with
and
I'm
gonna
go
out
to
sorry
we're
doing
some
image
work
here.
If
we
do
a
sy,
our
CTL
validate
and
then
we
place
I
believe
just
a
positional
argument
here.
Antidote
actually
just
do
that.
What
you
can
see
here
is
that
it's
actually
importing
all
of
the
all
of
the
lessons
that
are
in
the
directory
that
we
specified.
So
if
you
look
I'm
in
the
antidote
directory
right
now,
so
this
is
the
same
repo,
that's
out
there
on
github,
and
you
can
see.
B
We
have
a
lessons
directory
in
here.
So
what'll
happen
is
when
you
pass
the
direct,
the
local
directory,
which
is
dot
the
current
directory,
that
I'm
in
it'll
run
through
the
exact
same
validation
logic
that
it
normally
runs
through
when,
when
you
start
syringe
for
the
first
time,
so
let
me
actually
just
do
like
a
come.
Cuddle,
delete,
pod
and
I'll
delete
the
PTR
instance
of
syringe,
so
we
can
see
a
fresh
start.
B
Logs
PTR
syringe,
so
you
can
see
it's
kind
of
doing
the
same
thing
that
we
saw
before
so
it
says
successfully
imported
lesson:
12,
13,
14,
15,
so
on
and
so
forth.
I'm
just
doing
the
exact
same
thing,
it's
startup,
but
the
benefit
of
using
s.
B
What
our
CTL
is
that
you
don't
actually
have
to
be
running,
syringe,
there's
a
bunch
of
stuff
that
syringe
D,
the
other
end
of
the
actual
server
binary,
there's
a
lot
of
stuff
that
that
needs
to
run,
including
being
able
to
connect
to
kubernetes
the
benefit
of
being
able
to
run
this
validate
command
in
SOA.
Our
CTL
is
you're
using
the
exact
same
logic.
It
actually
uses
the
exact
same
code
within
the
syringe
project,
but
it
doesn't
require
you
to
actually
be
running
syringe
the
the
server.
B
It's
just
that
it's
just
that
that
functionality
is
exposed
via
this
command-line
utility.
Now
the
reason
this
is
super
cool
is
you
can
develop
your
own
lessons
and
then
use
this
command
to
make
sure
that
the
lesson
is
being
imported
into
syringe
successfully,
so
that
when
you're
developing
lessons,
you
have
confidence
that
it's
actually
going
to
work.
B
So
that
actually
exists.
There
are
two
things
that
I
think
two
more
things
that
are
needed
to
make.
This
really
super
valuable,
first
off
what
we
haven't
been
doing
with
when
we
release
new
versions
of
NRE
labs
or
though
or
the
antidote
project.
Rather
one
thing
that
we
are
not
doing
currently
is
public.
Releasing
you
know,
compiling
all
platforms,
compiling
binaries
for
syringe
across
all
platforms
and
putting
them
into
the
github
releases.
The
reason
we
haven't
been
doing,
that
is
because
normally
we
don't
really
use
syringe
as
the
binary.
B
We
just
build
the
docker
image
and
that's
fine,
because
that's
that's
normally
how
syringes
deployed
its
deployed
into
the
kubernetes
cluster
that
we're
running
and
then
and
then
of
course,
that
that
that
image
has
the
binaries
inside
of
it,
and
so
we
don't
really
need
to
compile
all
of
the
platforms
we
just
need
to
compile
for
Linux
in
it
and
then
it's
deployed
within
that
image.
However,
if
you
want
to
be
able
to
run
this
on
your
laptop,
you
know
you
might
be
running
Windows,
you
might
be
running.
B
You
know
Mac
OS
Darwin,
that
kind
of
thing
FreeBSD.
We
do
you
know
some
of
some
other
thing
there,
so
we
need
to
be
able
to
offer
downloads
for
all
of
those
things.
If
this
is
gonna,
be
something
that
somebody
can
go,
you
know
download
on
there
up.
So
we
need
to
do
that.
We
need
to
improve
the
release
process
so
that
that
that
gets
done
as
well
and
then
once
that's
done,
we
actually
I'm
gonna
be
adding
this
command.
B
This
actual
command
s
way
our
CTL
validate
to
the
CI
process
for
the
antidote
repo,
so
that
whenever
somebody
opens
a
pull
request,
the
Travis
CI
connect.
You
know
the
Travis
CI
job
that'll
get
kicked
off,
will
perform
a
validation
on
the
you
know
the
lessons
directory
in
that
repo
and
it'll
tell
us.
If
there's
you
know
an
issue
with
that,
it.
B
You
know
people
contributing
lessons,
but
it
also
helps
reviewers.
They
can
see
that
the
s
way
our
CTL
validate
command
succeeds.
They
don't
need
to
go
through
and
do
all
of
the
you
know
pedantic
like.
Oh,
you
need
to
make
sure
this
files
here
and
this
files
name
differently,
like
you,
don't
have
to
do
any
of
that.
You
can
just
focus
on
on
the
the
truth,
the
true
value
that
reviews
provide,
which
I'm
always
in
favor
of
so
this
is
a
cool
tool.
B
I'd
like
people
to
become
more
familiar
with
it,
but,
like
I,
said,
there's
some
homework
that
we
have
to
do
on
our
side
to
make
sure
that
it
gets
into
people's
hands
easily.
But
once
that's
done,
I
think
ending.
This
will
prove
pretty
valuable
and
by
the
way,
what
we
were
talking
about
earlier,
with
being
able
to
provide
a
wizard
that
a
lot
of
people
to
more
dynamically
create
lessons
without
having
to
really
know
how
to
build
a
lesson
manually.
B
A
Like
if
I'm
I'm,
developing
a
lesson
on
inside
of
inside
of
self-medicate
right
and
I'm,
making
changes
to
a
local
directory
using
the
local
directory
feature
that
that
is
new
too.
As
of
as
of
last
release
for
self
Medicaid,
yeah
and
I
think
I'm
ready
to
to
restart
syringe
rather
than
restart
it,
and
you
know,
sort
of
blindly.
I
can
run
this
command
and
validate
that
at
the
very
least,
the
syntax
and
everything
is
correct
for
how
my
lessons
is
laid
out
in
its
treachery
and
then
I
can
restart
syringe
yeah.
B
Totally
totally,
in
fact,
I
would
say
the
cool
one
of
the
cool
things
about
the
change
to
self-medicate
having
you
know
using
local
directories.
Instead
of
requiring
you
to
commit
and
push
your
changes,
it's
almost
exactly
the
same
amount
of
time,
just
restarting
syringe
inside
of
self-medicate.
B
So,
in
that
case,
yeah,
absolutely
if
you're,
if
you're,
just
developing,
if
you're,
if
you're
just
adding
the
files
in
general
and
you
you
want
to
know
that
something's
there,
just
like
you
said,
that's
why
our
CTL
validate
is
is
way
faster
than
waiting
for
the
lesson
to
get
spun
up
now
there
will
be
a
few
things
that
won't
get
detected
here
like,
for
instance,
if
you
have
the
you
a
bunch
of
network
configurations
in
your
lesson,
the
validate
command
doesn't
go
through
and
like
do
a
Juno's
commit
or
anything
like
that,
it's
not
running
Juno's
at
all.
B
It's
it
doesn't
know
how
to
deal
with
that,
so
it
won't.
It
won't
check
to
make
sure,
like
your
configurations
are
valid
or
or
that
they
do
what
they
need
to
do
sure
it
it.
This
is.
This
is
all
about
what
syringe
knows
about,
which
is
the
basic
layout
of
a
lesson,
the
different,
certainly
the
syringe
file,
so
syringe
ml,
all
the
fields
that
are
there.
B
There
are
some
fields
that
are
required,
and
then
there
are
some
other
fields
that
are
not
required,
but
maybe
if
they
are
provided,
they
need
to
be
a
certain
type
like
that
kind
of
thing,
that
kind
of
stuff
it
will
get
captured
here,
but
just
FYI.
This
isn't
a
panacea.
You
won't
go
to
run
this
and
be
like
okay,
my
lessons
perfect.
B
You
know
it's
not
gonna
catch
typos.
In
your
lesson
guys.
You
know
nothing
like
that,
although
we
could
add
some
tooling
to
help
with
that
too,
but
not
not
via
syringe.
Syringe
is
much
more
about
the
the
way
that
the
lesson
actually
runs
on
the
back
end.
So
naturally,
this
validate
command
is
focused
on
them.
Nice
wow.
B
It's
already
merged
the
functionality.
Is
there
the
the
and
certainly,
if
you
wanted
to
just
run,
if
you
have
docker
installed,
you
can
do
this.
Like
I
said
the
only
the
only
piece
that's
missing
is
for
us
to
pre-compile
binaries
for
all
architectures
so
that
you
could
just
curl
the
binary
of
your
choice
and
lipid
into
your
system
and
install
Duncan
Liffey
command.
If
you
docker,
let's
see
if
you
do
volume,
how
did
I
do
this
before
probably
not
volume,
antidote,
labs,
syringe
and
then
we'll
just
name
it
and.
B
So
if
you
have
docker
installed,
you
can
do
it
this
way
and
by
mount
and
by
mapping
this
volume,
your
you
know,
I'm
in
the
antidote
repo
now
and
I'm,
mounting
that
local
directory
into
the
container
file
system
at
at
roots.
You
know
to
a
root
directory,
slash
antidote
and
then
I'm
running
the
antidote,
lab,
cess,
slash,
syringe
image
and
then
I'm
running
the
binary
sy
our
CTL
validate
and
then
slash
antidote
that
should
work
yeah.
So
that's
that's
what
I've
done
there.
B
B
So
you
can
do
this
today,
but
what
but
then,
but
in
the
next
few,
the
next
week
or
so
I'll
be
putting
some
effort
into
the
the
deployment
pipeline
for
syringe
to
make
sure
the
binary
is
in
addition
to
the
docker
image
which
is
being
published
today,
I'd
like
to
also
make
sure
that
the
binaries
themselves
are
pre,
compiled
and
available
for
download.
If
you
wish
to
go
that
direction,.
B
A
C
A
I
will
mail
you
a
few
we'll
try
I'll
try
to
get
some
of
those
out
to
some
of
the
early
contributors
as
well,
and
maybe
you
know
some
of
the
people
who
actually
sit
through
this
twitch
stream,
we'll
catch
you
guys
some
stickers.
If
you
send
us
a
message,
so
we
got
those
coming
and
I
think
we're
gonna.
Do
we
got
to
catch
up
with
some
planning
around
doing
a
hackathon?
A
If
you
see
this
and
you're
something
you'd
be
interested
in
is
attending
a
hackathon
in
the
you
know
in
the
Bay
Area
in
California,
or
you
know,
someplace
else
you
know
give
us,
you
know,
give
send
us
a
message.
Let
us
know
what
what
your
interest
is.
Okay,
there,
you
are
and
we'll
well
we're
we're
just
starting
to
sort
of
plan
and
coordinate
these
now
and
settle
on
where
we're
gonna
do
them
and
how
we're
gonna
get.
A
B
A
B
Think
so,
like
I
said,
the
the
existing
project
plan
for
the
next
release
is
a
little
bit
of
a
mess.
So
the
URL
that
you
saw
on
the
screen
earlier
is
gonna
stay
the
same,
but
just
expect
that
the
different
things
around
the
plan
will
probably
move
because
I've
only
had
a
chance
to
look
at
it,
and
you
know
right
now,
so
it'll
it'll
probably
move
around,
but
we're
hoping
to
do
a
new
release,
probably
at
the
end
of
the
week,
if
not,
if
or
at
the
beginning
of
next
week,
at
the
very
latest.
Okay.
A
A
B
Viewers
just
making
sure
that
they
have
no
questions
in
the
chat
yeah,
nothing,
nothing
in
the
chat
right
now.