Introduction

Having found myself with a bit of spare time, I decided to go ahead and purchase Luca Palmieri’s book “Zero to Production in Rust.”

NOTE: This is a ‘living document’ that I will use as a notebook to chronicle my journey through the text. As such, it will likely be updated, modified, deleted, or set on fire in a fit of rage.

I’ve been playing with Rust for a couple of years and have acquired enough knowledge to be almost dangerous. Although, with this language in particular, that’s not exactly saying much. From an educational perspective, I’m in that strange place between ‘working knowledge of fundamental concepts’ and ‘being able to synthesize and integrate foundational elements into practical applications.’ But, really, that’s just a fancy way of saying, ‘I know enough to do tutorials but not enough to do anything particularly useful.’

It’s probably worth noting that I’m not a software developer by trade. As such, I’m not motivated by the allure of silicon valley or a massive paycheck. Selfishly, this is a crime of passion - I’m just an old-hat nerd trying to figure out what the kids are up to.

Ah, ‘old people,’ it’s so cute when they fiddle with things. Why exactly are you doing this? What do you hope to accomplish?

That’s a great point … before we get to that, let’s just close on the book’s intent.

There are countless excellent sources for foundational training in Rust. However, this book addresses the significant gap between fundamental concepts and advanced application development. In the words of the author:

I am writing this book for …

the seasoned backend developers who have read The Rust Book and are now trying to port over a couple of simple systems

the new engineers on my team, a trail to help them make sense of the codebases they will contribute to over the coming weeks and months

a niche whose needs I believe are currently underserved by the articles and resources available in the Rust ecosystem
— Luca Palmieri

BURP … seasoned … or something. I suppose you did read the book (several times).

While I might not fit Luca’s primary target audience, I am a huge fan of understanding how things are done correctly. That being said, let’s jump into what we actually hope to accomplish.

Objectives

Let’s briefly address the author’s noble intentions.

You will learn by doing: you will build a fully functional email newsletter API, starting from scratch.

Generally, the idea is pretty straightforward. I’ve probably done 100 of these in various tutorials for other languages and frameworks (e.g., TypeScript, Deno, Svelte, etc.). But, honestly, if I have one early criticism, it’s literally that one can only get so excited about developing a newsletter API. I realize the use case is contrived, and I appreciate the care and thought that went into selecting it, but the fact remains: newsletter APIs are inherently boring.

Regarding the more specific objectives, the broad brush strokes are listed on the website:

Navigate and leverage Rust’s crates ecosystem
Structure your application to make it modular and extensible
Write tests, from single units to full-blown integration tests
Enforce your domain invariants using Rust’s type system
Authenticate and authorize users of your API
Implement a robust error-handling strategy
Observe the state of your application using structured logs
Set up an extensive continuous integration and continuous deployment pipeline for your Rust projects

Let’s pay close attention to the one objective we’ll most likely end up disregarding entirely:

Our main focus is enterprise software: correct code which is expressive enough to model the domain and supple enough to support its evolution over time.

Resources

Rust

Book: Zero To Production In Rust
Video: Rust Axum Full Course - Web Development
Video: Introduction to Axum
Blog: Building a Rust service with Nix

SurrealDB

Solutions