►
From YouTube: CNCF SIG Runtime 2020-10-01
Description
CNCF SIG Runtime 2020-10-01
A
A
B
A
A
Maybe
maybe
we
could
do
a
little
bit
of
you
know
an
interactive
session.
I
guess,
and
maybe
I
can
just
kind
of
we
can
just
ask
questions
or
I
can
ask
questions
and
you
know
like
so
I'm
I'm
curious.
How
do
you
get
started?
I
mean
I
mean
you,
you
have
web
assembly
and
then
you
have
a
runtime
and
you
want
to
be
able
to
run
the
the
bytecode
with
the
runtime
right
and
how
would
you
get
started
with
the
w
sec.
B
Sure
so,
there's
a
couple
of
tutorials
on
the
wask.dev
website
that
walk
you
through
the
process
of
getting
started,
but
the
the
basic
idea
is
that
webassembly
on
its
own
is
a
pretty
basic
format.
You
can
only
pass
and
receive
numeric
arguments
and
return
values,
so
to
do
anything
more
interesting
than
that.
You've
got
to
put
a
layer
on
top
of
the
core
webassembly
spec
and
for
us
that
layer
is
a
a
webassembly
rpc
standard
called
wapc
I'll
put
the
wapc
link
in
the
in
the
slack
channel
as
well.
B
And
so
that,
basically,
that
one
puts
a
wrapper
around
basic
webassembly
function,
calls
that
let
you
send
and
receive
arbitrary
binary
payloads.
So
it
doesn't
really
care
what
the
contents
of
those
those
binaries
are.
So
they
can
mean
whatever
you
want
them
to
mean
as
long
as
the
webassembly
module
and
the
runtime
agree
on
that
meaning,
and
so
above
the
wapc
stuff
is
where
wasc
sits
and
wasc
adds
the
the
cloud
native
runtime
aspect
and
the
the
actor
model
aspect
to
the
webassembly
stuff,
and
so
the
tutorial
that's
out
on
the
website.
B
The
first
thing
that
it
has
you
do
is
you
can
make
an
actor
that
responds
to
http
requests
with
you
know
the
the
typical
json
hello
world
and
what's
unique
about
wasc
in
in
how
that
works
is
unlike
the
experience
of
creating
a
microservice
in
go
or
c-sharp
or
any
of
the
other
languages
that
I
might
use
for
for
my
cloud-native
type
services
in
wasc,
the
the
creation
of
an
http
server
endpoint
is
done
by
what's
called
a
capability
provider.
It
isn't
part
of
the
actor
code
that
you
write.
B
B
B
You
know
you,
you
compile
your
your
your
hello
world
actor
to
to
return
a
adjacent
payload,
but
how
it
returns.
That
payload
is
not.
It
is
not
your
concern,
so
at
runtime
you
can
switch
from
maybe
a
lightweight
web
server
when
you're
in
development
and
testing
to
a
super
high
throughput,
multi-threaded
beast
of
a
web
server
in
production.
A
So,
there's
a
at
run
time.
You
can
change
the
components
depending
on
you
know
how
you
want
to
run
your
whatever
you're
trying
to
run
like
then
also,
you
can
add
on
some
modules,
for
example
like
if
you
want
to
connect
to
a
database
right,
so
that
will
be
an
additional
module,
but
that
can
be
added.
Also
around
time
is
that
is
that
accurate.
C
You
have
a
higher
level
overview
of
kind
of
how
this
fits
in
compared
to
like
other
kind
of
normal
container
runtime.
I
saw
it
mentioned
like
container
lists,
because
I
know
there's
some
there's
like
the
wazi
stuff,
where
you
could
basically
run
wasm
almost
like
a
normal
container,
but
I
was
kind
of
curious.
B
B
With
a
webassembly
module,
it's
smaller,
it's
faster,
it's
more
secure
than
regular
containers.
The
only
difference
is
that
webassembly
modules
can't
do
on
their
own.
What
your
software
running
in
a
container
can
do.
So
how
do
you
give
a
webassembly
module
the
capability
to
do
things
in
the
cloud
and
that's
where
the
last
runtime
comes
in?
It's
basically
a
matchmaker
between
a
webassembly
module
that
has
a
declarative
set
of
uses
for
capabilities
and
these
capability
providers
it
binds
them
at
runtime
and
then
allows
them
to
communicate.
B
And
so
the
one
of
the
design
goals
behind
wasc
is
that
you
can
run
it
anywhere,
and
so
I
can
run.
I
can
put
this
runtime
on
a
raspberry
pi.
I
can
put
it
in
a
cloud.
I
can
put
it
on
my
laptop
and
the
webassembly
modules,
which
are
my
actors
and
my
business
logic.
Those
don't
have
to
be
recompiled
at
all,
because
the
webassembly
format
is
is
portable.
C
Yeah
is
it
did
it
answer
your
question
or
just
did
it,
I
think
for
me
it
it's
still
a
little
abstract
in
terms
of
like
how
the
deployment
looks,
how
the
how
the
kind
of
request
architecture
goes
through
saying,
like
a
kubernetes
environment,
maybe
I'm
just
thinking
about
it
from
like
too
conventional
of
an
approach,
but
I
was
comparing
it
with
wazi,
because
the
wazi
approach
is
like
using
web
assembly,
but
it's
basically
building.
You
could
use
it
to
build
containers
that
are
kind
of
like
containers.
B
Yeah,
so
the
the
difference
between
wasc
and
wazi
is
with
the
yz
module
you're,
basically
poking
holes
in
the
webassembly
module
through
these
imports
that
are
satisfied
by
a
runtime
that
knows
about
the
wow
spec
and
so
there's
a
couple
of
them.
Wasm
time
is
one
wisem
three
will
do
it.
Wasmer
will
do
it.
B
But
the
our
the
opinion
at
the
wasc
level
is
that
actors
in
being
pure
business
logic
shouldn't
have
access
to
the
file
system.
They
shouldn't
have
access
to
an
environment,
they
shouldn't
have
access
to
anything,
they
don't
have
permissions
to
have
access
to,
and
so
we
have
a
security
system
in
place
that
secures
capabilities
at
a
high
level.
So
the
capabilities
in
wazi
are
very
much
at
the
kernel
level.
Can
you
write
to
this
file
descriptor,
yes
or
no?
B
B
Okay,
so
you
can
see
that
then,
okay,
so
what
we're
looking
at
is
the
code
for
an
actor
written
in
rust,
but
it's
using
the
last
runtime
and
the
the
key
pieces
here
is
that
actors
are,
are
reactive,
they're,
very
much
like
think
of
them
like
lambdas,
where
they
get
an
event
or
a
message,
and
in
response
to
that
they
execute
some
logic,
and
then
they
return
what's
different
about
an
actor.
So
this
is
this
is
the
list
of
messages
that
it
handles.
B
B
The
capability
that
that
I
have
running
on
that
pie
is
re,
is
pulling
radio
signals
off
of
an
antenna
that
contain
a
list
of
planes
that
are
flying
overhead
within
about
a
100,
kilometer
radius,
and
so
every
time
I
get
one
of
those
messages
that
provider
decodes
it
and
if
I
had
access
to
the
terminal,
I
could
show
you
what
those
those
raw
messages
look
like
it
decodes.
It
and
then
sends
it
to
this
actor.
B
B
B
B
B
Where
you
know
I
have
a
net,
a
message
broker
provider
for
nats
and
that's
and
then
in
that
case
you
can
create
a
subscription
or
multiple
subscriptions,
and
every
time
you
get
that
provider
gets
a
nets
message.
It
can
then
deliver
it
to
the
appropriate
actor,
and
so
the
the
host
runtime
is
basically
a
dispatcher
between
these
tiny
actor
modules
which
contain
as
close
to
raw
business
logic
as
possible
and
the
capability
providers
that
are
satisfying
the
non-functional
requirements.
C
B
Yeah,
so
this
is
essentially
a
remote
rpc.
It's
our
the
there's,
a
at
a
low
level.
There
is
a
standard
called
wapc
that
allows
us
to
send
and
receive
binary
payloads
between
the
webassembly
module
and
the
host,
and
then
wasc
adds
meaning
to
those
payloads
on
top
things
like
the
key
value
stores
and
blob
stores,
and
all
of
that,
those
are
basically
just
a
set
of
data
types
defined
in
something
that
can
be
serialized
in
and
out
of
message
pack,
and
so
the
host
is
basically
just
sending
these
message.
B
B
B
A
So
thank
you
for
the
all
the
explanations
so
another
question.
So
how
do
you
handle
errors
like
if
you
one
of
your
actors
or
not
it's
not
responding,
or
I
mean
you
have
that
message
boss
right,
but
then
underneath
you
need
to
have
networking
right
between
right.
So
if
you
have
some
errors
to
you,
you
have
a
error
handling.
B
B
We
know
there
was
an
error,
and
so,
as
part
of
that
protocol
between
actors
and
the
runtime
host,
it
knows
how
to
store
an
arbitrary
error
payload
on
behalf
of
the
actor,
and
so,
if
the
actor
fails
at
any
point
in
processing,
we
can
set
that
value
in
the
host,
and
so
the
host
knows
when
the
actor
failed.
The
reverse
is
also
true.
The
actor
will
know
when
the
host
fails.
A
C
B
B
There's,
an
automatic
health
check
system
in
the
host
runtime
that
invokes
the
health
function
on
all
of
these
actors,
and
if
the
health
function
doesn't
come
back
or
it
returns
an
error
or
it
returns
explicitly
an
error
that
you
can
provide
on
your
own,
then
the
host
runtime
will
know
that
your
actor
is
unhealthy
and
there's
a
there's,
a
an
issue
open
to
finish
the
implementation
of
this.
But
basically
what
will
happen
is
the
host
runtime
will
bounce
your
actor.
It
will
dispose
of
it
and
then
reload.
B
D
B
B
Happen,
regardless
of
whether
your
host
runtime
is
running
in
or
out
of
kubernetes
microsoft
has
a
project
called
crosslit.
That
is
essentially
a
an
alternate
version
of
cubelet
that
runs
on
kubernetes
nodes.
That
allows
you
to
deploy
webassembly
modules
straight
to
a
node
without
the
use
of
a
container,
and
you
can
choose
either
a
wazi
module
or
a
wask
actor
to
deploy
straight
to
that
node.
B
There
are
other
there's
other
error
checking
like
I
said
before
when
you're
running
this
in
what
we
call
a
lattice,
which
is
just
a
cluster
of
these
host
runtimes
when
you're
running
it
in
a
lattice,
we
will
detect
things
like
rpc
timeouts
and
do
rpc,
retries
and
so
on.
So
if
we
can't
communicate
with
the
other
host,
then
that
is
treated
as
a
different
type
of
failure
than
if
we
did
communicate
with
the
host
and
the
host
did
invoke.
The
web
assembly
call
and
the
host
got
an
explicit
error
in
response.
D
B
B
Oh
okay,
so
the
protocol,
it
is
not
grpc
or
anything
else
like
that.
It's
below
ask
is
an
rpc
protocol
designed
specifically
for
web
assembly
called
wapc
and
without
getting
too
far
into
the
weeds
one
of
the
problems
that
I
think
exists
with
some
web
assembly.
Runtimes
right
now
is
they're,
either
very,
very
javascript
specific,
so
they
assume
the
existence
of
a
browser
as
your
host
or
they
assume
that
there
is
javascript
glue
code
like
bind
gen
or
things
like
m
scriptin.
B
You
could
have
inconsistent
state
and
all
sorts
of
terrible
problems
that
we
know
we
don't
want
to
have
when
building
state
stateless
services
in
the
cloud,
even
for
things
like
lambdas
and
so
wapc
is
specifically
designed
to
not
only
be
allocation.
Agnostic,
so
it
doesn't,
it
doesn't
rely
on
the
existence
or
non-existence
of
a
garbage
collector
inside
the
webassembly
module,
but
it
also
doesn't
allocate
anything.
B
It
is
unaware
of
how
either
side
of
that
conversation
allocates
memory,
and
so
what
that
means
is
that
between
any
two
function,
calls
which,
in
the
host
runtime,
are
managed
in
a
in
a
durable
queue.
So
between
any
two
of
those
function
calls
the
webassembly
module
can
be
destroyed
or
its
memory
can
be
wiped
and
it
will
have
no
impact
on
either
the
module
or
the
host.
B
That
allows
me
to
take
an
actor
that's
running
on
a
host
in
one
node
start
up
a
second
copy
of
that
actor
on
another
node
continue
to
distribute
function,
calls
between
the
two
take
one
down
and
bring
another
one
up
all
without
ever
having
to
worry
about
whether
I
left
some
sort
of
dangling
pointer
somewhere.
So
grpc
is
an
excellent
point-to-point
protocol,
but
in
trying
to
adapt
it
to
stateless
distributed.
B
C
B
B
You
can
find
that
on
on
github
I'll
I'll
post,
the
link
in
the
slack
channel
as
well,
but
that's
precisely
what
that
does
is.
If
you
run
crosslink
instead
of
cubelet,
you
can
choose
to
deploy
either
wazzy
modules
directly
to
a
kubernetes
node
with
the
kubernetes
deployment
manifest
or
you
can
choose
to
deploy
a
wask
actor
directly
to
a
kubernetes
node
and,
like
I
said
earlier,
the
the
way
wasc
form
self
forms.
B
D
B
So
I
have
this
demo
where
one
of
the
things
I
wanted
to
try
and
do
with
wasc
is
to
make
it
generally
much
easier
and
much
simpler
to
build
distributed
applications,
but
also
to
enable
a
the
possibility
of
thinking
about
distributed
applications
in
a
new
way.
So
when
we
build
microservices
and
we
deploy
them
to
the
cloud,
we
just
sort
of
assume
that
we're
going
to
build
this
walled
self-contained
structure,
whether
it's
a
kubernetes
cluster
or
not,
that
houses
all
of
our
compute
and
that's
what
we
think
of
as
a
distributed
application.
B
And
so
this
demo
called
wasm
air
essentially
builds
a
clone
of
the
flightaware
application.
I
don't
know
if
anyone's
familiar
with
it,
but
with
flightaware
you
can
basically
buy
these
little.
Ten
dollar
devices
put
an
antenna
on
the
outside
of
your
house
and
you'll
pull
radio
data
and
you
can
see
it
locally,
but
it
also
sends
it
up
to
a
cloud
aggregation
service.
So
you
can
see
all
of
these
flights
in
one
aggregate
pool
and
with
this
application
here
we
did
the
same
thing,
but
it
took
about
four
hours
rather
than
you
know.
B
However
long
it
would
have
taken
to
build
the
same
thing
using
traditional
microservices.
So
there's
a
couple
of
components
here
that
are
actors.
I
showed
the
code
for
this
thing
called
the
adsb
processor
and
adsb
is
just
the
acronym
for
the
type
of
radio
signal
that
we
have-
and
I
mentioned
earlier,
that
we've
got
a
level
of
security,
that's
embedded
inside
the
webassembly
modules.
B
So
one
of
the
things
that
has
burned
me
as
a
in
a
role
of
devops
in
deploying
docker
containers
is
how
to
secure
the
applications
that
are
running
in
them
in
general.
They
can
do
whatever,
whatever
they
feel
like
doing,
and
we
can
apply
networking
and
security
policies.
But
the
policies
are
in
environments,
they
don't
follow
the
docker
image,
and
so,
if
we
make
a
mistake,
forget
to
redeploy
something
forget
to
resynchronize
something.
It's
super
easy
to
accidentally.
Let
one
of
those
docker
images
fall
through
our
policy
enforcement
with
wasc.
B
B
Okay,
good,
so
what
we
have
embedded
directly
in
this
module,
which
is
a
little
over
a
meg
by
the
way,
so,
instead
of
having
this
docker
image,
where
I
have
a
runtime
embedded
in
it,
and
I
have
all
of
my
dependencies
embedded
in
it,
you
know
that
that
that
quote
about
saying
that
you
know
you
own.
All
of
your
dependencies
is
quite
true
because
they
all
end
up,
even
if
you're,
building
a
static
binary.
Those
things
still
end
up
in
in
your
application.
Wasc
actually
doesn't
have
the
dependencies
in
them.
B
So
inside
this
module
is
a
cryptographically
signed
json
web
token,
and
so
in
that
token
I
have
a
globally
unique
identifier
for
the
module
itself.
So
anywhere
this
module
goes
after
it's
been
signed.
It
will
always
have
this
identity.
I
have
the
identity
of
the
thing
that
signed
it.
So
essentially
the
tokens
issuer
and
I
can
have
a
chain
of
issuers
as
long
as
I
want
to
have,
so
I
can
verify
the
prominence
of
this
module,
but
my
security
system
can
choose
whether
or
not
I
trust
things
that
were
issued
by
this
account.
B
I
also
have
a
restful
service,
what
they
call
that
thing,
and
this
restful
service
exposes
the
aggregate
flight
data
that
my
actor,
my
processor
actor,
has
generated
by.
You
know
that
that
small
amount
of
code-
and
if
I
look
at
this
one,
the
code
for
this
is
also
remarkably
small.
The
only
thing
that
we
have
here
is
a
declaration
that
we
handle.
Http
requests,
the
mandatory
health
request
and
in
response
to
handling
this
http
request,
I
can
query
the
list
of
stations.
B
B
B
B
B
B
B
B
B
Here,
no,
there
we
go
so
I
don't
know
if
you
can
see
this,
but
I've
got
a
couple
of
flights
that
are
not
advertising
their
call
signs.
So
that's
probably
for
the
air
force
base.
That's
near
my
house,
and
then
this
other
one
here,
lxj381
that
that
those
these
two
here
look
the
bottom
two
look
like
regular
commercial
flights,
so
what's
happening
here.
Is
I
have
a
capability
provider
running
on
a
device
or
running
with
telnet
access
to
a
device
that
has
a
radio
receiver
on
it?
B
B
All
of
that
into
this
flight
state-
and
now
I
I
have
a
just
a
regular
console
application
that
is
reading
the
aggregate
state
generated
by
these
actors
or
this
one
yeah
the
two
actors,
and
also
subscribing
to
the
event
stream
of
events
that
one
of
the
actors
is
emitting,
and
you
saw
earlier
that
the
the
amount
of
code
to
get
all
this
stuff
to
work
was,
you
know
in
measured
in
the
tens
of
lines
of
code.
But
that's
not
really
the
most
important
thing
here.
B
I
could
change
the
hardware
device
that
I'm
getting
this
radio
from
from
the
little
antenna
outside
my
window
to
some
giant
thing
mounted
in
my
backyard
without
having
to
redeploy
my
actors,
and
I
could
switch
it
from
storing
the
data
in
redis
to
storing
it
in
cassandra
or
any
other
key
value
store
again
without
redeploying
the
actors
and
these
actors
are
unforgeable.
So
I
can't
pretend
to
these
actors
can't
pretend
to
have
an
identity
that
they
weren't.
B
Given
you
can't
tamper
with
them,
because
the
the
hash
of
the
bytes
of
the
webassembly
module
will
will
fail
that
check
and
further.
Since
I
know
the
identity
of
the
the
entity
that
signed
these
modules.
I
know
whether
or
not
I
trust
them
to
run
in
this
particular
environment.
So
I
could
have
identities
that
I
trust
to
sign
my
production
pay
workloads
and
I
could
not
trust
the
entities
that
sign
my
my
dev
and
qa
workloads.
D
So
I
have
a
question,
so
this
is
one.
This
is
the
data
that's
being
displayed
by
signals
that
are
coming
to
one
raspberry
pi.
Is
that
right
right
now,
and
the
idea
is
that
you
have
some
sort
of
distributed
database
that
has
all
these
flights
in
it
and
you
have
these
stations
all
over
the
world?
Is
that
the
idea
and
they
communicate?
Is
there
a.
D
B
So
if
I
were
to
send
all
of
these
events
from
all
of
these
different
flights,
all
the
way
up
to
to
the
cloud
in
order
to
do
pre-processing
on
them,
I
would
quickly
overwhelm
my
cloud
and
I'd
have
to
scale
it
up
and
pay
for
all
of
that
scale.
But
if
I
can
do
some
of
that
pre-processing
on
the
device
that
massively
impacts
the
type
of
architecture,
I
need
to
support
this.
B
B
D
B
Yeah,
okay,
so
the
the
core
components
of
the
system
here
are:
there's
an
actor
that
processes,
flight,
tracking
events
that
come
in
from
a
a
flight
tracking
capability
provider
and
there's
an
actor
that
provides
a
restful
service
on
top
of
the
aggregate
data
and
those
two
things
are
really
the
key
components
that
that
make
up
this
system.
There's
the
ui
here,
but
you
know
that
that's
just
a
essentially
a
passive
consumer.
B
As
long
as
the
design
of
my
system
is
to
process
these
radio
events
and
convert
them
into
aggregate
state,
then
I
can
satisfy
those
requirements.
However,
I
want
without
having
to
change
my
actors.
More
importantly,
I
can
move
my
capability
providers
from
one
host
to
another.
I
can
move
my
actors
from
one
house
to
another
and
I
can
choose
where
I
run
my
compute,
based
on
what
my
needs
are
not
based
on
what
technology
I
chose
for
my
client
library
at
the
time
that
I
was
developing
this
stuff.
A
B
That's
kind
of
the
that's
the
cool
part
is
that
it
doesn't
really
matter.
I
can
have
the
capability
provider
in
process
inside
the
same
host
as
the
actor
and
in
some
cases
that
might
make
a
lot
of
sense.
So
if
the
capability
provider
is
sending
tens
of
thousands
of
messages
per
second
to
an
actor
for
processing,
it
might
make
a
lot
of
sense
to
put
the
actor
and
that
provider
in
the
same
host
and
then
have
the
post-processing
actor
be
in
another
host
downstream
somewhere.
B
But
the
beauty
of
it
is
that,
because
these
things
are
portable
and
they'll
run
wherever
I
want
them
to,
if
one,
if,
while
I'm
prototyping
this
out-
and
I'm
testing
this
all
at
home,
just
to
see
how,
if
all
this
stuff
works
together,
I
can
run
it
all
in
a
single
process
and
verify
that
everything
is
the
way
I
want
it.
And
then,
when
I
want
to
scale
out
to
production,
I
don't
have
to
re-engineer
my
hello
world
to
production
anymore.
B
A
A
B
So
I
think
the
important
takeaway
here
is
that
the
way
people
are
building
stuff
right
now
today
is.
If
I
want
something
to
run
at
the
edge.
I
have
to
choose
a
very
specific
set
of
technologies
in
order
for
my
compute
to
run
on
the
edge,
and
if
I
want
my
stuff
to
run
in
the
cloud,
I
use
a
totally
different
set
of
technologies
to
run
in
the
cloud.
B
If
I
want
to
have
compute
running
inside
a
browser,
I
have
another
entirely
different
set
of
technologies
that
I
now
have
to
deal
with,
and
if
I
want
all
of
those
things
to
talk
to
each
other,
I
have
yet
another
set
of
technologies
I
need
to
deal
with.
But
if
I,
if
I
write
all
of
my
stuff
as
these
portable
actors
in
webassembly,
I
can
deploy
them
and
run
them
at
the
edge.
I
can
run
them
in
the
cloud.
I
can
run
them
on
tiny
devices
and
I
can
run
them
anywhere
I
want
to.
B
I
can
even
run
them
in
the
browser
and
I
don't
have
to
re-engineer
my
my
application
to
make
to
change
how
how
I
split
up
my
compute
and,
more
importantly,
I
don't
have
to
have
five
different
teams
with
five
different
skill
sets
to
manage
all
these
components.
I
essentially
have
one
stack
of
stuff
that
I
need
to
worry.
B
B
There's
a
there's
a
number
of
people
using
it,
ibm's
hyperledger
is
using
the
underlying
rpc
mechanism,
so
the
wapc
stuff.
There
is
a
company
that
whose
name
I'm
I'm
not
allowed
to
mention,
but
they
they
build.
5G
appliances
that
allow
you
to
that.
Allow
customers
to
grab
to
download
content
as
well
as
re-share
their
5g
bandwidth
with
other
neighbors
that
are
within
a
certain
distance
of
that
appliance
and
all
of
the
code
running
on
those
appliances
is
wasc
actors
running
inside
west
coasts,.