Погружение в Docker: руководство для React и Vue разработчиков

docker --version
docker compose version

# Установка Docker
curl -fsSL https://get.docker.com | sh

# Добавление пользователя в группу docker (чтобы не писать sudo)
sudo usermod -aG docker $USER

# Перезайдите в систему и проверьте
docker --version

# FROM — указываем базовый образ
# node:20-alpine — это Node.js версии 20 на базе Alpine Linux
# Alpine — минималистичный дистрибутив Linux (~5MB вместо ~900MB у обычного)
FROM node:20-alpine

# WORKDIR — создаём и переходим в директорию /app внутри контейнера
# Все последующие команды будут выполняться в этой папке
WORKDIR /app

# COPY — копируем package.json и package-lock.json в контейнер
# Почему отдельно? Для оптимизации кэширования слоёв Docker
# Если код изменился, но зависимости нет — npm install не будет перезапускаться
COPY package*.json ./

# RUN — выполняем команду при СБОРКЕ образа
# npm ci — "чистая" установка зависимостей строго по package-lock.json
# Отличие от npm install: не изменяет lock-файл, быстрее, надёжнее для CI/CD
RUN npm ci

# Копируем весь остальной код проекта
COPY . .

# EXPOSE — документируем, что приложение слушает порт 5173
# Это НЕ открывает порт автоматически, только информирует пользователя
EXPOSE 5173

# CMD — команда, которая выполнится при ЗАПУСКЕ контейнера
# --host 0.0.0.0 — важно! По умолчанию Vite слушает только localhost
# Внутри контейнера localhost недоступен извне, поэтому привязываем к 0.0.0.0
CMD ["npm", "run", "dev", "--", "--host", "0.0.0.0"]

# =============================================
# Stage 1: Build (этап сборки)
# Этот этап существует только для сборки приложения
# Его содержимое НЕ попадёт в финальный образ
# =============================================
FROM node:20-alpine AS builder
# AS builder — даём имя этому этапу, чтобы ссылаться на него позже

WORKDIR /app

# Копируем файлы зависимостей
COPY package*.json ./

# Устанавливаем ВСЕ зависимости (включая devDependencies)
# Они нужны для сборки (Vite, TypeScript, и т.д.)
RUN npm ci

# Копируем исходный код
COPY . .

# Собираем приложение
# После этой команды появится папка dist/ с готовыми статическими файлами
RUN npm run build

# =============================================
# Stage 2: Production (финальный этап)
# Только этот этап попадёт в итоговый образ
# =============================================
FROM nginx:alpine AS production
# nginx:alpine — легковесный веб-сервер (~20MB)
# Он будет раздавать наши статические файлы

# COPY --from=builder — копируем файлы из этапа "builder"
# Берём только папку dist и кладём в директорию nginx для статики
COPY --from=builder /app/dist /usr/share/nginx/html

# Копируем нашу конфигурацию nginx (для SPA-роутинга)
COPY nginx.conf /etc/nginx/conf.d/default.conf

# Nginx по умолчанию слушает порт 80
EXPOSE 80

# Запускаем nginx в foreground-режиме
# daemon off — важно для Docker, иначе контейнер сразу завершится
CMD ["nginx", "-g", "daemon off;"]

server {
    listen 80;
    server_name localhost;

    # Указываем корневую директорию со статикой
    root /usr/share/nginx/html;
    index index.html;

    # ===== Gzip сжатие =====
    # Сжимаем ответы для уменьшения трафика
    gzip on;
    gzip_vary on;           # Добавляет заголовок Vary: Accept-Encoding
    gzip_min_length 1024;   # Сжимаем файлы больше 1KB
    gzip_types text/plain text/css text/xml text/javascript
               application/javascript application/json application/xml;

    # ===== Кэширование статики =====
    # Файлы с хэшем в имени (main.a1b2c3.js) можно кэшировать надолго
    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2)$ {
        expires 1y;                                    # Кэш на 1 год
        add_header Cache-Control "public, immutable";  # immutable = файл никогда не изменится
    }

    # ===== SPA Fallback =====
    # Это КРИТИЧЕСКИ важно для Single Page Application!
    #
    # Проблема: пользователь переходит на /about, нажимает F5
    # Браузер запрашивает /about у сервера
    # Но файла /about не существует — есть только index.html
    #
    # Решение: try_files пробует найти файл, если не находит — отдаёт index.html
    # Vue Router внутри index.html сам разберётся с роутом /about
    location / {
        try_files $uri $uri/ /index.html;
    }

    # ===== Проксирование API =====
    # Если бэкенд запущен в отдельном контейнере
    location /api/ {
        # backend — имя сервиса в docker-compose
        proxy_pass http://backend:3000/;
        proxy_http_version 1.1;

        # Передаём оригинальные заголовки
        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;
    }
}

# =============================================
# Stage 1: Dependencies
# Устанавливаем только production-зависимости
# =============================================
FROM node:20-alpine AS deps
WORKDIR /app
COPY package*.json ./

# --omit=dev — пропускаем devDependencies
# Эти зависимости будут скопированы в production-образ
RUN npm ci --omit=dev

# =============================================
# Stage 2: Build
# Собираем приложение со ВСЕМИ зависимостями
# =============================================
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./

# Здесь устанавливаем ВСЕ зависимости — нужны для сборки
RUN npm ci

COPY . .

# Nuxt создаёт папку .output с сервером и статикой
RUN npm run build

# =============================================
# Stage 3: Production
# Финальный образ для запуска
# =============================================
FROM node:20-alpine AS runner
WORKDIR /app

# Создаём непривилегированного пользователя для безопасности
# Если приложение взломают — злоумышленник получит минимум прав
RUN addgroup --system --gid 1001 nodejs && \
    adduser --system --uid 1001 nuxtjs

# Копируем ТОЛЬКО собранное приложение
# Исходники, node_modules с dev-зависимостями — не нужны
COPY --from=builder /app/.output ./.output

# Переключаемся на непривилегированного пользователя
USER nuxtjs

EXPOSE 3000

# Переменные окружения для Nuxt
ENV HOST=0.0.0.0
ENV PORT=3000
ENV NODE_ENV=production

# Запускаем Nuxt-сервер
CMD ["node", ".output/server/index.mjs"]

# Версия формата docker-compose (можно не указывать для новых версий)
services:
  # ===== Nuxt приложение =====
  app:
    # build: . — собрать образ из Dockerfile в текущей директории
    build: .

    # Имя контейнера (для удобства в логах и командах)
    container_name: nuxt-app

    # Политика перезапуска:
    # - unless-stopped: перезапускать при падении, кроме ручной остановки
    # - always: перезапускать всегда
    # - on-failure: только при ненулевом exit code
    restart: unless-stopped

    # Проброс портов: [хост]:[контейнер]
    # localhost:3000 на хосте → порт 3000 в контейнере
    ports:
      - "3000:3000"

    # Переменные окружения для приложения
    environment:
      # mongo — это имя сервиса ниже, Docker автоматически
      # резолвит его в IP-адрес контейнера MongoDB
      - MONGODB_URI=mongodb://mongo:27017/mydb
      - NODE_ENV=production

    # Зависимости: app запустится только когда mongo будет "healthy"
    depends_on:
      mongo:
        condition: service_healthy  # Ждём прохождения healthcheck

    # Подключаем к внутренней сети
    networks:
      - app-network

  # ===== MongoDB =====
  mongo:
    # Используем готовый образ (не собираем свой)
    image: mongo:7

    container_name: mongodb
    restart: unless-stopped

    # Volumes — постоянное хранилище
    # Без volume данные пропадут при пересоздании контейнера!
    volumes:
      # mongo_data — именованный volume (объявлен внизу)
      # /data/db — директория MongoDB для данных
      - mongo_data:/data/db

    # Healthcheck — проверка здоровья сервиса
    # Docker будет периодически выполнять эту команду
    healthcheck:
      # Команда для проверки: пингуем MongoDB
      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
      interval: 10s    # Проверять каждые 10 секунд
      timeout: 5s      # Таймаут проверки
      retries: 5       # Сколько неудач до статуса "unhealthy"

    networks:
      - app-network

# ===== Networks (сети) =====
# Изолированная сеть для взаимодействия контейнеров
networks:
  app-network:
    driver: bridge  # Стандартный драйвер для локальной сети

# ===== Volumes (тома) =====
# Именованные тома для постоянного хранения данных
volumes:
  mongo_data:  # Данные MongoDB сохранятся между перезапусками

FROM node:20-alpine

WORKDIR /app

COPY package*.json ./

RUN npm ci

COPY . .

EXPOSE 5173

# Для Vite нужен флаг --host для доступа извне контейнера
# Без него Vite слушает только 127.0.0.1, который недоступен с хоста
CMD ["npm", "run", "dev", "--", "--host"]

# =============================================
# Stage 1: Build
# =============================================
FROM node:20-alpine AS builder

WORKDIR /app

COPY package*.json ./

RUN npm ci

COPY . .

# ARG — аргументы времени сборки
# В отличие от ENV, они доступны ТОЛЬКО при сборке образа
# Используем для передачи URL API, который "вшивается" в бандл
ARG VITE_API_URL
ENV VITE_API_URL=$VITE_API_URL

# После сборки переменные Vite будут "захардкожены" в JS-файлы
RUN npm run build

# =============================================
# Stage 2: Production
# =============================================
FROM nginx:alpine

COPY --from=builder /app/dist /usr/share/nginx/html

COPY nginx.conf /etc/nginx/conf.d/default.conf

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

server {
    listen 80;
    server_name localhost;
    root /usr/share/nginx/html;
    index index.html;

    # Gzip сжатие для уменьшения размера ответов
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_types text/plain text/css application/json application/javascript
               text/xml application/xml text/javascript;

    # Кэширование статических файлов
    # Vite добавляет хэш в имена файлов, поэтому можно кэшировать навсегда
    location /assets/ {
        expires 1y;
        add_header Cache-Control "public, immutable";
    }

    # SPA fallback для React Router
    # Любой путь, который не файл — отдаём index.html
    location / {
        try_files $uri $uri/ /index.html;
    }
}

services:
  # ===== React Frontend =====
  frontend:
    build:
      context: ./frontend        # Путь к папке с фронтендом
      dockerfile: Dockerfile
      args:
        # URL API для Vite — передаётся при сборке
        - VITE_API_URL=http://localhost:4000
    container_name: react-frontend
    ports:
      - "80:80"
    # Фронтенд зависит от бэкенда (опционально)
    depends_on:
      - backend
    networks:
      - app-network

  # ===== Node.js Backend =====
  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile
    container_name: node-backend
    restart: unless-stopped
    ports:
      - "4000:4000"
    environment:
      - NODE_ENV=production
      # DATABASE_URL: db — имя сервиса PostgreSQL
      - DATABASE_URL=postgresql://postgres:password@db:5432/myapp
      # Секреты лучше передавать через .env файл или Docker secrets
      - JWT_SECRET=${JWT_SECRET}
    depends_on:
      db:
        condition: service_healthy
    networks:
      - app-network

  # ===== PostgreSQL =====
  db:
    image: postgres:16-alpine
    container_name: postgres-db
    restart: unless-stopped
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password  # В продакшене используйте секреты!
      - POSTGRES_DB=myapp
    volumes:
      # Данные PostgreSQL сохраняются в volume
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      # pg_isready — утилита для проверки готовности PostgreSQL
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-network

  # ===== Redis =====
  redis:
    image: redis:alpine
    container_name: redis-cache
    restart: unless-stopped
    volumes:
      - redis_data:/data
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

volumes:
  postgres_data:
  redis_data:

FROM node:20-alpine

WORKDIR /app

# Устанавливаем только production-зависимости
COPY package*.json ./
RUN npm ci --omit=dev

# Копируем исходники
COPY . .

# Собираем TypeScript (если используется)
RUN npm run build

EXPOSE 4000

# Безопасность: запускаем от встроенного пользователя node
# Он уже существует в образе node:*
USER node

CMD ["node", "dist/index.js"]

# =============================================
# Stage 1: Dependencies
# =============================================
FROM node:20-alpine AS deps

# libc6-compat нужен для некоторых npm-пакетов в Alpine
RUN apk add --no-cache libc6-compat
WORKDIR /app

COPY package*.json ./
RUN npm ci

# =============================================
# Stage 2: Build
# =============================================
FROM node:20-alpine AS builder
WORKDIR /app

# Копируем node_modules из предыдущего этапа
COPY --from=deps /app/node_modules ./node_modules
COPY . .

# Отключаем телеметрию Next.js
ENV NEXT_TELEMETRY_DISABLED=1

RUN npm run build

# =============================================
# Stage 3: Production
# =============================================
FROM node:20-alpine AS runner
WORKDIR /app

ENV NODE_ENV=production
ENV NEXT_TELEMETRY_DISABLED=1

# Создаём пользователя
RUN addgroup --system --gid 1001 nodejs && \
    adduser --system --uid 1001 nextjs

# Копируем публичные файлы
COPY --from=builder /app/public ./public

# standalone output содержит:
# - минимальный сервер
# - только используемые node_modules
# - всё необходимое для работы
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static

USER nextjs

EXPOSE 3000

ENV PORT=3000
ENV HOSTNAME="0.0.0.0"

# standalone создаёт server.js — минималистичный Next.js сервер
CMD ["node", "server.js"]

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.dev
    container_name: dev-app
    ports:
      - "5173:5173"
    volumes:
      # Монтируем текущую директорию внутрь /app в контейнере
      # Теперь любое изменение файла на хосте видно в контейнере
      - .:/app

      # НО! node_modules должны быть из контейнера, не с хоста
      # Причины:
      # 1. Нативные модули могут отличаться (bcrypt на Mac vs Linux)
      # 2. Избегаем конфликтов версий
      # Этот "анонимный volume" перекрывает папку node_modules
      - /app/node_modules

    environment:
      # Chokidar — библиотека для отслеживания изменений файлов
      # USEPOLLING=true нужен для Docker на Mac/Windows
      # Потому что fs.watch не работает корректно через mount
      - CHOKIDAR_USEPOLLING=true

    # Нужны для корректной работы терминала
    stdin_open: true
    tty: true

FROM node:20-alpine

WORKDIR /app

# Копируем и устанавливаем зависимости
COPY package*.json ./
RUN npm install  # В dev используем install, не ci

# Исходники будут смонтированы через volume, копировать не нужно!
# При запуске папка /app будет содержать файлы с хоста

EXPOSE 5173

CMD ["npm", "run", "dev", "--", "--host"]

# 1. Используйте alpine образы
# Alpine — минималистичный Linux дистрибутив
FROM node:20-alpine

# 2. Устанавливайте только production зависимости в финальном образе
RUN npm ci --omit=dev

# 3. Используйте multi-stage builds
# Этап сборки с dev-зависимостями не попадает в финальный образ
FROM node:20-alpine AS builder
# ... сборка ...
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html

# 4. Используйте .dockerignore
# Создайте файл .dockerignore в корне проекта:

node_modules
.git
.gitignore
README.md
Dockerfile*
docker-compose*
.env*
coverage
.nyc_output
dist
.next
.nuxt

# 5. Объединяйте RUN команды и очищайте кэш
# Каждая RUN создаёт новый слой, объединение уменьшает количество слоёв
RUN npm ci --omit=dev && \
    npm cache clean --force && \
    rm -rf /tmp/*

services:
  app:
    environment:
      - API_URL=https://api.example.com
      - DEBUG=false

API_URL=https://api.example.com
DEBUG=false

services:
  app:
    env_file:
      - .env

# ARG — доступен ТОЛЬКО при сборке (docker build)
ARG VITE_API_URL

# ENV — доступен при запуске контейнера (docker run)
ENV VITE_API_URL=$VITE_API_URL

services:
  app:
    build:
      args:
        - VITE_API_URL=https://api.example.com  # Build-time
    environment:
      - NODE_ENV=production                      # Runtime

// public/config.js — этот файл не проходит через Vite
window.__CONFIG__ = {
  API_URL: '%%API_URL%%'  // Плейсхолдер
};

<!-- index.html -->
<script src="/config.js"></script>

// Использование в приложении
const apiUrl = window.__CONFIG__.API_URL;

# entrypoint.sh — замена плейсхолдеров при старте контейнера
#!/bin/sh
# Заменяем плейсхолдер на значение переменной окружения
sed -i "s|%%API_URL%%|$API_URL|g" /usr/share/nginx/html/config.js
# Запускаем nginx
nginx -g 'daemon off;'

# В Dockerfile
COPY entrypoint.sh /
RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]

docker run -e API_URL=https://api.prod.com my-app

services:
  frontend:
    build: .
    healthcheck:
      # Команда проверки: wget пытается получить главную страницу
      test: ["CMD", "wget", "-q", "--spider", "http://localhost:80"]
      interval: 30s      # Как часто проверять
      timeout: 10s       # Сколько ждать ответа
      retries: 3         # Сколько неудач до "unhealthy"
      start_period: 10s  # Время на запуск приложения (не считается)

  backend:
    build: ./backend
    healthcheck:
      # curl проверяет эндпоинт /health
      # -f — fail при HTTP ошибках (4xx, 5xx)
      test: ["CMD", "curl", "-f", "http://localhost:4000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

app.get('/health', (req, res) => {
  // Можно добавить проверку БД, Redis и т.д.
  res.status(200).json({ status: 'ok' });
});

name: Build and Push Docker Image

# Когда запускать workflow
on:
  push:
    branches: [main]        # При push в main
  pull_request:
    branches: [main]        # При PR в main

# Переменные окружения для всего workflow
env:
  REGISTRY: ghcr.io                          # GitHub Container Registry
  IMAGE_NAME: ${{ github.repository }}       # username/repo-name

jobs:
  build:
    runs-on: ubuntu-latest

    # Права для работы с registry
    permissions:
      contents: read
      packages: write

    steps:
      # 1. Клонируем репозиторий
      - name: Checkout repository
        uses: actions/checkout@v4

      # 2. Логинимся в GitHub Container Registry
      - name: Log in to Container Registry
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}  # Автоматический токен

      # 3. Генерируем теги и метаданные для образа
      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
          tags: |
            type=sha                              # ghcr.io/user/repo:abc1234
            type=ref,event=branch                 # ghcr.io/user/repo:main
            type=raw,value=latest,enable={{is_default_branch}}

      # 4. Собираем и пушим образ
      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: .
          # Пушим только при push, не при PR
          push: ${{ github.event_name != 'pull_request' }}
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          # Кэширование слоёв для ускорения сборки
          cache-from: type=gha
          cache-to: type=gha,mode=max

# Этапы pipeline
stages:
  - build
  - deploy

# Переменные
variables:
  IMAGE_TAG: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA    # registry.gitlab.com/user/repo:abc1234
  IMAGE_LATEST: $CI_REGISTRY_IMAGE:latest

# ===== Сборка образа =====
build:
  stage: build
  # Docker-in-Docker: запускаем Docker внутри Docker
  image: docker:24
  services:
    - docker:24-dind
  before_script:
    # Логинимся в GitLab Container Registry
    # CI_REGISTRY_* — встроенные переменные GitLab
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
  script:
    - docker build -t $IMAGE_TAG -t $IMAGE_LATEST .
    - docker push $IMAGE_TAG
    - docker push $IMAGE_LATEST
  only:
    - main  # Только для ветки main

# ===== Деплой на сервер =====
deploy:
  stage: deploy
  image: alpine:latest
  before_script:
    # Устанавливаем SSH-клиент
    - apk add --no-cache openssh-client
    # Настраиваем SSH-ключ из переменной GitLab
    - mkdir -p ~/.ssh
    - echo "$SSH_PRIVATE_KEY" > ~/.ssh/id_rsa
    - chmod 600 ~/.ssh/id_rsa
    - ssh-keyscan -H $VPS_HOST >> ~/.ssh/known_hosts
  script:
    # Подключаемся к серверу и обновляем контейнеры
    - ssh $VPS_USER@$VPS_HOST "cd /opt/app && docker compose pull && docker compose up -d"
  only:
    - main
  when: manual  # Ручной запуск (кнопка в GitLab UI)

# ===== Образы =====
docker build -t myapp .              # Собрать образ с тегом myapp
docker build -t myapp:v1.0 .         # С версией
docker images                        # Список образов
docker rmi myapp                     # Удалить образ
docker image prune                   # Удалить неиспользуемые образы
docker tag myapp registry/myapp      # Переименовать/добавить тег

# ===== Контейнеры =====
docker run myapp                     # Запустить (блокирует терминал)
docker run -d myapp                  # Запустить в фоне (detached)
docker run -p 3000:3000 myapp        # С пробросом портов
docker run -e NODE_ENV=prod myapp    # С переменной окружения
docker run -v $(pwd):/app myapp      # С монтированием тома
docker run --name my-container myapp # С именем контейнера

docker ps                            # Запущенные контейнеры
docker ps -a                         # Все контейнеры (включая остановленные)
docker stop <id|name>                # Остановить контейнер
docker start <id|name>               # Запустить остановленный
docker rm <id|name>                  # Удалить контейнер
docker rm -f <id|name>               # Удалить даже запущенный

docker logs <id|name>                # Логи контейнера
docker logs -f <id|name>             # Логи в реальном времени (follow)
docker logs --tail 100 <id|name>     # Последние 100 строк

docker exec -it <id|name> sh         # Зайти в контейнер (shell)
docker exec <id|name> ls /app        # Выполнить команду в контейнере

# ===== Docker Compose =====
docker compose up                    # Запустить все сервисы
docker compose up -d                 # В фоне
docker compose up --build            # Пересобрать образы и запустить
docker compose up app                # Запустить только сервис app
docker compose down                  # Остановить и удалить контейнеры
docker compose down -v               # + удалить volumes

docker compose logs                  # Логи всех сервисов
docker compose logs -f app           # Логи сервиса app в реальном времени
docker compose ps                    # Статус сервисов
docker compose exec app sh           # Зайти в контейнер сервиса
docker compose restart app           # Перезапустить сервис

# ===== Очистка =====
docker system df                     # Использование диска
docker system prune                  # Удалить всё неиспользуемое
docker system prune -a               # + все образы без контейнеров
docker volume prune                  # Удалить неиспользуемые volumes
docker network prune                 # Удалить неиспользуемые сети

# ===== Отладка =====
docker inspect <id|name>             # Детальная информация о контейнере
docker stats                         # Использование ресурсов (CPU, RAM)
docker top <id|name>                 # Процессы в контейнере

# Создайте пользователя и дайте ему права на нужные директории
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
RUN mkdir -p /app/data && chown -R appuser:appgroup /app
USER appuser

# 1. Не хватает памяти — увеличьте лимит для Node
ENV NODE_OPTIONS="--max-old-space-size=4096"

# 2. Проблемы с сетью — используйте npm ci (быстрее и надёжнее)
RUN npm ci

# 3. Много зависимостей — очищайте кэш
RUN npm ci && npm cache clean --force

# docker-compose.yml
environment:
  # Для Vite (использует Chokidar)
  - CHOKIDAR_USEPOLLING=true

  # Для Webpack
  - WATCHPACK_POLLING=true

  # Для Create React App (старый)
  - FAST_REFRESH=false

# Посмотрите логи
docker logs <container_id>

# Посмотрите exit code
docker inspect <container_id> --format='{{.State.ExitCode}}'

# Запустите интерактивно для отладки
docker run -it myapp sh

# 1. Docker Desktop не запущен — запустите его

# 2. На Linux: пользователь не в группе docker
sudo usermod -aG docker $USER
# Перезайдите в систему

# 3. Сервис Docker не запущен
sudo systemctl start docker

# Найдите, что занимает порт
lsof -i :3000  # Mac/Linux
netstat -ano | findstr :3000  # Windows

# Или используйте другой порт
docker run -p 3001:3000 myapp