►
From YouTube: CNF WG Meeting 2021-05-17
Description
CNF WG Meeting 2021-05-17
C
C
C
So
it
may
be
worth
talking
about
at
a
later
time
when
things
start
to
settle
about
what
what
they
actually
mean
with
that,
because
right
now,
they're
they're
doing
comments
through
both
ntia
nist
and
similar
and
they're,
going
to
put
out
more
guidance
as
to
as
to
what
the
stuff
means
so
very
likely.
It'll
affect
things
that
go
through
here.
C
D
B
B
C
B
B
B
B
Tal,
if
you
want
to
add
to
the
discussion
topic,
the
I've
dropped
a
spot
at
the
very
end
for
frederick
to
add
the
links
and
if
you
were,
I
think
you
had
a
comment
if
you
could
put
it
in
there
and
save
it
for
the
discussion,
so
you
don't
forget
because
there's
a
few
others
for
you.
So
by
the
time
we
get
around
all
right.
The
meeting
notes
link
is
in
the
zoom
chat.
You
can
add
your
name.
Does
anyone
and
any
topics?
C
B
B
B
B
E
See
the
diagram
from
my
screen,
so
so
this
is
a
use
case
related
to
a
5g
ccs,
where
a
ccs
is
a
convergent
charging
system
and
it's
a
network
function
that
needs
to
maintain
state
and
so
we're
trying
to
so
me
and
olivia
are
trying
to
define
a
use
case
around
that.
So
this
diagram
that
you
can
see
on
the
screen
is
a
basic
use
case
for
how
a
user
with
a
device
interacts
with
the
convergent
charging
system
and
the
element
within
the
ccs
that
needs
to
manage
date.
E
So
I
just
whizz
back
to
the
various
different
things
that
are
involved
in
here,
so
I
filled
in
a
glossary
of
all
the
different
things
that
are
involved
with
ccs,
a
lot
of
terms
acronyms,
and
that
kind
of
thing
that
may
not
be
familiar
with
various
people
on
this
call.
The
the
types
of
state
that
we're
dealing
with
here
are
long-lived
states
that
relates
to
balances
subscribers
devices,
quotas,
price
plan,
and
we
have
also
short-lived
state
that
relates
to
the
session
and
the
session
data.
E
I'm
just
gonna
skip
through
the
initial
sections
and
just
talk
through
this
particular
use
case
here.
So
the
precondition
here
is
that
we
have
a
user.
This
little
stick
command
here
and
they
have
a
device
and
they're
registered
with
the
service,
so
they
are
allowed
to
use
the
network,
and
the
initial
step
is
that
the
device
requests
well.
The
device
subscription
make
the
real-time
request
to
the
network
for
quota
to
use
the
network
and
it
starts
a
charging
session
network
routes.
E
The
request
from
the
user
equipment
through
the
amf,
which
is
the
access
mobility
function
and
either
to
the
pcf
or
the
smf.
So
in
the
initial
case,
it's
going
through
the
smf,
which
is
the
session
management
function
to
the
chf,
which
is
the
charging
function
and
that
communicates
internally
inside
the
ccs
to
identify
whether
the
subscriber
exists
and
then
it
runs
some
rating
rules
and
that
result
in
a
charging
session
being
granted
and
that's
returned
through
to
the
user
equipment.
E
When
the
charging
session
with
its
quota
expires,
so
when
a
charging
session
is
granted,
it's
given
a
certain
amount
of
time
to
to
run
for
or
a
certain
amount
of
usage,
such
as
a
data
allocation,
one
that
has
expired
and
run
out.
The
device
requests
for
more
more
quota
from
the
network
and
a
subsequent
request
is
sent
through
the
end
of
the
usage
scenario.
E
E
The
state
needs
to
be
preserved
in
the
event
of
any
catastrophic
failure,
and
the
state
should
be
available
across
the
whole
cluster
of
all
stateless
cns
that
need
to
access
it.
So
in
this
scenario,
the
smf
needs
to
access
the
state
at
any
point,
to
determine
whether
the
subscription
is
active
and
the
device
is
valid.
E
E
Yeah,
a
service
provider
needs
to
maintain
the
balances
and
quotas
for
millions
of
devices,
potentially
in
their
network,
and
many
of
those
devices
will
access
that
information
concurrently.
So
you
can
imagine
a
lot
of
subscribers
looking
for
downloading
data
in
a
small
period
of
time,
so
the
state
we're
talking
about
here
it
should
be.
It
should
have
acid
compliant
properties,
and
these
are
things
like
it
needs
to
be.
Atomic
needs
to
be
consistent,
needs
to
have
isolation,
and
it
needs
to
be
durable.
E
And
the
convergent
charging
system
should
be
resilient
and
scalable,
so
it
should.
The
stateful
cnf
is
is
how
we're
talking
about
the
conversion
charging
system,
and
it
should
continue
to
follow
cloud
nature
principles.
So
if
you
have
a
node
failure,
it
shouldn't
result
in
any
service
outage.
So
you
need
to
have
clusters
of
systems
to
allow
for
that.
E
So
the
challenges
of
running
in
a
coupe
native
environment
are
that
you
can't
so
in
a
non-kubernetes
environment.
So
like
a
bare
metal,
so
pnf
or
vnf
kind
of
situation.
You
you're
basically
running
with
a
specific
set
of
machines
that
you
have
pre-provisioned
in
a
kubernetes
environment.
You
don't
get
that
control.
You
just
have
to
request
the
resources
and
hope
that
the
system
kubernetes
system
gives
you
those
nodes
that
you
need.
E
E
E
But
just
because
we're
storing
the
state
in
memory
for
speed
readings,
there's
no
reason
why
you
shouldn't
have
permanent
backups
of
that.
And
so
you
need
to
have
persistent
storage
and
high-speed
persistent
storage
to
handle
things
like
checkpoints
and
snapshots
of
the
data,
and
that
data
is
also
replicated
across
different
availability
zones
in
the
case
of
a
kubernetes
multi-cluster
system,
so
that
you
have
geographic
redundancy
of
the
processing
and
of
the
data.
E
E
E
E
F
F
E
It's
done
through
not
directly
through
the
thf,
but
through
back
end
replication,
so
it's
not
done
through
state
based
replication.
So
when
I,
when
I
think
about
like
state-based
replication,
it's
like,
whenever
you
write
to
a
database,
you
write
a
transaction
across
the
network
to
the
secondary
database,
effectively
the
we're
doing
it
through
whenever
you
make
a
change
to
data,
that
same
change
is
applied
through
a
mechanism
that
is
before
it's
written
to
the
database
and
it
sort
of
effectively
replays
the
transaction
on
the
standby
cluster.
E
E
F
F
We
are
essentially
having
a
storage
class
on
ultra
high
speed,
all
flash
storage,
which
is
next
to
the
kubernetes
infrastructure.
So
there
is
like
100
gig
iscsi
connection
from
from
the
nodes
yeah,
and
then
these
storage
systems
usually
also
come
with
some
synchronous
replication.
So
you
would,
we
would
replicate
the
volumes
or
we
are
replicating
the
volumes
on
that
storage
system
synchronously
to
another
site.
Of
course,
the
synchronous
replication
has
a
performance
penalty,
the
better
one
for
performance
is
asynchronous,
but
it's
always
question.
F
E
E
You
know:
they're
shared
shared
storage
between
all
of
the
processes
that
are
involved
in
this
particular
cluster,
for
example,
but
and
they're
used
for
cold
start
scenarios
and
there's
the
data
that
is
stored
in
here
is
then
archived
off
onto
not
so
fast
storage,
because,
obviously
there's
a
limited
amount
of
space
you
can
store
in
in
the
sort
of
the
the
local
effectively
local
storage.
You
need
the
archive
into
other
storage,
but
yeah.
E
It
is,
I
guess,
there's
two
ways
of
solving
the
same
problem
and
using
a
storage
class
is
one
way,
especially
if
the
storage
system
gives
you
the
the
replication
for
free
effectively
by
using
the
storage
class
that
has
that
capability,
whereas
we
do
it.
I
guess
over
the
top
before
it
gets
to
the
point
where
it's
writing
the
state
of
the
data
that
the
ssd.
G
G
So
I
I
like
vox
questions
about
what
is
the
objective
recovery
time
and
target
response
time?
I
think
we
should
stick
to
that
and
then
maybe
for
the
best
practices,
pick
the
technology
that
can
fulfill
these
requirements.
So
there
are
things
like
redis
database
which
in
itself
is
in
memory,
but
it
acts
like
a
database
that
can
be
accessed
through
api.
So
maybe
something
like
that
can
can
be
a
solution
here,
but
we
need
to
better
understand
these
requirements
to
see
if
a
redis
skin
can
be
the
right
solution
here.
E
Yeah
I
mean,
in
this
use
case
we're
we're
trying
not
to
be
too
specific
about
our
implementation
and
also
not
be
too
specific
about.
You
know
any
implementation
that
you
may
want
to
do
to
to
to
create
this
system
so
which
is
trying
to
be
sort
of
generic
from
the
sort
of
cnf
perspective
and
and
trying
to
sort
of
describe
these
kind
of
properties
that
you
need
when
you
have
a
stateful
cnf.
E
Yeah,
which
is
which
is
what
we've
described
in
somewhere
in
here,
where
we
talk
about
ultra
low
latency,
where
we
need
to
have
maintain
that
low
response
time
and
high
throughput,
and
if
you
yeah
what?
However,
you
implement
it.
You
still
need
to
maintain
those
properties
and
generally
the
implementation
falls
to
using
local
caches,
or
you
know,
or
an
in-memory
system
like
redis,
for
example,
or
other
nosql
databases
that
can
handle
that
kind
of
situation.
E
H
B
Where
the
short-lived
state
for
a
stateful
cnf
is
stored
in
memory
and
then
the
next
one
where
long-lived
state
is
held
in
memory,
so
I
I
guess
it
would
be
working
backwards
to.
Why
would
we?
The
question
is
why
why
would
we
choose
memory
at
all?
So
then,
whatever
the
requirements
are
have
those
written
out
and
they
may
actually
be
somewhere
else
in
this
okay,
further
yeah.
H
E
B
E
E
Sorry
yeah,
if
you
could
the
comments
you
made
to
the
discussion
just
so
I
have
a
point
of
reference
and
then
I
can
respond
to
those
directly
when
I
update
the
use
case
and
and
also
to
you
books,
because
who
you
were
making
other
comments
when
you're
about
implementation
details.
So
again
any
you
know
any
comments
and
feedback.
Yeah
leave
that
to
the
discussion,
then
I
can
follow
up
on
directly
yeah
sure
I
will.
F
C
B
Right
so
this
one's
pretty
extensive
and
there's
been
a
lot
of
comments,
and
it
seems
like
the
latency
comments
that
on
the
last
one
simon,
there
would
be
some
related
things
for
this
dealing
with
latency
yeah.
I
don't
want
to
go
through
all
this
myself,
I'm
hoping
that
someone
they
personally
wrote
it
could
join,
but
they've
added
a
lot
on
the
glossary
and
other
things,
and
I
think
frederick
and
simon
yeah,
both
commented
and
victor.
E
Yeah
my
comments
are
mostly
around
formatting.
I
maybe
it's
a
question
for,
because
the
syntax
checker
just
checks
for
basic
syntax
errors,
whereas
you
know
there's
no,
no
checking
for
whether
the
markdown
actually
renders
correctly.
So
I
don't
know
what
there's
anything
added
to
the
checker
to
validate
things.
Like
the
you
know,
the
the
bulleted
list
and
things
like
that
I
mean
I
haven't.
H
There
is
no
surprise,
it
is
like
learning
another
language
dealing
with
ram,
but
you
don't
necessarily
have
to
know
the
whole
of
random.
In
fact,
you
shouldn't
have
to
know
the
whole
of
ram
to
understand
the
use
case.
I
think
I
mean
it's.
I
don't
have
to
understand
every
application.
Anyone
might
reasonably
conceive
of
to
understand
how
to
build
an
operating
system,
and
I
think
that's
how
this
should
work
for
us
as
well.
Yeah
yeah.
D
D
B
I'd
say
if
it's:
if
it's
different,
then
create
a
new
one,
and
we
really
want
use
cases
like
with
what
vuk
and
ronnie
were
trying
to
say
as
far
as
feedback
to
simon
someone's
done
a
great
job
on
trying
to
break
the
requirements
up,
but
we
want
to
keep
going
that
way
so
around
the
memory
usage.
Why
are
we
doing
it
so
that
we
can
think
about
other
things
so
on
the
o-ring?
It
would
be
here's
where
we're
going,
but
that's
a
implementation.
So
what
are
we
learning
out
of
that?
E
C
One
of
the
other
concerns
as
well
on
that
particular
thing
was:
what
is
there
anything
in
terms
of
the
kubernetes
architecture
itself
that
is
lacking,
that
or
in
the
linux
architecture,
with
the
way
containers
work
that
is
lacking,
that
that
are
not
sufficient
for
the
for
the
time
requirements,
and
so
I
I
I
don't
have
an
answer
to
this
just
yet,
but
it's
something
that's
sitting
on
my
mind,
based
on
some
of
these
conversations.
Instead.
H
H
The
network
clock
says
and
that's
well
and
good,
and
it
requires
a
certain
element
of
hardware
support
to
figure
out
what
the
network
is
telling
you
about
that
clock,
but
then
there's
another
part
of
that
which
is
the
software
interface,
the
thing
where
you
actually
ask
for
the
clock
and
obviously
that
introduces
latency
as
well.
So
when
you
say
I'm
getting
you
accurate
time,
then
how
many
of
those
components
matter
and
how
accurate
do
they
all
need
to
be.
H
I
D
D
H
E
H
H
E
Yeah,
so
I
guess
specifying
a
set
of
requirements
for
the
host
system
may
imply
that
it
will
give
you
a
decent
performance.
So,
like
yeah,
you
know
high
high
percentage
of
cpu
lots
of
memory.
Those
kind
of
things
will
potentially
give
you
a
system
that
will
satisfy
your
base
requirements.
Even
if
you
can't
request
those
specific,
like
real-time
kernel,
kind
of
parameters,.
H
Yeah,
I
I
think
the
way
I
would
phrase
it
is
at
the
moment
you
see
people
saying
I
want
a
real-time
kernel,
which
amounts
to.
I
don't
know
what
aspects
of
a
real-time
kernel
are
making
my
software
work,
but
at
least,
if
I
run
it
on
a
real-time
kernel,
I
haven't
managed
to
break
it
yet
versus
saying.
If
you
do
a
certain
thing
in
a
certain
quantity
of
time,
then
my
software
will
definitely
work
and
if
you
don't,
it
will
probably
fail.
H
So
one
of
those
is
based
on
constraining
the
actual
software
you
use
at
which
point
we
start
getting
down
to.
You,
know
linux
four
point
x
with
certain
sets
of
patches
and
so
on,
and
nothing
else
will
do
and
oh
there's
a
security
bug.
Well
that
would
break
compatibility,
so
you're
not
allowed
to
fix
it
and
so
on
and
so
forth.
So.
D
So
I
don't
know
if
a
generic
solution
right
the
life
cycle
begins
when
you
install
the
cluster
in
the
first
place,
with
all
the
cni
solutions,
I
mean
we're
going
back
to
to
the
things
that
are
what
this
work
group
is
about.
Right,
there's,
it's
not
just
cnfs.
It's
also.
The
platform
itself
needs
to
be
designed
in
a
certain
way,
and
by
that
we
mean
not
just
the
software
platform,
but
also
the
hardware
platform,
so.
H
Yeah,
if
you
are
going
to
run
a
cnf,
then
what
services
are
you
going
to
have
to
offer?
It
is
I
think,
kind
of
key
to
making
this
a
success.
It's
not
just
about
saying.
If
you're
going
to
run
a
cnf,
then
the
cnf
has
to
be
designed
with
these
things.
You
know
these
beautiful
procedures
in
place
when
we're
not
we're
not
talking
about
the
the
joys
of
how
the
how
the
cnf
developers
think
as
much
exclusively.
We
also
need
to
know
what
kubernetes
has
to
provide
what
they
can
expect.
C
H
C
C
There
are
some
paths
there
it
may
I,
and
in
the
normal
course
of
things,
I
would
not
be
too
concerned,
but
I
am
concerned
that
when
we
run
it
through
kernel,
when
we
run
it
in
a
name
space,
we
run
it
through
something
that's
kubernetes
based
when
we
get
scheduling.
Do
we
need
numeral
alignment
for
for
that
thing
like
I,
I
get
a
little
worried
there
for.
H
Of
the
most
important
things
at
the
real-time,
colonel-
and
I
believe,
actually
canonical,
have
passed
judgment
on
this
in
the
past
and
it's
quite
significant
is
you
can
run
a
process
with
the
fifo
scheduler,
which
is
effectively
uninterruptable.
If
it's
got
work
to
do
it
wins
the
argument
when
scheduling
comes
up.
H
H
D
So,
just
to
bring
this
back
to
kubernetes,
specifically
one
of
the
challenges
is,
you
know
we
have
affinity
and
anti-affinity,
so
a
workload
can
ask
for
to
be
on
certain
kinds
of
hosts
or
not
to
be
with
other
things,
but
one
challenge
with
real
time.
I'll
put
it
with
quotation
marks
real
time.
Is
you
want
to
know
what
other
things
are
running
on
that
node
because
they
can
interrupt
you,
so
there
should
be
ways
to
request.
You
know
I
I
want
to
know
it
all
to
myself.
D
H
I
I
would
be
clear
on
the
distinction
between
best
effort
and
a
guarantee
right,
anti-affinity
is
best
effort.
Anti-Infinity
is
saying
that
I
will
not
run
you
with
something
else,
because
that
is
likely
or
it
may
affect
your
performance,
but
something
else
may
affect
your
performance
as
well.
You're,
certainly
never
going
to
be
the
only
process
on
a
whole
linux
box
and
if
you're
running
kubernetes,
that's
an
impossibility,
but
a
guarantee
is
a
different
thing,
which
is
I
don't
care?
What
else
is
running
on
this
box,
because.
B
D
D
Yeah
exactly,
I
think
we
have
a
whole
bunch
of
different
tools
here,
and
this
use
case
is
perfect
for
looking
at
all
of
them
and
trying
to
find
a
way
to
to
streamline
them
and
suggest
what
the
best
practices
would
be.
So
I
I
think
this
is
perfect.
I
don't
think
we
have
clear
answers.
There's
a
lot
of
aspects
here.
H
B
C
Yeah,
I
think
a
good
approach
for
this
would
would
be
to
ask
the
oran
people
what
they
do.
I'd
be
surprised
if
they
haven't
spent
time
thinking
through
some
of
these
details
and
considering
that
they
want
to
sit
in
that
space.
They
certainly
have
to
have
some
answer.
Maybe
it's
in
practice.
It
works
well
enough.
Yes,
it
could
be
an
issue,
but
it's
it
happens,
rare
enough
that
we
don't
have
to
care
about
it.
Then
we
move.