Photo by Anthony Cantin on Unsplash
Launching Sat Beta-1: Still tiny, still mighty
5 min read
Today we're happy to announce that our open source WebAssembly edge compute server Sat is now in beta! We've spent the past few months testing, refining, and simplifying it to enable some essential cloud computing use-cases. Best of all, the original goal of the project is still alive and well — run a single WebAssembly function quickly, efficiently, and with the lowest possible overhead. Sat continues to be statically-compiled, can be run in a distro-less container, and is fully optimized for bare metal on x86 or ARM. It even has an adorable logo now:
There are three main use-cases we've come to rely on Sat for: ephemeral testing, single-function services, and meshed applications. Sat is also being used as the basis for something called the Suborbital Edge Data Plane, which I'll touch on at the end of this post. Sat has proven itself to be very versatile, and its simplicity lends itself to a wide variety of use-cases, both as a building block for larger systems and as a standalone utility.
On the ephemeral testing front, we've been using Sat since the very first release of Suborbital Compute to power function testing in our code editor. Whenever you’re writing code in a Compute-enabled application, the testing pane allows you to execute your function using test data as input. This is one of the most popular features of Compute, as it allows developers to ensure their code is working as designed before deploying the new version. Behind the scenes, each time a function test is run, the Compute builder service launches an ephemeral Sat instance to run the test. Since Sat is able to execute a Wasm module with sub- or single-millisecond startup times, function tests execute as quickly as they do in production.
Sometimes a single function may well be enough for your needs. Sat lends itself perfectly to simple applications because it's able to run as a production-grade API server with zero configuration. Sat can load a Wasm function, acquire TLS certificates via LetsEncrypt, and handle large amounts of traffic, all with a single statically-compiled (dependency free!) binary. This is an incredibly simple way to get sandboxed code running in the cloud with or without containers. We've built some very useful functions for things like rate limiting, session validity checks, and stream processing that can be deployed with no configuration and unlimited horizontal scalability. As you can see in the screenshot below, the simplicity of Sat is one of its greatest strengths, making cloud native Wasm as easy as a single CLI command.
Where Sat begins to really shine is when it's launched as part of a constellation. A constellation consists of three components; an autoscaled group of meshed Sat instances, an application-aware load balancer called
atmo-proxy, and the constellation daemon,
constd. From the start, we wanted the ability to run any Suborbital application on Atmo or a Sat constellation, ensuring that every project built using Suborbital tooling can easily run in a central cloud, on the edge, or in your local development environment. Using
constd, an entire application (including the Directive.yaml, Queries.yaml, static files, and more) can be launched. Each function in your application gets an autoscaled set of Sat instances to handle traffic, ensuring your deployment can scale nimbly even if a single route is getting all the traffic. Best of all, Sat constellations are designed to work in either containerized or bare metal environments, giving it the flexibility to operate in any system you add it to.
One of the main reasons we put so much effort into making Sat as lightweight as possible is for its use in edge computing and globally distributed infrastructure. Since late 2021, we've been working on a next-generation data plane that will power the upcoming hosted version of Suborbital Compute and some very ambitious partnerships that we can't talk about just yet. This project, which we call the Suborbital Edge Data Plane (EDP for short), is something we're building to enable powerful compute in a globally-distributed-by-default way. In early testing, the EDP is able to handle traffic on the order of millions of requests per second, and takes full advantage of the lightweight, sandboxed, polyglot nature of Sat and WebAssembly to execute serverless functions on heterogeneous hardware. We are able to achieve global rollouts of new functions in milliseconds, start serving traffic instantaneously, and support massively multi-tenant deployments.
In the coming days and weeks, we'll share some performance data, use-cases, and demos of Sat on the edge. Our main goal for Suborbital in 2022 is to make globally-distributed computing as easy as writing a function in a language you're already familiar with and running a single command. We believe this capability should be available to anyone, from single developers to large enterprises. We're going to be providing all of the building blocks you'll need to run your own global compute network, and we couldn't be more excited to show you more.
Between Sat, Atmo, Suborbital Compute, and our upcoming EDP, it's never been easier to build cloud native applications with WebAssembly. The launch of Sat Beta-1 is a big step towards making edge compute more accessible to anyone, and a big step towards the next-generation data plane that will power Suborbital Compute, our partners' distributed computing networks, and more. Stay tuned, and keep an eye out for our upcoming blog posts on performance.
P.S. check out our new docs!