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

Managing a microservice’s configuration details

So far, this chapter has provided us with some popular design patterns and strategies that can give us a kickstart on how to provide our FastAPI microservices with the best structures and architecture. This time, let us explore how the FastAPI framework supports storing, assigning, and reading configuration details to mounted microservice applications such as database credentials, networking configuration data, application server information, and deployment details. First, we need to install python-dotenv using pip:

pip install python-dotenv

All of these settings are values that are external to the implementation of the microservice applications. Instead of hardcoding them into the code as variable data, usually, we store them in the env, property, or INI files. However, challenges arise when assigning these settings to different microservices.

Frameworks that support the externalized configuration design pattern have...

Previous Section
End of Section 17
Next Section