Search icon CANCEL
Subscription
0
Cart icon
Your Cart (0 item)
Close icon
You have no products in your basket yet
Save more on your purchases! discount-offer-chevron-icon
Savings automatically calculated. No voucher code required.
Arrow left icon
Explore Products
Best Sellers
New Releases
Books
Videos
Audiobooks
Learning Hub
Newsletter Hub
Free Learning
Arrow right icon
timer SALE ENDS IN
0 Days
:
00 Hours
:
00 Minutes
:
00 Seconds
Building Python Microservices with FastAPI
Building Python Microservices with FastAPI

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

Arrow left icon
Profile Icon Sherwin John C. Tragura
Arrow right icon
₱1726.99 ₱1918.99
Full star icon Full star icon Full star icon Half star icon Empty star icon 3.9 (9 Ratings)
eBook Aug 2022 420 pages 1st Edition
eBook
₱1726.99 ₱1918.99
Paperback
₱2398.99
Subscription
Free Trial
Arrow left icon
Profile Icon Sherwin John C. Tragura
Arrow right icon
₱1726.99 ₱1918.99
Full star icon Full star icon Full star icon Half star icon Empty star icon 3.9 (9 Ratings)
eBook Aug 2022 420 pages 1st Edition
eBook
₱1726.99 ₱1918.99
Paperback
₱2398.99
Subscription
Free Trial
eBook
₱1726.99 ₱1918.99
Paperback
₱2398.99
Subscription
Free Trial

What do you get with eBook?

Product feature icon Instant access to your Digital eBook purchase
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Product feature icon AI Assistant (beta) to help accelerate your learning
OR
Modal Close icon
Payment Processing...
tick Completed

Billing Address

Table of content icon View table of contents Preview book icon Preview Book

Building Python Microservices with FastAPI

Setting Up FastAPI for Starters

In any software development work, it is always important to first know the business requirement of the project and the appropriate framework, tools, and deployment platform to use before pursuing the task. Frameworks that are easy to understand and use, seamless during coding, and within standards are always picked because of the integrity they provide to solve problems without risking too much development time. And a promising Python framework called FastAPI, created by Sebastian Ramirez, provides experienced developers, experts, and enthusiasts the best option for building REST APIs and microservices.

But before proceeding to the core details of building microservices using FastAPI, it is best to first learn the building blocks of this framework, such as how it captures clients’ requests, how it builds the rules for each HTTP method, and how it manages HTTP responses. Learning the basic components is always essential to know the strengths and weaknesses of the framework and to what extent we can apply FastAPI to solve different enterprise-grade and microservices-related problems.

Thus, in this chapter, we’re going to have a walkthrough of the basic features of FastAPI by covering the following main topics:

  • The setup of the development environment
  • Initialization and configuration of FastAPI
  • Design and implementation of the REST APIs
  • Managing user requests and server response
  • Handling form parameters
  • Handling cookies

Technical requirements

The software specimen for this chapter is a prototypical administrator-managed online academic discussion forum, which is an academic discussion hub where alumni, teachers, and students can exchange ideas. The prototype is working but it is open for changes, so you can tweak the code while reading this chapter. It is not designed to use any database management system, but all the data is temporarily stored in various Python collections. All the applications in this book are compiled and run using Python 3.8. Codes are all uploaded at https://github.com/PacktPublishing/Building-Python-Microservices-with-FastAPI/tree/main/ch01.

Setting up the development environment

The FastAPI framework is a fast, seamless, and robust Python framework but can only work on Python versions 3.6 and above. The Integrated Development Environment (IDE) used in this reference is Visual Studio Code (VS Code), which is an open source tool that we can download from this site: https://code.visualstudio.com/. Just be sure to install the VSC extensions such as Python, Python for VS Code, Python Extension Pack, Python Indent, and Material Icon Theme to provide your editor syntax checking, syntax highlighting, and other editor support.

After the successful installation of Python and VS Code, we can now install FastAPI using a terminal console. To ensure correct installation, first update Python’s package installer (pip) by running this command:

python -m pip install --upgrade pip

Afterward, we install the framework by running this series of commands:

pip install fastapi
pip install uvicorn[standard]
pip install python-multipart

Important note

If you need to install the complete FastAPI platform, including all optional dependencies, the appropriate command is pip install fastapi[all]. Likewise, if you want to install and utilize the full-blown uvicorn server, you should run the pip install uvicorn command. Also, install the bcrypt module for encryption-related tasks.

At this point, you should have installed all the needed FastAPI module dependencies from the pydantic and starlette module components in your Python environment. Furthermore, the python-multipart module is required to create a REST API that handles form parameters. The installed uvicorn, however, is an ASGI-based server that will run your FastAPI applications. The Asynchronous Server Gateway Interface (ASGI) server that FastAPI uses makes it the fastest Python framework at the time of writing. The uvicorn server has the capability to run both synchronous and asynchronous services.

After the installation and configuration of the essential tools, modules, and IDE, let us now start our first API implementation using the framework.

Initializing and configuring FastAPI

Learning how to create applications using FastAPI is easy and straightforward. A simple application can be created just by creating a main.py file inside your /ch01 project folder. In our online academic discussion forum, for instance, the application started with this code:

from fastapi import FastAPI
app = FastAPI()

This initializes the FastAPI framework. The application needs to instantiate the core FastAPI class from the fastapi module and use app as the reference variable to the object. Then, this object is used later as a Python @app decorator, which provides our application with some features such as routes, middleware, exception handlers, and path operations.

Important note

You can replace app with your preferred but valid Python variable name, such as main_app, forum, or myapp.

Now, your application is ready to manage REST APIs that are technically Python functions. But to declare them as REST service methods, we need to decorate them with the appropriate HTTP request method provided by the path operation @app decorator. This decorator contains the get(), post(), delete(), put(), head(), patch(), trace(), and options() path operations, which correspond to the eight HTTP request methods. And these path operations are decorated or annotated on top of the Python functions that we want to handle the request and response.

In our specimen, the first sample that the REST API created was this:

@app.get("/ch01/index")
def index():
    return {"message": "Welcome FastAPI Nerds"} 

The preceding is a GET API service method that returns a JSON object. To locally run our application, we need to execute the following command:

uvicorn main:app --reload

This command will load the forum application to the uvicorn live server through the application’s main.py file with FastAPI object referencing. Live reload is allowed by adding the --reload option, which enables the restart of the development server whenever there are changes in the code.

Figure 1.1 – The uvicorn console log

Figure 1.1 – The uvicorn console log

Figure 1.1 shows that uvicorn uses localhost to run the application with the default port 8000. We can access our index page through http://localhost:8000/ch01/index. To stop the server, you just need to press the Ctrl + C keyboard keys.

After running our first endpoint, let us now explore how to implement the other types of HTTP methods, namely POST, DELETE, PUT, and PATCH.

Designing and implementing REST APIs

The Representation State Transfer (REST) API makes up the rules, processes, and tools that allow interaction among microservices. These are method services that are identified and executed through their endpoint URLs. Nowadays, focusing on API methods before building a whole application is one of the most popular and effective microservices design strategies. This approach, called an API-first microservices development, focuses first on the client’s needs and then later identifies what API service methods we need to implement for these client requirements.

In our online academic discussion forum app, software functionality such as user sign-up, login, profile management, message posting, and managing post replies are some of the crucial needs we prioritized. In a FastAPI framework, these features are implemented as services using functions that are defined using Python’s def keyword, with the association of the appropriate HTTP request method through the path operations provided by @app.

The login service, which requires username and password request parameters from the user, is implemented as a GET API method:

@app.get("/ch01/login/")
def login(username: str, password: str):
    if valid_users.get(username) == None:
        return {"message": "user does not exist"}
    else:
        user = valid_users.get(username)
        if checkpw(password.encode(), 
                   user.passphrase.encode()):
            return user
        else:
            return {"message": "invalid user"}

This login service uses bcrypt’s checkpw() function to check whether the password of the user is valid. Conversely, the sign-up service, which also requires user credentials from the client in the form of request parameters, is created as a POST API method:

@app.post("/ch01/login/signup")
def signup(uname: str, passwd: str):
    if (uname == None and passwd == None):
        return {"message": "invalid user"}
    elif not valid_users.get(uname) == None:
        return {"message": "user exists"}
    else:
        user = User(username=uname, password=passwd)
        pending_users[uname] = user
        return user

Among the profile management services, the following update_profile() service serves as a PUT API service, which requires the user to use an entirely new model object for profile information replacement and the client’s username to serve as the key:

@app.put("/ch01/account/profile/update/{username}")
def update_profile(username: str, id: UUID, 
                     new_profile: UserProfile):
    if valid_users.get(username) == None:
        return {"message": "user does not exist"}
    else:
        user = valid_users.get(username)
        if user.id == id:
            valid_profiles[username] = new_profile
            return {"message": "successfully updated"}
        else:
            return {"message": "user does not exist"}

Not all services that carry out updates are PUT API methods, such as the following update_profile_name() service, which only requires the user to submit a new first name, last name, and middle initial for partial replacement of a client’s profile. This HTTP request, which is handier and more lightweight than a full-blown PUT method, only requires a PATCH action:

@app.patch("/ch01/account/profile/update/names/{username}")
def update_profile_names(username: str, id: UUID, 
                          new_names: Dict[str, str]):
    if valid_users.get(username) == None:
        return {"message": "user does not exist"}
    elif new_names == None:
        return {"message": "new names are required"}
    else:
        user = valid_users.get(username)
        if user.id == id:
            profile = valid_profiles[username]
            profile.firstname = new_names['fname']
            profile.lastname = new_names['lname']
            profile.middle_initial = new_names['mi']
            valid_profiles[username] = profile
            return {"message": "successfully updated"}
        else:
            return {"message": "user does not exist"}

The last essential HTTP services that we included before building the application are the DELETE API methods. We use these services to delete records or information given a unique identification, such as username and a hashed id. An example is the following delete_post_discussion() service that allows a user to delete a posted discussion when given a username and the UUID (Universally Unique Identifier) of the posted message:

@app.delete("/ch01/discussion/posts/remove/{username}")
def delete_discussion(username: str, id: UUID):
    if valid_users.get(username) == None:
        return {"message": "user does not exist"}
    elif discussion_posts.get(id) == None:
        return {"message": "post does not exist"}
    else:
        del discussion_posts[id] 
        return {"message": "main post deleted"}

All path operations require a unique endpoint URL in the str format. A good practice is to start all URLs with the same top-level base path, such as /ch01, and then differ when reaching their respective subdirectories. After running the uvicorn server, we can check and validate whether all our URLs are valid and running by accessing the documentation URL, http://localhost:8000/docs. This path will show us a OpenAPI dashboard, as shown in Figure 1.2, listing all the API methods created for the application. Discussions on the OpenAPI will be covered in Chapter 9, Utilizing Other Advanced Features.

Figure 1.2 – A Swagger OpenAPI dashboard

Figure 1.2 – A Swagger OpenAPI dashboard

After creating the endpoint services, let us scrutinize how FastAPI manages its incoming request body and the outgoing response.

Left arrow icon Right arrow icon
Download code icon Download Code

Key benefits

  • Provides a reference that contains definitions, illustrations, comparative analysis, and the implementation of real-world apps
  • Covers concepts, core details, and advanced integration and design-related topics
  • Imparts context, app templates, suggestions, and insights that are helpful to actual projects

Description

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.

Who is this book for?

This book is for Python web developers, advanced Python developers, 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.

What you will learn

  • Understand, orient, and implement REST APIs using the basic components of the FastAPI framework
  • Build asynchronous as well as synchronous REST services using the built-in pydantic module and asyncio support
  • Create small-scale and large-scale microservices applications using features supported by FastAPI
  • Build event-driven and message-driven applications using the framework
  • Create an asynchronous and synchronous data layer with both relational and NoSQL databases
  • Perform numerical and symbolic computations with FastAPI

Product Details

Country selected
Publication date, Length, Edition, Language, ISBN-13
Publication date : Aug 30, 2022
Length: 420 pages
Edition : 1st
Language : English
ISBN-13 : 9781803238791
Languages :
Concepts :
Tools :

What do you get with eBook?

Product feature icon Instant access to your Digital eBook purchase
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Product feature icon AI Assistant (beta) to help accelerate your learning
OR
Modal Close icon
Payment Processing...
tick Completed

Billing Address

Product Details

Publication date : Aug 30, 2022
Length: 420 pages
Edition : 1st
Language : English
ISBN-13 : 9781803238791
Languages :
Concepts :
Tools :

Packt Subscriptions

See our plans and pricing
Modal Close icon
$19.99 billed monthly
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Simple pricing, no contract
$199.99 billed annually
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Choose a DRM-free eBook or Video every month to keep
Feature tick icon PLUS own as many other DRM-free eBooks or Videos as you like for just ₱260 each
Feature tick icon Exclusive print discounts
$279.99 billed in 18 months
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Choose a DRM-free eBook or Video every month to keep
Feature tick icon PLUS own as many other DRM-free eBooks or Videos as you like for just ₱260 each
Feature tick icon Exclusive print discounts

Frequently bought together


Stars icon
Total 7,093.97
Building Python Web APIs with FastAPI
₱2142.99
Mastering Python 2E
₱2551.99
Building Python Microservices with FastAPI
₱2398.99
Total 7,093.97 Stars icon

Table of Contents

16 Chapters
Part 1: Application-Related Architectural Concepts for FastAPI microservice development Chevron down icon Chevron up icon
Chapter 1: Setting Up FastAPI for Starters Chevron down icon Chevron up icon
Chapter 2: Exploring the Core Features Chevron down icon Chevron up icon
Chapter 3: Investigating Dependency Injection Chevron down icon Chevron up icon
Chapter 4: Building the Microservice Application Chevron down icon Chevron up icon
Part 2: Data-Centric and Communication-Focused Microservices Concerns and Issues Chevron down icon Chevron up icon
Chapter 5: Connecting to a Relational Database Chevron down icon Chevron up icon
Chapter 6: Using a Non-Relational Database Chevron down icon Chevron up icon
Chapter 7: Securing the REST APIs Chevron down icon Chevron up icon
Chapter 8: Creating Coroutines, Events, and Message-Driven Transactions Chevron down icon Chevron up icon
Part 3: Infrastructure-Related Issues, Numerical and Symbolic Computations, and Testing Microservices Chevron down icon Chevron up icon
Chapter 9: Utilizing Other Advanced Features Chevron down icon Chevron up icon
Chapter 10: Solving Numerical, Symbolic, and Graphical Problems Chevron down icon Chevron up icon
Chapter 11: Adding Other Microservice Features Chevron down icon Chevron up icon
Index Chevron down icon Chevron up icon
Other Books You May Enjoy Chevron down icon Chevron up icon

Customer reviews

Top Reviews
Rating distribution
Full star icon Full star icon Full star icon Half star icon Empty star icon 3.9
(9 Ratings)
5 star 55.6%
4 star 0%
3 star 33.3%
2 star 0%
1 star 11.1%
Filter icon Filter
Top Reviews

Filter reviews by




Moses Kayanda Sep 11, 2022
Full star icon Full star icon Full star icon Full star icon Full star icon 5
I got an opportunity to go through the book as I was learning about FastAPI framework and I must say the author has done very well explaining what I thought was a complex domain. Going through the book opens up your understanding of creating an enterprise grade microservice application. You will a very detailed introduction into setting up FastAPI endpoints, get a feel of working with decorators (which prior to this, my knowledge was shacky), to core features how to connect a relational database, securing REST APIs to utilizing and adding advanced features such as OpenTracing, client-side service discovery and likes, among other essential topic areas. You will learn how to manage exceptions for building resilient microservice architecture when business processes become intricate. The book also touches on dependency injection and how it affects our FastAPIs projects.The book acts as a detailed reference guide whether you are learning this or implementing the same in your day job. By the end of it, you should have familiarized yourself with all the core components of FastAPI helping you upgrade the simple applications to quality ones.The book has left a curiosity in me to further learn about microservice architecture. I would highly recommend this book to anyone who would live to delve knees deep into this domain area.
Amazon Verified review Amazon
THOMAS GEORGE THOMAS Sep 17, 2022
Full star icon Full star icon Full star icon Full star icon Full star icon 5
This book is well written and is in an easy-to-understand manner. I am new to FastAPI and I got a good sense of it going through this book. I especially liked the chapters on how to connect FastAPI with SQL and NoSQL databases. A lot of the examples in this book are based on real-life scenarios which helped me think about designing systems efficiently. It also talks about how to leverage microservices to work with Kafka, Neo4j, and GraphQL platforms and also how to deploy and run on docker.Overall, it's a great book with lots of real-world applications. I would recommend it to someone looking for good microservices solutions design.
Amazon Verified review Amazon
Jose Machado Jun 11, 2023
Full star icon Full star icon Full star icon Full star icon Full star icon 5
The book kicks off with a stellar opening chapter that briefly summarizes the key concepts of FastAPI. This explanation is designed to welcome newcomers into the realm of FastAPI, while also providing an engaging refresher for those already familiar with the framework. The second chapter delves deeper into the core features of the framework, paving the way for the rest of the book.Is amazing to see how these interconnected subjects have been transformed by the author into self-contained sections that can be read and understood in isolation, offering the reader the flexibility to navigate the book nonlinearly. Once the first two chapters are assimilated, you have the freedom to choose your subsequent learning path.This book is a powerful resource for anyone aspiring to become a proficient and comprehensive FastAPI Python developer. It equips you for a myriad of topics that extend beyond merely utilizing the library, such as multi-layered dependency injection, microservice design principles, interacting with non-relational databases (which are frequently utilized in contemporary projects), addressing security concerns, and various other topics.In spite of its compelling content, I couldn't ignore the errors present in some of the annotations and the less-than-ideal formatting of the code. Nonetheless, this is a commendable book for programmers who prioritize efficiency, code quality, and adherence to best practices. However, note that novice programmers might find it challenging to progress past the second chapter. Some of the advanced topics might not appeal to beginners in the early stages of their coding journey, who are often more focused on getting tasks accomplished rather than delving into intricate details.
Amazon Verified review Amazon
Samyak Jan 03, 2023
Full star icon Full star icon Full star icon Full star icon Full star icon 5
Easy to understand the concept and to implement the Rest API using FastAPI framework.the book contains definitions, Examples and comparative analysis and the implementation of real world apps. Definitely recommend.
Amazon Verified review Amazon
RUI WANG Sep 30, 2022
Full star icon Full star icon Full star icon Full star icon Full star icon 5
This book has been a big help to me. I've been trying to learn Python myself and this book is a great guide. What I love the most is that it is so structured and organized that after teaching the concepts, it also has practice chapters where I could apply what I learned. It is always hard to keep going without actual practice because you thought you learned but you didn't. For every new concept the author attached code examples and detailed word explanations, which is super helpful. Strongly recommend!
Amazon Verified review Amazon
Get free access to Packt library with over 7500+ books and video courses for 7 days!
Start Free Trial

FAQs

How do I buy and download an eBook? Chevron down icon Chevron up icon

Where there is an eBook version of a title available, you can buy it from the book details for that title. Add either the standalone eBook or the eBook and print book bundle to your shopping cart. Your eBook will show in your cart as a product on its own. After completing checkout and payment in the normal way, you will receive your receipt on the screen containing a link to a personalised PDF download file. This link will remain active for 30 days. You can download backup copies of the file by logging in to your account at any time.

If you already have Adobe reader installed, then clicking on the link will download and open the PDF file directly. If you don't, then save the PDF file on your machine and download the Reader to view it.

Please Note: Packt eBooks are non-returnable and non-refundable.

Packt eBook and Licensing When you buy an eBook from Packt Publishing, completing your purchase means you accept the terms of our licence agreement. Please read the full text of the agreement. In it we have tried to balance the need for the ebook to be usable for you the reader with our needs to protect the rights of us as Publishers and of our authors. In summary, the agreement says:

  • You may make copies of your eBook for your own use onto any machine
  • You may not pass copies of the eBook on to anyone else
How can I make a purchase on your website? Chevron down icon Chevron up icon

If you want to purchase a video course, eBook or Bundle (Print+eBook) please follow below steps:

  1. Register on our website using your email address and the password.
  2. Search for the title by name or ISBN using the search option.
  3. Select the title you want to purchase.
  4. Choose the format you wish to purchase the title in; if you order the Print Book, you get a free eBook copy of the same title. 
  5. Proceed with the checkout process (payment to be made using Credit Card, Debit Cart, or PayPal)
Where can I access support around an eBook? Chevron down icon Chevron up icon
  • If you experience a problem with using or installing Adobe Reader, the contact Adobe directly.
  • To view the errata for the book, see www.packtpub.com/support and view the pages for the title you have.
  • To view your account details or to download a new copy of the book go to www.packtpub.com/account
  • To contact us directly if a problem is not resolved, use www.packtpub.com/contact-us
What eBook formats do Packt support? Chevron down icon Chevron up icon

Our eBooks are currently available in a variety of formats such as PDF and ePubs. In the future, this may well change with trends and development in technology, but please note that our PDFs are not Adobe eBook Reader format, which has greater restrictions on security.

You will need to use Adobe Reader v9 or later in order to read Packt's PDF eBooks.

What are the benefits of eBooks? Chevron down icon Chevron up icon
  • You can get the information you need immediately
  • You can easily take them with you on a laptop
  • You can download them an unlimited number of times
  • You can print them out
  • They are copy-paste enabled
  • They are searchable
  • There is no password protection
  • They are lower price than print
  • They save resources and space
What is an eBook? Chevron down icon Chevron up icon

Packt eBooks are a complete electronic version of the print edition, available in PDF and ePub formats. Every piece of content down to the page numbering is the same. Because we save the costs of printing and shipping the book to you, we are able to offer eBooks at a lower cost than print editions.

When you have purchased an eBook, simply login to your account and click on the link in Your Download Area. We recommend you saving the file to your hard drive before opening it.

For optimal viewing of our eBooks, we recommend you download and install the free Adobe Reader version 9.