Book Image

Building Python Microservices with FastAPI

By : Sherwin John C. Tragura
3 (2)
Book Image

Building Python Microservices with FastAPI

3 (2)
By: Sherwin John C. Tragura

Overview of this book

FastAPI is an Asynchronous Server Gateway Interface (ASGI)-based 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 the 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. After that, this 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 understand, build, deploy, test, and experiment with microservices and their components using the FastAPI framework.

Related Content you might be interested in

Current Title:

Small book image
Building Python Microservices with FastAPI
Sherwin John C. Tragura
Aug, 2022 | 420 pages
Small book image
Building Python Web APIs with FastAPI
Abdulazeez Abdulazeez Adeshina
Jul, 2022 | 216 pages
Small book image
Full Stack FastAPI, React, and MongoDB
Marko Aleksendrić
Sep, 2022 | 336 pages
Small book image
Building Data Science Applications with FastAPI
François Voron
Jul, 2023 | 422 pages
Table of Contents (17 chapters)
Preface
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
Share your thoughts
1
Part 1: Application-Related Architectural Concepts for FastAPI microservice development
Part 1: Application-Related Architectural Concepts for FastAPI microservice development
Free Chapter
2
Chapter 1: Setting Up FastAPI for Starters
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
Handling form parameters
Managing cookies
Summary
3
Chapter 2: Exploring the Core Features
Chapter 2: Exploring the Core Features
Technical requirements
Structuring and organizing huge projects
Managing API-related exceptions
Converting objects to JSON-compatible types
Managing API responses
Creating background processes
Using asynchronous path operations
Applying middleware to filter path operations
Summary
4
Chapter 3: Investigating Dependency Injection
Chapter 3: Investigating Dependency Injection
Technical requirements
Applying IoC/DI
Exploring ways of injecting dependencies
Organizing a project based on dependencies
Using third-party containers
Scoping of dependables
Summary
5
Chapter 4: Building the Microservice Application
Chapter 4: Building the Microservice Application
Technical requirements
Applying the decomposition pattern
Mounting the submodules
Creating a common gateway
Implementing the main endpoint
Evaluating the microservice ID
Applying the exception handlers
Centralizing the logging mechanism
Building the logging middleware
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
Managing a microservice’s configuration details
Summary
6
Part 2: Data-Centric and Communication-Focused Microservices Concerns and Issues
Part 2: Data-Centric and Communication-Focused Microservices Concerns and Issues
7
Chapter 5: Connecting to a Relational Database
Chapter 5: Connecting to a Relational Database
Technical requirements
Preparing for database connectivity
Creating CRUD transactions using SQLAlchemy
Implementing async CRUD transactions using SQLAlchemy
Using GINO for async transactions
Using Pony ORM for the repository layer
Building the repository using Peewee
Applying the CQRS design pattern
Summary
8
Chapter 6: Using a Non-Relational Database
Chapter 6: Using a Non-Relational Database
Technical requirements
Setting up the database environment
Applying the PyMongo driver for synchronous connections
Creating async CRUD transactions using Motor
Implementing CRUD transactions using MongoEngine
Implementing async transactions using Beanie
Building async repository for FastAPI using ODMantic
Creating CRUD transactions using MongoFrames
Summary
9
Chapter 7: Securing the REST APIs
Chapter 7: Securing the REST APIs
Technical requirements
Implementing Basic and Digest authentication
Implementing password-based authentication
Applying JWTs
Creating scope-based authorization
Building the authorization code flow
Applying the OpenID Connect specification
Using built-in middlewares for authentication
Summary
10
Chapter 8: Creating Coroutines, Events, and Message-Driven Transactions
Chapter 8: Creating Coroutines, Events, and Message-Driven Transactions
Technical requirements
Implementing coroutines
Creating asynchronous background tasks
Understanding Celery tasks
Building message-driven transactions using RabbitMQ
Building publish/subscribe messaging using Kafka
Implementing asynchronous Server-Sent Events (SSE)
Building an asynchronous WebSocket
Applying reactive programming in tasks
Customizing events
Summary
11
Part 3: Infrastructure-Related Issues, Numerical and Symbolic Computations, and Testing Microservices
Part 3: Infrastructure-Related Issues, Numerical and Symbolic Computations, and Testing Microservices
12
Chapter 9: Utilizing Other Advanced Features
Chapter 9: Utilizing Other Advanced Features
Technical requirements
Applying session management
Managing the CORS mechanism
Customizing APIRoute and Request
Choosing the appropriate responses
Applying the OpenAPI 3.x specification
Testing the API endpoints
Summary
13
Chapter 10: Solving Numerical, Symbolic, and Graphical Problems
Chapter 10: Solving Numerical, Symbolic, and Graphical Problems
Technical requirements
Setting up the projects
Implementing symbolic computations
Creating arrays and DataFrames
Performing statistical analysis
Generating CSV and XLSX reports
Plotting data models
Simulating a BPMN workflow
Using GraphQL queries and mutations
Utilizing the Neo4j graph database
Summary
14
Chapter 11: Adding Other Microservice Features
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
Deploying and running applications using Docker
Using Docker Compose for deployment
Using NGINX as an API Gateway
Integrating Flask and Django sub-applications
Summary
15
Index
Index
Why subscribe?
16
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share your thoughts

Building the Microservice Application

Previously, we spent a lot of time building API services for various applications using the core features of FastAPI. We also started applying important design patterns such as Inversion of Control (IoC) and Dependency Injection (DI), which are essential for managing FastAPI container objects. External Python packages were installed and used to provide options on what containers to use in managing objects.

These design patterns can help not only with managed objects in container but also when building scalable, enterprise-grade, and unconventionally complex applications. Most of these design patterns help break down monolithic architecture into loosely coupled components that are known as microservices.

In this chapter, we will explore some architectural design patterns and principles that can provide strategies and ways to initiate the building of our microservices from a monolithic application. Our focus will be on breaking the huge application...

Previous Section
End of Section 1
Next Section