Python Microservices Development 2nd Ed.

Build efficient and lightweight microservices using the Python tooling ecosystem

Simon Fraser, Tarek Ziadé

Publisher: Packt, 2021, 293 pages

ISBN: 978-1-80107-630-2

Keywords: Python, Programming

Last modified: July 18, 2022, 8:23 p.m.

The small scope and self-contained nature of microservices make them faster, cleaner, and more scalable than code-heavy monolithic applications. However, building microservices architecture that is efficient as well as lightweight into your applications can be challenging due to the complexity of all the interacting pieces.

Python Microservices Development, Second Edition will teach you how to overcome these issues and craft applications that are built as small standard units using proven best practices and avoiding common pitfalls. Through hands-on examples, this book will help you to build efficient microservices using Quart, SQLAlchemy, and other modern Python tools.

In this updated edition, you will learn how to secure connections between services and how to script nginx using Lua to build web application firewall features such as rate limiting. Python Microservices Development, Second Edition describes how to use containers and AWS to deploy your services. By the end of the book, you'll have created a complete Python application based on microservices.

Things you will learn:

  • Explore what microservices are and how to design them
  • Configure and package your code according to modern best practices
  • Identify a component of a larger service that can be turned into a microservice
  • Handle more incoming requests, more effectively
  • Protect your application with a proxy or firewall
  • Use Kubernetes and containers to deploy a microservice
  • Make change to an API provided by a microservice safely and keep things working
  • Identify the factors to look for to get started with an unfamiliar cloud provider
  1. Understanding Microservices
    • The origins of service-oriented architecture
    • The monolithic approach
    • The microservice approach
    • Microservice benefits
      • Separation of concerns
      • Smaller projects
      • Scaling and deployment
    • Pitfalls of microservices
      • Illogical splitting
      • More network interactions
      • Data storing and sharing
      • Compatibility issues
      • Testing
    • Implementing microservices with Python
      • How web services work
      • The WSGI standard
      • Workers, threads, and synchronicity
        • A worker pool approach
        • Being asynchronous
        • Twisted, Tornado, Greenlets, and Gevent
        • Asynchronous Python
      • Language performance
    • Summary
  2. Discovering Quart
    • Making sure we have Python
    • How Quart handles requests
      • Routing
        • Variables and converters
        • The url_for function
      • Request
      • Response
    • Quart's built-in features
      • The session object
      • Globals
      • Signals
      • Extensions and middleware
      • Templates
      • Configuration
      • Blueprints
      • Error handling
        • Custom error handler
    • A microservice skeleton
    • Summary
  3. Coding, Testing, and Documentation: the Virtuous Cycle
    • Different kinds of tests
      • Unit tests
      • Functional tests
      • Integration tests
      • Load tests
      • End-to-end tests
    • Using pytest and tox
    • Developer documentation
      • Tools for documentation
    • Version control
    • Continuous Integration and Continuous Deployment
      • GitHub Actions
      • Documentation
      • Coveralls
      • Badges
    • Summary
  4. Designing Jeeves
    • The Jeeves bot
    • User stories
    • Monolithic design
      • Model
      • View and template
      • A human-readable view
      • Slack workspaces
      • Taking actions
      • OAuth tokens
      • Authentication and authorization
      • Background tasks
    • Putting together the monolithic design
    • Summary
  5. Splitting the Monolith
    • Identifying potential microservices
      • Code complexity and maintenance
      • Metrics and Monitoring
      • Logging
    • Splitting a Monolith
      • Feature Flags
    • Refactoring Jeeves
      • Workflow
    • Summary
  6. Interacting with Other Services
    • Calling other web resources
    • Finding out where to go
      • Environment variables
      • Service discovery
    • Transferring data
      • HTTP cache headers
      • GZIP compression
      • Protocol Buffers
      • MessagePack
      • Putting it together
    • Asynchronous messages
      • Message queue reliability
      • Basic queues
      • Topic exchanges and queues
      • Publish/subscribe
      • Putting it together
    • Testing
    • Using OpenAPI
    • Summary
  7. Securing Your Services
    • The OAuth2 protocol
    • X.509 certificate-based authentication
    • Token-based authentication
      • The JWT standard
      • PyJWT
      • Using a certificate with JWT
    • The TokenDealer microservice
      • The OAuth implementation
      • Using TokenDealer
    • Securing your code
      • Limiting your application scope
      • Untrusted incoming data
      • Redirecting and trusting queries
      • Sanitizing input data
      • Using Bandit linter
      • Dependencies
    • Web application firewall
      • OpenResty: Lua and nginx
      • Rate and concurrency limiting
      • Other OpenResty features
    • Summary
  8. Making a Dashboard
    • Building a ReactJS dashboard
      • The JSX syntax
      • React components
      • Pre-processing JSX
    • ReactJS and Quart
      • Cross-origin resource sharing
    • Authentication and authorization
      • A note about Micro Frontends
      • Getting the Slack token
      • JavaScript authentication
    • Summary
  9. Packaging and Running Python
    • The packaging toolchain
      • A few definitions
      • Packaging
        • The file
        • The requirements.txt file
        • The file
      • Versioning
      • Releasing
      • Distributing
    • Running all microservices
    • Process management
    • Summary
  10. Deploying on AWS
    • What is Docker?
    • Introduction to Docker
    • Running Quart in Docker
    • Docker-based deployments
      • Terraform
      • Service discovery
      • Docker Compose
      • Docker Swarm
      • Kubernetes
    • Summary
  11. What's Next?
    • What's Next?
    • Automation
    • Scaling
    • Content Delivery Networks
    • Multi-cloud deployments
    • Lambda Functions
    • Expanding monitoring
    • Making promises
    • Summary
  • Other Books You May Enjoy


Python Microservices Development

Reviewed by Roland Buresund

Decent ****** (6 out of 10)

Last modified: Aug. 21, 2023, 3:51 p.m.

Fair book about how to build microservices, even if the usage of Quart is is a bit odd (an offspring of Flask), and a lot of the book is spent on discussing different tech choices.

But it is a fair introduction to the subject.


There are currently no comments

New Comment


required (not published)