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.

Preface

Who this book is for

What this book covers

To get the most out of this book

Share your thoughts

Free Chapter

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

Part I: Design

API Design

RESTful interfaces

Versioning the API

Frontend and backend

HTML interfaces

Designing the API for the example

Data Modeling

Types of databases

Database transactions

Distributed relational databases

The Data Layer

The Model layer

Database migrations

Dealing with legacy databases

Part II: Architectural Patterns

Part II: Architectural Patterns

The Twelve-Factor App Methodology

The Twelve-Factor App Methodology

Intro to the Twelve-Factor App

Continuous Integration

The Twelve Factors

Containerized Twelve-Factor Apps

Web Server Structures

Web Server Structures

Request-response

Web architecture

External layers

Event-Driven Structures

Event-Driven Structures

Asynchronous tasks

Subdividing tasks

Scheduled tasks

Advanced Event-Driven Structures

Advanced Event-Driven Structures

Streaming events

More complex systems

Testing event-driven systems

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

Part III: Implementation

Part III: Implementation

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

Package Management

Package Management

The creation of a new package

Trivial packaging in Python

The Python packaging ecosystem

Creating a package

Python package with binary code

Uploading your package to PyPI

Creating your own private index

Part IV: Ongoing operations

Part IV: Ongoing operations

Logging

Producing logs in Python

Detecting problems through logs

Adding logs while developing

Log limitations

Metrics

Metrics versus logs

Generating metrics with Prometheus

Querying Prometheus

Proactively working with metrics

Profiling

Profiling basics

Types of profilers

Profiling code for time

Partial profiling

Memory profiling

Debugging

Detecting and processing defects

Investigation in production

Understanding the problem in production

Local debugging

Python introspection tools

Debugging with logs

Debugging with breakpoints

Ongoing Architecture

Ongoing Architecture

Adjusting the architecture

Scheduled downtime

Backward compatibility

Teamwork aspects of changes

Other Books You May Enjoy

Other Books You May Enjoy

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Celery

Celery is the most popular task queue created in Python. It allows us to create new tasks easily and can handle the creation of the events that trigger new tasks.

Celery requires to work to set up a broker, which will be used as a queue to handle the messages.

In Celery parlance, the broker is the message queue, while the backend is reserved for interacting with a storage system to return information.

The code that creates the message will add it to the broker, and the broker will pass it to one of the connected workers. When everything happens with Python code, where the celery package can be installed, it's simple to operate. We'll see later how to operate it in other cases.

Celery can use multiple systems as brokers. The most popular are Redis and RabbitMQ.

In our examples, we will use Redis as it can be used for the broker and the backend, and it's widely available in cloud systems. It's also quite scalable and...