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

This chapter requires the Rust compiler, and you have to install at least version 1.31. Also, you need the rustup tool to add extra components, such as rustfmt and clippy. If you don't have it, you can find it here: https://rustup.rs/

Also in this chapter, we will try to bootstrap a CI system that will build and test a microservice. Since manual installation of these kinds of tools is long and complex, we will use Docker with Docker Compose to start and prepare the building environment faster. But in any case, you need a browser to be able to connect to the management console UI of the TeamCity tool to configure it.

The examples for this chapter can be found on GitHub: https://github.com/PacktPublishing/Hands-On-Microservices-with-Rust/tree/master/Chapter16.

Previous Section
End of Section 2
Next Section