Deploy Django application with Gunicorn and PostgreSQL database migrations

#!/usr/bin/env bash
set -euo pipefail

# Django + Gunicorn + PostgreSQL Deployment Script
# Usage: ./install.sh [domain] [db_password]

# Color codes
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
NC='\033[0m'

# Default values
DOMAIN=${1:-"localhost"}
DB_PASSWORD=${2:-"SecurePassword123!"}
DJANGO_USER="djangoapp"
DJANGO_HOME="/opt/djangoapp"
PROJECT_NAME="myproject"

# Cleanup function
cleanup() {
    echo -e "${RED}[ERROR] Installation failed. Cleaning up...${NC}"
    systemctl stop gunicorn.service 2>/dev/null || true
    systemctl disable gunicorn.service 2>/dev/null || true
    userdel -r $DJANGO_USER 2>/dev/null || true
    sudo -u postgres dropdb djangoapp 2>/dev/null || true
    sudo -u postgres dropuser djangouser 2>/dev/null || true
    exit 1
}

trap cleanup ERR

# Check root privileges
if [[ $EUID -ne 0 ]]; then
    echo -e "${RED}This script must be run as root${NC}"
    exit 1
fi

# Auto-detect distribution
if [ -f /etc/os-release ]; then
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_UPDATE="apt update && apt upgrade -y"
            PKG_INSTALL="apt install -y"
            PG_SERVICE="postgresql"
            PG_SETUP=""
            PYTHON_DEV="python3.12-dev"
            PG_DEV="libpq-dev"
            BUILD_TOOLS="build-essential"
            ;;
        almalinux|rocky|centos|rhel|ol)
            PKG_MGR="dnf"
            PKG_UPDATE="dnf update -y"
            PKG_INSTALL="dnf install -y"
            PG_SERVICE="postgresql"
            PG_SETUP="postgresql-setup --initdb"
            PYTHON_DEV="python3.12-devel"
            PG_DEV="postgresql-devel"
            BUILD_TOOLS="gcc"
            ;;
        fedora)
            PKG_MGR="dnf"
            PKG_UPDATE="dnf update -y"
            PKG_INSTALL="dnf install -y"
            PG_SERVICE="postgresql"
            PG_SETUP=""
            PYTHON_DEV="python3.12-devel"
            PG_DEV="postgresql-devel"
            BUILD_TOOLS="gcc"
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_UPDATE="yum update -y"
            PKG_INSTALL="yum install -y"
            PG_SERVICE="postgresql"
            PG_SETUP=""
            PYTHON_DEV="python3.12-devel"
            PG_DEV="postgresql-devel"
            BUILD_TOOLS="gcc"
            ;;
        *)
            echo -e "${RED}Unsupported distribution: $ID${NC}"
            exit 1
            ;;
    esac
else
    echo -e "${RED}Cannot detect OS distribution${NC}"
    exit 1
fi

echo -e "${GREEN}Starting Django deployment on $ID...${NC}"

# Step 1: Update system
echo -e "${YELLOW}[1/10] Updating system packages...${NC}"
$PKG_UPDATE

# Step 2: Install Python and dependencies
echo -e "${YELLOW}[2/10] Installing Python 3.12 and dependencies...${NC}"
$PKG_INSTALL python3.12 python3.12-venv $PYTHON_DEV python3-pip $PG_DEV $BUILD_TOOLS

# Step 3: Install PostgreSQL
echo -e "${YELLOW}[3/10] Installing PostgreSQL...${NC}"
$PKG_INSTALL postgresql-server postgresql-contrib
if [[ -n "$PG_SETUP" ]]; then
    sudo $PG_SETUP 2>/dev/null || true
fi
systemctl enable --now $PG_SERVICE

# Step 4: Create database and user
echo -e "${YELLOW}[4/10] Setting up PostgreSQL database...${NC}"
sleep 3  # Wait for PostgreSQL to start
sudo -u postgres psql -c "CREATE DATABASE djangoapp;" 2>/dev/null || true
sudo -u postgres psql -c "CREATE USER djangouser WITH PASSWORD '$DB_PASSWORD';" 2>/dev/null || true
sudo -u postgres psql -c "ALTER ROLE djangouser SET client_encoding TO 'utf8';"
sudo -u postgres psql -c "ALTER ROLE djangouser SET default_transaction_isolation TO 'read committed';"
sudo -u postgres psql -c "ALTER ROLE djangouser SET timezone TO 'UTC';"
sudo -u postgres psql -c "GRANT ALL PRIVILEGES ON DATABASE djangoapp TO djangouser;"

# Step 5: Create application user and directories
echo -e "${YELLOW}[5/10] Creating application user and directories...${NC}"
useradd --system --shell /bin/bash --home $DJANGO_HOME --create-home $DJANGO_USER 2>/dev/null || true
mkdir -p $DJANGO_HOME/{app,logs,static,media}
chown -R $DJANGO_USER:$DJANGO_USER $DJANGO_HOME
chmod 755 $DJANGO_HOME
chmod 755 $DJANGO_HOME/{app,logs,static,media}

# Step 6: Set up Python virtual environment
echo -e "${YELLOW}[6/10] Setting up Python virtual environment...${NC}"
sudo -u $DJANGO_USER python3.12 -m venv $DJANGO_HOME/venv
sudo -u $DJANGO_USER $DJANGO_HOME/venv/bin/pip install --upgrade pip

# Step 7: Install Django and dependencies
echo -e "${YELLOW}[7/10] Installing Django and dependencies...${NC}"
sudo -u $DJANGO_USER $DJANGO_HOME/venv/bin/pip install Django==5.0 gunicorn psycopg2-binary python-decouple whitenoise

# Step 8: Create Django project
echo -e "${YELLOW}[8/10] Creating Django project...${NC}"
cd $DJANGO_HOME/app
sudo -u $DJANGO_USER $DJANGO_HOME/venv/bin/django-admin startproject $PROJECT_NAME .

# Create settings.py
sudo -u $DJANGO_USER tee $DJANGO_HOME/app/$PROJECT_NAME/settings.py > /dev/null << 'EOF'
from pathlib import Path
import os
from decouple import config

BASE_DIR = Path(__file__).resolve().parent.parent
SECRET_KEY = config('SECRET_KEY', default='django-insecure-change-me-in-production')
DEBUG = config('DEBUG', default=False, cast=bool)
ALLOWED_HOSTS = ['*']

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'whitenoise.runserver_nostatic',
    'django.contrib.staticfiles',
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'whitenoise.middleware.WhiteNoiseMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'myproject.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'djangoapp',
        'USER': 'djangouser',
        'PASSWORD': 'SecurePassword123!',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

STATIC_URL = '/static/'
STATIC_ROOT = '/opt/djangoapp/static'
MEDIA_URL = '/media/'
MEDIA_ROOT = '/opt/djangoapp/media'
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
EOF

# Run migrations and collect static files
sudo -u $DJANGO_USER $DJANGO_HOME/venv/bin/python $DJANGO_HOME/app/manage.py migrate
sudo -u $DJANGO_USER $DJANGO_HOME/venv/bin/python $DJANGO_HOME/app/manage.py collectstatic --noinput

# Step 9: Create systemd service
echo -e "${YELLOW}[9/10] Creating systemd service...${NC}"
tee /etc/systemd/system/gunicorn.service > /dev/null << EOF
[Unit]
Description=Gunicorn daemon for Django project
Requires=network.target
After=network.target

[Service]
User=$DJANGO_USER
Group=$DJANGO_USER
WorkingDirectory=$DJANGO_HOME/app
Environment="PATH=$DJANGO_HOME/venv/bin"
ExecStart=$DJANGO_HOME/venv/bin/gunicorn --workers 3 --bind 0.0.0.0:8000 $PROJECT_NAME.wsgi:application
ExecReload=/bin/kill -s HUP \$MAINPID
KillMode=mixed
TimeoutStopSec=5
PrivateTmp=true

[Install]
WantedBy=multi-user.target
EOF

chmod 644 /etc/systemd/system/gunicorn.service
systemctl daemon-reload
systemctl enable gunicorn.service
systemctl start gunicorn.service

# Step 10: Verification
echo -e "${YELLOW}[10/10] Running verification checks...${NC}"
sleep 2

# Check service status
if systemctl is-active --quiet gunicorn.service; then
    echo -e "${GREEN}✓ Gunicorn service is running${NC}"
else
    echo -e "${RED}✗ Gunicorn service failed to start${NC}"
    exit 1
fi

# Check PostgreSQL connection
if sudo -u $DJANGO_USER $DJANGO_HOME/venv/bin/python $DJANGO_HOME/app/manage.py check --database default; then
    echo -e "${GREEN}✓ Database connection successful${NC}"
else
    echo -e "${RED}✗ Database connection failed${NC}"
    exit 1
fi

# Check HTTP response
if curl -s -o /dev/null -w "%{http_code}" http://localhost:8000/ | grep -q "200\|301\|302"; then
    echo -e "${GREEN}✓ HTTP server responding${NC}"
else
    echo -e "${RED}✗ HTTP server not responding${NC}"
    exit 1
fi

echo -e "${GREEN}Django deployment completed successfully!${NC}"
echo -e "${GREEN}Application running at: http://$DOMAIN:8000${NC}"
echo -e "${YELLOW}Don't forget to:${NC}"
echo -e "${YELLOW}1. Configure your reverse proxy (Nginx/Apache)${NC}"
echo -e "${YELLOW}2. Set up SSL certificates${NC}"
echo -e "${YELLOW}3. Change the SECRET_KEY in production${NC}"
echo -e "${YELLOW}4. Configure firewall rules${NC}"