Implement Nginx Redis cluster caching for high availability

#!/usr/bin/env bash

set -euo pipefail

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Configuration
NGINX_VERSION="1.24.0"
REDIS_NODES="${1:-3}"
CLUSTER_NAME="${2:-redis-cluster}"

# Usage message
usage() {
    echo "Usage: $0 [redis_nodes] [cluster_name]"
    echo "  redis_nodes: Number of Redis nodes (default: 3)"
    echo "  cluster_name: Name for Redis cluster (default: redis-cluster)"
    exit 1
}

# Error handling
cleanup() {
    local exit_code=$?
    if [ $exit_code -ne 0 ]; then
        echo -e "${RED}[ERROR] Installation failed. Cleaning up...${NC}"
        systemctl stop nginx redis 2>/dev/null || true
        rm -rf /tmp/nginx-* /tmp/redis2-nginx-module /tmp/set-misc-nginx-module /tmp/echo-nginx-module 2>/dev/null || true
    fi
    exit $exit_code
}

trap cleanup ERR

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

# Detect distribution
if [ -f /etc/os-release ]; then
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_INSTALL="apt install -y"
            PKG_UPDATE="apt update && apt upgrade -y"
            BUILD_DEPS="build-essential libpcre3-dev zlib1g-dev libssl-dev libgeoip-dev libhiredis-dev git wget"
            REDIS_PKG="redis-server"
            ;;
        almalinux|rocky|centos|rhel|ol|fedora)
            PKG_MGR="dnf"
            PKG_INSTALL="dnf install -y"
            PKG_UPDATE="dnf update -y"
            BUILD_DEPS="gcc gcc-c++ pcre-devel zlib-devel openssl-devel geoip-devel hiredis-devel git make wget"
            REDIS_PKG="redis"
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_INSTALL="yum install -y"
            PKG_UPDATE="yum update -y"
            BUILD_DEPS="gcc gcc-c++ pcre-devel zlib-devel openssl-devel geoip-devel hiredis-devel git make wget"
            REDIS_PKG="redis"
            ;;
        *)
            echo -e "${RED}[ERROR] Unsupported distribution: $ID${NC}"
            exit 1
            ;;
    esac
else
    echo -e "${RED}[ERROR] Cannot detect distribution${NC}"
    exit 1
fi

echo -e "${GREEN}[1/10] Updating system packages...${NC}"
$PKG_UPDATE

echo -e "${GREEN}[2/10] Installing Redis and development tools...${NC}"
$PKG_INSTALL $REDIS_PKG $BUILD_DEPS

echo -e "${GREEN}[3/10] Downloading Nginx source and Redis modules...${NC}"
cd /tmp
wget -q http://nginx.org/download/nginx-${NGINX_VERSION}.tar.gz
tar -xzf nginx-${NGINX_VERSION}.tar.gz
git clone --quiet https://github.com/openresty/redis2-nginx-module.git
git clone --quiet https://github.com/openresty/set-misc-nginx-module.git
git clone --quiet https://github.com/openresty/echo-nginx-module.git

echo -e "${GREEN}[4/10] Configuring and compiling Nginx with Redis modules...${NC}"
cd /tmp/nginx-${NGINX_VERSION}
./configure --prefix=/etc/nginx \
--sbin-path=/usr/sbin/nginx \
--modules-path=/usr/lib/nginx/modules \
--conf-path=/etc/nginx/nginx.conf \
--error-log-path=/var/log/nginx/error.log \
--http-log-path=/var/log/nginx/access.log \
--pid-path=/var/run/nginx.pid \
--lock-path=/var/run/nginx.lock \
--http-client-body-temp-path=/var/cache/nginx/client_temp \
--http-proxy-temp-path=/var/cache/nginx/proxy_temp \
--http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp \
--http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp \
--http-scgi-temp-path=/var/cache/nginx/scgi_temp \
--with-http_ssl_module \
--with-http_realip_module \
--with-http_addition_module \
--with-http_sub_module \
--with-http_dav_module \
--with-http_flv_module \
--with-http_mp4_module \
--with-http_gunzip_module \
--with-http_gzip_static_module \
--with-http_random_index_module \
--with-http_secure_link_module \
--with-http_stub_status_module \
--with-http_auth_request_module \
--with-threads \
--with-stream \
--with-stream_ssl_module \
--with-http_slice_module \
--with-http_v2_module \
--add-module=/tmp/redis2-nginx-module \
--add-module=/tmp/set-misc-nginx-module \
--add-module=/tmp/echo-nginx-module >/dev/null

make -j$(nproc) >/dev/null
make install >/dev/null

echo -e "${GREEN}[5/10] Creating nginx user and directories...${NC}"
if ! id nginx >/dev/null 2>&1; then
    useradd --system --home /var/cache/nginx --shell /sbin/nologin --comment "nginx user" --user-group nginx
fi

mkdir -p /var/cache/nginx/{client_temp,proxy_temp,fastcgi_temp,uwsgi_temp,scgi_temp}
mkdir -p /etc/nginx/conf.d
chown -R nginx:nginx /var/cache/nginx
chmod 755 /var/cache/nginx

echo -e "${GREEN}[6/10] Creating Nginx systemd service...${NC}"
cat > /etc/systemd/system/nginx.service << 'EOF'
[Unit]
Description=The nginx HTTP and reverse proxy server
Documentation=http://nginx.org/en/docs/
After=network.target remote-fs.target nss-lookup.target
Wants=network-online.target

[Service]
Type=forking
PIDFile=/var/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t
ExecStart=/usr/sbin/nginx
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s QUIT $MAINPID
KillMode=mixed
PrivateTmp=true
User=nginx
Group=nginx

[Install]
WantedBy=multi-user.target
EOF

echo -e "${GREEN}[7/10] Configuring Redis cluster...${NC}"
mkdir -p /etc/redis/cluster
for i in $(seq 1 $REDIS_NODES); do
    PORT=$((7000 + i - 1))
    mkdir -p /var/lib/redis/node-${PORT}
    cat > /etc/redis/cluster/redis-${PORT}.conf << EOF
port ${PORT}
cluster-enabled yes
cluster-config-file nodes-${PORT}.conf
cluster-node-timeout 5000
appendonly yes
dir /var/lib/redis/node-${PORT}
pidfile /var/run/redis_${PORT}.pid
logfile /var/log/redis/redis-${PORT}.log
EOF
    chown redis:redis /var/lib/redis/node-${PORT}
    chmod 755 /var/lib/redis/node-${PORT}
done

echo -e "${GREEN}[8/10] Creating Redis cluster service files...${NC}"
for i in $(seq 1 $REDIS_NODES); do
    PORT=$((7000 + i - 1))
    cat > /etc/systemd/system/redis-${PORT}.service << EOF
[Unit]
Description=Advanced key-value store (port ${PORT})
After=network.target
Documentation=http://redis.io/documentation, man:redis-server(1)

[Service]
Type=notify
ExecStart=/usr/bin/redis-server /etc/redis/cluster/redis-${PORT}.conf
TimeoutStopSec=0
Restart=always
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755

[Install]
WantedBy=multi-user.target
EOF
done

echo -e "${GREEN}[9/10] Creating Nginx configuration with Redis caching...${NC}"
cat > /etc/nginx/nginx.conf << 'EOF'
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

events {
    worker_connections 1024;
}

http {
    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                    '$status $body_bytes_sent "$http_referer" '
                    '"$http_user_agent" "$http_x_forwarded_for"';

    access_log /var/log/nginx/access.log main;

    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;

    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    upstream redis_cluster {
        server 127.0.0.1:7000;
        server 127.0.0.1:7001;
        server 127.0.0.1:7002;
    }

    server {
        listen 80 default_server;
        server_name _;
        root /usr/share/nginx/html;

        location /redis-health {
            redis2_query ping;
            redis2_pass redis_cluster;
        }

        location / {
            set $redis_key $uri$args;
            redis2_query get $redis_key;
            redis2_pass redis_cluster;

            error_page 404 = @fallback;
        }

        location @fallback {
            proxy_pass http://127.0.0.1:8080;
            redis2_query setex $redis_key 3600 $upstream_response_body;
            redis2_pass redis_cluster;
        }
    }

    include /etc/nginx/conf.d/*.conf;
}
EOF

mkdir -p /usr/share/nginx/html
echo "<h1>Nginx Redis Cluster Cache Ready</h1>" > /usr/share/nginx/html/index.html
chown -R nginx:nginx /usr/share/nginx/html
chmod 644 /usr/share/nginx/html/index.html

echo -e "${GREEN}[10/10] Starting and enabling services...${NC}"
systemctl daemon-reload

for i in $(seq 1 $REDIS_NODES); do
    PORT=$((7000 + i - 1))
    systemctl enable redis-${PORT}
    systemctl start redis-${PORT}
done

systemctl enable nginx
systemctl start nginx

# Verification
echo -e "${YELLOW}Verifying installation...${NC}"
sleep 3

if systemctl is-active --quiet nginx; then
    echo -e "${GREEN}✓ Nginx is running${NC}"
else
    echo -e "${RED}✗ Nginx failed to start${NC}"
    exit 1
fi

REDIS_RUNNING=0
for i in $(seq 1 $REDIS_NODES); do
    PORT=$((7000 + i - 1))
    if systemctl is-active --quiet redis-${PORT}; then
        echo -e "${GREEN}✓ Redis node ${PORT} is running${NC}"
        ((REDIS_RUNNING++))
    else
        echo -e "${RED}✗ Redis node ${PORT} failed to start${NC}"
    fi
done

if [ $REDIS_RUNNING -eq $REDIS_NODES ]; then
    echo -e "${GREEN}✓ All Redis nodes are running${NC}"
else
    echo -e "${YELLOW}⚠ Only $REDIS_RUNNING of $REDIS_NODES Redis nodes are running${NC}"
fi

# Clean up build files
rm -rf /tmp/nginx-* /tmp/redis2-nginx-module /tmp/set-misc-nginx-module /tmp/echo-nginx-module

echo -e "${GREEN}Installation completed successfully!${NC}"
echo -e "${YELLOW}Next steps:${NC}"
echo "1. Test Redis health: curl http://localhost/redis-health"
echo "2. Configure your application backend on port 8080"
echo "3. Monitor logs: tail -f /var/log/nginx/error.log"