Microservices in Rust: How to Get Started and Keep Your Sanity

Why Rust is Your Next Step in Microservices?

The world of microservices has long been divided between Java (with its Spring Boot), Python (FastAPI, Django), and Go. But in the last couple of years, the voice of Rust has been heard more and more often. Why? Because Rust delivers what once seemed unattainable: C++ performance and memory safety — without a garbage collector.

If you write in Python, you're used to development speed. But when the load grows, Python starts to "slow down". Rust solves this problem radically: one microservice in Rust can replace 3–4 services in Python in terms of performance. And the code doesn't "crash" at runtime with a NullPointerException.

In this article, we won't philosophize. We'll take and write a microservice in Rust from scratch. You'll see that it's not scary, but actually quite exciting.

Preparing the Environment: What to Install

Before writing code, let's make sure you have everything you need. If you're new to Rust — don't worry, installation takes 2 minutes.

1. Installing Rust

The easiest way is through the official installer rustup:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

After installation, check the version:

rustc --version\ncargo --version

2. Choosing an Editor

I recommend VS Code with the rust-analyzer extension. This will give you autocompletion, error highlighting, and refactoring "out of the box".

3. Docker (for Containerization)

Microservices usually live in containers. Install Docker Desktop or Docker Engine. We'll build an image at the end of the article.

Choosing a Framework: Actix-web vs Axum vs Rocket

In the Rust world, there are three main frameworks for HTTP servers. Here's a brief comparison:

\n
• Actix-web — the fastest (up to 1 million requests/sec). Mature, lots of examples. Ideal for production.
\n
• Axum — modern, from the creators of Tokio. Integrates best with the async ecosystem.
\n
• Rocket — the most "friendly" syntax, but updates slower.
\n

In this article, we'll use Actix-web, as it's battle-tested over the years and has the largest community. But if you want a "trendy" stack — feel free to go with Axum.

First Microservice: URL Shortener Service

To avoid being abstract, let's write a real microservice — a url-shortener. It will accept a long URL and return a short one.

Step 1. Create the Project

cargo new url-shortener\ncd url-shortener

Step 2. Add Dependencies

Open Cargo.toml and add:

[dependencies]\nactix-web = "4"\nserde = { version = "1", features = ["derive"] }\nserde_json = "1"\nuuid = { version = "1", features = ["v4"] }\ntokio = { version = "1", features = ["full"] }

Step 3. Write the Code

Replace the contents of src/main.rs with the following code:

use actix_web::{web, App, HttpServer, HttpResponse, Responder};\nuse serde::{Deserialize, Serialize};\nuse std::sync::Mutex;\nuse uuid::Uuid;\n\n// Structure for storing links in memory\nstruct AppState {\n    links: Mutex>,\n}\n\n#[derive(Serialize, Deserialize, Clone)]\nstruct Link {\n    id: String,\n    url: String,\n}\n\n#[derive(Deserialize)]\nstruct CreateLinkRequest {\n    url: String,\n}\n\n// POST /shorten — creates a short link\nasync fn shorten(data: web::Data<AppState>, body: web::Json<CreateLinkRequest>) -> impl Responder {\n    let new_link = Link {\n        id: Uuid::new_v4().to_string()[..8].to_string(), // take the first 8 characters of the UUID\n        url: body.url.clone(),\n    };\n\n    let mut links = data.lin