Name: Rust Web Programming
Author: Maxwell Flitton
ISBN: 9781835887776

微信读书书城Rust Web Programming

首页我的书架登录

翻译完成

切换

Rust Web Programming

Maxwell Flitton

扉页
版权信息
+书签
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Free benefits with your book
How to Unlock
Share your thoughts
1 A Quick Introduction to Rust
Technical requirements
What is Rust?
Why is Rust revolutionary?
Reviewing data types and variables in Rust
Using strings in Rust
Using integers and floats
8-byte integers
16-byte integers
Introducing floats
Storing data in arrays
Storing data in vectors
Mapping data with enums
Mapping data with HashMaps
Handling results and errors
Controlling variable ownership
Copying variables
Moving variables
Immutable borrowing of variables
Mutable borrowing of variables
Scopes
Running through lifetimes
Building Structs
Summary
Questions
Answers
Further reading
Get this book’s PDF copy, code bundle, and more
2 Useful Rust Patterns for Web Programming
Technical requirements
Verifying with traits
Metaprogramming with macros
Mapping messages with macros
Defining our contracts and contract handler
Defining functions to handle contracts
Building a register contract macro
Using our macro in a program
Configuring our functions with traits
Defining the trait signature
Implementing our trait for the database handle
Calling our macro with our trait
Checking struct state with the compiler
Defining the state of a struct
Changing the state of a struct
Summary
Questions
Answers
Learn more on Discord
3 Designing Your Web Application in Rust
Technical requirements
Managing a software project with Cargo
Basic Rust compilation
Building with Cargo
Shipping crates with Cargo
Documenting with Cargo
Interacting with Cargo
Structuring code through nanoservices
Building to-do structs
Managing structs with an API
Storing tasks with our data access layer
Creating a task using our DAL
Summary
Questions
Answers
Get this book’s PDF copy, code bundle, and more
4 Async Rust
Technical requirements
Understanding threads and processes
Understanding async and await with Rust
Implementing our own async task queue
Building a task-spawning function
Building an async sleep future
Running our async sleep future
Exploring high-level concepts of tokio
Implementing an HTTP server in Hyper
Summary
Questions
Answers
Learn more on Discord
5 Handling HTTP Requests
Technical requirements
Launching a basic web server
Defining our file layout
Writing our server code
Running our server
Connecting the core to the server
Defining our core file layout
Coding our networking layer
Refactoring our to-do items
Serving our to-do items
Defining the JSON body
Defining the get all API
Connecting get_all to our server
Handling errors in API endpoints
Defining our glue module
Building our custom error
Mapping our custom error
Integrating our glue module into our dal
Integrating our glue module into our core layer
Integrating our glue module into our networking layer
Summary
Questions
Answers
Get this book’s PDF copy, code bundle, and more
6 Processing HTTP Requests
Technical requirements
Passing parameters via the URL
Passing data via POST body
Defining the core create function
Wrapping our core in the networking layer
Deleting resources using the DELETE method
Defining our delete JSON file method
Adding delete to our networking layer
Defining the delete route
Refactoring our JSON file code
Automating running our server
Updating resources using a PATCH method
Extracting data from HTTP request headers
Defining our header token modules
Implementing an Actix header extraction trait
Extracting headers from requests in the Actix networking layer
Summary
Questions
Answers
Learn more on Discord
7 Displaying Content in the Browser
Technical requirements
Building out a development setup
Hello World
Hello World
8 Injecting Rust in the Frontend with WebAssembly
Technical requirements
What is WASM?
Setting up our WASM build
Defining our WASM module
Loading WASM in the frontend
Inspecting a WASM interface
Integrating WASM loading into our React component
Passing our WASM output to subcomponents
Pending Items
Done Items
Loading WASM on the local machine
Building a WASM kernel
Building a WASM library
Building a WASM client
Summary
Questions
Answers
Learn more on Discord
9 Data Persistence with PostgreSQL
Technical requirements
Building our PostgreSQL database
Why we should use a proper database
Why use Docker?
How to use Docker
Running a database in Docker
Exploring routing and ports in Docker
Running Docker in the background with Bash scripts
Adding SQLX to the data access layer
Defining our database transactions
Connecting our transactions to the core
Connecting our transactions to the server
Creating our database migrations
Refactoring our frontend
Summary
Questions
Answers
Appendix
Get this book’s PDF copy, code bundle, and more
10 Managing User Sessions
Technical requirements
Building our auth server
Building our data access layer
Building our auth core module
Networking layer
Defining our user data model
Storing passwords
Verifying passwords
Creating users
Defining our create user database transactions
Defining our core create API endpoint
Defining our networking create API endpoint
Refactoring our JWT
Restructuring our JWT for a unique ID
Creating a get key function for encoding
Creating an encode function to encode user credentials
Creating a decode function to extract user credentials
Building our login API
Getting users via email in the data access layer
Creating our core login API
Mounting our core login function to our server
Interacting with our auth server
Adding authentication to our frontend
Building a login API call
Adding tokens to our API calls
Building a login form component
Connecting the login form to the app
Summary
Questions
Answers
Appendix
Learn more on Discord
11 Communicating Between Servers
Technical requirements
Getting users from auth with the unique ID
Adding get by unique ID to dal
Adding get by unique ID to core
Adding get by unique ID to networking
Making auth accessible to other servers
Tethering users to to-do items
Linking our to-do items to users in the database
Adding user IDs to data access transactions
Adding user IDs to core functions
Adding user IDs to networking functions
Testing our server-to-server communication with Bash
Summary
Questions
Answers
Get this book’s PDF copy, code bundle, and more
12 Caching Auth Sessions
Technical requirements
What is caching?
Setting up Redis
Building our Redis module
Defining the user session
Building the login process
Building the logout process
Building the update process
Building our Redis client
Building the login/logout client
Building the update client
Connecting our cache to our servers
Building our cache kernel
Calling the kernel from our to-do server
Calling the kernel from our auth server
Summary
Questions
Answers
Learn more on Discord
13 Observability Through Logging
Technical requirements
What are RESTful services?
Building frontend code on command
What is logging?
Logging via the terminal
Summary
Questions
Answers
14 Unit Testing
Technical requirements
The importance of unit testing
Writing our first unit test
Testing our core
Unit testing our networking layer
Defining our test module
Mocking our database handle
Mocking our user cache handle
Defining our mock service
Writing tests
Unit testing our data access layer
Defining a teardown SQL command
Creating a DAL unit test
Refactoring our testing script
Summary
Questions
Answers
Learn more on Discord
15 End-to-End Testing
Technical requirements
The importance of end-to-end testing
Building our to-do HTTP kernel
Building our create item HTTP kernel
Building our delete item HTTP kernel
Building our atomic end-to-end tests
Writing the end-to-end test
Running our atomic end-to-end test
Testing workflows with end-to-end tests
Configuring existing code to accommodate the workflow tests
Building a kernel API call for creating a user
Building a kernel API call for logging in
Creating a workflow test workspace
Creating a delete workflow test
Updating our test runner bash script
Summary
Questions
Answers
Get this book’s PDF copy, code bundle, and more
16 Deploying Our Application on AWS
Technical requirements
Setting up our build environment
Setting up an AWS SSH key for an Amazon EC2 instance
Setting up our AWS account
Setting up our Terraform build
Building a server build pipeline
Packaging our system with Docker
Building the base Docker image for all servers
Defining the build config for our monolith
Defining the build config for our microservices
Distributing our system with Docker
Deploying our system with Docker
Writing a Terraform script for our server and database
Writing a Docker Compose system for our server
Writing a deployment script for our system
Summary
Questions
Answers
Learn more on Discord
17 Configuring HTTPS with NGINX on AWS
Technical requirements
What is HTTPS?
Implementing HTTPS locally with Docker Compose
Installing SSL
Attaching a URL to our deployed application on AWS
Attaching an Elastic IP to our server
Registering a domain name
Enforcing HTTPS on our application on AWS
Getting certificates for our URL
Prepping our EC2 instances
Creating a load balancer for our traffic
Creating security groups to lock down and secure traffic
Updating our deployment script
Attaching our URL to the load balancer
Summary
Questions
Answers
Further reading
Get this book’s PDF copy, code bundle, and more
18 Practicalities of Using Microservices and Nanoservices
Technical requirements
When to use nanoservices, microservices, and monoliths
The negative effects of microservices
The positive effects of microservices
Managing private repositories with dockpack
Integrating Rust nanoservices with other languages using C interfaces
Creating our to-do Rust library
Creating our C interface
Interfacing with our Rust nanoservice with Python
Summary
Learn more on Discord
19 Low-Level Networking
Technical requirements
Building a TCP server
Building a kernel for key-value messages
Building a TCP server
Building a TCP client
Implementing HTTP on top of TCP
Defining a basic server
Defining an HTTP client from scratch
Implementing HTTPS on top of TCP
Exploring WebSockets
Summary
Questions
Answers
Get this book’s PDF copy, code bundle, and more
20 Distributed Computing
Technical requirements
Introduction to queuing
Defining the layout of the queuing system
Client
Compute unit and kernel
Server and worker
Other configurations
Building our kernel
Building our compute unit
Building our worker
Building our server
Building our client
Running our queuing system
Summary
Questions
Answers
Learn more on Discord
21 Unlock Your Exclusive Benefits
Unlock this Book’s Free Benefits in 3 Easy Steps
Step 1
Step 2
Step 3
Need Help
Why subscribe?
Other Books You May Enjoy
Packt is searching for authors like you
Share your thoughts
Index

简介

版权

Rust Web Programming