Rust Web Programming

A hands-on guide to developing fast and secure web apps with the Rust programming language

Maxwell Flitton

• Publisher: Packt Publishing
• Year: 2021
• ISBN:
  9781800566095
• Edition: 1
• Topic: Computer Science
• Subtopic: Web Services & APIs
• Index: Computer Science

Adopt the Rust programming language by learning how to build fully functional web applications and services and address challenges relating to safety and performance

Key Features

• Build scalable web applications in Rust using popular frameworks such as Actix, Rocket, and Warp
• Create front-end components that can be injected into multiple views
• Develop data models in Rust to interact with the database

Book Description

Are safety and high performance a big concern for you while developing web applications?

While most programming languages have a safety or speed trade-off, Rust provides memory safety without using a garbage collector. This means that with its low memory footprint, you can build high-performance and secure web apps with relative ease.

This book will take you through each stage of the web development process, showing you how to combine Rust and modern web development principles to build supercharged web apps.

You'll start with an introduction to Rust and understand how to avoid common pitfalls when migrating from traditional dynamic programming languages. The book will show you how to structure Rust code for a project that spans multiple pages and modules. Next, you'll explore the Actix Web framework and get a basic web server up and running. As you advance, you'll learn how to process JSON requests and display data from the web app via HTML, CSS, and JavaScript. You'll also be able to persist data and create RESTful services in Rust. Later, you'll build an automated deployment process for the app on an AWS EC2 instance and Docker Hub. Finally, you'll play around with some popular web frameworks in Rust and compare them.

By the end of this Rust book, you'll be able to confidently create scalable and fast web applications with Rust.

What you will learn

• Structure scalable web apps in Rust in Rocket, Actix Web, and Warp
• Apply data persistence for your web apps using PostgreSQL
• Build login, JWT, and config modules for your web apps
• Serve HTML, CSS, and JavaScript from the Actix Web server
• Build unit tests and functional API tests in Postman and Newman
• Deploy the Rust app with NGINX and Docker onto an AWS EC2 instance

Who this book is for

This book on web programming with Rust is for web developers who have programmed in traditional languages such as Python, Ruby, JavaScript, and Java and are looking to develop high-performance web applications with Rust. Although no prior experience with Rust is necessary, a solid understanding of web development principles and basic knowledge of HTML, CSS, and JavaScript are required if you want to get the most out of this book.

Section 1:Setting Up the Web App Structure

Rust is a memory safe programming language. However, new developers can feel intimidated when picking up Rust. This does not help when Rust is described as a systems language, as if this tag instantly disqualifies Rust for web development.

However, we have to remember that Rust is memory safe. If we, as experienced web developers in other memory safe languages, understand the quirks of Rust such as borrow checking and lifetimes, we can code in Rust in a productive way. If we get to grips with package management (known as crates) and modules, there is nothing stopping us from building structured and safe applications in Rust in a fast paced manner.

This section gets the experienced web developer up and running with the basics of Rust and covers concepts that will enable you to structure a web app.

This section comprises the following chapters:

• Chapter 1, Quick Introduction to Rust
• Chapter 2, Designing Your Web Application in Rust

Chapter 1: Quick Introduction to Rust

Rust is growing in popularity, but it is described as having a steep learning curve. By covering the basic rules of Rust, as well as how to manipulate a range of data types and variables, we will be able to write simple programs in the same fashion as dynamically typed languages with close to the same lines of code.

In this chapter, we will cover the main differences between Rust and generic dynamic languages to provide you with a quick understanding of how to utilize Rust. Installation and project management will be covered in the next chapter. Therefore, it's advised that you code the examples covered in this chapter using the online Rust playground.

In this chapter, we will cover the following topics:

• Reviewing data types and variables in Rust
• Controlling variable ownership
• Building structs
• Metaprogramming with macros

Let's get started!

Technical requirements

For this chapter, we only need access to the internet as we will be using the online Rust playground to implement all the code. The code examples provided can be run in the online Rust playground at https://play.rust-lang.org/.

For detailed instructions, please refer to the README file at https://github.com/PacktPublishing/Rust-Web-Programming/tree/master/Chapter01. You will also find all the source code used in this chapter at the preceding link.

The CiA videos for this book can be viewed at: http://bit.ly/3jULCrw

Reviewing data types and variables in Rust

If you have coded in another language, you will have used these data types already. However, Rust has some quirks that can throw developers, especially if they come from dynamic languages. In order to see the motivation behind these quirks, it's important that we explore why Rust is such a paradigm-shifting language.

Why Rust?

With programming, there is usually a trade-off between speed/resources and development speed/safety. Low-level languages such as C/C++ can give the developer fine-grained control over the computer with fast code execution and minimal resource consumption. However, this is not free. Manual memory management can induce bugs and security vulnerabilities. On top of this, it takes more code and time to solve a problem in a low-level language. As a result of this, C++ web frameworks do not take up a large share of web development. Instead, it made sense to go for high-level programming languages where developers can solve problems safely and quickly.

However, it has to be noted that this memory safety comes at a cost. Languages such as Python, JavaScript, PHP, and Java keep track of all the variables defined and their references to a memory address. When there are no more variables pointing to a memory address, the data in that memory address gets deleted. This process is called garbage collection and consumes extra resources and time.

With Rust, memory safety is ensured without the costly garbage collection process. Instead, the compiler maps the variables, enforcing rules to ensure safety via a mechanism called the borrow checker. Because of this, Rust has enabled rapid, safe problem solving with truly performant code, thus breaking the speed/safety trade-off. As more data processing, traffic, and complex tasks are lifted into the web stack, Rust, with its growing number of web frameworks and libraries, has now become a viable choice for web developmen...