DEV Community: Timothy McCallum

SpinKube: Orchestrating light, fast and efficient WebAssembly (Wasm) workloads in Kubernetes (k8s)

Timothy McCallum — Wed, 13 Mar 2024 23:16:35 +0000

In this article, we touch on technologies that have had a profound impact over the last decade or so and then reveal how SpinKube has cherry-picked the best parts to provide a way of orchestrating light, fast and efficient Wasm workloads in k8s.

Virtual Machines (VMs)

Using VMs solves several problems compared to running servers directly. By running multiple VMs on a single physical server, we can maximize the use of our hardware infrastructure and reduce costs. Aside from the advantage of better utilisation of hardware resources, VMs also provide us with a level of isolation between different applications sharing the host's hardware. VMs allow us to scale up and down. However, scaling is typically done at the VM level, provisioning more or fewer VMs based on demand.

Containers

Unlike VMs, containers can run multiple instances on a single host without requiring a separate Operating System (OS) environment for each instance.

This translates to faster start-up and deployment times compared to VMs. Containers offer horizontal scaling, allowing each application to be distributed across many containers.

K8s

K8s is a powerful container orchestration platform. It facilitates horizontal application scaling by automatically distributing containers across multiple nodes and ensures high availability by restarting failed containers or rescheduling them on healthy nodes.

K8s also offers built-in service discovery and load-balancing mechanisms, allowing applications to discover and communicate with other services within the cluster, making it easier to build complex microservice architectures.

With continuous monitoring of the health of its containers and nodes, k8s' self-healing capability helps ensure application availability and reliability, making it a popular choice for managing containerized applications.

Overprovisioning

Allocating more resources (CPU, memory, and/or storage) than an application requires goes against the idea of using containers in the first place. Yet overprovisioning is still a common challenge in the container ecosystem; leading to unnecessary costs and resource wastage.

Efficient orchestration of containers is crucial for optimizing application performance. In today's fast-paced world, ensuring optimal performance and quick application response times is of the utmost importance.

By minimizing wastage and controlling costs, you can enhance the overall user experience and meet modern users' expectations.

This is a great segue for discussing cold start times, specifically Spin and Wasm's lightweight and efficient execution model.

Spin and Wasm

The Spin framework leverages the latest developments in the Wasm component model and Wasmtime runtime; designed for fast startup times. Spin is an open-source framework for building and running fast, secure, composable cloud microservices with Wasm. Importantly, in the context of performance, Spin offers several advantages regarding startup times for cloud microservices.

Wasm's Lightweight Execution

Wasm is a binary instruction format designed to be compact and efficient. Its lightweight nature allows efficient resource utilization during startup. Spin and Wasm's fast startup times make them well-suited for scalable cloud microservices architectures. Applications can be quickly spun up or down based on demand, allowing for efficient resource allocation and improved scalability. Spin and Wasm perfectly match a container orchestration platform like k8s.

SpinKube

SpinKube is a new open-source project that streamlines the experience of developing, deploying, and operating Wasm workloads on K8s. It provides hyper-efficient serverless on K8s powered by Wasm. With SpinKube, you can leverage the advantages of using Wasm for your workloads. For example:

Artifacts are significantly smaller in size compared to container images.
Artifacts can be quickly fetched over the network and started much faster.
Substantially fewer resources are required during idle times.

Thanks to Spin Operator, we can integrate with k8s primitives (DNS, probes, autoscaling, metrics, and many more cloud native and CNCF projects).

K8s has a large and vibrant ecosystem with many extensions and plugins. It can be easily extended to integrate with other tools and services. Let's look at the open-source projects that comprise the overarching SpinKube GitHub organization.

The SpinKube GitHub organisation consists of the following individual open-source project repositories:

Spin Operator - facilitating the orchestration of Wasm workloads in k8s
Containerd Shim Spin - the containerd shim implementation for Spin
Spin Kube Plugin - a Spin plugin for interacting with k8s
Runtime Class Manager - the spiritual successor to the kwasm-operator.

The Spin operator uses the Kubebuilder framework and contains a Spin App Custom Resource Definition (CRD) and controller. It watches Spin App Custom Resources and realizes the desired state in the K8s cluster. Aside from the immediate benefits gained by running Wasm workloads in k8s, additional optimizations such as Horizontal Pod Scaling (HPA) and k8s Event-driven Autoscaling (KEDA) can be achieved in a pinch.

SpinKube throws a host of useful functionality into the mix, allowing you to install Spin Operator on an Azure k8s Service (AKS) cluster to deploy your Spin application and much more. You can build and push Spin Operator images. Whether running locally or on a cluster, you can be assured that your orchestration of light, fast and efficient Wasm workloads in k8s is optimal.

The Spin plugin for k8s is crafted to augment Spin's capabilities, facilitating the direct execution of Wasm modules within a k8s cluster. It is a specialized tool for integrating k8s with the Spin command-line interface. By collaborating with containerd shims, this plugin enables k8s to oversee and execute Wasm workloads in a manner akin to conventional container tasks.

The diagram below illustrates application development (using the spin CLI), workload lifecycle, and runtime management.

For more information and documentation, please visit the SpinKube website.

Pickling Python in the Cloud via WebAssembly

Timothy McCallum — Thu, 11 Jan 2024 05:24:19 +0000

I have just finished publishing an article, "Leveraging Python Standard Library via WebAssembly" and no sooner am I struck with the immediate urge of Pickling Python in the Cloud via WebAssembly (Wasm).

Writing Wasm-powered serverless applications in Python is irresistible. I love Python, and I love Wasm, so I guess that makes sense.

With the latest version of Spin I can use the spin new command to scaffold out a new HTTP Python application in seconds:

Creating an Application

$ spin new -t http-py
Enter a name for your new application: pickling-python
Description: Pickling Python
HTTP path: /...

From there if I change into the application's folder and open the application manifest file (spin.toml) for editing:

$ cd pickling-python
$ vi spin.toml

I see the following (a pretty straight forward .toml file):

spin_manifest_version = 2

[application]
authors = ["tpmccallum <tim.mccallum@fermyon.com>"]
description = "Pickling Python"
name = "pickling-python"
version = "0.1.0"

[[trigger.http]]
route = "/..."
component = "pickling-python"

[component.pickling-python]
source = "app.wasm"
[component.pickling-python.build]
command = "spin py2wasm app -o app.wasm"
watch = ["app.py", "Pipfile"]

Adding Redis Storage

I want all this processing and pickling in the cloud (e.g., once built and deployed, no processing or storage will be performed locally). For this to become a reality, I go to my Redis Cloud account and copy the credentials of an existing database, e.g. username, password, URL and port.

I then add the values in the environment and allowed_outbound_hosts configurations at the component.pickling-python "component" level (as shown below):

[component.pickling-python]
environment = { REDIS_ADDRESS = "redis://username:password@my-redis-cloud.redislabs.com:16978" }
allowed_outbound_hosts = ["redis://my-redis-cloud.redislabs.com:16978"]

There is granting network permissions to components and Python component configuration documentation available if you need it. But you should be ok just mirroring what I am doing here (using your credentials, of course).

The Python

The app.py file in the application directory holds all the Python source code needed. You can open your app.py and replace it with the following code (if you are following along):

import os
import json
import pickle
from spin_http import Response
from spin_redis import redis_set, redis_get

# Define a simple example class
class ExampleClass:
    def __init__(self, attribute1, attribute2):
        self.attribute1 = attribute1
        self.attribute2 = attribute2

def handle_request(request):
    # Obtain the Redis address
    redis_address = os.environ['REDIS_ADDRESS']
    if request.method == 'POST':
        # Read the body of the request
        json_str = request.body.decode('utf-8')
        json_object = json.loads(json_str)
        json_object["attribute1"]
        json_object["attribute2"]
        # Create an instance of our ExampleClass using the values from the incoming request
        example_instance = ExampleClass(json_object["attribute1"], json_object["attribute2"])
        # Serialize the instance of our ExampleClass and set the  into Redis as a value
        redis_set(redis_address, "example_instance", pickle.dumps(example_instance))
        # Fetch the previously stored value from Redis and deserialize the value so we can work with an instance of our class
        fetched_instance = pickle.loads(redis_get(redis_address, "example_instance"))
        answer = {"Attribute 1": fetched_instance.attribute1, "Attribute 2": fetched_instance.attribute2}
    return Response(200,
                    {"content-type": "text/plain"},
                    bytes(json.dumps(answer),"utf-8"))

I will pause a moment and explain what this Python code is doing...

The code above:

receives a JSON object as part of an incoming request,
instantiates our ExampleClass using the JSON object's data,
uses pickle.dumps to serialize the instance of the ExampleClass,
stores the instance as bytes in Redis (with the attribute1 and attribute2 values intact),
retrieves the bytes back from Redis and deserializes them into the form of our original ExampleClass instance (with the attribute1 and attribute2 values intact),
creates a Response object,
returns a JSON string that describes the correct state of the ExampleClass.

The build and deploy part is super easy, we just run the following 2 commands:

$ spin build
$ spin deploy

Once deployed, a secure HTTP request from a client can be made. Here is an example of a client's request using the curl command:

$ curl -X POST "https://dev-to-example-zwirrxzu.fermyon.app/" -H "Content-Type: application/json" -d '{"attribute1": 123, "attribute2": 456}'

And voilà, we get the correct response (as follows):

{
    "Attribute 1": 123,
    "Attribute 2": 456
}

How did this go for you? You can contact us on Discord if you get stuck or have any questions.

What's next

In my experience so far, I can use a vast amount of the Python Standard Library to build Wasm-powered serverless applications. The caveat I currently understand is that Python’s implementation of TCP and UDP sockets, as well as Python libraries that use threads, processes, and signal handling behind the scenes, will not compile to Wasm. It is worth noting that a similar caveat exists with libraries that I find on The Python Package Index (PyPI) site. While these caveats might limit what can be compiled to Wasm, there are still a ton of extremely powerful libraries to leverage.

My takeaway is that it is now so easy and quick to develop very powerful serverless web applications using a combination of Python, Spin and Fermyon Cloud.

What combinations of Python can you think of to launch applications for the web? Perhaps you can develop in tandem with a front-end web developer and create dynamic functionality using a combination of HTML/CSS/Javascript on the client side.

I hope this inspires you to create something great!

References:

Leveraging Python Standard Library via WebAssembly
YouTube - Leveraging Python Standard Library via WebAssembly
Fermyon Developer Home
Python logo image attribution Dnu72, CC BY-SA 4.0 https://creativecommons.org/licenses/by-sa/4.0, via Wikimedia Commons