✻ Урок 5.2 · Тема 5: Docker и учебный стенд
Dockerfile: как собирается образ «Магазина»
Содержание урока
Как работать с кодом и когда идти дальше
Команды не нужно писать по памяти. Пользуйся примерами из урока и справкой. Ориентируйся на цель задания:
- Запусти готовое. Код приложения и вспомогательных скриптов можно скопировать. Пойми, зачем они нужны, что запускают или меняют и как проверить результат. Разбирать каждую функцию внутри готового инструмента не требуется.
- Измени по образцу. Разбери новые конструкции, объяснённые в уроке. Измени указанный параметр или часть кода, предскажи результат и проверь запуском.
- Напиши сам. Собери свой вариант под условия задания. Образцы и справка разрешены: важно объяснить своё решение и проверить его работу.
Можно идти дальше, если ты выполнил практику, получил ожидаемый результат и понимаешь, что проверил. Если задание просит изменить код, проверь и своё изменение.
Непонятные детали готового инструмента можно оставить на потом. При ошибке запуска вернись к разбору вывода и типичным ошибкам в уроке.
Зачем это нужно
Я прошу новичков начинать именно с этого урока про сборку: на нём я сам когда-то терял часы.
В команде магазина решили: тебе нужна своя копия «Магазина», на которой можно ломать что угодно. В уроке 5.1 ты запускал готовые образы: nginx, PostgreSQL. Но образа «Магазина» на Docker Hub нет: он собирается на твоей машине при первом docker compose up --build (Compose разберём в уроке 5.3). Флаг --build велит собрать образ из исходников. Помнишь, в 2.1 первый запуск занимал больше минуты? Это шла сборка.
Главный вопрос урока: как убедиться, что замер идёт по новому образу, а не по старому? Ловушка выглядит так: ты поправил код, пересобрал образ, прогнал тест и радуешься, что задержка упала вдвое. Потом выясняется, что контейнер запущен из старого образа, и почти два часа ты мерил старый код. Хронология:
10:00 поправил код
10:05 пересобрал образ, запустил тест: задержка упала вдвое
12:00 выяснилось: контейнер всё это время работал из образа недельной давности
Поэтому перед замером сверяй, из чего собран образ (время создания видно в docker image ls --format '{{.Tag}} {{.CreatedSince}}', шаг 2 практики).
Этот рецепт называется Dockerfile, и для тебя он рабочий инструмент. Не понимая, как образ собирается, ты будешь либо ждать лишние минуты, либо тестировать старый код, думая, что он новый. К тому же рецепт документирует сервис: версию Python, библиотеки, команду запуска. На вопрос «на какой версии проверяли» ответ лежит там. Он же отвечает на фразу «а у меня работало»: рецепт один, образ у всех одинаковый.
Шаг проекта: ты разберёшь project/shop/shop/Dockerfile и entrypoint.sh по строкам, соберёшь образ командой docker build и нарочно сломаешь кэш сборки. Файлы для экспериментов лежат в ~/perf-lab/05-docker/: чужой клон репозитория мы не портим.
Что нужно знать
- Образ, контейнер, слои, теги: урок 5.1. В 5.1 мы только назвали
docker history, теперь запустишь его на своём образе и увидишь, откуда берутся слои. - Файлы, переменные окружения и
PATH: урок 1.1, права на выполнение (chmod +x) и скрипты оболочки#!/bin/sh: урок 1.5. - Стенд «Магазин» и его устройство в общих чертах: урок 2.3.
- Python,
pipиrequirements.txtпо-настоящему ты проходишь в теме 4. Здесь достаточно знать:pip installскачивает библиотеки, аrequirements.txtэто их список. - Глубже про написание Dockerfile и многоэтапную сборку: урок DevOps «Dockerfile». Для курса хватит того, что ниже.
Картина целиком
Dockerfile похож на рецепт блюда с заготовками. В рецепте сказано: «возьми готовую основу (Python), поставь на неё библиотеки, положи код и запускай вот так». Повар (команда docker build) идёт по шагам сверху вниз и после каждого делает снимок (слой). Если завтра ты поменяешь только последний шаг, повар не станет готовить всё заново: достанет снимок после предпоследнего шага и сделает только последний. Это и есть кэш.
flowchart TD
A["Dockerfile<br/>рецепт"] --> B["docker build"]
B --> C["Слой 1: основа Python"]
C --> D["Слой 2: библиотеки"]
D --> E["Слой 3: код приложения"]
E --> F["Образ shop-lab"]
F -->|"docker run"| G["Контейнер"]
Здесь видно: каждая строка даёт слой, а итог это образ, из которого запускают контейнеры. Главная мысль урока: порядок строк определяет скорость сборки. Редкое (библиотеки) ставят выше, частое (код) ниже.
Теория
Я тоже первое время писал Dockerfile «как получится» и платил за это долгими пересборками, поэтому порядок строк разберём внимательно.
Dockerfile: рецепт образа
«У меня на машине работало» стоит командам больше времени, чем любая другая фраза. Если образ собирали руками (зашли в контейнер, поставили, сохранили), то через месяц никто не вспомнит, что именно поставили. Повторить такую сборку нельзя, проверить тоже. Dockerfile лежит в git, и его правки видны в истории.
Поэтому образ собирают по текстовому рецепту, который лежит в git рядом с кодом. Это Dockerfile: рецепт, по которому образ можно в любой момент собрать заново и получить такой же. Если в рецепте написано просто «возьми муку», а на складе поменяли сорт, блюдо выйдет другим. Поэтому версии в Dockerfile «Магазина» зафиксированы жёстко.
Dockerfile это обычный текстовый файл без расширения. Каждая строка начинается с инструкции (заглавное слово), дальше идут аргументы. Сборка идёт сверху вниз. RUN и COPY меняют файлы и создают слой с содержимым. ENV, EXPOSE, ENTRYPOINT, WORKDIR только дописывают настройки. Весь Dockerfile «Магазина» умещается в десять строк:
FROM python:3.14.8-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app ./app
COPY entrypoint.sh .
RUN chmod +x entrypoint.sh
ENV PYTHONUNBUFFERED=1 PROMETHEUS_MULTIPROC_DIR=/tmp/shop-metrics
EXPOSE 8000
ENTRYPOINT ["./entrypoint.sh"]
Осторожно: Dockerfile путают с compose.yaml. Первый описывает, как собрать один образ, второй, как запустить несколько контейнеров вместе (урок 5.3).
Главное: Dockerfile это воспроизводимый и читаемый рецепт образа, который живёт в git рядом с кодом.
Пройдём по строкам в порядке сборки, с первой.
FROM: основа образа
Ставить систему и Python с нуля в каждом образе бессмысленно: берут готовый образ и строят поверх. Первая инструкция Dockerfile почти всегда FROM (перед ним допустим только ARG), она задаёт базовый образ, нижний слой стопки.
FROM python:3.14.8-slim читается так: «возьми образ python с тегом 3.14.8-slim». 3.14.8 это версия Python, а slim вариант образа: только Python и минимум системы, около 130 МБ. Полный python:3.14.8 с компиляторами весит около 1 ГБ, а alpine около 50 МБ, но часть библиотек на нём ведёт себя иначе. «Магазин» берёт slim: он достаточно мал и совместим с готовыми бинарными библиотеками (psycopg[binary], bcrypt). Цена: в slim нет curl, поэтому проверку здоровья в compose.yaml делают через Python (в 5.3 увидишь).
Прикинь сам: зачем в
FROMуказывать3.14.8-slim, а не простоpython?
Без тега Docker возьмёт latest (урок 5.1), и через несколько месяцев там окажется другой Python. Образ поведёт себя иначе, чем при прошлых замерах, и результаты тестов не получится сравнивать. Точная версия делает сборку воспроизводимой.
Осторожно: версия Python в Dockerfile и Python на твоей машине не связаны. В контейнере работает 3.14.8, а у тебя на Ubuntu может быть 3.12, и это нормально: в этом смысл контейнера.
Для любопытных: многоэтапная сборка
Если компилятор нужен только для сборки, в одном Dockerfile пишут несколько FROM (multi-stage build). Первый этап собирает на тяжёлом образе, второй копирует готовый результат на лёгкий (COPY --from=build ...). В итоговый образ попадают слои только последнего этапа. «Магазину» это не нужно: его библиотеки приходят скомпилированными.
Главное:
FROMвыбирает основу, и точный тег (3.14.8-slim) делает сборку повторяемой.
Основа есть. Теперь нужны код и библиотеки.
WORKDIR, COPY, RUN: папка, файлы и команды
Для этого три инструкции. WORKDIR /app создаёт папку /app и делает её текущей для всех следующих строк и для запуска. Это как mkdir /app && cd /app (урок 1.1), только навсегда.
COPY откуда куда копирует файлы с твоей машины внутрь образа. Берёт он их не из папки, где ты стоишь в терминале, а из контекста сборки: папки, которую ты указал последним аргументом docker build (у нас project/shop/shop/). COPY requirements.txt . кладёт файл в /app, COPY app ./app кладёт код в /app/app. Есть и ADD: он умеет скачивать по ссылке и распаковывать архивы, поэтому по умолчанию берут простой COPY.
RUN команда выполняет команду во время сборки, и результат попадает в слой. RUN pip install --no-cache-dir -r requirements.txt ставит библиотеки по списку (-r значит «читай список из файла»). Флаг --no-cache-dir не даёт pip хранить скачанные архивы: они раздули бы слой. RUN chmod +x entrypoint.sh даёт скрипту право на исполнение (флаг x, урок 1.1): в репозитории он хранится без него, поэтому право закрепляют явно.
Важны два момента времени. RUN и COPY отрабатывают при сборке один раз, и результат запечатывается в образ. Запуск контейнера идёт потом и сколько угодно раз.
flowchart TD
A["docker build<br/>RUN и COPY: один раз"] --> B["Образ<br/>библиотеки уже внутри"]
B -->|"docker run"| C["Контейнер 1"]
B -->|"docker run"| D["Контейнер 2"]
Схема показывает: тяжёлую работу делает сборка, а контейнеры берут готовое.
Прикинь сам:
RUN pip installвыполнился при сборке, потом ты запустил из образа три контейнера. Сколько раз pip скачивал библиотеки?
Один раз, при сборке. Библиотеки запечатаны в слое образа, контейнеры их просто используют. Поэтому контейнер стартует быстро: если бы библиотеки ставились при запуске, каждый старт занимал бы минуту.
Для любопытных: `COPY --chmod` вместо `RUN chmod`
COPY --chmod=755 entrypoint.sh . копирует файл и выдаёт право одним шагом. Отдельный RUN chmod создаёт ещё один слой с полной копией файла (в docker history его размер виден дважды), а при COPY --chmod лишнего слоя нет. Тот же результат даёт право x, записанное в git (git update-index --chmod=+x). «Магазин» оставлен с RUN chmod, потому что файл крошечный, но в своих Dockerfile бери COPY --chmod.
Главное:
COPYберёт файлы из контекста сборки, аRUNвыполняется один раз при сборке и запечатывает результат в образ.
Осталось понять, откуда у pip берутся библиотеки и что значит == в списке.
Откуда берутся библиотеки: pip, PyPI и закреплённые версии
Веб-запросы, хэши паролей и базу никто не пишет с нуля: берут чужой код, оформленный как библиотека. Для Python их хранит общий каталог PyPI (Python Package Index, pypi.org), а программа pip (урок 4.5) скачивает оттуда нужное. При сборке pip скачивает пакеты с pypi.org по списку из requirements.txt. Без номера версии привезут любую, с номером одну и ту же каждый раз.
Список «Магазина» (первые восемь строк):
fastapi==0.142.2
uvicorn[standard]==0.54.0
psycopg[binary,pool]==3.3.6
psycopg-pool==3.3.3
redis==8.1.0
prometheus-client==0.26.0
bcrypt==5.0.0
httpx==0.28.1
# ещё 7 строк opentelemetry-*: трейсы, урок 7.7
== значит «ровно эта версия». Без номера pip взял бы самую свежую, а она со временем меняется. Библиотеки тянут за собой другие: fastapi приведёт starlette и pydantic, их версии pip подберёт сам.
Для нагрузочного тестировщика важны две строки. bcrypt считает хэши паролей и нагружает процессор: поэтому логин в «Магазине» тяжёлый. psycopg с pool ходит в PostgreSQL через пул соединений (урок 2.3), которым мы займёмся в теме 11.
Без == через полгода пересборка без кэша даст другие версии, возможно, с другой производительностью. Поэтому версии записаны жёстко.
Осторожно: pip на твоей машине и в образе ставят в разные места: поставил себе, в контейнере не появилось.
Главное: закреплённые версии (
==) вrequirements.txtдают одинаковый образ сегодня и через полгода.
Версии закреплены, но pip при каждой сборке качает всё. Хочется, чтобы это случалось один раз.
Кэш слоёв: почему порядок строк важен
Первая сборка «Магазина» идёт около минуты с четвертью, почти всё время работает pip. Ты поправил одну строку кода: неужели ждать заново? Нет: Docker запоминает результат каждого шага и использует снова, если шаг не изменился (слово CACHED в выводе).
Аналогия с рецептом здесь ломается: в жизни можно заменить один ингредиент, а в Docker изменил шаг 3, и все шаги после него работают заново, тогда как шаги до него берутся из кэша.
Перед каждым шагом Docker сверяет: та же ли инструкция и, для COPY, те же ли файлы (по хэшу, как в уроке 3.1). Если всё совпало, шаг получает метку CACHED и пропускается. Как только один шаг изменился, все шаги ниже него выполняются заново: старые снимки к ним не подходят. Вот почему Dockerfile «Магазина» устроен именно так. COPY requirements.txt . и RUN pip install стоят до копирования кода: список библиотек меняется редко, и самый дорогой шаг остаётся в кэше. COPY app ./app стоит после: код правят каждый день, но пересобираются только он и дешёвые шаги под ним.
В виджете сравни два порядка. В «плохом» код копируется до установки библиотек (COPY . . одной строкой), поэтому любая правка заставляет pip качать всё заново.
Видно, какие слои Docker выполнил заново: при правке кода в хорошем порядке два-три за пару секунд, в плохом снова работает pip.
Вот цифры для «Магазина». Первая сборка: 1 мин 15 с. Повторная без изменений: 1 с, все слои CACHED. Правка app/main.py: 3 с, pip остаётся в кэше. Правка requirements.txt: около 45 с. Числа примерные, но соотношение (секунды против минуты) у тебя будет таким же.
Прикинь сам: ты поменял одну букву в комментарии в
app/main.pyи пересобрал образ. Какие шаги выполнятся заново и почему pip среди них нет?
Заново пойдут COPY app ./app (файл изменился, хэш другой) и все шаги ниже: COPY entrypoint.sh и RUN chmod. Всё выше (FROM, WORKDIR, COPY requirements.txt, RUN pip install) не менялось и берётся из кэша: requirements.txt тот же, а установка стоит до копирования кода.
Осторожно: кэш видит только Dockerfile и файлы контекста. RUN pip install с незакреплёнными версиями не пересоберётся, пока не изменилась строка, и останется на старой версии, хотя на PyPI вышла новая. Собрать без кэша принудительно можно так: docker build --no-cache.
Главное: Docker пропускает шаг, если он не менялся, но всё ниже изменённого шага пересобирается, поэтому редкое ставят выше, частое ниже.
Библиотеки на месте, код лежит. Остались настройки запуска: что и как стартует при docker run.
ENV, EXPOSE, ENTRYPOINT: настройки запуска
Последние три инструкции не меняют файлы, они дописывают в образ «паспорт».
ENV PYTHONUNBUFFERED=1 PROMETHEUS_MULTIPROC_DIR=/tmp/shop-metrics задаёт переменные окружения (урок 1.1). PYTHONUNBUFFERED=1 отключает буферизацию вывода Python: без неё строки логов появлялись бы в docker logs с опозданием и пропадали при падении. PROMETHEUS_MULTIPROC_DIR это каталог, где рабочие процессы сервера обмениваются счётчиками метрик: каждый считает своё, а /metrics должен отдать сумму. Переменные из compose.yaml или -e перекрывают значения из ENV.
EXPOSE 8000 записывает «программа слушает порт 8000». Это документация, а не открытие порта: наружу его публикуют -p или ports: (урок 5.1).
ENTRYPOINT ["./entrypoint.sh"] задаёт, какая программа запускается при старте контейнера. Список в квадратных скобках (exec-форма) запускает её напрямую, без промежуточной оболочки. Запись без скобок (ENTRYPOINT ./entrypoint.sh, shell-форма) запустила бы то же самое через /bin/sh -c, и главным процессом контейнера стала бы оболочка, а не твоя программа: чем это плохо, видно ниже, на слове exec. Рядом существует CMD: аргументы по умолчанию, которые можно заменить при запуске (в «Магазине» его нет). Отсюда разница с RUN: RUN работает при сборке, ENTRYPOINT и CMD при каждом запуске.
Сам скрипт entrypoint.sh (в последней строке uvicorn это сервер «Магазина»):
#!/bin/sh
set -eu
export PROMETHEUS_MULTIPROC_DIR="${PROMETHEUS_MULTIPROC_DIR:-/tmp/shop-metrics}"
mkdir -p "$PROMETHEUS_MULTIPROC_DIR"
find "$PROMETHEUS_MULTIPROC_DIR" -type f -name '*.db' -delete
exec uvicorn app.main:app --host 0.0.0.0 --port 8000 --workers "${WEB_CONCURRENCY:-1}" --no-access-log
Разберём скрипт по порядку.
#!/bin/shв первой строке называет оболочку для файла (урок 1.5).set -euостанавливает скрипт на первой ошибке.- Следующие две строки готовят каталог для метрик. Запись
${ПЕРЕМЕННАЯ:-значение}подставляет запасное значение, если переменная не задана. find ... -deleteстирает файлы метрик прошлого запуска, иначе счётчики показывали бы старые цифры.- Последняя строка запускает сервер.
--host 0.0.0.0 --port 8000значит «слушай на всех адресах контейнера, на порту 8000» (урок 5.1). --workersзадаёт число воркеров: воркер это рабочий процесс сервера, чем их больше, тем больше запросов обрабатывается одновременно. Число берётся изWEB_CONCURRENCY, по умолчанию один: менять его будем в теме 11.--no-access-logотключает строку лога на каждый запрос, чтобы лог не мешал замерам.
Теперь слово exec: из-за него перезапуск стенда может занимать лишние десять секунд. Вспомни из урока 5.1: у первого процесса контейнера номер (PID) 1, и Docker шлёт команды ему. Вспомни и сигналы: SIGTERM значит «закончи дела и завершайся», SIGKILL значит «убиваем сразу». Без exec оболочка осталась бы PID 1 и получила бы SIGTERM от docker stop, но не передала бы его uvicorn. Через 10 секунд Docker убил бы контейнер силой (код выхода 137). exec заменяет оболочку uvicorn’ом: тот становится PID 1, получает сигнал сам и завершается чисто с кодом 0 (uvicorn ловит SIGTERM и выходит штатно).
flowchart TD
A["docker stop"] -->|"SIGTERM"| B["PID 1"]
B --> C{"Это uvicorn<br/>(через exec)?"}
C -->|"да"| D["Завершается сразу,<br/>код выхода 0"]
C -->|"нет, это sh"| E["Сигнал потерян,<br/>через 10 с SIGKILL, код 137"]
Проверка простая: time docker stop покажет долю секунды с exec и около десяти без него (в «Сломай и почини» ты это измеришь).
Прикинь сам: ты убрал
execиз последней строкиentrypoint.shи пересобрал образ. Что изменится приdocker stopи как это заметить?
SIGTERM придёт оболочке sh, она не передаст его uvicorn. Через 10 секунд контейнер будет убит: docker stop продлится около десяти секунд, а статус станет Exited (137). Заметить можно по времени (time docker stop ...) и по коду выхода в docker ps -a.
Главное:
ENTRYPOINTзапускает сервер при старте, аexecделает сервер процессом 1, чтобы он получал сигнал остановки.
Образ почти готов. Осталось узнать, что именно уезжает в сборку вместе с COPY.
Контекст сборки и .dockerignore
docker build не берёт файлы по одному: он отправляет демону Docker (dockerd, урок 5.1) всю папку, которую ты указал, и COPY может брать файлы только оттуда. Значит, если в папке лежат тяжёлые или секретные вещи (.git, .env, виртуальное окружение), они попадут в контекст и могут оказаться в образе.
Спасает файл .dockerignore со списком исключений: .git, .venv, __pycache__, .env. В project/shop/shop/ его нет: код маленький. На рабочих проектах он есть почти всегда. Размер контекста виден в выводе docker build: transferring context: 12.34kB это норма, а 1.2GB значит, что забыли исключить виртуальное окружение. Если сборка «зависла» на этой строке, смотри размер папки.
Осторожно: .dockerignore и .gitignore (урок 3.1) похожи, но читают разные программы. И не копируй .env с паролями в образ: слой хранит их навсегда, переменные передают при запуске.
Что ещё отличает боевой Dockerfile от учебного «Магазина»:
USER: учебный образ работает отroot, а в боевом создают обычного пользователя и пишутUSER app, чтобы взлом сервера не давал прав администратора в контейнере. Это частый вопрос на собеседовании; в шаге 8 практики ты сделаешь это на копии.HEALTHCHECK: проверка здоровья прямо в образе, её увидит и обычныйdocker run(в шаге 8 тоже)..dockerignoreесть всегда.- Образ закрепляют по digest (
FROM python@sha256:..., урок 5.1), потому что тег можно переназначить. Цена: патчи безопасности сами не придут, образ надо пересобирать вручную по новому digest. - Многоэтапная сборка (см. врезку выше) оставляет в итоговом образе только нужное.
Главное: в сборку уезжает вся папка контекста, лишнее исключают через
.dockerignore, а секреты в образ не кладут.
Образ собран. Остаётся дать ему имя, чтобы не перепутать.
Теги при сборке
Через час после пары сборок легко забыть, какой образ свежий, и замерить старый код. Поэтому образу дают имя и тег флагом -t: docker build -t shop-lab:exp .. Одному образу можно навесить несколько тегов (docker tag shop-lab:exp shop-lab:v1): это метки на один набор слоёв, места они не занимают. Compose, увидев build: ./shop, называет образ shop-shop (проект shop, сервис shop). Перед нагрузочным прогоном записывай в отчёт коммит, из которого собран образ (git rev-parse --short HEAD), и ставь его в тег.
Главное: тег это метка на образе, и коммит в нём защищает от замеров старого кода.
Теперь собери образ сам: практика.
Практика
Ты не будешь править файлы в клоне ~/learning: он должен остаться чистым, иначе git pull потом начнёт ругаться на конфликты. Скопируй каталог сервиса в свой репозиторий и работай с копией.
1. Подготовь копию для экспериментов
mkdir -p ~/perf-lab/05-docker
cp -r ~/learning/load-tester/project/shop/shop ~/perf-lab/05-docker/shop-build
cd ~/perf-lab/05-docker/shop-build
ls -la
Разбор: cp -r копирует папку вместе со всем содержимым (-r recursive); конечный каталог shop-build будет создан. ls -la показывает файлы с правами.
total 24
drwxr-xr-x 3 student student 4096 Oct 3 11:02 .
drwxr-xr-x 3 student student 4096 Oct 3 11:02 ..
-rw-r--r-- 1 student student 284 Oct 3 11:02 Dockerfile
drwxr-xr-x 3 student student 4096 Oct 3 11:02 app
-rw-r--r-- 1 student student 424 Oct 3 11:02 entrypoint.sh
-rw-r--r-- 1 student student 437 Oct 3 11:02 requirements.txt
Как читать вывод: четыре элемента контекста сборки: рецепт Dockerfile, папка кода app, скрипт запуска и список библиотек. У entrypoint.sh права -rw-r--r--: буквы x (исполнение) нет, в репозитории файл хранится без неё. Поэтому в Dockerfile есть строка RUN chmod +x entrypoint.sh (или COPY --chmod=755): без права запуск образа упал бы с permission denied. Размеры могут слегка отличаться.
2. Первая сборка
docker build -t shop-lab:exp .
Разбор: docker build собирает образ сборщиком BuildKit (он и печатает шаги [N/M] и метки кэша); -t shop-lab:exp даёт ему имя shop-lab и тег exp; точка в конце это контекст сборки: текущая папка. Не забудь точку: без неё будет ошибка requires 1 argument.
[+] Building 74.3s (12/12) FINISHED docker:default
=> [internal] load build definition from Dockerfile 0.0s
=> => transferring dockerfile: 284B 0.0s
=> [internal] load metadata for docker.io/library/python:3.14.8-slim 1.2s
=> [internal] load .dockerignore 0.0s
=> => transferring context: 2B 0.0s
=> [1/7] FROM docker.io/library/python:3.14.8-slim@sha256:7d1c... 18.4s
=> => resolve docker.io/library/python:3.14.8-slim@sha256:7d1c... 0.0s
=> [internal] load build context 0.0s
=> => transferring context: 22.37kB 0.0s
=> [2/7] WORKDIR /app 0.3s
=> [3/7] COPY requirements.txt . 0.0s
=> [4/7] RUN pip install --no-cache-dir -r requirements.txt 46.8s
=> [5/7] COPY app ./app 0.0s
=> [6/7] COPY entrypoint.sh . 0.0s
=> [7/7] RUN chmod +x entrypoint.sh 0.0s
=> exporting to image 3.6s
=> => exporting layers 3.5s
=> => naming to docker.io/library/shop-lab:exp 0.0s
(Шагов семь: FROM, WORKDIR, два COPY, RUN pip, ещё COPY и RUN chmod. Строки ENV, EXPOSE и ENTRYPOINT в нумерацию не входят, они только дописывают настройки.)
Как читать вывод: каждая строка => [N/M] это шаг рецепта, число справа время в секундах. Самое долгое: FROM (первый раз скачивается основа, 18 с) и RUN pip install (47 с: скачивание библиотек). Строки [internal] ... служебные: Docker читает Dockerfile, метаданные базового образа и контекст. transferring context: 22.37kB размер контекста: маленький, значит, лишнего нет. В конце naming to ... shop-lab:exp: образ получил имя.
Проверь результат:
docker image ls shop-lab --format 'table {{.Repository}}\t{{.Tag}}\t{{.ID}}\t{{.CreatedSince}}\t{{.Size}}'
REPOSITORY TAG IMAGE ID CREATED SIZE
shop-lab exp 5e8c1a2d93b7 40 seconds ago 262MB
Без --format Docker 29 печатает другой, компактный вид (колонки IMAGE, ID, DISK USAGE, CONTENT SIZE, EXTRA, без времени создания); формат выше возвращает привычную таблицу. Размер там в колонке SIZE, а в компактном виде она называется DISK USAGE.
Размер 262 МБ: основа (131 МБ) плюс библиотеки (около 130 МБ) и несколько килобайт кода.
Типичные ошибки:
ERROR: failed to solve: failed to read dockerfile: open Dockerfile: no such file or directory: ты не в той папке.pwdиls: в текущем каталоге должен лежатьDockerfile.docker: 'docker buildx build' requires 1 argument: забыта точка (контекст) в конце команды.ERROR: Could not find a version that satisfies the requirement ...во время pip: нет интернета или опечатка вrequirements.txt. Проверьcurl -I https://pypi.org.failed to fetch anonymous token ... dial tcp: lookup registry-1.docker.io: no such host: Docker не достучался до реестра, проверь сеть и DNS (урок 1.4).
Сборка упала на шаге, которого нет в «Типичных ошибках»? Скопируй строку
=> ERRORи весь вывод шага, спроси нейросеть, что значит каждая строка. Ответ проверь, воспроизведя шаг руками черезdocker run --rm --entrypoint sh <образ> -c "...".
3. Посмотри слои
docker history shop-lab:exp
IMAGE CREATED CREATED BY SIZE COMMENT
5e8c1a2d93b7 2 minutes ago ENTRYPOINT ["./entrypoint.sh"] 0B buildkit.dockerfile.v0
<missing> 2 minutes ago EXPOSE map[8000/tcp:{}] 0B buildkit.dockerfile.v0
<missing> 2 minutes ago ENV PYTHONUNBUFFERED=1 PROMETHEUS_MULTIPROC… 0B buildkit.dockerfile.v0
<missing> 2 minutes ago RUN /bin/sh -c chmod +x entrypoint.sh # buil… 424B buildkit.dockerfile.v0
<missing> 2 minutes ago COPY entrypoint.sh . # buildkit 424B buildkit.dockerfile.v0
<missing> 2 minutes ago COPY app ./app # buildkit 21.5kB buildkit.dockerfile.v0
<missing> 2 minutes ago RUN /bin/sh -c pip install --no-cache-dir -… 128MB buildkit.dockerfile.v0
<missing> 2 minutes ago COPY requirements.txt . # buildkit 437B buildkit.dockerfile.v0
<missing> 2 minutes ago WORKDIR /app 0B buildkit.dockerfile.v0
<missing> 3 weeks ago CMD ["python3"] 0B buildkit.dockerfile.v0
...
Как читать вывод: читай снизу вверх, как шла сборка. Нижние строки (их скрыто многоточием) принадлежат базовому образу Python. Выше идут наши инструкции, по одной на строку Dockerfile. Колонка SIZE: тяжёлый слой только один, pip install, 128 МБ. Копирование кода COPY app весит 21 килобайт. Строки 0B у ENV, EXPOSE, ENTRYPOINT и WORKDIR: файлов они не добавляют. Именно поэтому правка кода не стоит ничего, а правка библиотек стоит дорого. Размеры слоёв можно сопоставить с тем, что рассказывал виджет.
4. Кэш в действии
Повтори сборку без изменений и засеки время:
time docker build -t shop-lab:exp .
[+] Building 1.1s (12/12) FINISHED docker:default
=> [internal] load build definition from Dockerfile 0.0s
=> [internal] load metadata for docker.io/library/python:3.14.8-slim 0.9s
=> [1/7] FROM docker.io/library/python:3.14.8-slim@sha256:7d1c... 0.0s
=> CACHED [2/7] WORKDIR /app 0.0s
=> CACHED [3/7] COPY requirements.txt . 0.0s
=> CACHED [4/7] RUN pip install --no-cache-dir -r requirements.txt 0.0s
=> CACHED [5/7] COPY app ./app 0.0s
=> CACHED [6/7] COPY entrypoint.sh . 0.0s
=> CACHED [7/7] RUN chmod +x entrypoint.sh 0.0s
=> exporting to image 0.0s
real 0m1.3s
Слово CACHED означает, что шаг пропущен. Вся сборка заняла секунду. Теперь поменяй код:
echo '# правка для эксперимента' >> app/main.py
time docker build -t shop-lab:exp .
=> CACHED [2/7] WORKDIR /app 0.0s
=> CACHED [3/7] COPY requirements.txt . 0.0s
=> CACHED [4/7] RUN pip install --no-cache-dir -r requirements.txt 0.0s
=> [5/7] COPY app ./app 0.0s
=> [6/7] COPY entrypoint.sh . 0.0s
=> [7/7] RUN chmod +x entrypoint.sh 0.0s
=> exporting to image 0.4s
real 0m2.1s
Как читать вывод: шаги выше кода остались CACHED, включая дорогой pip; пересобрались COPY app (файл изменился) и всё после. Две секунды против почти полутора минут. Теперь поменяй список библиотек (добавь безобидный комментарий):
echo '# правка для эксперимента' >> requirements.txt
time docker build -t shop-lab:exp .
В выводе [3/7] COPY requirements.txt . перестанет быть CACHED, и RUN pip install пойдёт заново (около 40-50 секунд), хотя набор библиотек не изменился: Docker сравнивает файл, а не его смысл. Так и устроена цена: изменил файл, пересобрал всё ниже.
5. Собери «плохой» вариант и сравни
Создай рядом второй Dockerfile, где код копируется до установки:
cat > Dockerfile.bad <<'EOF'
FROM python:3.14.8-slim
WORKDIR /app
COPY . .
RUN pip install --no-cache-dir -r requirements.txt
RUN chmod +x entrypoint.sh
ENV PYTHONUNBUFFERED=1 PROMETHEUS_MULTIPROC_DIR=/tmp/shop-metrics
EXPOSE 8000
ENTRYPOINT ["./entrypoint.sh"]
EOF
docker build -f Dockerfile.bad -t shop-lab:bad .
Разбор: cat > файл <<'EOF' ... EOF записывает несколько строк в файл (конструкция называется heredoc, урок 1.5); -f указывает другой Dockerfile вместо стандартного. Первая сборка займёт столько же, сколько хорошая. Теперь измени код и пересобери:
echo '# ещё правка' >> app/main.py
time docker build -f Dockerfile.bad -t shop-lab:bad .
В выводе строка COPY . . пересобралась, а за ней и RUN pip install: снова около 45 секунд на скачивание библиотек из-за одной строки комментария. Вывод по цифрам: хороший порядок 2 секунды, плохой 47. Именно поэтому в Dockerfile сначала копируют только список зависимостей.
6. Проверь, что внутри образа
docker run --rm --entrypoint python shop-lab:exp -c "import fastapi; print(fastapi.__version__)"
Разбор: --rm удалит контейнер после выхода; --entrypoint python заменяет ENTRYPOINT из образа на python, иначе запустился бы сервер; всё, что после имени образа, это аргументы: -c "..." значит «выполни этот код». Контейнер напечатает версию библиотеки и сразу завершится.
0.142.2
Как читать вывод: версия совпадает с записью в requirements.txt (fastapi==0.142.2): образ собран так, как написано в рецепте. Тот же приём (--entrypoint) пригодится всегда, когда нужно заглянуть в образ и не запускать его по-настоящему. Посмотри ещё docker run --rm --entrypoint sh shop-lab:exp -c "ls -la /app": увидишь app, entrypoint.sh и requirements.txt в /app, именно туда их положили WORKDIR и COPY.
7. Теги
docker tag shop-lab:exp shop-lab:v1
docker image ls shop-lab --format 'table {{.Repository}}\t{{.Tag}}\t{{.ID}}\t{{.CreatedSince}}\t{{.Size}}'
REPOSITORY TAG IMAGE ID CREATED SIZE
shop-lab v1 5e8c1a2d93b7 3 minutes ago 262MB
shop-lab exp 5e8c1a2d93b7 3 minutes ago 262MB
shop-lab bad a77d90c3e1b4 2 minutes ago 262MB
Как читать вывод: у exp и v1 одинаковый IMAGE ID: это два имени одного образа, на диске он один. Размеры колонки SIZE показывают «виртуальный» размер каждого образа, но общие слои хранятся один раз. Теперь убери за собой:
docker image rm shop-lab:v1 shop-lab:exp shop-lab:bad
Образ, из которого запущен хотя бы один контейнер, удалить не получится: Docker скажет conflict: unable to delete ... image is being used by stopped container. Сначала docker rm контейнер.
8. Приблизь образ к боевому: пользователь и проверка здоровья
Учебный Dockerfile «Магазина» работает от root и не содержит HEALTHCHECK. Сделаем на копии образ ближе к боевому:
cd ~/perf-lab/05-docker/shop-build
cat > Dockerfile.prod <<'EOF'
FROM python:3.14.8-slim
WORKDIR /app
RUN useradd --system --no-create-home app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY --chown=app:app app ./app
COPY --chown=app:app --chmod=755 entrypoint.sh .
ENV PYTHONUNBUFFERED=1 PROMETHEUS_MULTIPROC_DIR=/tmp/shop-metrics
EXPOSE 8000
USER app
HEALTHCHECK --interval=5s --timeout=5s --start-period=20s --retries=12 \
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/healthz', timeout=3)"
ENTRYPOINT ["./entrypoint.sh"]
EOF
docker build -f Dockerfile.prod -t shop-lab:prod .
docker run --rm --entrypoint whoami shop-lab:prod
docker image inspect shop-lab:prod --format '{{json .Config.Healthcheck}}'
Разбор: useradd --system --no-create-home app создаёт служебного пользователя app без домашней папки. COPY --chown=app:app отдаёт файлы ему, а --chmod=755 выдаёт скрипту право на запуск (отдельный RUN chmod не нужен). Инструкция USER app делает app пользователем для всего, что идёт ниже, и для запуска контейнера. HEALTHCHECK раз в 5 секунд запускает проверку; пока она успешна, у контейнера в docker ps статус healthy.
app
{"Test":["CMD-SHELL","python -c \"import urllib.request; ...\""],"Interval":5000000000,"Timeout":5000000000,"StartPeriod":20000000000,"Retries":12}
Как читать вывод: whoami ответил app, а не root: процесс в контейнере живёт без прав администратора. Вторая строка показывает проверку, записанную в образ (время в наносекундах: 5000000000 это 5 секунд). Такая же проверка есть в compose.yaml «Магазина», в поле healthcheck: (урок 5.3). Поле Compose перекрывает HEALTHCHECK образа, зато образная проверка работает и без Compose, при простом docker run. Убери образ: docker image rm shop-lab:prod.
9. Сохрани результат
Положи рядом заметку и сделай коммит. Сам shop-build в репозиторий класть не нужно: это копия кода из репозитория стенда, поэтому в коммит идёт только то, что написал ты.
cd ~/perf-lab/05-docker
cat > notes-dockerfile.md <<'EOF'
# Dockerfile «Магазина»: что запомнить
- Порядок строк: редко меняющееся выше, часто меняющееся ниже.
- requirements.txt копируется ДО кода: pip остаётся в кэше.
- exec в entrypoint.sh: uvicorn становится PID 1 и получает SIGTERM.
EOF
cp shop-build/Dockerfile.bad Dockerfile.bad
cd ~/perf-lab
echo "05-docker/shop-build/" >> .gitignore
git add .gitignore 05-docker
git commit -m "Dockerfile: заметки и пример плохого порядка слоёв (урок 5.2)"
git push
Допиши в заметку (любым редактором) четыре числа из шагов 2 и 4: первая сборка (строка Building в шаге 2), повтор без изменений, правка кода, правка requirements.txt (real от time в шаге 4). И одной фразой ответь: какая правка дорогая и почему. Строка с .gitignore исключает копию кода из репозитория.
Типичные ошибки при сборке
| Текст ошибки | Причина | Что делать |
|---|---|---|
failed to read dockerfile: open Dockerfile: no such file or directory |
ты не в папке с Dockerfile |
cd в нужную папку или -f путь/к/Dockerfile |
docker: 'docker buildx build' requires 1 argument |
не указан контекст (точка) | добавь . в конце |
COPY failed: file not found in build context или "/entrypoint.sh": not found |
файла нет в папке контекста или он указан неверно | проверь ls в папке контекста и написание в COPY |
exec ./entrypoint.sh: no such file or directory при запуске образа |
в скрипте символы конца строки Windows (CRLF) или нет оболочки из #! |
file entrypoint.sh покажет CRLF; sed -i.bak 's/\r$//' entrypoint.sh && rm entrypoint.sh.bak, пересобрать |
exec ./entrypoint.sh: permission denied |
у скрипта нет права на выполнение | в Dockerfile добавь RUN chmod +x entrypoint.sh или COPY --chmod=755 entrypoint.sh . |
| образ собрался, а в контейнере старый код | собирал не тот каталог, или запустил старый образ/контейнер | docker image inspect -f '{{.Created}}' shop-lab:exp или docker image ls --format '{{.Tag}} {{.CreatedSince}}': время создания; пересобери и пересоздай контейнер |
ERROR: No matching distribution found for ... |
опечатка или версии нет на PyPI | проверь строку в requirements.txt |
Сломай и почини
Поломка 1. Два контейнера запускают одну и ту же программу-заглушку (она ловит SIGTERM и выходит с кодом 0). Отличие только в слове exec. Образ shop-lab:exp в шаге 7 ты удалил, поэтому сначала собери его снова: docker build -t shop-lab:exp . в папке shop-build (из кэша это быстро или около минуты). Запусти оба контейнера и останови по очереди:
PY='import signal, sys, time; signal.signal(signal.SIGTERM, lambda s, f: sys.exit(0)); time.sleep(300)'
docker run -d --name with-exec --entrypoint sh shop-lab:exp -c "exec python -c '$PY'"
docker run -d --name no-exec --entrypoint sh shop-lab:exp -c "python -c '$PY'; echo done"
sleep 2
time docker stop with-exec
time docker stop no-exec
docker inspect with-exec no-exec --format '{{.Name}} код {{.State.ExitCode}}'
(Это упрощённая модель «Магазина»: ни базы, ни сети не нужно.) Что покажет time, какие будут коды выхода и почему?
Подсказка: замерь
time docker stopи посмотри, кто PID 1:docker exec ИМЯ cat /proc/1/cmdline | tr '\0' ' '(доdocker stop, пока контейнер жив). Потом спроси нейросеть и сравни её объяснение со своей гипотезой.
Разбор
with-exec остановится за долю секунды (real 0m0.3s), код 0: exec заменил оболочку заглушкой, она стала PID 1, получила SIGTERM и вышла штатно. no-exec остановится примерно за 10 секунд (real 0m10.2s), код 137: PID 1 там sh, он не передал SIGTERM дочернему python, Docker подождал положенные 10 секунд и послал SIGKILL. Код 143 здесь не встретится: он бывает, только если процесс прервал необработанный SIGTERM, а PID 1 необработанные сигналы ядро не доставляет.
/proc/1/cmdline покажет в первом случае python -c ..., во втором sh -c .... Вывод для диагностики: когда остановка контейнера «зависает» на десять секунд, смотри, кто PID 1 внутри. Если это оболочка, а не сервис, ищи exec или передавай сигналы явно. Тот же механизм в «Магазине» работает через entrypoint.sh: уберёшь оттуда exec, получишь те же 10 секунд и код 137. Убери за собой: docker rm -f with-exec no-exec.
Поломка 2. Убедись, что exec на месте в entrypoint.sh, а в Dockerfile поменяй местами строки: COPY app ./app поставь перед COPY requirements.txt .. Измени код, пересобери и ответь: сколько шагов пересоберётся и почему слой pip тоже оказался среди них?
Разбор
Пересоберётся и COPY app, и все шаги после него, включая pip install. Порядок «код перед зависимостями» заставил pip стоять ниже изменившегося слоя, а всё ниже изменённого пересобирается. Исправление: вернуть COPY requirements.txt и pip install выше, чем COPY app.
ИИ в помощь
Нейросеть быстро набрасывает черновик Dockerfile и объясняет, почему кэш сборки не сработал. Общие правила на странице ИИ-помощник.
Задача: разобрать чужой Dockerfile, прежде чем собирать его.
Я учусь Docker. Вот Dockerfile (Python 3.12, FastAPI-сервис):
<вставь Dockerfile целиком>
Разбери построчно: что делает каждая инструкция, в какой слой она
попадает и что сбрасывает кэш. Покажи, какие две строки стоит
поменять местами, чтобы правка кода не пересобирала pip install.
Объясни причину, потом покажи исправленный файл.
Проверь ответ: внеси изменение в своей копии shop-build и сравни число пересобранных шагов (CACHED против реальных) с обещанием нейросети. Типичная ошибка: она ставит COPY . . перед установкой зависимостей или советует latest вместо закреплённой версии образа.
Задача: понять, почему образ получился тяжёлым.
Образ весит <размер> МБ, хотя приложение маленькое. Вывод docker history:
<вставь вывод docker history --no-trunc или обычный>
Укажи, какие слои самые тяжёлые и почему. Предложи 2-3 способа
уменьшить образ (базовый образ, --no-cache-dir, порядок инструкций)
и скажи, чем каждый рискует.
Проверь ответ: примени одно предложение за раз и пересобери, сверяя размер в docker image ls (колонка SIZE, в Docker 29 без --format она называется DISK USAGE). Нейросети советуют alpine как универсальное решение, но библиотеки с C-расширениями на нём могут не собраться: проверяй сборкой, а не верой.
Если в Dockerfile или docker history попали пароли и токены (ARG, ENV), замени их на <секрет>: слои хранят их навсегда.
Словарик урока
| Термин | Простыми словами |
|---|---|
| Dockerfile | Текстовый рецепт, по которому собирается образ |
| Инструкция | Строка-команда Dockerfile: FROM, COPY, RUN и другие |
| Базовый образ | Образ, на котором строится твой: первая строка FROM |
slim, alpine |
Облегчённые варианты базовых образов |
FROM |
Задаёт основу образа |
WORKDIR |
Рабочая папка внутри образа |
COPY |
Копирует файлы с твоей машины в образ при сборке |
RUN |
Выполняет команду при сборке и сохраняет результат в слой |
ENV |
Переменные окружения, зашитые в образ как значения по умолчанию |
EXPOSE |
Запись «программа слушает этот порт», сам порт не открывает |
ENTRYPOINT / CMD |
Что запускается при старте контейнера |
| Контекст сборки | Папка, которую docker build отправляет демону; из неё берёт файлы COPY |
.dockerignore |
Список файлов, которые не попадут в контекст сборки |
Кэш слоёв (CACHED) |
Повторное использование результата шага, если ничего не изменилось |
| Сброс кэша | Изменение шага заставляет заново выполнять и все шаги ниже |
requirements.txt |
Список библиотек Python с версиями |
exec в скрипте |
Заменяет оболочку программой, чтобы сигналы достигали её |
| SIGTERM / SIGKILL | Сигнал «заверши работу» и сигнал «убить немедленно» |
| BuildKit | Сборщик образов в Docker: печатает шаги [N/M] и метки CACHED |
Вопросы с собеседований
Раздел для повторения: ответь вслух, потом открой ответ. Вопросы [на скорость] нужно уметь отвечать за 30 секунд.
1. [junior] [часто] Что такое Dockerfile и что делает docker build?
Ответ
Dockerfile это текстовый рецепт сборки образа: набор инструкций (FROM, COPY, RUN, ENTRYPOINT и других). docker build выполняет их сверху вниз, после каждой сохраняет слой и в итоге собирает образ, из которого запускаются контейнеры.
Что хотят услышать: рецепт, инструкции, слои, образ как результат; хранится в git рядом с кодом.
Красный флаг: «Dockerfile это конфигурация запуска нескольких контейнеров» (путает с Compose).
2. [junior] [часто] Чем RUN отличается от CMD и ENTRYPOINT?
Ответ
RUN выполняется при сборке образа, результат запечатывается в слое. CMD и ENTRYPOINT задают, что запускать при старте контейнера. ENTRYPOINT это основная программа, CMD аргументы по умолчанию для ENTRYPOINT (а без ENTRYPOINT сама команда запуска), и их легко заменить при docker run.
Что хотят услышать: разница «сборка против запуска».
Красный флаг: «RUN запускает приложение».
3. [junior] [часто] Как работает кэш слоёв и почему важен порядок инструкций?
Ответ
Docker пропускает шаг (CACHED), если инструкция и входные файлы не изменились. Но изменение одного шага заставляет пересобрать все шаги ниже. Поэтому редко меняющееся (список зависимостей, установка) ставят выше, а часто меняющееся (код) ниже: например, COPY requirements.txt и pip install до COPY app.
Что хотят услышать: «всё ниже изменённого слоя пересобирается», пример с зависимостями.
Красный флаг: не знает, что кэш бывает и как его сбросить (--no-cache).
4. [junior] Зачем в образе «Магазина» используется python:3.14.8-slim, а не python:latest?
Ответ
Точная версия делает сборку воспроизводимой: результаты замеров можно сравнивать, потому что Python не меняется под ногами. slim значительно меньше полного образа (около 130 МБ против 1 ГБ), при этом достаточен для работы сервиса с бинарными колёсами библиотек.
Что хотят услышать: воспроизводимость, размер, осознанный выбор варианта образа.
Красный флаг: «latest лучше, потому что всегда свежий».
5. [junior] Что делает EXPOSE 8000? Откроет ли он порт?
Ответ
Нет. EXPOSE лишь документирует, что программа слушает порт 8000. Опубликовать порт на хосте нужно флагом -p при docker run или ports: в Compose.
Что хотят услышать: «документация, а не открытие порта».
Красный флаг: «EXPOSE открывает порт наружу».
6. [middle] Зачем в entrypoint.sh стоит exec перед uvicorn?
Ответ
Без exec процессом 1 остаётся оболочка, а сервер её дочерний процесс. Сигнал SIGTERM от docker stop получает PID 1, и оболочка его не пересылает: сервер не завершается аккуратно, через 10 секунд Docker убивает контейнер (код 137), могут оборваться запросы и не закрыться соединения. exec заменяет оболочку сервером, он становится PID 1 и корректно реагирует на остановку.
Что хотят услышать: PID 1, сигналы, docker stop, код 137.
Красный флаг: считает, что exec «ускоряет запуск».
7. [middle] Как уменьшить размер образа и время сборки?
Ответ
Брать облегчённую основу (slim, alpine), ставить зависимости с --no-cache-dir, держать .dockerignore, не копировать лишнее, правильно упорядочивать слои ради кэша, а на сложных проектах использовать многоэтапную сборку (собрать на тяжёлом образе, перенести результат в лёгкий).
Что хотят услышать: несколько приёмов и понимание, что размер и скорость это разные цели.
Красный флаг: «удалю файлы отдельным RUN rm» (удаление в верхнем слое не уменьшает размер нижнего).
8. [middle] Почему нельзя копировать .env с секретами в образ?
Ответ
Всё, что попало в слой, остаётся в образе навсегда и видно любому, кто получит образ (docker history, распаковка слоёв). Удаление файла в следующем слое не помогает: нижний слой по-прежнему содержит секрет. Секреты и настройки передают при запуске (переменные окружения, env_file, секреты оркестратора), а в образ добавляют .dockerignore.
Что хотят услышать: слои неизменяемы, секрет остаётся в истории, настройки при запуске.
Красный флаг: «я удалил файл следующей строкой, значит, его нет».
9. [middle] Образ собран, а в контейнере работает старый код. Что проверишь?
Ответ
Время создания образа (docker image inspect -f '{{.Created}}' <образ>), что контейнер пересоздан из нового образа (а не просто перезапущен: docker compose up -d --build пересоздаёт его), что собирается именно тот каталог и тот Dockerfile, а также не мешает ли кэш (--no-cache для проверки).
Что хотят услышать: контейнер привязан к образу на момент создания, надо пересоздавать.
Красный флаг: «просто перезапущу контейнер».
10. [на скорость] Что означает CACHED в выводе сборки?
Ответ
Шаг не выполнялся заново: инструкция и входные файлы не изменились, Docker взял готовый слой из кэша.
Что хотят услышать: шаг взят из кэша слоёв, инструкция и входные файлы не менялись.
Красный флаг: считает CACHED ошибкой или пропуском шага, не понимает, почему код не обновился.
11. [на скорость] Почему COPY requirements.txt стоит раньше COPY app?
Ответ
Зависимости меняются редко, код часто. Если слой с pip install стоит выше кода, то при правке кода он остаётся в кэше, и сборка занимает секунды вместо минуты.
Что хотят услышать: редко меняющееся выше часто меняющегося, слой с pip install остаётся в кэше при правке кода.
Красный флаг: копирует весь проект одной строкой до установки зависимостей и мирится с минутной сборкой.
12. [на скорость] Чем docker build -t shop:1 . отличается от docker build shop:1?
Ответ
В первом -t задаёт имя и тег, а точка указывает контекст сборки. Во втором не хватает флага -t и контекста: Docker воспримет shop:1 как путь к контексту и выдаст ошибку.
Что хотят услышать: -t задаёт имя и тег, точка это контекст сборки.
Красный флаг: путает контекст сборки с именем образа или не знает, что означает точка.
Проверено на версиях
Ubuntu 24.04 LTS, Docker Engine 29.x с BuildKit и Buildx, базовый образ python:3.14.8-slim, библиотеки из requirements.txt (FastAPI 0.142.2, Uvicorn 0.54.0, psycopg 3.3.6). Октябрь 2026. Время сборки и размеры слоёв у тебя будут другими: зависят от интернета и диска.
Итог урока: ты умеешь
- Объяснить, что такое Dockerfile, инструкция, слой, и чем сборка отличается от запуска.
- Прочитать Dockerfile «Магазина» строка за строкой и сказать, зачем нужна каждая.
- Объяснить, зачем в
entrypoint.shстоитexecи что бывает без него (код 137). - Собрать образ
docker build -t имя:тег .и прочитать вывод шагов, меткиCACHEDи время. - Объяснить кэш слоёв и доказать на опыте, что порядок
COPY requirements.txtиCOPY appвлияет на время сборки. - Посмотреть слои
docker historyи проверить версию библиотеки внутри образа через--entrypoint. - Поставить тег на образ и объяснить, почему два тега не удваивают размер.
- Расшифровать ошибки:
no such file or directory,requires 1 argument,permission deniedпри запуске скрипта.
Дальше: урок 5.3. Docker Compose: поднимаем «Магазин» с базой и кэшем, где образы, которые ты теперь умеешь собирать, объединяются в целый стенд.
Проверь себя
Короткий тест по уроку: 5 вопросов из банка в 35. Засчитывается только полностью правильный ответ, порог 60%. Каждая новая попытка даёт другие вопросы, пока банк не закончится. Ответы видны после проверки.
Тест работает с включённым JavaScript.