About the Book
Build production Rust microservices that scale, stay fast, and fail safely.
Distributed systems are hard when APIs drift, retries fight timeouts, and debugging stops at vague logs. This book gives you a cohesive Axum based stack with Hyper, Tower, Tokio, and Tonic, then applies it across HTTP and gRPC, data, messaging, security, observability, delivery, and operations.
You get practical guidance shaped by real outages and fixes, from idempotent POST patterns and Problem JSON to OpenTelemetry pipelines, mTLS, and safe rollouts. Each topic includes code that compiles and patterns you can adopt across services.
Model stable HTTP resources, lay out routes, and version with confidence
Validate inputs, set body limits, and add predictable paging and filtering
Use Problem JSON for consistent errors and actionable diagnostics
Generate OpenAPI with Utoipa, serve Swagger UI, document auth and deprecations
Create Rust and TypeScript clients, wire generation into CI, review schema changes
Define Protobuf services, use Prost codegen, set deadlines and metadata in Tonic
Expose health and reflection, support gRPC Web through a gateway or tonic web
Apply timeouts and budgets, retries with backoff and jitter, and safe methods only
Set concurrency limits, rate limits, admission control, circuit breaking, and load shedding
Work with Kafka, NATS JetStream, and RabbitMQ, including consumer groups and dead letters
Use Outbox and Inbox with SQLx, understand exactly once illusions
Run Postgres with SQLx pools and migrations, choose isolation, enforce idempotency by constraint
Cache with Redis and Redis Streams, pick TTL and eviction strategies
Evolve schemas and data safely with backward compatible migrations
Set up OpenTelemetry and OTLP, add histograms and exemplars for HTTP and gRPC
Build dashboards and alerts with RED and USE, define SLOs that guide limits
Secure with rustls TLS and mTLS, rotate certificates, add JWT, OAuth2, and browser sessions
Package with cargo chef, multistage, and distroless, verify startup in CI
Generate SBOMs, run cargo audit, ship with semantic versioning, canary, and rollback
Operate on Kubernetes with manifests, resources and limits, probes including gRPC, HPA, and disruption budgets
Integrate a mesh with Envoy or Linkerd, propagate identity, tune keepalives and load balancing, enforce edge rate limits and auth
Test with unit and property tests, integration via testcontainers for Postgres Kafka NATS Redis
Write contract tests for HTTP and gRPC with grpcurl and stable snapshots
Measure performance with Criterion and k6, protect baselines from regressions
Engineer reliability with graceful startup and shutdown, backpressure, cancellation, hedged requests, and fault injection
Adopt a reference architecture, scaffold new services, share crates, and migrate from a monolith with strangler patterns, data moves, and messaging bridges
Ship runbooks, a production readiness checklist, dashboards, and alerts with every service
This is a code heavy guide with working Rust, TOML, YAML, JSON, Protobuf, and Bash snippets that map directly to real projects.
Grab your copy today and build Rust services that hold up in production.
