►
From YouTube: NMRG Interim Meeting, 2020-07-22
Description
NMRG Interim Meeting, 2020-07-22
B
A
So
welcome
everybody.
My
name
is
walter
cerrone
from
the
university
of
bologna
in
italy,
and
I
am
going
to
present
to
make
introduction,
let's
say
to
this
akaton
session
during
the
ietf
108
this.
This
akaton
session
comes
from
the
activity
that
myself,
with
david
bursati
from
unesco,
bologna
and
malcolm
garbowie,
and
barbara
martini
from
cnit.
A
In
particular.
The
the
topic
of
this
session
is
a
multi-level
approach
to
ibm
to
interdependent
turkey,
and
basically
the
idea
is
to
try
to
understand
if
it
makes
sense
and
if
it's
possible
to
build
an
intent-based
networking
system
where
you
can
express
intent
at
different
levels,
because
you
may
have
different
needs
and
also
because
different
stakeholders
are
involved
in
the
in
the
objectives
that
you
want
to
achieve.
A
Any
suggestion
on
how
to
improve
things
so
also
any
critique
or
any
remarks
that
you
may
have
on
what
we
are
doing
and
also
there
are
several
points
that
are
still
missing
in
our
implementation.
So
we
also
discuss
this,
meaning
that
there
are
several
components
of
an
intent-based
networking
system
that
we
still
have
to
develop
and
then
any
experience
and
idea.
Any
contribution
from
from
people
interested
in
working
together
would
be
more
more
their
work.
A
So
what
is
an
intent
based
network
issues?
Let's
just
find
some
common
definition,
and
you
know
some
common
ground,
because
everybody's
been
talking
about
about
intent
based
systems
in
the
past
few
years,
and
actually
we
could
say
that
the
the
most
common
definition
is
that
you
with
an
intent
you
actually
when
you
apply
the
intent
to
the
network,
in
particular
the
network
management.
A
You
just
want
to
tell
the
network
what
you
want
to
achieve,
instead
of
how
you
want
to
achieve
this.
So
basically,
you
you're
moving
from
a
prescriptive
approach,
which
is
typical
of
traditional
network
management
and
configuration
system
where
you
have
to
follow
some
kind
of
recipe
to
configure
and
deploy
services
and
again
configuring
network.
A
A
A
Of
course,
something
like
a
piece
of
networking
software
that
can
help
they
can
help
to
the
to
plan
this
design
and
implement
or
operate
the
network
through
some
sort
of
life
cycle
management,
software
for
network
infrastructures
and
also
something
that
allows
you
to
automate
the
orchestration,
of
course,
using
software
platforms
and
taking
into
account,
of
course,
several
several.
Let's
say,
systems
that
subsystems
that
need
to
monitor,
identify
and
react
in
real
time.
A
What
is
what
are
the
the
network
conditions
that
can
be
changing
and
then
in
order
to
also
learn?
So
that
is
also
mentioned
on
some
something
someone
mentioning
machine,
learning,
algorithms,
because
learning
is
also
an
important
part
of
the
of
the
our
intern
based
networking
system,
at
least
as
a
common
understand,
actually
the
after
the
all
these
discussions
that
have
been
going
on
in
the
past
few
years,
the
network
management
research
group
of
the
irtf
is
working
on
this.
There
are
several
people
involved
in
this
activity
and
they
within
the
group.
A
I
think
some
of
the
authors
of
those
graphs
are
also
here,
but
they
are
part
of
the
nmrg,
so
they
can
perfectly
talk
much
but
much
better
than
me
about
about
this
job,
but
I
would
like
to
borrow
from
the
the
the
draft
on
concept
and
definition,
because
this
is
what
that
draft
define
as
an
intent,
so
a
set
of
operational
goals
that
a
network
should
meet
and
outcomes
that
the
network
is
supposed
to
deliver
defined
in
a
declarative
manner
without
specifying
how
to
achieve
or
implement.
So.
A
A
The
keywords
here
are
basically
the
desired
outcome.
If
you,
if
you
read
through
the
the
draft,
there
is
also
very
interesting
discussion
about
what
is
an
intent
compared
to
policy-based
management
and
service
models,
and
you
can
see
that
the
idea
of
this
desired
outcome
is
basically
the
key
pump
here.
A
A
Again,
there
are
a
lot
of
concepts
here.
There
are
a
lot
of
important
aspects
that
I'm
not
going
to
not
going
through,
because
it
will
take
a
lot
of
time
to
discuss
this
and
they
are
discussing
the
draft,
but
just
to
let
you
know
you,
we
basically
are
working
partially
on
the
the
translation
or
ibs
space
that
you
can
see
in
the
center.
Actually,
we
are
not
exactly
doing
translation.
A
A
Translation
is
something
different,
something
more
because
it
requires
some
sort
of
understanding
of
a
high-level
common
language
which,
for
instance,
is
one
of
the
the
aspect
that
is
still
that
are
still
missing
in
our
in
our
implementation
and
again,
this
would
be
one
of
the
of
the
interesting
points
that
we
welcome.
Contribution
for
also
the
departure
are
related
to
learning
and
planning.
This
is
something
that
still
needs
to
be
developed.
A
A
Very
important
is
also
the
bottom
part
of
the
of
the
life
cycle,
where
you
have
all
the
monitoring
observation,
validation
and
reporting
to
the
to
the
user
about
the
intent.
This
is
another
point
that
still
requires
work,
at
least
in
our
in
our
implementation.
Again,
any
any
idea
any
help
any
feedback
on
a
possible
contribution
if
you
are
working
on
this
will
be
more
modern
work.
A
So
we
consider
the
case
where,
with
this
virtualized
infrastructure,
we
can
have
different
partitions
different
slices,
starting
from
a
common
infrastructure,
physical
infrastructure.
So
the
idea
is
to
consider
the
approach
of
the
intent-based
intern
based
system
applied
at
different
levels,
so
starting
from
an
infrastructure
provider.
That,
of
course,
has
knows
all
the
details
of
the
the
figure
infrastructure
and
whatever
is
that
they
are
running
on
their
on
their
infrastructure.
A
They
they
want
to
deploy
and
running
their
applications,
and
this
is
at
the
second
level,
the
higher
level
of
intent,
because
this
is
where
the
actual
service
requested
required
by
by
a
customer
is
going
to
be
specified
as
a
sort
of
intent.
So,
basically,
the
idea
is
to
try
to
understand
how
we
can
apply
this.
A
C
Yes,
I
open
my
okay,
I
can
nothing
to
add
to
this
slide.
You
gave
comprehensive
description
of
the
involved
stakeholders
and
the
correspond
rich
of
those
involved
stakeholders.
Basically,
we
have
the
different
levels
of
ibn.
We
want
to
present
in
the
demo
so
to
agree.
We
can
move
on
to
the
next
slide.
So
more
precisely.
C
C
C
Okay,
so
we
have
a
slice
component
at
the
level
of
infrastructure
provider
and
the
slice
component
at
the
level
of
a
service
provider
to
highlight
that
the
service
providers
use
slices
from
the
infrastructure
provider
to
deploy
customized
network
services
for
their
customer,
such
as
virtual
infrastructures
with
mobile
or
satellite
capabilities,
because,
typically
in
in
our
scenario,
we
are
considering
a
service
provider.
We
have
in
mind
service
providers
such
as
mobile
virtual
network
operators
or
service
providers,
service
virtual
network
operators.
C
C
D
C
C
Running
on
top
of
layer,
4
layer,
7
virtual
function,
so
indication
on
how
traffic
flows
should
traverse
the
sequence
of
service
component
running
into
the
slides
into
the
slides
where
service
component
is
strictly
mean
the
layer,
4
layer,
7
virtual
function,
so
I
I
think
we
can
move
to
the
next
slide
with
more
detail.
If
there
are
questions,
of
course,
I
can
take
it.
A
A
We've
been
implementing
it
in
in
some
platform
to
basically
to
to
towards
the
the
nfv
scenario.
So,
basically,
we
use
use
virtual
network
infrastructure
based
on
mostly
on
openstack.
We
are
also
working
on
the
idea
of
using
also
kubernetes,
and
this
is
feeling
progress,
but
we
use
openstack
as
a
virtualized
infrastructure
manager
to
to
manage
the
the
the
virtual
infrastructures.
A
You
see
that
the
wind,
the
wider
network
infrastructure
manager
is
attached,
because
this
is
also
something
that's
still
missing,
that
we
are.
We
are
still
working
on
on
this,
and
on
top
of
that,
we
need,
of
course,
an
orchestrator
for
this,
and
and
we
we
use
open
source
panel
as
a
enabled
orchestrator
for
for
doing
this,
and
this
is
basically
the
those
are
basically
the
platform
that
that
we
are
using
to
to
run
our
demo
or
demonstration.
A
On
top
of
that,
we
have
it's
not
shown
actually
here,
but
we
have
some
customized
software
layers
that
are
going
to
expose
the
internet
interface.
So
basically
we
call
it
intent
layer
and
where
is
basically,
we
send
the
request
formalized
I
mean
the
intent
that
expresses
the
request
formalized
in
a
format.
A
A
Basically,
what
we
want
to
do
today
in
this
academic
session,
we,
of
course
we
want
to
show
you
the
proof
of
concept
of
this
multi-level
approach
to
ibn,
as
I
said
in
an
nfb
web
framework,
so
we
are
going
to
demonstrate
how
we
set
up
live
intent
and
how
we
can
also
set
up
one
of
two
service
intent
service
chain.
Intents
on
top
of
that-
and
we
do
that
in
a
very
simple
scenario,
where
we
are
a
single
beam
or
single
point
of
presence.
A
Which,
of
course,
need
to
be
extended
also
in
another,
more
general
scenario,
which
would
involve,
for
instance,
the
wim,
the
wider
network
infrastructure
manager,
which
will
involve
some
sort
of
interaction
with
the
transport
network.
Those
are
still
open
issues
that
again
we
we
would
like
to
have
any
any
feedback
or
any
idea
or
suggestion
from
from
anyone
who
is
actually
working
on
that
also.
A
And,
of
course,
we
again,
we
would
like
to
have
feedbacks
on
possible
issues
and
contributions
for
further
developing
this.
This,
this
proof
of
concept,
for
instance,
extended
implementation
to
a
more
complex
scenarios.
I
already
say
that
also
developing
missing
components,
anything
related
to
the
translation
from
higher
level
languages,
the
validation
and
monitoring
of
service
and
all
those
aspects
that
we
still
have
to
implement,
of
course,
and,
as
I
said,
also
interactions
with
the
transport
network.
A
So
after
the
demonstration
I
hope
we
will
have
enough
time
to
have
a
discussion
and,
in
the
let's
say
the
for
the
sake
of
a
real
hackathon
event,
if
possible,
try
to
set
up
a
collaboration
either
today
or
maybe
in
the
next
few
days
or
even
in
the
future.
If
so,
it's
something
that
requires
more
more
discussion
and
more
interaction
in
order
to
to
try
to
come
up
with
an
improvement
of
of
our
of
our
system.
A
B
A
A
A
Now
the
service
provider,
it
can
be
either
the
same
entity
as
the
infrastructure
provider
or
could
be
something
different.
So
if
the
service
provider
is
a
virtual
network
operator,
then
is
the
one
that
is
receiving
the
request.
The
intent
request
from
the
customer
and
then
the
service
provider
itself
that
wants
to
have
access
to
the
infrastructure
is
going
to
send
an
intense
slice
intent
to
the
the
infrastructure
provider.
So
this
is
how
we
we,
we
see
the
different,
the
different
levels.
E
A
It
could
be,
I
mean
if,
when
you
we
will
show
the
demonstration
we
actually
we
have.
We
have
first,
the
service
provider
asking
the
the
slice
intent
to
the
infrastructure
provider
because
he
wants
to
set
up
a
network,
a
virtual
network
and
then
it's
going
to
offer
services
to
the
to
the
to
the
customer.
So
you
will
see
that
in
two
steps.
A
A
F
B
F
A
B
C
C
F
A
A
C
C
So
for
the
needs
of
this
demo,
we
have
further
simplified
the
intense
template
and
we
kept
only
three
main
information
which
are
the
id.
The
number
of
visual
network
functions
in
this
slide
and
the
number
of
other
functions.
The
other
parameters
that
I
have
showed
before
are
considered
as
a
static
and
we
have
set
them
up
within
the
template.
C
C
F
For
now,
and
so
I'm
going
to
briefly
present
the
service
chain
intent,
which
is
the
intent
that
the
user
can
use
to
express
a
request
for
a
service
as
a
sequence
or
a
chain
of
service
component
running
on
top
of
like
the
v,
the
vnf
of
that
we
deployed,
for
example,
during
this
license
that
moreca
showed
you
so
in
the
next
slide.
We
see
how
it
is
like
composed.
So
again
is
the
json,
which
you
have
the
first
parameter,
which
is
simply
the
name
of
the
service.
F
The
intent
layers
that
you
see
here
refer
to
an
older
document
of
the
an
mrg
group,
but
we
decide
to
keep
it
that
way,
because
it
could
be
any
way
mapped
to
the
life
cycle.
That
walter
showed
the
one
of
the
first
lights
and,
as
you
can
see,
right
now
is
just
like
a
simple
mapping
so
taking
the
values
inside
the
json
and
trying
to
map
them
directly
onto
the
resources
available
on
osm
or
on
the
openstack
below.
F
F
So
in
next
slide
you
we
have
a
brief
representation
of
openstack,
which
is,
I
think,
that
most
of
you
already
know
what
it
is,
but
is
just
like
the
one
of
the
most
famous
infrastructure
as
a
service
cloud
platform
and
is
being
used
in
different
scenarios
from
research
to
commercials,
and
it
provides
different
types
of
services
such
as
computing
capabilities,
virtualized,
networking,
storage
and
more
and,
as
you
can
see,
from
the
figure
we
are
using
it
as
the
vm.
So
the
virtualized
infrastructure
manager
for
our
demo.
F
F
Okay,
this
is
the
very
briefly
the
intent
processing
flow
diagram
on
the
left.
We
see
the
flow
diagram
for
the
slice
intent
which
we
have
the
users
that
request
for
a
particular
slice
using
the
intent.
The
intent
layer
will
then
trigger
the
correct
natural
service
creation
on
osm,
which
again
will
trigger
the
deployment
of
that
particular
network
services
on
top
of
the
desired
vm
or
in
this
case
openstack
and
then
on
the
right.
We
have
the
flow
diagram
for
the
service
chain.
F
F
B
E
A
Okay,
yeah,
if
I
can
also
add
something
that
the
discussion
was
definitely
on
the
on
the
point.
So
so,
basically,
what
we
are
considering
with
our
json
based
expression
on
the
intent
is
that
we
want
to
express
something
like
okay.
We
know
that
the
the
the
slides
or
the
platform
in
general
is
providing
functions
like
a
firewall,
a
load
balancer,
some
other
components.
A
So
basically
the
intent
here
that
can
be
definitely
see
as
a
low
level.
Intent
is
okay.
I
want
a
service
that
needs
to
be
deployed,
including
a
firewall,
a
dpi
and
then
in
a
given
order,
and
maybe
we
can
also
decide
to
say
okay,
I
want
this
to
be
applied
only
to
uplink
traffic
bro
or
maybe
to
to
both
uplink
and
and
downlink.
So
this
is
basically
the
the
meaning
of
of
those
those
specifications
that
we.
F
A
Yeah,
so
that's
why
I
was
talking
at
the
beginning
of
a
mapping,
because,
basically
you
know
what
what
the
system
offers
you
and
then
you
map
your
let's
say,
need
into
how
you
can
compose
the
service.
But
this
is
what
is
definitely
needed,
and
many
was
perfectly
right
with
that
is
we
need
to
have
a
link
to
someone
stating
or
declaring
an
intent
at
a
very
high
level,
maybe
using
some
sort
of
natural
language,
something
like
this
and
then
try
to
to
translate
it
into
what
we
are
showing.
A
B
Yeah,
I
can
send
you,
I
can
send
you
a
link
to
a
paper
when
you
can
talk
about
this,
and
I
can
send
you
a
link
to
a
paper
navid
who's
attending.
The
meeting
today
has
presented
this
year
actually
for
automating
this
mapping
from
a
high
level
requirement
from
a
functional
like
what
are
the
functions
you
need
and
the
non
and
the
quality
of
services
and
the
mapping
is
done
with
the
help
of
an
ontology.
A
F
F
G
You
may
have
a
kind
of
network
wide
policies
that
all
of
the
slides
that
have
to
go
to
fireball
or
something
like
that
you
know.
So
there
is
a
question.
If
all
of
these
things
are
the
service
parts
of
the
service
intents
or
would
they
be
some
kind
of
network-wide
policies
as
well?
So
you
could
maybe
look
at
that
approach
as
well
going
forward.
F
Yeah,
we
were
also
starting
to
study
the
the
draft
related
to
the
different,
like
intent,
specification
classification
that
we
have
so,
of
course,
right
now.
What
we're
showing
is
limited
to
a
simple
is
like
limited
to
the
service
itself,
not
to
the
overall
like
network
wide,
as
you
suggested,
but
of
course
it
would
be
interesting
in
the
future
to
also
try
to
explore
different
classification
of
intent.
For
example,
the
network
wide
one
that
you
suggested.
F
H
F
F
F
C
Yes,
by
network
components
in
one
opencl
switch
to
which
the
three
applicative
resource
functions
are
directly
connected
within
the
site.
We
have
also
one
sdn
controller,
which
is
follow
responsible
of
managing
the
network
components
and
for
the
applicative
functions
we
have,
they
are
only
named
tribal
dpi
and
low
balancer
and
also
they
are
automatically
configure
it
as
their
deployment.
F
Yeah,
okay,
so
this
the
machines
are
up
and
running,
as
you
can
see
here,
which
is
like
the
another
topology
that
openstack
is
showing
us,
and
here
on
the
right.
You
see
the
data
net
of
the
slides,
so
the
what
that
we
will
use
to
to
move
the
traffic
between
the
different
bnf
and
on
the
left,
the
management
network
that
we
will
just
use
to
access
them.
F
F
You
can
see
here.
This
is
exactly
the
json
that
we
are
going
to
use
for
launching
the
first
chain
that
I'm
going
to
remind
you,
will
be
the
blue
one,
so
we
will
launch
a
source
of
destination
simply
again
for
having
like
the
source
of
and
the
destination
of
the
traffic.
We
want
to
force
through
this
path
and,
as
you
can
see,
it
will
cross
all
three,
the
applicative
vnf
and
in
fact,
if
you
go
back
to
the
intent,
you
see
that
there
are
three
elements
inside
this
list.
F
F
F
F
F
F
So
this
is
the
list
of
service
chain
currently
present
inside
of
openstack.
We
save
that
we
have
the
the
one
that
we
just
created
so
the
chain
for
service
a
which
is
composed
of
three
elements
here,
to
exactly
prove
that
these
three
numbers
are.
The
related
to
the
three
applicative
function
is
a
bit
complicated,
so
I
we
will
just
go
through.
F
D
F
F
F
F
F
F
F
F
F
Also
in
on
the
firewall.
We
see
a
packet
coming
in
and
going
out
from
the
same
interface
on
the
on
the
first
path
and
then
on
the
reverse
path.
The
same
thing
we
see
an
acknowledgement
packet
coming
in
and
going
out
of
the
same
interface,
meaning
that
exactly
the
packet
generating
the
tcp
packets
generated
from
the
source
are
going
in
the
dpi,
then
the
firewall
and
again
the
load
balancer.
F
And
again
this
was
just
a
demonstration
that
the
chain
is
actually
working
and
okay.
So
the
next
step
will
be
to
go
on
with
the
second
service,
which
again
is
just
a
way
to
show
you
that
it's
possible
to
deploy
different
chain
with
different
characteristics
on
top
of
the
same
slice,
using
again
the
intent
of
course.
This
time
the
intent
will
be
a
bit.
F
As
you
see,
we
have
different
name
for
the
service,
but
we
have
the
same
name
for
the
slice
id,
so
we
are
going
to
set
up
this
service
on
top
of
the
same
slice
as
before,
and
this
time
the
service
block
list
is
simpler.
It's
just
composed
ie
by
a
single
firewall
and
also
with
the
symmetric
flag
set
to
false,
meaning
that
the
this
block
will
be
not
part
of
the
reverse
path,
and
the
procedure
is
the
same
as
that,
one
that
we
so
before.
F
F
F
F
We
see
that
there
is
a
new
chain
that
has
been
created,
the
one
related
to
the
service
b
and
since
we
set
the
flag
of
the
of
the
block
of
this
chain
to
the
symmetric
flag
to
false.
Also,
the
chain
is
not
symmetric,
so
it
would
mean
that
it
would
cross
this
single
vnf
only
once
so.
Only
on
the
on
the
first
part
not
on
the
reverse
path,
and
we
should
see
also
the
new
flow
classifier.
F
F
F
So
this
more
or
less
concludes
our
live
demo,
and
we
saw
how,
through
these
two
different
intent
types,
it's
possible
to
first
deploy
a
slice
so
a
set
of
virtual
resources
and
how
we
can
set
up
again
with
the
service
intent
we
can
set
up
the
services
or
how
we
can
like
change.
This
applicative
function
in
the
way
that
we
want
to
serve
our
particular
needs
and
also
in
a
dynamic
way,
so
adding
new
and
adding
more
than
one
services
on
top
of
the
the
same
slides,
for
example,
and
okay.
F
F
A
Well,
not
much,
I
think,
usual.
Basically
what
what
we
intended
to
to
prove
with
this
with
this
demo,
maybe
you
can
what
you
could
do
if
it's
time
to
to
show
how
the
intent
were
basically
translated
into
the
the
natural
service
descriptions
for
for
the
open
source
model,
at
least
related
to
the
let's
say,
the
instantiation
of
the
components
of
the
slides
and
then
of
the
of
the
service
that
were
that
were
requested
by
the
service
chain
intact.
A
I
Hi,
this
is
navid
talking,
I'm
work.
I
work
under
supervision
of
dr
kendick
and
I
work
on
the
same
in
the
same
topic
as
it
was
discussed
in
the
beginning
of
the
meeting.
Thank
you
very
much
very
interesting
presentation.
I
have
a
few
questions.
First
question
was:
what
is
the?
What
is
the
format
of
nsd?
That's
the
the
open
manual
receives
the
osm.
I
A
F
You
should
able
to
see
the
osm
interface
and
practically
osm
works
with
the
two
types
of
descriptor,
which
are
in
form
of
yaml,
and
the
first
one
is
used
to
describe
the
dvnf.
So
this
is
the
vnf
descriptor
vfd
and
contains
information
related
to
the
vnf
itself,
meaning
for
example,
I
just
open
one
of
them,
meaning,
for
example,
the
image
that
should
be
used.
F
F
So
what?
How
is
this
composed
this
virtual
machine?
How
many
interfaces
it
has
and
how
it
is
computing
capabilities
are
so,
for
example,
this
is
a
very
small
vnf,
so
just
512
megabyte
of
ram
10,
gig
of
storage,
juan
verto
super
and
so
on.
So
with
this
descriptor
we
are
describing
how
the
vnf
is
structured,
so
how
the
virtual
machine
act
basically
is
structured.
F
F
So
here
we
are
saying
we
want
to
create
a
service
with
a
load,
balancer
a
dpi
and
a
firewall,
and
then
we
are
going
to
specify
how
we
want
to
connect
them.
So
how
is
the
network?
How
are
the
networks
between
these
machines-
and
we
are
doing
this
here?
For
example,
this
is
the
management
network,
and
this
is
the
declaration
of
the
data
network.
F
I
My
next
question
was
so
so,
basically,
you
take
the
intent
and
you
translate
them
into
the
nsd
and
then
into
such
nsdnl
file,
and
you
feed
the
osm
with
that
exactly
yeah,
okay,
my
question
the
question
was
raised
in
my
head
was
first
what
if,
for
instance,
in
the
middle
of
the
chain,
like
it
branches
out
into
multiple
other
branches,
with
the
the
type
of
intent
definition
that
you
have,
which
just
provides
the
order?
Can
it
be?
F
F
That's
actually
a
very
good
question
and
it's
something
that
we
also
try
to
answer
ourselves
and
because
this
could
be
also
a
problem
of
the
underlying
infrastructure,
so,
like
composing,
very
complex
network
function
with
the,
for
example,
a
simple
open
stack
as
in
this
case
could
be
complex
or
maybe
even
impossible,
because
we
are
not
sure
that
the
traffic
will
actually
go
through
a
very
complex
path.
Due
to
some
limitation
of
the
implementation
itself.
Right
and
yeah,
for
example,
the
branching
could
be
done
inside
of
openstack,
but
if
it
actually
works.
F
So
if
you
actually
start
generating
traffic
and
you're
capturing
it,
I
don't
know
if
it's
actually
going
through
that
specific
path
and
yeah.
It
would
be
hard
to
specify
that
in
in
our
intent,
but
the
idea
could
be,
for
example,
if
you
take
the
template
or
the
servicing
intent,
for
example,
here
in
the
block
name,
we
use
the
exactly
the
name
of
the
vnf,
but
this
could
be,
for
example,
not
the
only
possibility.
F
So
if
you
have,
for
example,
branching
if
you
want
to
add
branching
to
this
template
here,
you
could,
for
example,
say
that
that
specific
block
name
actually
resolves
to
a
specific
branch
of
our
chain,
so
not
to
a
single
vnf,
but
one
complete
branch
of
the
chain
that
we
want
to
set
up.
For
example,
it's
just
like
something
that
I
I'm
thinking
of
right
now,
actually
and
but
yeah.
A
You
cannot,
I
can
add
something
related
to
this.
Actually,
we
worked
on
exactly
that
problem
a
few
years
ago.
Actually
david
was
not
yet
working
on
his
phd.
At
that
time,
we
did
try
to
to
generalize
the
idea
of
expressing
a
service
function
chain
in
a
high
level
format
specifying
the
rest
of
the
vnh
to
be
crossed,
even
in
case
of
branching,
but
that
is
I
mean
unless
you
want
to
go
with
a
graph
specification
which
complicates,
of
course,
things.
A
If
you
want
to
keep
it
simple,
we
ended
up
with
something
that
would
actually
work,
but
because,
at
that
time
we
were
actually
not
using
openstack.
We
were
working
low
level
working
on
open
flow
traffic
tools
inside
virtual
switch.
In
order
to
do
that,
we
managed
to
do
that
having
let's
say,
not
a
chain
after
a
branch,
but
only
like
a
some
sort
of
terminal
network
function.
A
For
instance,
we
made
the
example
that
at
some
point
you
want
your
traffic
to
be
branched
and
one
one
copy
of
your
traffic
will
go
through
the
rest
of
the
chain
and
one
copy
will
reach.
For
instance,
in
that
case,
was
actually
a
dpi,
but
working
only
as
a
you
know,
as
a
stubbed
as
a
sub
node,
we
just
receiving
traffic,
and
that's
it
so
without
without
forwarding
further
to
another
another
change.
So
we
were
able
to
do
that
without
problems.
A
I
A
The
effort
here
should
be
okay,
even
if
I
have
a
complex
vnf
which
is
made
by
I
don't
know
a
number
of
components
with.
I
don't
know
three
networks
and
five
components
interacting
each
other.
I
I
think
the
intent
level.
You
should
see
that
as
a
single
entity
and
whatever
happens
inside
that
that
pnf
how
the
traffic
is
going
to
be
exchanged
between
different
components
on
the
different
networks,
it
should
be
some
sort
of,
let's
say,
high-level
characteristics
that
you
want
to
use.
A
For
instance,
we
what
we
did,
because
we
wanted,
for
instance,
to
represent
the
fact
that
some
traffic
flows
should
cross
a
given
service
chain
only
on
the
forward
path
or
both
on
the
forward
and
the
reverse
path,
because,
for
instance,
if
you
have,
I
don't
know,
a
dpi
or
even
better
an
intrusion,
traction
system
that
network
component.
I
would
like
to
see
the
whole
traffic
going
in
both
direction
in
order
to
to
understand
what
is
going
on.
A
A
G
G
I
think
it
would
be
very
useful
if
you
could
in
the
future,
maybe
add
a
diagram
with
that
shows
kind
of
input
and
outputs
artifacts,
so
that
you
understand
kind
of
what
you
are
doing,
because
I
think
you
describe
the
inputs
here,
as
different
intents
and
in
the
demo,
and
you
are
showing
us
what
you
are
generating
for
the
controller.
So
it
would
be
useful
to
have
maybe
a
diagram
that
shows
that
scope.
B
F
Okay,
so,
regarding
the
the
request
between,
like
the
network
service
description
and
its
system
station-
and
there
are,
there
isn't
like
a
single
request,
but
it's
a
series
basically
osm
decomposes,
these
descriptors,
I
take
this
one,
which
is
to
be
simpler,
starts
like
okay.
I
need
the
two
networks
and
starts
like
posting
requests
toward
the
virtual
infrastructure
manager.
So
openstack
in
this
case,
like
asking,
give
me
one
network,
give
me
another.
One
then
give
me
a
vnf
like
this
one
and
another
vmf
like
this
one.
F
F
G
So,
okay,
okay,
so
I
was
just
wondering
in
terms
of
properties
which
what
is
the
part
of
the
descriptor
versus?
What's
the
part
of
the
instantiation
request,
so
I
would
assume,
maybe
that
you
would
figure
out,
I
don't
know,
source
destination
or
something
and
send
it
in
the
instantiation
request
and
then
descriptors
could
be
reused
between
multiple
sources
and
destinations
or
something
like
that.
Is
that
the
case.
F
F
G
G
Okay,
that
was
my
comment
originally
when
I
was
thinking.
Okay,
there
are
some
kind
of
things
that
are
network-wide
policies
that
could
be
separate
from
the
intent
itself,
so
that
intent
itself
can
become
maybe
simpler.
So
in
that
case,
if
you
maybe
decouple
intents
from
those
ones
which
are
related
to
the
descriptor
versus
one
which
are
related
to
the
instances
of
the
service,
in
that
case,
you
may
achieve
simplification
even
of
service
instances,
because
then
you
may
not
have
to
have
all
the
imperative
information
in
those.
G
C
We
are
performing
a
simple
mapping.
We
are
not
creating
the
description
from
scratch
when
the
internet
arrives,
so
we
have
already
a
catalog
of
descriptors
that
are
already
present
and
when
we
receive
the
intent,
mainly
david.
If
you
go
to
the
flight
intense
template
for
this
demo,
we
have
simply
the
instant
id,
which
is
specified,
of
course,
for
each
intent
and
which
should
be
unique.
And
then
we
only
specify
the
number
of
network
functions
and
applicative
functions.
So
we
have
only
a
few
examples
of
a
descriptors
that
are
already
present.
C
F
F
So
there
are
all
pretty
similar
the
network
services
here,
but
what
changes
is
just
in
case
we
had
like
more
than
one
slice.
So,
thanks
to
the
I
said,
parameter
we
are
used.
We
are
creating
a
network
service
descriptor
that
connects
the
our
source
destination
to
the
actual
data
net
of
that
particular
device.
G
A
A
E
Thank
you.
I
will
try
to
again.
I
hope
I
can
be
able
to
present
my
demo
this
week
and
I
think
it
might
be
so
I'm
using
some
yeah.
I
mean
some
ideas
from
this
hunger
and
his
team,
so
I
think
that
might
be
interesting.
Also
too
so
I
mean
there
is
the
the
high
level
part
of
the
intent
where
we're
using.
For
example,
google
assistant
talking
human.
F
A
A
Okay,
so
I
think
basically
we're
done.
I
would
like
to
thank
everybody
for
for
being
here
for
more
than
two
hours
actually,
but
I
think
it
was
worth
it.
It
was
a
very
good
discussion,
yeah
that
that
was
actually
the
first
time
we
we
proposed
a
project
for
a
hackathon
or
an
iatf
academy,
so
maybe
it
was
not
exactly.
A
A
That
would
be.
That
would
have
been
different
and
also
our
our
own
work
was
a
little
bit
slowed
down
because
because
of
the
pandemic
issue,
so
we
were
not
able
to
at
this
point
to
be
as
much
ready
as
we
wanted
to
be
so
so
I
think
we
can
start
from
the
discussion
that
we
have
today
try
to
to
improve
this
system,
try
to
build
something
together
with
the
other
people
that
were
interested
in
collaborating
and
see.
A
If
we
can,
we
can
come
up
with
something
more
practical,
more
usable,
I
would
say
the
next
time
you,
you
see
the
contacts
you
you
know
how
to
reach
us.
You,
you
also
have
the.
If
you
want
the
chance
to
to
connect
to
the
slack
workspace
that
can
be
used
apart
from
the
hackathon
can
be
used
also
as
another
channel
to
communicate
to
collaborate,
and
we,
I
think
we
will
stay
in
touch
if
whoever
is
is
interesting,
is
interested
in
going
on
with
this.
A
For
your
own
testing
for
your
own
development,
for
instance,
if
you
have
any
functionality
implemented
that
you
wanted
to
try
on
an
nfvm
environment,
we
can
help
you
setting
up
that.
We
can
help
you,
maybe
working
on
the
same
environment
that
we
have
so
feel
free
to
contact
us
if
you
want
to.
If
you
want
to,
you,
know,
join
forces
and-
and
do
something
like
that.
A
So
thank
you
again.
I
think
we
can
we
can
stop
here.
I
would
like
to
thank
barbara
davis
for
helping
with
this
without
their
contribution.
Of
course,
this
would
not
have
been
possible
and
if
you
have
the
chances
there
will
be
the
meeting
next
week,
I'm
not
sure.
Maybe
we
will
present
like
some
sort
of
a
shorter
report
or
short,
a
brief
summary
of
what
what
we
did
today
and
then
we
will
have
the
chance
to
talk
more
on
other
meeting
future
meetings
on
the
nmrg.