Book Image

Hands-On Microservices with Rust

By : Denis Kolodin
Book Image

Hands-On Microservices with Rust

By: Denis Kolodin

Overview of this book

Microservice architecture is sweeping the world as the de facto pattern for building web-based applications. Rust is a language particularly well-suited for building microservices. It is a new system programming language that offers a practical and safe alternative to C. This book describes web development using the Rust programming language and will get you up and running with modern web frameworks and crates with examples of RESTful microservices creation. You will deep dive into Reactive programming, and asynchronous programming, and split your web application into a set of concurrent actors. The book provides several HTTP-handling examples with manageable memory allocations. You will walk through stateless high-performance microservices, which are ideally suitable for computation or caching tasks, and look at stateful microservices, which are filled with persistent data and database interactions. As we move along, you will learn how to use Rust macros to describe business or protocol entities of our application and compile them into native structs, which will be performed at full speed with the help of the server's CPU. Finally, you will be taken through examples of how to test and debug microservices and pack them into a tiny monolithic binary or put them into a container and deploy them to modern cloud platforms such as AWS.

Related Content you might be interested in

Current Title:

Small book image
Hands-On Microservices with Rust
Denis Kolodin
Jan, 2019 | 520 pages
Small book image
Mastering Rust.
Vesa Kaihlavirta | Rahul Sharma
Jan, 2019 | 554 pages
Small book image
Network Programming with Rust
Abhishek Chanda
Feb, 2018 | 278 pages
Small book image
Rust Web Development with Rocket
Karuna Murti
Jun, 2022 | 420 pages
Table of Contents (19 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Introduction to Microservices
Introduction to Microservices
Technical requirements
What are microservices?
How to split a traditional server into multiple microservices
Why Rust is a great tool for creating microservices
Summary
Further reading
2
Developing a Microservice with the Hyper Crate
Developing a Microservice with the Hyper Crate
Technical requirements
Binding a Tiny Server
Handling incoming requests
Implementing the REST principles
Routing advanced requests
Summary
3
Logging and Configuring Microservice
Logging and Configuring Microservice
Technical requirements
Adding logging to a microservice
Reading environment variables
Parsing command-line arguments
Reading the configuration from file
Summary
4
Data Serialization and Deserialization with the Serde Crate
Data Serialization and Deserialization with the Serde Crate
Technical requirements
Data formats for interaction with microservices
Microservices with multiple formats
Summary
5
Understanding Asynchronous Operations with Futures Crate
Understanding Asynchronous Operations with Futures Crate
Technical requirements
Basic asynchronous types
Creating an image service
Summary
6
Reactive Microservices - Increasing Capacity and Performance
Reactive Microservices - Increasing Capacity and Performance
Technical requirements
What is a reactive microservice?
Understanding JSON-RPC
Learning about gRPC
Summary
7
Reliable Integration with Databases
Reliable Integration with Databases
Technical requirements
PostgreSQL
MySQL
Redis
MongoDB
DynamoDB
Summary
8
Interaction to Database with Object-Relational Mapping
Interaction to Database with Object-Relational Mapping
Technical requirements
The diesel crate
Complex database structure
Summary
9
Simple REST Definition and Request Routing with Frameworks
Simple REST Definition and Request Routing with Frameworks
Technical requirements
Rouille
Nickel
Rocket
Gotham
Summary
10
Background Tasks and Thread Pools in Microservices
Background Tasks and Thread Pools in Microservices
Technical requirements
Interacting with threads
Using thread pools
Actors
Summary
11
Involving Concurrency with Actors and the Actix Crate
Involving Concurrency with Actors and the Actix Crate
Technical requirements
Actor concurrency in microservices
Creating a microservice with actix-web
Using databases
WebSocket
Summary
12
Scalable Microservices Architecture
Scalable Microservices Architecture
Technical requirements
Scalable architecture
Scalable application with Rust and RabbitMQ
Summary
13
Testing and Debugging Rust Microservices
Testing and Debugging Rust Microservices
Technical requirements
Testing microservices
Debugging microservices
Structural logging
Distributed tracing
Summary
14
Optimization of Microservices
Optimization of Microservices
Technical requirements
Performance-measuring tools
Measuring and optimizing performance
Optimization techniques 
Summary
15
Packing Servers to Containers
Packing Servers to Containers
Technical requirements
Building a Docker image with a microservice
Creating an image with the Rust compiler
Building an image
Composing a microservice set
Adding persistent state to the application
Summary
16
DevOps of Rust Microservices - Continuous Integration and Delivery
DevOps of Rust Microservices - Continuous Integration and Delivery
Technical requirements
Continuous integration and continuous delivery
Rust tools
CI and CD tools
Demonstration of continuous integration
Summary
17
Bounded Microservices with AWS Lambda
Bounded Microservices with AWS Lambda
Technical requirements
Serverless architecture
Minimal Rust microservices for AWS Lambda
Serverless Framework
Summary
18
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Technical requirements

Because we're starting to write code in this chapter, you'll need to have certain software in order to compile and run examples:

  • I recommend you use the rustup tool, which will keep your Rust instance up to date. If you don't have this tool, you can get it from https://rustup.rs/. When it's installed, run the rustup update command to update the current installation.
  • The Rust compiler, at least version 1.31.
  • The hyper crate, which we'll use to compile the code, requires the OpenSSL (https://www.openssl.org/) library. The most popular operating systems already include the OpenSSL package and you can follow the manual of your package manager to install it.

You can get the examples shown in this chapter from GitHub at https://github.com/PacktPublishing/Hands-On-Microservices-with-Rust/tree/master/Chapter02...

Previous Section
End of Section 2
Next Section