book

Building Python Microservices with FastAPI

Name: Building Python Microservices with FastAPI
Author: Sherwin John C. Tragura
ISBN: 9781803245966

by Sherwin John C. Tragura

August 2022

Intermediate to advanced

420 pages

9h 32m

English

Packt Publishing

Read now

Unlock full access

Building Python Microservices with FastAPI
ContributorsAbout the authorAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchShare your thoughts
Part 1: Application-Related Architectural Concepts for FastAPI microservice development
Chapter 1: Setting Up FastAPI for Starters
Technical requirementsSetting up the development environmentInitializing and configuring FastAPIDesigning and implementing REST APIsManaging user requests and server responseParameter type declarationPath parametersQuery parametersDefault parametersOptional parametersMixing all types of parametersRequest bodyRequest headersResponse dataHandling form parametersManaging cookiesSummary
Chapter 2: Exploring the Core Features
Technical requirementsStructuring and organizing huge projectsImplementing the API servicesImporting the module componentsImplementing the new main.py fileManaging API-related exceptionsA single status code responseMultiple status codesRaising HTTPExceptionCustom exceptionsA default handler overrideConverting objects to JSON-compatible typesManaging API responsesCreating background processesUsing asynchronous path operationsApplying middleware to filter path operationsSummary
Chapter 3: Investigating Dependency Injection
Technical requirementsApplying IoC/DIInjecting a dependency functionInjecting a callable classBuilding nested dependenciesCaching the dependenciesDeclaring Depends() parameter typesInjecting asynchronous dependenciesExploring ways of injecting dependenciesDependency injection on servicesDependency injection on path operatorsDependency injection on routersDependency injection on main.pyOrganizing a project based on dependenciesThe model layerThe repository layerThe repository factory methodsThe service layerThe REST API and the service layerThe actual project structureUsing third-party containersUsing configurable containers – Dependency InjectorUsing a simple configuration – LagomThe FastAPI and Lagom integrationScoping of dependablesSummary
Chapter 4: Building the Microservice Application
Technical requirementsApplying the decomposition patternCreating the sub-applicationsMounting the submodulesCreating a common gatewayImplementing the main endpointEvaluating the microservice IDApplying the exception handlersCentralizing the logging mechanismUtilizing the Loguru moduleBuilding the logging middlewareConsuming the REST API servicesUsing the httpx moduleUsing the requests moduleApplying the domain modeling approachCreating the layersIdentifying the domain modelsBuilding the repository and service layersUsing the factory method patternManaging a microservice’s configuration detailsStoring settings as class attributesStoring settings in the properties fileSummary
Part 2: Data-Centric and Communication-Focused Microservices Concerns and Issues
Chapter 5: Connecting to a Relational Database
Technical requirementsPreparing for database connectivityCreating CRUD transactions using SQLAlchemyInstalling the database driverSetting up the database connectionInitializing the session factoryDefining the Base classBuilding the model layerImplementing the repository layerRunning the transactionsCreating tables Implementing async CRUD transactions using SQLAlchemyInstalling the asyncio-compliant database driversSetting up the database’s connectionCreating the session factoryCreating the Base class and the model layerBuilding the repository layerRunning the CRUD transactionsUsing GINO for async transactionsInstalling the database driverEstablishing the database connectionBuilding the model layerImplementing the CRUD transactionsRunning the CRUD transactionsCreating the tablesUsing Pony ORM for the repository layerInstalling the database driverCreating the database’s connectivityDefining the model classesImplementing the CRUD transactionsRunning the repository transactionsCreating the tablesBuilding the repository using PeeweeInstalling the database driverCreating the database connectionCreating the tables and the domain layerImplementing the CRUD transactionsRunning the CRUD transactionApplying the CQRS design patternDefining the handler interfacesCreating the command and query classesCreating the command and query handlersAccessing the handlersSummary
Chapter 6: Using a Non-Relational Database
Technical requirementsSetting up the database environmentApplying the PyMongo driver for synchronous connectionsSetting up the database connectivityBuilding the model layerImplementing the repository layerRunning the transactionsCreating async CRUD transactions using MotorSetting up the database connectivityCreating the model layerRunning the CRUD transactionsImplementing CRUD transactions using MongoEngineEstablishing database connectionBuilding the model layerImplementing the CRUD transactionsRunning the CRUD transactionsImplementing async transactions using BeanieCreating the database connectionDefining the model classesImplementing the CRUD transactionsRunning the repository transactionsBuilding async repository for FastAPI using ODManticCreating the database connectionCreating the model layerImplementing the CRUD transactionsRunning the CRUD transactionCreating CRUD transactions using MongoFramesCreating the database connectionBuilding the model layerCreating the repository layerApplying the repository layerSummary

Chapter 7: Securing the REST APIs
Technical requirementsImplementing Basic and Digest authenticationUsing Basic authenticationUsing Digest authenticationImplementing password-based authenticationInstalling the python-multipart moduleUsing OAuth2PasswordBearer and OAuth2PasswordRequestFormExecuting the login transactionSecuring the endpointsApplying JWTsGenerating the secret keyCreating the access_tokenCreating the login transactionAccessing the secured endpointsCreating scope-based authorizationCustomizing the OAuth2 classBuilding the permission dictionaryImplementing the login transactionApplying the scopes to endpointsBuilding the authorization code flowApplying OAuth2AuthorizationCodeBearerImplementing the authorization requestImplementing the authorization code responseApplying the OpenID Connect specificationUsing HTTPBearerInstalling and configuring the Keycloak environmentSetting the Keycloak realm and clientsCreating users and user rolesAssigning roles to clientsCreating user permissions through scopesIntegrating Keycloak with FastAPIImplementing the token verificationIntegrating Auth0 with FastAPIIntegrating Okta with FastAPIUsing built-in middlewares for authenticationSummary
Chapter 8: Creating Coroutines, Events, and Message-Driven Transactions
Technical requirementsImplementing coroutinesApplying coroutine switchingDesigning asynchronous transactionsUsing the HTTP/2 protocolCreating asynchronous background tasksUsing the coroutinesCreating multiple tasksUnderstanding Celery tasksCreating and configuring the Celery instanceCreating the taskCalling the taskStarting the worker serverMonitoring the tasksBuilding message-driven transactions using RabbitMQCreating the Celery instanceMonitoring AMQP messagingBuilding publish/subscribe messaging using KafkaRunning the Kafka broker and serverCreating the topicImplementing the publisherRunning a consumer on a consoleImplementing asynchronous Server-Sent Events (SSE)Building an asynchronous WebSocketImplementing the asynchronous WebSocket endpointImplementing the WebSocket clientApplying reactive programming in tasksCreating the Observable data using coroutinesCreating background processAccessing API resourcesCustomizing eventsDefining the startup eventDefining shutdown eventsSummary
Part 3: Infrastructure-Related Issues, Numerical and Symbolic Computations, and Testing Microservices
Chapter 9: Utilizing Other Advanced Features
Technical requirementsApplying session managementCreating user sessionsManaging session dataRemoving the sessionsCustomizing BaseHTTPMiddlewareManaging the CORS mechanismCustomizing APIRoute and RequestManaging body, form, or JSON dataEncrypting and decrypting the message bodyChoosing the appropriate responsesSetting up the Jinja2 template engineSetting up the static resourcesCreating the template layoutUsing ORJSONResponse and UJSONResponseApplying the OpenAPI 3.x specificationExtending the OpenAPI schema definitionUsing the internal code base propertiesUsing the Query, Form, Body, and Path functionsTesting the API endpointsWriting the unit test casesMocking the dependenciesRunning test methodsSummary
Chapter 10: Solving Numerical, Symbolic, and Graphical Problems
Technical requirementsSetting up the projectsUsing the Piccolo ORM The Beanie ODMImplementing symbolic computationsCreating symbolic expressionsSolving linear expressionsSolving non-linear expressionsSolving linear and non-linear inequalitiesCreating arrays and DataFramesApplying NumPy’s linear system operationsApplying the pandas modulePerforming statistical analysisGenerating CSV and XLSX reportsPlotting data modelsSimulating a BPMN workflowDesigning the BPMN workflowImplementing the workflowUsing GraphQL queries and mutationsSetting up the GraphQL platformCreating the record insertion, update, and deletionImplementing the query transactionsRunning the CRUD transactionsUtilizing the Neo4j graph databaseSetting the Neo4j databaseCreating the CRUD transactionsSummary
Chapter 11: Adding Other Microservice Features
Technical requirementsSetting up the virtual environmentChecking the API propertiesImplementing open tracing mechanismsSetting up service registry and client-side service discoveryImplementing client-side service discoverySetting up the Netflix Eureka service registryDeploying and running applications using DockerGenerating the requirements.txt fileCreating the Docker image Using the Mongo Docker imageCreating the containersUsing Docker Compose for deploymentUsing NGINX as an API GatewayIntegrating Flask and Django sub-applicationsSummary
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare your thoughts

Overview

Dive into the world of FastAPI with this comprehensive guide to building Python microservices. Whether you're a seasoned backend developer or new to the field, you'll learn how to design, deploy, and maintain scalable and fast microservices using the latest techniques and practices.

What this Book will help me do

Understand the role of FastAPI in the Python ecosystem and master its installation and initial setup.
Design and build async and sync REST APIs leveraging FastAPI's pydantic and built-in asyncio support.
Employ advanced design patterns for creating efficient and scalable microservices architecture.
Integrate relational and NoSQL databases seamlessly with your microservices applications.
Enhance your applications with event-driven and message-driven designs while ensuring security and optimal performance.

Author(s)

Sherwin John C. Tragura is an experienced software engineer and technical writer with a passion for Python and web backend technologies. With years of professional experience in backend development and a drive for creating practical educational content, Sherwin combines clarity and depth. His approachable writing style has helped countless developers enhance their skills.

Who is it for?

This book is ideal for Python developers, backend engineers, and software architects eager to expand their knowledge of microservices using FastAPI. Familiarity with REST APIs and Python programming will help you extract maximum value. Whether transitioning from frameworks like Flask or Django or building new skills in modern backend technologies, this book caters directly to your needs.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781803245966

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills