Why Every Python Developer Should Learn Kubernetes in 2026

FROM python:3.12-slim
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
RUN useradd --create-home appuser
USER appuser
EXPOSE 8000
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

# app/settings.py
import os

DATABASE_URL = os.environ["DATABASE_URL"]          # required
LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO")    # optional
FEATURE_NEW_SEARCH = os.environ.get("FEATURE_NEW_SEARCH", "false") == "true"

from fastapi import FastAPI, Response
import sqlalchemy as sa
from app.settings import DATABASE_URL

app = FastAPI()
engine = sa.create_engine(DATABASE_URL, pool_pre_ping=True)

@app.get("/healthz")
def healthz():
    return {"status": "ok"}

@app.get("/ready")
def ready(response: Response):
    try:
        with engine.connect() as conn:
            conn.execute(sa.text("SELECT 1"))
        return {"ready": True}
    except Exception:
        response.status_code = 503
        return {"ready": False}

containers:
  - name: api
    image: registry.example.com/py-api:1.2.0
    ports: [{ containerPort: 8000 }]
    envFrom:
      - configMapRef: { name: py-api-config }
      - secretRef: { name: py-api-secrets }
    readinessProbe:
      httpGet: { path: /ready, port: 8000 }
      periodSeconds: 10
    livenessProbe:
      httpGet: { path: /healthz, port: 8000 }
      initialDelaySeconds: 10
      periodSeconds: 20

apiVersion: batch/v1
kind: CronJob
metadata:
  name: nightly-report
spec:
  schedule: "30 1 * * *"
  concurrencyPolicy: Forbid
  jobTemplate:
    spec:
      template:
        spec:
          restartPolicy: OnFailure
          containers:
            - name: report
              image: registry.example.com/py-api:1.2.0
              command: ["python", "-m", "app.jobs.nightly_report"]

kubectl logs deploy/py-api --since=15m
kubectl logs -l app=py-worker --tail=100
kubectl describe pod <pod-name>
kubectl exec -it <pod-name> -- python -c "import app; print(app.__version__)"
kubectl port-forward deploy/py-api 8000:8000   # test locally

apiVersion: apps/v1
kind: Deployment
metadata:
  name: py-worker
spec:
  replicas: 2
  selector:
    matchLabels: { app: py-worker }
  template:
    metadata:
      labels: { app: py-worker }
    spec:
      containers:
        - name: worker
          image: registry.example.com/py-api:1.2.0
          command: ["celery", "-A", "app.tasks", "worker", "--loglevel=info"]
          envFrom:
            - secretRef: { name: py-api-secrets }

apiVersion: batch/v1
kind: Job
metadata:
  name: migrate-1-2-0
spec:
  backoffLimit: 1
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: migrate
          image: registry.example.com/django-app:1.2.0
          command: ["python", "manage.py", "migrate", "--noinput"]

import signal, sys, time

running = True

def handle_sigterm(signum, frame):
    global running
    running = False          # stop taking new work

signal.signal(signal.SIGTERM, handle_sigterm)

while running:
    # process one item from the queue
    time.sleep(1)
print("finished current work, exiting cleanly")
sys.exit(0)