Gain insights into clean architecture using Python. Delve into layered systems, design efficient applications, and integrate web components, error handling, and databases with test-driven development practices.

tarball.tar.gz

POSTGRES_USER

POSTGRES_PASSWORD

POSTGRES_HOSTNAME

APPLICATION_DB

POSTGRES_PORT

POSTGRES_DB

Python Execution

Flask

Flask + Postgres

Python Test

Clean architecture is a software design methodology that separates the processes of an application into discrete steps instead of presenting them as “spaghetti code.” With the versatility of Python, software engineers can build performant, modular applications quickly using the Flask framework.

This course will help you build better applications using the principles of clean architecture. You’ll start with an introduction to data flow in clean systems and learn about the advantages of layered architectures. Next, you’ll learn system components and the connections between application layers. You’ll then design and build a clean system using Python by layering components in guided coding exercises. Finally, you’ll learn how to add functional components for the web, handle errors, and work with external databases using both Postgres and MongoDB. At each step, you’ll use test-driven development practices to ensure robust functionality.

Clean Architecture in Python

# Build a web application

Now that we’ve successfully containerized the tests, we can devise a production-ready setup of the whole application, running both a web server and a database in Docker containers.

To run a production-ready infrastructure, we need to put a WSGI server in front of the web framework and a web server in front of it. We’ll also need to run a database container that we’ll initialize only once.

The steps toward achieving a production-ready configuration aren’t complicated, and the final setup won’t be too different from what we already did for the tests. We need to follow these steps:

1. Create a JSON configuration with environment variables suitable for production.
2. Create a suitable configuration for Docker Compose, and configure the containers.
3. Add commands to `manage.py` that allow us to control the processes.


## Step 1: Create the JSON configuration file
We’ve created the `config/production.json` file, which is similar to the one we created for the tests.


FLASK_ENV

FLASK_CONFIG

Both `FLASK_ENV` and `FLASK_CONFIG` are set to `production`. It’s important to remember that the first is an internal Flask variable with two possible fixed values (`development` and `production`). In contrast, the second is an arbitrary name that has the final effect of loading a specific configuration object, which is `ProductionConfig` in this case. We’ve also changed `POSTGRES_PORT` back to the default `5432` and `APPLICATION_DB` to `application`, which is an arbitrary name.

Let’s define which containers we want to run in our production environment and how we want to connect them. We need a production-ready database, so we’ll use PostgreSQL, as we already did during the tests. Afterward, we need to wrap Flask with a production HTTP server. For this job, we’ll use `gunicorn`. Last, we need a web server to act as the load balancer.

## Step 2: Configure Docker

### Create Docker configuration for production

The `docker/production.yml` file will contain the Docker Compose configuration according to the convention we defined in `manage.py`. The configuration is given below:


Let’s learn to configure our system for production in clean architecture.

Get Started

A Day in the Life of a Clean System

Components of Clean Architecture

A Simple Coding Example

Add a Web Application

Error Management

Integration with a Real External System Postgres

Integration with a Real External System MongoDB

Run a Production-ready System

Appendix

Build a Web Stack

Build a web application

Step 1: Create the JSON configuration file