Linux, Docker, Git, CI/CD
Материал для подготовки к собеседованию (Middle / Senior). DevOps-темы с точки зрения разработчика: что нужно уметь, чтобы собирать, контейнеризовать, версионировать и деплоить свой код. Термины на английском там, где это принято.
Содержание
- Linux: основы для разработчика
- Файловая система и права доступа
- Процессы и сигналы
- Основные утилиты и пайпы
- Сеть и порты
- Сервисы, логи, cron
- Docker: зачем и как
- Образы, контейнеры, слои
- Dockerfile
- Multi-stage builds и оптимизация
- Тома и данные
- Сети Docker
- docker compose
- Docker в проде и отладка
- Kubernetes: обзор для разработчика
- Git: модель и внутреннее устройство
- Git: merge, rebase, cherry-pick
- Git: reset, revert, восстановление
- Git: ветвление и стратегии
- Git: работа в команде
- CI/CD: понятия
- GitHub Actions
- GitLab CI/CD
- GitHub Actions vs GitLab CI
- Стратегии деплоя
- Секреты и переменные окружения
- Вероятные вопросы
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: джоба стартует, не дожидаясь всего этапа (ускорение).artifactsvscache— артефакты передают результаты между этапами и сохраняются; кэш переиспользует зависимости между запусками.- Встроенные переменные —
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), переменные окружения, права на тома, архитектуру образа.