Optimize Nginx caching performance with Redis backend and memory tuning for high-traffic websites

#!/usr/bin/env bash

set -euo pipefail

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

# Global variables
DOMAIN="${1:-example.com}"
REDIS_MEMORY="${2:-2g}"
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Usage function
usage() {
    echo "Usage: $0 [domain] [redis_memory]"
    echo "  domain: Domain name (default: example.com)"
    echo "  redis_memory: Redis memory limit (default: 2g)"
    exit 1
}

# Logging functions
log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
log_warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $1"; }

# Cleanup function
cleanup() {
    log_error "Installation failed. Rolling back changes..."
    systemctl stop nginx redis-server 2>/dev/null || true
    rm -f /etc/nginx/sites-available/redis-cache 2>/dev/null || true
    rm -f /etc/nginx/conf.d/redis-cache.conf 2>/dev/null || true
    rm -rf /usr/local/share/lua 2>/dev/null || true
}

trap cleanup ERR

# Check prerequisites
check_prerequisites() {
    if [[ $EUID -ne 0 ]]; then
        log_error "This script must be run as root"
        exit 1
    fi
    
    if [[ $# -gt 2 ]]; then
        usage
    fi
}

# Detect distribution
detect_distro() {
    if [[ ! -f /etc/os-release ]]; then
        log_error "Cannot detect distribution"
        exit 1
    fi
    
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_UPDATE="apt update && apt upgrade -y"
            PKG_INSTALL="apt install -y"
            NGINX_CONF_DIR="/etc/nginx"
            NGINX_SITES_DIR="/etc/nginx/sites-available"
            NGINX_ENABLED_DIR="/etc/nginx/sites-enabled"
            REDIS_CONF="/etc/redis/redis.conf"
            NGINX_USER="www-data"
            USE_SITES_AVAILABLE=true
            ;;
        almalinux|rocky|centos|rhel|ol|fedora)
            PKG_MGR="dnf"
            PKG_UPDATE="dnf update -y"
            PKG_INSTALL="dnf install -y"
            NGINX_CONF_DIR="/etc/nginx"
            NGINX_SITES_DIR="/etc/nginx/conf.d"
            NGINX_ENABLED_DIR="/etc/nginx/conf.d"
            REDIS_CONF="/etc/redis.conf"
            NGINX_USER="nginx"
            USE_SITES_AVAILABLE=false
            if [[ "$ID" == "centos" ]] && [[ "${VERSION_ID%%.*}" -le 7 ]]; then
                PKG_MGR="yum"
                PKG_UPDATE="yum update -y"
                PKG_INSTALL="yum install -y"
            fi
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_UPDATE="yum update -y"
            PKG_INSTALL="yum install -y"
            NGINX_CONF_DIR="/etc/nginx"
            NGINX_SITES_DIR="/etc/nginx/conf.d"
            NGINX_ENABLED_DIR="/etc/nginx/conf.d"
            REDIS_CONF="/etc/redis.conf"
            NGINX_USER="nginx"
            USE_SITES_AVAILABLE=false
            ;;
        *)
            log_error "Unsupported distribution: $ID"
            exit 1
            ;;
    esac
    
    log_info "Detected distribution: $ID"
}

# Install packages
install_packages() {
    echo "[1/7] Installing packages..."
    
    eval $PKG_UPDATE
    
    case "$PKG_MGR" in
        apt)
            $PKG_INSTALL nginx redis-server lua-cjson libnginx-mod-http-lua build-essential git
            ;;
        dnf)
            $PKG_INSTALL epel-release
            $PKG_INSTALL nginx redis nginx-mod-http-lua lua-cjson git gcc make
            ;;
        yum)
            $PKG_INSTALL epel-release
            $PKG_INSTALL nginx redis lua-cjson git gcc make
            ;;
    esac
    
    log_info "Packages installed successfully"
}

# Install lua-resty-redis
install_lua_redis() {
    echo "[2/7] Installing lua-resty-redis library..."
    
    cd /tmp
    if [[ -d lua-resty-redis ]]; then
        rm -rf lua-resty-redis
    fi
    
    git clone https://github.com/openresty/lua-resty-redis.git
    cd lua-resty-redis
    
    mkdir -p /usr/local/share/lua/5.1/resty
    cp lib/resty/redis.lua /usr/local/share/lua/5.1/resty/
    chown root:root /usr/local/share/lua/5.1/resty/redis.lua
    chmod 644 /usr/local/share/lua/5.1/resty/redis.lua
    
    log_info "lua-resty-redis installed successfully"
}

# Configure Redis
configure_redis() {
    echo "[3/7] Configuring Redis..."
    
    cp "$REDIS_CONF" "$REDIS_CONF.backup"
    
    cat > "$REDIS_CONF" << EOF
# Memory optimization
maxmemory ${REDIS_MEMORY}b
maxmemory-policy allkeys-lru

# Performance tuning
tcp-keepalive 60
timeout 300
tcp-backlog 511

# Persistence settings for cache
save ""
appendonly no

# Network optimization
bind 127.0.0.1
port 6379
protected-mode yes

# Logging
loglevel notice
logfile /var/log/redis/redis-server.log

# Client output buffer limits
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60

# Security
requirepass $(openssl rand -base64 32)
EOF
    
    # Create log directory
    mkdir -p /var/log/redis
    chown redis:redis /var/log/redis
    chmod 755 /var/log/redis
    
    log_info "Redis configured successfully"
}

# Configure Nginx
configure_nginx() {
    echo "[4/7] Configuring Nginx..."
    
    cp "$NGINX_CONF_DIR/nginx.conf" "$NGINX_CONF_DIR/nginx.conf.backup"
    
    cat > "$NGINX_CONF_DIR/nginx.conf" << EOF
user $NGINX_USER;
worker_processes auto;
worker_rlimit_nofile 65535;
pid /run/nginx.pid;

events {
    worker_connections 4096;
    use epoll;
    multi_accept on;
}

http {
    # Lua package path
    lua_package_path "/usr/local/share/lua/5.1/?.lua;;";
    
    # Redis connection pool
    lua_shared_dict redis_cache 10m;
    
    # Basic settings
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    keepalive_requests 1000;
    types_hash_max_size 2048;
    client_max_body_size 16M;
    
    # Gzip compression
    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types
        text/plain
        text/css
        text/xml
        text/javascript
        application/json
        application/javascript
        application/xml+rss
        application/atom+xml;
    
    include /etc/nginx/mime.types;
    default_type application/octet-stream;
    
    # Logging
    log_format main '\$remote_addr - \$remote_user [\$time_local] "\$request" '
                    '\$status \$body_bytes_sent "\$http_referer" '
                    '"\$http_user_agent" rt=\$request_time';
    
    access_log /var/log/nginx/access.log main;
    error_log /var/log/nginx/error.log warn;
    
    include /etc/nginx/conf.d/*.conf;
    $([ "$USE_SITES_AVAILABLE" = true ] && echo "include /etc/nginx/sites-enabled/*;")
}
EOF
    
    log_info "Nginx main configuration updated"
}

# Create virtual host
create_vhost() {
    echo "[5/7] Creating Redis cache virtual host..."
    
    if [[ "$USE_SITES_AVAILABLE" = true ]]; then
        VHOST_FILE="$NGINX_SITES_DIR/redis-cache"
    else
        VHOST_FILE="$NGINX_SITES_DIR/redis-cache.conf"
    fi
    
    cat > "$VHOST_FILE" << EOF
server {
    listen 80;
    server_name $DOMAIN www.$DOMAIN;
    
    location / {
        set \$cache_key "\$scheme\$request_method\$host\$request_uri";
        
        content_by_lua_block {
            local redis = require "resty.redis"
            local red = redis:new()
            
            red:set_timeout(1000)
            
            local ok, err = red:connect("127.0.0.1", 6379)
            if not ok then
                ngx.log(ngx.ERR, "Failed to connect to Redis: ", err)
                return ngx.exit(500)
            end
            
            local cache_key = ngx.var.cache_key
            local res, err = red:get(cache_key)
            
            if res ~= ngx.null then
                ngx.header["X-Cache"] = "HIT"
                ngx.say(res)
                return
            end
            
            ngx.header["X-Cache"] = "MISS"
            local content = "Hello from Redis-cached Nginx! Time: " .. ngx.time()
            
            red:setex(cache_key, 300, content)
            red:close()
            
            ngx.say(content)
        }
    }
}
EOF
    
    chmod 644 "$VHOST_FILE"
    chown root:root "$VHOST_FILE"
    
    if [[ "$USE_SITES_AVAILABLE" = true ]]; then
        ln -sf "$VHOST_FILE" "$NGINX_ENABLED_DIR/"
    fi
    
    log_info "Virtual host created successfully"
}

# Start services
start_services() {
    echo "[6/7] Starting services..."
    
    systemctl enable redis-server redis 2>/dev/null || systemctl enable redis
    systemctl enable nginx
    
    systemctl restart redis-server redis 2>/dev/null || systemctl restart redis
    systemctl restart nginx
    
    log_info "Services started successfully"
}

# Verify installation
verify_installation() {
    echo "[7/7] Verifying installation..."
    
    # Check services
    if ! systemctl is-active --quiet nginx; then
        log_error "Nginx is not running"
        exit 1
    fi
    
    if ! systemctl is-active --quiet redis-server && ! systemctl is-active --quiet redis; then
        log_error "Redis is not running"
        exit 1
    fi
    
    # Test Redis connection
    if ! redis-cli ping >/dev/null 2>&1; then
        log_error "Cannot connect to Redis"
        exit 1
    fi
    
    # Test Nginx configuration
    if ! nginx -t >/dev/null 2>&1; then
        log_error "Nginx configuration test failed"
        exit 1
    fi
    
    log_info "Installation verified successfully"
    log_info "Redis + Nginx cache setup complete for domain: $DOMAIN"
    log_info "Test your setup with: curl -H 'Host: $DOMAIN' http://localhost/"
}

# Main execution
main() {
    check_prerequisites "$@"
    detect_distro
    install_packages
    install_lua_redis
    configure_redis
    configure_nginx
    create_vhost
    start_services
    verify_installation
}

main "$@"