Building Python Microservices with FastAPI: Build secure, scalable, and structured Python microservices from design concepts to infrastructure

Cover
Title Page
Copyright
Dedication
Contributors
Table of Contents
Preface
Part 1: Application-Related Architectural Concepts for FastAPI microservice development
Chapter 1: Setting Up FastAPI for Starters
	Technical requirements
	Setting up the development environment
	Initializing and configuring FastAPI
	Designing and implementing REST APIs
	Managing user requests and server response
		Parameter type declaration
		Path parameters
		Query parameters
		Default parameters
		Optional parameters
		Mixing all types of parameters
		Request body
		Request headers
		Response data
	Handling form parameters
	Managing cookies
	Summary
Chapter 2: Exploring the Core Features
	Technical requirements
	Structuring and organizing huge projects
		Implementing the API services
		Importing the module components
		Implementing the new main.py file
	Managing API-related exceptions
		A single status code response
		Multiple status codes
		Raising HTTPException
		Custom exceptions
		A default handler override
	Converting objects to JSON-compatible types
	Managing API responses
	Creating background processes
	Using asynchronous path operations
	Applying middleware to filter path operations
	Summary
Chapter 3: Investigating Dependency Injection
	Technical requirements
	Applying IoC/DI
		Injecting a dependency function
		Injecting a callable class
		Building nested dependencies
		Caching the dependencies
		Declaring Depends() parameter types
		Injecting asynchronous dependencies
	Exploring ways of injecting dependencies
		Dependency injection on services
		Dependency injection on path operators
		Dependency injection on routers
		Dependency injection on main.py
	Organizing a project based on dependencies
		The model layer
		The repository layer
		The repository factory methods
		The service layer
		The REST API and the service layer
		The actual project structure
	Using third-party containers
		Using configurable containers – Dependency Injector
		Using a simple configuration – Lagom
		The FastAPI and Lagom integration
	Scoping of dependables
	Summary
Chapter 4: Building the Microservice Application
	Technical requirements
	Applying the decomposition pattern
		Creating the sub-applications
	Mounting the submodules
	Creating a common gateway
	Implementing the main endpoint
	Evaluating the microservice ID
	Applying the exception handlers
	Centralizing the logging mechanism
		Utilizing the Loguru module
	Building the logging middleware
		Consuming the REST API services
	Using the httpx module
	Using the requests module
	Applying the domain modeling approach
	Creating the layers
	Identifying the domain models
	Building the repository and service layers
		Using the factory method pattern
	Managing a microservice’s configuration details
		Storing settings as class attributes
		Storing settings in the properties file
	Summary
Part 2: Data-Centric and Communication-Focused Microservices Concerns and Issues
Chapter 5: Connecting to a Relational Database
	Technical requirements
	Preparing for database connectivity
	Creating CRUD transactions using SQLAlchemy
		Installing the database driver
		Setting up the database connection
		Initializing the session factory
		Defining the Base class
		Building the model layer
		Implementing the repository layer
		Running the transactions
		Creating tables
	Implementing async CRUD transactions using SQLAlchemy
		Installing the asyncio-compliant database drivers
		Setting up the database’s connection
		Creating the session factory
		Creating the Base class and the model layer
		Building the repository layer
		Running the CRUD transactions
	Using GINO for async transactions
		Installing the database driver
		Establishing the database connection
		Building the model layer
		Implementing the CRUD transactions
		Running the CRUD transactions
		Creating the tables
	Using Pony ORM for the repository layer
		Installing the database driver
		Creating the database’s connectivity
		Defining the model classes
		Implementing the CRUD transactions
		Running the repository transactions
		Creating the tables
	Building the repository using Peewee
		Installing the database driver
		Creating the database connection
		Creating the tables and the domain layer
		Implementing the CRUD transactions
		Running the CRUD transaction
	Applying the CQRS design pattern
		Defining the handler interfaces
		Creating the command and query classes
		Creating the command and query handlers
		Accessing the handlers
	Summary
Chapter 6: Using a Non-Relational Database
	Technical requirements
	Setting up the database environment
	Applying the PyMongo driver for synchronous connections
		Setting up the database connectivity
		Building the model layer
		Implementing the repository layer
		Running the transactions
	Creating async CRUD transactions using Motor
		Setting up the database connectivity
		Creating the model layer
		Running the CRUD transactions
	Implementing CRUD transactions using MongoEngine
		Establishing database connection
		Building the model layer
		Implementing the CRUD transactions
		Running the CRUD transactions
	Implementing async transactions using Beanie
		Creating the database connection
		Defining the model classes
		Implementing the CRUD transactions
		Running the repository transactions
	Building async repository for FastAPI using ODMantic
		Creating the database connection
		Creating the model layer
		Implementing the CRUD transactions
		Running the CRUD transaction
	Creating CRUD transactions using MongoFrames
		Creating the database connection
		Building the model layer
		Creating the repository layer
		Applying the repository layer
	Summary
Chapter 7: Securing the REST APIs
	Technical requirements
	Implementing Basic and Digest authentication
		Using Basic authentication
		Using Digest authentication
	Implementing password-based authentication
		Installing the python-multipart module
		Using OAuth2PasswordBearer and OAuth2PasswordRequestForm
		Executing the login transaction
		Securing the endpoints
	Applying JWTs
		Generating the secret key
		Creating the access_token
		Creating the login transaction
		Accessing the secured endpoints
	Creating scope-based authorization
		Customizing the OAuth2 class
		Building the permission dictionary
		Implementing the login transaction
		Applying the scopes to endpoints
	Building the authorization code flow
		Applying OAuth2AuthorizationCodeBearer
		Implementing the authorization request
		Implementing the authorization code response
	Applying the OpenID Connect specification
		Using HTTPBearer
		Installing and configuring the Keycloak environment
		Setting the Keycloak realm and clients
		Creating users and user roles
		Assigning roles to clients
		Creating user permissions through scopes
		Integrating Keycloak with FastAPI
		Implementing the token verification
		Integrating Auth0 with FastAPI
		Integrating Okta with FastAPI
	Using built-in middlewares for authentication
	Summary
Chapter 8: Creating Coroutines, Events, and Message-Driven Transactions
	Technical requirements
	Implementing coroutines
		Applying coroutine switching
		Designing asynchronous transactions
		Using the HTTP/2 protocol
	Creating asynchronous background tasks
		Using the coroutines
		Creating multiple tasks
	Understanding Celery tasks
		Creating and configuring the Celery instance
		Creating the task
		Calling the task
		Starting the worker server
		Monitoring the tasks
	Building message-driven transactions using RabbitMQ
		Creating the Celery instance
		Monitoring AMQP messaging
	Building publish/subscribe messaging using Kafka
		Running the Kafka broker and server
		Creating the topic
		Implementing the publisher
		Running a consumer on a console
	Implementing asynchronous Server-Sent Events (SSE)
	Building an asynchronous WebSocket
		Implementing the asynchronous WebSocket endpoint
		Implementing the WebSocket client
	Applying reactive programming in tasks
		Creating the Observable data using coroutines
		Creating background process
		Accessing API resources
	Customizing events
		Defining the startup event
		Defining shutdown events
	Summary
Part 3: Infrastructure-Related Issues, Numerical and Symbolic Computations, and Testing Microservices
Chapter 9: Utilizing Other Advanced Features
	Technical requirements
	Applying session management
		Creating user sessions
		Managing session data
		Removing the sessions
		Customizing BaseHTTPMiddleware
	Managing the CORS mechanism
	Customizing APIRoute and Request
		Managing body, form, or JSON data
		Encrypting and decrypting the message body
	Choosing the appropriate responses
		Setting up the Jinja2 template engine
		Setting up the static resources
		Creating the template layout
		Using ORJSONResponse and UJSONResponse
	Applying the OpenAPI 3.x specification
		Extending the OpenAPI schema definition
		Using the internal code base properties
		Using the Query, Form, Body, and Path functions
	Testing the API endpoints
		Writing the unit test cases
		Mocking the dependencies
		Running test methods
	Summary
Chapter 10: Solving Numerical, Symbolic, and Graphical Problems
	Technical requirements
	Setting up the projects
		Using the Piccolo ORM
		The Beanie ODM
	Implementing symbolic computations
		Creating symbolic expressions
		Solving linear expressions
		Solving non-linear expressions
		Solving linear and non-linear inequalities
	Creating arrays and DataFrames
		Applying NumPy’s linear system operations
		Applying the pandas module
	Performing statistical analysis
	Generating CSV and XLSX reports
	Plotting data models
	Simulating a BPMN workflow
		Designing the BPMN workflow
		Implementing the workflow
	Using GraphQL queries and mutations
		Setting up the GraphQL platform
		Creating the record insertion, update, and deletion
		Implementing the query transactions
		Running the CRUD transactions
	Utilizing the Neo4j graph database
		Setting the Neo4j database
		Creating the CRUD transactions
	Summary
Chapter 11: Adding Other Microservice Features
	Technical requirements
	Setting up the virtual environment
	Checking the API properties
	Implementing open tracing mechanisms
	Setting up service registry and client-side service discovery
		Implementing client-side service discovery
		Setting up the Netflix Eureka service registry
	Deploying and running applications using Docker
		Generating the requirements.txt file
		Creating the Docker image
		Using the Mongo Docker image
		Creating the containers
	Using Docker Compose for deployment
	Using NGINX as an API Gateway
	Integrating Flask and Django sub-applications
	Summary
Index
About Packt
Other Books You May Enjoy