Деплой Next.js с GitLab CI/CD: От настройки сервера до автоматизации

GitLab CI → git pull → npm ci → npm run build → PM2 reload → готово

# Обновление системы
sudo apt update && sudo apt upgrade -y
 
# Установка базовых пакетов
sudo apt install -y git curl ufw fail2ban build-essential
 
# Настройка firewall
sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo ufw enable
sudo ufw status

# 1. Создаем SSH ключ на локальной машине (если еще нет)
# Выполняйте на ЛОКАЛЬНОЙ машине, не на сервере!
ssh-keygen -t ed25519 -C "your_email@example.com"
 
# 2. Копируем публичный ключ на сервер
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@your_server_ip
 
# 3. Проверяем, что можем зайти по ключу
ssh user@your_server_ip
 
# 4. Отключаем вход по паролю (только SSH ключи)
sudo nano /etc/ssh/sshd_config
 
# Найдите и измените эти строки:
# PasswordAuthentication no
# PubkeyAuthentication yes
# PermitRootLogin no
# ChallengeResponseAuthentication no
 
# 5. Перезапускаем SSH
sudo systemctl restart sshd
 
# 6. НЕ ЗАКРЫВАЙТЕ текущую сессию! Откройте новое окно терминала
# и проверьте, что можете зайти по ключу

# Установка (уже установлен выше)
sudo apt install -y fail2ban
 
# Создаем локальную конфигурацию
sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
 
# Настраиваем базовую защиту SSH
sudo tee /etc/fail2ban/jail.local << 'EOF'
[DEFAULT]
bantime = 1h
findtime = 10m
maxretry = 5
destemail = your_email@example.com
sendername = Fail2Ban
 
[sshd]
enabled = true
port = ssh
logpath = %(sshd_log)s
backend = %(sshd_backend)s
EOF
 
# Запускаем Fail2Ban
sudo systemctl enable fail2ban
sudo systemctl start fail2ban
 
# Проверяем статус
sudo fail2ban-client status
sudo fail2ban-client status sshd

# Сбрасываем правила (если нужно начать с чистого листа)
sudo ufw --force reset
 
# Политика по умолчанию: запретить все входящие, разрешить исходящие
sudo ufw default deny incoming
sudo ufw default allow outgoing
 
# Разрешаем SSH (ВАЖНО: сделайте это до enable!)
sudo ufw allow 22/tcp comment 'SSH'
 
# Разрешаем HTTP/HTTPS для NPM или Nginx
sudo ufw allow 80/tcp comment 'HTTP'
sudo ufw allow 443/tcp comment 'HTTPS'
 
# Если используете NPM, разрешаем админку (только для вашего IP!)
# sudo ufw allow from YOUR_IP to any port 81 comment 'NPM Admin'
 
# Ограничение скорости подключений SSH (защита от DDoS)
sudo ufw limit 22/tcp
 
# Включаем firewall
sudo ufw enable
 
# Проверяем правила
sudo ufw status numbered

# Установка Node.js 20 через NodeSource
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs
 
# Проверка версий
node -v  # должно быть >= v20.x
npm -v   # должно быть >= 10.x
 
# Настройка npm для production
npm config set loglevel error

# Установка PM2 глобально
sudo npm install -g pm2
 
# Настройка автозапуска PM2 при перезагрузке
pm2 startup systemd -u $USER --hp $HOME
# Команда выведет строку с sudo: выполните её
 
# Проверка systemd сервиса
sudo systemctl status pm2-$USER

# Создаем директорию для NPM
mkdir -p ~/nginx-proxy-manager
cd ~/nginx-proxy-manager
 
# Создаем docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: '3.8'
services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    restart: unless-stopped
    ports:
      - '80:80'     # HTTP
      - '443:443'   # HTTPS
      - '81:81'     # Admin UI
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    environment:
      DB_SQLITE_FILE: "/data/database.sqlite"
EOF
 
# Запускаем NPM
docker-compose up -d
 
# Проверяем статус
docker-compose ps

# Кастомные настройки для Next.js
location /_next/static/ {
    proxy_cache_valid 200 60m;
    add_header Cache-Control "public, immutable";
}
 
location /api/health {
    access_log off;
}
 
# Таймауты для SSR
proxy_read_timeout 60s;
proxy_connect_timeout 60s;

# /etc/nginx/sites-available/potapov.me
server {
    listen 80;
    server_name potapov.me www.potapov.me;
 
    location / {
        proxy_pass http://localhost:3000;
        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_read_timeout 60s;
    }
}

sudo certbot --nginx -d potapov.me -d www.potapov.me

# Создаем каталог для приложения
sudo mkdir -p /var/www/potapov.me
sudo chown -R $USER:$USER /var/www/potapov.me
 
# Создаем каталоги для логов и бэкапов
mkdir -p /var/www/potapov.me/{logs,backups}
 
# Создаем .env файл (заполним позже через GitLab CI)
touch /var/www/potapov.me/.env

// ecosystem.config.cjs
module.exports = {
  apps: [
    {
      name: "potapov-me",
      cwd: "/var/www/potapov.me",
      script: "node_modules/next/dist/bin/next",
      args: "start -p 3000",
 
      // Environment variables
      env: {
        NODE_ENV: "production",
        PORT: 3000,
      },
 
      // Cluster mode для zero-downtime reload
      exec_mode: "cluster",
      instances: 2, // или 'max' для использования всех CPU ядер
 
      // Auto-restart settings
      autorestart: true,
      max_restarts: 10,
      min_uptime: "10s",
      max_memory_restart: "500M", // Рестарт при превышении памяти
 
      // Logging
      out_file: "./logs/pm2-out.log",
      error_file: "./logs/pm2-error.log",
      log_date_format: "YYYY-MM-DD HH:mm:ss Z",
      merge_logs: true,
 
      // Graceful shutdown
      kill_timeout: 5000,
      wait_ready: true,
      listen_timeout: 10000,
    },
  ],
 
  // Deployment configuration (опционально, используем GitLab CI)
  deploy: {
    production: {
      user: "deployer",
      host: "potapov.me",
      ref: "origin/main",
      repo: "git@gitlab.com:username/potapov.me.git",
      path: "/var/www/potapov.me",
      "post-deploy":
        "npm ci && npm run build && pm2 reload ecosystem.config.cjs --env production",
    },
  },
};

// app/api/health/route.ts
import { NextResponse } from "next/server";
 
export async function GET() {
  const health = {
    status: "ok",
    timestamp: new Date().toISOString(),
    uptime: process.uptime(),
    environment: process.env.NODE_ENV,
  };
 
  return NextResponse.json(health, { status: 200 });
}

# На сервере: создаем пользователя для деплоя (опционально)
sudo adduser deployer
sudo usermod -aG sudo deployer
 
# Добавляем в sudoers для выполнения команд без пароля (если нужно)
# Для NPM обычно не требуется, так как он работает через Docker
# Для обычного Nginx:
# echo "deployer ALL=(ALL) NOPASSWD: /usr/bin/systemctl reload nginx, /usr/bin/pm2" | sudo tee /etc/sudoers.d/deployer
 
# Переключаемся на deployer
su - deployer
 
# Создаем SSH ключи (на локальной машине или в GitLab CI/CD Settings)
ssh-keygen -t ed25519 -C "gitlab-ci@potapov.me" -f ~/.ssh/gitlab_ci_ed25519
 
# Копируем публичный ключ на сервер
# На сервере (под deployer):
mkdir -p ~/.ssh
chmod 700 ~/.ssh
nano ~/.ssh/authorized_keys
# Вставляем содержимое gitlab_ci_ed25519.pub
chmod 600 ~/.ssh/authorized_keys

# .gitlab-ci.yml
# GitLab CI/CD pipeline для деплоя Next.js приложения
 
# Глобальные настройки
image: node:20-alpine
 
# Стадии pipeline
stages:
  - install
  - lint
  - test
  - build
  - deploy
  - healthcheck
  - rollback
 
# Кэширование node_modules для ускорения
cache:
  key:
    files:
      - package-lock.json
  paths:
    - node_modules/
    - .npm/
 
# Переменные окружения
variables:
  npm_config_cache: "$CI_PROJECT_DIR/.npm"
  ARTIFACT_COMPRESSION_LEVEL: "fast"
  CACHE_COMPRESSION_LEVEL: "fast"
 
# Шаблон для job с Node.js
.node_job:
  before_script:
    - node -v
    - npm -v
 
# === STAGE: Install Dependencies ===
install_dependencies:
  extends: .node_job
  stage: install
  script:
    - echo "Installing dependencies..."
    - npm ci --prefer-offline --no-audit
  artifacts:
    paths:
      - node_modules/
    expire_in: 1 hour
  only:
    - main
    - develop
    - merge_requests
 
# === STAGE: Lint ===
lint:
  extends: .node_job
  stage: lint
  dependencies:
    - install_dependencies
  script:
    - echo "Running ESLint..."
    - npm run lint
  only:
    - main
    - develop
    - merge_requests
 
# === STAGE: Test (опционально) ===
# Раскомментируйте, если есть тесты
# test:
#   extends: .node_job
#   stage: test
#   dependencies:
#     - install_dependencies
#   script:
#     - echo "Running tests..."
#     - npm run test
#   coverage: '/Statements\s*:\s*(\d+\.\d+)%/'
#   only:
#     - main
#     - develop
#     - merge_requests
 
# === STAGE: Build ===
build:
  extends: .node_job
  stage: build
  dependencies:
    - install_dependencies
  script:
    - echo "Building Next.js application..."
    - npm run build
  artifacts:
    paths:
      - .next/
      - public/
    expire_in: 1 hour
  only:
    - main
    - develop
 
# === STAGE: Deploy to Production ===
deploy_production:
  stage: deploy
  image: alpine:latest
  dependencies:
    - build
  before_script:
    # Установка SSH клиента
    - apk add --no-cache openssh-client bash git
 
    # Настройка SSH
    - eval $(ssh-agent -s)
    - echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add -
    - mkdir -p ~/.ssh
    - chmod 700 ~/.ssh
    - ssh-keyscan -H $SSH_HOST >> ~/.ssh/known_hosts
    - chmod 644 ~/.ssh/known_hosts
 
  script:
    - echo "Deploying to production server..."
 
    # Создаем бэкап текущей версии
    - |
      ssh $SSH_USER@$SSH_HOST "
        cd $DEPLOY_PATH &&
        if [ -d .next ]; then
          echo 'Creating backup...' &&
          BACKUP_NAME=backup-\$(date +%Y%m%d-%H%M%S) &&
          mkdir -p backups &&
          tar -czf backups/\$BACKUP_NAME.tar.gz .next package.json package-lock.json &&
          echo 'Backup created: '\$BACKUP_NAME &&
 
          # Оставляем только последние 5 бэкапов
          cd backups &&
          ls -t | tail -n +6 | xargs -r rm &&
          cd ..
        fi
      "
 
    # Деплоим через git pull на сервере
    - echo "Deploying via git pull..."
    - |
      ssh $SSH_USER@$SSH_HOST "
        cd $DEPLOY_PATH &&
        git fetch origin &&
        git reset --hard origin/main &&
        echo 'Code updated from git'
      "
 
    # Устанавливаем зависимости, билдим и перезапускаем PM2
    - |
      ssh $SSH_USER@$SSH_HOST "
        cd $DEPLOY_PATH &&
        echo 'Installing dependencies...' &&
        npm ci --prefer-offline &&
 
        echo 'Building application...' &&
        npm run build &&
 
        echo 'Reloading PM2...' &&
        pm2 reload ecosystem.config.cjs --update-env &&
 
        echo 'Waiting for app to start...' &&
        sleep 5 &&
 
        pm2 status
      "
 
    - echo "Deployment completed successfully!"
 
  environment:
    name: production
    url: https://potapov.me
 
  only:
    - main
 
# === STAGE: Deploy to Staging ===
deploy_staging:
  stage: deploy
  image: alpine:latest
  before_script:
    - apk add --no-cache openssh-client bash git
    - eval $(ssh-agent -s)
    - echo "$SSH_PRIVATE_KEY_STAGING" | tr -d '\r' | ssh-add -
    - mkdir -p ~/.ssh
    - chmod 700 ~/.ssh
    - ssh-keyscan -H $SSH_HOST_STAGING >> ~/.ssh/known_hosts
 
  script:
    - echo "Deploying to staging server..."
    - |
      ssh $SSH_USER_STAGING@$SSH_HOST_STAGING "
        cd $DEPLOY_PATH_STAGING &&
        git fetch origin &&
        git reset --hard origin/develop &&
        npm ci &&
        npm run build &&
        pm2 reload ecosystem.config.staging.js --update-env
      "
 
  environment:
    name: staging
    url: https://staging.potapov.me
 
  only:
    - develop
 
# === STAGE: Health Check ===
healthcheck_production:
  stage: healthcheck
  image: alpine:latest
  before_script:
    - apk add --no-cache curl
 
  script:
    - echo "Checking application health..."
    - |
      for i in {1..10}; do
        if curl -f -s https://potapov.me/api/health > /dev/null; then
          echo "✅ Health check passed!"
          exit 0
        else
          echo "⏳ Waiting for app to be ready (attempt $i/10)..."
          sleep 5
        fi
      done
      echo "❌ Health check failed after 10 attempts"
      exit 1
 
  dependencies:
    - deploy_production
 
  only:
    - main
 
# === STAGE: Rollback (manual) ===
rollback_production:
  stage: rollback
  image: alpine:latest
  before_script:
    - apk add --no-cache openssh-client
    - eval $(ssh-agent -s)
    - echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add -
    - mkdir -p ~/.ssh
    - ssh-keyscan -H $SSH_HOST >> ~/.ssh/known_hosts
 
  script:
    - echo "Rolling back to previous version..."
    - |
      ssh $SSH_USER@$SSH_HOST "
        cd $DEPLOY_PATH &&
 
        # Находим последний бэкап
        LATEST_BACKUP=\$(ls -t backups/*.tar.gz | head -1) &&
 
        if [ -z \"\$LATEST_BACKUP\" ]; then
          echo '❌ No backups found!'
          exit 1
        fi &&
 
        echo 'Restoring from backup: '\$LATEST_BACKUP &&
 
        # Восстанавливаем из бэкапа
        tar -xzf \$LATEST_BACKUP &&
 
        # Перезапускаем PM2
        pm2 reload ecosystem.config.cjs &&
 
        echo '✅ Rollback completed!'
      "
 
  when: manual
  only:
    - main

build_docker:
  image: docker:latest
  services:
    - docker:dind
  before_script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
  script:
    - docker pull $CI_REGISTRY_IMAGE:latest || true
    - docker build --cache-from $CI_REGISTRY_IMAGE:latest -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

# Запускаем lint и test параллельно
lint:
  stage: test
  script:
    - npm run lint
 
test:unit:
  stage: test
  script:
    - npm run test:unit
 
test:e2e:
  stage: test
  script:
    - npm run test:e2e

deploy_production:
  stage: deploy
  when: manual # Требует ручного подтверждения
  only:
    - main

deploy_production:
  script:
    # ... previous steps ...
 
    # Создаем .env файл из GitLab Variables
    - |
      ssh $SSH_USER@$SSH_HOST "
        cd $DEPLOY_PATH &&
        cat > .env << EOF
        NODE_ENV=production
        DATABASE_URL=$DATABASE_URL
        NEXT_PUBLIC_API_URL=$NEXT_PUBLIC_API_URL
        SECRET_KEY=$SECRET_KEY
        EOF
      "
 
    # Устанавливаем права доступа
    - ssh $SSH_USER@$SSH_HOST "chmod 600 $DEPLOY_PATH/.env"

# Добавляем маскирование секретов в логах
variables:
  GIT_STRATEGY: clone
  GIT_DEPTH: 1 # Shallow clone для ускорения
 
before_script:
  # Маскируем чувствительные данные в логах
  - export DATABASE_URL="***MASKED***"

# Статус всех процессов
pm2 status
 
# Детальная информация
pm2 show potapov-me
 
# Мониторинг в реальном времени
pm2 monit
 
# Логи
pm2 logs potapov-me --lines 100
 
# Очистка старых логов
pm2 flush

# Регистрация (бесплатный план: 1 сервер, 4 приложения)
pm2 plus
 
# Подключение к PM2 Plus
pm2 link <secret_key> <public_key>

# /var/www/potapov.me/scripts/healthcheck.sh
#!/bin/bash
 
URL="https://potapov.me/api/health"
LOG="/var/www/potapov.me/logs/healthcheck.log"
 
response=$(curl -s -o /dev/null -w "%{http_code}" $URL)
 
if [ $response -eq 200 ]; then
  echo "$(date): ✅ Health check passed" >> $LOG
else
  echo "$(date): ❌ Health check failed (HTTP $response)" >> $LOG
 
  # Отправляем алерт (например, в Telegram)
  curl -s -X POST "https://api.telegram.org/bot<TOKEN>/sendMessage" \
    -d chat_id=<CHAT_ID> \
    -d text="🚨 potapov.me is down! HTTP $response"
 
  # Пытаемся перезапустить PM2
  pm2 restart potapov-me
fi

chmod +x /var/www/potapov.me/scripts/healthcheck.sh
 
# Проверка каждые 5 минут
crontab -e
*/5 * * * * /var/www/potapov.me/scripts/healthcheck.sh

// ecosystem.config.staging.js
module.exports = {
  apps: [
    {
      name: "potapov-me-staging",
      cwd: "/var/www/staging.potapov.me",
      script: "node_modules/next/dist/bin/next",
      args: "start -p 3001",
      env: {
        NODE_ENV: "production",
        PORT: 3001,
        STAGING: "true",
      },
      exec_mode: "cluster",
      instances: 1, // Меньше инстансов для staging
      autorestart: true,
      max_memory_restart: "300M",
    },
  ],
};

# /etc/nginx/sites-available/staging.potapov.me
server {
    listen 80;
    server_name staging.potapov.me;
 
    location / {
        proxy_pass http://localhost:3001;
        # ... остальные настройки как для production
    }
}

# Deploy to staging (ветка develop)
deploy_staging:
  stage: deploy
  script:
    - ssh $SSH_USER@$SSH_HOST "cd /var/www/staging.potapov.me && git pull origin develop && npm ci && npm run build && pm2 reload ecosystem.config.staging.js"
  environment:
    name: staging
    url: https://staging.potapov.me
  only:
    - develop
 
# Deploy to production (ветка main)
deploy_production:
  stage: deploy
  script:
    - ssh $SSH_USER@$SSH_HOST "cd /var/www/potapov.me && git pull origin main && npm ci && npm run build && pm2 reload ecosystem.config.cjs"
  environment:
    name: production
    url: https://potapov.me
  only:
    - main
  when: manual # Ручной деплой в production

healthcheck_production:
  stage: healthcheck
  script:
    - |
      if ! curl -f https://potapov.me/api/health; then
        echo "Health check failed! Triggering rollback..."
        # Вызываем rollback job
        curl -X POST \
          -F token=$CI_JOB_TOKEN \
          -F ref=main \
          -F "variables[TRIGGER_ROLLBACK]=true" \
          https://gitlab.com/api/v4/projects/$CI_PROJECT_ID/trigger/pipeline
        exit 1
      fi

rollback_production:
  stage: rollback
  when: manual
  script:
    - |
      ssh $SSH_USER@$SSH_HOST "
        cd $DEPLOY_PATH &&
        LATEST_BACKUP=\$(ls -t backups/*.tar.gz | head -1) &&
        tar -xzf \$LATEST_BACKUP &&
        pm2 reload ecosystem.config.cjs
      "

# На сервере: две копии приложения
/var/www/potapov.me-blue/   # Текущая версия
/var/www/potapov.me-green/  # Новая версия
 
# Nginx переключает между ними
upstream backend {
    server localhost:3000;  # blue
    # server localhost:3001;  # green
}

#!/bin/bash
# switch-deployment.sh
 
CURRENT=$(readlink /var/www/potapov.me)
 
if [[ $CURRENT == *"blue"* ]]; then
  NEW_COLOR="green"
  NEW_PORT=3001
else
  NEW_COLOR="blue"
  NEW_PORT=3000
fi
 
echo "Switching from $CURRENT to $NEW_COLOR..."
 
# Деплоим в неактивное окружение
cd /var/www/potapov.me-$NEW_COLOR
git pull
npm ci
npm run build
 
# Запускаем новую версию
pm2 start ecosystem.config.cjs
 
# Проверяем health
if curl -f http://localhost:$NEW_PORT/api/health; then
  # Обновляем symlink
  ln -sfn /var/www/potapov.me-$NEW_COLOR /var/www/potapov.me
 
  # Перезагружаем Nginx
  sudo nginx -s reload
 
  echo "✅ Switched to $NEW_COLOR"
else
  echo "❌ Health check failed, keeping $CURRENT"
  pm2 stop ecosystem.config.cjs
  exit 1
fi

potapov.me {
    reverse_proxy localhost:3000
}

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

# Проверяем статус systemd сервиса PM2
systemctl status pm2-$USER
 
# Если сервис не активен, настраиваем автозапуск
pm2 startup systemd -u $USER --hp $HOME
# Выполните команду с sudo, которую выведет PM2
 
# Сохраняем текущий список процессов
pm2 save
 
# Тестируем
sudo reboot
# После перезагрузки проверяем
pm2 status

# 1. Проверьте, что SSH ключ добавлен в GitLab Variables
# Settings → CI/CD → Variables → SSH_PRIVATE_KEY
 
# 2. Убедитесь, что публичный ключ добавлен на сервере
cat ~/.ssh/authorized_keys
 
# 3. Проверьте права на .ssh директорию
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
 
# 4. Проверьте SSH подключение вручную
ssh -i ~/.ssh/gitlab_ci_key user@server
 
# 5. Добавьте -vvv для диагностики
ssh -vvv user@server

# 1. Проверяем, что приложение запущено
pm2 status
pm2 logs app-name --lines 50
 
# 2. Проверяем, слушает ли процесс нужный порт
sudo netstat -tlnp | grep 3000
# или
sudo lsof -i :3000
 
# 3. Проверяем health endpoint локально
curl http://localhost:3000/api/health
 
# 4. Проверяем с внешнего IP
curl http://YOUR_IP:3000/api/health
 
# 5. Проверяем логи Nginx/NPM
docker logs nginx-proxy-manager_app_1

# 1. Проверьте доступную память
free -h
 
# 2. Создайте swap файл (если нет)
sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
 
# 3. Сделайте swap постоянным
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
 
# 4. Или увеличьте heap для Node.js в package.json
"scripts": {
  "build": "NODE_OPTIONS='--max-old-space-size=2048' next build"
}

# Вариант 1: Жесткий reset (удаляет все локальные изменения)
ssh user@server "
  cd /var/www/app &&
  git fetch origin &&
  git reset --hard origin/main &&
  git clean -fd
"
 
# Вариант 2: Stash локальных изменений
ssh user@server "
  cd /var/www/app &&
  git stash &&
  git pull origin main
"
 
# Вариант 3: Если репозиторий большой, используйте shallow clone
# При первичной настройке:
git clone --depth 1 https://gitlab.com/user/repo.git /var/www/app
 
# При деплое:
ssh user@server "
  cd /var/www/app &&
  git fetch --depth 1 &&
  git reset --hard origin/main
"

# 1. Проверьте, что домен указывает на ваш IP
dig potapov.me +short
nslookup potapov.me
 
# 2. Проверьте, что порты 80 и 443 открыты
sudo ufw status
sudo netstat -tlnp | grep ':80\|:443'
 
# 3. Проверьте логи NPM
docker logs nginx-proxy-manager_app_1 --tail 100
 
# 4. Попробуйте получить сертификат вручную через certbot
sudo certbot certonly --standalone -d potapov.me

# === PM2 ===
pm2 status                      # Статус всех процессов
pm2 logs app-name --lines 100   # Логи приложения
pm2 monit                       # Мониторинг в реальном времени
pm2 describe app-name           # Детальная информация
pm2 reset app-name              # Сброс счетчиков рестартов
 
# === Проверка портов ===
sudo netstat -tlnp              # Все слушающие порты
sudo lsof -i :3000              # Процесс на порту 3000
nc -zv localhost 3000           # Проверка доступности порта
 
# === Логи системы ===
journalctl -u pm2-$USER -f      # Логи PM2 systemd сервиса
journalctl -u nginx -f          # Логи Nginx (если не Docker)
tail -f /var/log/syslog         # Системные логи
 
# === Docker (для NPM) ===
docker ps                       # Запущенные контейнеры
docker logs <container> -f      # Логи контейнера
docker exec -it <container> sh  # Зайти внутрь контейнера
 
# === Disk space ===
df -h                           # Свободное место на дисках
du -sh /var/www/*               # Размер директорий
du -sh node_modules .next       # Размер артефактов
 
# === Memory ===
free -h                         # Память и swap
htop                            # Интерактивный мониторинг