book

Rust Web Programming - Third Edition

Name: Rust Web Programming - Third Edition
Author: Maxwell Flitton
ISBN: 9781835887769

by Maxwell Flitton

January 2026

Intermediate to advanced

674 pages

15h 30m

English

Packt Publishing

Read now

Unlock full access

Preface
Who this book is forWhat this book coversTo get the most out of this bookGet in touchFree benefits with your bookHow to Unlock
A Quick Introduction to Rust
Technical requirementsWhat is Rust?Why is Rust revolutionary?Reviewing data types and variables in RustUsing strings in RustUsing integers and floats8-byte integers16-byte integersIntroducing floatsStoring data in arraysStoring data in vectorsMapping data with enumsMapping data with HashMapsHandling results and errorsControlling variable ownershipCopying variablesMoving variablesImmutable borrowing of variablesMutable borrowing of variablesScopesRunning through lifetimesBuilding StructsSummaryQuestionsAnswersFurther readingGet this book’s PDF copy, code bundle, and more
Useful Rust Patterns for Web Programming
Technical requirementsVerifying with traitsMetaprogramming with macrosMapping messages with macrosDefining our contracts and contract handlerDefining functions to handle contractsBuilding a register contract macroUsing our macro in a programConfiguring our functions with traitsDefining the trait signatureImplementing our trait for the database handleCalling our macro with our traitChecking struct state with the compilerDefining the state of a structChanging the state of a structSummaryQuestionsAnswers
Designing Your Web Application in Rust
Technical requirementsManaging a software project with CargoBasic Rust compilationBuilding with CargoShipping crates with CargoDocumenting with CargoInteracting with CargoStructuring code through nanoservicesBuilding to-do structsConfiguring our file structureDefining the task statusBuilding our to-do structsManaging structs with an APIStoring tasks with our data access layerDefining our module layoutBuilding our JSON file handleBuilding storage API functionsCreating a task using our DALSummaryQuestionsAnswersGet this book’s PDF copy, code bundle, and more
Async Rust
Technical requirementsUnderstanding threads and processesUnderstanding async and await with RustImplementing our own async task queueBuilding a task-spawning functionBuilding an async sleep futureRunning our async sleep futureExploring high-level concepts of tokioImplementing an HTTP server in HyperSetting up the Hyper server environmentBuilding the Hyper request handle functionBuilding the main function for running the Hyper serverImplementing HTTP2 for our Hyper serverSummaryQuestionsAnswers
Handling HTTP Requests
Technical requirementsLaunching a basic web serverDefining our file layoutWriting our server codeRunning our serverConnecting the core to the serverDefining our core file layoutCoding our networking layerRefactoring our to-do itemsServing our to-do itemsDefining the JSON bodyDefining the get all APIConnecting get_all to our serverHandling errors in API endpointsDefining our glue moduleBuilding our custom errorMapping our custom errorIntegrating our glue module into our dalIntegrating our glue module into our core layerIntegrating our glue module into our networking layerSummaryQuestionsAnswersGet this book’s PDF copy, code bundle, and more
Processing HTTP Requests
Technical requirementsPassing parameters via the URLPassing data via POST bodyDefining the core create functionWrapping our core in the networking layerConfiguring our create network routeTesting our endpoint with cURLDeleting resources using the DELETE methodDefining our delete JSON file methodAdding delete to our networking layerDefining the delete routeRefactoring our JSON file codeAutomating running our serverUpdating resources using a PATCH methodExtracting data from HTTP request headersDefining our header token modulesImplementing an Actix header extraction traitExtracting headers from requests in the Actix networking layerSummaryQuestionsAnswers
Displaying Content in the Browser
Technical requirementsBuilding out a development setupConnecting our development environment and applicationRunning our frontend serverServing the frontend from RustDefining our frontend embedding dependenciesEmbedding the HTML fileEmbedding the React applicationServing the embedded frontendConnecting backend API endpoints to the frontendDefining our interfacesDefining our API utilsDefining our GET API callIntegrating our get API call in our main appBuilding out the rest of the API callsCreating React componentsBuilding a create item formInjecting our form component into our appTesting our create item formRendering multiple React componentsInserting styles with CSSServing our CSSDefining page borders with CSS for different screen sizesStyling React components with CSSSummaryQuestionsAnswersGet this book’s PDF copy, code bundle, and more
Injecting Rust in the Frontend with WebAssembly
Technical requirementsWhat is WASM?Setting up our WASM buildDefining our WASM moduleLoading WASM in the frontendInspecting a WASM interfaceIntegrating WASM loading into our React componentPassing our WASM output to subcomponentsLoading WASM on the local machineBuilding a WASM kernelBuilding a WASM libraryBuilding a WASM clientSummaryQuestionsAnswers
Data Persistence with PostgreSQL
Technical requirementsBuilding our PostgreSQL databaseWhy we should use a proper databaseWhy use Docker?How to use DockerRunning a database in DockerExploring routing and ports in DockerRunning Docker in the background with Bash scriptsAdding SQLX to the data access layerDefining our database transactionsConnecting our transactions to the coreConnecting our transactions to the serverCreating our database migrationsRefactoring our frontendSummaryQuestionsAnswersAppendixGet this book’s PDF copy, code bundle, and more

Managing User Sessions
Technical requirementsBuilding our auth serverBuilding our data access layerBuilding our auth core moduleNetworking layerDefining our user data modelStoring passwordsVerifying passwordsCreating usersDefining our create user database transactionsDefining our core create API endpointDefining our networking create API endpointRefactoring our JWTRestructuring our JWT for a unique IDCreating a get key function for encodingCreating an encode function to encode user credentialsCreating a decode function to extract user credentialsBuilding our login APIGetting users via email in the data access layerCreating our core login APIMounting our core login function to our serverInteracting with our auth serverAdding authentication to our frontendBuilding a login API callAdding tokens to our API callsBuilding a login form componentConnecting the login form to the appSummaryQuestionsAnswersAppendix
Communicating Between Servers
Technical requirementsGetting users from auth with the unique IDAdding get by unique ID to dalAdding get by unique ID to coreAdding get by unique ID to networkingMaking auth accessible to other serversTethering users to to-do itemsLinking our to-do items to users in the databaseAdding user IDs to data access transactionsAdding user IDs to core functionsAdding user IDs to networking functionsTesting our server-to-server communication with BashSummaryQuestionsAnswersGet this book’s PDF copy, code bundle, and more
Caching Auth Sessions
Technical requirementsWhat is caching?Setting up RedisBuilding our Redis moduleDefining the user sessionBuilding the login processBuilding the logout processBuilding the update processBuilding our Redis clientBuilding the login/logout clientBuilding the update clientConnecting our cache to our serversBuilding our cache kernelCalling the kernel from our to-do serverCalling the kernel from our auth serverSummaryQuestionsAnswers
Observability Through Logging
Technical requirementsWhat are RESTful services?Building frontend code on commandWhat is logging?Logging via the terminalDefining a loggerCreating a logging middlewareIntegrating our logger into our serversLogging via a databaseWhat is an actor?Building our logging actorUpdate logging functionsConfiguring our logging databaseSummaryQuestionsAnswersGet this book’s PDF copy, code bundle, and more
Unit Testing
Technical requirementsThe importance of unit testingWriting our first unit testTesting our coreUnit testing our networking layerDefining our test moduleMocking our database handleMocking our user cache handleDefining our mock serviceWriting testsUnit testing our data access layerDefining a teardown SQL commandCreating a DAL unit testRefactoring our testing scriptSummaryQuestionsAnswers
End-to-End Testing
Technical requirementsThe importance of end-to-end testingBuilding our to-do HTTP kernelBuilding our create item HTTP kernelBuilding our delete item HTTP kernelBuilding our atomic end-to-end testsWriting the end-to-end testRunning our atomic end-to-end testTesting workflows with end-to-end testsConfiguring existing code to accommodate the workflow testsBuilding a kernel API call for creating a userBuilding a kernel API call for logging inCreating a workflow test workspaceCreating a delete workflow testUpdating our test runner bash scriptSummaryQuestionsAnswersGet this book’s PDF copy, code bundle, and more
Deploying Our Application on AWS
Technical requirementsSetting up our build environmentSetting up an AWS SSH key for an Amazon EC2 instanceSetting up our AWS accountSetting up our Terraform buildBuilding a server build pipelinePackaging our system with DockerBuilding the base Docker image for all serversDefining the build config for our monolithDefining the build config for our microservicesDistributing our system with DockerDeploying our system with DockerWriting a Terraform script for our server and databaseWriting a Docker Compose system for our serverWriting a deployment script for our systemSummaryQuestionsAnswers
Configuring HTTPS with NGINX on AWS
Technical requirementsWhat is HTTPS?Implementing HTTPS locally with Docker ComposeInstalling SSLAttaching a URL to our deployed application on AWSAttaching an Elastic IP to our serverRegistering a domain nameEnforcing HTTPS on our application on AWSGetting certificates for our URLPrepping our EC2 instancesCreating a load balancer for our trafficCreating security groups to lock down and secure trafficUpdating our deployment scriptAttaching our URL to the load balancerSummaryQuestionsAnswersFurther readingGet this book’s PDF copy, code bundle, and more
Practicalities of Using Microservices and Nanoservices
Technical requirementsWhen to use nanoservices, microservices, and monolithsThe negative effects of microservicesContainer orchestrationFlying blindNetwork calls are expensiveThe positive effects of microservicesRolling out releasesIsolation of codeFlexibility to experimentManaging private repositories with dockpackIntegrating Rust nanoservices with other languages using C interfacesCreating our to-do Rust libraryCreating our C interfaceInterfacing with our Rust nanoservice with PythonSummary
Low-Level Networking
Technical requirementsBuilding a TCP serverBuilding a kernel for key-value messagesBuilding a TCP serverBuilding a TCP clientImplementing HTTP on top of TCPDefining a basic serverDefining an HTTP client from scratchImplementing HTTPS on top of TCPExploring WebSocketsSummaryQuestionsAnswersGet this book’s PDF copy, code bundle, and more
Distributed Computing
Technical requirementsIntroduction to queuingDefining the layout of the queuing systemClientCompute unit and kernelServer and workerOther configurationsBuilding our kernelBuilding our compute unitBuilding our workerBuilding our serverBuilding our clientRunning our queuing systemSummaryQuestionsAnswers
Unlock Your Exclusive Benefits
Unlock this Book’s Free Benefits in 3 Easy StepsStep 1Step 2Step 3Need Help
Other Books You May Enjoy
Index

Content preview from Rust Web Programming - Third Edition

5 Handling HTTP Requests

After the detour of understanding async on a deeper level, we are now going back to the project that we were working on in Chapter 3. So far, we have structured our to-do module in a flexible, scalable, and reusable manner. However, this can only get us so far in terms of web programming. We want our to-do module to reach people quickly without the user having to install Rust on their own computers. We can do this with a web framework.

In this chapter, we will build on the core logic of our to-do items and connect this core logic to a server. By the end of this chapter, you will be able to build a server that has a data access layer, core layer, and networking layer. You will also get some exposure in handling errors ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781835887769

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Rust Web Programming - Third Edition

by Maxwell Flitton

5

Handling HTTP Requests

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.