Vengala Vinay

Having 9+ Years of Experience in Software Development

Home » Zero-Downtime Blue-Green Deployment Pipelines for Python Applications on DigitalOcean

Zero-Downtime Blue-Green Deployment Pipelines for Python Applications on DigitalOcean

Understanding Blue-Green Deployments

Blue-Green deployment is a strategy for reducing downtime and risk associated with application releases. It involves maintaining two identical production environments, “Blue” and “Green.” At any given time, one environment (e.g., Blue) is live and serving production traffic, while the other (Green) is idle. To deploy a new version, we update the idle environment (Green) with the new code. Once tested and validated, traffic is switched from the Blue environment to the Green environment. The Blue environment then becomes the idle environment, ready for the next deployment.

Prerequisites and Setup on DigitalOcean

This guide assumes you have a DigitalOcean account with existing Droplets configured for your Python application. We’ll need at least two Droplets for the Blue and Green environments, and a load balancer to manage traffic routing. For simplicity, we’ll assume a basic Nginx setup on each application Droplet, serving a Python WSGI application (like Flask or Django).

Key Components:

  • DigitalOcean Load Balancer: Essential for directing traffic to either the Blue or Green environment.
  • Two Application Droplets: One for the “Blue” environment, one for the “Green” environment. These should be identical in configuration.
  • Nginx Configuration: Each Droplet will have Nginx configured to proxy requests to the Python application server (e.g., Gunicorn).
  • Deployment Script: A script to automate the deployment process to the idle environment.

Configuring the Load Balancer

First, create a DigitalOcean Load Balancer. Add your “Blue” application Droplet as a backend server. Configure a health check for your application. A common health check is to ping a specific endpoint (e.g., /health) that returns a 200 OK status if the application is healthy.

Once the Load Balancer is set up with the Blue Droplet, we’ll manually switch traffic later. For now, ensure the Load Balancer is pointing to the Blue Droplet.

Setting up Application Droplets

Each application Droplet needs to be configured identically. This includes installing Python, your application dependencies, a WSGI server (like Gunicorn), and Nginx. The critical part is ensuring Nginx is configured to listen on a specific port (e.g., 8000) that the WSGI server uses, and that the WSGI server is configured to bind to a port that is *not* directly exposed to the internet, but rather proxied by Nginx.

Example Nginx Configuration (for both Blue and Green Droplets):

server {
    listen 80;
    server_name your_domain.com;

    location / {
        proxy_pass http://127.0.0.1:8000; # Proxy to Gunicorn
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /health {
        access_log off;
        return 200 'OK';
        add_header Content-Type text/plain;
    }
}

Example Gunicorn Configuration (for both Blue and Green Droplets):

gunicorn --workers 3 --bind 127.0.0.1:8000 your_app.wsgi:application

Ensure your application code is deployed to both Droplets, and that both are running and accessible via Nginx on port 80. At this stage, only the “Blue” Droplet should be registered with the Load Balancer.

Automating the Deployment Pipeline

We need a script that can deploy new code to the *idle* environment (initially Green). This script will typically:

  • Fetch the latest code from your repository (e.g., Git).
  • Install dependencies (e.g., pip install -r requirements.txt).
  • Run database migrations (if applicable).
  • Restart the WSGI server (Gunicorn).
  • Perform a quick self-test on the idle environment.

Let’s assume your “Blue” Droplet is currently live. The “Green” Droplet is idle. We’ll create a deployment script that targets the Green Droplet.

Deployment Script (deploy.sh):

#!/bin/bash

# --- Configuration ---
TARGET_HOST="user@green_droplet_ip" # SSH user and IP of the idle Droplet
APP_DIR="/path/to/your/app"
GIT_REPO="[email protected]:your_org/your_repo.git"
BRANCH="main"
REQUIREMENTS_FILE="requirements.txt"
WSGI_APP="your_app.wsgi:application"
GUNICORN_BIND="127.0.0.1:8000"
HEALTH_CHECK_URL="http://green_droplet_ip/health" # Use the IP directly for testing before LB switch

# --- Deployment Steps ---
echo "Starting deployment to Green environment..."

# 1. SSH into the target Droplet and execute deployment commands
ssh $TARGET_HOST << EOF
    echo "Pulling latest code..."
    cd $APP_DIR
    git fetch origin
    git checkout $BRANCH
    git pull origin $BRANCH

    echo "Installing dependencies..."
    pip install -r $REQUIREMENTS_FILE

    echo "Running database migrations (if applicable)..."
    # python manage.py migrate # Example for Django

    echo "Restarting Gunicorn..."
    # Find and kill existing Gunicorn processes
    pkill gunicorn
    # Start new Gunicorn process
    gunicorn --workers 3 --bind $GUNICORN_BIND $WSGI_APP &

    echo "Deployment to Green environment complete."
EOF

# 2. Health Check the Green environment
echo "Performing health check on Green environment..."
HEALTH_STATUS=$(curl -s -o /dev/null -w "%{http_code}" $HEALTH_CHECK_URL)

if [ "$HEALTH_STATUS" -eq 200 ]; then
    echo "Green environment health check passed ($HEALTH_STATUS)."
    # Proceed to traffic switch
else
    echo "Green environment health check failed ($HEALTH_STATUS). Aborting deployment."
    exit 1
fi

echo "Deployment script finished."
exit 0

Performing the Traffic Switch

Once the deployment script successfully updates and validates the Green environment, the next step is to switch traffic. This is done by reconfiguring the DigitalOcean Load Balancer.

Manual Switch (via DigitalOcean UI or API):

  • Navigate to your Load Balancer in the DigitalOcean control panel.
  • Add the "Green" application Droplet to the Load Balancer's backend pool.
  • Remove the "Blue" application Droplet from the Load Balancer's backend pool.

This action will immediately start directing all new incoming traffic to the Green environment. The Blue environment will now be idle and can be updated in the next deployment cycle.

Automating the Traffic Switch

For a fully automated pipeline, you'll need to interact with the DigitalOcean API. This can be done using tools like curl, Python SDKs, or Terraform.

Here's a conceptual example using curl to update the Load Balancer's backend pool. You'll need to obtain your Load Balancer ID and API Token from DigitalOcean.

#!/bin/bash

# --- Configuration ---
DO_API_TOKEN="YOUR_DIGITALOCEAN_API_TOKEN"
LB_ID="YOUR_LOAD_BALANCER_ID"
BLUE_DROPLET_ID="YOUR_BLUE_DROPLET_ID"
GREEN_DROPLET_ID="YOUR_GREEN_DROPLET_ID"

# --- Get current LB configuration ---
CURRENT_CONFIG=$(curl -X GET "https://api.digitalocean.com/v2/loadbalancers/$LB_ID" \
    -H "Authorization: Bearer $DO_API_TOKEN")

# Extract current backend pool
BACKEND_POOL=$(echo $CURRENT_CONFIG | jq '.load_balancer.backend_pools[0]') # Assuming one backend pool

# --- Update backend pool: Remove Blue, Add Green ---
# This is a simplified example. Real-world scenarios might need more robust JSON manipulation.
# You'd typically fetch the existing pool, filter out the BLUE_DROPLET_ID, and append GREEN_DROPLET_ID.

# For demonstration, let's assume we are replacing the entire pool with just Green.
# In a real scenario, you'd want to preserve other backend pool settings.
NEW_BACKEND_POOL=$(echo $BACKEND_POOL | jq --argjson green_id "$GREEN_DROPLET_ID" \
    '.droplets = [{"id": $green_id}]')

# --- Send the update request ---
echo "Switching traffic to Green Droplet ($GREEN_DROPLET_ID)..."
curl -X PUT "https://api.digitalocean.com/v2/loadbalancers/$LB_ID" \
    -H "Authorization: Bearer $DO_API_TOKEN" \
    -H "Content-Type: application/json" \
    -d "{\"backend_pools\": [$NEW_BACKEND_POOL]}"

echo "Traffic switch initiated."

Note: The above `curl` example is illustrative. You'll need to parse the existing configuration carefully and construct the new one. Using the DigitalOcean Python SDK or Terraform would be more robust for managing this.

Rollback Strategy

A critical part of any deployment strategy is the rollback plan. In a Blue-Green setup, rolling back is as simple as switching traffic back to the previously live environment. If the new deployment to Green fails or causes issues, you simply reconfigure the Load Balancer to point back to the Blue Droplet.

Rollback Procedure:

  • Identify the Droplet that was previously serving traffic (e.g., Blue).
  • Reconfigure the Load Balancer to include the Blue Droplet and exclude the Green Droplet.

This can be automated using similar API calls as the traffic switch, but reversing the Droplet IDs.

Integrating with CI/CD

This entire process can be integrated into a CI/CD pipeline (e.g., GitLab CI, GitHub Actions, Jenkins). The pipeline would typically:

  • On a successful merge to the `main` branch (or a release tag):
  • Trigger the deployment script to deploy to the idle environment (e.g., Green).
  • Perform automated integration and end-to-end tests against the newly deployed environment (using its IP directly or a staging URL).
  • If tests pass, trigger the Load Balancer traffic switch API calls.
  • If tests fail, alert the team and do not switch traffic.

This ensures that only validated code is promoted to production, and the switch is automated, minimizing human error and downtime.