Docker Deployment Guide

This guide explains how to deploy the NSGG Backend using Docker and Docker Compose.

Prerequisites

  • Docker Engine (20.10.x or later)
  • Docker Compose (2.x or later)
  • Access to Docker registry
  • SSL certificates (for production)

Project Structure

nsgg-main-backend/
├── Dockerfile
├── docker-compose.yml
├── docker-compose.prod.yml
└── docker/
    ├── nginx/
    │   ├── Dockerfile
    │   └── nginx.conf
    └── postgres/
        └── init.sql

Development Setup

1. Build and Run

# Build images
docker-compose build

# Start services
docker-compose up -d

# View logs
docker-compose logs -f

2. Development Configuration

# docker-compose.yml
version: '3.8'

services:
  web:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    volumes:
      - .:/app
    ports:
      - "8000:8000"
    env_file:
      - .env
    depends_on:
      - db
      - redis

  db:
    image: postgres:14-alpine
    volumes:
      - postgres_data:/var/lib/postgresql/data/
    environment:
      - POSTGRES_DB=nsgg
      - POSTGRES_USER=nsgg
      - POSTGRES_PASSWORD=nsgg

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

3. Development Workflow

# Create migrations
docker-compose exec web python manage.py makemigrations

# Apply migrations
docker-compose exec web python manage.py migrate

# Create superuser
docker-compose exec web python manage.py createsuperuser

# Run tests
docker-compose exec web python manage.py test

Production Deployment

1. Production Configuration

# docker-compose.prod.yml
version: '3.8'

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile
    command: gunicorn config.wsgi:application --bind 0.0.0.0:8000
    volumes:
      - static_volume:/app/staticfiles
      - media_volume:/app/mediafiles
    expose:
      - 8000
    env_file:
      - .env.prod
    depends_on:
      - db
      - redis

  db:
    image: postgres:14-alpine
    volumes:
      - postgres_data:/var/lib/postgresql/data/
    env_file:
      - .env.prod.db

  nginx:
    build: ./docker/nginx
    volumes:
      - static_volume:/app/staticfiles
      - media_volume:/app/mediafiles
      - ./docker/nginx/certs:/etc/nginx/certs
    ports:
      - "80:80"
      - "443:443"
    depends_on:
      - web

  redis:
    image: redis:7-alpine
    command: redis-server --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis_data:/data

volumes:
  postgres_data:
  static_volume:
  media_volume:
  redis_data:

2. Nginx Configuration

# docker/nginx/nginx.conf
upstream nsgg_backend {
    server web:8000;
}

server {
    listen 80;
    server_name example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl;
    server_name example.com;

    ssl_certificate /etc/nginx/certs/fullchain.pem;
    ssl_certificate_key /etc/nginx/certs/privkey.pem;

    location / {
        proxy_pass http://nsgg_backend;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $host;
        proxy_redirect off;
    }

    location /static/ {
        alias /app/staticfiles/;
    }

    location /media/ {
        alias /app/mediafiles/;
    }
}

3. Production Environment Variables

# .env.prod
DEBUG=0
SECRET_KEY=your-secret-key
DJANGO_ALLOWED_HOSTS=example.com
SQL_ENGINE=django.db.backends.postgresql
SQL_DATABASE=nsgg_prod
SQL_USER=nsgg_prod_user
SQL_PASSWORD=your-secure-password
SQL_HOST=db
SQL_PORT=5432
REDIS_PASSWORD=your-redis-password

# .env.prod.db
POSTGRES_USER=nsgg_prod_user
POSTGRES_PASSWORD=your-secure-password
POSTGRES_DB=nsgg_prod

4. Production Deployment Steps

# Build production images
docker-compose -f docker-compose.prod.yml build

# Start production services
docker-compose -f docker-compose.prod.yml up -d

# Apply migrations
docker-compose -f docker-compose.prod.yml exec web python manage.py migrate

# Collect static files
docker-compose -f docker-compose.prod.yml exec web python manage.py collectstatic --no-input

Monitoring and Maintenance

1. Container Health Checks

# Check container status
docker-compose ps

# View container logs
docker-compose logs -f [service_name]

# Monitor container resources
docker stats

2. Backup and Restore

# Backup database
docker-compose exec db pg_dump -U nsgg_prod_user nsgg_prod > backup.sql

# Restore database
cat backup.sql | docker exec -i nsgg-main-backend_db_1 psql -U nsgg_prod_user -d nsgg_prod

3. Scaling Services

# Scale web workers
docker-compose -f docker-compose.prod.yml up -d --scale web=3

# Update nginx configuration for load balancing
upstream nsgg_backend {
    server web:8000;
    server web:8001;
    server web:8002;
}

Security Considerations

  1. Environment Variables
  2. Never commit .env files
  3. Use secure passwords

  4. Rotate secrets regularly

  5. Network Security

  6. Use internal Docker network
  7. Expose only necessary ports

  8. Enable SSL/TLS

  9. Container Security

  10. Use official base images
  11. Keep images updated
  12. Run containers as non-root

Troubleshooting

Common Issues

  1. Database Connection Issues 

    # Check database logs
docker-compose logs db

# Verify database connection
docker-compose exec web python manage.py dbshell

  2. Static Files Not Serving 

    # Verify static files collection
docker-compose exec web python manage.py collectstatic --no-input

# Check nginx configuration
docker-compose exec nginx nginx -t

  3. Container Startup Issues 

    # Check container logs
docker-compose logs web

# Verify environment variables
docker-compose config

Deployment Checklist

  1. Pre-deployment
  2. [ ] Update environment variables
  3. [ ] Test locally with production settings
  4. [ ] Backup database

  5. [ ] Update SSL certificates

  6. Deployment

  7. [ ] Build new images
  8. [ ] Apply database migrations
  9. [ ] Collect static files
  10. [ ] Start services

  11. [ ] Verify health checks

  12. Post-deployment

  13. [ ] Test critical functionality
  14. [ ] Monitor error logs
  15. [ ] Check resource usage
  16. [ ] Update documentation

Performance Optimization

  1. Docker Image Optimization
  2. Use multi-stage builds
  3. Minimize layer size

  4. Use .dockerignore

  5. Resource Allocation

  6. Set container memory limits
  7. Configure worker processes

  8. Optimize database connections

  9. Caching

  10. Configure Redis caching
  11. Use nginx caching
  12. Implement CDN for static files