Shell Scripting: Automated Django Deployment & Process Management

This guide covers the step-by-step automation of deploying a Django application using a modular Bash script. It focuses on structuring scripts into reusable functions, managing system services with systemctl, containerizing applications via Docker, and handling common runtime errors (such as pre-existing directories during repository cloning) to ensure deployment reliability.

1. The Problem Statement & Automation Goals

In manual deployments, developers and DevOps engineers repeatedly execute a series of commands: cloning code, installing system dependencies, enabling services, building container images, and running application containers. Doing this manually is prone to human error, slow, and difficult to scale.

The Core Objectives of the Script

• Automate Code Retrieval: Clone the application repository from GitHub.
• Idempotency & Error Handling: Handle scenarios where the script is run multiple times (e.g., preventing the script from crashing if the repository folder already exists).
• Dependency Management: Install required system packages (docker.io, nginx) non-interactively.
• Service Management: Ensure background services are enabled to persist across system reboots.
• Containerized Deployment: Build and run the application using Docker.

2. Deployment Workflow

The following vertical flow illustrates the sequential execution of the deployment script:

3. Step-by-Step Script Evolution

Step 3.1: The Shebang and Task Definition

Every Bash script must start with a Shebang (#!/bin/bash) to instruct the operating system's program loader to use the Bash interpreter to execute the script.

#!/bin/bash

# Task: Deploy a Django App and handle code execution errors

4. Modularizing the Script with Functions

Structuring a script into functions makes it readable, maintainable, and easier to debug. We break down our deployment into four distinct functions.

Function 1: Code Cloning (code_clone)

The naive approach is to simply run git clone <repo_url>. However, running this a second time will cause the script to fail because the directory already exists.

Naive Approach:

code_clone() {
    echo "Cloning the Django app..."
    git clone https://github.com/LondheShubham153/django-notes-app.git
}

Robust Approach (With Error Handling):

To make the script idempotent, we check if the directory already exists. If it does, we pull the latest changes instead of trying to clone again.

code_clone() {
    echo "Cloning the Django app..."
    if [ -d "django-notes-app" ]; then
        echo "Repository directory already exists. Pulling latest changes..."
        cd django-notes-app && git pull
    else
        git clone https://github.com/LondheShubham153/django-notes-app.git
        cd django-notes-app
    fi
}

Function 2: Installing Dependencies (install_requirements)

The application requires Docker and Nginx. We use the system package manager (apt-get) to install them. The -y flag is critical here to auto-approve prompts, ensuring the script runs without human intervention.

install_requirements() {
    echo "Installing dependencies..."
    sudo apt-get update
    sudo apt-get install -y docker.io nginx
}

Function 3: Service Management (required_restarts)

To ensure that our background processes (Docker and Nginx) start automatically whenever the server reboots, we use systemctl enable. We also restart them to ensure they are running with the latest configurations.

required_restarts() {
    echo "Enabling and restarting system services..."
    
    # Enable services to persist across system reboots
    sudo systemctl enable docker
    sudo systemctl enable nginx
    
    # Restart services to ensure clean state
    sudo systemctl restart docker
    sudo systemctl restart nginx
}

Function 4: Containerized Deployment (deploy)

Once the environment is configured, we build the Docker image using the Dockerfile present in the repository and run the container in detached mode (-d), mapping the appropriate ports.

deploy() {
    echo "Building the Docker image..."
    docker build -t django-notes-app .
    
    echo "Running the Docker container..."
    # Run container in detached mode mapping port 8000 of host to 8000 of container
    docker run -d -p 8000:8000 django-notes-app
}

5. Complete Execution Flow Walkthrough

Below is the complete, production-ready shell script combining all modular functions, error handling, and visual execution separators.

#!/bin/bash

###############################################################################
# Script Name: deploy_django_app.sh
# Description: Automates Django deployment with Docker, Nginx, and systemctl.
# Author: DevOps Engineering Team
###############################################################################

# Exit immediately if a command exits with a non-zero status
set -e

# --- Functions ---

code_clone() {
    echo "----------------------------------------"
    echo "Step 1: Cloning the Django App"
    echo "----------------------------------------"
    if [ -d "django-notes-app" ]; then
        echo "Directory 'django-notes-app' already exists. Pulling latest changes..."
        cd django-notes-app
        git pull
    else
        git clone https://github.com/LondheShubham153/django-notes-app.git
        cd django-notes-app
    fi
}

install_requirements() {
    echo "----------------------------------------"
    echo "Step 2: Installing Dependencies"
    echo "----------------------------------------"
    sudo apt-get update
    sudo apt-get install -y docker.io nginx
}

required_restarts() {
    echo "----------------------------------------"
    echo "Step 3: Configuring System Services"
    echo "----------------------------------------"
    sudo systemctl enable docker
    sudo systemctl enable nginx
    sudo systemctl restart docker
    sudo systemctl restart nginx
}

deploy() {
    echo "----------------------------------------"
    echo "Step 4: Deploying Application via Docker"
    echo "----------------------------------------"
    docker build -t django-notes-app .
    
    # Stop and remove existing container if running to avoid port conflicts
    if [ "$(docker ps -aq -f name=django-app-container)" ]; then
        echo "Stopping and removing existing container..."
        docker rm -f django-app-container
    fi
    
    docker run -d --name django-app-container -p 8000:8000 django-notes-app
}

# --- Main Execution Flow ---

echo "========================================"
echo "      DEPLOYMENT STARTED                "
echo "========================================"

code_clone
install_requirements
required_restarts
deploy

echo "========================================"
echo "      DEPLOYMENT COMPLETED SUCCESSFUL   "
echo "========================================"

6. Synthesis of Deployment Stages

7. Real-World Pitfalls & Debugging Workflows

1. Handling Port Conflicts

• The Issue: If you run the script multiple times, the docker run command will fail because port 8000 is already bound by the container from the previous run.
• The Fix: Add a cleanup step before running the new container:
  BASH

  Copy

  docker rm -f django-app-container || true
  

  (The || true ensures that if the container doesn't exist, the script doesn't crash).

2. Permissions Issues with Docker

• The Issue: Running docker build or docker run without sudo can throw permission denied errors if the current user is not in the docker group.
• The Fix: Ensure the script is run with sudo privileges, or add the current user to the docker group:
  BASH

  Copy

  sudo usermod -aG docker $USER
  

Summary and Key Takeaways

• The Shebang Line: Always start your scripts with #!/bin/bash to define the execution environment.
• Modular Code Design: Breaking your script into logical functions (code_clone, install_requirements, etc.) makes troubleshooting and maintenance significantly easier.
• Idempotency: A production-grade script must be runnable multiple times without throwing errors. Checking if directories exist or if containers are already running prevents script failures.
• Non-Interactive Execution: When installing packages via package managers in scripts, always use flags like -y to prevent the script from hanging on user prompts.
• Service Persistence: Use systemctl enable <service> to ensure critical background services like Docker and Nginx survive system reboots.
• Container Lifecycle Management: Always clean up old container instances before launching new ones to avoid port binding conflicts.