Bài 31: Docker Basics for Django

Docker Concepts

Docker giúp package application với dependencies vào containers.

What is Docker?

Traditional Deployment:- Install Python on server- Install dependencies- Configure environment- Conflicts between projects- "Works on my machine" problem Docker Deployment:- Package app + dependencies in container- Run anywhere Docker is installed- Isolated from other containers- Consistent across environments

Key Concepts

Image (Hình ảnh):- Blueprint for containers- Contains OS, Python, dependencies, code- Built from Dockerfile- Immutable (read-only) Container (Container):- Running instance of image- Isolated process- Has own filesystem, network- Can start/stop/restart Volume (Volume):- Persistent storage- Share data between host and container- Persist data after container stops Example:Image = Class definitionContainer = Object instance

Installing Docker

# macOS: Download Docker Desktop# https://www.docker.com/products/docker-desktop # Linux: Install Docker Enginecurl -fsSL https://get.docker.com -o get-docker.shsudo sh get-docker.sh # Verify installationdocker --versiondocker run hello-world # Check Docker infodocker infodocker version

Dockerfile for Django

Basic Dockerfile

# DockerfileFROM python:3.11-slim # Set environment variablesENV PYTHONDONTWRITEBYTECODE=1ENV PYTHONUNBUFFERED=1 # Set work directoryWORKDIR /app # Install dependenciesCOPY requirements.txt /app/RUN pip install --upgrade pipRUN pip install -r requirements.txt # Copy projectCOPY . /app/ # Expose portEXPOSE 8000 # Run DjangoCMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Explained Line by Line

# Base image: Python 3.11 slim versionFROM python:3.11-slim# Alternative: python:3.11-alpine (smaller but may have issues) # Don't create .pyc filesENV PYTHONDONTWRITEBYTECODE=1# Output directly to terminal (no buffering)ENV PYTHONUNBUFFERED=1 # Create and set working directoryWORKDIR /app # Copy requirements first (Docker layer caching)COPY requirements.txt /app/# If requirements don't change, this layer is cached # Install Python packagesRUN pip install --upgrade pipRUN pip install -r requirements.txt # Copy all project filesCOPY . /app/ # Port Django will run onEXPOSE 8000 # Command to run when container startsCMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Production Dockerfile

# Dockerfile.prodFROM python:3.11-slim # Install system dependenciesRUN apt-get update && apt-get install -y \    postgresql-client \    && rm -rf /var/lib/apt/lists/* ENV PYTHONDONTWRITEBYTECODE=1ENV PYTHONUNBUFFERED=1 WORKDIR /app # Install Python dependenciesCOPY requirements.txt /app/RUN pip install --upgrade pipRUN pip install -r requirements.txt # Copy projectCOPY . /app/ # Collect static filesRUN python manage.py collectstatic --noinput # Create non-root userRUN adduser --disabled-password --gecos '' appuserRUN chown -R appuser:appuser /appUSER appuser EXPOSE 8000 # Use Gunicorn for productionCMD ["gunicorn", "--bind", "0.0.0.0:8000", "myproject.wsgi:application"]

.dockerignore File

Exclude files from Docker build context.

# .dockerignore*.pyc__pycache__/*.pyo*.pyd.Pythonenv/venv/ENV/.venvdb.sqlite3.env.git.gitignore.vscode/.idea/*.logstaticfiles/media/*.md!README.md.DS_StoreThumbs.db

Building Docker Images

Build Command

# Build imagedocker build -t myproject:latest . # -t: tag name# .: build context (current directory) # Build with specific Dockerfiledocker build -f Dockerfile.prod -t myproject:prod . # Build with build argumentsdocker build --build-arg PYTHON_VERSION=3.11 -t myproject:latest . # Build without cache (fresh build)docker build --no-cache -t myproject:latest .

Django Project Structure

myproject/├── myproject/│   ├── __init__.py│   ├── settings.py│   ├── urls.py│   └── wsgi.py├── blog/│   ├── models.py│   ├── views.py│   └── ...├── templates/├── static/├── manage.py├── requirements.txt├── Dockerfile├── .dockerignore└── .env.example

Running Containers

Basic Run Commands

# Run containerdocker run -p 8000:8000 myproject:latest # -p: port mapping (host:container)# Access at http://localhost:8000 # Run in background (detached mode)docker run -d -p 8000:8000 myproject:latest # Run with namedocker run -d --name django-app -p 8000:8000 myproject:latest # Run with environment variablesdocker run -d -p 8000:8000 \  -e DEBUG=False \  -e SECRET_KEY=your-secret-key \  myproject:latest # Run with .env filedocker run -d -p 8000:8000 --env-file .env myproject:latest

Volume Mounting

# Mount code for development (live reload)docker run -d -p 8000:8000 \  -v $(pwd):/app \  myproject:latest # Mount specific directoriesdocker run -d -p 8000:8000 \  -v $(pwd)/blog:/app/blog \  -v $(pwd)/templates:/app/templates \  myproject:latest # Create named volume for databasedocker run -d -p 8000:8000 \  -v django-db:/app/db.sqlite3 \  myproject:latest # Mount static filesdocker run -d -p 8000:8000 \  -v $(pwd)/staticfiles:/app/staticfiles \  myproject:latest

Interactive Container

# Run shell in containerdocker run -it --rm myproject:latest /bin/bash # -it: interactive terminal# --rm: remove container after exit # Run Django shelldocker run -it --rm myproject:latest python manage.py shell # Run migrationsdocker run -it --rm \  -v $(pwd):/app \  myproject:latest \  python manage.py migrate # Create superuserdocker run -it \  -v $(pwd):/app \  myproject:latest \  python manage.py createsuperuser

Essential Docker Commands

Container Management

# List running containersdocker ps # List all containers (including stopped)docker ps -a # Stop containerdocker stop container_iddocker stop django-app # Start stopped containerdocker start container_id # Restart containerdocker restart container_id # Remove containerdocker rm container_iddocker rm -f container_id  # Force remove running container # Remove all stopped containersdocker container prune

Image Management

# List imagesdocker images # Remove imagedocker rmi image_iddocker rmi myproject:latest # Remove unused imagesdocker image prune # Remove all imagesdocker image prune -a # Tag imagedocker tag myproject:latest myproject:v1.0 # Save image to filedocker save -o myproject.tar myproject:latest # Load image from filedocker load -i myproject.tar

Logs and Debugging

# View logsdocker logs container_id # Follow logs (live)docker logs -f container_id # Last 100 linesdocker logs --tail 100 container_id # Execute command in running containerdocker exec container_id python manage.py migrate # Interactive shell in running containerdocker exec -it container_id /bin/bash # Copy files to/from containerdocker cp container_id:/app/db.sqlite3 ./backup.dbdocker cp ./local_file.txt container_id:/app/

System Commands

# Show disk usagedocker system df # Clean up everythingdocker system prune # Remove everything (including volumes)docker system prune -a --volumes # View container statsdocker stats # View container processesdocker top container_id # Inspect container detailsdocker inspect container_id

Complete Django Docker Example

Project Setup

# Project structuremyproject/├── myproject/├── blog/├── manage.py├── requirements.txt├── Dockerfile├── .dockerignore├── .env.example└── README.md

Dockerfile

# DockerfileFROM python:3.11-slim ENV PYTHONDONTWRITEBYTECODE=1ENV PYTHONUNBUFFERED=1 WORKDIR /app COPY requirements.txt /app/RUN pip install --upgrade pip && pip install -r requirements.txt COPY . /app/ EXPOSE 8000 CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

.dockerignore

*.pyc__pycache__/*.pyodb.sqlite3.env.gitvenv/staticfiles/media/

Build and Run

# 1. Build imagedocker build -t myblog:latest . # 2. Run containerdocker run -d \  --name myblog-app \  -p 8000:8000 \  -v $(pwd):/app \  -e DEBUG=True \  myblog:latest # 3. Run migrationsdocker exec myblog-app python manage.py migrate # 4. Create superuserdocker exec -it myblog-app python manage.py createsuperuser # 5. Collect static filesdocker exec myblog-app python manage.py collectstatic --noinput # 6. View logsdocker logs -f myblog-app # 7. Access at http://localhost:8000

Development Workflow

Hot Reload Setup

# Dockerfile.devFROM python:3.11-slim ENV PYTHONDONTWRITEBYTECODE=1ENV PYTHONUNBUFFERED=1 WORKDIR /app COPY requirements.txt /app/RUN pip install --upgrade pip && pip install -r requirements.txt # Don't copy code - will be mounted as volume EXPOSE 8000 CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

# Run with volume mount for live reloaddocker run -d \  --name django-dev \  -p 8000:8000 \  -v $(pwd):/app \  -e DEBUG=True \  myproject:dev # Code changes are reflected immediately# Edit files on host, see changes in container

Multi-Stage Builds

Smaller production images.

# Multi-stage Dockerfile# Stage 1: BuilderFROM python:3.11-slim AS builder WORKDIR /app COPY requirements.txt .RUN pip install --user --no-cache-dir -r requirements.txt # Stage 2: RuntimeFROM python:3.11-slim ENV PYTHONDONTWRITEBYTECODE=1ENV PYTHONUNBUFFERED=1 WORKDIR /app # Copy Python packages from builderCOPY --from=builder /root/.local /root/.localENV PATH=/root/.local/bin:$PATH # Copy applicationCOPY . /app/ RUN python manage.py collectstatic --noinput EXPOSE 8000 CMD ["gunicorn", "--bind", "0.0.0.0:8000", "myproject.wsgi:application"]

# Build multi-stage imagedocker build -t myproject:prod . # Check image size (smaller than single-stage)docker images myproject:prod

Bài Tập

Bài 1: Basic Dockerization

Task: Dockerize existing Django project:

# Requirements:# 1. Create Dockerfile for Django project# 2. Create .dockerignore file# 3. Build Docker image# 4. Run container on port 8000# 5. Access Django app in browser# 6. View container logs# 7. Execute migrations in container# 8. Create superuser in container# 9. Stop and remove container# 10. Test rebuild with code changes

Bài 2: Development Setup

Task: Docker development environment:

# Requirements:# 1. Create Dockerfile.dev# 2. Setup volume mounting for code# 3. Enable hot reload (auto-restart)# 4. Mount static files directory# 5. Mount templates directory# 6. Run migrations in container# 7. Test code changes reflect immediately# 8. Access Django shell in container# 9. View and follow logs# 10. Debug in container

Bài 3: Production-Ready Image

Task: Production Dockerfile:

# Requirements:# 1. Use Python slim image# 2. Install system dependencies# 3. Create non-root user# 4. Copy and install requirements# 5. Copy application code# 6. Collect static files# 7. Use Gunicorn instead of runserver# 8. Optimize image size# 9. Add health check# 10. Test production image

Bài 4: Complete Docker Workflow

Task: Full Docker development workflow:

# Requirements:# 1. Dockerfile for development# 2. Dockerfile for production# 3. .dockerignore file# 4. Multi-stage build# 5. Volume mounting for development# 6. Environment variables# 7. Build scripts# 8. Run scripts# 9. Migration script# 10. Backup script# 11. Documentation# 12. Test both dev and prod images# 13. Optimize image size (<200MB)# 14. Security scan (docker scan)# 15. Deploy to local testing

Tài Liệu Tham Khảo

Previous: Bài 30: Deployment Preparation | Next: Bài 32: Docker Compose for Django

#dockerfile

Docker Basics for Django