Deploy Python to Production: Environments, Artifacts, Processes, Health Checks, and Rollback

Python Release

A production release combines source, Python version, dependencies, native libraries, configuration, secrets, writable storage, database schema, process supervision, logs, and monitoring. Reproducing only the source checkout is not enough.

After this lesson, you can define a build artifact, inject environment-specific configuration, run the application under a supervisor, separate liveness from readiness, coordinate schema changes, and decide rollback from measured signals.

Runtime Contract

Declare the supported interpreter range in pyproject.toml and build with the exact production series. Native wheels and optional free-threaded builds need separate compatibility checks. Record python --version and the release identifier with deployment evidence.

Inspect Installed Dependencies

python --version
python -m pip check
python -m pip list --format=freeze

pip check detects incompatible installed requirements; a lock or resolved artifact remains necessary for reproducible installation.

Immutable Artifact

Build a wheel or container from a reviewed commit, install locked dependencies in a clean environment, run tests against that artifact, and promote the same artifact between environments. Avoid editing source or installing surprise packages on a live server.

External Configuration

Read environment-specific values at startup, validate them into a typed configuration object, and fail before accepting work when a required value is missing. Never print secrets in a complete environment dump.

Validate Startup Settings

from dataclasses import dataclass
import os

@dataclass(frozen=True)
class Settings:
    database_url: str
    environment: str

def load_settings() -> Settings:
    database_url = os.environ.get("DATABASE_URL", "")
    if not database_url:
        raise RuntimeError("DATABASE_URL is required")
    return Settings(database_url, os.environ.get("APP_ENV", "production"))

The program validates configuration once instead of scattering os.environ lookups across business code.

Managed Process

Use an operating-system service manager, container orchestrator, or suitable application server to start, stop, restart, and observe long-running processes. A development server is not a production process model.

Send logs to a managed stream or destination instead of an unbounded local file.
Handle termination so in-flight work has a bounded shutdown window.
Set memory, CPU, request, and worker limits from measured capacity.
Deploy scheduled jobs and workers with compatible application code and schema.

Health Signals

Liveness shows that the process can respond. Readiness shows that the instance is prepared to receive traffic. Keep checks fast and avoid turning a downstream outage into a storm of expensive probes.

Return Release Health Data

import json
import os

health = {
    "status": "ok",
    "release": os.environ.get("APP_RELEASE", "unknown"),
}
print(json.dumps(health, separators=(",", ":")))

Output

{"status":"ok","release":"unknown"}

Schema Compatibility

During a rolling release, old and new processes may run together. Add backward-compatible schema first, deploy code that understands both shapes, migrate data, and remove old fields in a later release. Test restoration, not only backup creation.

Rollback Evidence

Define error-rate, latency, queue, and functional thresholds that stop the rollout.
Keep the previous tested artifact available.
Know which data migrations cannot be reversed automatically.
Smoke-test one critical read, write, authentication, and background-job path after activation.

Approve the Deployment

0 of 2 checked

Q1. Why promote one artifact between environments?

It reduces differences between tested and deployed code It removes configuration It guarantees every database query

Q2. What should readiness communicate?

Whether the instance can receive traffic Whether the process ID exists only Every secret value

Try this next

Write a Python Runbook

0 of 2 completed

Map the release sequence
Document artifact build, dependency verification, migrations, activation, process restart, smoke checks, monitoring, and rollback.
Test a missing secret
Prove startup fails clearly before work begins and that logs do not reveal nearby environment values.

Previous Next