🚀 Deployment & DevOps

Goal: Configure your Flask app to use environment variables with python-dotenv.

• Install python-dotenv: pip install python-dotenv
• Create a .env file with these variables:

  SECRET_KEY=your-super-secret-key-here
  DATABASE_URL=sqlite:///app.db
  DEBUG=True
  API_KEY=demo-api-key-12345

• Create a config.py that loads these variables using os.getenv()
• Add .env to .gitignore to prevent committing secrets
• Create a .env.example file with placeholder values for documentation
• Test that your app fails gracefully when required variables are missing

Create a professional configuration system with multiple environments:

• Create a config.py with base Config class
• Add DevelopmentConfig, TestingConfig, and ProductionConfig subclasses
• Use FLASK_ENV environment variable to select the config
• Implement validation that raises errors for missing required settings
• Add type hints and docstrings to your configuration classes

Goal: Master Python dependency management for production deployments.

• Create a fresh virtual environment and install: flask, gunicorn, python-dotenv
• Generate requirements.txt with pinned versions using pip freeze
• Create requirements-dev.txt with additional dev dependencies:

  -r requirements.txt
  pytest==7.4.0
  pytest-cov==4.1.0
  black==23.7.0
  flake8==6.1.0

• Test installing from both files in a clean environment
• Document the purpose of each dependency in comments

Explore advanced dependency management with modern tools:

• Install and configure pip-tools for dependency compilation
• Create a requirements.in file with unpinned top-level dependencies
• Use pip-compile to generate locked requirements.txt
• Research and compare: pip-tools vs Poetry vs Pipenv
• Write a brief summary of when to use each tool

Goal: Containerize a Flask application with Docker and docker-compose.

• Create a simple Flask app with a /health endpoint that returns JSON
• Write a Dockerfile using the template above
• Add a .dockerignore file to exclude: venv/, .env, __pycache__/, .git/
• Build the image: docker build -t my-flask-app .
• Run the container: docker run -p 8000:8000 my-flask-app
• Verify by visiting http://localhost:8000/health

docker-compose.yml:

version: '3.8'
services:
  web:
    build: .
    ports:
      - "8000:8000"
    environment:
      - FLASK_ENV=production
      - SECRET_KEY=${SECRET_KEY}
    volumes:
      - ./logs:/app/logs
  redis:
    image: redis:alpine
    ports:
      - "6379:6379"

Optimize your Docker image with multi-stage builds:

• Create a multi-stage Dockerfile with a build stage and production stage
• Use python:3.9 for building and python:3.9-slim for production
• Compare image sizes between single-stage and multi-stage builds
• Add health checks to your docker-compose.yml
• Configure proper logging with Docker log drivers
• Set up a volume for persistent data (database files)

Goal: Implement structured logging for production debugging.

• Configure Python's logging module with different levels (DEBUG, INFO, WARNING, ERROR)
• Create a logging configuration that:
  • Logs to console in development
  • Logs to files with rotation in production
  • Includes timestamps, log levels, and source location
• Add request logging middleware to your Flask app
• Log important events: startup, shutdown, errors, slow requests
• Never log sensitive data (passwords, API keys, personal info)

Example logging config:

import logging
from logging.handlers import RotatingFileHandler

def setup_logging(app):
    handler = RotatingFileHandler(
        'logs/app.log', maxBytes=10000000, backupCount=5
    )
    handler.setFormatter(logging.Formatter(
        '[%(asctime)s] %(levelname)s in %(module)s: %(message)s'
    ))
    app.logger.addHandler(handler)
    app.logger.setLevel(logging.INFO)

Set up automated testing and deployment with GitHub Actions:

• Create .github/workflows/ci.yml for your repository
• Configure the workflow to:
  • Trigger on push to main and pull requests
  • Set up Python environment
  • Install dependencies from requirements.txt
  • Run linting with flake8 or black --check
  • Run tests with pytest and generate coverage report
• Add a badge to your README showing CI status
• Configure branch protection to require passing CI

Starter workflow:

name: Python CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.9'
    - name: Install dependencies
      run: |
        pip install -r requirements.txt
        pip install -r requirements-dev.txt
    - name: Lint with flake8
      run: flake8 . --count --show-source --statistics
    - name: Test with pytest
      run: pytest --cov=app tests/