# 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.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1723959751283/0f9fa336-e728-475f-8742-dd30f413e869.png align="center")

## 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

%[https://github.com/SundayPyjamas/weatherapp_deployment_experiments] 

## Application Code Overview

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

### Dockerfile

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1723959778322/ce0f3fb2-b0c5-4eca-b298-0aa521dadfe6.jpeg align="center")

```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

```yaml
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](http://manage.py)

```python
#!/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`](http://manage.py) file, which is used for various Django administrative tasks.

## Deployment on Digital Ocean

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1723959826276/917250ca-138c-46c6-be76-d8565f3c4b34.png align="center")

### Steps:

1. Create a Digital Ocean account and set up a Droplet.
    
2. SSH into your Droplet:
    
    ```bash
    ssh root@your_droplet_ip
    ```
    
3. Install Docker on the Droplet:
    
    ```bash
    curl -fsSL https://get.docker.com -o get-docker.sh
    sh get-docker.sh
    ```
    
4. Pull your Docker image:
    
    ```bash
    docker pull paparomeoecho/weather-app-django:v4
    ```
    
5. Run the container:
    
    ```bash
    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

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1723959837444/ce5bff76-3780-4dc5-85cf-04c31ea2d626.png align="center")

### 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:
    
    ```bash
    gcloud auth login
    ```
    
4. Set your project ID:
    
    ```bash
    gcloud config set project YOUR_PROJECT_ID
    ```
    
5. Build and push your Docker image to Google Container Registry:
    
    ```bash
    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:
    
    ```bash
    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

```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

```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:
    
    ```bash
    minikube start
    ```
    
3. Apply your Kubernetes configurations:
    
    ```bash
    kubectl apply -f deployment.yaml
    kubectl apply -f service.yaml
    ```
    
4. Check the deployment status:
    
    ```bash
    kubectl get deployments
    kubectl get pods
    kubectl get services
    ```
    
5. Access the app:
    
    ```bash
    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:
    
    ```bash
    aws configure
    ```
    
3. Create an ECS cluster:
    
    ```bash
    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):
    
    ```bash
    aws ecs register-task-definition --cli-input-json file://task-definition.json
    ```
    
5. Create a service:
    
    ```bash
    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.