Building Python Microservices with FastAPI E-Book

Sherwin John C. Tragura

• Herausgeber: Packt Publishing
• Kategorie: Fachliteratur
• Sprache: Englisch

Seitenzahl: 445

Veröffentlichungsjahr: 2022

Beschreibung

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.

Leseprobe

Building Python Microservices with FastAPI

Build secure, scalable, and structured Python microservices from design concepts to infrastructure

Sherwin John C. Tragura

BIRMINGHAM—MUMBAI

Building Python Microservices with FastAPI

Copyright © 2022 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing or its dealers and distributors, will be held liable for any damages caused or alleged to have been caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

Associate Group Product Manager: Pavan Ramchandani

Publishing Product Manager: Bhavya Rao

Senior Editor: Mark Dsouza

Content Development Editor: Divya Vijayan

Technical Editor: Shubham Sharma

Copy Editor: Safis Editing

Project Coordinator: Sonam Pandey

Proofreader: Safis Editing

Indexer: Tejal Daruwale Soni

Production Designer: Joshua Misquitta

Marketing Coordinators: Anamika Singh and Marylou De Mello

First published: August 2022

Production reference: 1260822

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham

B3 2PB, UK.

ISBN 978-1-80324-596-6

www.packt.com

This book is for everyone who became my support system during those months in 2021 when I got sick and for everyone who fought and stayed strong during this pandemic.

– Sherwin John C. Tragura

Contributors

About the author

Sherwin John Calleja Tragura is a subject matter expert on Java, ASP .NET MVC, and Python applications with some background in frontend frameworks. He has managed a team of developers to build various applications related to manufacturing and fixed assets, document management, records management, POS, and inventory systems. He has a background in building laboratory information management systems (LIMS) and hybrid mobile applications as a consultant. He has also provided corporate Bootcamp training services since 2010 for courses on Python, Django, Flask, Jakarta EE, C#, ASP .NET MVC, JSF, Java, and some frontend frameworks. He has authored books such as Spring MVC Blueprints and Spring 5 Cookbook and a Packt video, Modern Java Web Applications with Spring Boot 2.x.

I want to thank my friends, Icar, Mathieu, and Abby, and my cousins, Rhonalyn, Mica, and Mila, for their time and effort when I was not well in 2021. Also, I want to express my gratitude and appreciation to the Packt team for their understanding and consideration given to me. Lastly, this book would have been impossible without the support and time of Owen, who was always there pushing me to finish the book despite the scary situation during the pandemic.

About the reviewers

Glenn Base De Paula is a product of the University of the Philippines Integrated School and is a computer science graduate of the country’s most prestigious institutions, the University of the Philippines. He has 14 years of industry experience, which was mostly with the government’s ICT institute and recently in the banking industry.

He uses Spring, Grails, and JavaScript for his day-to-day activities. He has developed numerous Java web applications for various projects and was also the technical team lead for several others. He currently manages a team of Java developers assigned to different projects in one of the country’s most reputable banks.

He is often involved in systems analysis and design, source code review, testing, implementation, training, and mentoring. He learns about better software architecture and design in his free time.

Sathyajith Bhat is an experienced Site Reliability Engineer (SRE) with over 15 years of experience in DevOps, Site Reliability Engineering, System Architecture, Performance Tuning, Cloud Computing, and Observability. He believes in getting the most out of the tools that he works with. Sathyajith is the author of Practical Docker with Python and a co-author of The CDK Book. He loves working with various communities and has been recognized as an AWS Community Hero for his contributions to the AWS community.

I would like to thank my wife, Jyothsna, for being patient and supporting me both in my career and while working on this book.

Table of Contents

Preface

Part 1: Application-Related Architectural Concepts for FastAPI microservice development

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

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

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

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

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

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

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

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

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

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

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

Other Books You May Enjoy

Part 1: Application-Related Architectural Concepts for FastAPI microservice development

In this part, we will look at the whole FastAPI framework and explore the systematic and ideal way of decomposing a monolithic application into several business units. During the process, you will see how to get started with development and what components there are in FastAPI that can be utilized to pursue microservices implementation.

This part comprises the following chapters:

Chapter 1, Setting Up FastAPI for Starters Chapter 2, Exploring the Core Components Chapter 3, Investigating Dependency Injection Chapter 4, Building the Microservice Application

2

Exploring the Core Features

In the previous chapter, we found out how easy it is to install and start developing REST APIs using the FastAPI framework. Handling requests, cookies, and form data was fast, easy, and straightforward with FastAPI, as was building the different HTTP path operations.