Перейти к основному содержимому

Скрипт автоматической настройки Nginx

Автоматизированный скрипт для создания и настройки виртуальных хостов Nginx с расширенными возможностями.

Расширенный скрипт nginx-site-manager.sh​

#!/bin/bash

# Цвета для вывода
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

# Конфигурация
NGINX_SITES_AVAILABLE="/etc/nginx/sites-available"
NGINX_SITES_ENABLED="/etc/nginx/sites-enabled"
NGINX_CONF_DIR="/etc/nginx/conf.d"
WEB_ROOT="/var/www"
SSL_DIR="/etc/ssl/certs"
BACKUP_DIR="/etc/nginx/backups"
LOG_FILE="/var/log/nginx-manager.log"

# Создание необходимых директорий
mkdir -p "$BACKUP_DIR"
touch "$LOG_FILE"

# Функции для вывода
print_error() {
    echo -e "${RED}[ERROR]${NC} $1" >&2
    echo "$(date): ERROR: $1" >> "$LOG_FILE"
}

print_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
    echo "$(date): SUCCESS: $1" >> "$LOG_FILE"
}

print_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
    echo "$(date): WARNING: $1" >> "$LOG_FILE"
}

print_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
    echo "$(date): INFO: $1" >> "$LOG_FILE"
}

print_header() {
    echo -e "${CYAN}===================================================${NC}"
    echo -e "${CYAN}$1${NC}"
    echo -e "${CYAN}===================================================${NC}"
}

# Функция логирования
log_action() {
    echo "$(date): ACTION: $1" >> "$LOG_FILE"
}

# Проверка прав root
check_root() {
    if [ "$EUID" -ne 0 ]; then
        print_error "Этот скрипт должен запускаться с правами root"
        exit 1
    fi
}

# Проверка установки Nginx
check_nginx() {
    if ! command -v nginx >/dev/null 2>&1; then
        print_error "Nginx не установлен"
        read -p "Установить Nginx? (y/n): " install_nginx
        if [ "$install_nginx" = "y" ]; then
            install_nginx
        else
            exit 1
        fi
    fi
}

# Установка Nginx
install_nginx() {
    print_info "Установка Nginx..."

    if command -v apt >/dev/null 2>&1; then
        apt update
        apt install -y nginx
    elif command -v yum >/dev/null 2>&1; then
        yum install -y nginx
    else
        print_error "Неподдерживаемая система пакетов"
        exit 1
    fi

    systemctl enable nginx
    systemctl start nginx
    print_success "Nginx установлен и запущен"
}

# Создание простого сайта
create_simple_site() {
    local domain="$1"
    local web_root="$WEB_ROOT/$domain"
    local config_file="$NGINX_SITES_AVAILABLE/$domain"

    print_info "Создание простого сайта для $domain..."

    # Создание директории сайта
    mkdir -p "$web_root"

    # Создание индексной страницы
    cat > "$web_root/index.html" << EOF
<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Добро пожаловать на $domain</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; background: #f5f5f5; }
        .container { max-width: 800px; margin: 0 auto; background: white; padding: 40px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
        h1 { color: #333; text-align: center; }
        .info { background: #e7f3ff; padding: 20px; border-radius: 5px; margin: 20px 0; }
    </style>
</head>
<body>
    <div class="container">
        <h1>🎉 Сайт $domain успешно настроен!</h1>
        <div class="info">
            <p><strong>Домен:</strong> $domain</p>
            <p><strong>Корневая директория:</strong> $web_root</p>
            <p><strong>Дата создания:</strong> $(date)</p>
        </div>
        <p>Теперь вы можете загрузить свои файлы в директорию <code>$web_root</code></p>
    </div>
</body>
</html>
EOF

    # Создание конфигурации Nginx
    cat > "$config_file" << EOF
server {
    listen 80;
    server_name $domain www.$domain;

    root $web_root;
    index index.html index.htm index.php;

    # Логи
    access_log /var/log/nginx/${domain}_access.log;
    error_log /var/log/nginx/${domain}_error.log;

    # Основная обработка запросов
    location / {
        try_files \$uri \$uri/ =404;
    }

    # PHP обработка (если нужно)
    # location ~ \.php$ {
    #     include snippets/fastcgi-php.conf;
    #     fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
    # }

    # Запрет доступа к .htaccess файлам
    location ~ /\.ht {
        deny all;
    }

    # Оптимизация статических файлов
    location ~* \.(css|js|png|jpg|jpeg|gif|ico|svg)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
    }
}
EOF

    # Установка прав доступа
    chown -R www-data:www-data "$web_root"
    chmod -R 755 "$web_root"

    print_success "Простой сайт создан: $config_file"
}

# Создание SSL сайта
create_ssl_site() {
    local domain="$1"
    local web_root="$WEB_ROOT/$domain"
    local config_file="$NGINX_SITES_AVAILABLE/$domain"

    print_info "Создание SSL сайта для $domain..."

    # Создание директории сайта
    mkdir -p "$web_root"

    # Создание индексной страницы
    cat > "$web_root/index.html" << EOF
<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>🔒 Безопасный сайт $domain</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; }
        .container { max-width: 800px; margin: 0 auto; background: rgba(255,255,255,0.1); padding: 40px; border-radius: 15px; backdrop-filter: blur(10px); }
        h1 { text-align: center; margin-bottom: 30px; }
        .ssl-info { background: rgba(76, 175, 80, 0.2); padding: 20px; border-radius: 10px; margin: 20px 0; border-left: 4px solid #4CAF50; }
        .warning { background: rgba(255, 152, 0, 0.2); padding: 15px; border-radius: 5px; border-left: 4px solid #FF9800; }
    </style>
</head>
<body>
    <div class="container">
        <h1>🔒 SSL сайт $domain готов!</h1>
        <div class="ssl-info">
            <h3>✅ SSL конфигурация готова</h3>
            <p><strong>Домен:</strong> $domain</p>
            <p><strong>Корневая директория:</strong> $web_root</p>
            <p><strong>SSL статус:</strong> Настроен (требуется сертификат)</p>
        </div>
        <div class="warning">
            <h4>⚠️ Следующие шаги:</h4>
            <ol>
                <li>Получите SSL сертификат с помощью Certbot</li>
                <li>Обновите пути к сертификатам в конфигурации</li>
                <li>Перезагрузите Nginx</li>
            </ol>
        </div>
    </div>
</body>
</html>
EOF

    # Создание SSL конфигурации
    cat > "$config_file" << EOF
# Редирект с HTTP на HTTPS
server {
    listen 80;
    server_name $domain www.$domain;
    return 301 https://\$server_name\$request_uri;
}

# HTTPS сервер
server {
    listen 443 ssl http2;
    server_name $domain www.$domain;

    root $web_root;
    index index.html index.htm index.php;

    # SSL сертификаты (обновите пути после получения сертификата)
    ssl_certificate /etc/letsencrypt/live/$domain/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/$domain/privkey.pem;

    # SSL настройки
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers off;

    # SSL оптимизация
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 1d;
    ssl_session_tickets off;

    # OCSP Stapling
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_trusted_certificate /etc/letsencrypt/live/$domain/chain.pem;
    resolver 8.8.8.8 8.8.4.4 valid=300s;

    # Заголовки безопасности
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header X-Frame-Options DENY always;
    add_header X-Content-Type-Options nosniff always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header Referrer-Policy "strict-origin-when-cross-origin" always;

    # Логи
    access_log /var/log/nginx/${domain}_ssl_access.log;
    error_log /var/log/nginx/${domain}_ssl_error.log;

    # Основная обработка запросов
    location / {
        try_files \$uri \$uri/ =404;
    }

    # PHP обработка
    # location ~ \.php$ {
    #     include snippets/fastcgi-php.conf;
    #     fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
    # }

    # Запрет доступа к скрытым файлам
    location ~ /\. {
        deny all;
        access_log off;
        log_not_found off;
    }

    # Оптимизация статических файлов
    location ~* \.(css|js|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
        add_header X-Content-Type-Options nosniff;
    }
}
EOF

    # Установка прав доступа
    chown -R www-data:www-data "$web_root"
    chmod -R 755 "$web_root"

    print_success "SSL сайт создан: $config_file"
    print_warning "Не забудьте получить SSL сертификат с помощью: certbot --nginx -d $domain"
}

# Создание обратного прокси
create_reverse_proxy() {
    local domain="$1"
    local backend_url="$2"
    local config_file="$NGINX_SITES_AVAILABLE/$domain"

    print_info "Создание обратного прокси для $domain -> $backend_url..."

    cat > "$config_file" << EOF
server {
    listen 80;
    server_name $domain www.$domain;

    # Логи
    access_log /var/log/nginx/${domain}_proxy_access.log;
    error_log /var/log/nginx/${domain}_proxy_error.log;

    # Обратный прокси
    location / {
        proxy_pass $backend_url;
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection 'upgrade';
        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;
        proxy_cache_bypass \$http_upgrade;

        # Таймауты
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;

        # Буферизация
        proxy_buffering on;
        proxy_buffer_size 4k;
        proxy_buffers 8 4k;
    }

    # Обработка статических файлов (если нужно)
    # location /static/ {
    #     alias /var/www/$domain/static/;
    #     expires 1y;
    #     add_header Cache-Control "public, immutable";
    # }
}
EOF

    print_success "Обратный прокси создан: $config_file"
}

# Создание конфигурации для Node.js приложения
create_nodejs_app() {
    local domain="$1"
    local port="$2"
    local app_dir="$3"
    local config_file="$NGINX_SITES_AVAILABLE/$domain"

    print_info "Создание конфигурации для Node.js приложения $domain:$port..."

    cat > "$config_file" << EOF
server {
    listen 80;
    server_name $domain www.$domain;

    # Логи
    access_log /var/log/nginx/${domain}_nodejs_access.log;
    error_log /var/log/nginx/${domain}_nodejs_error.log;

    # Главное приложение
    location / {
        proxy_pass http://127.0.0.1:$port;
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection 'upgrade';
        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;
        proxy_cache_bypass \$http_upgrade;

        # Таймауты для Node.js
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
    }

    # WebSocket поддержка
    location /socket.io/ {
        proxy_pass http://127.0.0.1:$port;
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection "upgrade";
        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 /public/ {
        alias $app_dir/public/;
        expires 1y;
        add_header Cache-Control "public, immutable";
    }

    # API endpoint с увеличенным таймаутом
    location /api/ {
        proxy_pass http://127.0.0.1:$port;
        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;

        # Увеличенные таймауты для API
        proxy_connect_timeout 120s;
        proxy_send_timeout 120s;
        proxy_read_timeout 120s;
    }
}
EOF

    print_success "Node.js конфигурация создана: $config_file"
}

# Включение сайта
enable_site() {
    local domain="$1"
    local config_file="$NGINX_SITES_AVAILABLE/$domain"
    local enabled_link="$NGINX_SITES_ENABLED/$domain"

    if [ ! -f "$config_file" ]; then
        print_error "Конфигурация $config_file не найдена"
        return 1
    fi

    # Создание символической ссылки
    ln -sf "$config_file" "$enabled_link"

    # Проверка конфигурации
    if nginx -t >/dev/null 2>&1; then
        systemctl reload nginx
        print_success "Сайт $domain включен и Nginx перезагружен"
    else
        print_error "Ошибка в конфигурации Nginx"
        nginx -t
        rm -f "$enabled_link"
        return 1
    fi
}

# Отключение сайта
disable_site() {
    local domain="$1"
    local enabled_link="$NGINX_SITES_ENABLED/$domain"

    if [ -L "$enabled_link" ]; then
        rm "$enabled_link"
        systemctl reload nginx
        print_success "Сайт $domain отключен"
    else
        print_warning "Сайт $domain не был включен"
    fi
}

# Удаление сайта
remove_site() {
    local domain="$1"
    local config_file="$NGINX_SITES_AVAILABLE/$domain"
    local enabled_link="$NGINX_SITES_ENABLED/$domain"
    local web_root="$WEB_ROOT/$domain"

    read -p "Вы уверены, что хотите удалить сайт $domain? (y/N): " confirm
    if [ "$confirm" != "y" ]; then
        print_info "Отменено"
        return 0
    fi

    # Отключение сайта
    if [ -L "$enabled_link" ]; then
        rm "$enabled_link"
    fi

    # Удаление конфигурации
    if [ -f "$config_file" ]; then
        rm "$config_file"
        print_success "Конфигурация удалена: $config_file"
    fi

    # Удаление файлов сайта (опционально)
    if [ -d "$web_root" ]; then
        read -p "Удалить файлы сайта в $web_root? (y/N): " remove_files
        if [ "$remove_files" = "y" ]; then
            rm -rf "$web_root"
            print_success "Файлы сайта удалены: $web_root"
        fi
    fi

    systemctl reload nginx
    print_success "Сайт $domain полностью удален"
}

# Автоматическая настройка Let's Encrypt
setup_letsencrypt() {
    local domain="$1"

    print_info "Настройка Let's Encrypt для $domain..."

    # Проверка установки Certbot
    if ! command -v certbot >/dev/null 2>&1; then
        print_warning "Certbot не установлен. Устанавливаю..."

        if command -v apt >/dev/null 2>&1; then
            apt update
            apt install -y certbot python3-certbot-nginx
        elif command -v yum >/dev/null 2>&1; then
            yum install -y certbot python3-certbot-nginx
        else
            print_error "Не удалось установить Certbot"
            return 1
        fi
    fi

    # Получение SSL сертификата
    print_info "Получение SSL сертификата для $domain..."

    if certbot --nginx -d "$domain" -d "www.$domain" --non-interactive --agree-tos --email "admin@$domain"; then
        print_success "SSL сертификат успешно установлен для $domain"

        # Настройка автоматического обновления
        setup_certbot_renewal

        return 0
    else
        print_error "Не удалось получить SSL сертификат для $domain"
        return 1
    fi
}

# Настройка автоматического обновления сертификатов
setup_certbot_renewal() {
    local cron_job="0 12 * * * /usr/bin/certbot renew --quiet"

    if ! crontab -l 2>/dev/null | grep -q "certbot renew"; then
        (crontab -l 2>/dev/null; echo "$cron_job") | crontab -
        print_success "Автоматическое обновление сертификатов настроено"
    fi
}

# Создание конфигурации с оптимизацией производительности
create_performance_site() {
    local domain="$1"
    local web_root="$WEB_ROOT/$domain"
    local config_file="$NGINX_SITES_AVAILABLE/$domain"

    print_info "Создание высокопроизводительного сайта для $domain..."

    # Создание директории сайта
    mkdir -p "$web_root"

    # Создание конфигурации с оптимизациями
    cat > "$config_file" << EOF
# Конфигурация для $domain с оптимизацией производительности
server {
    listen 80;
    listen [::]:80;
    server_name $domain www.$domain;

    # Редирект на HTTPS
    return 301 https://\$server_name\$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name $domain www.$domain;

    root $web_root;
    index index.html index.htm index.php;

    # SSL конфигурация (будет настроена Certbot)
    # ssl_certificate /path/to/cert;
    # ssl_certificate_key /path/to/key;

    # Современные SSL настройки
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers off;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;

    # HSTS заголовок
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

    # Безопасность заголовков
    add_header X-Frame-Options DENY always;
    add_header X-Content-Type-Options nosniff always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header Referrer-Policy "strict-origin-when-cross-origin" always;

    # Логи
    access_log /var/log/nginx/${domain}_access.log combined buffer=16k flush=2m;
    error_log /var/log/nginx/${domain}_error.log warn;

    # Основная обработка запросов
    location / {
        try_files \$uri \$uri/ =404;

        # Кэширование для статических файлов
        location ~* \.(css|js|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
            expires 1y;
            add_header Cache-Control "public, immutable";
            add_header Vary Accept-Encoding;

            # Gzip сжатие
            gzip on;
            gzip_vary on;
            gzip_min_length 1024;
            gzip_types
                text/plain
                text/css
                text/xml
                text/javascript
                application/javascript
                application/xml+rss
                application/json;
        }
    }

    # PHP обработка с оптимизацией
    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
        fastcgi_cache_valid 200 60m;
        fastcgi_cache_valid 404 10m;
    }

    # Запрет доступа к служебным файлам
    location ~ /\.(ht|git|svn) {
        deny all;
    }

    # Лимиты запросов
    location /api/ {
        limit_req zone=api burst=10 nodelay;
        proxy_pass http://backend;
    }
}

# Upstream для бэкенда (если нужно)
upstream backend {
    least_conn;
    server 127.0.0.1:3000 max_fails=3 fail_timeout=30s;
    server 127.0.0.1:3001 max_fails=3 fail_timeout=30s backup;
}
EOF

    # Создание красивой индексной страницы
    cat > "$web_root/index.html" << EOF
<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>⚡ Высокопроизводительный сайт $domain</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            display: flex;
            align-items: center;
            justify-content: center;
        }
        .container {
            max-width: 900px;
            background: rgba(255,255,255,0.95);
            padding: 50px;
            border-radius: 20px;
            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
            backdrop-filter: blur(10px);
            text-align: center;
        }
        h1 { color: #333; margin-bottom: 30px; font-size: 2.5em; }
        .features { display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 20px; margin: 30px 0; }
        .feature { background: #f8f9fa; padding: 20px; border-radius: 10px; border-left: 4px solid #667eea; }
        .feature h3 { color: #667eea; margin-bottom: 10px; }
        .stats { background: #e8f5e8; padding: 20px; border-radius: 10px; margin: 20px 0; }
        .badge { display: inline-block; background: #28a745; color: white; padding: 5px 15px; border-radius: 20px; margin: 5px; }
    </style>
</head>
<body>
    <div class="container">
        <h1>⚡ Сайт $domain готов к работе!</h1>

        <div class="stats">
            <h3>📊 Информация о конфигурации</h3>
            <div class="badge">HTTP/2 включен</div>
            <div class="badge">Gzip сжатие</div>
            <div class="badge">SSL готов</div>
            <div class="badge">Кэширование настроено</div>
        </div>

        <div class="features">
            <div class="feature">
                <h3>🚀 Производительность</h3>
                <p>HTTP/2, Gzip сжатие, кэширование статических файлов</p>
            </div>
            <div class="feature">
                <h3>🔒 Безопасность</h3>
                <p>HTTPS, HSTS, защитные заголовки</p>
            </div>
            <div class="feature">
                <h3>📱 Адаптивность</h3>
                <p>Оптимизация для всех устройств</p>
            </div>
        </div>

        <p><strong>Домен:</strong> $domain</p>
        <p><strong>Корневая директория:</strong> $web_root</p>
        <p><strong>Дата создания:</strong> $(date)</p>
    </div>
</body>
</html>
EOF

    # Установка прав доступа
    chown -R www-data:www-data "$web_root"
    chmod -R 755 "$web_root"

    print_success "Высокопроизводительный сайт создан: $config_file"
}

# Мониторинг Nginx
monitor_nginx() {
    print_header "МОНИТОРИНГ NGINX"

    echo -e "${BLUE}Статус сервиса:${NC}"
    systemctl status nginx --no-pager

    echo -e "\n${BLUE}Активные соединения:${NC}"
    ss -tulpn | grep :80
    ss -tulpn | grep :443

    echo -e "\n${BLUE}Использование памяти:${NC}"
    ps aux | grep nginx | grep -v grep

    echo -e "\n${BLUE}Последние ошибки:${NC}"
    tail -10 /var/log/nginx/error.log

    echo -e "\n${BLUE}Топ посещаемых страниц:${NC}"
    awk '{print $7}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -10
}

# Создание резервной копии
backup_nginx_config() {
    local backup_name="nginx_backup_$(date +%Y%m%d_%H%M%S)"
    local backup_path="$BACKUP_DIR/$backup_name"

    print_info "Создание резервной копии конфигурации Nginx..."

    mkdir -p "$backup_path"

    # Копирование конфигураций
    cp -r /etc/nginx/* "$backup_path/"

    # Создание архива
    tar -czf "$backup_path.tar.gz" -C "$BACKUP_DIR" "$backup_name"
    rm -rf "$backup_path"

    print_success "Резервная копия создана: $backup_path.tar.gz"
}

# Восстановление из резервной копии
restore_nginx_config() {
    print_info "Доступные резервные копии:"
    ls -la "$BACKUP_DIR"/*.tar.gz 2>/dev/null

    read -p "Введите имя файла резервной копии: " backup_file

    if [ ! -f "$BACKUP_DIR/$backup_file" ]; then
        print_error "Файл резервной копии не найден"
        return 1
    fi

    read -p "Вы уверены, что хотите восстановить конфигурацию? (y/N): " confirm
    if [ "$confirm" != "y" ]; then
        print_info "Отменено"
        return 0
    fi

    # Создание текущей резервной копии
    backup_nginx_config

    # Восстановление
    systemctl stop nginx
    rm -rf /etc/nginx/*
    tar -xzf "$BACKUP_DIR/$backup_file" -C /etc/nginx --strip-components=1

    if nginx -t; then
        systemctl start nginx
        print_success "Конфигурация восстановлена успешно"
    else
        print_error "Ошибка в восстановленной конфигурации"
        nginx -t
    fi
}

# Интерактивное меню
show_menu() {
    clear
    print_header "NGINX SITE MANAGER"

    echo -e "${CYAN}Выберите действие:${NC}"
    echo "1.  Создать простой сайт"
    echo "2.  Создать SSL сайт"
    echo "3.  Создать высокопроизводительный сайт"
    echo "4.  Создать прокси для Node.js приложения"
    echo "5.  Настроить Let's Encrypt SSL"
    echo "6.  Включить сайт"
    echo "7.  Отключить сайт"
    echo "8.  Удалить сайт"
    echo "9.  Показать список сайтов"
    echo "10. Мониторинг Nginx"
    echo "11. Создать резервную копию"
    echo "12. Восстановить из резервной копии"
    echo "13. Проверить конфигурацию"
    echo "14. Перезагрузить Nginx"
    echo "0.  Выход"
    echo
}

# Список сайтов
list_sites() {
    print_header "СПИСОК САЙТОВ"

    echo -e "${BLUE}Доступные сайты:${NC}"
    ls -la "$NGINX_SITES_AVAILABLE" | grep -v "^total\|^d"

    echo -e "\n${GREEN}Включенные сайты:${NC}"
    ls -la "$NGINX_SITES_ENABLED" | grep -v "^total\|^d"
}

# Проверка конфигурации
check_config() {
    print_info "Проверка конфигурации Nginx..."

    if nginx -t; then
        print_success "Конфигурация корректна"
    else
        print_error "Найдены ошибки в конфигурации"
    fi
}

# Перезагрузка Nginx
reload_nginx() {
    print_info "Перезагрузка Nginx..."

    if nginx -t; then
        systemctl reload nginx
        print_success "Nginx перезагружен успешно"
    else
        print_error "Ошибка в конфигурации. Перезагрузка отменена"
        nginx -t
    fi
}

# Основная функция
main() {
    check_root
    check_nginx

    case "${1:-interactive}" in
        "create-simple")
            if [ -z "$2" ]; then
                print_error "Использование: $0 create-simple <domain>"
                exit 1
            fi
            create_simple_site "$2"
            ;;
        "create-ssl")
            if [ -z "$2" ]; then
                print_error "Использование: $0 create-ssl <domain>"
                exit 1
            fi
            create_ssl_site "$2"
            ;;
        "create-proxy")
            if [ -z "$2" ] || [ -z "$3" ]; then
                print_error "Использование: $0 create-proxy <domain> <backend_url>"
                exit 1
            fi
            create_reverse_proxy "$2" "$3"
            ;;
        "create-nodejs")
            if [ -z "$2" ] || [ -z "$3" ]; then
                print_error "Использование: $0 create-nodejs <domain> <port> [app_dir]"
                exit 1
            fi
            create_nodejs_app "$2" "$3" "${4:-/var/www/$2}"
            ;;
        "enable")
            if [ -z "$2" ]; then
                print_error "Использование: $0 enable <domain>"
                exit 1
            fi
            enable_site "$2"
            ;;
        "disable")
            if [ -z "$2" ]; then
                print_error "Использование: $0 disable <domain>"
                exit 1
            fi
            disable_site "$2"
            ;;
        "remove")
            if [ -z "$2" ]; then
                print_error "Использование: $0 remove <domain>"
                exit 1
            fi
            remove_site "$2"
            ;;
        "list")
            list_sites
            ;;
        "ssl")
            if [ -z "$2" ]; then
                print_error "Использование: $0 ssl <domain>"
                exit 1
            fi
            get_ssl_certificate "$2"
            ;;
        "help"|"-h"|"--help")
            show_help
            ;;
        "interactive"|"")
            interactive_mode
            ;;
        *)
            print_error "Неизвестная команда: $1"
            show_help
            exit 1
            ;;
    esac
}

# Запуск скрипта
main "$@"

Дополнительные утилиты​

Скрипт проверки конфигурации​

#!/bin/bash
# nginx-config-check.sh

print_info() {
    echo -e "\033[0;34m[INFO]\033[0m $1"
}

print_success() {
    echo -e "\033[0;32m[SUCCESS]\033[0m $1"
}

print_error() {
    echo -e "\033[0;31m[ERROR]\033[0m $1"
}

check_nginx_config() {
    print_info "Проверка конфигурации Nginx..."

    if nginx -t 2>/dev/null; then
        print_success "Конфигурация Nginx корректна"
        return 0
    else
        print_error "Ошибки в конфигурации Nginx:"
        nginx -t
        return 1
    fi
}

check_ssl_certificates() {
    print_info "Проверка SSL сертификатов..."

    for site_config in /etc/nginx/sites-enabled/*; do
        if [ -f "$site_config" ]; then
            site_name=$(basename "$site_config")

            # Извлечение путей к сертификатам
            ssl_cert=$(grep -o 'ssl_certificate [^;]*' "$site_config" | head -1 | awk '{print $2}')
            ssl_key=$(grep -o 'ssl_certificate_key [^;]*' "$site_config" | head -1 | awk '{print $2}')

            if [ -n "$ssl_cert" ] && [ -n "$ssl_key" ]; then
                if [ -f "$ssl_cert" ] && [ -f "$ssl_key" ]; then
                    # Проверка срока действия
                    expiry_date=$(openssl x509 -enddate -noout -in "$ssl_cert" | cut -d= -f2)
                    expiry_epoch=$(date -d "$expiry_date" +%s)
                    current_epoch=$(date +%s)
                    days_left=$(( (expiry_epoch - current_epoch) / 86400 ))

                    if [ $days_left -gt 30 ]; then
                        print_success "$site_name: SSL сертификат действителен ($days_left дней)"
                    elif [ $days_left -gt 0 ]; then
                        print_error "$site_name: SSL сертификат истекает через $days_left дней!"
                    else
                        print_error "$site_name: SSL сертификат истек!"
                    fi
                else
                    print_error "$site_name: SSL файлы не найдены"
                fi
            fi
        fi
    done
}

check_log_files() {
    print_info "Проверка лог файлов..."

    nginx_log_dir="/var/log/nginx"

    if [ -d "$nginx_log_dir" ]; then
        log_size=$(du -sh "$nginx_log_dir" | cut -f1)
        print_info "Размер логов: $log_size"

        # Проверка больших лог файлов
        large_logs=$(find "$nginx_log_dir" -size +100M -type f)
        if [ -n "$large_logs" ]; then
            print_error "Найдены большие лог файлы:"
            echo "$large_logs" | while read -r log_file; do
                size=$(du -sh "$log_file" | cut -f1)
                echo "  $log_file ($size)"
            done
        else
            print_success "Размер лог файлов в норме"
        fi
    else
        print_error "Директория логов не найдена: $nginx_log_dir"
    fi
}

check_nginx_status() {
    print_info "Проверка статуса Nginx..."

    if systemctl is-active --quiet nginx; then
        print_success "Nginx запущен"
    else
        print_error "Nginx не запущен"
        return 1
    fi

    if systemctl is-enabled --quiet nginx; then
        print_success "Nginx включен в автозагрузку"
    else
        print_error "Nginx не включен в автозагрузку"
    fi
}

main() {
    echo "╔════════════════════════════════════════╗"
    echo "║       Проверка конфигурации Nginx      ║"
    echo "╚════════════════════════════════════════╝"
    echo ""

    check_nginx_status
    echo ""

    check_nginx_config
    echo ""

    check_ssl_certificates
    echo ""

    check_log_files
    echo ""

    print_info "Проверка завершена"
}

main "$@"

Скрипт резервного копирования конфигураций​

#!/bin/bash
# nginx-backup.sh

BACKUP_DIR="/backup/nginx"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_NAME="nginx_config_backup_$DATE.tar.gz"

print_info() {
    echo -e "\033[0;34m[INFO]\033[0m $1"
}

print_success() {
    echo -e "\033[0;32m[SUCCESS]\033[0m $1"
}

print_error() {
    echo -e "\033[0;31m[ERROR]\033[0m $1"
}

create_backup() {
    print_info "Создание резервной копии конфигураций Nginx..."

    mkdir -p "$BACKUP_DIR"

    tar -czf "$BACKUP_DIR/$BACKUP_NAME" \
        /etc/nginx/ \
        /var/www/ \
        --exclude="/var/www/*/logs" \
        --exclude="/var/www/*/tmp" \
        2>/dev/null

    if [ $? -eq 0 ]; then
        backup_size=$(du -h "$BACKUP_DIR/$BACKUP_NAME" | cut -f1)
        print_success "Бэкап создан: $BACKUP_DIR/$BACKUP_NAME ($backup_size)"
    else
        print_error "Ошибка при создании бэкапа"
        return 1
    fi
}

restore_backup() {
    local backup_file="$1"

    if [ ! -f "$backup_file" ]; then
        print_error "Файл бэкапа не найден: $backup_file"
        return 1
    fi

    print_info "Восстановление из бэкапа: $backup_file"

    read -p "Вы уверены? Это перезапишет текущие конфигурации (y/N): " confirm
    if [ "$confirm" != "y" ]; then
        print_info "Отменено"
        return 0
    fi

    tar -xzf "$backup_file" -C / 2>/dev/null

    if [ $? -eq 0 ]; then
        nginx -t && systemctl reload nginx
        print_success "Восстановление завершено"
    else
        print_error "Ошибка при восстановлении"
        return 1
    fi
}

list_backups() {
    print_info "Доступные бэкапы:"

    if [ -d "$BACKUP_DIR" ]; then
        ls -lh "$BACKUP_DIR"/nginx_config_backup_*.tar.gz 2>/dev/null | \
        awk '{print "  " $9 " (" $5 ", " $6 " " $7 " " $8 ")"}'
    else
        print_error "Директория бэкапов не найдена: $BACKUP_DIR"
    fi
}

cleanup_old_backups() {
    local retention_days="${1:-30}"

    print_info "Очистка бэкапов старше $retention_days дней..."

    find "$BACKUP_DIR" -name "nginx_config_backup_*.tar.gz" -mtime +$retention_days -type f | while read -r old_backup; do
        if [ -f "$old_backup" ]; then
            rm "$old_backup"
            print_info "Удален старый бэкап: $(basename "$old_backup")"
        fi
    done
}

case "${1:-backup}" in
    "backup")
        create_backup
        ;;
    "restore")
        if [ -z "$2" ]; then
            list_backups
            read -p "Введите имя файла бэкапа: " backup_file
            restore_backup "$BACKUP_DIR/$backup_file"
        else
            restore_backup "$2"
        fi
        ;;
    "list")
        list_backups
        ;;
    "cleanup")
        cleanup_old_backups "${2:-30}"
        ;;
    *)
        echo "Использование: $0 {backup|restore|list|cleanup} [параметры]"
        exit 1
        ;;
esac

Скрипт мониторинга производительности​

#!/bin/bash
# nginx-performance-monitor.sh

# Проверка производительности Nginx
check_nginx_performance() {
    echo "=== МОНИТОРИНГ ПРОИЗВОДИТЕЛЬНОСТИ NGINX ==="

    # Проверка активных соединений
    echo "Активные соединения:"
    curl -s http://localhost/nginx_status 2>/dev/null || echo "Статус модуль не настроен"

    # Статистика процессов
    echo -e "\nПроцессы Nginx:"
    ps aux | grep nginx | grep -v grep | awk '{print $2, $3, $4, $11}'

    # Использование памяти
    echo -e "\nИспользование памяти:"
    pmap $(pgrep nginx) | tail -1

    # Открытые файлы
    echo -e "\nОткрытые файлы:"
    lsof -p $(pgrep nginx | head -1) | wc -l

    # Проверка лимитов
    echo -e "\nТекущие лимиты:"
    cat /proc/$(pgrep nginx | head -1)/limits | grep "open files\|processes"
}

# Анализ логов доступа
analyze_access_logs() {
    local log_file="${1:-/var/log/nginx/access.log}"

    echo "=== АНАЛИЗ ЛОГОВ ДОСТУПА ==="
    echo "Файл: $log_file"

    if [ ! -f "$log_file" ]; then
        echo "Лог файл не найден: $log_file"
        return 1
    fi

    # Топ IP адресов
    echo -e "\nТоп 10 IP адресов:"
    awk '{print $1}' "$log_file" | sort | uniq -c | sort -rn | head -10

    # Топ запрашиваемых страниц
    echo -e "\nТоп 10 запрашиваемых страниц:"
    awk '{print $7}' "$log_file" | sort | uniq -c | sort -rn | head -10

    # Коды ответов
    echo -e "\nСтатистика кодов ответов:"
    awk '{print $9}' "$log_file" | sort | uniq -c | sort -rn

    # User Agent статистика
    echo -e "\nТоп User Agents:"
    awk -F'"' '{print $6}' "$log_file" | sort | uniq -c | sort -rn | head -10

    # Трафик по часам
    echo -e "\nТрафик по часам за последний день:"
    awk '{print $4}' "$log_file" | cut -d: -f2 | sort | uniq -c
}

# Автоматическая ротация логов
setup_log_rotation() {
    cat > /etc/logrotate.d/nginx << EOF
/var/log/nginx/*.log {
    daily
    missingok
    rotate 52
    compress
    delaycompress
    notifempty
    create 0644 www-data www-data
    sharedscripts
    prerotate
        if [ -d /etc/logrotate.d/httpd-prerotate ]; then
            run-parts /etc/logrotate.d/httpd-prerotate
        fi
    endscript
    postrotate
        invoke-rc.d nginx rotate >/dev/null 2>&1
    endscript
}
EOF

    echo "Ротация логов настроена в /etc/logrotate.d/nginx"
}

# Основная функция
main() {
    case "${1:-performance}" in
        "performance"|"perf")
            check_nginx_performance
            ;;
        "logs"|"log")
            analyze_access_logs "$2"
            ;;
        "rotate")
            setup_log_rotation
            ;;
        *)
            echo "Использование: $0 [performance|logs|rotate] [log_file]"
            echo "  performance - проверка производительности"
            echo "  logs [file] - анализ логов доступа"
            echo "  rotate      - настройка ротации логов"
            ;;
    esac
}

if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    main "$@"
fi

Автоматический деплой статических сайтов​

#!/bin/bash
# static-site-deploy.sh

DEPLOY_USER="deployer"
SITES_DIR="/var/www"
BACKUP_DIR="/var/backups/sites"

# Функция деплоя из Git репозитория
deploy_from_git() {
    local domain="$1"
    local git_repo="$2"
    local branch="${3:-main}"
    local site_dir="$SITES_DIR/$domain"
    local temp_dir="/tmp/deploy_$domain"

    echo "Деплой $domain из $git_repo (ветка: $branch)"

    # Создание резервной копии
    if [ -d "$site_dir" ]; then
        echo "Создание резервной копии..."
        mkdir -p "$BACKUP_DIR"
        tar -czf "$BACKUP_DIR/${domain}_$(date +%Y%m%d_%H%M%S).tar.gz" -C "$SITES_DIR" "$domain"
    fi

    # Клонирование репозитория
    echo "Клонирование репозитория..."
    rm -rf "$temp_dir"
    git clone -b "$branch" "$git_repo" "$temp_dir"

    if [ $? -ne 0 ]; then
        echo "Ошибка клонирования репозитория"
        return 1
    fi

    # Сборка проекта (если нужно)
    if [ -f "$temp_dir/package.json" ]; then
        echo "Установка зависимостей и сборка..."
        cd "$temp_dir"
        npm install
        npm run build 2>/dev/null || npm run dist 2>/dev/null || echo "Сборка не требуется"
        cd -
    fi

    # Копирование файлов
    echo "Копирование файлов..."
    mkdir -p "$site_dir"

    # Определение директории с файлами
    if [ -d "$temp_dir/dist" ]; then
        cp -r "$temp_dir/dist/"* "$site_dir/"
    elif [ -d "$temp_dir/build" ]; then
        cp -r "$temp_dir/build/"* "$site_dir/"
    elif [ -d "$temp_dir/public" ]; then
        cp -r "$temp_dir/public/"* "$site_dir/"
    else
        cp -r "$temp_dir/"* "$site_dir/"
    fi

    # Установка прав доступа
    chown -R www-data:www-data "$site_dir"
    chmod -R 755 "$site_dir"

    # Очистка
    rm -rf "$temp_dir"

    echo "Деплой завершен успешно"
}

# Настройка автоматического деплоя через webhook
setup_webhook_deploy() {
    local domain="$1"
    local secret="$2"
    local git_repo="$3"
    local webhook_script="/usr/local/bin/webhook-deploy-$domain.sh"

    # Создание скрипта webhook
    cat > "$webhook_script" << EOF
#!/bin/bash
# Webhook деплой для $domain

LOGFILE="/var/log/webhook-$domain.log"
exec > >(tee -a \$LOGFILE)
exec 2>&1

echo "\$(date): Webhook деплой запущен для $domain"

# Проверка подписи (если указан секрет)
if [ -n "$secret" ]; then
    SIGNATURE=\$(echo -n "\$1" | openssl sha1 -hmac "$secret" -binary | xxd -p)
    if [ "sha1=\$SIGNATURE" != "\$HTTP_X_HUB_SIGNATURE" ]; then
        echo "Неверная подпись webhook"
        exit 1
    fi
fi

# Запуск деплоя
cd /usr/local/bin
./static-site-deploy.sh deploy "$domain" "$git_repo"

echo "\$(date): Webhook деплой завершен для $domain"
EOF

    chmod +x "$webhook_script"

    echo "Webhook скрипт создан: $webhook_script"
    echo "Настройте веб-сервер для обработки POST запросов на /$domain/webhook"
}

# Создание конфигурации для статического сайта с CI/CD
create_static_site_config() {
    local domain="$1"
    local config_file="/etc/nginx/sites-available/$domain"

    cat > "$config_file" << EOF
server {
    listen 80;
    listen [::]:80;
    server_name $domain www.$domain;

    # Редирект на HTTPS
    return 301 https://\$server_name\$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name $domain www.$domain;

    root /var/www/$domain;
    index index.html index.htm;

    # SSL будет настроен автоматически

    # Оптимизация для статических файлов
    location / {
        try_files \$uri \$uri/ /index.html;

        # Кэширование HTML файлов
        location ~* \.(html|htm)$ {
            expires 1h;
            add_header Cache-Control "public, must-revalidate";
        }

        # Долгосрочное кэширование ресурсов
        location ~* \.(css|js|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
            expires 1y;
            add_header Cache-Control "public, immutable";
            add_header Vary Accept-Encoding;
        }
    }

    # Webhook для автоматического деплоя
    location = /$domain/webhook {
        access_log /var/log/nginx/webhook-$domain.log;
        proxy_pass http://127.0.0.1:9000/$domain;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
    }

    # Защита от прямого доступа к системным файлам
    location ~ /\.(git|svn|hg) {
        deny all;
    }

    # Gzip сжатие
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_types
        text/plain
        text/css
        text/xml
        text/javascript
        application/javascript
        application/xml+rss
        application/json
        image/svg+xml;
}
EOF

    echo "Конфигурация статического сайта создана: $config_file"
}

# Основная функция
main() {
    case "$1" in
        "deploy")
            deploy_from_git "$2" "$3" "$4"
            ;;
        "webhook")
            setup_webhook_deploy "$2" "$3" "$4"
            ;;
        "config")
            create_static_site_config "$2"
            ;;
        *)
            echo "Использование: $0 [deploy|webhook|config] [параметры]"
            echo "  deploy <domain> <git_repo> [branch] - деплой из Git"
            echo "  webhook <domain> <secret> <git_repo> - настройка webhook"
            echo "  config <domain> - создание конфигурации статического сайта"
            ;;
    esac
}

if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    main "$@"
fi

Система оповещений о проблемах​

#!/bin/bash
# nginx-alerts.sh

ALERT_EMAIL="admin@example.com"
ALERT_WEBHOOK=""
LOG_FILE="/var/log/nginx-alerts.log"

# Отправка уведомления
send_alert() {
    local subject="$1"
    local message="$2"
    local urgency="${3:-normal}"

    # Логирование
    echo "$(date): ALERT [$urgency]: $subject - $message" >> "$LOG_FILE"

    # Email уведомление
    if [ -n "$ALERT_EMAIL" ] && command -v mail >/dev/null 2>&1; then
        echo "$message" | mail -s "[$urgency] Nginx Alert: $subject" "$ALERT_EMAIL"
    fi

    # Webhook уведомление
    if [ -n "$ALERT_WEBHOOK" ]; then
        curl -X POST "$ALERT_WEBHOOK" \
             -H "Content-Type: application/json" \
             -d "{\"subject\":\"$subject\",\"message\":\"$message\",\"urgency\":\"$urgency\"}" \
             >/dev/null 2>&1
    fi

    # Системные уведомления
    logger "Nginx Alert [$urgency]: $subject - $message"
}

# Проверка доступности сайтов
check_sites_availability() {
    local sites_file="/etc/nginx/monitored-sites.list"

    if [ ! -f "$sites_file" ]; then
        echo "example.com" > "$sites_file"
        echo "Создан файл $sites_file. Добавьте в него домены для мониторинга"
        return
    fi

    while IFS= read -r domain; do
        [ -z "$domain" ] && continue
        [ "${domain:0:1}" = "#" ] && continue

        # HTTP проверка
        if ! curl -f -s -o /dev/null "http://$domain" --max-time 10; then
            send_alert "Site Down" "Сайт $domain недоступен по HTTP" "critical"
        fi

        # HTTPS проверка
        if ! curl -f -s -o /dev/null "https://$domain" --max-time 10; then
            send_alert "SSL Issue" "Проблемы с HTTPS на $domain" "warning"
        fi

        # Проверка времени отклика
        response_time=$(curl -o /dev/null -s -w "%{time_total}" "https://$domain" --max-time 30)
        if (( $(echo "$response_time > 5.0" | bc -l) )); then
            send_alert "Slow Response" "Медленный отклик на $domain: ${response_time}s" "warning"
        fi

    done < "$sites_file"
}

# Проверка статуса Nginx
check_nginx_status() {
    if ! systemctl is-active --quiet nginx; then
        send_alert "Service Down" "Сервис Nginx остановлен" "critical"

        # Попытка автоматического перезапуска
        systemctl start nginx
        if systemctl is-active --quiet nginx; then
            send_alert "Service Recovered" "Сервис Nginx автоматически восстановлен" "normal"
        fi
    fi
}

# Проверка использования ресурсов
check_resource_usage() {
    # Использование CPU
    cpu_usage=$(ps -C nginx -o %cpu= | awk '{sum+=$1} END {print sum}')
    if (( $(echo "$cpu_usage > 80" | bc -l) )); then
        send_alert "High CPU" "Высокое использование CPU Nginx: ${cpu_usage}%" "warning"
    fi

    # Использование памяти
    mem_usage=$(ps -C nginx -o %mem= | awk '{sum+=$1} END {print sum}')
    if (( $(echo "$mem_usage > 80" | bc -l) )); then
        send_alert "High Memory" "Высокое использование памяти Nginx: ${mem_usage}%" "warning"
    fi

    # Проверка дискового пространства для логов
    disk_usage=$(df /var/log | tail -1 | awk '{print $5}' | sed 's/%//')
    if [ "$disk_usage" -gt 85 ]; then
        send_alert "Disk Space" "Мало места для логов: ${disk_usage}% использовано" "warning"
    fi
}

# Анализ ошибок в логах
check_error_logs() {
    local error_log="/var/log/nginx/error.log"
    local last_check_file="/tmp/nginx-alert-last-check"

    if [ ! -f "$last_check_file" ]; then
        date +%s > "$last_check_file"
        return
    fi

    last_check=$(cat "$last_check_file")
    current_time=$(date +%s)

    # Проверка ошибок за последние 5 минут
    recent_errors=$(awk -v start="$last_check" '
        BEGIN { count = 0 }
        {
            # Парсинг времени из лога Nginx
            match($0, /[0-9]{4}\/[0-9]{2}\/[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}/)
            if (RSTART > 0) {
                timestr = substr($0, RSTART, RLENGTH)
                cmd = "date -d \"" timestr "\" +%s"
                cmd | getline timestamp
                close(cmd)

                if (timestamp > start && /\[error\]/) {
                    count++
                }
            }
        }
        END { print count }
    ' "$error_log" 2>/dev/null)

    if [ "$recent_errors" -gt 10 ]; then
        send_alert "Many Errors" "Много ошибок в логах: $recent_errors за последние 5 минут" "warning"
    fi

    echo "$current_time" > "$last_check_file"
}

# Настройка мониторинга
setup_monitoring() {
    # Создание cron задач
    crontab -l 2>/dev/null | grep -v nginx-alerts > /tmp/current_cron

    cat >> /tmp/current_cron << EOF
# Nginx мониторинг
*/5 * * * * /usr/local/bin/nginx-alerts.sh check
0 */6 * * * /usr/local/bin/nginx-alerts.sh resources
EOF

    crontab /tmp/current_cron
    rm /tmp/current_cron

    echo "Мониторинг настроен. Проверки каждые 5 минут."
}

# Основная функция
main() {
    case "$1" in
        "check")
            check_nginx_status
            check_sites_availability
            check_error_logs
            ;;
        "resources")
            check_resource_usage
            ;;
        "setup")
            setup_monitoring
            ;;
        "test")
            send_alert "Test Alert" "Тестовое уведомление системы мониторинга" "normal"
            ;;
        *)
            echo "Использование: $0 [check|resources|setup|test]"
            echo "  check     - проверка статуса и доступности сайтов"
            echo "  resources - проверка использования ресурсов"
            echo "  setup     - настройка автоматического мониторинга"
            echo "  test      - отправка тестового уведомления"
            ;;
    esac
}

if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    main "$@"
fi

Лучшие практики и рекомендации​

Безопасность​

  1. Регулярные обновления

    # Автоматическое обновление Nginx
    echo "0 2 * * 1 apt update && apt upgrade -y nginx" | sudo crontab -

  2. Настройка фаервола

    # UFW правила для Nginx
    sudo ufw allow 'Nginx Full'
    sudo ufw enable

  3. Ограничение доступа к административным страницам

    location /admin {
        allow 192.168.1.0/24;
        deny all;
        auth_basic "Admin Area";
        auth_basic_user_file /etc/nginx/.htpasswd;
    }

Оптимизация производительности​

  1. Настройка worker процессов

    # /etc/nginx/nginx.conf
    worker_processes auto;
    worker_connections 1024;
    worker_rlimit_nofile 2048;

  2. Кэширование

    # Настройка FastCGI кэша
    fastcgi_cache_path /var/cache/nginx levels=1:2 keys_zone=microcache:10m max_size=1g;
    fastcgi_cache_key "$scheme$request_method$host$request_uri";

  3. Rate Limiting

    # Ограничение запросов
    limit_req_zone $binary_remote_addr zone=login:10m rate=1r/s;
    limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;

Мониторинг и логирование​

  1. Кастомный формат логов

    log_format detailed '$remote_addr - $remote_user [$time_local] '
                       '"$request" $status $body_bytes_sent '
                       '"$http_referer" "$http_user_agent" '
                       '$request_time $upstream_response_time';

  2. Интеграция с Prometheus

    # Установка nginx-prometheus-exporter
    wget https://github.com/nginxinc/nginx-prometheus-exporter/releases/download/v0.10.0/nginx-prometheus-exporter_0.10.0_linux_amd64.tar.gz
    tar -xzf nginx-prometheus-exporter_0.10.0_linux_amd64.tar.gz
    sudo mv nginx-prometheus-exporter /usr/local/bin/

Автоматизация DevOps​

  1. Docker интеграция

    # Dockerfile для Nginx с кастомной конфигурацией
    FROM nginx:alpine
    COPY nginx.conf /etc/nginx/nginx.conf
    COPY sites/ /etc/nginx/sites-available/
    RUN nginx -t
    EXPOSE 80 443

  2. Ansible playbook

    # nginx-setup.yml
    - name: Setup Nginx with automation
      hosts: webservers
      become: yes
      tasks:
        - name: Install Nginx
          package:
            name: nginx
            state: present

        - name: Copy automation scripts
          copy:
            src: "{{ item }}"
            dest: /usr/local/bin/
            mode: '0755'
          loop:
            - nginx-site-manager.sh
            - nginx-alerts.sh

  3. GitHub Actions для деплоя

    # .github/workflows/deploy.yml
    name: Deploy to Nginx
    on:
      push:
        branches: [main]

    jobs:
      deploy:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v2
          - name: Deploy to server
            run: |
              ssh ${{ secrets.SERVER_USER }}@${{ secrets.SERVER_HOST }} \
              "cd /usr/local/bin && ./static-site-deploy.sh deploy ${{ secrets.DOMAIN }} ${{ github.repository_url }}"

Заключение​

Этот набор скриптов обеспечивает полную автоматизацию управления Nginx:

  • Автоматическое создание сайтов любого типа
  • SSL сертификты с Let's Encrypt
  • Мониторинг производительности и доступности
  • Система оповещений о проблемах
  • Автоматический деплой из Git репозиториев
  • Резервное копирование конфигураций

Скрипты готовы к использованию в production среде и могут быть легко адаптированы под ваши конкретные требования.

Поддержка и развитие​

Для обновления скриптов и получения новых функций посетите:

  • Документацию: /docs/scripts/nginx-automation.md
  • Примеры конфигураций: /examples/nginx/
  • Логи: /var/log/nginx-manager.log

Совет: Регулярно создавайте резервные копии с помощью nginx-site-manager.sh backup перед внесением изменений в конфигурацию.