К содержимому
Войти

PHP Road Map

🐳 Docker

Docker упаковывает сервис вместе со всем, что ему нужно для запуска, в образ, и этот образ одинаково стартует на ноутбуке, в CI и на проде. Для бэкенд-разработчика это повседневная работа: написать Dockerfile, поднять Postgres и Kafka локально, понять, почему контейнер не останавливается или весит гигабайт. Docker указан ключевым навыком в 21% мидл-вакансий на Go и в 26% на Node.js из нашего недельного среза, а на собеседовании спрашивают «чем контейнер отличается от виртуалки», «как Docker запускает контейнер» и «как уменьшить образ»

🧠 Контейнер — это процесс

Виртуальная машина эмулирует целый компьютер со своим ядром. Контейнер — обычный процесс на хосте, которому ядро Linux ограничило, что он видит и сколько ресурсов может взять. Ядро у всех контейнеров на машине одно, поэтому контейнер стартует за доли секунды, а не за десятки секунд, как ВМ

Что процесс видит, задают namespaces. Каждый тип изолирует свою часть системы:

NamespaceЧто изолируетЧто видно изнутри контейнера
PIDНумерацию процессовСвой процесс с PID 1, чужих процессов не видно
NetworkСетевые интерфейсы, порты, маршрутыСвой eth0 и свой порт 8080, который не конфликтует с хостом
MountТочки монтированияКорневая файловая система из образа, а не диск хоста
UTSИмя хостаСвоё hostname
IPCОчереди сообщений и общая память System VТолько свои объекты
UserUID и GIDroot внутри может быть обычным пользователем снаружи

Сколько ресурсов процесс может взять, задают cgroups: лимит памяти, доля CPU, число процессов. По умолчанию Docker никаких лимитов не ставит, контейнер берёт столько, сколько даст планировщик ядра. С --memory=512m контейнер, который вылез за лимит, убивает OOM-killer ядра. Как рантайм Go читает эти лимиты, разобрано на странице Go в контейнере

Проще всего это увидеть руками:

docker run --rm alpine ps
# PID   USER     TIME  COMMAND
#     1 root      0:00 ps

Внутри контейнера ps — единственный процесс, и у него PID 1. На хосте тот же процесс виден с обычным большим номером

Виртуальная машинаКонтейнер
ЯдроСвоё у каждой ВМОбщее с хостом
СтартДесятки секунд, грузится ОСДоли секунды, стартует процесс
РазмерГигабайты, целая ОСМегабайты, приложение и его файлы
ИзоляцияСильная, граница — гипервизорСлабее, граница — ядро. Уязвимость ядра бьёт по всем контейнерам
Другая ОСМожно запустить Windows на LinuxТолько то же ядро. Docker Desktop на macOS прячет внутри Linux-ВМ

Что происходит при docker run

  1. Клиент docker отправляет команду демону dockerd по REST API через UNIX-сокет
  2. Если образа нет локально, демон скачивает его слои из registry: Docker Hub по умолчанию или свой, например GitLab Registry
  3. Демон передаёт контейнер в containerd, который управляет жизненным циклом: создать, запустить, остановить
  4. containerd через shim вызывает runc. runc создаёт namespaces и cgroups, монтирует файловую систему из слоёв образа и запускает процесс из ENTRYPOINT
  5. Поверх слоёв образа появляется тонкий слой для записи, контейнер получает сетевой интерфейс и IP в сети Docker

После exit контейнер останавливается, но не удаляется: его можно запустить снова. Всё, что процесс записал на диск, живёт в слое для записи и пропадает вместе с docker rm. Поэтому данные Postgres кладут в volume, а не внутрь контейнера

🧱 Образ и слои

Образ — неизменяемый набор слоёв плюс метаданные: какую команду запускать, от какого пользователя, какие переменные окружения. Каждая инструкция Dockerfile, которая меняет файлы (RUN, COPY, ADD), даёт новый слой. Слои только для чтения, и одинаковые слои хранятся один раз: десять контейнеров из одного образа делят его слои, а у каждого свой только верхний слой для записи

Когда контейнер меняет файл из нижнего слоя, файл сначала копируется в его слой для записи. Это copy-on-write: пока файл только читают, копии нет

Из слоёв следуют две вещи, о которых спрашивают на собеседовании

Кэш сборки идёт сверху вниз. Если слой поменялся, все слои под ним пересобираются, даже если их инструкции те же. Поэтому сначала копируют то, что меняется редко, а код последним:

COPY go.mod go.sum ./
RUN go mod download     # пересоберётся, только если поменялись зависимости
COPY . .                # меняется при каждом коммите
RUN go build -o /out/app .

Если поставить COPY . . первой строкой, любая правка в коде заново скачивает все модули

Удаление в следующем слое не уменьшает образ. Файл остаётся в слое, где его создали, а верхний слой только помечает его удалённым. Проверка:

FROM alpine:3.22
RUN dd if=/dev/urandom of=/big bs=1M count=50
RUN rm /big

docker history покажет слой с dd на 52.4 МБ и слой с rm на 0 Б. Файла в контейнере нет, а образ тяжелее на 50 МБ. С секретом то же самое: COPY .env и RUN rm .env оставляют его в слое, достать его можно из скачанного образа

🛠️ Dockerfile для Go-сервиса

Go собирает один бинарник, которому для работы ничего не нужно, если отключить cgo. Поэтому образ Go-сервиса делают в два этапа: multi-stage сборка. На первом этапе работает образ golang с компилятором, на втором берётся минимальная база, куда копируется только бинарник

# syntax=docker/dockerfile:1
FROM golang:1.27 AS build
WORKDIR /src
COPY go.mod go.sum* ./
RUN go mod download
COPY . .
RUN --mount=type=cache,target=/root/.cache/go-build \
    CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/app .

FROM gcr.io/distroless/static-debian13:nonroot
COPY --from=build /out/app /app
USER nonroot:nonroot
EXPOSE 8080
ENTRYPOINT ["/app"]

Что здесь происходит:

  • AS build даёт этапу имя, COPY --from=build берёт из него файл. Всё остальное с первого этапа в итоговый образ не попадает
  • --mount=type=cache сохраняет кэш компилятора между сборками, но не кладёт его в слой. Пересборка после правки одного файла занимает секунды
  • CGO_ENABLED=0 даёт статический бинарник. Без этого флага в образе golang cgo включён, и бинарник с пакетом net линкуется с libc
  • -ldflags="-s -w" выкидывает таблицу символов и отладочную информацию, бинарник становится меньше
  • distroless/static содержит только сертификаты, часовые пояса и пользователя nonroot. Ни шелла, ни пакетного менеджера, так что у атакующего в контейнере нет даже sh
  • EXPOSE ничего не публикует, это документация. Порт открывает docker run -p 8080:8080 или Service в Kubernetes

Для небольшого HTTP-сервиса этот Dockerfile даёт образ на 7.81 МБ, из них 2.37 МБ занимает база distroless. Сам golang:1.27, в котором шла сборка, весит 900 МБ. Образ меньше — быстрее скачивается на ноду при деплое и меньше пакетов, в которых сканер найдёт уязвимости

Какую базу брать:

БазаРазмерКогда
scratch0Совсем пусто: нет даже сертификатов для HTTPS и /etc/passwd. Всё нужное копируешь сам
distroless/staticоколо 2 МБСтатический Go-бинарник. Разумный выбор по умолчанию
distroless/baseбольше, есть glibcБинарник с cgo
alpineоколо 9 МБНужен шелл и пакеты. Внутри musl вместо glibc, с cgo это источник сюрпризов

Для отладки у distroless есть тег :debug с шеллом busybox. В прод его не ставят

Локально сервис запускают вместе с зависимостями через docker compose: один файл описывает Postgres, Kafka и сам сервис, docker compose up поднимает всё. Если сервис должен ждать базу, у Postgres пишут healthcheck, а у сервиса depends_on с condition: service_healthy. Без этого сервис стартует раньше, чем база начала принимать соединения

⚠️ Где ошибаются

Shell-форма ENTRYPOINT. Запись ENTRYPOINT /app без квадратных скобок запускает команду через /bin/sh -c. Документация Docker предупреждает, что такой шелл не передаёт сигналы. docker stop шлёт SIGTERM процессу с PID 1, ждёт 10 секунд и добивает SIGKILL. На Alpine с ENTRYPOINT /app && echo done это легко воспроизвести. PID 1 в контейнере — sh, SIGTERM до сервиса не доходит, остановка занимает 11 секунд, код выхода 137. Graceful shutdown не срабатывает, запросы в полёте обрываются. Один голый /app busybox запускает сам вместо шелла, и сигнал доходит, но полагаться на это не стоит. Пиши exec-форму ["/app"], а остановку в Go делай через signal.NotifyContext, как на странице про graceful shutdown

Бинарник с cgo в статической базе. Собрали без CGO_ENABLED=0, положили в distroless/static или scratch и получили при старте:

exec /app: no such file or directory

Файл на месте, сообщение сбивает с толку. Ядро не нашло динамический загрузчик ld-linux, на который ссылается бинарник: в статической базе его нет. Лечится CGO_ENABLED=0 или базой с glibc

Секреты в образе. Токен в ARG, ENV или скопированный и удалённый файл остаются в слоях, и их видит каждый, кто скачал образ. Для приватных модулей при сборке есть build secrets: RUN --mount=type=secret,id=netrc в Dockerfile и docker build --secret id=netrc,src=$HOME/.netrc. Секрет появляется в /run/secrets/netrc только на время одной команды. Секреты для работы сервиса передают переменными окружения или файлами при запуске, а не в образе

Тег latest и плавающие версии. FROM golang:latest сегодня и через месяц — разные образы, сборка перестаёт быть воспроизводимой. Фиксируй версию базы, а свой образ в registry помечай версией или хэшем коммита. Для Kubernetes это важно: тег latest не говорит, какой код сейчас крутится

Запуск от root. Процесс в контейнере по умолчанию работает от root. Изоляция держится на ядре, и root внутри при уязвимости ближе к root на хосте. USER nonroot в Dockerfile стоит одну строку

🎯 Вопросы с собеседований

Чем контейнер отличается от виртуальной машины?

ВМ запускает свою ОС со своим ядром поверх гипервизора. Контейнер — процесс на хосте, изолированный namespaces и ограниченный cgroups, ядро общее. Поэтому контейнер стартует за доли секунды и весит мегабайты. Плата — более слабая изоляция: уязвимость ядра затрагивает все контейнеры, и запустить другую ОС нельзя

Как Docker запускает контейнер?

Клиент отправляет запрос демону dockerd. Тот при необходимости скачивает слои образа из registry и передаёт контейнер в containerd. containerd через shim вызывает runc, а runc создаёт namespaces и cgroups, собирает корневую файловую систему из слоёв образа с верхним слоем для записи и запускает процесс из ENTRYPOINT с PID 1 внутри контейнера

Что такое namespaces и cgroups?

Это механизмы ядра Linux, из которых сделан контейнер. Namespaces ограничивают, что процесс видит: свои PID, сеть, точки монтирования, имя хоста, пользователей. Cgroups ограничивают, сколько он потребляет: память, CPU, число процессов. Docker сам по себе изоляцию не изобретает, он настраивает эти механизмы

Что такое образ и слой? Что будет с данными при удалении контейнера?

Образ — набор неизменяемых слоёв и метаданных запуска. Каждая инструкция, которая меняет файлы, даёт слой, одинаковые слои хранятся и скачиваются один раз. Контейнер добавляет сверху свой слой для записи, изменения туда попадают по copy-on-write. При docker rm этот слой удаляется вместе со всеми данными, поэтому всё, что должно пережить контейнер, кладут в volume

Как уменьшить образ Go-сервиса?

Multi-stage сборка: компилирую в образе golang, во второй этап копирую только бинарник. Собираю с CGO_ENABLED=0, чтобы бинарник был статическим, и кладу его в distroless/static или scratch. Флаги -ldflags="-s -w" убирают отладочную информацию. Так образ получается в единицы мегабайт вместо сотен, а заодно в нём нет шелла и лишних пакетов

Зачем копировать go.mod отдельно от кода?

Из-за кэша слоёв: если слой поменялся, все следующие пересобираются. go.mod и go.sum меняются редко, поэтому go mod download после них берётся из кэша. Код копируется после, и правка в нём пересобирает только компиляцию, а не скачивание зависимостей

Чем отличаются CMD и ENTRYPOINT? Что такое shell-форма и exec-форма?

ENTRYPOINT задаёт, что запускать, а CMD — аргументы по умолчанию, их перекрывает то, что передали в docker run. Exec-форма ["/app"] запускает процесс напрямую, и он получает PID 1 и сигналы. Shell-форма /app оборачивает команду в /bin/sh -c, такой шелл может не передать SIGTERM, и docker stop через 10 секунд убьёт сервис SIGKILL

Почему сервис в контейнере не завершается корректно при остановке?

Частая причина — shell-форма ENTRYPOINT или скрипт-обёртка без exec: SIGTERM получает шелл, а не приложение. Вторая — приложение не ловит SIGTERM, и рантайм Go завершает его сразу, не дождавшись запросов. Третья — остановка дольше таймаута: Docker ждёт 10 секунд, в Kubernetes по умолчанию 30, потом SIGKILL. Проверяю, кто PID 1 в контейнере, и что сервис ловит сигнал и укладывается в таймаут

📚 Что почитать

  • Multi-stage builds — официальная страница с примером на Go и флагом --target
  • Optimize cache usage in builds — порядок слоёв, .dockerignore, cache mount с путями кэша Go
  • Distroless — какие базы есть, теги nonroot и debug
  • namespaces(7) — man-страница со списком всех типов namespaces и что каждый изолирует