Rust on Thorsten Hans

Out Now: Building Serverless Applications with WebAssembly & Spin

Tue, 13 Oct 2026 08:45:00 +0200

Hey friends 👋🏼,

The wait is finally over! After countless early mornings, extensive refactorings, and hours spent obsessing over every code sample and diagram, the first version of Building Serverless Applications with WebAssembly & Spin is officially live.

You can grab your copy right now on Leanpub:

👉 https://leanpub.com/building-serverless-apps-with-wasm-and-spin

Building Serverless Applications with WebAssembly & Spin

What the Book Is About

Server-side WebAssembly represents the next major evolution in cloud architecture. By combining sub-millisecond cold starts, near-native performance, and robust sandboxed isolation, Wasm components eliminate the overhead of traditional containers and function-as-a-service platforms.

A comprehensive guide on authoring plugins for Fermyon Spin

Fri, 25 Aug 2023 10:05:15 +0200

Did you know that you can extend the spin CLI with custom plugins that integrate seamlessly and feel like functionality provided by Fermyon itself?

No? No problem!

In this article, we will explore how I build the check-for-update plugin - a simple Spin plugin that allows you to check if your local installation of the spin CLI is outdated. On top of building the actual Spin Plugin, we’ll also go through the process of testing and distributing the check-for-update plugin. Finally we’ll wrap up this article by adding the custom Spin Plugin to the Spin Up Hub, to ensure users can discover it.

Weekly Rust Trivia: How to use pattern matching

Thu, 03 Aug 2023 13:00:00 +0200

Weekly Rust Trivia is a problem-oriented series of articles that assist developers while learning Rust. Every article solves simple, everyday development tasks using the Rust standard library or leveraging popular and proven crates.

Question: How to use pattern matching in Rust?

In Rust, pattern matching is a powerful language feature that allows you to destructure data and match it against specific patterns. It helps you handle different cases and extract values from complex data structures with concise and readable code. The match keyword is used to perform pattern matching. Inside a match block, you define patterns and corresponding code blocks for each pattern. When the input data matches a specific pattern, the corresponding code block will be executed.

Weekly Rust Trivia: How to share state between threads

Thu, 27 Jul 2023 13:00:00 +0200

Question: How to share state between threads in Rust?

In Rust, we have the ability to share data between threads by using concurrent data structures and synchronization tools provided by the Rust standard library. The most popular concurrent data structures in Rust include Arc (atomic reference counting) and Mutex (mutual exclusion). These allow multiple threads to access shared data in a safe and synchronized manner.

Weekly Rust Trivia: How to write a function-like macro

Thu, 20 Jul 2023 13:00:00 +0200

Question: How to implement a function-like macro in Rust?

Function-like macros in Rust are powerful tools that allow you to define macros that resemble function calls. They can take in arguments and generate code based on those arguments. Function-like macros are defined using the macro_rules! keyword and a set of rules that define patterns and transformations. For demonstration purposes, we’ll define the factorial macro, which will generate code to calculate the factorial of a given number:

Weekly Rust Trivia: How to write an HTTP API with Actix

Thu, 13 Jul 2023 13:00:00 +0200

Question: How to implement the builder pattern in Rust?

To create an HTTP API with Actix, we must add the actix-web crate to our project. We can add it using cargo add:

# Add actix-web as dependency
cargo add actix-web

Having the crate added to our project, we can move on and use Actix to implement our HTTP API. First, we will implement two handlers, responsible for constructing HTTP responses. actix-web provides macros like post, get, … with which we can decrate our handler functions to describe how Actix should expose them via HTTP:

Weekly Rust Trivia: How to Implement the Builder Pattern

Thu, 06 Jul 2023 13:00:00 +0200

Question: How to implement the builder pattern in Rust?

The derive_builder crate provides a macro which allows us to satisfy the builder pattern for your individual structs without writing custom code.

First let’s add the dependency using cargo add:

Weekly Rust Trivia: How to Implement a Generic Stack

Thu, 29 Jun 2023 13:00:00 +0200

Question: How to implement a generic stack in Rust?

To implement a generic stack, we can simply create a custom struct wrapping a vector (Vec<T>):

struct Stack<T> {
    items: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Stack<T> {
        Stack { items: Vec::new() }
    }

    fn push(&mut self, item: T) {
        self.items.push(item);
    }

    fn pop(&mut self) -> Option<T> {
        self.items.pop()
    }

    fn is_empty(&self) -> bool {
        self.items.is_empty()
    }

    fn size(&self) -> usize {
        self.items.len()
    }
}

The implementation (impl<T> Stack<T>) uses a generic type T to allow it to store any type of data. The Stack struct has four methods: new, push, pop, is_empty, and size:

Weekly Rust Trivia: How to Retrieve Image Dimensions

Thu, 22 Jun 2023 13:00:00 +0200

Question: How to retrieve the dimensions of an image in Rust?

The image crate provides necessary functionality to work with images in Rust. We can combine functionality provided by the crate with the path module from Rusts standard library to solve this trivia. We also use the anyhow crate, to streamline error handling.

Weekly Rust Trivia: How to create a TCP Server

Thu, 15 Jun 2023 13:00:00 +0200

Question: How to create a TCP server in Rust?

We can use the io and net and thread modules from Rust standard library this trivia.

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::thread;

fn handle(mut stream: TcpStream) {
    // 64 KB buffer for demonstration purposes
    let mut buffer = [0; 65536];

    loop {
        let bytes_read = match stream.read(&mut buffer) {
            Ok(0) => return, // End of stream
            Ok(n) => n,
            Err(_) => return, // Error reading from stream
        };

        // Echo the data back to the client
        if let Err(_) = stream.write(&buffer[..bytes_read]) {
            return; // Error writing to stream
        }
    }
}

The handle function takes in a TcpStream object representing a client connection.

Weekly Rust Trivia: How to Implement Binary Search

Thu, 08 Jun 2023 13:00:00 +0200

Question: How to implement binary search in Rust?

All we need to implement binary search in Rust is bringing the cmp module into scope. The cmp::Ordering enum and the cmd::Ord trait provide everything required to implement a generic binary search supporting all types implementing the Ord trait.

Weekly Rust Trivia: How to Read a CSV File

Thu, 01 Jun 2023 13:00:00 +0200

Question: How to read a .csv file in Rust?

The csv crate provides necessary functionality to work with .csv files in Rust. We can combine functionality provided by the crate with the fs module from Rusts standard library to solve this trivia. We also use the anyhow crate, to streamline error handling.

How to use Azure Cosmos DB as a key-value store for Fermyon Spin

Fri, 26 May 2023 10:04:05 +0200

With the 1.2.1 release of Fermyon Spin, we can now use Azure Cosmos DB as a key-value store for persisting data when building serverless applications. In this article, I guide you through setting up the necessary infrastructure and creating a fairly simple app to store and retrieve arbitrary values using Azure Cosmos DB as the key-value store.

All code shown in this article is also available on GitHub at https://github.com/ThorstenHans/spin-kv-azure-cosmosdb .

Weekly Rust Trivia: How to Compute a SHA256 Hash of a File

Thu, 25 May 2023 13:00:00 +0200

Question: How to compute a SHA256 hash of a file in Rust?

The sha2 crate is an implementation of cryptographic hash algorithms that we can use to compute hashes. We can combine functionality provided by the crate with the fs and io modules from Rusts standard library to solve this trivia. We also use the anyhow crate, to streamline error handling.

Weekly Rust Trivia: How to Download an Image to a File

Thu, 18 May 2023 13:00:00 +0200

Question: How to download an image from the web and store it in a file using Rust?

The reqwest crate allows us to create HTTP requests with ease, we can combine functionality provided by the crate with the fs and io modules from Rusts standard library to solve this trivia. We also use the anyhow crate, to streamline error handling.

Weekly Rust Trivia: How to Get all Files in a Directory

Thu, 11 May 2023 13:00:00 +0200

Question: How to get a vector (Vec<String>) containing all filenames of a particular directory in Rust?

We can use the fs and io modules from Rust standard library this trivia.

use std::{fs, io};

fn get_files_in_directory(path: &str) -> io::Result<Vec<String>> {
    // Get a list of all entries in the folder
    let entries = fs::read_dir(path)?;

    // Extract the filenames from the directory entries and store them in a vector
    let file_names: Vec<String> = entries
        .filter_map(|entry| {
            let path = entry.ok()?.path();
            if path.is_file() {
                path.file_name()?.to_str().map(|s| s.to_owned())
            } else {
                None
            }
        })
        .collect();

    Ok(file_names)
}

In this example, we pass the path of the desired directory as argument to the get_files_in_directory function. We then use the fs::read_dir() method to get a list of all entries in the directory, which returns a std::fs::ReadDir iterator. We use the filter_map() method to filter out any None values from the iterator, then check whether each entry is a file or a directory using the is_file() method of the std::path::Path struct.

A First Glance at the Spin Router for Rust

Tue, 18 Apr 2023 13:02:41 +0200

With the release of Fermyon Spin 1.1 (April 15th, 2023), the Spin SDKs for Rust and Go now provide a built-in router for HTTP applications. In this post, we will take a quick look at the built-in router supplied by the Spin SDK for Rust and build a small sample application to illustrate how one could solve day-to-day requirements when building serverless applications with WebAssembly (Wasm).

What’s the purpose of a router in HTTP apps?

In HTTP applications, a router serves as a central component to direct incoming HTTP requests to the appropriate handler functions that can process and respond to those requests. The router does so by looking at different parts of an incoming HTTP request, such as:

Let's build a HTTP router for Spin with Rust

Fri, 14 Apr 2023 11:13:43 +0200

Although we can build more complex HTTP applications in Fermyon Spin by composing multiple components, having a single component is easier, reduces development time, and is more flexible in the first place. In this article, I will explain how to implement simple routing capabilities using enumerations in Rust.

Let Spin lift your key-value store

Sat, 08 Apr 2023 15:41:09 +0200

For quite sometime now (since version 0.9.0), Spin has had built-in key-value support. In this article, we will quickly investigate how we can use that built-in key-value support when building serverless applications with Fermyon Spin.

What are key-value stores

A key-value store is a type of database that stores data as a collection of key-value pairs. Each key in the database maps to a corresponding value, which can be retrieved by querying the key. Key-value stores are often used for storing and retrieving data quickly, as they can perform reads and writes with very low latency. They are commonly used in web applications, caching layers, and distributed systems and can be implemented using various technologies, such as Redis, Cassandra, etcd, SQLite, and others.

CRUD in WebAssembly with Fermyon Spin and MySQL

Tue, 20 Dec 2022 16:32:11 +0100

With the latest release of Fermyon Spin (v 0.7.0), we can persist data in MySQL (persistence in PostgreSQL has been available for quite some time now). Being able to persist and retrieve some sort of data is a must-have for any kind of application.

In this article, we’ll take a look at a full-fledged CRUD implementation. We’ll build an HTTP-API that allows its users to Create, Read, Update, and Delete products using corresponding HTTP methods (POST, GET, PUT, and DELETE). All code shown in this article is available on GitHub at ThorstenHans/spin-crud-mysql .

Master configuration data in Fermyon Spin

Thu, 15 Dec 2022 14:01:01 +0100

Every application has to deal with configuration data, and applications built using Fermyon Spin are no exception here. Instead of baking configuration data into your source code, you should attach it from the outside to alter behavior of your applications without having to re-compile your source code.

This short article demonstrates how to deal with configuration data when building applications using WebAssembly and Fermyon Spin. You can find the source code of the sample application (spin-to-slack) on GitHub at ThorstenHans/spin-to-slack .

Building Microservices With WebAssembly and Fermyon Spin

Sun, 11 Dec 2022 15:18:16 +0100

Although WebAssembly is an excellent fit for bringing complex solutions that need near-native runtime performance to the client (Browser), I see WebAssembly as a technology with way more potential and a way bigger impact on the server (read: cloud) in contrast. That said, WebAssembly will not replace containers on the server side. It’s an addition or alternative approach to packaging and distributing specific software components typically part of a bigger system. It’s on us - the developers and software architects - to decide if a container or WebAssembly is the better foundation for meeting a particular requirement.

Let's build a gRPC server and client in Rust with tonic

Thu, 07 Jul 2022 17:13:13 +0200

Last week I was showcasing WebAssembly in the cloud using krustlet and Fermyon Spin at Cloudland 2022 in Brühl (Germany). While preparing for the talk, I recognized how much I’d missed Rust 🦀 over the past months.

Although I’ve been reading articles and watching some videos on Rust in general from time to time, I missed doing some hands-on. So I dedicated some time to do a quick refresher for Rust, updated my local installation rustup update, and wrote a small gRPC server in Rust using tonic . However, before we dive into the tutorial, let’s quickly look at what tonic is and what we can do with it.

Check if your application is running in a Docker container

Thu, 21 Apr 2022 17:22:42 +0000

Especially when building cloud-native applications, we tend to develop applications that run in any environment. We design components, so we can run them with or without container technologies to ensure we can host the application on different application platforms. However, sometimes we may have to determine if our applications are running inside a Docker container or not. This allows us to take particular actions at runtime without adding additional environment variables or configuration values (state). Every container has a .dockerenv file in the file system’s root. That said, we can quickly check for the existence of that file to determine reliably if our application runs inside a container or not. For demonstration purposes, this post shows how to determine if the application is executed in a container using Go and Rust.

Distribute WebAssembly modules as OCI artifacts

Tue, 02 Nov 2021 14:19:39 +0000

When using WebAssembly (Wasm) on platforms different than the browser, we have to care about distribution. How can we securely transfer our Wasm modules to desired environments? How can we verify integrity to ensure Wasm modules were not compromised during distribution?

Let’s take a look at the container world. Container registries (those that implement the Docker Registry 2.0 standard (or to be more precise, the OCI distribution spec )) are a trusted distribution channel that addresses all the questions raised before. This does not mean that we have to package our Wasm modules as containers! Container registries can store and distribute more than just containers. Container registries can store any OCI compliant artifact. And that’s exactly what we will create from our Wasm modules to leverage container registries as a trusted distribution channel.

How to Build CLIs in Rust with StructOpt

Mon, 11 Oct 2021 10:03:31 +0000

As my journey on learning Rust continues, I looked at several options for building Command-Line Interfaces (CLIs) in Rust. There are several crates available you can use to craft tailored CLIs in Rust. At some point, StructOpt got my attention, and I saw a couple of people tweeting and writing about it. That said, this article helps you understanding StructOpt and gives you a head-start when it comes to building custom CLIs in Rust.

Calling HTTP APIs in Rust with reqwest

Wed, 15 Sep 2021 11:31:00 +0000

As part of my Rust journey, I’m building a simple CLI to get rid of manual tasks I’ve to complete on regular basis. Some of those tasks can be automated by leveraging a HTTP client in Rust. A quick research led me to reqwest (https://github.com/seanmonstar/reqwest) , a simple HTTP client for Rust that fits my needs and let me get the job done quickly.

You may ask yourself if reqwest is the best HTTP client for Rust? To be honest, I don’t know (yet). But I got my job done quickly, and I really enjoyed the API surface offered by reqwest. That said let’s dive into reqwest and see how it actually looks like.

Shadowing and Temporary Mutability in Rust

Tue, 07 Sep 2021 18:37:36 +0000

Rust already amazes a lot when it comes to the basic language features. Let’s, for example, take a look at shadowing and temporary mutability. Both, fairly basic and simple language features, yet powerful and a real booster for robustness and correctness.

Shadowing in Rust

Shadowing is such a simple language feature. However, it has a significant effect on the code you write daily. Shadowing allows you to re-declare a variable in the same scope, using the same name. The re-declared variable differs from the original by having a different type. This is especially useful upon casting data from one type into another. In Rust, you can achieve this without adding unnecessary application-state.Take the following code as an example:

Working with Environment Variables in Rust

Mon, 06 Sep 2021 15:51:19 +0000

Rust makes working with environment variables fairly easy. The standard library provides fundamental APIs as part of std::env which we use to access environment variables inside of our application. If you’re expecting valid unicode values, you can use env::var - which returns an Result<String, VarError> - as shown here:

use std::env;

fn verbose() {
    let name = "USER";
    match env::var(name) {
        Ok(v) => println!("{}: {}", name, v),
        Err(e) => panic!("${} is not set ({})", name, e)
    }
}

fn short() {
    let v = env::var("USER").expect("$USER is not set");
}

In contrast, env::var_os does not check if the value of the desired environment variable is valid unicode. var_os has also a slightly different function signature, it returns an Option<OsString>: