►
From YouTube: Why (and How) We Wrote a WebAssembly CMS - Matt Butcher & Radu Matei, Fermyon Technologies
Description
Why (and How) We Wrote a WebAssembly CMS - Matt Butcher & Radu Matei, Fermyon Technologies
Our website, Fermyon.com, is powered by a cloud-side CMS written specifically to be compiled to WebAssembly. Bartholomew (our CMS) is blazingly fast, SEO-optimized, and consumes minimal system resources. It is easier to use than the popular static site generators, and has all the benefits of a dynamic CMS. Best of all, it shows the promise of WebAssembly on the cloud side. In this talk, we share the design of this CMS and talk about how it's running. We'll talk about the limitations we encountered (and overcame) with WebAssembly, as well as our early performance and optimization work. Along the way, we will talk about why we chose HashiCorp Nomad as our clustering technology. And we'll introduce Wagi (WebAssembly Gateway Interface), the HTTP engine that powers our CMS.
A
Program
committee
here
was
myself
and
sherry
lindsey
and
taylor,
all
from
cncf
and
divya,
who
presented
the
webassembly
text
file
presentation
earlier
today,
but
the
two
people
who
have
consistently
worked
behind
the
scenes
to
make
wasmday
happen
before
in
la
again
here
are
ralph
scholagi
and
liam
randall.
So
please
give
them
a
round
of
applause.
A
I'm
gonna
gonna
ask
for
a
favor,
though
liam
randall
has
unfortunately
spent
the
day
in
an
airport
and
I'm
hoping
that
he
is
watching
on
the
live
stream.
So
if
you
can,
you
know
do
what
you
can
to
direct
the
applause
toward
the
camera.
Hopefully
we'll
get
a
round
of
applause
for
liam
he's
worked
tirelessly
behind
the
scenes.
So
just
for
liam,
please
one
more
round
of
applause.
A
A
We
believe
that
you
know
we
kind
of
see
waves
in
technology
and
we
believe
we're
about
to
see
the
next
wave
of
cloud
computing
and
we
think
that
web
assembly
is
really
going
to
play
a
really
crucial
role
in
that
next
wave
of
cloud
computing.
So
we're
really
excited
to
present
this,
to
talk
about
some
of
the
things
we've
done
and
to
thank
the
community
for
all
all
the
really
cool
stuff
that's
coming
out.
I
just
I.
A
I
would
like
to
list
a
whole
whole
bunch
of
projects
that
I've
worked
on
in
the
past,
but
people
who
know
me
tend
to
know
me
from
the
illustrated
children's
guide
to
kubernetes,
which
I
wrote
along
with
karen
chu.
So,
if
you've,
if
I
lapse
into
childlike
explanations
of
things,
you'll
totally
understand
why
radu
matai
down
there
is
my
co
is
the
co-founder
one
of
the
co-founders
of
fermion.
A
He
really
is
around
computers
all
the
time,
but
he
does
say
that
when
he's
not
around
computers,
he
enjoys
cycling
and
boba
tea
and
things
like
that.
I'm
not
sure
when
he
is
not
around
computers,
though
also
I've
been
asked
a
couple
of
times
if
we
are
going
to
present
on
finicky
whiskers
again
today
we
are
not.
We
talked
about
that
at
dockercon
earlier.
We
will
talk
about
it
again
at
hashi,
confident
open
source
summit,
but
we
have
something
very
different
to
present.
Today
we
started
fermion
in
november
of
2021.
A
Part
of
the
reason
for
that
is
because
we're
engineers
and
there's
nothing
engineers
like
more
than
re-implementing
something
but
really
the
reason
for
us
was
that
we
looked
around
the
webassembly
ecosystem
and
saw
lots
and
lots
of
great
projects.
We
ourselves
had
worked
on
many
many
projects,
crestlin
wagy
and
bindle
and
stuff
like
that,
and
I
personally
had
contributed-
probably
20
hello
world
programs
to
the
webassembly
ecosystem,
and
so
we
decided
all
right.
We
don't
want
to
lead
with
another
demo.
A
We
want
to
be
able
to
lead
with
something
that
is
beyond
a
regular
demo,
maybe
something
that
we
could
run
in
production,
maybe
something
that
we
felt
like
would
really
exercise
a
lot
of
webassembly
as
it
is
today
and
then
be
able
to
demonstrate
to
people.
No.
This
is
a
technology
that
is
ready
for
production
use.
A
Now
I'm
kind
of
inherently
impatient,
and
so
you
won't
hear
anything
in
my
talk
about
well,
you
know
we
needed
to
wait
for
networking
or
we
need
to
wait
for
this
or
that
kind
of
thing.
Instead,
what
you'll
hear
is
we
looked
at
the
technology
and
said
we
can
build
cool
stuff
with
this
today
we
can
run
it
in
production
and
I
think
we
can
produce
some
really
cool
results.
A
We
were
hearing
people
saying
to
us.
Oh,
I
don't
know
fermion,
you
know,
don't
you
think
you
might
be
a
little
too
early
into
the
market
or
don't
you
think
you'd
like
to
wait
until
maybe
networking
is
done
or
maybe
threading
is
done.
You
can't
really
build
anything
useful
in
wasm
yet,
and
we
really
I
mean
it
kind
of
got
under
our
skin.
We
went
all
right.
We
just
kind
of
want
to
prove
that
we
really
can
build
something
fun
and
something
cool
and
something
that
we
could
run
in
production.
A
A
So
a
lot
of
the
inspiration
for
bartholomew
or
cms
was
drawn
from
drupal,
but
not
all
the
features,
some
of
them
we
took
over
for
we
we
carried
on
in
the
tradition
of
jekyll
and
hugo
and
the
static
site
generators,
because
we
liked
the
way
that
it
was
very
simple
to
write
content.
You
could
write
it
in
markdown
and
put
a
little
header
at
the
top,
and
basically
you
working
in
your
text
editor
or
your
code,
and
that
was
really
comfortable
for
us,
and
so
we
borrowed
mark
down
as
the
text
format
we
borrowed.
A
We
used
tommel
as
the
header
format,
and
you
know
I
think,
built
something
that
really
takes
the
things
we
liked
about
static
site
generators
and
the
things
we
like
about
dynamics
site
generators.
Now,
once
it's
dynamic,
you
need
ways
to
extend
it
right.
You
want
to
be
able
to
do
things
like
dynamically
list,
which
things
are
available
right
now
or
allow
people
to
sort
things.
A
So,
of
course,
we
added
a
scripting
language,
because
we
all
need
another
scripting
language
we
used
rye,
which
is
actually
a
really
cool
project
out
there.
That
is
sort
of
like.
I
guess
it's
rust
script,
sort
of
it
borrows
the
syntax
of
rust,
it's
dynamically
typed,
at
least
to
a
degree,
very
easy
for
us,
as
as
rust
developers
to
pick
up
and
start
using
to
do
things
like
listing
out
the
blog
post
and
doing
you
know,
modifications
of
where
things
showed
up
on
the
screen.
So
we
used
drive
for
our
scripting
language.
A
Then
we
chose
a
template
engine
I
was
helm,
is
one
of
my
projects
and
I
think
honestly,
one
of
the
bigger
mistakes
I
made
with
helm.
If
not,
the
biggest
was
not
thinking
hard
about
the
template
language
that
I
picked.
I
used
ghost
template
language
at
the
time.
Nobody
was
really
using
it.
I
spent
lots
and
lots
of
time
documenting
it.
It
was
very
frustrating
to
a
number
of
people.
I
think
it
still
is
one
of
the
more
frustrating
features
of
helm,
and
so,
as
we
approached
this,
I
went
all
right.
A
I'm
going
to
take
a
very
different
approach.
Instead
of
going
with,
you
know,
what's
the
most
ready
at
hand,
one
I'm
going
to
go,
find
one
that
people
say
they
like,
and
I'm
going
to
use
that
one
instead
handlebars
was
very
popular
in
the
javascript
world.
Has
lots
and
lots
of
people
who
use
it?
There
are
books
about
it.
There
are
articles
all
over
the
place
and
I'm
like
okay.
Well,
that
will
work.
So
we
found
a
handlebars
library
and
used
that
as
a
template
engine.
A
We
also
wanted
to
make
sure,
as
a
new
company
entering
a
new
space
that
we
had
a
lot
of
seo
optimizations
a
lot
of
performance
optimizations,
because
one
of
the
important
things
to
us
is.
If
we're
going
to
tell
people
about
webassembly,
we
need
people
to
find
us
so
that
they
can.
You
know,
read
about
webassembly,
and
so
we
spent
a
lot
of
time
up
front,
designing
the
cms
so
that
you
know
the
the
ordering
of
the
source
would
be
correct.
We
would
use.
We
would
follow
all
the
specifications
for
best
practices.
A
I
need
a
good
catchy
title
right,
so
that
was
really
interesting,
focus
that
we
had
early
on
and
then,
of
course,
the
last
one
ronan,
our
designer
who
did
the
slide
designs
here:
the
fermion
logo,
the
website
design
he's
an
amazing
designer,
an
amazing
html,
css
wizard
as
well,
and
we
wanted
to
give
him
the
freedom
to
do
things
the
way
he
wanted.
So
we
wanted
to
make
the
system
very
easily
themeable,
so
he
could
pick
his
own
theme
engine.
He
could
pick
his
own
css
framework
and
javascript
libraries
and
bring
all
of
that.
A
So
this
is
a
very
hefty
batch
of
features
to
be
using
in
a
system
that
people
are
saying
I
don't
know,
might
not
be
production
ready.
Yet
I'm
not
sure
you
can
build
anything
with.
So
we
really
took
on
this
challenge
of
saying.
We
think
we
can
build
something
really
cool
with
webassembly,
as
it
is
today.
A
What
language
did
we
choose
to
write
it
in?
Well,
we
chose
rust.
Why
did
we
choose
rust
because
we
like
rust,
I
mean
there
honestly
wasn't
much
more
of
a
reason
than
that
we
were
like.
Oh,
we
have
really
like
crust.
We
could
have
written
it
in
an
assembly
script.
We
could
have
used
tiny,
go.
We
actually,
the
fermion
site
does
have
components
written
in
a
number
of
different
languages,
including
grain
and
tiny,
go,
and
now,
with
finicky
whiskers.
We
have
ruby
in
there
as
well.
So
we
we
built
bar,
we
built
bartholomew.
A
A
We
just
used
the
ryze
scripting
engine,
as
is
we
use
the
handlebars
template
engine,
as
is
we
use
the
tomml
parser
as
is
and
so
on,
and
so
on,
and
the
only
real
library
that
we
used
that
wasn't
that
was
very
specific
to
what
we
were
doing
is
the
spin
core
library
that
roddy
will
show
a
little
bit
later,
as
we
look
at
some
of
the
code
generation
and
stuff.
So
really
we
were
trying
to
just
prove
once
again
in
another
dimension.
A
Another
of
the
dimensions
on
this
whole
thing
right
that
we
could
build
something
with
web
assembly
using
off-the-shelf
components
without
having
to
do
any
forks
or
or
anything
like
that
comment
things
out
or
anything
like
that
and
build
a
feature
set.
That
is
a
real
content
management
system,
not
a
toy,
not
a
demo,
so
bartholomew
was
originally
written
on
waggy,
which
is
one
of
the
projects
we
did.
Waggy
is
webassembly
gateway,
interface,
it's
basically
cgi
for
web
assembly,
as
we
developed
our
next
gen
execution
context
called
spin.
A
We
switched
all
these
things
over
to
the
spin
framework
and
then,
as
as
we
went
to
deploy,
we
realized.
We
could
write
a
file,
so
add
a
file
server
into
the
cms.
We
could
add
in
you
know
a
redirecting
library
that
you
know
does
307
redirects
or
things
like
that,
or
we
could
write
all
of
those
as
separate
webassembly
modules
and
then
just
basically
line
them
all
up
in
the
spin
configuration
and
and
mount
them
to
different
pads
on
there
and
basically
treat
our
web
server.
A
Our
web
front
end
the
fermion.com
website
as
a
batch
of
microservices,
so
the
file
server
is
a
microservice
favicon
fava
favicon,
depending
on
how
you
prefer
pronouncing
that
that's
a
microservice
redirecting
is
a
microservice
they're,
all
written
in
different
languages,
and
so
we
assembled
part
of
the
bartholomew
cms
out
of
little
separate
projects.
That
then,
are
totally
reusable
and
we
ended
up
reusing
the
file
server
all
over
the
place.
We
use
it
on
spin.fermion.dev,
we
use
it
on
finicky,
whiskers
and
other
places
as
well.
A
So
from
these
things
we
assembled
a
content
management
system
we
launched
on
february,
8th
and
thus
far
we
have
not
had
any
downtime.
On
the
web
assembly
side.
We
had
one
case
where
our
load
balancer
tipped
over
but
had
nothing
to
do
with
any
of
the
web
assembly
side.
So
we
we
feel
like
we
demonstrated
that
we
could
run
web
assembly
in
production
with
a
real
workload,
and
so
we
started
testing
it.
Fortunately,
the
internet
helped
us
test
it.
When
things
trended
on
different
news
sites,
we
saw
huge
amounts
of
traffic
come
in.
A
At
one
point,
we
had
somewhere
upwards
of
2000
concurrent
requests
coming
in.
We
were
running
on
three
t2
small
instances
on
ecs,
because
we're
a
startup
and
our
budget
was
tight
right,
and
so
you
know,
kubernetes
cluster
takes
at
least
large
instances
before
you
can
even
start
it,
and
we
were
running
it
on
small
instances
and
watching
the
traffic
come
in
and
go
oh,
but
it
held
up
held
up
remarkably
well.
A
We
actually
never
saw
cpu
utilization
jump
above
70
memory
stayed
constant
at
about
40,
even
when
we
were
under
tremendous
load
and
the
most
exciting
thing
was
when
we
ran
all
of
this.
Through
the
google
page
speed
test,
we
scored
a
99
out
of
100
and
we
were
averaging
about
53
milliseconds.
For
response
time
over
s
cell
in
a
round
trip,
so
we
were
just
like
absolutely
ecstatic
over
what
we
were
saying.
B
Hello,
so
one
of
the
things
that
we
had
to
build
first
of
all,
the
content
management
system
was
bartholomew,
but
the
second
part
was
actually
running
it
and
accepting
web
requests
and
then
returning
so
right
now
you
can
try
bartholomew
using
spin,
which
is
our
open
source
framework
for
building
microservices
on
top
of
webassembly,
and
we
have
a
tiny
template
for
starting
up
a
new
bartholomew
website.
So
you
can
use
the
spin
cli.
B
We
have
a
couple
of
templates
and
we'll
see
the
a
tiny
go
example
in
a
couple
of
seconds,
but
what
you
can
do
is
do
a
spin
new
bartholomew,
and
at
this
point
you
have
the
building
blocks
for
creating
a
new
website
with
bartholomew,
and
all
you
have
to
do
to
write.
A
new
page
is
just
what
you
would
expect
with
a
static
site
generator,
which
is
add
a
new
markdown
file.
A
B
B
So
we've
seen
how
bartholomew
takes
your
markdown
content
and
templates
and
renders
your
page,
but
the
thing
that
we
haven't
seen
yet
is
what
actually
happens
when
you
take
an
application
than
is
in
the
content
management
system
and
try
to
run
it
and
try
to
compile
it
to
webassembly.
So
the
second
thing
that
we
want
to
show
is
spin,
which
we've
talked
a
bit.
We
touch
it
a
little
bit
on,
but
spin
is
our
open
source
framework
for
building
microservices
with
webassembly
and
running
them
at
scale.
B
B
Everyone
is
familiar
with
writing
a
function
that
takes
an
http
request
and
returns
an
http
response
and
using
all
the
libraries
you
would
normally
use
when
handling
web
requests,
regardless
of
the
programming
language.
So
we've
seen
throughout
the
day,
people
demoing,
rust
and
people
talking
about
rust
is
absolutely
amazing
in
general,
and
particularly
at
building
webassembly
applications,
but
we're
also
really
really
big
fans
of
tiny
go
and
we'll
see
in
a
second
how
you
can
get
started
with
your
first
spin
microservice
with
tiny
go
and
the
same
thing
right.
B
We
want
to
be
able
to
reuse
the
standard
library
objects
so
if
you've
ever
written
a
go,
handle
handler
func
to
handle
web
requests.
This
is
literally
just
using
the
net
http
package,
so
you're
writing
a
function
that
takes
an
http
response.
Writer
and
the
request,
and
you
can
manipulate
that
and
spin
will,
will
return.
B
It
will
instantiate
it.
It
will
execute
the
handler
function
and
then
return
the
response.
So,
let's
see
how
we
can
really
start
something
like
that.
So
same
as
before,
we
have
a
couple
of
templates
that
that
we
maintain
for
for
spin.
We
have
http
written
in
tiny,
go
rust
and
then
the
bartholomew
one
that
we
just
saw.
B
So
we
can
do
the
same
thing
and
then
spin
will
start
a
web
listener
and
whenever
we'll
have
incoming
requests,
it
will
respond.
We've
seen
earlier
and
we've
seen
that
program
talk
about
tiny
go
and
how
awesome
and
how
small
and
how
fast
it
is,
but
and
we've
seen
us
talk
about
webassembly
and
how
it
runs
bartholomew
and
how
it
runs
our
website.
B
B
The
response
times
as
measured
by
the
client
executing
webassembly
modules,
written
in
tiny
go
is
on
average
153
microseconds
and
in
a
span
of
10
seconds,
we
managed
to
handle
300
000
requests
all
and
for
each
request.
What
happens?
Is
we
take
a
web
assembly
module?
We
instantiate
it.
We
call
the
function
defined
with
the
component
model
with
with
bind
gen
and
then
execute
the
function
and
return.
The
result
all
happening
within
153
microseconds,
as
measured
by
a
client.
B
So
we're
really
excited
about
spin
and
we're
excited
about
people
from
the
community.
Joining
we've
already
seen
a
lot
of
external
contributors
and
we're
really
really
thankful
for
that.
But,
more
importantly,
what
I
think
we
all
want
to
want
to
do
is
give
a
big
shout
out
and
thank
you
to
the
webassembly
community.
B
None
of
the
work
that
we
have
seen
here
today
from
9
a.m
would
have
been
possible
without
all
the
amazing
people
working
on
the
web
assembly
standards
and
the
webassembly
implementations,
and
I
want
to
give
a
particular
shout
out
to
all
the
people
at
in
the
bytecode
alliance
and
the
web
and
the
western
time
developers
for
all
the
amazing
work
that
they
keep
putting
out.
So
I
would
really
like
to
give
a
round
of
applause
to
all
the
amazing
people.