Web Assembly (on the server)

© 2022, Amazon Web Services, Inc. or its affiliates. All rights reserved.
WebAssembly (on the server)
Massimo Re Ferrè
Senior Principal Technologist
AWS

I spent 16 years at IBM
I spent 8 years at VMware
Current: 5 years at AWS
28 years in IT (I am old)
x86 server (and virtualization)
Virtualization (and containers)
Containers / Serverless (and …)

Obligatory link to Solomon’s tweet (2019)
https://twitter.com/solomonstre/status/1111004913222324225
That sounds like a
bold statement,
let’s dig in

OK what’s the fuss about? (2021)
TWItter, WE nEEd tHe EdIT BUttON!

Docker announces WASM support (2022)
https://www.docker.com/blog/docker-wasm-technical-preview/

Chapter 1 – Current Status

Physical Server
Where are we (technologically speaking)?
Virtual Machine
Virtual Machine
Container
Container
Container

30 years in 30 seconds
• 1990-2000 The dark age (phisical servers deployments)
• Provisioning lead times of weeks
• Exaggerated resource wasting with gigantic unit of work
• Lots of manual processes
• 2000-2015 The hope (hardware virtualization)
• Provisioning lead times of hours
• Optimized resource configurations with dynamically sizable unit of work
• Still many manual processes (seeds of DevOps)
• 2015-today The light out of the tunnel (containers for the masses)
• Provisioning times of minutes/seconds
• Optimized resource configurations with OS sharing
• Full automation
Fun fact: none of the new stuff
replaced the previous iteration
(niche exceptions apply e.g.
containers on bare metal)

Chapter 2 – WebAssembly

WebAssembly (abbreviated Wasm) is a binary instruction
format for a stack-based virtual machine. Wasm is designed as
a portable compilation target for programming languages,
enabling deployment on the web for client and server
applications.
What is WebAssembly?
https://webassembly.org/

A WebAssembly artifact is a (portable) binary file (.wasm) that
executes “somewhere"
What is WebAssembly?
That’s how I like to think about it

How do you get to this .wasm file?
For example, in Rust, by doing this:
cargo build --manifest-path ./spin-hello-world/Cargo.toml --target wasm32-wasi --release
In go, by doing this:
tinygo build -o myapp.wasm -target wasm ./myapp.go

WebAssembly.instantiateStreaming(fetch(”myapp.wasm"), importObject).then(
(obj) => {
// Call an exported function:
obj.instance.exports.exported_func();
// or access the buffer contents of an exported memory:
const i32 = new Uint32Array(obj.instance.exports.memory.buffer);
// or access the elements of an exported table:
const table = obj.instance.exports.table;
console.log(table.get(0)());
}
);
Where is WebAssembly (today)?
Mostly on the browser

Chromium
Where is WebAssembly (today)?
V8 (JS and WASM engine)
JavaScript code
WASM artifact
user interaction
execution
execution
(Very) rough visual representation of Chromium support for WebAssembly
(the Firefox runtime is called SpiderMonkey and it would look similar-ish)

1. Small footprint (relative to what?)
2. Near native performance / almost no cold starts (relative to what?)
3. Secure sandbox (relative to what?)
4. Multi-language (if the language supports it)
5. Compiled artifact is OS independent (Mac, Linux, Windows)
6. Compiled artifact is CPU independent (hello Arm!)
Why WebAssembly?

Chapter 3 – WASI

Traditional
computing (non browser)
Browser
Can we bring WASM everywhere?
Cloud region / Data Center
Edge
location
Edge
location
Edge
location
Edge
location
Edge
location
Edge
location
Browser
Browser
Browser
Browser
Browser
Browser
Browser
Browser
Browser
Browser
How can we run WASM
byte-code on non
browser traditional
computing?

“Developers are starting to push WebAssembly beyond the
browser… but we don’t yet have a solid foundation to build upon.
Code outside of a browser needs a way to talk to the system—a
system interface. And the WebAssembly platform doesn’t have
that yet.”[ Lin Clark, 2019 ]
Why WASI?
https://hacks.mozilla.org/2019/03/standardizing-wasi-a-webassembly-system-interface/

“WASI stands for WebAssembly System Interface. It's an API …
that provides access to several operating-system-like features,
including files and filesystems, Berkeley sockets, clocks, and
random numbers… It's designed to be independent of browsers,
so it doesn't depend on Web APIs or JS, and isn't limited by the
need to be compatible with JS…”
What is WASI?
https://github.com/bytecodealliance/wasmtime/blob/main/docs/WASI-intro.md

• The list of runtimes that supports WASI/WASM is long and growing
• They are written in different languages, some use V8, some use
other technologies
• They are (often) available for multiple OSes and architectures
• This is a list of all available WASM/WASI runtimes
(https://github.com/appcypher/awesome-wasm-runtimes)
Where is WASI?

Docker adds WASM support
One of the many
WASM runtimes
Your standard
Linux containers
https://www.docker.com/blog/docker-wasm-technical-preview/

Native run experience Vs Docker run experience
> docker run --runtime=io.containerd.wasmedge.v1
--platform=wasi/wasm32
mreferre/hello-rust:latest
Hello from main!
FROM scratch
COPY hello-rust.wasm /hello-rust.wasm
ENTRYPOINT [ "hello-rust.wasm" ]
hello-rust.wasm
> wasmer hello-rust.wasm
Hello from main!
Dockerfile

Chapter 4 – What are people doing w/ WASM?
[ Warning: this is where it gets complicated ]

How people are using WASM
(outside of the browser and in no particular order)
Operating System
NGINX
NGINX Interpreter Interpreter
App
App module
Program binary
module
WASM/WASI runtime
Program binary
module
WASM-ified object

Chapter 5 – Detour: how to think about containers

• They are essentially a packaging format
• Containers alone and per se no longer describe runtime
characteristics and requirements
• I can use containers to package traditional applications and run
them as long-running processes on ECS/Fargate or Kubernetes
• I can use containers to package functions and run them in Lambda
• And yes you can also package WASM modules in containers !
How should we think about containers?

Physical Server
“Containers” characteristics and requirements
VM
Container
microVM
Container
I use this as a ”fat” container
- Bring any code you want
- Better life cycle than VMs
- Immutability over patching
- Dockerfile over AMI
- Infrastructure agnostic
- Security is critical
- Cold starts are nice to (NOT) have
- Not wasting resources is desirable
I use this as a ”function” container
- Focus on writing code
- Forget about infrastructure
- Dockerfile over Zip
- Security is critical
- Cold starts are critical
- Not wasting resources is critical
Fargate task
Lambda function

Chapter 6 – Where does WASM fit?
[ …into the compute primitives we know ]

Physical Server
What is the role of WASM in the current stack?
Virtual Machine
Virtual Machine
Container
Container
Container
Should/could WASM replace the container?
(and run inside the VM)
Should/could WASM replace the VM?
(and run on bare metal)
Should/could WASM run inside the container?

• It’s incredibly hard to compare technologies when they are used with
different characteristics and for different purposes
• Containers as “functions” or as “fat containers”?
• WASM as “a function” or as “a packaging mechanism for NGINX / the
Python interpreter”?
• WASM is definitely throwing a big curveball into the industry
They are all hard questions

Containers/VMs Vs WASM value prop overlap
Containers
VMs
WASM
Language agnostic libraries
Infrastructure packaging
Sandboxing untrusted code
Dev features
Ops features

• Both VMs and containers are application agnostic technologies
• You can take anything a dev built and run it in a VM or container
• WASM requires dev intention
• The line between “code” and “its ops” is blurry
• There is no clear Dev and Ops decoupling in WASM
• WASM tooling still maturing (some languages are ahead than others)
Important

Chapter 7 – A science experiment (for fun)

WAGI (run WebAssembly WASI binaries as HTTP handlers)
Source: https://www.youtube.com/watch?v=9NDwHBjLlhQ
The Fermyon Spin framework
supports WAGI
(https://github.com/fermyon/spin)

Spin on multi-compute (EC2, Fargate, Lambda)
ALB
Fargate Fargate
Fargate
EC2
ECS service
Lambda
EFS
ASG
This adpter turns an event
into a local HTTP request
AMI packaging
Container image
packaging
Multi-concurrency
Single-concurrency
(1 instance per http request)
Wasm files
Web process binary (Spin)
https://github.com/mreferre/spin-wasm-multi-compute

Source: https://www.youtube.com/watch?v=9NDwHBjLlhQ
This is what you may want to do
https://www.cncf.io/blog/2021/0
8/25/webassembly-serverless-
functions-in-aws-lambda/

Source of screenshots (credit): https://www.youtube.com/watch?v=9NDwHBjLlhQ
But this is what we are doing
in our experiment

Spin on multi-compute (EC2, Fargate, Lambda)
Lambda cold start (@ first invoke)
EC2, Fargate and Lambda target groups

• WASM (and to some extent WASI) have been in the cooking for some
time…
• … but the “wow effect” (outside of specific circles) has not been close
to that of VM and containers technologies
• “Containers have been around for 30 years and grew big only in the
last 7-8” I hear you say…
• … it almost feels like WASM needs a “Docker”. Will Docker be it? Or
Fermyon? Or…..?
Conclusion

- https://it20.info
- https://twitter.com/mreferre
- https://github.com/mreferre
Thanks & stay in touch!

Web Assembly (on the server)

More Related Content

Similar to Web Assembly (on the server)

More from Massimo Ferre'

Recently uploaded

Web Assembly (on the server)