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

External layers

On top of the web server, there is the possibility to continue the link by adding extra levels that work on the HTTP layer. This allows you to load balance between multiple servers and increase the total throughput of the system. This can be chained into multiple layers, if necessary.

Figure 6.6: Chained load balancers

The route from the user to the edge of our system is handled by the internet, but once it reaches the edge load balancer, it directs the requests inside the system. The edge load balancer works as a gateway between the external networks and the controlled environment of our network.

The edge load balancer is normally the only one that handles HTTPS connection, allowing the rest of the system to use only HTTP. This is convenient as HTTP requests are easier to cache and handle. HTTPS requests are encoded end to end and cannot be properly cached or analyzed. The internal traffic is protected from external access and should have robust...

Previous Section
End of Section 7
Next Section