TeoreticQuiz

Linux, Docker, Git, CI/CD

Материал для подготовки к собеседованию (Middle / Senior). DevOps-темы с точки зрения разработчика: что нужно уметь, чтобы собирать, контейнеризовать, версионировать и деплоить свой код. Термины на английском там, где это принято.

Содержание


Linux: основы для разработчика

Большинство серверов — Linux, поэтому разработчику нужно уверенно работать в терминале: запускать приложения, читать логи, разбираться, почему «не запускается», настраивать окружение в контейнере.

Оболочка (shell) — обычно bash или zsh. Команда состоит из имени, опций (-l, --all) и аргументов. Справка — man команда, команда --help.


Файловая система и права доступа

Всё в Linux — файл (в т.ч. устройства, сокеты). Дерево от корня /. Важные каталоги: /etc (конфиги), /var/log (логи), /home (домашние), /tmp (временное), /usr/bin (программы), /proc (инфо о процессах).

Навигация и файлы: pwd, ls -la, cd, cp, mv, rm, mkdir, touch, cat, less, head, tail -f (следить за логом), find, du -sh, df -h.

Права доступа — три группы (владелец / группа / остальные) × три права (r=4, w=2, x=1):

ls -l
# -rwxr-xr--  1 user group  ...
#  ^^^ владелец: rwx (7)
#     ^^^ группа: r-x (5)
#        ^^^ остальные: r-- (4)

chmod 755 script.sh      # rwxr-xr-x
chmod +x script.sh       # добавить право на выполнение
chown user:group file    # сменить владельца

sudo — выполнить от имени root (админ). Не запускать приложения/контейнеры от root без необходимости (безопасность).


Процессы и сигналы

Каждая программа — процесс со своим PID. Просмотр и управление:

ps aux | grep node        # найти процессы
top / htop                # мониторинг в реальном времени (CPU, память)
kill <PID>                # послать сигнал (по умолчанию SIGTERM — мягко)
kill -9 <PID>             # SIGKILL — жёстко (последнее средство)
jobs / bg / fg            # управление фоновыми задачами
nohup ./app &             # запуск в фоне, не завершится при выходе

Сигналы (важно для graceful shutdown приложений и контейнеров):

  • SIGTERM (15) — «завершись корректно» (по умолчанию у kill, Docker шлёт его при остановке). Приложение должно поймать и корректно закрыться (дождаться запросов, закрыть БД).
  • SIGKILL (9) — «убить немедленно», нельзя перехватить (крайняя мера).
  • SIGINT (2) — Ctrl+C.
  • SIGHUP (1) — часто используют для перечитывания конфига.

Фоновые процессы держат через systemd, supervisor или менеджеры (PM2 для Node).


Основные утилиты и пайпы

Философия Unix: маленькие утилиты, соединённые пайпами.

  • Пайп | — вывод одной команды на вход другой.
  • Редиректы: > (перезаписать в файл), >> (дописать), < (из файла), 2> (stderr), > file 2>&1 (весь вывод, POSIX); &> — то же, но расширение bash/zsh, не POSIX (в sh/dash не работает).
  • Потоки: stdin (0), stdout (1), stderr (2).
cat access.log | grep "500" | wc -l          # сколько ошибок 500
grep -r "TODO" ./src                          # рекурсивный поиск в коде
tail -f app.log | grep ERROR                  # следить за ошибками в реальном времени
tail -f app.log | grep --line-buffered ERROR | tee err.log  # флаг нужен, когда вывод grep идёт дальше в пайп (иначе блочная буферизация)
ps aux | grep node | awk '{print $2}' | xargs kill  # убить все node-процессы
sed 's/old/new/g' file.txt                    # замена текста
cut -d',' -f1 data.csv                        # первая колонка CSV

Ключевые утилиты: grep (поиск по регуляркам), sed (потоковое редактирование), awk (обработка колонок), find (поиск файлов), xargs (передать вывод как аргументы), sort, uniq, wc, curl/wget (HTTP), jq (обработка JSON).


Сеть и порты

curl -i https://api.com/health       # HTTP-запрос с заголовками
curl -X POST -d '{"a":1}' -H "Content-Type: application/json" url
ss -tulpn                            # какие порты слушаются (замена netstat)
netstat -tulpn                       # то же (устаревшее)
lsof -i :3000                        # кто занял порт 3000
dig example.com / nslookup           # DNS-резолвинг
ping / traceroute                    # доступность/маршрут

Частая задача разработчика — «порт занят»/«приложение недоступно»: проверить, слушается ли порт (ss -tulpn), кто его держит (lsof -i), доступен ли сервис (curl localhost:PORT).


Сервисы, логи, cron

systemd — система инициализации и управления сервисами:

systemctl status nginx       # статус сервиса
systemctl start/stop/restart nginx
systemctl enable nginx       # автозапуск при загрузке
journalctl -u nginx -f       # логи сервиса (follow)
journalctl --since "1 hour ago"

Логи — /var/log/ (nginx, syslog), у контейнеров/systemd — journald. Читают через tail -f, less, grep, journalctl.

cron — планировщик задач:

crontab -e
# формат: минута час день месяц день_недели команда
0 3 * * *   /usr/bin/backup.sh        # каждый день в 3:00
*/15 * * * * php /app/artisan schedule:run  # каждые 15 минут

Docker: зачем и как

Docker — платформа контейнеризации. Контейнер упаковывает приложение вместе с его зависимостями и окружением, чтобы оно одинаково работало везде — на машине разработчика, в CI, на проде. Решает проблему «у меня работает, а у тебя нет».

Контейнер vs виртуальная машина:

Контейнер Виртуальная машина
Изоляция процессы, общее ядро ОС хоста полная ОС с гипервизором
Вес мегабайты, запуск за секунды гигабайты, запуск минуты
Накладные расходы минимальные значительные
Изоляция уровня процесс/namespace/cgroups аппаратная

Контейнеры легче и быстрее ВМ, потому что используют ядро хоста (не тащат целую ОС), а изоляцию дают namespaces (изоляция процессов/сети/файлов) и cgroups (лимиты ресурсов) ядра Linux.


Образы, контейнеры, слои

  • Image (образ) — неизменяемый шаблон (снимок файловой системы + метаданные), из которого запускают контейнеры. Собирается из Dockerfile.
  • Container (контейнер) — запущенный экземпляр образа (образ + тонкий записываемый слой сверху). Из одного образа — много контейнеров.
  • Registry (реестр) — хранилище образов (Docker Hub, GitHub Container Registry, GitLab Registry, приватные).
  • Слои (layers) — образ состоит из слоёв, каждый шаг Dockerfile добавляет слой. Слои кэшируются и переиспользуются между образами (экономия места и времени сборки).
docker build -t myapp:1.0 .          # собрать образ
docker images                        # список образов
docker run -d -p 8080:80 --name web myapp:1.0  # запустить контейнер
docker ps / docker ps -a             # запущенные / все контейнеры
docker logs -f web                   # логи контейнера
docker exec -it web sh               # зайти внутрь работающего контейнера
docker stop web / docker rm web      # остановить / удалить
docker pull / docker push            # скачать / залить в registry
docker system prune                  # почистить мусор (остановленные, dangling)

Ключевое понимание слоёв: если поменять строку в Dockerfile, пересобираются этот слой и все после него; предыдущие берутся из кэша. Отсюда правило — часто меняющиеся шаги (копирование исходников) ставить ниже, редко меняющиеся (установка зависимостей) — выше.


Dockerfile

Инструкция сборки образа:

FROM node:20-alpine              # базовый образ (alpine — лёгкий)
WORKDIR /app                     # рабочая директория

# Сначала только манифесты — чтобы кэшировать слой зависимостей
COPY package*.json ./
RUN npm ci --omit=dev            # установка зависимостей (кэшируется, пока не менялся package*.json)

COPY . .                         # исходники (меняются часто — ниже)
RUN npm run build

EXPOSE 3000                      # документирует порт (не публикует)
ENV NODE_ENV=production
USER node                        # не root — безопаснее

HEALTHCHECK --interval=30s CMD wget -qO- http://localhost:3000/health || exit 1
CMD ["node", "dist/main.js"]     # команда запуска (exec-форма)

Основные инструкции: FROM (база), WORKDIR, COPY/ADD, RUN (выполнить при сборке), CMD (команда запуска, одна), ENTRYPOINT (точка входа), EXPOSE, ENV, ARG (переменная сборки), USER, VOLUME, HEALTHCHECK.

CMD vs ENTRYPOINT: ENTRYPOINT — что запускается всегда (например, бинарь), CMD — аргументы по умолчанию (можно переопределить при docker run). Часто ENTRYPOINT ["app"] + CMD ["--default-flag"].

RUN vs CMD: RUN выполняется при сборке образа (создаёт слой), CMD — при запуске контейнера.

.dockerignore — исключает файлы из контекста сборки (node_modules, .git, .env) — быстрее сборка, меньше образ, безопаснее.


Multi-stage builds и оптимизация

Multi-stage build — несколько стадий FROM: в первой собираем (нужны компиляторы, dev-зависимости), в финальную копируем только результат. Итоговый образ маленький и без лишнего.

# Стадия 1: сборка
FROM node:20 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Стадия 2: рантайм — только собранное
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
CMD ["node", "dist/main.js"]

Оптимизация образов:

  • Лёгкая база — alpine, slim, distroless вместо полной ОС.
  • Multi-stage — не тащить билд-инструменты в прод-образ.
  • Порядок слоёв — зависимости выше исходников (кэш).
  • Объединять RUN — меньше слоёв; чистить кэш пакетного менеджера в том же слое (apt-get clean, rm -rf /var/lib/apt/lists/*).
  • .dockerignore — не тянуть лишнее в контекст.
  • Не root — USER.
  • Фиксировать теги базовых образов (не latest).

Тома и данные

Контейнеры эфемерны — данные в записываемом слое исчезают при удалении контейнера. Для сохранения — тома:

  • Volumes — управляются Docker (/var/lib/docker/volumes), лучший способ для БД и постоянных данных.
  • Bind mounts — монтируют папку хоста в контейнер (удобно в разработке — подхватывать код).
  • tmpfs — в памяти (временное).
docker volume create pgdata
docker run -v pgdata:/var/lib/postgresql/data postgres      # named volume
docker run -v $(pwd)/src:/app/src node                       # bind mount (dev)

Правило: код и зависимости — в образ; изменяемые данные (БД, загрузки) — в тома; конфиги/секреты — через env/секреты.


Сети Docker

Контейнеры общаются через виртуальные сети Docker. Типы:

  • bridge (по умолчанию) — изолированная сеть на хосте; контейнеры в одной пользовательской bridge-сети видят друг друга по имени (встроенный DNS).
  • host — контейнер использует сеть хоста напрямую (без изоляции портов).
  • none — без сети.
docker network create app-net
docker run --network app-net --name db postgres
docker run --network app-net --name api myapi   # api достучится до db по хосту "db"

Проброс портов -p host:container (-p 8080:80) — публикует порт контейнера на хосте. Важно: EXPOSE в Dockerfile только документирует, реально публикует -p.


docker compose

Docker Compose — описание многоконтейнерного приложения одним YAML-файлом (compose.yaml) и запуск одной командой. Незаменим для локальной разработки (приложение + БД + Redis + …).

services:
  api:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://user:pass@db:5432/app
    depends_on:
      db:
        condition: service_healthy
    restart: unless-stopped

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: app
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user"]
      interval: 5s

  redis:
    image: redis:7-alpine

volumes:
  pgdata:
docker compose up -d          # поднять всё в фоне
docker compose logs -f api    # логи сервиса
docker compose exec api sh    # зайти в контейнер
docker compose down           # остановить и удалить (down -v — и тома)
docker compose build          # пересобрать

Ключевое: сервисы в одном compose видят друг друга по имени сервиса (db, redis); depends_on управляет порядком запуска (с condition — ждать healthcheck); тома и сети описываются здесь же.


Docker в проде и отладка

  • Логи — приложение должно писать в stdout/stderr (Docker/оркестратор их собирают), а не в файлы внутри контейнера.
  • Один процесс на контейнер — контейнер = один сервис (не «всё в одном»).
  • Healthcheck — оркестратор понимает, жив ли контейнер.
  • Лимиты ресурсов — --memory, --cpus (чтобы один контейнер не съел всё).
  • Отладка: docker logs, docker exec -it <c> sh (зайти внутрь), docker inspect (метаданные, сеть, тома), docker stats (потребление ресурсов), docker events.
  • Частые проблемы: контейнер сразу падает (смотреть docker logs), не тот порт (-p), нет переменных окружения, права доступа к томам, образ под другую архитектуру (arm/amd).

Kubernetes: обзор для разработчика

Kubernetes (k8s) — оркестратор контейнеров: автоматически разворачивает, масштабирует, перезапускает и балансирует контейнеры на кластере машин. Разработчику полезно понимать базовые объекты (даже если настраивает DevOps):

  • Pod — минимальная единица, один или несколько тесно связанных контейнеров с общей сетью/томами.
  • Deployment — управляет набором одинаковых подов: желаемое число реплик, обновления (rolling update), откаты.
  • Service — стабильная точка доступа к подам (внутренний DNS, балансировка), т.к. поды эфемерны и меняют IP.
  • Ingress — маршрутизация внешнего HTTP-трафика к сервисам (по хосту/пути).
  • ConfigMap / Secret — конфиги и секреты, отдаваемые в поды через env/тома.
  • Namespace — логическое разделение (dev/stage/prod).
  • HPA (Horizontal Pod Autoscaler) — автомасштабирование по нагрузке.

Ключевая идея k8s — декларативность: описываешь желаемое состояние в YAML (kubectl apply -f), а k8s сам приводит кластер к нему и поддерживает (перезапускает упавшее, держит нужное число реплик). Основные команды: kubectl get pods, kubectl logs, kubectl describe, kubectl exec, kubectl apply. Пакеты приложений часто ставят через Helm (charts).


Git: модель и внутреннее устройство

Git — распределённая система контроля версий: у каждого разработчика полная копия истории.

Внутреннее устройство (важно понимать для собеседования):

  • Commit — снимок (snapshot) всего дерева файлов на момент коммита + метаданные (автор, сообщение, ссылка на родительский коммит). Не «дельта», а снимок (хотя хранится эффективно).
  • История — направленный ацикличный граф (DAG) коммитов, связанных ссылками на родителей.
  • Объекты Git: blob (содержимое файла), tree (каталог), commit, tag. Идентифицируются хешем (SHA-1/SHA-256).
  • Ветка (branch) — просто указатель (ref) на коммит; создание ветки дёшево (создаётся указатель).
  • HEAD — указатель на текущую ветку/коммит.
  • Три «зоны»: working directory (рабочие файлы) → staging area / index (git add) → repository (git commit).
git init / git clone <url>
git status
git add <file> / git add -p       # -p — по частям (интерактивно)
git commit -m "message"
git log --oneline --graph --all   # история графом
git diff / git diff --staged      # изменения

Git: merge, rebase, cherry-pick

Merge — объединяет ветки, создавая merge-коммит (с двумя родителями). Сохраняет реальную историю. Fast-forward merge (если ветка не разошлась) — просто перемещает указатель без merge-коммита.

Rebase — «переносит» коммиты ветки поверх другой, переписывая их (новые хеши). Даёт линейную чистую историю, но меняет историю.

git merge feature          # влить feature в текущую
git rebase main            # перенести коммиты текущей ветки поверх main
git rebase -i HEAD~3       # интерактивный: squash/reorder/edit последних 3 коммитов

Merge vs rebase (частый вопрос): merge безопасен и сохраняет историю как есть (видно ветвления); rebase даёт линейную историю, но переписывает коммиты. Золотое правило rebase: не делать rebase публичных (запушенных, общих) веток — сломаете историю другим. Rebase — для локальной уборки перед пушем; merge — для интеграции в общие ветки.

Cherry-pick — применить конкретный коммит из другой ветки:

git cherry-pick <commit-hash>   # например, хотфикс из одной ветки в другую

Squash — схлопнуть несколько коммитов в один (чистая история фичи) — через rebase -i или squash-merge PR.


Git: reset, revert, восстановление

git reset — двигает указатель ветки (переписывает историю локально):

  • --soft — сдвинуть HEAD, изменения остаются в staging.
  • --mixed (по умолчанию) — в working directory (не staged).
  • --hard — удалить изменения (осторожно!).

git revert — создаёт новый коммит, отменяющий изменения указанного, не переписывая историю. Безопасно для общих веток (в отличие от reset).

git reset --soft HEAD~1     # отменить последний коммит, оставить изменения
git reset --hard HEAD~1     # отменить коммит И изменения (опасно)
git revert <hash>           # безопасная отмена в новом коммите

Восстановление:

  • git reflog — журнал всех перемещений HEAD; спаситель при «потерял коммиты после reset --hard/rebase». Находим хеш и git reset --hard <hash> / git checkout <hash>.
  • git stash — временно спрятать незакоммиченные изменения (stash pop — вернуть).
  • git restore / git checkout -- file — откатить файл к последнему коммиту.

Reset vs revert: reset переписывает историю (для локальных, ещё не запушенных изменений); revert добавляет отменяющий коммит (для уже опубликованных).


Git: ветвление и стратегии

  • Git Flow — ветки main, develop, feature/*, release/*, hotfix/*. Структурно, но тяжело; подходит для релизов по расписанию.
  • GitHub Flow — простой: main всегда деплоится, фичи в короткоживущих ветках → PR → merge в main → деплой. Для непрерывной поставки.
  • Trunk-based development — все работают в одной ветке (main/trunk) короткоживущими ветками, частые мержи, фичи прячут за feature flags. Хорошо для CI/CD и частых релизов.

Общее правило современных команд: короткоживущие ветки, частая интеграция, PR/MR с ревью и прогоном CI перед мержем.


Git: работа в команде

Pull Request (GitHub) / Merge Request (GitLab) — предложение влить ветку: код-ревью, обсуждение, автоматический прогон CI, проверки перед мержем.

git remote -v
git fetch origin              # скачать изменения без слияния
git pull                      # fetch + merge (или --rebase)
git push origin feature       # отправить ветку
git push --force-with-lease   # безопасный форс (после rebase; не затрёт чужие пуши)
  • .gitignore — что не коммитить (node_modules, .env, /vendor, сборки). Секреты никогда в репозиторий.
  • Хуки (hooks) — скрипты на события git: pre-commit (линт/формат перед коммитом), pre-push, commit-msg. Часто через Husky (Node) / lefthook.
  • Разрешение конфликтов — при merge/rebase git помечает конфликтные участки (<<<<<<<, =======, >>>>>>>), их правят вручную, затем git add + продолжают.
  • Теги — git tag v1.2.0 (метки релизов), часто по SemVer.
  • Conventional Commits — соглашение о сообщениях (feat:, fix:, chore:) — для автогенерации changelog и версий.

CI/CD: понятия

CI (Continuous Integration) — непрерывная интеграция: разработчики часто вливают код в общую ветку, и на каждый push/PR автоматически запускаются сборка, тесты, линтеры. Цель — ловить проблемы рано, держать main рабочим.

CD — два смысла:

  • Continuous Delivery — код после CI автоматически готов к деплою (собран артефакт), но выкатка на прод — по кнопке (ручное подтверждение).
  • Continuous Deployment — полностью автоматический деплой на прод после прохождения пайплайна.

Pipeline (пайплайн) — последовательность этапов, которые проходит код. Типовые этапы:

push/PR → [build] → [lint] → [test] → [security scan] → [build image] → [deploy staging] → [deploy prod]

Общие понятия (есть в любой CI-системе):

  • Job (задача) — единица работы (например, «запустить тесты»).
  • Stage (этап) — группа задач, выполняемых вместе; этапы идут последовательно, задачи внутри — параллельно.
  • Runner / Agent — машина (или контейнер), которая выполняет задачи.
  • Artifacts (артефакты) — файлы-результаты (собранный бандл, отчёты), передаются между задачами/сохраняются.
  • Cache (кэш) — переиспользование зависимостей между запусками (ускорение).
  • Triggers (триггеры) — что запускает пайплайн (push, PR/MR, тег, расписание, вручную).
  • Environments — окружения (dev/staging/prod) с правами и секретами.

Зачем разработчику: понимать, почему «упал пайплайн», читать логи джоб, писать/править конфиг пайплайна, добавлять шаги (тесты, линт, сборку образа).


GitHub Actions

CI/CD, встроенный в GitHub. Конфигурация — YAML-файлы в .github/workflows/.

Понятия: workflow (весь процесс) → jobs (задачи, по умолчанию параллельны) → steps (шаги внутри job) → actions (переиспользуемые шаги из Marketplace, например actions/checkout). Джобы выполняются на runners (ubuntu-latest и др., GitHub-hosted или self-hosted).

Пример — тесты и линт на каждый push/PR:

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main]
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4              # склонировать репозиторий
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: npm                            # кэш зависимостей
      - run: npm ci
      - run: npm run lint
      - run: npm test

Пример со сборкой Docker-образа и публикацией в GitHub Container Registry (только на push в main):

name: Build & Push

on:
  push:
    branches: [main]

jobs:
  docker:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
    steps:
      - uses: actions/checkout@v4
      - uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}   # встроенный секрет
      - uses: docker/build-push-action@v6
        with:
          push: true
          tags: ghcr.io/${{ github.repository }}:${{ github.sha }}

Полезное:

  • on — триггеры: push, pull_request, workflow_dispatch (вручную), schedule (cron), release.
  • needs — зависимости между джобами (последовательность).
  • matrix — запустить джобу на нескольких версиях/ОС:
    strategy:
      matrix:
        node: [18, 20, 22]
    steps:
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
  • if — условия выполнения (if: github.ref == 'refs/heads/main').
  • Secrets — ${{ secrets.NAME }} (задаются в Settings → Secrets); GITHUB_TOKEN — автоматический токен репозитория.
  • Environments — с правилами защиты (ручное подтверждение перед prod).
  • Reusable workflows / composite actions — переиспользование.
  • Concurrency — отменять устаревшие запуски.

GitLab CI/CD

CI/CD, встроенный в GitLab. Конфигурация — файл .gitlab-ci.yml в корне репозитория.

Понятия: stages (этапы, последовательные) → jobs (задачи; попадают в этап через stage:, внутри этапа параллельны) → выполняются на runners (shared или свои). Pipeline запускается на push/MR/тег/расписание.

Пример — сборка, тесты, деплой:

# .gitlab-ci.yml
stages:
  - build
  - test
  - deploy

variables:
  NODE_ENV: test

# кэш зависимостей между джобами/запусками
cache:
  key: ${CI_COMMIT_REF_SLUG}
  paths:
    - node_modules/

build:
  stage: build
  image: node:20-alpine
  script:
    - npm ci
    - npm run build
  artifacts:
    paths:
      - dist/                     # передать результат дальше по пайплайну
    expire_in: 1 hour

test:
  stage: test
  image: node:20-alpine
  script:
    - npm ci
    - npm run lint
    - npm test
  coverage: '/Coverage: \d+/'

deploy_staging:
  stage: deploy
  image: alpine
  script:
    - ./deploy.sh staging
  environment:
    name: staging
  rules:
    - if: '$CI_COMMIT_BRANCH == "main"'    # только на main

deploy_prod:
  stage: deploy
  script:
    - ./deploy.sh production
  environment:
    name: production
  rules:
    - if: '$CI_COMMIT_TAG'                  # только на тег
      when: manual                          # ручной запуск (кнопка) — Continuous Delivery

Сборка и публикация Docker-образа (Docker-in-Docker):

build_image:
  stage: build
  image: docker:27
  services:
    - docker:27-dind                        # Docker-in-Docker
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

Полезное:

  • rules / only/except — когда запускать джобу (ветка, тег, MR).
  • when — on_success (по умолч.), manual (кнопка), always, delayed.
  • needs — DAG: джоба стартует, не дожидаясь всего этапа (ускорение).
  • artifacts vs cache — артефакты передают результаты между этапами и сохраняются; кэш переиспользует зависимости между запусками.
  • Встроенные переменные — CI_COMMIT_SHA, CI_COMMIT_BRANCH, CI_REGISTRY, CI_REGISTRY_IMAGE, CI_PIPELINE_ID.
  • Секреты — CI/CD Variables (Settings → CI/CD → Variables), можно masked/protected.
  • Environments — окружения с URL и историей деплоев, ручное подтверждение для prod.
  • include — подключать шаблоны/другие файлы (переиспользование).

GitHub Actions vs GitLab CI

Аспект GitHub Actions GitLab CI/CD
Конфиг .github/workflows/*.yml (много файлов) .gitlab-ci.yml (один файл, можно include)
Единицы workflow → jobs → steps → actions pipeline → stages → jobs
Переиспользование Marketplace (готовые actions) шаблоны через include, extends
Runners GitHub-hosted / self-hosted shared / self-hosted
Реестр образов GHCR встроенный GitLab Container Registry
Секреты Secrets, GITHUB_TOKEN CI/CD Variables (masked/protected)
Ручной деплой environments + approvals when: manual, protected environments
DAG-ускорение needs needs

Концептуально очень похожи: этапы, джобы, раннеры, кэш, артефакты, секреты, окружения, ручные шаги для прода. Разница в синтаксисе и экосистеме (Actions Marketplace vs GitLab-шаблоны).


Стратегии деплоя

Как выкатывать новую версию с минимальным риском/даунтаймом:

  • Recreate — остановить старое, поднять новое. Простой, но есть даунтайм.
  • Rolling update — постепенно заменять экземпляры по одному (стандарт в k8s). Без даунтайма, но какое-то время работают обе версии.
  • Blue-Green — две среды: «синяя» (текущая) и «зелёная» (новая). Переключение трафика на зелёную одномоментно; при проблеме — мгновенный откат на синюю. Требует двойных ресурсов.
  • Canary (канареечный) — новую версию сначала получает небольшой % пользователей; если метрики в норме — постепенно раскатывают на всех. Минимизирует влияние багов.
  • Feature flags — выкатить код выключенным, включать фичу флагом (отдельно от деплоя), в т.ч. для части пользователей (A/B).

Rollback (откат) — вернуться на предыдущую рабочую версию при проблеме (по образу с прошлым тегом/через оркестратор). Заранее определяют rollback triggers (при каких метриках/ошибках откатываемся). Для БД — миграции должны быть обратимыми/безопасными (сначала добавить, потом удалять в отдельном релизе).


Секреты и переменные окружения

  • 12-factor: конфигурация — через переменные окружения, а не в коде. Разное окружение (dev/stage/prod) — разные значения.
  • .env — локально; никогда не в git (в .gitignore), в репозитории — только .env.example (шаблон без значений).
  • Секреты в CI/CD — хранят в защищённых переменных (GitHub Secrets / GitLab CI Variables), маскируются в логах, доступны только нужным окружениям/веткам (protected).
  • Секрет-хранилища — HashiCorp Vault, AWS Secrets Manager, k8s Secrets — для прода.
  • Правила: не логировать секреты, не коммитить, ротация при компрометации, минимум прав (least privilege).

Вероятные вопросы

Чем контейнер отличается от виртуальной машины? Контейнер использует ядро хоста (изоляция через namespaces/cgroups), лёгкий и быстрый; ВМ тащит целую ОС с гипервизором — тяжелее и медленнее.

Образ vs контейнер? Образ — неизменяемый шаблон (снимок ФС); контейнер — запущенный экземпляр образа с записываемым слоем сверху.

Как устроены слои образа и зачем это знать? Каждый шаг Dockerfile — слой; слои кэшируются. При изменении шага пересобираются он и все последующие. Поэтому редко меняющиеся шаги (зависимости) ставят выше исходников.

Зачем multi-stage build? Собрать в одной стадии (с билд-инструментами), в финальный образ скопировать только результат — маленький и безопасный прод-образ.

CMD vs ENTRYPOINT? ENTRYPOINT — что запускается всегда; CMD — аргументы по умолчанию (переопределяются при run). RUN — при сборке, CMD/ENTRYPOINT — при запуске.

Как контейнеры общаются и как хранят данные? По имени сервиса в общей bridge-сети (встроенный DNS); данные — в volumes (не в эфемерном слое контейнера).

Что делает docker compose? Описывает многоконтейнерное приложение в YAML и поднимает одной командой; сервисы видят друг друга по имени, depends_on, тома/сети — там же.

Что такое Kubernetes и его базовые объекты? Оркестратор контейнеров: Pod, Deployment (реплики/rolling update), Service (стабильный доступ), Ingress, ConfigMap/Secret, Namespace, HPA. Декларативность: описываешь желаемое состояние, k8s поддерживает его.

Merge vs rebase? Merge создаёт merge-коммит, сохраняет историю; rebase переписывает коммиты для линейной истории. Не делать rebase публичных веток.

reset vs revert? reset двигает указатель/переписывает историю (для локального); revert создаёт отменяющий коммит (безопасно для общих веток).

Как восстановить потерянные коммиты? git reflog — найти хеш и reset --hard/checkout. Незакоммиченное можно прятать в git stash.

Что такое ветка в git? Просто указатель (ref) на коммит; создание дёшево. HEAD — указатель на текущую ветку.

Какие стратегии ветвления знаешь? Git Flow (структурно, релизы по расписанию), GitHub Flow (main всегда деплоится), trunk-based (одна ветка + feature flags, под CI/CD).

Что такое CI/CD? CI — автоматические сборка/тесты на каждый push/PR; Continuous Delivery — готово к деплою по кнопке; Continuous Deployment — авто-деплой на прод.

Что такое пайплайн, джоба, этап, раннер, артефакт? Пайплайн — последовательность этапов; этап — группа джоб (последовательно), джобы внутри параллельны; раннер — исполнитель; артефакт — файл-результат, передаётся дальше.

Как настроить CI в GitHub Actions? YAML в .github/workflows/: on (триггеры), jobs → steps, готовые actions (checkout, setup-node), кэш, matrix, secrets, needs. (Показать ci.yml.)

Как настроить CI в GitLab? .gitlab-ci.yml: stages, jobs со script, image, artifacts/cache, rules/when: manual, environment, встроенные CI_* переменные.

artifacts vs cache в CI? Артефакты — результаты сборки, передаются между этапами и сохраняются; кэш — переиспользование зависимостей между запусками для ускорения.

Стратегии деплоя? Recreate (даунтайм), rolling (постепенно), blue-green (переключение сред + мгновенный откат), canary (% пользователей), feature flags. Rollback — откат на прошлую версию; миграции БД — обратимые.

Где хранить секреты? В переменных окружения / защищённых CI-переменных / секрет-хранилищах (Vault, k8s Secrets); не в коде и не в git; маскировать в логах, ротировать.

Что такое graceful shutdown и при чём тут сигналы? По SIGTERM (шлёт Docker/k8s при остановке) приложение должно корректно завершиться — дождаться запросов, закрыть соединения; SIGKILL убивает без возможности перехвата.

Как отлаживать контейнер, который падает? docker logs, docker exec -it sh (если жив), docker inspect, проверить порты (-p), переменные окружения, права на тома, архитектуру образа.