Book Image

Python Architecture Patterns

By : Jaime Buelta
Book Image

Python Architecture Patterns

By: Jaime Buelta

Overview of this book

Developing large-scale systems that continuously grow in scale and complexity requires a thorough understanding of how software projects should be implemented. Software developers, architects, and technical management teams rely on high-level software design patterns such as microservices architecture, event-driven architecture, and the strategic patterns prescribed by domain-driven design (DDD) to make their work easier. This book covers these proven architecture design patterns with a forward-looking approach to help Python developers manage application complexity—and get the most value out of their test suites. Starting with the initial stages of design, you will learn about the main blocks and mental flow to use at the start of a project. The book covers various architectural patterns like microservices, web services, and event-driven structures and how to choose the one best suited to your project. Establishing a foundation of required concepts, you will progress into development, debugging, and testing to produce high-quality code that is ready for deployment. You will learn about ongoing operations on how to continue the task after the system is deployed to end users, as the software development lifecycle is never finished. By the end of this Python book, you will have developed "architectural thinking": a different way of approaching software design, including making changes to ongoing systems.

Related Content you might be interested in

Current Title:

Small book image
Python Architecture Patterns
Jaime Buelta
Jan, 2022 | 594 pages
Small book image
Hands-On Docker for Microservices with Python
Jaime Buelta
Nov, 2019 | 408 pages
Small book image
Crafting Test-Driven Software with Python
Alessandro Molina
Feb, 2021 | 338 pages
Small book image
Python Automation Cookbook.
Jaime Buelta
May, 2020 | 526 pages
Table of Contents (23 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Share your thoughts
Free Chapter
1
Introduction to Software Architecture
Introduction to Software Architecture
Defining the structure of a system
Division into smaller units
Conway's Law – Effects on software architecture
Application example – Overview
Security aspects of software architecture
Summary
2
Part I: Design
Part I: Design
3
API Design
API Design
Abstractions
RESTful interfaces
Authentication
Versioning the API
Frontend and backend
HTML interfaces
Designing the API for the example
Summary
4
Data Modeling
Data Modeling
Types of databases
Database transactions
Distributed relational databases
Schema design
Data indexing
Summary
5
The Data Layer
The Data Layer
The Model layer
Database migrations
Dealing with legacy databases
Summary
6
Part II: Architectural Patterns
Part II: Architectural Patterns
7
The Twelve-Factor App Methodology
The Twelve-Factor App Methodology
Intro to the Twelve-Factor App
Continuous Integration
Scalability
Configuration
The Twelve Factors
Containerized Twelve-Factor Apps
Summary
8
Web Server Structures
Web Server Structures
Request-response
Web architecture
Web servers
uWSGI
Python worker
External layers
Summary
9
Event-Driven Structures
Event-Driven Structures
Sending events
Asynchronous tasks
Subdividing tasks
Scheduled tasks
Queue effects
Celery
Summary
10
Advanced Event-Driven Structures
Advanced Event-Driven Structures
Streaming events
Pipelines
Defining a bus
More complex systems
Testing event-driven systems
Summary
11
Microservices vs Monolith
Microservices vs Monolith
Monolithic architecture
The microservices architecture
Which architecture to choose
The key factor – team communication
Moving from a monolith to microservices
Containerizing services
Orchestration and Kubernetes
Summary
12
Part III: Implementation
Part III: Implementation
13
Testing and TDD
Testing and TDD
Testing the code
Different levels of testing
Testing philosophy
Test-Driven Development
Introduction to unit testing in Python
Testing external dependencies
Advanced pytest
Summary
14
Package Management
Package Management
The creation of a new package
Trivial packaging in Python
The Python packaging ecosystem
Creating a package
Cython
Python package with binary code
Uploading your package to PyPI
Creating your own private index
Summary
15
Part IV: Ongoing operations
Part IV: Ongoing operations
16
Logging
Logging
Log basics
Producing logs in Python
Detecting problems through logs
Log strategies
Adding logs while developing
Log limitations
Summary
17
Metrics
Metrics
Metrics versus logs
Generating metrics with Prometheus
Querying Prometheus
Proactively working with metrics
Alerting
Summary
18
Profiling
Profiling
Profiling basics
Types of profilers
Profiling code for time
Partial profiling
Memory profiling
Summary
19
Debugging
Debugging
Detecting and processing defects
Investigation in production
Understanding the problem in production
Local debugging
Python introspection tools
Debugging with logs
Debugging with breakpoints
Summary
20
Ongoing Architecture
Ongoing Architecture
Adjusting the architecture
Scheduled downtime
Incidents
Load testing
Versioning
Backward compatibility
Feature flags
Teamwork aspects of changes
Summary
21
Other Books You May Enjoy
Other Books You May Enjoy
22
Index
Index

Backward compatibility

The key aspect of changing architecture in a running system is the necessity of always keeping backward compatibility in its interfaces and APIs.

We also talked about backward compatibility in regard to databases changes in Chapter 3, Data Modeling. Here we will talk about interfaces, but it follows the same ideas.

Backward compatibility means that systems keep their old interfaces working as expected, so any calling system won't be affected by the change. This allows them to be upgraded at any point, without interrupting the service.

Keep in mind that backward compatibility needs to apply externally, as customers rely on a stable working interface, but also internally where multiple services interact with each other. If the system is complex and has multiple parts, the APIs connecting them should be backward compatible. This is particularly important in microservices architectures to allow the independent deployment of microservices...

Previous Section
End of Section 7
Next Section