►
From YouTube: Bindles Bundle but They Don't Fall Down: Aggregate Object Storage fo... Matt Butcher & Taylor Thomas
Description
Don’t miss out! Join us at our next event: KubeCon + CloudNativeCon Europe 2022 in Valencia, Spain from May 17-20. Learn more at https://kubecon.io The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Bindles Bundle but They Don't Fall Down: Aggregate Object Storage for Wasm - Matt Butcher, Microsoft Azure & Taylor Thomas, Cosmonic
As interest in WebAssembly (Wasm) continues to increase, a familiar problem has reared its head: how do we distribute and store these new applications? We have tried everything from tarballs, to OCI, to bespoke storage products. But Wasm has a unique characteristic – it enables you to build an application out of several completely different, but related parts. An "application" may be an aggregate of dozens of Wasm binaries. Enter Bindle, an aggregate object storage and Cloud Native Wasm packaging tool. In this talk, we will discuss why we created Bindle, including a deep dive into its strengths and weaknesses. We will also demo how this can be used to package an aggregate application and deploy it to a service, before finishing up with the future of the project and how you can help! Along the way, we'll talk about security, integrity, Merkle trees, caching, and trust.
A
B
C
A
C
Yeah,
since
I'm
on
the
left
I'll
go
first,
I
guess
yeah
so
like
like
we
said,
my
name
is
taylor
thomas.
I
am
a
director
at
cosmonic,
so
I
work
with
liam
and
I'm
a
core
maintainer
crestlet
bindle
waggy
bunch
of
other
oss
things.
If
you've
been
in
the
kubernetes
space
for
a
while,
I'm
an
emeritus
maintainer
of
helm,
I'm
also
a
breast
station.
I
do
lots
of
rust
as
many
of
us
here
in
web
assembly.
C
A
I'm
matt
butcher,
I'm
a
principal
engineer
at
microsoft.
If
you
run
across
deus
labs
projects,
that's
the
team
that
that
I'm
on
at
microsoft,
we've
been
doing
a
lot
of
web
assembly
work,
a
lot
of
rust
work
and
kind
of
stretching
back
into
kubernetes
land,
and
I'm
techno
sofas,
pretty
much
everywhere
online.
C
So,
let's
go
through
our
agenda.
This
is
going
to
be.
This
is
a
quick
overview.
I
always
like
to
have
this.
So
people
know
where
we're
going
we're
going
to
talk
all
about
what
bindle
is
then
go
over
some
well
two
specific
case
studies
or
a
case
study
and
a
real
example
of
of
how
this
could
be
used
in
action
and
then
kind
of
discuss.
A
So
you
got
a
silverware
drawer
right
and
many
of
us
have
these
nice
little
divider
things
where
we
can
put
the
forks,
the
spoons
the
knives,
keep
everything
separate
and
we've
got
one
storage
area
where
we
keep
all
the
things,
but
when
it
comes
to
using
that
drawer
we
use
it
in
different
ways.
Right
I
get
up.
I
want
cereal
for
breakfast,
I
open
the
drawer.
I
pull
out
a
spoon,
you
know
I
I'm
gonna
have
spaghetti.
I
might
need
my
spoon
fork
and
knife.
I
decide
to
host
a
fancy
dinner.
A
A
A
We
want
to
talk
about
aggregate
object,
storage,
aggregate
object,
storage
is
when
you
figure
out
a
way
to
create
that
silverware
drawer
for
your
data
in
such
a
way
that
it
makes
sense
to
have
it
all
in
one
place,
but
where
you
can
kind
of
pick
and
choose
and
grab
the
things
that
are
most
important
to
you
at
that
moment,
when
you
need
them
in
in
wasm
land
most
applications
are
not
sort
of
the
monolithic
applications.
What
we're
starting
to
see
is
the
way
that
they're
getting
combined
from
individual
wasm
modules.
A
It
can
be
pulled
together
in
different
configurations
and
then
executed.
So
it
makes
sense
in
a
way
that
we
want
to
keep
all
of
these
objects
stored
together,
but
given
the
runtime
constraints
right
when
I
start
up
the
application-
and
I
know
what
the
physical
environment
looks
like-
I
might
want
to
pick
and
choose
a
little
bit.
So
I
open
up
the
silverware
drawer
and
say
I
just
need
the
spoon
and
the
knife
for
this
one
or
I
open
up
the
silverware
drawer
and
scoop
everything
out
and
you
know
lay
it
all
out
it.
A
But
the
point
there
is
that,
with
the
with
an
aggregate
object-
storage
system,
it's
the
run
time
that
selects
which
things
we
need
at
a
given
time.
And
when
we're
preparing
everything
when
we're
deploying
things
we
can
deploy
it
together
and
at
runtime
we
can
pull
that
silverware
drawer,
open
and
pick
the
things
we
need.
C
So
let's
talk
about
what
are
the
different
parts
of
bindle?
There's
some
terminology
here
that
you're
going
to
hear
multiple
times.
We
go
throughout
the
rest
of
talk
and
it's
important
to
understand
what
they're,
what
they
are,
so
we're
talking
about
invoices
and
parcels.
First,
these
are
the
two
key
parts
of
a
bindle.
C
Everything
together
is
a
bindle
lower
case,
if
you're,
if
we're
being
really
nitpicky
about
it,
yeah
who
would
think
engineers
are
pedantic,
but
so
an
invoice
is
basically
the
bill
of
materials
or
the
parts
list
everything
that's
contained
within
the
bindle.
It
describes
everything
that
should
be
in
there
and
the
relationship
between
those
items
which
we'll
talk
about
in
a
second
and
then
a
parcel
is
an
item
inside
of
a
bindle,
so
that
can
be
literally
anything
that
can
be
turned
into
bytes.
C
It
does
not
care,
so
they
they
don't
care
what
things
are
in
them.
It
just
cares
that
they're
labeled
correctly
and
have
the
correct
sha,
which
that
is
the
the
label,
is
the
kind
of
the
data
saying.
This
is
the
data
that
I'm
expecting
and
it
contains
the
sha-256
sum
and
any
additional
information
about
that
specific
item.
So
that's
the
first
two
parts
of
a
bindle
yeah.
A
C
And
actually
like
that's
not
to
completely
over
make
an
over
analogy
here,
but
the
it
actually
holds
up
really
well
there,
because
the
invoice
is
the
empty
tray.
You
put
it
in
there.
You
say
I'm
expecting
these
things
now.
The
next
thing
is
groups
and
features,
and
this
is
really
where
you
get
into
the
the
meat
of
of
bindle
versus
other
object.
Storage
mechanisms.
C
Parcels
can
be,
are
really
organized
as
trees
rather
than
flat
lists
if
you're
not
familiar
with
oci
and
anything
with
containers,
that's
a
basically
a
list,
it's
a
vector
or
a
or
a
slice
or
whatever.
You
want
to
call
the
data
structure
of
of
images
that
are
stacked
on
top
of
each
other.
But
the
way
we
express
this
kind
of
silverware
drawer
thing
is
through
trees,
and
so
parcels
can
be
organized
into
groups
and
these
groups
can
be
optional
or
required.
C
There's
a
default
group,
that's
built
into
every
single
bundle,
every
single
bundle,
but
any
any
specific
parcel
can
also
require
a
group.
So
if
you
like,
enable
a
specific
parcel
or
feature
that
you
need
that
can
say,
I
need
something
from
this
group
and
then
individual
parcels
can
have
arbitrary
features
attached
to
them,
so
these
features
can
be
turned
on
or
off
to
r,
to
require
more
of
the
parcels
that
you
need
to
assemble
your
application.
A
Which
are
expressed
in
the
invoice
and
we'll
come
back
to
that
with
some
examples
in
a
moment,
so
that
you
can
kind
of
understand
why
to
us.
This
is
a
really
big
deal,
but
before
that,
let's
talk
about
security
because
it
seems,
like
you
know
all
the
time
in
the
news
right
now
we're
seeing
you
know
messaging
about
or
articles
about
supply,
chain,
attacks
and
various
ways
of
trying
to
inject
malicious
code
throughout
the
process.
A
Now
we
wanted
to
try
and
tackle
problems
like
that
right
out
of
the
gate
with
bindle,
because
it
is
our
experience
that
if
you
layer
on
security
later
it's
effectively
not
layering
on
security,
because
people
will
opt
out
of
it
so
bindles
from
day.
One
are
immutable
right
once
you
push
a
bindle
that
invoice
becomes
is,
is
you
know,
signed
and
then
frozen,
and
it
cannot
change
from
that
point
on.
A
C
A
And
part
the
reason
for
that
is
because
we
wanted
to
have
roles
for
signers.
So
a
lot
of
times
we've
been
talking
about
signatures
as
something
where
it's
like.
Oh
somebody
signs
it
we're
done
with
it
right
now
it's
signed,
but
when
you
think
about
signing,
we
don't
necessarily
trust
the
developer
in
some
occasions,
so
we
might
want
somebody
else
to
sign
in
or
we
might
not
trust
the
place
where
we
downloaded
the
package.
So
we
might
want.
You
know
to
know
that
the
developer
signed
it.
A
So
we
introduced
this
idea
of
roles
where
you
can.
You
can
say:
okay,
I
am
the
developer
of
this
spindle
and
I
am
signing
it
with
my
key.
This
is
what
I
intended
it
to
be.
Now
we
upload
it
to
the
server
the
server
automatically
signs
it
and
says
when
I
got
this
from
developer
x.
These
are
exactly
the
things
I
got
from
them
and
I
have
verified
that
they
are
so
and
we
added
even
another
one
like
the
idea
of
having
an
auditor
who
might
be
a
third
party
or
a
trusted
party.
A
I
only
trust
stuff
from
this
auditor
right
or
I'll
trust.
Anything
from
this
server
or
I
like
this
developer
this
developer
and
this
developer
and
I'll
trust
anything
they
sign.
But
if
it's
not,
if
they
didn't
sign
it,
then
I
want
an
auditor
to
audit
it
and
you
can
start
building
up
those
rules.
However,
your
org
wants
them
or,
however,
you
personally
want
them.
We
just
provide
the
mechanism
so
that
signatures
can
happen.
A
A
So
we
came
up
with
this
simple
application
called
chao
time
sort
of
mental
exercise
here
and
chow
time
is
an
application
that
helps
you
find
the
food.
You
want.
That's
close
to
you
right.
So
it's
like
you,
know,
six
o'clock.
Today
we
come
out
of
the
conference
venue
and
I'm
like
wow.
You
know
I
could
really
go
for
something
good,
I'm
not
totally
sure
what
I
want.
You
pull
out
the
chow
time
app
and
say
I'm
hungry
and
it
says.
Well,
you
know
you
had
noodles.
Last
night
you
had
pizza
the
night
before
you
know.
A
And
then
it
says:
okay,
the
four
or
nearest
taco,
restaurants
that
are
rated
whatever
are
within
this
radius
and
here's
the
one
that
we
think
you'll
chow
time
thinks
you'll
like
the
most.
So
you
can
imagine
an
app
that
works
like
this
right
knows
a
little
bit
about
your
preferences
knows
a
little
bit
about
your
history
because
you've
been
using
it
every
day
and
can
make
some
recommendations
based
on
what
it
believes
that
you
want.
Now
we
can
imagine
a
couple
different
ways
of
implementing
this
right.
A
We
could
use
machine
learning,
algorithms
that
might
be
fairly
intensive,
compute
wise,
but
would
be
very
accurate.
We
could
also
imagine
a
fairly
basic
statistical
model,
that'll
just
say:
hey,
you
know
you
ate
pizza
last
night,
not
going
to
suggest
it
today.
No
real
machine
learning
necessary
there.
You
can
also
imagine
different
data
services
plugged
into
the
back
end
right.
I
could
have
a
small
local
database
of
big
chains
from
around
the
area
that
would
comfortably
fit.
A
A
So
here
we
have
a
couple
different
ways
to
build
the
same
application,
and
when
you
think
about
how
you
might
want
to
run
it,
you
might
want
to
run
it
in
different
modes
right.
If
you
don't
have
any
cell
service,
you
might
prefer
to
run
that
kind
of
faster,
faster
version
with
local
storage
you
might.
If
your
device
is
underpowered,
you
might
want
to
not
want
to
do
the
machine
learning.
A
So
in
these
cases
we
could
imagine
a
single
front
end
where
different
modules
here
can
be
plugged
in,
on
the
back
end,
to
give
us
different
configurations
and
here's
the
important
part
and
the
thing
that's
super
exciting
about
webassembly.
Is
it's
starting
to
look
very
much
like
we'll
be
able
to
build
applications
like
that?
Conveniently
you
know,
with
widix
with
the
component
model,
with
with
type
interfaces
and
things
like
that,
we're
getting
awfully
close
to
being
able
to
do
things
like
that
and
determine
at
run
time.
A
So
bindle's
problem
here
is:
how
do
we
solve
the
packaging
system
such
that
I
can
grab
an
invoice
and
that
invoice
says:
hey
here's
your
chow
time,
application!
Here's
the
main
entry
point,
and
here
are
some
different
options.
You
can
turn
on
or
off.
You
can
use
this
full
database.
You
can
use
the
the
skinny
one.
You
can
use
the
machine
learning
one
you
can
are
just
basic
user
preferences
and
the
application
at
runtime
or
you
as
the
user,
perhaps
intervening
at
runtime
could
say
this
is
the
one
I
want
now.
A
I
want
everything,
local
and
everything
fast
or
no.
I
really
want
you
to
find
that
excellent
restaurant
for
me,
because
I'm
trying
to
impress
people
so
use
the
full
power,
but
it's
a
runtime
consideration
and
bindle
is
attempting
to
through
that
aggregated
object.
Storage
system
provide
a
package
managery
kind
of
experience
that
will
basically
facilitate
all
these
really
cool
technologies.
That
webassembly
is
is
introducing.
A
C
Now,
let's
talk
about
it
with
an
actual
practical
thing
now
this
is
an
example
in
wasm
cloud.
This
is
not
real
and
wasn't
cloud
yet,
but
it's
an
example
of
how
this
could
help
with
a
real
world
a
real
world
thing.
So
let's
go
ahead
and
take
a
look.
Everyone
can
see
that.
Well
enough,
I
put
it
pretty
big,
okay
good.
If
someone
can't
online
just
let
somebody
shout
out
here
in
person,
so
we're
going
to
go
ahead
and
I'll
actually
clear.
C
C
Now
these
providers
are
actually
connectors
that
a
lot
that
bridge
the
gap
between
missing
or
even
stuff
that
will
never
be
added
to
webassembly
and
current
things.
That
could
be
like
a
key
value
store.
It
could
be
an
http
server,
it
could
be
any
of
those
things,
and
so
you
have
to
provide
host
specific
binaries
for
this
to
run
inside
of
your
system,
and
so
all
of
these
are
all
bundled
together.
So
I
took
this
and
I
turned
it
into
a
bundle
to
show
what
kind
of
thing
this
could
do.
C
So,
let's
go
ahead
and
I'm
going
to
just
show
what
an
invoice
looks
like
for
our
for
our
kv
redis
provider,
for
example.
So
this
is
just
using
a
key
value
store,
that's
implemented,
that's
backed
by
redis
instead,
okay,
so
there's
a
lot
of
stuff
here.
First,
we'll
just
work
from
the
bottom
up.
First
you'll
see
these
signatures
here.
So
when
I
created
this,
I
signed
it
with
my
signature.
It's
available
here.
You
can
see
the
signature
use
it
to
validate
the
the
public
key.
C
I
signed
it
of
the
key
I
signed
it
with
and
then
the
role
I
signed
with,
which
was
the
creator
you'll,
also
see
that
the
host
key
from
my
bundle
server
is
also
signed.
It,
which
is
really
nice
because,
as
you
pass
a
bundle
through
various
servers,
because
even
proxy
servers
need
to
sign
it
and
they
sign
it
as
a
proxy
key
role,
and
so
you
can
see
exactly
where
the
bundle
has
been
all
the
way
down
the
chain.
C
So
that's
what
that's
the
security
features
we
were
mentioning
about,
but
you'll
also
see
here
that
we
have
these
groups
that
are
all
specified.
So
we
have
binaries
test
and
the
json
web
token.
So
there's
a
json
web
token.
That's
bundled
with
these
things
to
validate
that
they
are
what
they
are
and
then
you
can
choose
one
of
let's
say
you
had
some
test
binaries
that
you
could
use
that
are
just
mocking
out
a
redis
or
using
a
local
radis
that
it
spins
up
and
then
the
normal
real
binaries
you're
going
to
use.
C
So
all
of
these
are
actually
specified
in
here.
I
think
there
are
14
different
parcels
in
here,
but
you'll
see
that
I
specify
like
okay.
This
is
this
is
part
of
the
jwt
group.
This
is
part
of
the
binaries
group
and
it's
from
windows
and
you'll
see
that
there's
features
here
where
I'm
specifying
okay,
I
have
this
is
for
the
x86
arch
for
windows.
C
C
So
I
created
just
a
mock
example
that
uses
a
bundle
server
and
just
pretends
that
it's
a
wasmcloud
host,
which
is,
for
all
intents
and
purposes
and
node
for
for
this
association,
so
like
I'm,
going
to
I'm
going
to
run
this
provider
on
a
host
somewhere.
So
what
I
can
do
is
it'll
automatically
select
right
here.
So
so
this
is
just
using,
like,
I
said,
bundle
underneath
the
hood,
I'm
going
to
say.
I
would
like
you
to
load
the
key
value
redis
store.
Please.
C
What
the
parcel
looks
like
yeah
right
here-
I
did
right
here,
so
these
are
the
parcels,
so
this
is
the
shot
I
forgot
to
mention
the
shot,
so
here's
the
shaw
and
you
can
specify
the
media
type
and
then
you
have
a
name
and
size,
so
it's
expecting
those
size
and
shot
to
match
everywhere.
It
goes
along
with
the
feature
set.
C
Okay,
I
have
this
claims
one
and
I'm
fetching
the
mac
os
binary
for
you
to
use
it
didn't
have
to
fetch
all
of
them.
So
if
you're
doing
this
in
oci,
you
will
fetch
every
single
artifact
and
in
most
object
storage.
This
is
what
you're
going
to
download
every
single
artifact,
but
now,
let's
say
oh
I'm
running
in
a
test
environment.
Please
just
give
me
a
test
middle
so,
like
I
just
mocked
this
by
passing,
like
a
test
flag,
so
that
would
obviously
be
set
by
whatever
system
using
it.
C
But
now
I
do
it
and
you'll
see
that
it's
changed
to
use.
I
mean
it's
a
mock
thing.
I
didn't
actually
shove
a
real
one
in
there,
but
you'll
see
that
it's
the
test,
bundle
or
test
the
test
binary,
rather
than
the
the
other,
a
real
official
one
which
we
see
up
here,
and
so
this
allows
you
to
save
bandwidth.
It
also
allows
you
to
select
and
assemble
the
specific
things
you
need
for
your
circumstance.
So
in
this
case
it's
super
simple.
It's
like
do.
C
A
C
In
this,
but
there's
multiple,
tooling
things
that
can
be
used
to
generate
this
inside
of
code
and
whatnot.
So
let's
get
to
that
question
of.
Why
does
this
even
matter?
The
first
thing
is
that
this
is
very
good
for
distributed
systems
and,
like
we
mentioned
before,
particularly
with
with
webassembly,
I
can
run
a
heavy
compute
module
if
I'm
running
on
a
big
machine
or
a
light,
compute
module
on
a
smaller
device
and,
like
I
said,
there's,
there's
bandwidth
saving
as
well.
C
The
software
supply
chain
security
aspect
is
another
big
thing
there.
It's
not
the
primary
reason
why
we
create
it,
but,
like
matt
said,
if
you
don't
put
security
in
at
the
beginning,
then
people
and
layered
on
later
people
just
opt
out
of
it.
We've
seen
that
with
kubernetes
we've
seen
that
with
docker,
so
it's
built
in
security-
and
this
is
an
if
statement,
but
I
think
it's
a
strong
argument
to
make.
I
think
we've
already
seen
some
things
we'll
see
more.
C
So
I
say
if
the
future
of
wasm
is
this
swappable
components
idea
bindle
provides
that
storage
layer
that
allows
application
to
developers
to
express
how
that
application
can
behave
with
any
situation
that
it's
in,
whether
that's
this
heavy
compute,
whether
that's
other
specific
requirements
for
your
runtime
or
platform,
it
can
do
that
has
any.
I
missed.
A
You
no,
but
I
think
it's
worth
you
know
kind
of
as
a
kind
of
wrap-up
statement.
You
know
I
led
with
asking
if
they're
you
know,
prompting
with
this
idea
that
we've
got
different
kinds
of
package
managers
right.
We've
got
some
that
are
four
operating
systems
where
an
operator
determines
which
pieces
and
parts
they
want
to
pull
in
when
they
install
something.
A
The
chow
time
example
is
a
good
example
of
that
right,
and
so,
if
we
do
this
well
and
if
web
assembly
works
out
the
way
that
we're
all
hoping
it
will,
then
we
can
build
a
sort
of
package
infrastructure
that
meets
the
needs
of
the
developer
at
development
time.
And
then,
when
it
comes
to
deploying
it
meets
the
needs
of
the
sys,
the
sres,
the
devops
team,
the
operators
right
and
when
we
think
about
where
we
are
in
the
cloud
native
landscape,
we
can
see
this
pendulum
swinging
back
and
forth
between.
A
So
what
we're
hoping
is
that,
if
we
can
start
solving
this
problem
on
the
component
layer
in
webassembly
itself
and
even
on
the
package
manager
here
with
tools
like
bindle
or
something
else
that
works
in
the
same
vein
right,
then
we
can
carve
out
that
right,
sort
of
center
point
where
we
can
separate
the
operator
concerns
and
the
developer
concerns,
and
we
can
build
a
tool.
That's
really
going
to
meet
both
groups
where
they
are,
and
this
we
think,
is
one
step
in
that
particular
direction.
C
C
It
was
a.
It
was
a
specification
first,
the
rust
library
you
see
at
the
link
I
shared
at
the
beginning
is
just
the
rust
implementation.
You
can
implement
a
client,
you
can
implement
a
server.
It
just
has
to
meet
the
things
that
are
inside
the
specification.
So
we
really
just
want
feedback.
We
want
to
make
sure
the
spec's
right.
We
want
to
make
sure
the
software
is
right,
it's
functioning
as
needed.
Do
people
find
it
useful?
Do
they
have
better
ideas?
Any
of
those
things
are
what
we're
looking
for.
B
A
Oh
yeah
you're
going
to
repeat
the
question.
Make
me
a
lot
of
what
you
see
in
bindle
is
definitely
inspired
by
oci.
I
mean
the
the
idea
of
you
know
the
content
address
addressability
of
it
and
hashing
and
shying
things
that
way,
and
we
do
believe
that
you
can
store
a
bindle
in
an
oci
registry.
If
you
can
figure
out
how
to
store
the
invoice
and
the
parcels
both
in
there
and
then
fetch
the
invoice
out.
A
A
C
Yeah,
the
featured
new
groups
of
features
yeah
like
there's
the
the
important
thing
just
to
know
is
that,
like
a
lot
of
people
like
well,
what?
If
we're
still
using
oci
stuff,
we've
thought
about
that.
I
think
you're
going
to
see
things
from
stuff
like
we're
doing,
wasmcloud
and
whatnot,
where
you
might
see
some
oci
compatibility
stuff
to
make
it
easier
for
people
who
want
to
try
this
out.
D
A
Yeah,
there
is
a
lot
here
inspired
by
the
way
that
tough
defines
different
roles.
In
fact,
the
very
presence
of
different
roles
and-
and
I'm
actually
kind
of
looking
forward
to
hearing
opinions
from
people
who
are
who
are
well
into
tough.
Our
interest
was
just
slightly
different
than
what
tough
does
right
in
the
sense
that
tough
is
all
about
how
to
do.
A
The
updates
and
hours
is
really
more
about
package
how
to
how
to
certify
that
an
immutable
package
looks
like
x,
but
the
roles
were
inspired
very
much
by
the
way
tuff
does
things.
We
hope
that
this
was
our
first
pass
at
a
lot
of
this
stuff,
and
we
hope
that
we
will
learn
a
lot
from
the
work
that
tough
and
also
the
work
that
intoto
did
in
toto.
Does
software
supply
chain
and
we
had
when
we
were
working
on
cnab,
we
did
a
lot
of
work.