Rust for the IoT: Building Internet of Things Apps with Rust and Raspberry Pi

Table of Contents
About the Author
About the Technical Reviewer
Acknowledgments
Preface
Chapter 1: Introduction
	Who Is This Book For?
	What Is IoT?
		IoT 10K Foot Picture
	Why Rust?
	Pre-requisites
		Components to Purchase
	Goals
		Source Code
	Web Application
	Board Application
	Basic Rust
		Rust Origins
			Command Line
			Modules
			Microservices
			Embedded
		Learning Rust
		Installing Rust
		Hello World
	Writing in Rust
		Variables and Data Types
		Borrowing and Ownership
			Memory
			Reference and Dereferencing
		Traits
			Typemap
		Cargo
			Feature Flags
			Creating a Release
	Summary
Chapter 2: Server Side
	Goals
	Microservice Architecture
		Why Microservices?
	Backend Design
	Database Design
	RESTful Endpoints
	Deploying
	Docker
	Web Framework
	Choosing a Web Framework
		Start Up Basic Iron
			Hello World
			Redirects
			Response Codes
			Parsing Parameters
				Params Parsing
				URL REST Parsing
				JSON Parsing
			Routing
			Middleware
				Logging Middleware
				Timer Middleware
	Database with Diesel
		Getting Started
		Configuring the App
		Creating the Database Tables
			Generating the Database with Docker
				Docker Running Containers
				Stopping Docker
				Starting Docker
				Running the Generation Scripts
				Schema File
		Basics
			Inserting
			Deleting
			Querying
		Using Enumerations
			Diesel Derive Enum Crate
		Relationships
		Using a UUID
		Integrating with Our Application
			Diesel Write Your Own Middleware
				Implementing the Connection Pool
				Adding the Middleware
				Adding a Method to Request
			Diesel Middleware
	More Web Framework
		Command-Line Parameters
		Error Handling
		Loggers
	Summary
Chapter 3: File Uploading and Parsing
	Goals
	Parsing Image Data
		EXIF
		Kamadak EXIF
		Data Structure
		Reading the Image
			Parsing Data Types
			Parsing GIS
	Parsing Video Data
		Mp4Parser
		Our Data Structure
		Reading the Video
	File Uploads
		Upload File
			Saving the File
	Creating the Metadata
		Upload File
		Send Data to Retrieval Services
	Storing the Metadata
		Update the Database
		Update the Structs
		Parse the Incoming Data
		Save the Data
	Summary
Chapter 4: Messaging and GraphQL
	Goals
	GraphQL
		Problems with REST
		GraphQL to the Rescue
			Query
			Mutations
			Subscriptions
			Playground
		Juniper
			Setting Up Juniper
			Creating the Context
			Setting Up the Schema
			Creating a Query
			Creating a Mutation
			Integrating with the Iron Router
	Messaging
		Purpose in the IoT System
		Our Design
		Starting Up Local Messaging Service
		Calling Messaging Service Locally
			Single-Level Wildcard (+)
			Multi-Level Wildcard (#)
			Subscribing
			Publishing
		Create the Messaging Service
			Subscribe to the Health Topic
			Publish to the Recording Topic
				Message Queue Middleware
				Recording Module
	Summary
Chapter 5: Performance
	Goals
	CQRS
		CQRS Steps
		Which CQRS to Use?
		Event Sourcing
		Implementing in Our Application
			Gotchas
		Setting Up Our Environment
			Cargo Update
		Creating Our CQRS Objects
			Command and Event
			Aggregator
			Dispatcher
		Calling Our Commanded Endpoint
		Processing the Event Stream
			Creating the Executor
			Subscription Stream Monitor
				Reading the Connection Stream
				Creating Connection to Stream
				Launching the CQRS Monitor Service
				Run It All
	Cap’n Proto
		Cap’n Proto
			Advantages of Cap’n Proto
			Cap’n Proto RPC
			Cap’n Proto for Rust
				Implementing in Our Application
				Installing Cap’n Proto
				Define the Message
				Creating the Client
				Message Queue Layer
				Retrieval Service Layer
	Summary
Chapter 6: Security
	What We Aren’t Covering
	Goals
	Authenticate Endpoints
		Authorization vs. Authentication
		OAuth 2
			OpenID Connect
		Applying AuthZ and AuthN
			Auth0
				Setting Up Auth0
		Authenticating
			Device Flow
			Processing the Tokens
				ID Tokens
				Programmatically Parse
				Access Tokens
				Implement Authorization Check
				Refresh Tokens
	Securing MQTT
		Certificates
			Certificate Authority (CA) vs. Self-Signed Certificates
			Creating Server Certificates
				Generate CA Root Certificate
				Message Queue Server Cert
				Updating the MQTT Server
			Creating Client Certificates
		Creating Our New Message Queue Service
	Summary
Chapter 7: Deployment
	What to Deploy
		Microservices
		Data Services
	How to Deploy
	Deployment Options
		Goals
	Docker
		What Is Containerization
			Full Machines
			Virtual Machines
			Containers
			Docker Layers
			Creating Our Own Containers
				Scratch Containers
		Using Docker in Our Applications
			Upload Service
			MQTT Service
			Retrieval Service
	Deploying with Kubernetes
		How Kubernetes Works
			Pods
			Nodes
			Control Plane
		Deploying to Kubernetes
			Kubectl
			Kubernetes Configurations
				Namespace
				Controllers
				Services
				Ingress
	Helm Charts
		What It Does
		Installing Helm
		Creating a Helm Chart
			Templates
				Release Metadata
				Chart Data
				Values.yaml
		Mapping Our Deployments
			Dependency Helm Charts
			Deploy the Extra Charts
				EventStore
				EMQX
				Sealed Secrets
			Deploying Our Chart
				Helper File
				Secret
				Upload Service
				Retrieval Service
				MQTT Service
				Service
				Ingress
		Deploying Your Helm Chart
	Standing Up the System
		DigitalOcean
			Register Your Domain
		Attaching to DigitalOcean Kubernetes
		Deploying to DigitalOcean
		Setting Up Gitlab CI/CD Pipeline
			Build Docker Images
			Deploying the Helm Chart
	Summary
Chapter 8: Raspberry Pi
	Goals
	Raspberry Pi
	Create Raspberry Pi Image
		Unbox the Raspberry Pi
		Assembling Raspberry Pi
			GPIO
		OS Software
			Installing the Software
				Unpack the File
				Wipe and Initialize the SD Card
				Install Image
			Final Setup Steps
				Set Up Wi-Fi
				Setup SSH Access
	Client Application
		Hello World Application
			Cross Compiling
		Developing the Client Application
			Creating UUID
			Transferring Certificates
			Setting Up Arguments
			Creating the Heartbeat
			Keep Alive
			Run from the Command Line
	Summary
Chapter 9: Sense HAT
	Goals
	Hardware
		Install
		Sensors
			LED Display
				Frames
				LED Controls
			Temperature Display
			Joystick Control
		Creating Interactions
			Tokio Async Run
			Daily Runs
			Joystick
			Receiver
	Logging In
		Yup OAuth 2
		Authentication Library
			VisualDisplay
			Entry Point Struct
		Auth0 FlowDelegate
		Raspberry Pi App Integration
	Summary
Chapter 10: Camera
	Goals
	Facial Recognition
	Installation
	Cross
		Rust Embedded – Cross Crate
			Using Cross
			Customizing
	Open Computer Vision
		Installing OpenCV
		Running the Application
			Capturing the Video
			Displaying to the Camera
			Capturing the Facial Recognition
				Using Trained Cascades
				Running the Cascade
			Saving the Video Content
			Apply Text to the Video
			Saving the Image Content
			Calling the Video Processing
	Deploying to the Pi
		OpenCV Install
	Summary
Chapter 11: Integration
	Uploading Video
		SQLite
			Design
			Creating the Interactions with the Database
			Adding Entry to the Database
			Uploading the Video File
				Sending to the Server
				Marking Entry Successfully Uploaded
				Marking Entry when Not Successful
	Sending Commands
		IPC
			Packet IPC
		Application
			Subscribing to the Message Queue
			IPC Server Side
			Client Side
				IPC Client
				Integrating on the Video Loop
	HomeKit
		HomeKit Accessory Protocol (hap-rs)
			Accessories
		Creating Our HomeKit
			Implement Generic Temperature Sensor
			Implementing Temperature Sensor
			Implementing Motion Sensor
				Video Module
				Manager Module
				Homekit Module
		Adding to Homekit
	Summary
Chapter 12: Final Thoughts
	Custom Buildroot
		Provisioning the Application
	Last Words
Index