DevOps in Django E-Commerce System with DRF and Docker

⚙️ Introduction

When your Django + DRF backend powers a mobile e-commerce app, every release matters.
A single downtime can stop users from logging in, checking out, or receiving push notifications.

To keep development fast and reliable, you need DevOps — an approach combining development and operations to automate everything from testing to deployment.

This guide shows how to apply DevOps to a Python Django + DRF + PostgreSQL + Docker e-commerce backend that serves mobile users.

🧱 System Overview

Architecture Components:

Backend: Django + Django REST Framework (API for mobile app)
Database: PostgreSQL
Containerization: Docker + Docker Compose
Deployment: GitHub Actions → AWS EC2 / DigitalOcean droplet
Monitoring: Prometheus + Grafana

Goal:

Deliver continuous integration, testing, and deployment for a stable, API-driven e-commerce backend.

🔄 DevOps Workflow Overview

flowchart TD
  A["Developer Commit (GitHub)"] --> B["CI Pipeline (GitHub Actions)"]
  B --> C["Build Docker Image"]
  C --> D["Run Unit & API Tests (pytest + DRF client)"]
  D --> E["Push to Registry (Docker Hub / ECR)"]
  E --> F["Deploy via Docker Compose / K8s"]
  F --> G["Monitor with Prometheus + Grafana"]

🧩 1. Continuous Integration (CI)

Each commit triggers automatic build and test processes to ensure API stability.

Example: .github/workflows/ci.yml

name: Django CI
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:14
        env:
          POSTGRES_DB: ecommerce
          POSTGRES_USER: django
          POSTGRES_PASSWORD: password
        ports: ['5432:5432']
    env:
      DATABASE_URL: postgres://django:password@localhost:5432/ecommerce
    steps:
      - uses: actions/checkout@v3
      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'
      - name: Install dependencies
        run: |
          pip install -r requirements.txt
      - name: Run Tests
        run: pytest -v

✅ Result: Only tested code gets merged, reducing runtime errors for mobile users.

🚀 2. Continuous Delivery (CD)

When CI passes, the code is automatically packaged and deployed via Docker.

Dockerfile

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "core.wsgi:application", "--bind", "0.0.0.0:8000"]

docker-compose.yml

version: '3'
services:
  web:
    build: .
    container_name: ecommerce_api
    command: gunicorn core.wsgi:application --bind 0.0.0.0:8000
    ports:
      - "8000:8000"
    depends_on:
      - db
  db:
    image: postgres:14
    environment:
      POSTGRES_DB: ecommerce
      POSTGRES_USER: django
      POSTGRES_PASSWORD: password

🟢 Goal: CI → Docker build → Push to registry → Auto deploy to production (e.g., via GitHub Actions + SSH to EC2).

🧪 3. Automated Testing

Use pytest and DRF’s API client for unit and endpoint testing.

from rest_framework.test import APIClient

def test_product_list(api_client):
    client = APIClient()
    response = client.get("/api/products/")
    assert response.status_code == 200
    assert isinstance(response.json(), list)

🧠 Tip: Run all API tests before deployment to prevent broken endpoints in your mobile app.

🧰 4. Infrastructure as Code (IaC)

Use Terraform or Ansible to provision servers, networks, and databases automatically.

Terraform Example:

resource "aws_instance" "backend" {
  ami           = "ami-0f3e2d1e1d33b3b57"
  instance_type = "t3.medium"
  tags = { Name = "django-ecommerce" }
}

Reproducible infrastructure ensures new environments (e.g., staging, production) can be deployed identically.

📊 5. Monitoring & Logging

Integrate Prometheus + Grafana for performance metrics and alerts.
You can monitor:

API latency
Response time
Database connections
CPU/memory usage

Example alert:

“API latency above 2s for /checkout — possible DB bottleneck.”

Logs can be shipped to ELK Stack (Elasticsearch + Logstash + Kibana) for deeper analysis.

🧠 6. Security & Environment Management

Store secrets in GitHub Secrets or AWS SSM Parameter Store.
Use .env files in Docker (not committed to Git).
Rotate keys and restrict SSH access.
Run container security scans with Trivy.

Example .env:

DEBUG=False
DATABASE_URL=postgres://django:password@db:5432/ecommerce
SECRET_KEY=change_this_in_production

📱 7. Serving the Mobile App

Your DRF API serves as the mobile app backend.
Each build deploys:

Updated endpoints for products, cart, checkout
JWT or OAuth2 authentication
Versioned APIs (e.g., /api/v1/, /api/v2/)

CI/CD ensures:

New app versions can be released without breaking the existing mobile client.

🌐 System Architecture

graph TD
  APP["Mobile App"] --> API["Django REST Framework API"]
  API --> DB["PostgreSQL"]
  API --> CACHE["Redis / Celery Worker"]
  API --> MON["Prometheus + Grafana"]
  DEV["CI/CD Pipeline (GitHub Actions)"] --> API
  API --> DOCKER["Docker Container on EC2"]

🧭 Benefits of DevOps for Django + DRF Project

Benefit	Description
🚀 Faster Delivery	Automatic deployment reduces release time
✅ Higher Quality	Continuous testing prevents API errors
🔒 Secure	Controlled secrets and containers
📈 Scalable	Infrastructure as Code makes scaling easy
🔍 Transparent	Monitoring keeps team informed in real time