Python Architecture Patterns

Cover
Copyright
Table of Contents
Preface
Chapter 1: Introduction to Software Architecture
	Defining the structure of a system
	Division into smaller units
		In-process communication
	Conway's Law – Effects on software architecture
	Application example – Overview
	Security aspects of software architecture
	Summary
Part I
Chapter 2: API Design
	Abstractions
		Using the right abstractions
		Leaking abstractions
		Resources and action abstractions
	RESTful interfaces
		A more practical definition
		Headers and statuses
		Designing resources
		Resources and parameters
		Pagination
		Designing a RESTful API process
		Using the Open API specification
	Authentication
		Authenticating HTML interfaces
		Authenticating RESTful interfaces
			Self-encoded tokens
	Versioning the API
		Why versioning?
		Internal versus external versioning
		Semantic versioning
		Simple versioning
	Frontend and backend
		Model View Controller structure
	HTML interfaces
		Traditional HTML interfaces
		Dynamic pages
		Single-page apps
		Hybrid approach
	Designing the API for the example
		Endpoints
			Review of the design and implementation
	Summary
Chapter 3: Data Modeling
	Types of databases
		Relational databases
		Non-relational databases
			Key-value stores
			Document stores
			Wide-column databases
			Graph databases
		Small databases
	Database transactions
	Distributed relational databases
		Primary/replica
		Sharding
			Pure sharding
			Mixed sharding
			Table sharding
		Advantages and disadvantages of sharding
	Schema design
		Schema normalization
		Denormalization
	Data indexing
		Cardinality
	Summary
Chapter 4: The Data Layer
	The Model layer
		Domain-Driven Design
		Using ORM
			Independence from the database
			Independence from SQL and the Repository pattern
			No problems related to composing SQL
		The Unit of Work pattern and encapsulating the data
		CQRS, using different models for read and write
	Database migrations
		Backward compatibility
		Relational schema changes
			Changing the database without interruption
			Data migrations
		Changes without enforcing a schema
	Dealing with legacy databases
		Detecting a schema from a database
		Syncing the existing schema to the ORM definition
	Summary
Part II
Chapter 5: The Twelve-Factor App Methodology
	Intro to the Twelve-Factor App
	Continuous Integration
	Scalability
	Configuration
	The Twelve Factors
		Build once, run multiple times
		Dependencies and configurations
		Scalability
		Monitoring and admin
	Containerized Twelve-Factor Apps
	Summary
Chapter 6: Web Server Structures
	Request-response
	Web architecture
	Web servers
		Serving static content externally
		Reverse proxy
		Logging
		Advanced usages
	uWSGI
		The WSGI application
		Interacting with the web server
		Processes
		Process lifecycle
	Python worker
		Django MVT architecture
		Routing a request towards a View
		The View
			HttpRequest
			HttpResponse
		Middleware
		Django REST framework
			Models
			URL routing
			Views
			Serializer
	External layers
	Summary
Chapter 7: Event-Driven Structures
	Sending events
	Asynchronous tasks
	Subdividing tasks
	Scheduled tasks
	Queue effects
		Single code for all workers
		Cloud queues and workers
	Celery
		Configuring Celery
		Celery worker
		Triggering tasks
		Connecting the dots
		Scheduled tasks
		Celery Flower
		Flower HTTP API
	Summary
Chapter 8: Advanced Event-Driven Structures
	Streaming events
	Pipelines
		Preparation
		Base task
		Image task
		Video task
		Connecting the tasks
		Running the task
	Defining a bus
	More complex systems
	Testing event-driven systems
	Summary
Chapter 9: Microservices vs Monolith
	Monolithic architecture
	The microservices architecture
	Which architecture to choose
		A side note about similar designs
	The key factor – team communication
	Moving from a monolith to microservices
		Challenges for the migration
		A move in four acts
			1. Analyze
			2. Design
			3. Plan
			4. Execute
	Containerizing services
		Building and running an image
		Building and running a web service
			uWSGI configuration
			nginx configuration
			Start script
			Building and running
			Caveats
	Orchestration and Kubernetes
	Summary
Part III
Chapter 10: Testing and TDD
	Testing the code
	Different levels of testing
		Unit tests
		Integration tests
		System tests
	Testing philosophy
		How to design a great test
		Structuring tests
	Test-Driven Development
		Introducing TDD into new teams
		Problems and limitations
		Example of the TDD process
	Introduction to unit testing in Python
		Python unittest
		Pytest
	Testing external dependencies
		Mocking
		Dependency injection
		Dependency injection in OOP
	Advanced pytest
		Grouping tests
		Using fixtures
	Summary
Chapter 11: Package Management
	The creation of a new package
	Trivial packaging in Python
	The Python packaging ecosystem
		PyPI
		Virtual environments
		Preparing an environment
			A note on containers
		Python packages
	Creating a package
		Development mode
		Pure Python package
	Cython
	Python package with binary code
	Uploading your package to PyPI
	Creating your own private index
	Summary
Part IV
Chapter 12: Logging
	Log basics
	Producing logs in Python
	Detecting problems through logs
		Detecting expected errors
		Capturing unexpected errors
	Log strategies
	Adding logs while developing
	Log limitations
	Summary
Chapter 13: Metrics
	Metrics versus logs
		Kinds of metrics
	Generating metrics with Prometheus
		Preparing the environment
		Configuring Django Prometheus
		Checking the metrics
		Starting a Prometheus server
	Querying Prometheus
	Proactively working with metrics
	Alerting
	Summary
Chapter 14: Profiling
	Profiling basics
	Types of profilers
	Profiling code for time
		Using the built-in cProfile module
		Line profiler
	Partial profiling
		Example web server returning prime numbers
		Profiling the whole process
		Generating a profile file per request
	Memory profiling
		Using memory_profiler
		Memory optimization
	Summary
Chapter 15: Debugging
	Detecting and processing defects
	Investigation in production
	Understanding the problem in production
		Logging a request ID
		Analyzing data
		Increasing logging
	Local debugging
	Python introspection tools
	Debugging with logs
	Debugging with breakpoints
	Summary
Chapter 16: Ongoing Architecture
	Adjusting the architecture
	Scheduled downtime
		Maintenance window
	Incidents
		Postmortem analysis
		Premortem analysis
	Load testing
	Versioning
	Backward compatibility
		Incremental changes
		Deploying without interruption
	Feature flags
	Teamwork aspects of changes
	Summary
PacktPage
Other Books You May Enjoy
Index