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

Description

Discover the secrets of building Python microservices using the FastAPI framework Key FeaturesProvides a reference that contains definitions, illustrations, comparative analysis, and the implementation of real-world appsCovers concepts, core details, and advanced integration and design-related topicsImparts context, app templates, suggestions, and insights that are helpful to actual projectsBook Description FastAPI is an ASGI-based (Asynchronous Server Gateway Interface) framework that can help build modern, manageable, and fast microservices. Because of its asynchronous core platform, this ASGI-based framework provides the best option when it comes to performance, reliability, and scalability over WSGI-based Django and Flask. When working with Python, Flask, and Django microservices, you’ll be able to put your knowledge to work with this practical guide to building seamlessly manageable and fast microservices. You’ll begin by understanding the background of FastAPI and learning how to install, configure, and use FastAPI to decompose business units. You’ll explore a unique and asynchronous REST API framework that can provide a better option when it comes to building microservices. Next, the book will guide you on how to apply and translate microservices design patterns in building various microservices applications and RESTful APIs using the FastAPI framework. By the end of this microservices book, you’ll be able to learn, build, deploy, test, and experiment with microservices and their components using the FastAPI framework. What you will learnUnderstand, orient, and implement REST APIs using the basic components of the FastAPI frameworkBuild asynchronous as well as synchronous REST services using the built-in pydantic module and asyncio supportCreate small-scale and large-scale microservices applications using features supported by FastAPIBuild event-driven and message-driven applications using the frameworkCreate an asynchronous and synchronous data layer with both relational and NoSQL databasesPerform numerical and symbolic computations with FastAPIWho This Book Is For This book is for Python web developers, advanced Python users, and backend developers using Flask or Django who want to learn how to use the FastAPI framework to implement microservices. Readers familiar with the REST API and microservices will also benefit from this book. Some parts of the book contain general concepts, processes, and instructions that intermediate-level developers and Python enthusiasts can relate to as well. Table of ContentsSetting up FastAPI for StartersExploring the Core ComponentsUsing Dependency Injection to Manage ObjectsBuilding the Microservices ApplicationConnecting to a Relational DatabaseUsing MongoDB to Build NoSQL Data LayerSecuring the Microservice ApplicationAsynchronous, Event-Driven, and Message-Driven ProgrammingManaging, Monitoring and Testing the MicroservicesSolving Numerical and Symbolic ProblemsUsing Docker, Kubernetes, AWS, NGINX and Other Infrastructure Solutions 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