Deployment Guide for Django: GCP Cloud Run, AWS ECS, Minikube & DigitalOcean

Introduction

This guide provides detailed instructions for deploying our Django Weather App across various platforms. The app allows users to track weather for cities they add. We'll cover deployment processes, pro tips, and common errors for each platform, as well as include relevant code files for reference.

Prerequisites

Before proceeding with any deployment, ensure you have:

• The app's source code

• Docker installed and configured

• Access to the container registries (Docker Hub, GCR, ECR)

• Necessary CLI tools for each platform

• Required API keys and credentials

Link to our Github Codebase

Application Code Overview

Let's review the key files that are crucial for our deployment process:

Dockerfile

FROM python:3.10-slim

ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1
ENV PYTHONPATH=/app:$PYTHONPATH

WORKDIR /app

COPY requirements.txt /app/
RUN pip install --upgrade pip && pip install -r requirements.txt

COPY . /app/

CMD ["gunicorn", "the_weather.wsgi:application", "--bind", "0.0.0.0:8000"]

This Dockerfile sets up our Python environment, installs dependencies, and configures the command to run our Django application using Gunicorn.

docker-compose.yml

version: '3.8'

services:
  web:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    volumes:
      - .:/app
    ports:
      - "8000:8000"
    environment:
      - DJANGO_SETTINGS_MODULE=the_weather.settings
      - PYTHONPATH=/app
      - SECRET_KEY=ADD_YOUR_SECRET_KEY
      - DEBUG=True
      - ALLOWED_HOSTS = ["*"]
      - OPENWEATHERMAP_API_KEY=ADD_YOUR_API_KEY

This Docker Compose file is useful for local development and testing. It sets up our web service with the necessary environment variables and port mapping.

manage.py

#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys


def main():
    """Run administrative tasks."""
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'the_weather.settings')
    try:
        from django.core.management import execute_from_command_line
    except ImportError as exc:
        raise ImportError(
            "Couldn't import Django. Are you sure it's installed and "
            "available on your PYTHONPATH environment variable? Did you "
            "forget to activate a virtual environment?"
        ) from exc
    execute_from_command_line(sys.argv)


if __name__ == '__main__':
    main()

This is the standard Django manage.py file, which is used for various Django administrative tasks.

Deployment on Digital Ocean

Steps:

1. Create a Digital Ocean account and set up a Droplet.

2. SSH into your Droplet:

    ssh root@your_droplet_ip
   

3. Install Docker on the Droplet:

    curl -fsSL https://get.docker.com -o get-docker.sh
    sh get-docker.sh
   

4. Pull your Docker image:

    docker pull paparomeoecho/weather-app-django:v4
   

5. Run the container:

    docker run -d -p 80:8000 paparomeoecho/weather-app-django:v4
   

Pro Tips:

• Use Docker Compose for easier management of multi-container applications.

• Set up a reverse proxy like Nginx for better security and performance.

• Use Digital Ocean's Managed Databases for production-grade database setup.

Common Errors:

1. Port conflicts: Ensure no other services are using port 80.

   • Troubleshoot: netstat -tuln | grep 80

2. Docker permission issues: Add your user to the docker group.

   • Fix: usermod -aG docker ${USER}

Deployment on Google Cloud Run

Steps:

1. Set up a Google Cloud account and create a new project.

2. Install and initialize the Google Cloud SDK.

3. Authenticate with Google Cloud:

    gcloud auth login
   

4. Set your project ID:

    gcloud config set project YOUR_PROJECT_ID
   

5. Build and push your Docker image to Google Container Registry:

    docker build -t gcr.io/YOUR_PROJECT_ID/weather-app:v1 .
    docker push gcr.io/YOUR_PROJECT_ID/weather-app:v1
   

6. Deploy to Cloud Run:

    gcloud run deploy weather-app --image gcr.io/YOUR_PROJECT_ID/weather-app:v1 --platform managed
   

Pro Tips:

• Use Cloud Build for automated builds and deployments.

• Set up Cloud Monitoring for real-time performance insights.

• Utilize Cloud Run's autoscaling capabilities for cost-effective scaling.

Common Errors:

1. Authentication issues: Ensure you're authenticated with the correct Google account.

   • Troubleshoot: gcloud auth list

2. Resource quota exceeded: Check your project's quotas in the Google Cloud Console.

3. Cold start latency: Optimize your Docker image size and use warmup requests.

Local Deployment with Minikube

For local deployment with Minikube, we'll use the following Kubernetes configuration files:

deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: weather-deployment
spec:
  replicas: 10
  selector:
    matchLabels:
      app: weather
  template:
    metadata:
      labels:
        app: weather
    spec:
      containers:
      - name: weather
        image: paparomeoecho/weather-app-django:v4
        ports:
        - containerPort: 8000

service.yaml

apiVersion: v1
kind: Service
metadata:
  name: weather-service
spec:
  selector:
    app: weather
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8000
      nodePort: 30007  # You can specify a port in the range 30000-32767
  type: NodePort

Steps:

1. Install Minikube and kubectl.

2. Start Minikube:

    minikube start
   

3. Apply your Kubernetes configurations:

    kubectl apply -f deployment.yaml
    kubectl apply -f service.yaml
   

4. Check the deployment status:

    kubectl get deployments
    kubectl get pods
    kubectl get services
   

5. Access the app:

    minikube service weather-service
   

Pro Tips:

• Use kubectl describe for detailed information about resources.

• Leverage Minikube addons like dashboard for better cluster visibility.

• Practice local development workflows using Skaffold.

Common Errors:

1. ImagePullBackOff: Ensure your image is accessible and correctly specified.

   • Troubleshoot: kubectl describe pod <pod-name>

2. CrashLoopBackOff: Check container logs for application errors.

   • Logs: kubectl logs <pod-name>

3. Service not accessible: Verify service and pod selectors match.

   • Check: kubectl get pods --show-labels

Deployment on AWS ECS

Steps:

1. Set up an AWS account and install the AWS CLI.

2. Configure AWS CLI:

    aws configure
   

3. Create an ECS cluster:

    aws ecs create-cluster --cluster-name weather-cluster
   

4. Create a task definition (you'll need to create a JSON file based on your requirements):

    aws ecs register-task-definition --cli-input-json file://task-definition.json
   

5. Create a service:

    aws ecs create-service --cluster weather-cluster --service-name weather-service --task-definition weather-app:1 --desired-count 1
   

Pro Tips:

• Use AWS Fargate for serverless container management.

• Implement AWS Application Load Balancer for improved traffic distribution.

• Utilize ECS Service Auto Scaling for dynamic scaling based on metrics.

Common Errors:

1. Insufficient permissions: Ensure your IAM role has necessary permissions.

   • Check: Review IAM roles in AWS Console.

2. Network configuration issues: Verify VPC and security group settings.

   • Troubleshoot: Check VPC settings in AWS Console.

3. Container health check failures: Implement and test Docker health checks.

   • Add: Include HEALTHCHECK in your Dockerfile.

Conclusion

This comprehensive guide covers the deployment of your Django Weather App across various platforms, including Digital Ocean, Google Cloud Run, local Minikube, and AWS ECS. By including the actual configuration files and code snippets, we've provided a more concrete and actionable resource for your team.

Remember to always follow security best practices, especially when dealing with sensitive information like API keys and secret keys. In a production environment, these should be managed securely, possibly using environment variables or secret management services provided by the cloud platforms.

As your application evolves, make sure to update this documentation accordingly. Regular reviews and updates of deployment processes and configurations will help maintain a smooth and efficient deployment pipeline.