►
Description
Broadcasted live on Twitch -- Watch live at https://www.twitch.tv/nrelabs
B
A
I'm
good
I'm,
good
I'm
well-rested
about
to
go
to
Toronto
tomorrow
to
talk
about
automating,
Network
automation,
so
I'm
excited
about
that
nice
I
love
Toronto,
it's
about
an
hour
from
where
I
grew
up,
but
I
had
no
family
there
anymore.
So
I
really
don't
have
a
reason
to
go
down
there
while
I'm
out
there.
B
B
Last
week,
I
was
in
Sun
River
Oregon,
which
is
it's
pretty
cool.
Actually
so
there's
a
there's,
a
river
that
runs
sort
of
down
the
middle
of
the
state
along
the
along
the
Cascade
Range.
If
you're
not
familiar,
it's
like
we're
like
Mount
Hood
and
Mount,
Ranier
and
Mount,
you
know
Adams
Jefferson,
like
the
whole
bit.
That's
the
range
up
here
in
the
Pacific
Northwest
that
really
where
all
the
mountains
are
just
running
down
north-south,
that
direction
anyway.
B
If
you
haven't
been
to
crater
lake,
it's
mind-blowing
ly
cool.
We
haven't
gone
there,
yet
we've
been
living
in
the
Pacific
Northwest
for
like
for
to
put
over
40
years,
and
we
haven't
been
down
there
yet
just
cuz.
It's
like
a
five
hour
drive
but
driving
like
what
three
hours
to
Sun
River
from
Portland
is
is
okay
and
then
you
know
resting
for
a
day
and
kind
of
hanging
around
there
and
then
driving.
You
know
the
rest
of
the
way
to
crater
lake
made
it
manageable,
but
anyway
it
was
just.
B
You
know
some
time
off
badly
needed.
Apparently
so
it
was
a.
It
was
good,
it
was.
It
was
actually
a
lot
of
fun.
I
didn't
take
my
laptop
with
me
and
everybody's
like
who
survives
like
yeah
I
I
survived
I'm,
not
like
you
know,
physiologically
dependent
on
my
laptop,
but
nevertheless
it
is
good
to
to
leave
it
behind
and
be
able
to
focus
on
the
things
you
need
to
focus
on.
So
that's
what.
A
A
Had
well
I
didn't
go
on
vacation,
but
we
had
Bryan
Linkletter
on
last
week.
He
wrote
the
blogs
about.
You
know
how
to
set
up
self-medicate
and
how
to
you
know
how
to
whatever
the
basic
things
involved,
with
making
a
lesson
actually
very
well
written
blogs
that
are
pretty
much
everything
you
need
to
know
to
do
either
one
of
those
things.
So
we
had
it
on
last
week
for
those
who
are
watching
who
have
not
seen
last
week's
stream
definitely
check
it
out.
A
Bryan
specializes
in
he
has
a
blog
about
network
simulation
and
so
he's
he
likes.
He
likes
enemy,
labs
and
blogs
about
it.
So
we
also
had
our
first
community
stand-up
meeting
for
the
project
last
week,
Bryan
the
aforementioned
Bryan
was
there
as
well
as
over
jaques,
that's
his
handle
on
discord
and
discourse.
He
was
there
and
we
talked
a
little
bit
about
something
that
actually
this
reason,
while
you're
on
this
week.
One
of
the
things
that
came
up
is
you
know
we
did.
How
can
we
get
other
kinds
of
nodes
in
our
topologies?
B
Was
like
watching
that
I,
so
I
came
home
like
late
last
week
and
one
of
the
first
things
I
did
was
to
catch
up
on
the
vid
cuz
I
knew
you
guys
were
doing
that
so
I
loaded
up.
You
know
the
the
videos
from
that
and
started
watching
the
community
meet
the
community
meeting
to
stand
up
that
you
guys
recorded
and,
like
the
whole
time,
I
was
like
already
fixed
yep.
No,
no,
that's
fixed,
no,
no
that'll
be
fixed
like
every
it's
so
funny
like
like,
and
we
haven't
talked
about
this.
A
Well,
yeah,
so
let's
get
started
then
so
we
have.
We
have
a
couple
of
viewers.
Now
will
will
kick
it
off
officially
welcome
to
the
NRE
labs
livestream,
our
weekly
live
stream.
That
is
now
it's
done.
Every
every
single
Monday
at
this
time
ad
or
excuse
me
10:00
a.m.
Pacific
goes
for
30
minutes
to
an
hour
depends
and
depends
on
the
topic.
A
B
A
Remember
this
time:
yes,
you
did
so
so
we
today
we're
gonna,
actually
talk
about
some
of
the
things
that
that
came
up
in
last
week's
community
stand-up.
As
you
know,
right
now,
the
way
the
way
was
built
you
can
pretty
much
only
support
Juno's
and
some
linux
hosts
for
our
for
the
endpoints
that
you
can
place
into
your
virtual
topology.
A
For
your
lesson,
and
we
know
this
is
something
that's
been
top
of
mind
for
us
for
a
little
while
now
it
needs
to
be
fixed,
there's
lots
of
other
things
we
could
be
putting
in
that
topology
other
other
network.
Things
like,
like
maybe
cumulus,
maybe
FRR,
just
the
open
source
version
of
FRR,
as
well
as
the
ability
to
generally
customize
the
endpoints
that
we're
putting
out
there,
which
is
you
know
it's
it's
a
little
bit
hokey
now.
A
If
you
want
to
put
something
specific
into
the
Linux
utility
thing,
then
you're,
just
adding
more
and
more
stuff
to
that
one
image
it'd
be
nice.
If
there
was
a
way
to
avoid
doing
that
so,
and
this
I
believe
addresses
that
so
without
further
ado,
I'm
gonna.
Actually,
let
Matt
talk
for
a
little
bit
about
the
changes
he
made
for
these
exact
things.
B
Yeah,
let
me
share
my
screen,
so
we
have
a
guy
open
to
github
issue
a
couple
weeks
ago
to
start
to
discuss
some
of
the
problems
that
we've
had
on
our
mind
for
a
while.
Actually
much
of
this
is
the
thing
much
of
what
was
discussed
on
that
on
that
that
call
we've
actually
known
about
for
a
while.
It
was
just
a
matter
of
you
know
trade-offs
like
what
well,
how
long
can
we
get
away
with?
B
B
Sure
yeah
how's
that
beautiful
so
there's
a
few
problems
that
we
want
to
solve
the
first
one,
and
so,
if
yeah,
if
you
want
to,
if
you
want
to
follow
along
under
the
syringe
issue,
so
syringe.
If
you
don't
know
what
syringe
is
it's
the
back
end
Orchestrator
for
the
antidote
project
and
then,
as
a
result,
NRI
labs.
So
a
lot
of
the
whenever
we
get
into
like
the
abstractions
that
are
offered
by
you
know
the
antidote
project
more
or
less.
B
B
Its
presented
to
you
in
the
browser-
that's
another,
that's
another
sub-project
of
the
evade
to
dope,
but
syringe
does
take
care
of
allowing
you
to
convert
sort
of
you
know
to
simple
text
files
that
describe
a
lesson
into
a
usable
lesson
in
the
browser.
So
that's
why
we
have
the
issue
here
now:
there's
a
few
problems
that
we
have,
that
we
want
to
solve
with
this
effort
and
I'll
sort
of
go
through
them,
one
by
one
and
sort
of
talk
about
the
history
of.
Why
we're
here,
because
I
think
that's
important
to
talk
about
the.
B
It's
very
limited
so
right
now,
when
you,
when
you
spit
up
an
unused
to
fine
a
lesson,
you
have
a
few
options.
You
have
an
option
to
declare
end
points
within
a
key
within
the
email
document
called
utilities.
You
also
have
devices,
and
then
you
have
black
box
I,
think
that's
it
right
now,
yeah!
So
those
are
the
three
types
now
there's
there's
a
few
things
wrong
with
that.
B
First
off,
when
it
comes
to
actually
making
configuration
changes,
the
way
it
works
is
syringe
will
only
perform
configuration
changes
for
any
endpoints
under
devices
and
there's
a
bunch
of
problems
with
that
that
we've
already
articulated
and
other
issues
actually
Brian
brought
up
a
bunch
of
problems
with
that.
So
that's
going
to
get
fixed
by
this
effort
as
well,
but
they're
in
a
separate
issue.
The
main
problem
that
I'm
talking
about
here
is
the
fact
that
let's
say
everything's
working
appropriately
and
there's
not
really
a
bug.
B
It's
still
insufficient
because
you
know
what
we
did
was
we
said:
look
we
want
this
to
be
multi
vendors.
So
what
we'll
do
is
we'll
select
napalm
as
the
sort
of
mechanism
for
how
to
provide
configurations.
So
what
you
do
is
you
declare
an
endpoint
within
that
device
is
key
and
then
based
on
the
name
of
the
endpoint
that
you
declare
say
you
know
V
Q
of
X
1.
B
What
it'll
do
is
it'll
look
for
a
configuration
file
in
the
lesson
directory
in
the
stage
that's
being
loaded
and
then
it'll
call
napalm
with
that
config
file
and
load
it
onto
the
device.
There's
a
few
things
wrong
with
that.
First
off
the
the
napalm
sort
of
CLI
command.
That's
executed
by
syringe
statically
has
the
the
driver
set
to
juno's
and
now
before
you
freak
out,
that's
actually
very
easy
to
change.
Their
only
only
reason.
B
Because
there's
only
Juno's
images
in
the
platform
right
now,
so
there's
not
only
a
point
to
make
that
configurable,
because
there's
no
there's
no
other
images
other
than
Juno's
right
now,
but
this
presents
a
little
bit
of
a
catch-22
so
like
who
how
you
know
how
we're
gonna
get
other
images
contributed.
If,
if
you
know
the
the
configuration
mechanism
is
so
limited
and
I
don't
mean
I
don't
mean
that
it's
statically
set
to
Juneau.
So
again,
that's
easy
to
fix.
B
We
can
expose
that
field
into
the
lesson
definition
and
make
it
to
you
know
fully
configurable.
That's
very
easy,
however.
What's
what's
less
easy
is
the
fact
that
napalm
isn't
it
doesn't
support
everything
that
we
we
want
to
configure
from
a
network
devices
perspective,
for
instance,
cumulus,
as
Derek
mentioned,
is
not
supported
by
napalm
because
cumulative
net
kampf
for
for
cumulus,
or
at
least
you
know,
that's
not
like
the
way
that
they
prefer
things
get
configured.
B
There's
a
very
different
configuration
model
if
you're
working
on
cumulus
same
thing
is
true
by
the
way
for
things
like
by
OS.
So
if
you're,
using
that
being
able
to
being
able
to
configure
things
directly
via
SSH,
not
screen
scraping
per
se,
but
you
know
editing
files
and
things
like
that
and
config
files,
that's
very
useful
and
obviously
napalm
is
not
meant
to
support
those
things.
Napalm
is
not
a
configuration
management
tool,
and
so,
as
a
result,
the
network
configuration
you
know.
B
Mechanism
that's
currently
in
place
assumes
that
the
first
off
the
thing
you're
trying
to
configure
is
a
network
device
and
also
on
top
of
that
it
has
to
be
supported
by
napalm
which,
as
we've
mentioned,
not
all
network
devices.
Our
second
thing
is
sort
of
what
I
just
mentioned.
Not
all
endpoints
are
network
devices,
but
they
require
configurations
just
the
same
so
take.
For
instance,
if
you
have
what
Derek
was
saying,
you
have
a
utility
image
which
is
not
a
network
device.
B
You
know
maybe
you're
using
salt
or
set
or
stack
storm,
or
something
like
that,
and
you
want
to
be
able
to
show
something
different
based
on
the
stage
that
you're
in
so
you
want
to
be
able
to
say,
like
look
I'm
moving
from
stage
1
to
stage
2
I
need
to
change
the
state
within
this
container
because
it
needs
to
show
something
different
or
I
need
to
change
a
config
file
or
something
something
along
those
lines.
Right.
B
Not
even
possible,
because
again,
what
we've
done
is
we've
limited
the
configuration
mechanism
to
napalm,
so
that
means
it
has
to
be
a
network
devices.
It
has
to
be
a
network
device
that
you're
configuring
so
yeah.
This
is
a
lot
easier
to
talk
about,
because
this
just
there's
no
there's
no
option
here
you
what
you
have
to
do
today
is
you
have
to
bake
everything
possible
into
the
docker
image
ahead
of
time.
Now,
I
want
to
be
careful
here
because
we're
not
going
away
from
that.
B
I
still
believe
very
strongly
that
one
of
the
one
of
the
benefits
of
the
platform
is
a
lot
of
the
you
know.
There's
not
everything
is
configured
at
runtime.
One
of
the
great
things
about
immutable
infrastructure
is
there's
actual
cryptic
graphic
mechanisms
in
place
to
make
sure
that
the
containers
start
exactly
the
same
way
every
single
time.
So
we
we
don't
want
to
move
away
from
that,
that's
very
valuable.
B
B
It
uses
the
same
image,
regardless
of
the
stage
that
you're
in
so
being
able
to
make
some
just-in-time
configuration
changes
is
useful,
so
I
would
say
try
to
you
know
as
we
as
we
move
forward
with
this
new
feature
that
I'm
about
to
talk
about
we're
still
gonna
try
to
bake
about
90%
into
the
image
itself,
just
to
just
to
keep
things
you
know
immutable,
but
that
last
10%
for
things
that
we
really
need
to
change
in
real
time.
It's
useful
to
have
a
mechanism
for
doing
that.
B
So
those
are
the
configurations,
sort
of
problems
that
we
currently
have
at
the
platform.
Like
I
said
you
know,
we've
kind
of
known
that
these
were
gonna,
be
that
these
were
gonna
bite
us.
Eventually,
it's
just
been
about
trade-offs
right
now.
You
know:
we've
gotten
away
with
we've
actually
gotten
away
for
a
while
with
without
solving
these
problems.
We
have
quite
a
bit
of
content
already
that
didn't
need
to
address.
It
didn't
force
us
to
address
this,
so
you
know
like
I
said
it's,
it's
not!
You
know.
B
It's
not
that
we
we,
you
know,
for
instance,
the
you
know
selected
napalm
with
the
Junos
driver.
We
did
that
just
to
move
things
forward,
but
now
it's
time
to
fix
it.
So
that's
what
we're
doing
the
third.
The
third
problem
is
a
CLI
terminal.
Isn't
always
the
right
thing
to
use
to
show
content.
So
one
of
the
great
things
about
about
the
platform
the
week
that
we,
you
know,
sort
of
wow
people
with
early.
B
B
A
No,
no
I
I
think
you
know
I'm.
Looking
forward
to
these
changes
myself
I
know
some
of
our
community
members
are
like
over
jix,
because
he
you
know
he
he
figured
out
that
VNC
could
work,
and
you
know
I'm
I'm,
myself,
I'm
kind
of
looking
forward
to
that
I
think
it's
gonna
be
I!
Think
this
it's
good
like
it's
like
I,
said
online
I
think
this
is
going
to
open
up
the
field
for
us
in
terms
of
the
kinds
of
lessons
we
can
do.
A
B
But
I
I
talked
about
that.
A
lot
I
gave
I
basically
gave
the
version
of
the
presentation,
as
as
the
platform
might
exist
in
a
few
months,
so
I
kind
of
have
an
idea
of
the
changes
we're
making
in
the
next
few
months
and
I
presented
it.
That
way,
one
of
the
things
I
mentioned
and
I'll
reap
repeated
here
is,
you
know.
The
job
of
the
platform
is
to
be
opinionated,
but
you
know
just
you
know
exactly
exactly
opinionated
enough,
but
no
more
so
you
know
we
we
provide.
B
B
Things
as
easy
as
possible
for
them
yep,
so
that's
kind
of
a
goal.
So
here's
how
we're
going
to
fix
it.
So
there's
two
aspects
to
this
effort:
there's
obviously
the
configuration
portion.
So
we
need
to
be
able
to
make
configuration
changes
to
non
napalm,
supportive
devices
network
devices
as
well
as
non
network
devices,
and
so
what
we
need
is
a
new,
a
new
way
of
performing
configurations
that
allows
us
to
sort
of
address.
All
of
that
without
reinventing
the
wheel.
The
other
aspect
is
presentations.
B
So,
as
I
mentioned
before,
not
everything
is
shown
via
CLI.
Sometimes
you
might
want
other
other
mechanisms
for
showing
for
showing
content
this
also,
by
the
way,
there's
also
a
thing
that
Pete
some
people
have
requested
is
the
ability
to
show
the
same
endpoint
in
multiple
different
ways.
So
right
now
the
way
that
you
have
to
define
lessons,
you
can
only
show
the
endpoint
once
and
again,
it's
very
C
lies
specific,
so
not
only
is
a
CLI
specific,
but
it's
also
limited
in
terms
of
what
you
can
show.
B
B
Configured
and
the
way
things
are
presented
both
of
those
will
be
addressed
in
the
same
in
the
same
change,
because
well
because
of
the
way
that
they're
conflated
today.
So
let
me
let
me
actually
go.
Is
this
the
you
know?
That's
the
new
format.
Let
me
actually
go
out
I'm
going
to
show
the
curriculum.
Real,
quick
and
I'll
show
you
an
example
of
how
this
is
kinda
not
ideal.
Today,
oops,
it's
not
where
I
want
to
go.
I
want
to
go
tools.
B
Let's
take
a
look
at
the
J
snappy
lesson,
for
example.
So
unless
I'm
not
met
about
yeah
Mille,
this
is
the
metadata
file
for
describing
the
J
snappy
lesson.
This
is
where,
if
you
haven't
looked
at
this
before,
basically
this
is
a
yellow
file.
It
describes
the
structure
of
a
lesson
now,
there's
a
lot
more
to
a
lesson
than
just
this
file,
for
instance
config
files
and
lesson
guides
and
whatnot,
but
this
is
where
you
start.
B
This
is
what
describes
the
sort
of
the
structure
of
a
lesson,
and
so,
as
I
mentioned,
you
have
a
few
top-level
keys
here.
You
have
utilities,
and
then
you
have
devices
and
again
the
way
that
the
way
that
the
backend
works
is
it
says:
okay,
you've
defined
these
three
endpoints
under
devices
and
then
this
one
endpoint
under
utilities.
B
So
what
I'm
gonna
do
is
when
you
go
to
stage
one
I'm
gonna
look
for
three
text
files
under
the
stage,
one
directory:
that's
named
the
effects,
one
dot
txt
and
then
that
txt
and
that
gun
takes
date
and
that's
how
these
these
three
network
devices
are
going
to
be
configured.
And
it's
going
to
use
maple
to
do
that,
since
this
is
under
utilities,
I'm
not
going
to
do
anything
that,
because
utilities
don't
get
automatically
configured.
B
So
that's
currently
how
it
is
and
again
you
know
that
kind
of
that
kind
of
isn't
ideal,
because
what,
if
you
know
what,
if
these
need
to
get
configured,
let's
take
a
peek
at,
for
instance,
let's
take
a
peek
in
another
lesson.
Actually,
let's
look
at
your
testing
lesson
because
that's
a
yeah,
your
troubleshooting
lesson,
because
that's
actually
a
really
good
example
of
the
the
other
aspect
to
this,
which
is
21.
B
Thank
you,
which
is
I,
haven't
added
human
readable
names
to
the
workflows.
Yet
oh
wait,
no
I
have
I
have
here
we
go
here.
We
go
there,
we
go
there,
we
go
that's
another
thing:
I
need
to
fix,
I
added
those.
Those
directories
back
there
to
fix
some
images
problem,
that'll
get
fixed
in
the
new
release,
so
lesson
about
many
animal.
B
This
is
this
is
troubleshooting
less
than
that
you
built,
and
this
is
actually
a
really
good
way
of
showing
the
problem,
because
because
you're
using
all
of
the
features
which
shows
how
I'm
conflating
things
on
the
back
end.
So
as
I
mentioned,
there's
three
high
level
keys,
I've
shown
you
utilities
and
devices.
Here's
this
new
one,
though
black
boxes,
the
the
original
thought
behind
this
was
okay.
Maybe
you
want
to
show
maybe
there's
some
endpoints
that
you
would
like
to
that.
B
You
would
like
to
have
in
the
lesson,
but
you
don't
want
to
show
in
any
way
you
like
have
them
represented
within
the
within
the
you
know
within
the
the
web.
You
are
you
just
want
them
to
exist.
So,
for
instance,
you
might
have
say
in
the
net
box
endpoint
here
you
need
to
be
able
to
call
the
net
box
API,
but
you
don't
necessarily
want
to
show
it
in
any
way
in
the
web
browser
you
just
want
to.
B
You
just
want
the
API
to
be
accessible
with
a
lesson
yeah,
so
you
spit
up
an
endpoint
underneath
black
boxes,
and
so
syringe
will
say:
okay,
cool
I
need
to
start
this
container,
but
I'm,
not
gonna
I'm,
not
gonna
tell
the
web
frontend
about
it.
It's
just
gonna
simply
exist
and
I'll
open
the
ports
for
it.
B
Now,
if
you
look
at
this
and
and
you
look
at
the
difference
between
utilities
and
devices,
you'll
notice
that
the
difference
between
those
two
is
pretty
simple
devices
get
configured
and
utilities
don't
and-
and
that's
kind
of
the
distinction
there
now
put
aside
for
a
second,
the
fact
that
utilities
you
know
you
might
want
to
be
able
to
configure
these
influenced.
Put
aside
that
that
fact,
for
a
moment,
even
though
that's
true,
that's
totally
true,
you
might
want
to
perform
configuration
tasks
on
this.
That's
not
actually
the
biggest
problem.
B
The
biggest
problem
is
that
here,
the
difference
between
devices
and
utilities
is
a
configuration
thing.
It's
it's
the
way,
they're
configuring
configured.
But
if
you
look
at
the
difference
between
black
boxes
and
devices,
that's
not
the
difference
at
all.
The
difference.
There
is
how
they're
presented
to
the
front
to
the
front
end,
and
so
we
have
these
two,
the
two
axes
that
I
discussed
in
the
issue
that
I
showed
you
are
actually
being
conflated
among
these
three
groups
of
endpoints.
B
Even
though
all
three
of
these
endpoints
are
effectively
identical
in
their
fields,
they
have
a
name,
they
have
an
image
reference
and
then
they
have
ports.
The
way
that
they're
treated
is
very
different,
based
on
the
category
that
they're
in
here
and
and
that's
not
great
in
terms
of
how
the
in
terms
of
how
the
abstraction
is
built,
it's
it's
kind
of
confusing.
B
So
you
see
like
you
know,
oh
I
put
an
endpoint
under
devices
if
I
wanted
to
be
configured,
but
if
I
don't
want
it
to
be
presented,
I
need
to
put
it
under
black
boxes,
but
what,
if
I,
need
it
to
be
configured
to
like?
That's?
Not?
It's
just
very
confusing,
so
here's
how
we're
changing
that
I
go
back
to
the
issue
here:
issue
1,
1
2.
This
is
where
we're
discussing
the
changes
and
I'm
I
believe
this
is
pretty
much
identical
to
how
it
is
today
there
might
be
a
small
change.
B
I
think
this
field
might
be
a
little
bit
different,
but
the
spirit
of
it
is
the
same,
so
forget
about
the
whole
utility
devices.
Black
boxes
like
just
forget
about
that.
That's
not
going
to
exist
anymore
in
any
way,
it's
just
gone.
So
what
we've
done
instead
is
in
the
new
version
of
syringe
and
again
you'll
be
able
to
access
this
well.
B
You
can
actually
access
this
today
if
you
check
out
my
branch
and
build
syringe
yourself,
but
if
you
want
to
do
that,
I'll
be
you
know
when
I
merge
the
PR
that
does
this
all
you
know
be
uploading
the
the
new
docker
image
for
syringe
and
you
can
just
download
it.
So
if
you're
not
super
ambitious,
you
can
you
can
just
try
that
so
forget
about
the
whole
utilities
devices
black
boxes
thing
like
just
forget
about
it.
Everything
is
under
endpoints.
B
Every
single
thing
that
you
put
into
a
lesson
is
under
endpoints:
that's
this
key
here
now,
let's
pick
on
one
of
these
endpoints,
this
is
gonna,
be
pretty
similar
to
what
you
what
you
see
today,
let's
pick
on
this
one,
so
V
key
affects
one.
A
lot
of
this
is
gonna,
be
familiar,
for
instance,
name
is
the
same,
so
naming
the
endpoint.
Obviously
you
want
to
be
able
to
provide
it
with
a
name.
Image
is
exactly
the
same.
That's
a
docker!
B
You
know
image
reference
that
that
hasn't
changed,
but
underneath
that
is,
is
all
new
stuff
and
again
I'm
talking
about
both
configuration
changes
as
well
as
presentation
changes
in
the
same
breath
because
the
previous
of
the
world,
a
current
abstraction,
conflates
the
two.
So
there's
not
really
a
way
to
solve
one
problem
and
then
the
other
you
kinda
have
to
solve
both
of
them
together.
B
That's
why
this
is
a
pretty
big
change,
but
I
think
it's
a
good
I
think
it's
a
good,
a
good
change
so
underneath
underneath
each
endpoint,
so
you
have
in
the
amal.
If
you
haven't
seen
this
before,
you
have
a
list
of
endpoints,
so
I'm
just
gonna
highlight
the
the
endpoint
here.
This
is
the
endpoint
I'm
talking
about
right
now
this
particular
endpoint
says
configuration
and
I
think
in
the
in
the
current
version.
B
It's
actually
not
configuration
and
then
type
is
just
one
more
configuration
type,
but
it's
mostly
the
same
if
you
specify
Napalm
after
that,
what's
gonna
happen
is
oh
I'm,
so
sorry,
I'm,
probably
being
overly
confusing,
because
that's
napalm
is
not
a
supported
configuration
type.
Let
me
let
me
do
one
better,
actually,
sorry
I.
This
is
I
thought
that
was
going
to
be
a
good
example
and
it's
not
I
was
also
fixing
some
blog
issues.
On
my
blog,
let
me
bring
up
the
curriculum
here
and
I'll.
Bring
up
the
oh.
B
No,
you
know,
I
do
have
that
a
github
I
do
have
that
in
github
and
I
relapse
curriculum
lessons
fundamentals.
Oh
it's
in
config
presentation
as
where
it
is
that's
the
one
demo.
Okay,
sorry
about
that.
So
so,
as
I
mentioned,
the
I
created
the
issue
a
few
weeks
ago.
So,
even
though
the
Spirit
of
the
change
is
the
same,
some
of
the
syntax-
that's
here
has
changed
so
instead
of
showing
you
in
the
issue,
I'll
show
you
here
in
the
in
the
curriculum
that
I've
been
editing
to
to
work
with
the
new
system.
B
A
B
Little
easier
to
look
at
so
anyway,
the
key
effects-
one!
Oh
sorry
about
that.
This
is
endpoints
list
of
endpoints
and
then
underneath
this
endpoint
is
that
are
the
changes
that
we
have
so,
as
I
mentioned,
the
the
way
that
you,
the
way
that
you
perform
configurations
on
an
endpoint
now
is
with
this
field
that
says
configuration
type.
Now,
it's
an
optional
field.
Not
everything
needs
to
be
configured,
as
evidenced
by
the
way
that
we're
currently
doing
things
like
some
of
the
some
of
the
images
are
just
ready
to
go.
B
You
sort
of
baked
all
of
the
things
you
need
into
the
image
and
it's
just
ready
to
go.
You
just
need
to
start
it.
That's
still
totally
fine.
So
if
you
wanted
to
leave
this
field
out,
as
you
see
I'm
doing
here,
see,
there's
no
configuration
type
field
here
or
here
you'll
see
that
it's
it's
optional.
But
if
you
do
provide
it,
you
have
two
options:
you
have
Python
and
you
have
ansible.
B
So
in
the
case
of
Python,
what
happens
is
similar
to
how
it
currently
works?
What
it'll
do
is
I
say
it
cool,
so
I'm
loading
up.
This
lesson
and
you're
going
to
stage
one.
So
what
that
means
is
I'm
going
to
look
in
the
stage
one
directory
for
a
file
underneath
configs
that
is
named
the
endpoint
name,
so
vqf
x1,
dot
py,
because
we've
selected
python
as
our
configuration
mechanism
that
python
script
is
fairly
arbitrary.
B
Now
what
I've
done
in
this
Python
script
specifically
is
effectively
replicate
what
we're
currently
doing
statically
with
the
Napalm
CLI.
So
in
the
previous
version
of
syringe,
what
we've
done
is
we
basically
just
shelled
out
to
the
Napalm
CLI
and
told
it
hey,
use
this
config
file
and
load
it
onto
the
device?
B
What
I've
done
is
I've
as
I've
replicated
that
in
a
Python
script
and
provided
that
into
the
curriculum
as
a
as
a
as
a
Python
script,
so
the
same
functionality
is
is
being
done
in
this
particular
case,
but
the
cool
thing
about
this
is
it's
all.
In
the
Python
script,
it's
not
actually
baked
into
syringe
at
all,
which
means
that
the
power
of
how
to
configure
the
network
device
is
fully
within
the
curriculum.
There's
not
like
some
magic
configuration.
You
know,
sort
of
voodoo
baked
into
syringe
syringes.
B
B
B
That
we've
acted
that
we're
already
currently
using.
Actually
the
difference
is,
if
you
look
at
the,
if
you
don't
like,
if
you
don't
know,
go,
don't
worry
about
it.
I'll
explain
this,
but
I'll
show
you
the
difference
in
what
we're
actually
doing
so
isn't
the
PR
that
actually
implements
these
changes
and
what
I'll
do
is
I'll
just
go
straight
to
a
file
called
jobs,
dot
go
and
show
you
the
change
here
so
yep
there
we
go
so
previously.
If
you
I'll
show
you
the
red
tech
first,
because
this
is
what
it's
currently
doing.
B
If
you
look
at,
if
you
look
at
the
way,
this
syringe
works
currently
in
order
to
configure
something
what
it'll
do
is
it'll
spin
up
a
new
docker
it'll
spin
up
a
new
kubernetes
pod?
It
actually
does
it
via
a
job,
but
it's
you
know
at
the
end
of
the
day,
it's
a
pod,
which
is
a
container,
so
it's
pinned
to
the
container.
The
image
that
it
uses
is
the
special
image
that
we
built
for
for
doing
this
called
configurator,
and
basically
all
that
is,
is
an
image
that
has
a
bunch
of
stuff
installed.
B
Python
ansible
may
Paul
all
kinds
of
stuff
just
has
it
installed,
and
what
that
allows
us
to
do
is
it
allows
us
to
call
a
Python
script.
That's
baked
into
the
image
called
configure
dot,
py,
which,
by
the
way,
is
very
very
similar
to
the
script.
I
just
showed
you
with
some
small
changes
and
basically
what
it
does.
This
is:
okay,
I'm
gonna
configure
this
device
with
this
config
file
and
I'm
gonna
configure
the
the
hostname.
That's
that's
here.
So
all
this
is
passed
in
dynamically.
B
However,
the
way
that
it's
call
is
actually
very
static
as
you
as
you
see,
for
instance,
the
driver
that
we're
selecting
is
Juno's.
Now
again,
that's
easy
to
fix.
You
know
we
we,
the
hard
work
of
selecting
napalm,
was
already
done.
It's
just
that
we
were
statically
calling
Juno's,
because
that
was
the
only
image
we
supported.
B
So
that's
how
it's
currently
done.
So
basically,
what
we
do
is
we
spin
up
an
image
called
configurator
and
we
call
a
script
within
the
configurator
image
to
do
the
configuration
task
now
we're
still
using
the
configurator
image
in
the
new
in
the
new
mechanism,
because
it
has
all
of
the
things
that
we
need
installed
by
default,
so
ansible
and
python
and
napalm,
and
all
that
stuff
net
miko
is
also
installed.
So
there's
all
kinds
of
configuration
utilities
installed
in
the
configurator
and
of
course
you
can
contribute
to
this.
B
If
you
have
a
library
that
you'd
like
to
use,
you
know
within
reason,
we'll
absolutely
consider
adding
it
to
the
configurator,
which
we
try
to
treat
that
a
little
special,
because
it
does
affect
everyone,
but
that
doesn't
mean
we're.
You
know
we're
restricting
people
from
contributing
to
it.
You
absolutely
can
do
that
now.
The
big
difference
here
is
instead
of
calling
things
in
instead
of
calling
a
custom
script
that
we
wrote
within
the
the
end
and
then
we
baked
into
the
image.
B
Instead,
what
we're
doing
is
we're
passing
simply
the
Python
command
with
the
Python
script
in
the
appropriate
directory.
So
in
this
line
here,
if
you
don't
know,
go
basically
what
this
does
is.
It
creates
a
string
with
some
replacements,
so
here
it
puts
the
stage
that
you're
currently
accessing
so
say
stage
one
and
then
it
uses
the
name
of
the
endpoint
you're
trying
to
access
or
configure
dot
py,
and
it
simply
runs
that
script.
That's
it.
It
just
runs
the
script.
B
So
if
you
want
to
run
a
Python
script
and
a
lot
of
people
do
have
ansible
playbooks
for
doing
configuration,
changes
so
keeping
with
the
spirit
of
what
we
want
to
do
for
the
project
and
that
is
to
you
know,
allow
people
to
reuse
content
and
not
reinvent
the
wheel.
A
lot
of
people
have
ansible
play
books
to
do
configuration
changes
already,
but
rather
than
force
them
to
write
NIT
new
python
scripts.
We
also
support
the
use
of
ansible
play
books.
B
Same
rules
apply
if
you
have
an
answerable
playbook
that
you
want
to
use
for
a
particular
device,
just
name
it
the
same
as
that
device
and
put
it
in
there
lesson
the
appropriate
stage
directory
within
your
lesson.
Periculum,
nice
and
it'll
simply
execute
it
again
arbitrarily.
So
you
you
can
put
whatever
you
want
inside
of
that.
B
Take,
for
instance,
the
we'll
go
back
out
a
directory
and
look
at
that
particular
ansible
playbook,
so
linux,
dot,
yml,
one
of
the
endpoints
is
called
linux,
and
so,
if
you
try
to
move
to
stage
one,
if
you
load
the
lesson,
it'll
look
at
this
directory
and
say,
oh
looks,
looks
like
I.
Have
a
little
yml
file,
so
I'm
gonna
try
to
run
that
with
ansible
and
configure
the
endpoint
appropriately-
and
this
is
just
a
you
know:
BS
playbook,
it
doesn't
actually
do
anything,
but
the
cool
thing
is
we're
generating
the
inventory
manically.
B
B
So
totally
arbitrary.
The
whole
point
of
the
the
whole
point
of
this
is
to
remove
the
black
magic
from
the
platform.
All
the
configuration
now
is
done
in
the
scripts
that
are
in
the
curriculum.
The
big
difference
here
is
that
there's
no
there's
no
actual
configuration
done
within
the
platform.
It's
actually
done
within
the
scripts
that
those
that
the
platform
calls.
So
we
have
a
little
little
object.
B
That
says
you
know
based
on
what
you
stated
in
the
lesson
definition,
we
got
to
figure
out
where
the
appropriate
script
or
PlayBook
is,
but
once
we've
done
that
the
power
is
back
in
your
hands,
you
you
do
whatever
you
need
to
do
within
the
playbook
or
within
the
Python
script.
To
do
what
you
need
to
do
to
configure
any
endpoint
whatsoever.
It
doesn't
matter
if
it's
a
network
device,
it
really
doesn't
matter
at
all.
You
can
do
whatever
you
want.
A
On
go
ahead,
so
one
of
the
things
that
somebody
pointed
out
before
was
when
they
use
that
Linux
container.
You
know
just
for
you
know,
like
that's,
used
almost
in
every
lesson.
Actually
they
see
all
of
the
files
from
all
of
the
lessons
in
the
same
directory.
Is
that
like,
like,
for
instance,
the
Python
scripts
I
use,
I
was
building
for
the
troubleshooting
thing
show
up
in
every
single
lesson.
Is
that
something
that'll
be
changed
or
that
will
that
remain
the
same?
B
B
A
B
Yeah,
it's
it's
actually
already
merged,
I,
believe
I,
believe
the
syringe
has
already
been
modified
appropriately.
But
let
me
try
to
paraphrase
what
you
just
said:
if
you
go
to,
for
instance
like
if
you
load
up
less
than
current
this,
so
this
is
how
it
works
today,
if
you
go
to,
if
you're
gonna
labs,
that
Network
reliability
at
engineering
and
you
load
up
a
lesson
and
and
as
Derek
just
said
most
lessons
have
that
that
utility
container
for
showing
for
showing
things
like
you
know
little
CLI
tools
and
whatnot.
B
B
Bring
it
over
here.
So
if
you,
if
you
click
this
first
button
in
the
introduction,
a
camel
you
see,
what
it's
doing
here
is
it's
going
into
the
slash
antidote,
slash
lessons,
flash
lesson:
14
slash
stage,
one
yeah,
because
what
happens
on
the
back
end
is
slash.
Antidote
is
actually
mapped
to
the
full
lesson
curriculum
in
every
single
case
for
every
container.
In
a
lesson,
so,
actually,
let's
manually,
go
to
slash
antidote
and
show
you
what
I
mean.
Oh.
B
So
if
you
look
at
that,
you
can
see
the
entire
curriculum,
including
all
of
the
the
the
like
Travis
dot,
yml
files
like
the
whole,
it's
the
whole
route,
git
repo,
it's
kind
of
it's
kind
of
kind
of
funny.
Actually
everything
is
laid
bare.
It's
you
now
that
has
its
advantages,
because
you
can
in
the
in
the
you
know,
you
can
actually
just
poke
around
and
see
what's
there,
but
honestly,
you
can
do
that
and
github.
You
can
clone
the
same
repo
yourself.
So
it's
not
like
this
is
the
only
way
to
see
that
content.
B
The
the
problem,
with
the
way
that
it
currently
is,
is
it
just
produces
a
lot
of
unnecessary
noise
so,
and,
and
and
really
the
biggest
way
that
that
impacts
is
the
fact.
Every
single
lesson
has
to
have
this
giant
cd2
path
at
the
very
beginning
of
every
lesson,
and
you
might
have
noticed
that
we
could
restructure
the
lesson
curriculum
to
be
a
little
bit
more
nested
and
organized.
B
So
what
that
change
is
actually
only
gonna
get
worse,
which
is
not
ideal,
so
another
change
that
we
made
actually
is
instead
of
mapping
slash
antidote
within
the
container
to
the
to
the
root
of
the
curriculum,
meaning
the
git
repo
as
a
whole.
It'll,
actually
map
slash
antidote
to
the
specific
lesson
directory.
That's
loaded,
so
a
syringe
will
keep
track
of
where
each
lesson
lesson
definition
is
and
use
that
as
the
root
quote
of
each
of
each
lesson.
B
B
Obviously
this
is
the
old
version
because
we're
not
on
PTR,
but
if
you
go
to
in
the
new
version
of
the
platform,
what
you'll
see
is,
instead
of
instead
of
the
full
curriculum
when
you
go
to
slash
antidote,
you'll
just
be
DLitt
you'll
just
be
placed
at
this
lesson
directory
within
this
lesson.
Okay,
so
it'll
be
a
little
a
little
more
simplified
nice
now,
naturally,
if
you
still,
if
you
do
want
to
poke
around
at
the
at
the
files
from
other
lessons,
you're
obviously
welcome
to
do
so.
It's
all
on
github.
A
B
Listen,
no
matter
all
right,
as
I
mentioned
before
we
have
device,
we
have
black
boxes
devices
utilities,
and
these
you
know
these
three
things
are
not
they
don't
mean
the
same
things
like
as
I
mentioned.
The
difference
between
devices
and
utilities
is
how
they're
configured
we
fix
the
configuration
aspect
of
things,
but
then
we
have
this
other
thing
called
presently
the
way
these
things
are
presented,
which
is
the
difference
between
devices
and
black
boxes
or
really
utilities
in
black
box.
B
The
only
thing
that
the
fits
different
about
black
boxes
is
that
they're
not
presented
to
the
front
end,
so
they
have
no
presentation
to
the
front
end
at
all.
So,
instead
of
having,
as
I
mentioned,
you're
getting
rid
of
all
three
of
these
keywords,
they're
just
they're
totally
gone,
so
you
could
forget
about
them
in
this
new
version.
Rather,
what
we're
doing
is?
B
So
every
endpoint
has
a
field
called
presentations
which
is
also
optional
kind
of
like
how
configuration
type
is
optional.
Not
every
endpoint
needs
to
be
configured
at
one
time,
sometimes
it's
baked
into
the
sometimes
it's
just
baked
into
the
image.
That's
totally
fine.
Similarly,
not
every
endpoint
needs
to
be
presented
to
the
front-end.
We
still
want
to
preserve
that
functionality.
We
just
want
to
do
it
in
a
way
that
makes
more
sense.
B
One
all
right:
well,
that's
I'll,
continue
to
explain
so
presentations.
This
is
the
canonical
example
like
to
show
a
CLI.
So
what
you
do
is
you
say
you
name?
The
every
presentation
has
a
name
and
that'll
become
obvious
in
a
second,
but
just
suffice
it
to
say
that
we
named
it
CLI
for
now
you
have
to
provide
a
port.
B
Port
on
which
that
that
protocol
is
accessed,
and
obviously
as
a
sage
on
port
22,
fairly
common
now
this
is
this-
is
cool.
It's
just
it's
a
syntactic.
You
know
it's
it's
a
it's!
It's
a
nice
new
way
of
describing
how
to
access
this
particular
endpoint,
but
I
think
this
new
format
becomes
much
more
attractive
when
you
consider
the
use
cases
that
it
unlocks,
for
instance,
as
I
mentioned
there
is
there's
no
need
the
presentations
field
is
not
required.
It's
it's
not
a
required
field.
B
You
can
provide
no
presentations
at
all
and
what
it'll
do
is
it'll,
just
not
present
that
to
the
front
end
and,
as
you
can
see,
we've
done
that
with
the
influx
DB
endpoint
here
so
in
flux.
Db
is
a
time
series
database
and
kind
of
like
in
Derek's
troubleshooting
lesson.
We
want
to
be
able
to
show
in
flux
DB.
We
all
want
the
influx
DB
API
to
be
available
to
the
other
endpoints,
but
we
don't
need
to
influx
DB
itself
to
be
shown.
B
We
just
need
it
to
be
reachable,
and
so
we
declare
it
underneath
endpoints.
We
simply
don't
pass
any
presentations
underneath
it
and
it's
there
now
there's
one
thing
that
I
want
to
call
out
here.
If,
if
you,
if
you
specify
presentations,
what
it'll
do
is
it'll,
when
you
specify
the
port
that
that
presentation
is
accessible
over
port
22,
syringe
will
do
all
the
magic
on
the
backend
to
instruct
kubernetes
to
open
that
port.
If
you
don't
have
any
presentations,
you're
still
gonna
want
a
port
open.
B
So
you
need
to
provide
that
in
this
additional
ports
field.
So
if
you
don't
have
any
presentations
or
even
if
you
do
have
presentations,
but
you
want
additional
ports
open,
you
can
provide
that
as
a
list
here
and
syringe
will
open
those
ports
for
you.
So
just
keep
that
in
mind.
Any
port
you
mentioned
here
is
open
to
automatically,
but
if
you
want
additional
ports
open
use,
you
use
the
additional
ports
field,
also
cool,
but
I
think
the
real
value
is
in
what
I'm
about
is
what
I'm
about
to
show.
B
If
you
go
to
the
Linux
endpoint,
for
instance,
as
I
mentioned,
it
might
be
useful
to
show
the
same
endpoint
multiple
times,
so
you
might
have
noticed
that
the
presentations
field,
the
key
presentations,
has
a
value
and
that
value
is
actually
a
list.
So
it's
not
a
single
presentation.
You
can
provide
multiple
presentations
and
what's
gonna
happen,
is
it's
gonna
provide
it's
gonna
pass
both
of
those
presentations
up
to
the
front
end.
B
B
B
B
So
if
you
look
these
two,
that's
horrible!
If
you
see
these
two,
the
screenshot
here,
you
can
see
that
it
has
multiple
tabs
to
the
same
resource.
So
Linux
is
the
name
of
the
end
point.
If
there
are
multiple
presentations
for
an
endpoint,
the
web
front
end
is
going
to
disambiguate
those
two
presentations
with
the
name
of
the
presentation
itself,
so
CLI
in
this
case
and
in
the
other
tab
CLI
two
two
different
two
different
presentations,
two
different
tabs
to
the
exact
same
endpoint,
that's
pretty
cool
the.
B
Other
aspect
of
this
is
not
only
as
SH
is
supported,
so
you
don't
have
to
say
like
two
tabs
with
SSH.
It
might
be
useful
to
show
an
HTTP
resource
and,
as
you
can
see,
the
only
difference,
there's
really
only
one
difference
with
the
way
that
that's
shown
and
instead
of
using
type
SSH,
you
say,
type
HTTP
still
have
to
provide
a
port,
and
obviously
this
image
has
to
be
offering
some
web
content.
It
has
to
be
running
some
sort.
B
Obviously,
in
this
case
over
port
5,000,
but
that's
what
we're
doing
so.
If
you
look
at
the
the
screenshot
for
that,
you
can
see,
we
have
a
little
self-service
portal
I
built,
and
it's
shown
just
like
any
other
tab
in
the
in
the
the
web
UI
here
now.
The
cool
thing
about
this
is
it's
shown
alongside
the
rest
of
the
lesson
content.
B
So,
instead
of
having
to
open
a
new
tab
to
a
new
resource,
its
contained
within
its
own
tab,
that
you
can
that
you
can
toggle
back
and
forth
from
and
again,
if
you
wanted
to
provide,
say
this
presentation
to
an
endpoint
and
then
have
a
second
presentation,
but
instead
of
using
HTTP,
you
can
use
CLI,
that's
also
supported.
So
not
only
do
you
have
the.
B
Presentations
but
each
presentation
doesn't
have
to
use
the
same
type.
You
can
have
one
be
HTTP
and
have
the
other
be
SSH,
not
sure
I,
don't
think
this
is
gonna
be
supported
initially,
but
because
of
this
framework,
the
next
logical
step
is
to
not
only
support
those
two
presentation
types,
but
also
to
support
VNC
nice,
which
is
which
is
on
the
roadmap.
Now.
The
reason
we're
probably
not
going
to
get
that
done
for
this
release.
B
Is
it's
not
a
simple
matter
of
exposing
the
the
the
field
and
the
abstraction
there's
actually
more
work
to
do
than
that.
The
terminal
functionality
right
now
is
being
offered
of
work
Amole
and
the
the
HTTP
functionality
is
not
offered
over
welcome,
only
that's
done
directly
via
kubernetes
ingresses,
and
so
that
was
actually
much
more
easy
to
add.
The
VNC
functionality
will
actually
also
be
offered
over
guacamole,
but
right
now
the
guacamole
front-end
are
really
that
the
servlet
is
statically
using
SSH.
So
it's
more
there's
more
changes
that
are
needed
there.
B
This
particular
effort
is
meant
to
focus
on
the
abstraction
for
syringe.
So
once
the
abstraction
is
is
appropriate
and
there
will
be
a
place
to
place.
The
VNC
feel
the
sort
of
the
VNC
specification.
Then
we'll
go
turn
our
attention
to
the
servlet
and
make
sure
that
it
supports
VNC
once
it
does,
will
light
up
that
feature
within
the
within
the
abstraction
and
that
way.
You'll
have
three
options.
Instead
of
two.
B
Looks
like
I
have
one
more
screenshot
this
this
kind
of
shows
back
to
the
configuration
portion
of
this.
Instead
of
we
were
talking
about
presentation
for
a
while
there,
but
back
to
the
configuration
portion,
you
can
see
that
we're
spinning
up
config
pods
for
both
the
Linux
endpoint,
as
well
as
a
DQ
effects,
endpoint,
that's
sort
of
what
you'll
that's
sort
of
what
you'll
see.
B
Now,
if
you
poke
around
and
self-medicate
you'll,
see
stuff
like
this,
it
used
to
be
that
you
would
only
see
config
for
like
Network
endpoints,
like
VT
effects,
and
that
would
W
that
then
be
all
you
saw
now.
You're
gonna
see
a
config
endpoint
for
any
and
config
pod
for
any
endpoint.
You
specify
a
configuration
type
for.
A
B
Think
I
mentioned
this
mentioned
this
in
this
issue,
so
the
original
concern
was
that
only
network
devices
were
able
to
spin
up.
Basically
that
you
know
syringe
didn't
allow
connections
to
non
network
devices.
That
was
the
original
concern
and
III.
That
was
very
concerning
to
me,
because
I
didn't
think
that
was
the
case,
so
I
I
did
go
back
and
forth
a
little
bit
with
with
Brian.
It
was
a
very
good
discussion,
because
what
I
discovered
was
while
connections
to
non
network
devices
absolutely
is
supported.
B
B
In
this
answer,
I
illuminate
the
problem
in
syringe
in
the
current
version.
What
it'll
do
is
it'll
say
only
if
there
are
devices
in
the
lesson
will
I
create
connections.
So
it's
a
it's
it's
it's
a
it's
a
small
distinction,
but
an
important
one
connections.
You
know
Multan
care
what's
running
in
the
container
like
at
all.
It
doesn't
matter
if
it's
running
a
network
device
or
not,
it
doesn't
have
any
any
way
of
knowing
that.
Actually,
so
that's
not
the
problem.
It's
not!
That
motors
can't
support
network
devices
it.
B
B
What
is
the
logic
here
is
if
there
are,
if
there
are
devices
in
the
lesson
definition,
then
I
will
create
all
of
the
connections
and
in
Brian's
case
he
actually
didn't
have
any
network
devices
at
all.
What
he
was
trying
to
do
is
spin
up
connections
to
nothing
but
again,
utility
endpoints,
which
again
I'm
trying
not
to
use
that
terminology,
because
it's
going
away,
but
basically
non
network
devices.
So
technically,
it's
supported,
but
because
of
this
logic,
those
those
connections
didn't
like
syringe,
didn't
even
try
to
create
those
connections.
B
B
In
there
at
you
know
ever
I'm,
not
sure
why
I
was
ever
in
there
I'm
sure
I
had
a
good
reason
at
the
time,
but
clearly
I,
don't
anymore.
So
in
the
new
PR.
That's
that's
gonna
solve
all
these
changes.
It's
gonna
implement
all
these
changes.
That
conditional
is
no
longer
there
and
any
connection
that
you
put
into
place
will
be
put
into
place
at
runtime.
So
this
yeah
that'll
tell
gets
washed.
A
B
So
I
think
I
think
it's
a
step
and
certainly
a
step
in
the
right
direction
for
the
I'm
mostly
excited
about
the
HTTP
functionality,
because,
if
you've
paid
attention,
this
is
actually
currently
supported,
but
I
just
don't
talk
about
it,
because
the
way
that
it's
configured
is
pretty
bad.
The
way
that
you
show
iframes
within
you
know
like
a
web.
A
lesson
resource
is
actually
pretty
pretty
gross
and
I've
known
that
I've
been
playing
with
the
idea
for
a
while,
but
it
just
hasn't
worked
well.
I
feel
a
lot
better
about
this.
B
B
I'm
gonna
be
turning
my
attention
to
a
few
of
the
lessons
that
I've
kind
of
kept
on
the
back
burner
waiting
for
this
functionality
to
be
here
and
I'm.
Gonna
use
those
as
a
way
of
sort
of
showing
off
this
functionality.
There's
a
lot
of
people
that
I've
talked
to
that
want
to
build
lessons.
For
instance,
there's
some
folks
that
want
to
build
stuff
around
time,
series,
databases
and
and
and
visualization.
B
You
can't
do
that
with
a
CLI.
You
need
to
be
able
to
show
something
in
the
way
in
you
know
in
a
web
resource,
so
I'm
pretty
excited
about
that
and
then,
of
course
the
configuration
change,
I
think
that's
huge
right
like
not
not
only
supporting
non
Napalm
devices
but,
frankly
being
able
to
configure
anything.
You
want
in
an
arbitrary
way.
Yeah,
it's
gonna,
unlock
I.
Think
a
lot
again
previously,
we
kind
of
had
a
chicken-and-egg
problems
like
look.
B
We
haven't
had
a
need
for
this
yet
because
you
know,
we've
got
a
lot
of
stuff
to
do
and
right
now
it
kind
of
works,
and
that's
that's
true.
We're
getting
to
the
point
now
where
it's
like:
okay,
we've,
we've
we've
kept
this
technical
debt
on
the
books.
For
so
long
now
we
got
to
start
paying
it
off
and
that's
what
this
effort
is
meant
to
do.
It's
meant
to
it's
meant
to
be
the
the
culmination
of
that
initial
trade-off
with
you
know,
actually
addressing
the
problem.
Long
term,
nice.
A
Nice
yeah
I'm,
excited
I
think
this
will
actually
make
it
easier
for
me
to
actually
finish
that
troubleshooting
lesson
or
an
actually
multiple
other
workflow
lessons
that
you
know.
There's
multiple
ideas.
We've
been
talking
about
this'll.
This
will
make
it
a
lot
easier
to
get
those
done
and
yeah
the
workflow.
Lessons
are
really
gonna
end
up
being
the
meat
of
the
matter
on
this
site
where
people
can
actually
see.
A
You
know
something
tangible
right
away,
that
that
does
something
for
them
and
like
in
that
workflow
lesson,
that's
tied
to
all
the
fundamentals
and
having
this
means
there
I
mean
there
are
so
many
things
we
can
do
now
once
and
once
this
is
complete.
So
when
one
should
be
expect
to
see
at
least
some
of
these
initial
changes
being
checked
in
like
and
made
official.
B
So
you
know,
actually:
is
there
I
if
you
I,
gotta
figure
out
what's
going
on
with
PTR,
but
I've
tested
a
lot
of
the
functionality
already
and
it's
there.
I
have
a
few
things.
I
want
to
do
before.
I
merge
it
so
and
of
course,
I've
got
other
things.
I
need
to
do
like
for
those
that
have
been
looking
at
some
of
the
activity
and
in
some
of
our
operational
repos,
you
might
notice
that
we're
doing
a
lot
of
infrastructure
changes
or
at
least
planning
them.
One.
B
A
service
provider
which
is
going
to
be
awesome
from
a
performance
perspective
also
a
very
needed
change,
so
that's
another
one
of
the
big
projects
on
my
plate.
Nevertheless,
the
functionality
for
this
change
does
already
exist.
I
just
need
to
sort
of
check
a
few
T's
and
your
Cross
few
T's
and
dot
a
few
eyes.
I
would
expect,
ideally
by
the
end
of
the
week,
although
I
will
say
stretch,
you
know,
that's
that's
sort
of
a
stretch,
goal
cool,
worst-case
scenario
within
the
next
two
weeks:
nice,
as
you,
as
you
mentioned.
B
This
is
a
very,
very
big
change,
so
I
do
want
to
make
sure.
That's
you
know
properly
tested
and
and
baked
and
I
got
a
you
know
clean
up
some
of
the
things
that
I
was
building
originally
that
I
sort
of
tabled
so
mostly
cleanup
tasks.
The
both
of
the
bulk
of
the
work
is
done,
but
because
of
the
the
sort
of
the
fastness
of
this
change,
I
want
to
be
sensitive
to
how
its
implemented
so
I'm.
A
A
Thank
you
thank
you
for
watching
and
I
I
hope
you're
as
excited
as
we
are
about
the
changes
we
talked
about
today,
they're
coming
soon,
and
they
should
definitely
enable
you
as
a
lesson
creator
to
do
some
amazing
things.
So
please
join
us
tomorrow
for
our
community
stand-up
call
it's
at
8:00
a.m.
Pacific.
We
do
it
at
that
time
because
we
have
community
members,
multiple
community
members
over
in
Europe,
and
that
this
is
a
balance
between
beginning
of
the
day
in
the
end
a
day
and
everyone
in
between
such
as
myself.
So
please
join
us.
A
The
the
details
for
that
are
on
our
on
our
forum,
site,
community
dot
network
reliability
that
engineering
it's
it's
so
head
over
there.
If
you
want
to
see
the
and
just
click
on
that
invite
link
at
8:00
a.m.
tomorrow,
and
you
should
used
to
be
able
to
join
the
stand
up
call
so
once
again,
I'm
Derek
winkworth
a
a
cake
loud
toad
on
Twitter,
and
this
is
Matt,
our
co-host
and
and
and
technical
genius
behind
this,
really
all
the
coding
behind
his
project
he's
at
mierda,
nem,
ier
di
n.