►
From YouTube: IETF94-TUTORIAL-NETCONFbyExample-20151101-1300
Description
NETCONF by Example at IETF94
2015/11/01 1300
A
Okay,
changing
the
subject
to
our
favorite
protocol.
I
got
the
t-shirt
and
everything
same
thing
applies
guys.
This
is
the
first
time
I
do
this.
It
is
working.
Progress
is
also
the
type
of
content
that
we
are
going
to
put
in
the
public
domain,
and
you
guys
saw
the
test
audience
this
time.
It's
about
the
Netcom
protocol.
A
All
right
same
thing
here,
this
presentation
uses
in
this
case
actually
a
set
of
common
kind
of
network
oriented
tasks
that
people
that
run
networks
do
to
walk
you
through
the
features
of
the
Netcom
protocol.
So
you'll
see
a
commonality
here
that
we
wanted
to
try
to
do,
presentations
or
tutorials
that
are
just
not
going
through
or
if
these
top
to
bottom,
that
actually
tie
it
into
a
useful
narrative
or
a
useful
set
of
activities.
And
after
this
presentation,
which
I
think
will
be
a
little
shorter
than
the
yang
one.
A
Unless
you
really
hammer
on
with
questions,
you
will
know
how
to
get
configuration
from
Netcom.
You
know
how
to
actually
configure
things
with
net
cough
and
you
will
understand
how
Netcom
transactions
work.
I
told
you
about
there's
about
Yang,
and
it's
even
more
important
here,
I'm,
not
covering
everything
that
the
net
comforta
Cole
can
do.
It's
actually
large
chunks
that
we
just
don't
have
time
for
I
believe
that
the
full
blown
version
of
this
presentation
will
be
only
order
four
hours
when
we
strive
for
completeness.
A
So
take
this
as
kind
of
an
intro
for
those
of
you
who
haven't
heard
this
before
and
there's
quite
a
bit
of
other
types
of
presentation,
material
and
tutorial
material
available,
including,
of
course,
all
the
way
back
to
the
source.
The
RFC
net
course,
of
course,
is
a
protocol.
It's
been
around
for
a
while
now
as
any
good
protocol.
It's
based
on
a
couple
of
layers.
I
cannot
spend
too
much
time
with
this,
but
some
of
the
terminology
here
is
important
on
the
bottom.
A
A
The
majority
of
the
net
conf
implementations
that
I've
seen
in
the
world
today
uses
SSH.
So
most
of
the
implementations
today
is
actually
traveling
over
SSH,
but
that
doesn't
mean
that
it's
inextricably
linked
with
SSH
in
any
way
shape
or
form,
especially
in
the
beginning,
we
had
grand
plans
about
soap
and
beep
and
all
kinds
of
things
we
may
see,
or
we
will
actually
I
think
we
will
see
TLS
coming,
but
for
now
most
of
the
actual
deployed
equipment
runs
over
SSH.
Then
we
have
a
messages
layer.
So
this
is,
let's
call
it
the
envelope.
A
It's
the
RPC
RPC
reply,
style
messaging
that
you've
seen
before
you
will
see
already
here,
hopefully
that
this
is
actually
the
on
the
wire
encoding
for
Netcom
phys
XML
all
right,
but
that
doesn't
mean
that
you
guys
need
to
know
XML.
There's
a
lot
of
nice
libraries
and
there's
also
or
another
net
conf
like
protocol
called
rest
conf
in
the
making
and
will
probably
extend
their
tutorial
too.
To
add
that
to
where
we
have
JSON,
but
for
net
conf.
We
use
XML.
So
you
have
the
messages,
layer
or
PC
an
RPC
reply.
A
Then
we
have
operations
so
net
confess
a
protocol,
and
this
makes
it
vastly
different
from
things
like
soap
from
things
like
HTTP
from
things
like
beep,
we
actually
describe
a
set
of
base
operations,
so
we
go
far
up
the
stack
compared
to
many
other
things.
So,
the
next
time
people
ask
you:
why
don't?
Why
do
we
use
net
conf?
Why
don't
we
use
just
use
rest?
You
can
tell
them,
because
net
confit
is
a
full
semantic
stack
with
operations
in
it.
Rest
is
an
architectural
principle.
A
You
can
probably
implement
net
comp
like
behavior
using
rest,
but
it's
not
in
rest
itself.
On
the
top
we
have
content.
This
is,
of
course,
where
yang
comes
in
right
when
we
actually
published
the
net
comp
RFC.
The
first
thing
that
we
heard
back
was
nothing
right
because
what's
the
fun
of
a
protocol,
when
you
don't
know
what
you're
manipulating
right,
so
of
course
the
fun
starts
with
the
content.
In
that
comms
case,
it's
the
configuration
data
and
also
the
notification
data.
A
We
won't
talk
about
notifications
today,
but
the
configuration
data
and,
of
course,
that's
what
we
created
yang
for
to
describe
the
same
tax
structure
and
semantics
of
the
content
that
travels
in
at
calm
a
core
principle
of
net
comp,
that
it
also
makes
it
vastly
different
than
many
other
so-called
protocols
is
that
we
have
a
concept
of
data
stores,
I'm
trying
to
use
data
stores.
When
I
can
not
databases,
we
have
a
concept
of
data
stores,
there's
three
of
them.
A
This
far
we'll
talk
about
capabilities,
so
this
would
this
denotes
a
capability
which
means
that
it's
optional,
but
let's
talk
about
all
three
of
them.
Of
course,
the
running
data
store
is
what
reflects
what
the
box
is
doing
right
now.
What
that
actually
means
in
a
router
switch
or
base
station
depends
a
little
bit
on
the
vendor
right.
It
may
take
time
for
your
newly
changed
configuration
to
actually
happen
on
the
firmware,
but
it's
the
representation
of
what
the
books
thinks
is
it's
complete
and
active
configuration.
A
We
have
a
start
up.
Data
store,
that's
a
pretty
obvious
thing.
Usually,
when
you
want
to
snapshot-
or
you
say
that
this
looks
like
a
good
configuration
to
have
when
I
come
up
again,
you
copy
the
content
of
you're
running
into
the
start
up
data
store
so
the
next
time
your
books,
cold
or
warm
boots.
It's
going
to
read
the
startup
configuration
a
key
thing
that
makes
Netcom,
perhaps
a
little
bit
more
interested
depending
on
your
leanings.
Is
the
candidate
data
store
I?
Think
of
it
as
a
scratch
pad
it's
a
global
scratch
pad?
A
But
it's
where
you
actually
start
editing
your
configuration
and
the
cool
thing
here
is
that
with
the
candidate
data
store,
you
can
pre
validate
we'll
get
to
that.
But
you
can
pre
validate
the
configuration
without
affecting
the
running
data
store
in
a
well
implemented
system
and,
of
course
the
communications
between
candidate
and
running.
A
Is
that
when
you're
happy
with
your
candidate
and
we'll
talk
about
these
in
more
detail,
you
do
what
we
call
a
commit
commit
means,
take
the
content
of
candidate
and
make
it
running
very
painful
to
implement
for
those
of
you
who
knows,
and
of
course
you
can
go
the
other
way
around.
So
when
you
start
afresh,
you
start
a
new
session.
You
usually
start
by
copying
you're
running
into
your
candidate.
A
There's.
Nothing
particularly
strange
with
a
basic
napkin
session
like
most
are
PC
based
stateful
protocols
that
go
through
kind
of
three
main
phases.
We
start
a
session
by
exchanging,
what's
called
hello
messages,
we'll
look
at
example
of
this.
Their
cool
thing
here
is
that
the
hello
messages
gives
you
capabilities
exchange,
which
is
also
a
little
a
little
novell,
a
little
new
I
think
for
for
network
management
protocols.
Then
you
go
on
your
merry
way.
You
perform
usually
one
or
more
operations
to
rate
first,
not
conquest.
A
A
So
that's
what's
gonna
happen
in
the
first
phase.
Here
we
do
a
very
thorough
capabilities,
publishing
or
exposure.
So
yeah
I'll
show
you
examples,
so
you
perform
a
set
of
operations
or
series
of
operations
until
you're
happy,
and
then
you
end
your
session.
Of
course
the
well-behaved
client
would
do
a
closed
session.
The
less
well
behaved
client
will
do
a
kill
session
and
the
really
rude
would
just
tear
down
the
transport.
Just
kill
SSH,
it
kind
of
has
the
same
effect.
A
So
here
we
go
with
the
capabilities
right
for
every
new
session.
The
client
starts
with
sending
a
hello.
The
client
actually
sends
capabilities.
If
it
wants
to,
it
doesn't
make
much
sense
actually
in
the
real
world,
but
you
can
send
things
like
what
net
conversion
to
support
the
server
then
responds.
This
is
a
very
I.
Don't
have
time
to
show
you
running
code,
but
this
is
a
very
small
response.
This
is
usually
fairly
large.
What
this
server
tells
the
client
here
is
that
it
supports
net
call
base
protocol
1.1.
A
So
the
client
knows
that
all
the
mandatory
capabilities
or
the
mandatory
functions
in
napkins
is
supported
by
the
server.
It
also
says
that
actually
I
have
writable
running.
You
can
write
straight
into
my
running.
Data
store
and
I
have
a
candidate,
so
this
implementation
actually
has
two
of
the
three
data
stores
that
I
showed
you
on
the
previous
slide.
Now
the
client
knows
right
down
here
and
for
further
study.
A
The
server
also
says
these
are
the
yang
modules
that
I
support
think
about
that
for
a
while,
that's
pretty
cool,
including
the
revision,
and
how
to
how
to
actually
get
a
hold
of
it.
This
means
that
you
can
always
query
a
router
for
the
exact
contract
language,
like
definition
of
the
data
set
that
you
can
manipulate
on
it.
This
has
been
sorely
lacking
in
the
industry
for
a
long
long
while
and
before
we
move
on
I'm
gonna
bring
yes.
A
Features,
yes,
deviations
are
in
the
yang
files
that
you
that
you
look
in
okay.
Well,
they
are
you
see.
This
is
great
they're,
also,
okay,
so
the
actual
editor
of
the
RFC
said
yes,
they're
also
advertised,
so
both
deviations
and
features
that
was
close.
Thank
you
should
prob'ly
put
that
in
the
example.
A
Okay,
some
terminology,
so
this
is
XML
heavy,
but
bear
with
me,
okay,
so
in
net
comp
lingo,
you
remember
this.
This
is
the
RPC
envelope.
Here
are
our
operations,
so
in
this
case
we
use
the
get
operation.
It's
a
basic
Netcom
operation
operations
have
parameters.
In
this
case
we
use
a
filter,
we'll
make
an
example
of
this,
but
I
just
want
to
point
out.
The
lingo
parameters
may
have
attributes
so
we're
gonna
use
a
specific
type
or
filter
in
this
case,
so
operations,
parameters
and
attributes.
A
So
the
first
completely
set
up
question
is
how
do
I
get
all
configuration
and
operational
data
day
to
day
question
right
to
do
this?
We're
going
to
use
two
different
operations,
and
this
is
also
where
net
conf
is
a
little
bit
different
than
other
protocols.
We
make
a
strong
difference
between
the
get
operation
that
actually
returns.
Everything
both
configuration
operational
data.
A
So
if
you
wanna,
if
you
wanna,
if
you
want
to
have
fun,
you
can
take
any
big
router
that
supports
net
Commodore,
get
on
route
and
watch
it
slowly,
keel
over
it's
a
very,
very
heavy
operation
for
most
current
implementations,
because
that
means
it
needs
to
snapshot
all
counters
everything
in
its
entire
system.
It's
comparable
to
a
single
single
call
snmpwalk
for
the
entire
mid-set.
Okay,
so
don't
do
it
yet
until
they
got
their
coding
in
in
order
the
gap
config
operation
only
actually
only
fetches
the
configuration,
so
this
is
probably
more
useful.
A
Typical
use
would
be
a
backup.
Actually.
The
semantics
of
this
is
such
that
you're
supposed
to
be
able
to
say,
get
config,
get
the
data,
put
it
to
the
side
and
at
any
point
in
time
later,
as
long
as
the
router
or
the
books
runs
the
same
yang
models,
you're
supposed
to
be
able
to
just
dump
it
back.
So
we
can.
We
can
say
it's
reliable
backup
and
restore
much
different
from
the
way
we've
done
it
with
CL
is
an
SNMP
okay,.
A
So
here's
an
example:
all
RPC
messages
have
an
ID
we
actually
use
the
base
net,
conf,
namespace
or
namespaces
is,
is
all
over
the
place
here.
Nothing
strange
to
do
a
gift,
there's
no
parameters
to
get
which
means
you're
doing
the
thing
you
shouldn't
be
doing
and
you
get
an
entire
set
of
data
returned
in
a
data
envelope.
Okay,
very
straightforward,
a.
A
More
realistic
get
response.
Actually
this
comes
out
of
our
previous
example.
Is
this,
but
it's
it's
a
very
made-up.
It's
as
if
this
box
only
has
two
interfaces
and
only
running
ipv6,
but
as
you
can
see
this
data,
then
it's
the
same
that
we
looked
at
for
the
example
in
yang.
Maybe
the
things
to
think
of
here
is
that
this
is
where
you
start
seeing
the
namespaces
right.
This
is
the
namespace
from
the
yang
module
for
the
AF
types.
This
is
the
ITF
IP,
namespace
and
so
forth.
A
Okay,
so
of
course
our
eager
network
person
wants
to
know
how
to
filter
data
instead
of
just
get
everything
right,
so
both
they
get
or
and
the
gate
config
operations
have
a
filter
parameter.
There
are
two
types
of
filters:
there
is
a
simple
subtree
filter
which
I
believe
is
actually
mandatory.
So
it's
a
way
of
pointing
out.
This
is
the
path
to
which
I
want
to
see
everything
below
that
for
the
more
adventurous
implementers.
You
can
also
have
filter
type
X
path,
and
that
puts
you
in
a
whole
different
situation.
A
A
So
here
we
go.
We
send
the
following
message,
because
we
want
to
see
just
the
interfaces
list,
so
we
have
a
gift.
We
have
the
parameter,
filter
type
sub
tree,
and
what
we're
saying
here
is
that
we
only
want
to
see
what's
under
interfaces.
Okay,
this
is
the
if
you
like
the
sub
tree
criteria.
I
should
probably
make
it
into
one
element
and
here's
the
response
message,
and
it
throws
back
at
me
that,
based
on
the
filter
from
this
namespace
here
is
the
only
interface
that
I
have
it's
called
eth0.
A
A
Okay,
so
that's
that
about
getting
get
config
and
filtering
now.
How
do
we
manipulate
configuration?
So
in
this
case
again
we're
gonna
borrow
from
a
previous
example:
gonna
enable
and
configure
ipv6
addresses
for
the
interface
to
new
operations.
Here
edit
config
is
the
big
tool
to
actually
manipulate
data
on
boxes,
so
we're
going
to
edit
data
for
content,
but
you
guys
now
know
that
there's
three
data
stores,
so
we
may
need
a
target
parameter
to
specify
which
data
store.
A
A
So
here's
the
actual
payload
to
do
what
we
did
as
an
example
in
the
previous
in
the
yang
session,
so
edit
config
target
running
right,
so
no
candidate,
just
no
candidate
subtleties,
just
straight
into
running.
We
know
what
we're
doing
config
envelope,
and
in
this
case
we
know
that
what
we
are
going
to
change
is
in
the
interfaces
subtree-
and
this
is
the
this-
is
the
namespace
for
that
on
our
interface.
For
this
to
be
actually
valid.
A
Of
course,
we
need
to
send
the
key,
so
we
need
to
say
that
for
this
member
of
this
tree
eth0
make
it
enabled
okay.
So
this
is
the
edit
config
content
to
do,
or
we
mentioned
the
yang
module,
but
that's
too
easy
for
our
adventurous
programmer
here
he
wants
to
use,
she
wants
to
use
edit
config
on
candidates.
First
of
all,
as
I
said,
you
have
to
check
the
fact
that
the
book
supports
the
candidate
capabilities.
You
have
to
look
in
the
hello
message
to
see.
Thus
these
books
actually
support
candidate.
A
If
it
does
here's
what
you
need
to
do.
First
of
all,
it's
good
form
to
clear
out
the
candidate.
As
I
said,
the
candidate
is
global.
There
may
be
lingering
data
in
it
that
someone
else
didn't
clean
up
after
them.
You
edit
the
candidates,
so
it
looks
like
the
way
you
want
it
to,
and
then
you
commit
it
again,
which
means
that
you
move
the
content
of
it
into
the
running
data
store.
A
B
Sorry
question
pauses:
I
had
a
configuration
so,
but
not
yours,
either
configuration
to
configure
the
configuration
to
total
servers
do
I
need
a
tool.
You
look
at
config
first,
because
we
added
a
configuration.
Maybe
does
the
configuration
of
the
server
may
be
changed
so
better
I
need
a
tool.
First,
cattle
coming
Edition
and
as
an
added
to
the
server.
A
B
A
So
here's
the
edit
config
our
first
step
in
that
3-step
thing,
so
we
had
any
confident
and
elates
saying
content
that
you
saw
before
and
then
we
commit
that's
that's
the
basic
difference
and
the
commit
step
if
I
didn't
mention
that
before
is,
of
course
a
transaction.
So
when
the
box
returns
that
your
commit
was
successful,
it
is
supposed
to
be
successfully
running
in
running.
If
something
happens,
while
applying
it,
you
should
have
your
candidate
intact
and
you
can
use
other
things
like
validate
or
change
what
you
have
any
candidate
and
retry.
A
Okay,
now,
three
slides,
that's
what
it
was
locking
I,
don't
want
others
to
change
the
configuration
while
I'm
editing
it
right.
You
don't
want
you
don't
want
bad
fall
outs
from
race
conditions.
We
will
use
a
couple
of
new
things,
actually
we're
getting
closer
to
another
full
set
of
operations
that
will
give
you
two-phase
commit
like
transactionality.
A
The
new
operation
here
is
that
we
will
use
a
locking
operation
you've
seen
delete.
Now
you
have
you
haven't
seen
any
config
you've
seen
edit
config
you've
seen
commit
and
then,
of
course,
to
close
it
off.
We
will
unlock
the
databases
that
we
needed,
so
here
we
go
a
good
gentlemen.
Will
then
log
in
or
in
the
first
thing
to
do
in
the
session
is
to
look
so
we
have
a
target
here.
Of
course
you
don't
want
to
lock
the
entire
thing
in
this
case.
A
A
A
Validation
and
rollback,
in
this
case
we
will
use
a
new
operation
called
validate,
so
we
will
validate
the
content
of
a
datastore,
which
means
that
you
will
ask
the
system
to
do
whatever
it
can
in
the
back
end
to
make
sure
that
first
of
all,
it
complies
with
the
yang
but
may
be.
Oh,
there
are
also
other
stuff
right.
Is
the
temperature
in
the
chasis
such
that
you
can
do
this
change
and
then
we're
going
to
use
something
called
a
confirmed,
commit
now?
That's
a
that's!
A
that's.
A
A
hint,
that's
called
confirm
commit
confirm
commit
is
a
particular
type
of
commit.
There
are
two
new
parameters
that
we're
going
to
talk
about
here.
One
is
a
persist,
parameter
to
specify
a
commit
identifier,
so
a
unique
identifier
for
a
particular
commit
like
you
can
use
later,
and
the
other
one
is
a
confirmed
timeout.
So
what
confirm
timeout
means
is
that
unless
you're
back
to
confirm
the
confirmed
commit-
or
we
call
a
confirming
commit,
the
box
itself
will
roll
back
okay.
A
A
If
this
is
okay,
then
you
can
proceed
to
the
commit
state
and
here's
the
confirmed
commit.
So
the
new
things
here
are
the
parameters
we
have
the
confirmed
element.
We
are
sure
that
you
know
if
something
goes
wrong
inside
of
the
next
ten
seconds
it
needs
to
roll
back.
If
it
survives
10
seconds
we're
fine.
A
This
would
have
saved
me
in
1998
from
taking
out
half
of
Sweden,
for
example,
by
mistyping
AC
else,
and
locking
myself
out
of
some
core
routers
because
had
I
done
this
with
a
conference
I'm
out
I
couldn't
come
back
and
confirm
the
commit,
so
it
would
have
rolled
back
and
saved
me
a
crazy
car
ride,
and
in
this
case
we
also
send
the
persist.
Id.
A
So
that
means
that
you
can
forget
about
the
timer
you're.
Now
can
can't
forget
that
state
and
you're
running
okay,
we're
getting
closer
to
the
final
crescendo
here.
Is
configuring
multiple
devices?
So
in
this
case
our
network
engineer
wants
to
configure
multiple
devices
at
once
and
rollback
everything.
If
anything
fails
right.
So
yeah
you
set
up
a
VPN.
A
If
anything
fails
on
any
of
the
participating
boxes,
you
want
all
of
them
to
reliably
come
back
to
where
they
were
before
I
started,
meddling
with
them
same
steps
as
in
the
previous
example,
but
we'll
do
it
in
parallel
with
one
stop
along
the
way.
So
this
allows
for
two
phase
commit
transactions
over
network
devices,
given,
of
course
that
devices
do
work
actually
has
the
capabilities
that
is
required
for
all
these
steps.
A
A
So
let's
say
you
have
an
alarm
system
on
the
side
that
suddenly
gets
a
trap
rather
the
year.
They
would
need
to
be
some
sort
of
a
channel
between
that
alarm
system
and
whatever
client
is
actually
doing
it,
see
what
I
mean.
There's
no
way
for
you
as
a
third
party
to
come
in
and
say
stop
what
you're
doing.
Okay,
unless
you
know
of
the
transaction
ID.
Actually,
then
you.
B
A
Okay,
so
here's
the
preparer
face
for
you
for
the
people
with
some
database
background,
so
three
devices
right
step.
One
prepared
and
prepare
this
case
means
that
you
look
everything
clear
the
candidate
edit
the
candidate,
and
then
you
validates
all
right
so
now
you
know
that
the
content
that
you
have
in
the
candidates
is
validated
by
the
books.
A
So
that's
a
traditional
preparer
face
all
the
subscribers
or
all
the
members
in
the
transaction
have
said
what
you're
telling
me
looks
good,
okay,
if
any
of
the
devices
here
say
well,
Act
you
just
gave
me
garbled
inputs,
you
can
just
mm
to
the
candidate
and
unlock
the
data
store
and
go
back
and
think
about
what
happens.
Okay,
so
nothing
has
actually
been
done
to
the
running
data
store.
Yet,
but
again
the
devices
have
told
you
that
what
you're
asking
me
to
do
looks
reasonable
and
then
you
commit.
A
Then
you
probably
do
a
confirm
commit
here
because
of
course,
while
the
data
that
you
send
to
the
box
will
be
semantically,
it's
syntactically
and
structurally
valid,
it
may
be
wrong
right.
You
may
have
the
wrong
bgp
parameter,
so
your
neighbor
doesn't
come
up.
You
may
have
the
wrong
VPN
endpoints,
so
there's
no
data
flowing
right.
So
between
the
step
of
a
commit
and
a
confirming
commit,
you
can
go
ahead
and
do
whatever
burn
in
or
feature
tests
that
you
that
you
need.
A
So
you
will
have
a
timeout
that
is
appropriate
for
whatever
you're
going
to
do
and
if
any
of
those
fails,
if
something
you
know,
there's
no
there's
no
Carrier
Ethernet
that
the
inter,
inter
frame
delay,
is
too
high.
So
that's
not
gonna
work.
All
you
have
to
do
is
well.
If
you're
rude,
you
can
just
kill
the
session
because
a
killed
session
on
a
confirm
or
come.
A
It
actually
means
roll
back,
and
you
just
kill
the
sessions
or
close
the
sessions
on
all
devices
and
they
will
reliably
roll
back
so
you're
back
to
where
you
were.
If
they
all
work,
then
you
can
reliably
just
confirm
the
commits
and
then
unlock
the
data
store.
So
this
will
formally
protect
you
from
the
common
mistakes
that
we
all
do
in
the
sense
that
it
provides
two
phase
commit
based
transactions.
A
B
A
B
A
That
is
a
universally
challenging
thing,
and
it's
not
new
for
net
conf
or
for
yang.
For
that
matter.
It's
a
tough
thang,
but
what
kiri
diese
don't
use
anything
else?
It
depends
on
so
either
from
from
observation,
because
the
company
that
I
work
for
use
to
cell
navcom
service
into
people
running
or
building
network
equipment,
there
are
two
kind
of
ways
of
going
about
it.
The
one
is
to
take
the
step
and
say:
look.
The
Netcom
server
actually
owns
the
data
right,
so
everything
that
happens
to
that
data
mean
needs
to
be
conforming
with
yang.
A
That's
what
cleanslate
implementations,
to
put
it
mildly
right
when
you
have
a
green
field,
the
other
one
is
to
actually
try
and
separate
them
based
on
what
is
is
that
you
want
to
do
so.
You
have
napkin
for
certain
things,
and
then
you
have
the
others
for
other
things,
and
you
hope
that
there's
no
interaction
between
them.
B
B
A
B
Similar
thing
with
routes,
we
have
static
routes
which
are
done
through
net
cons
and
BGP
routes
that
are
not
done
through
net
cons,
and
you
know
exactly
what
you
said:
time
scales,
it's
dynamic
and
so
on
and
they're
separate,
so
I
don't
know.
If
you'd
call
the
BGP
routes
operational,
you
can
read
them,
but
but
you
definitely
don't
configure
them
any
routes
that
you
configure
are
static
routes.
At
least
this
is
how
we
work.
B
A
A
third
type
right,
config
non
config,
operational
and
ephemeral
yeah.
It
might
be
appropriate
as
a
sort
of
an
concluding
remark
is
that
again
and
thank
you
for
patients.
This
is
a
pretty
basic
and
straightforward
tutorial
style
presentation.
So
don't
take
away
from
this
that
we're
not
doing
other
things.
We
are
doing
a
whole
lot
of
other
things
in
the
ITF,
both
around
protocol
development
and
certainly
around
the
yang
language
itself
and
modules.
So
this
is
this.
Is
the
entry
level
welcome
to
NAV,
configure
and
kind
of
kind
of
presentation?
A
And,
of
course
you
are
all
now
able
to
obtain
configuration,
configure
network
devices
and
explain
to
someone
how
Netcom
transactions
work,
how
am
I
on
time,
yeah
officially
dangerous.
You
can
now
shoot
yourself
in
the
foot
using
two-phase
commits
if
there's
no
other
questions.
Thank
you
guys.
That's
it
for
this
time
and
no
wait.
Here's
what
want
to
do!
Here's!
What
we
want
to
do.
We
want
to
send
the
link
to
the
evaluation.
Don't
we
for
the
EDD,
you
team,
there
is
really
there
is
one!
Yes,
yes,
how
do
we
do
that?
A
It's
pretty
pointless
to
put
it
up
on
the
projector.
There
is
an
evaluation
link
on
the
agenda
for
this
item.
Please
again,
the
the
the
the
usefulness
for
me
is,
if
you
guys
rip
into
what
I
just
did
and
help
me
make
this
much
better.
So
I
can
iterate
over
the
content.
Many
many
many
times
go
ahead
and.