book

Python Architecture Patterns

by Jaime Buelta

January 2022

Intermediate to advanced

594 pages

13h 37m

English

Packt Publishing

Read now

Unlock full access

Who this book is forWhat this book coversTo get the most out of this bookGet in touchShare your thoughts
Defining the structure of a systemDivision into smaller unitsIn-process communicationConway's Law – Effects on software architectureApplication example – Overview Security aspects of software architectureSummary
Design
AbstractionsUsing the right abstractionsLeaking abstractionsResources and action abstractionsRESTful interfacesA more practical definitionHeaders and statusesDesigning resourcesResources and parametersPaginationDesigning a RESTful API processUsing the Open API specificationAuthenticationAuthenticating HTML interfacesAuthenticating RESTful interfacesSelf-encoded tokensVersioning the APIWhy versioning?Internal versus external versioningSemantic versioningSimple versioningFrontend and backendModel View Controller structureHTML interfacesTraditional HTML interfacesDynamic pagesSingle-page appsHybrid approachDesigning the API for the exampleEndpointsReview of the design and implementationSummary
Types of databasesRelational databasesNon-relational databasesKey-value storesDocument storesWide-column databasesGraph databasesSmall databasesDatabase transactionsDistributed relational databasesPrimary/replicaShardingPure shardingMixed shardingTable shardingAdvantages and disadvantages of shardingSchema designSchema normalization DenormalizationData indexingCardinalitySummary
The Model layerDomain-Driven DesignUsing ORMIndependence from the databaseIndependence from SQL and the Repository patternNo problems related to composing SQLThe Unit of Work pattern and encapsulating the dataCQRS, using different models for read and writeDatabase migrationsBackward compatibilityRelational schema changesChanging the database without interruptionData migrationsChanges without enforcing a schemaDealing with legacy databasesDetecting a schema from a databaseSyncing the existing schema to the ORM definitionSummary
Architectural Patterns
Intro to the Twelve-Factor AppContinuous IntegrationScalabilityConfigurationThe Twelve FactorsBuild once, run multiple timesDependencies and configurationsScalabilityMonitoring and adminContainerized Twelve-Factor AppsSummary
Request-responseWeb architectureWeb serversServing static content externallyReverse proxyLoggingAdvanced usagesuWSGIThe WSGI applicationInteracting with the web serverProcessesProcess lifecyclePython workerDjango MVT architectureRouting a request towards a ViewThe ViewHttpRequestHttpResponseMiddlewareDjango REST frameworkModelsURL routingViewsSerializerExternal layersSummary
Sending eventsAsynchronous tasksSubdividing tasksScheduled tasksQueue effectsSingle code for all workersCloud queues and workersCeleryConfiguring CeleryCelery workerTriggering tasksConnecting the dotsScheduled tasksCelery FlowerFlower HTTP APISummary

Streaming eventsPipelinesPreparationBase taskImage taskVideo taskConnecting the tasksRunning the taskDefining a busMore complex systemsTesting event-driven systemsSummary
Monolithic architectureThe microservices architectureWhich architecture to chooseA side note about similar designsThe key factor – team communicationMoving from a monolith to microservicesChallenges for the migrationA move in four acts1. Analyze2. Design3. Plan4. ExecuteContainerizing servicesBuilding and running an imageBuilding and running a web serviceuWSGI configurationnginx configurationStart scriptBuilding and runningCaveatsOrchestration and KubernetesSummary
Implementation
Testing the codeDifferent levels of testingUnit testsIntegration testsSystem testsTesting philosophyHow to design a great testStructuring testsTest-Driven DevelopmentIntroducing TDD into new teamsProblems and limitationsExample of the TDD processIntroduction to unit testing in PythonPython unittestPytestTesting external dependenciesMockingDependency injectionDependency injection in OOPAdvanced pytestGrouping testsUsing fixturesSummary
The creation of a new packageTrivial packaging in PythonThe Python packaging ecosystemPyPIVirtual environmentsPreparing an environmentA note on containersPython packagesCreating a packageDevelopment modePure Python packageCythonPython package with binary codeUploading your package to PyPICreating your own private indexSummary
Ongoing operations
Log basicsProducing logs in PythonDetecting problems through logsDetecting expected errorsCapturing unexpected errorsLog strategiesAdding logs while developingLog limitationsSummary
Metrics versus logsKinds of metricsGenerating metrics with PrometheusPreparing the environmentConfiguring Django PrometheusChecking the metricsStarting a Prometheus serverQuerying PrometheusProactively working with metricsAlertingSummary
Profiling basicsTypes of profilersProfiling code for timeUsing the built-in cProfile moduleLine profilerPartial profiling Example web server returning prime numbersProfiling the whole processGenerating a profile file per requestMemory profilingUsing memory_profilerMemory optimizationSummary
Detecting and processing defectsInvestigation in productionUnderstanding the problem in productionLogging a request IDAnalyzing dataIncreasing loggingLocal debuggingPython introspection tools Debugging with logsDebugging with breakpointsSummary
Adjusting the architectureScheduled downtimeMaintenance windowIncidentsPostmortem analysisPremortem analysisLoad testingVersioningBackward compatibilityIncremental changesDeploying without interruptionFeature flagsTeamwork aspects of changesSummary

Overview

Python Architecture Patterns provides comprehensive coverage of architectural patterns for developers using Python, helping you implement scalable and maintainable systems. You will learn how to build APIs, event-driven systems, and perform effective testing and debugging, ensuring your software meets both current and future demands.

What this Book will help me do

Learn to design scalable and secure APIs effectively using Python.
Understand and implement various software architecture patterns such as microservices and event-driven systems.
Apply test-driven development (TDD) principles to ensure robust and reliable code.
Master the use of profiling tools to optimize application performance.
Develop skills to structure your Python packages for maintainability and clarity.

Author(s)

Jaime Buelta is a seasoned software engineer and author with years of experience in Python development and software architecture. They have extensive expertise in designing large-scale, maintainable software systems, and their writing is known for its clarity and practical guidance. Jaime's passion is helping developers advance their skills to solve real-world challenges effectively.

Who is it for?

This book is perfect for software developers and architects seeking to enhance their ability to design scalable, maintainable systems using Python. It assumes familiarity with the Python programming language and a basic understanding of software development principles. If you're aiming to harness your coding knowledge to develop strategic architectural skills, this book is for you.