Содержит инструкции и команды по сборке образа

Docker, первый выпуск которого был еще в 2013 году, — весьма удобный инструмент для сборки пакетов, поставки и запуска приложений в «контейнерах». Большинство крупных компаний, например, Google, Amazon и VMware рассматривают Docker как зрелую технологию для контейнеров, поэтому сейчас самое время изучить этот инструмент и в результате продвинуться по карьерной лестнице. Хотите? В статье будут приведены вопросы по Docker, ответы на которые нужно знать, если вы идете на собеседование.

Что такое контейнер Docker?

Контейнер — базовая единица программного обеспечения, покрывающая код и все его зависимости для обеспечения запуска приложения прозрачно, быстро и надежно независимо от окружения. Контейнер Docker может быть создан с использованием образа Docker. Это исполняемый пакет программного обеспечения, содержащий все необходимое для запуска приложения, например, системные программы, библиотеки, код, среды исполнения и настройки.

Опишите составные части архитектуры Docker

Основные составные части архитектуры Docker — это:

• сервер, содержит сервис Docker, образы и контейнеры. Сервис связывается с Registry, образы — метаданные приложений, запускаемых в контейнерах Docker.
• клиент, применяется для запуска различных действий на сервере Docker.
• registry, используется для хранения образов. Есть публичные, доступные каждому, например, Docker Hub и Docker Cloud.

Опишите Registry подробнее

Docker Registry служит для хранения образов Docker. Есть два публичных сервиса хранения: Docker Hub и Docker Cloud. Docker Hub — наиболее значимая публичная система хранения образов контейнеров, полностью поддерживаемая множеством разработчиков и другими участниками сообщества.

Расскажите кратко о жизненном цикле контейнера Docker

Жизненный цикл контейнера:

• Создание контейнера
• Работа контейнера
• Приостановка контейнера
• Возобновление работы контейнера
• Запуск контейнера
• Остановка контейнера
• Перезапуск контейнера
• Принудительная остановка контейнера
• Удаление контейнера

Назовите наиболее важные команды Docker

Наиболее важные команды Docker:

• build, сборка образа для Docker
• create, создание нового контейнера
• kill. принудительная остановка контейнера
• dockerd, запуск сервиса Docker
• commit, создание нового образа из изменений в контейнере

Что такое пространства имен в Docker?

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

Что такое Docker Swarm?

Docker Swarm (теперь это уже swarm mode, прим. переводчика) — встроенный инструмент Docker, используемый для организации кластеризации и планирования контейнеров. Разработчики и системные администраторы с его помощью могут легко собрать несколько узлов в единую виртуальную систему Docker и управлять ею.

Как определить состояние контейнера Docker?

Чтобы определить состояние, надо запустить команду:

docker ps -a

Эта команда выведет список всех доступных контейнеров с их состоянием на сервере. Из этого списка нужно выбрать требуемый контейнер и узнать его состояние.

Что такое образ Docker, что делает команда Docker run?

Образ Docker — это набор файлов, соединенный с настройками, с помощью которого можно создать экземпляры, которые запускаются в отдельных контейнерах в виде изолированных процессов. Образ строится с использованием инструкций для получения полной исполняемой версии приложения, зависящей от версии ядра сервера. Команда Docker run используется для создания таких экземпляров, называемых контейнерами, запускаемыми с использованием образов Docker. При запуске одного образа пользователь может создать несколько контейнеров.

Опишите функции и случаи применения Docker

С помощью Docker можно:

• Сделать процесс настройки проще и упростить настройку на уровне инфраструктуры;
• Помочь разработчикам сосредоточиться исключительно на коде, сокращая время разработки и увеличивая продуктивность;
• Усилить возможности отладки с использованием встроенных функций;
• Изолировать приложения;
• Улучшить плотность использования серверов в форме контейнеризации;
• Делать быстрое развертывание на уровне операционной системы.

Что такое объекты Docker?

Под объектами понимают образы, сервисы и контейнеры.
Образы — шаблоны с инструкциями только для чтения для создания контейнеров.
Контейнеры — запущенные экземпляры образов.
Сервисы — можно запустить несколько контейнеров поверх нескольких сервисов Docker, работающих совместно как swarm.

Еще объектами можно назвать сети и тома.

Какой тип приложений больше подходит для контейнеров Docker: с хранением состояния (stateful) или без хранения (stateless)?

Приложения без хранения состояния (stateless) больше подходят для работы в Docker, чем приложения с хранением (stateful). Мы можем создать контейнер для нашего приложения и принять некоторые его настройки. Таким образом мы можем запускать один и тот же контейнер с разными настройками для различных окружений. Если мы не будем хранить состояние, сможем использовать один и тот же образ в разных сценариях. Также такие приложения проще масштабировать при их работе в контейнерах Docker.

Что такое Dockerfile?

Dockerfile содержит инструкции для сборки образов, которые передаются в Docker. Также его можно описать как текстовый документ, содержащий все возможные команды, с помощью которых пользователь, последовательно их запуская, может собрать образ.

Какие сети доступны по умолчанию в Docker?

По умолчанию есть:

• bridge, сеть, к которой подключаются контейнеры, если не указано иначе.
• none, сетевой стек без наличия сетевого интерфейса в контейнере.
• host, подключение к сетевому стеку сервера.

Приведите необходимые шаги для развертывания докеризированного приложения, сохраненного в репозитории Git

Шаги, необходимые для развертывания приложения зависят от окружения, основной процесс развертывания будет таким:

• Сборка приложения с использованием Docker build в каталоге с кодом приложения
• Тестирование образа
• Выгрузка образа в Registry
• Уведомление удаленного сервера приложений, что он может скачать образ из Registry и запустить его
• Перестановка порта в прокси HTTP(S)
• Остановка старого контейнера

Чем Docker отличается от остальных технологий контейнеризации?

Docker — одна из последних разработок в контейнеризации, он стал одной из наиболее популярных. Docker, созданный в облачную эру, сделал возможным использование новых функций, ранее отсутствующих в старых технологиях контейнеризации. Самая крутая функция Docker — это работа с использованием любой инфраструктуры, неважно, у вас дома, либо в облаке.

Посредством Docker все больше приложений могут работать на старых серверах, также с его помощью можно упаковывать и поставлять программы. Существует также DockerHub, Registry для контейнеров, откуда можно легко и просто скачать образы контейнеров для использования. Еще более интересная функция — общие контейнеры для таких приложений. Также Docker хорошо задокументирован, что делает его лучше остальных технологий контейнеризации.

Если вы остановите контейнер — потеряете данные?

Если контейнер Docker останавливается, потери данных не происходит, поскольку все данные, пишутся на диск приложением с единственной целью — хранение. Этот процесс повторяется до тех пор, пока контейнер не будет однозначно удален. Более того: файловая система контейнера хранит изменения даже после полной остановки контейнера.

Как выполняется мониторинг Docker в производственных окружениях?

Для мониторинга есть инструменты Docker stats и Docker events. С их помощью можно получить отчеты по важной статистике. Если запустить stats с некоторым идентификатором контейнера, он вернет использование оперативной памяти и процессорного времени в контейнере. Это схоже с использованием команды top. С другой стороны есть events, показывающая список активностей в процессе работы сервиса Docker. Вот некоторые из них: подключение к консоли контейнера, commit, переименование, удаление и т.п., а также есть возможность фильтрации нужных событий.

Расскажите о рабочем процессе использования Docker

Краткое пояснение рабочего процесса с использованием Docker:

• Все начинается c Dockerfile, поскольку это исходный код образа.
• Как только он создан, его можно использовать для сборки образа контейнера. Образ — собранная версия Dockerfile.
• Образ можно распространять, используя Registry, работающий как репозиторий образов.
• Далее образ используется для запуска контейнеров. Контейнер при работе весьма похож на виртуальную машину, но без гипервизора.

Поясните разницу между docker run и docker create

Главная разница между этими командами заключается в том, что вторая создаст контейнер в остановленном состоянии. Также docker create может быть использована для хранения и вывода идентификатора контейнера для будущего использования. Лучше всего это делать с помощью docker run, добавляя --cidfile FILENAME, поскольку повторный запуска не перезаписывает файл.

Что такое виртуализация?

Виртуализация, как только понятие появилось, обозначала способ логического разделения мейнфреймов для обеспечения одновременной работы нескольких приложений. Но со временем, с появлением в отрасли возможности одновременной работы нескольких операционных систем на одном сервере x86, смысл виртуализации значительно поменялся.

Что же в сухом остатке? С помощью виртуализации можно запустить две различных операционных системы на одном и том же оборудовании. Первая операционная система используется для административных целей, все остальные гостевые — загружаются как обычно, включая инициализацию, загрузку ядра и т.д. Это также идеально для безопасности, поскольку гостевая ОС не может получить полного доступа к управляющей (host) ОС, что могло бы привести к дырам в безопасности.

Есть три типа виртуализации:

• Паравиртуализация
• Эмуляция
• Контейнерная виртуализация

В чем разница между Registry и Repository?

Registry — это сервис хранения и распространения образов, также DockerHub — это Registry по умолчанию. Repository — это набор связанных образов. У них одно и то же имя, но разные метки.

Можно ли использовать JSON вместо YAML в файле для docker-compose, если да — как?

Да, так можно сделать. Для этого нужно явно указать имя файла, например так:

docker-compose -f docker-compose.json up

Расскажите о CMD и ENTRYPOINT в Dockerfile

Эти инструкции Dockerfile задают команду, исполняемую при запуске контейнера. При их использовании есть несколько правил, например:

• Должна быть минимум одна из них, CMD или ENTRYPOINT, в Dockerfile.
• Если контейнер используется как исполняемый файл — ENTRYPOINT должна быть определена.
• Если контейнер запускается с другими аргументами — CMD будет переопределена.

Опишите процесс запуска приложения внутри контейнера Linux, используя Docker

• Установите и запустите Docker;
• Скачайте базовый образ с Docker Hub;
• Загрузите ваше приложение в базовый образ;
• Запустите контейнер в интерактивном режиме, используя полученный образ;
• Проверьте контейнеры в системе;
• Запустите или остановите контейнер;
• Зайдите внутрь контейнера;
• Удалите контейнер и образ.

Что такое гипервизор?

Гипервизор, он же монитор виртуальных машин, — это программное обеспечение для создания и запуска виртуальных машин. С его помощью можно запустить на одном компьютере несколько гостевых операционных систем. Это достигается с помощью разделения ресурсов, например, оперативной памяти, процессорного времени и т.п., сокращая требования к памяти, дисковому пространству и обслуживанию. Есть два типа гипервизоров:

• первого типа, легковесная операционная система, запускаемая на оборудовании;
• второго типа, программное обеспечение, запускаемое из операционной системы.

Расскажите о ключевом различии между виртуализацией и контейнеризацией

Виртуализация позволяет запустить несколько операционных систем на одном физическом сервере. Контейнеризация работает на одной и той же операционной системе, в которой приложения упакованы в контейнеры и запускаются на одном сервере/виртуальной машине.

Расскажите об образах Docker, DockerHub, Dockerfile

Образы: файлы, содержащие несколько слоев, используемые для выполнения кода внутри контейнера. Они собираются по инструкциям для получения исполняемой версии приложения. Образы могут ускорить сборку в Docker с помощью кэширования каждого этапа.

DockerHub: сервис для поиска и совместного использования образов контейнеров. Вы можете выгружать туда свои образы, скачивать их оттуда, работать с частными репозиториями образов контейнеров, собирать автоматически образы с помощью GitHub (Bitbucket), а затем закачивать их в DockerHub. Этот сервис предоставляет компания Docker.

Dockerfile: текстовый файл, используемый для сборки образа. Он содержит инструкции и команды по сборке образа. Docker читает их и автоматически собирает образ.

Как проверить версии Docker client и Docker server?

Версию Docker можно проверить с помощью docker version [параметры]. Если не указывать параметры, команда выдаст всю информацию, связанную с версией клиента и сервера. Чтобы получить только версию сервера, можно запустить такую команду:

docker version --format '{{.Server.Version}}'

Расскажите о процедуре входа в Docker Repository

Чтобы войти в Docker Repository, используется следующая команда:

docker login [OPTIONS] [SERVER]

Например, для входа в registry, размещенную на своих мощностях (локально), команда будет такой:

$ docker login localhost:8080

Расскажите о наиболее общих командах Docker

• docker push: Закачать репозиторий или образ в Registry;
• docker run: Запустить команду в новом контейнере;
• docker pull: Скачать репозиторий или образ из Registry;
• docker start: Запустить один или несколько контейнеров;
• docker stop: Остановить один или несколько контейнеров;
• docker search: Поиск образа на DockerHub;
• docker commit: Сохранить изменения в новый образ.

Чем отличается контейнеризация в виде Docker от других технологий?

Docker может быть легко развернут в любой облачной платформе. Также разработчики могут создать готовые к запуску контейнеризированные приложения быстрее, могут легко развертывать приложения и управлять ими. Кроме того, контейнеры могут быть общими для приложений. Эти функции не работают в других технологиях контейнеризации.

На каких платформах запускается Docker?

Docker работает на Windows (x86_64), Linux (x86_64, ARM, s390x, ppc64le).

Возможен ли самостоятельный перезапуск контейнера?

Да, возможен. Docker задает различные политики перезапуска контейнера:

• Off: контейнер не перезапускается, если он остановился или аварийно завершил работу;
• On-failure: перезапуск только в случае аварийной остановки, но не по команде пользователя;
• Unless-stopped: перезапуск будет работать до тех пор, пока пользователь его не остановит;
• Always: перезапуск в любом случае, независимо от ошибок или других проблем.

Политику можно задать так:

$ docker run -dit — restart [unless-stopped|off|on-failure|always] [CONTAINER]

Можно ли сравнить облака по возможностям контейнеризации с Docker?

Здесь можно высказать свое мнение, например, я думаю, что несмотря на то, что облака — хороший конкурент, они не смогут заменить контейнеризацию. Большинство компаний используют облака и контейнеризацию вместе, чтобы получить лучшее от обеих технологий.

Опишите все возможные состояния контейнера Docker

Created — контейнер создан, но не активен.
Restarting — контейнер в процессе перезапуска.
Running — контейнер работает.
Paused — контейнер приостановлен.
Exited — контейнер закончил свою работу.
Dead — контейнер, который сервис попытался остановить, но не смог.

Расскажите о средствах оркестрации и случаях их использования

Оркестрация позволяет управлять работой контейнеров, запущенных в больших и динамических окружениях. С ее помощью можно автоматизировать и управлять следующими задачами:

• Создание и развертывание контейнеров;
• Балансировка нагрузки;
• Разделение ресурсов между контейнерами;
• Мониторинг контейнеров и серверов;
• Масштабирование контейнеров;
• Перенос контейнеров с одного сервера на другой, если на первом возникает недостаток ресурсов.

Опишите параметр memory-swap

С помощью параметра memory-swap можно разрешить контейнеру записывать на диск данные, превышающие размер оперативной памяти, выделенной контейнеру. Он работает, только если используется одновременно с параметром memory. Например, если memory = «400m» и memory-swap = «1g», то контейнер может использовать 400мб оперативной памяти и 600мб подкачки (1гб-400мб).

Где хранятся тома Docker?

Тома, создаваемые и управляемые Docker (у не-Docker процессов к ним нет доступа), хранятся в файловой системе сервера Docker по пути /var/lib/docker/volumes/. Тома — наиболее эффективный способ сохранения данных в Docker.

Назовите продвинутые команды Docker

Наиболее важные из них:

docker -version: узнать установленную версию Docker;
docker ps: перечислить все запущенные контейнеры вместе с дополнительной информацией о них;
docker ps -a: перечислить все контейнеры, включая остановленные, вместе с дополнительной информацией о них;
docker exec: войти в контейнер и выполнить в нем команду;
docker build: собрать образ из Dockerfile;
docker rm: удалить контейнер с указанным идентификатором;
docker rmi: удалить образ с указанным идентификатором;
docker info: получить расширенную информацию об установленном Docker, например, сколько запущено контейнеров, образов, версию ядра, доступную оперативную память и т.п.;
docker cp: сохранить файл из контейнера в локальную систему;
docker history: показать историю образа с указанным именем.

Расскажите о командах systemd для управления Docker

Для запуска Docker многие дистрибутивы Linux используют systemd. Для запуска сервисов используется команда systemctl. Если ее нет, следует использовать команду service.

$ sudo systemctl start docker
$ sudo service docker start

Чтобы добавить сервис в автозагрузку, либо убрать его:

$ sudo systemctl enable docker
$ sudo systemctl disable docker

Для проверки параметров запуска сервиса и их изменения:

$ sudo systemctl edit docker

Просмотра связанных с сервисом журналов:

$ journalctl -u docker

Опишите процесс масштабирования контейнеров Docker

Контейнеры могут быть масштабированы с использованием команды docker-compose scale. Процесс масштабирования такой:

• Масштабируем контейнер и запускаем n экземпляров:

$ docker-compose --file docker-compose-run-srvr.yml scale <service_name>=<n>

В вышеприведенном примере имя сервиса задается в файле docker-compose-run-srvr.yml, а также запускается n копий контейнеров, где n — любое целое положительное число.

• После масштабирования контейнера для проверки можно использовать такую команду:

$ docker ps -a

Что такое CNM?

CNM или Container Network Model — описание, формально определяющее шаги, требуемые для предоставления сети контейнерам, где обслуживающая абстракция применяется для поддержки нескольких сетевых драйверов. CNM основан на трех компонентах: sandbox (песочница), оконечная точка и сеть.

Какие типы монтирования доступны в Docker?

• Bind mount: подключаются к любой точке файловой системы сервера;
• Volume mount: управляются Docker и хранятся как часть файловой системы сервера;
• tmpfs mount: хранятся в оперативной памяти сервера, поэтому никогда не пишутся на реальную файловую систему сервера.

Расскажите о Docker Trusted Registry

Это хранилище образов для безопасного хранения и управления образами Docker. Его можно установить на своих мощностях, либо в частном облаке. DTR применятся в процессах CI/CD для сборки, поставки и запуска приложений. Его также можно развернуть в отказоустойчивом варианте, есть встроенная система управления доступом.

Каково назначение docker_host?

Он задает URL или путь к сокету unix, используемые для соединения с API Docker. Значение по умолчанию — unix://var/run/docker.sock

Для подключения к удаленному серверу обычно используется TCP, например:
tcp://192.0.1.20:3230

Возможен ли запуск нескольких копий одного и того же compose файла на одном и том же сервере? Как именно?

Это можно сделать с помощью docker-compose, использующего файл YAML для настройки сервисов приложения. После его создания вы можете в одну команду создать и запустить все сервисы. Для того, чтобы начать им пользоваться:

• Задайте окружение приложения в Dockerfile, так что оно сможет быть реплицировано везде
• Определите все сервисы вашего приложения в файле docker-compose.yml
• Запустите docker-compose up для создания и запуска приложения целиком

Объясните метки объектов в Docker

Метки объектов Docker — это пары ключ-значение, сохраняемые в виде строк. Мы можем применить метаданные с их помощью. Метки могут быть применены к любому объекту, например, образу, контейнеру, тому, сети, локальным сервисам, узлам swarm и непосредственно сервисам. Каждая пара должна быть уникальной для объекта, сами метки не меняются динамически на протяжении существования объекта.

Результаты

Это был список вопросов для собеседования по Docker. Как много ответов вы знали? Просим принять участие в опросе ниже. Также рекомендуем вам ознакомиться с руководствами от сообщества

На сколько вопросов получилось ответить?

Проголосовали 122 пользователя.

Воздержались 43 пользователя.

Docker может создавать образы автоматически, читая инструкции из файла Dockerfile, по сути это текстовый документ, содержащий все команды, которые пользователь может вызвать в командной строке для сборки образа Images. С помощью команды docker build можно создать автоматизированную сборку, которая последовательно выполняет несколько инструкций командной строки.

Создавать новый образ есть смысл когда вы не можете найти подходящий для вашей задачи образ на hub.docker.com. Созданные образы можно также загружать на hub.docker.com и делать их доступными для других разработчиков.

Инструкции, при сборке образа обрабатываются сверху вниз. Слои в итоговом образе создают только инструкции FROM, RUN, COPY, ADD. Другие инструкции занимаются настройкой, описывают метаданные, или сообщают Docker о том, что во время выполнения контейнера нужно что-то сделать, например — открыть какой-то порт или выполнить какую-то команду.

Этапы создания

1. Необходимо создать докер файл это специальный файл с инструкциями для Docker по созданию нового образа, один докер файл для одного образа
2. Дальше докер файл помещают в корне папки приложения то есть если у вас уже есть папка в которой находится приложение тогда помещаете докер файл в корень проекта, это удобно тем что если вы например используете Git для контроля версии, Dockerfile всегда будет в вашем репозитории вместе с приложением
3. Каждая инструкция FROM, RUN, COPY, ADD в Dockerfile будет создавать новый слой в новом образе
4. При создании образа нужно указывать имя и тег для образа
5. На основании готового образа, создается контейнер

Типичный вид файла

Теперь давайте посмотрим как выглядит докер файл:

Это пример небольшого Dockerfile, в нём есть четыре инструкции:

• Инструкция FROM указывает на то, какой базовый образ будет использоваться для вашего образа, в данном примере базовый образ называется python а версия alpine
• Инструкция WORKDIR сдесь создаётся рабочая директория внутри образа. В данном примере указан путь /app и благодаря такой инструкции внутри образа будет создана папка. Рекомендуется всегда создавать папку внутри образа для вашего приложения, иначе можно например случайно перезаписать системные папки
• Инструкция COPY мы копируем все файлы из локальной текущей папки (первая точка) в папку указанную в директории WORKDIR (вторая точка). Когда необходимо скопировать файл с текущей папки на компьютере в папку внутри образа можно указывать в качестве целевой папке просто точку
• Инструкция CMD указывает, какая команда будет выполнена когда создается новый контейнер на основании уже созданного образа. В данном примере будет запущен процесс python и ему передаётся аргумент main.py. Иными словами мы запустим процесс python и он выполнит файл main.py, этот файл должен находиться в рабочей директории. Подразумевается что файл main.py мы скопируем с нашего компьютера на этапе инструкция COPY

Синтаксис файла Dockerfile

Работу с Dockerfile можно разбить на два этапа: описание инструкций и сборка образа. Набор инструкций — последовательность действий, чтобы собрать образ.

1. FROM установка родительского базового образа
2. RUN запуск команд терминала
3. COPY копирование файлов проекта
4. ADD копирует файлы по ссылке и распаковывавает локальные tar архивы
5. ENTRYPOINT предоставляет команду с аргументами для вызова во время выполнения контейнера, причем аргументы не переопределяются в командной строке пользователем
6. CMD предоставляет команду с аргументами для вызова во время выполнения контейнера, причем аргументы переопределяются в командной строке пользователем
7. ENV устанавливает постоянные переменные среды
8. WORKDIR задаёт рабочую папку проекта
9. USER задаёзапуск приложения от имени пользователя
10. EXPOSE указывает на необходимость открыть порт
11. ARG задаёт переменные для передачи Docker во время сборки образа
12. VOLUME создаёт точку монтирования для работы с постоянным хранилищем

FROM установка базового образа

Dockerfile обычно начинается с инструкции FROM. Эта инструкция задаёт базовый образ. В качестве базового образа может быть использован образ с чистой операционной системой, образ с уже установленной и настроенной платформой или вообще любой другой образ. Вот так можно установить Ubuntu 18.04 как базовый образ:

FROM ubuntu:18.04

Для установки Node.js alpine версии используют команду ниже:

FROM node

RUN запуск команд терминала

Инструкция RUN позволяет запускать команды терминала при сборке. Это самая используемая инструкция, ей можно создать папку, установить недостающие пакеты или запустить shell скрипт. Например, установим платформу Node.js поверх образа с чистой Ubuntu:

FROM ubuntu:18.04
RUN sudo apt update && sudo apt install nodejs && sudo apt install npm

COPY копирование файлов проекта

Инструкции COPY позволяют перенести файлы с компьютера, который запускает сборку, внутрь образа. Например, перенесём все содержимое папки, где лежит Dockerfile в папку /app внутри образа:

FROM ubuntu:18.04
RUN sudo apt update && sudo apt install nodejs && sudo apt install npm
COPY . /app

ADD копирование файлов проекта

Инструкции ADD умеет скачивать файлы с сервера по ссылке и распаковывать tar-архивы.

Если собрать образ из этого Dockerfile и запустить контейнер, то окажется что команда ADD выкачала этот архив:

FROM ubuntu:18.04
RUN sudo apt update && sudo apt install nodejs && sudo apt install npm
ADD https://github.com/bessarabov/Moment/archive/1.3.1.tar.gz /app

В той же папке где лежит Dockerfile находится файл с архивом. Если собрать образ и запустить контейнер из этого образа то будет видно что ADD разархивировал этот tar.gz файл:

FROM ubuntu:18.04
RUN sudo apt update && sudo apt install nodejs && sudo apt install npm
ADD 1.3.1.tar.gz /app

Используйте COPY, она только копирует указанную папку во внутреннюю папку образа. Инструкция ADD слишком всемогущая и можно случайно использовать её неверно. Например, она может скачать файл из Интернета перед копированием или разархивировать архив.

ENTRYPOINT запуск приложения

После того как образ готов, необходимо запустить приложение, которое в нем содержится. Образы Docker задумывались как упаковка для приложения, поэтому нет ничего удивительного в существовании механизма запуска приложения при старте контейнера на основе собранного образа. Для этого используют инструкцию ENTRYPOINT. Инструкция используется для запуска приложения при старте контейнера. Вместе с командой запуска контейнера вы можете передавать параметры команде, которая прописана после ENTRYPOINT. Внутри контейнера можно запустить программу node и выполнить файл переданный через параметры /app/app.js:

FROM ubuntu:18.04
RUN sudo apt update && sudo apt install nodejs && sudo apt install npm
COPY . /app
ENTRYPOINT ["node", "/app/app.js"]

Есть две формы записи аргументов ENTRYPOINT: в виде строки и в виде массива строк. Первый вариант (так называемый shell режим) используется редко, поскольку не позволяет гибко настраивать работу образа. Обычно используется второй вариант (так называемый exec режим) — массив строк, который может состоять из команды и её параметров.

Используйте ENTRYPOINT, если вы не хотите, чтобы пользователь вашего образа переопределял поведение приложения в контейнере. Используйте CMD, если записываете команду по умолчанию, которую пользователь с лёгкостью может переопределить на этапе запуска контейнера.

CMD запуск приложения

Инструкция CMD делает практически то же самое, что и ENTRYPOINT. Обычно это также команда запуска приложения, она игнорируется в том случае, если пользователь вашего образа прописывает в явном виде, что и как запускать после запуска контейнера на основе образа. Часто CMD вообще используется для передачи параметров по умолчанию вашему приложению, которые пользователь может переопределить:

FROM ubuntu:18.04
RUN sudo apt update && sudo apt install nodejs && sudo apt install npm
COPY . /app
CMD ["node", "/app/app.js"]

Есть две формы записи аргументов CMD: в виде строки и в виде массива строк. Первый вариант (так называемый shell режим) используется редко, поскольку не позволяет гибко настраивать работу образа. Обычно используется второй вариант (так называемый exec режим) — массив строк, который может состоять из команды и её параметров. Среди аргументов инструкции CMD строка с командой может отсутствовать, если эта инструкция идёт после инструкции ENTRYPOINT. В этом случае строки массива рассматриваются как аргументы по умолчанию для команды, обозначенной в ENTRYPOINT.

Используйте ENTRYPOINT, если вы не хотите, чтобы пользователь вашего образа переопределял поведение приложения в контейнере. Используйте CMD, если записываете команду по умолчанию, которую пользователь с лёгкостью может переопределить на этапе запуска контейнера.

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

Переменные окружения задаются инструкцией ENV. Через переменные окружения передают ключи и пароли к сервисам, режим работы, другие секретные и не очень значения. Например, запуск приложения Node.js для конечного пользователя обозначается дополнительной инструкцией:

FROM ubuntu:18.04
RUN sudo apt update && sudo apt install nodejs && sudo apt install npm
COPY . /app
ENV NODE_ENV=production
CMD ["node", "/app/app.js"]

WORKDIR рабочая папка проекта

Инструкция WORKDIR задаёт рабочую папку приложения. Все инструкции в Dockerfile будут выполняться относительно неё. Устанавливать рабочую папку — хороший тон. Она позволяет явно указать место, где будет происходить вся работа. Добавим её в нашу конфигурацию:

FROM ubuntu:18.04
RUN sudo apt update && sudo apt install nodejs && sudo apt install npm
WORKDIR /app
COPY . .
ENV NODE_ENV=production
CMD ["node", "app.js"]

USER запуск от имени пользователя

Если приложение нужно запускать от имени пользователя системы, то используйте инструкцию USER с именем пользователя. Например, если вы хотите запускать приложение от имени пользователя node_user, то конфигурационный файл будет выглядеть так:

FROM ubuntu:18.04
RUN sudo apt update && sudo apt install nodejs && sudo apt install npm
WORKDIR /app
COPY . .
ENV NODE_ENV=production
USER node_user
CMD ["node", "app.js"]

EXPOSE проброска порта вовне

Для запуска веб-приложения на компьютере вы используете веб-сервер, запущенный локально. Обычно веб-приложение становится доступным по адресу http://localhost:8080. Цифры в конце означают порт, открытый для запросов со стороны браузера или других приложений. Чтобы открыть в браузере веб-приложение, запущенное внутри контейнера, нужно «пробросить» запросы от браузера внутрь контейнера, а ответ от веб-приложения из контейнера наружу. Для этого используется перенаправление пакетов в виртуальном сетевом окружении.

EXPOSE незаменим, когда в образе находится база данных и нам нужен доступ к ней вне контейнера. Запись EXPOSE 8080 означает, что на компьютере, на котором запущен Docker, веб-приложение будет доступно по адресу http://localhost:8080:

FROM ubuntu:18.04
RUN sudo apt update && sudo apt install nodejs && sudo apt install npm
WORKDIR /app
COPY . .
ENV NODE_ENV=production
USER node_user
EXPOSE 8080
CMD ["node", "app.js"]

ARG Аргументы командной строки

Во время сборки образа не всегда удобно, а иногда даже опасно, описывать все параметры внутри Dockerfile, поскольку этот файл обычно доступен в репозитории большинству разработчиков. В случае публичного репозитория это недопустимо вовсе. В этом случае следует пользоваться переменными, значения которых задаются на этапе сборки образа.

Передавать данные можно с помощью аргументов команды docker build на этапе сборки образа. Во время сборки эти аргументы можно использовать как переменные, достаточно их определить инструкцией ARG. Можно задать и значения по умолчанию на тот случай, если пользователь не укажет нужные аргументы. Например, передать имя пользователя внутрь контейнера можно следующим образом:

docker build --build-arg user=node_user .

В Dockerfile надо будет добавить соответствующие инструкции:

FROM ubuntu:18.04
RUN sudo apt update && sudo apt install nodejs && sudo apt install npm
WORKDIR /app
COPY . .
ENV NODE_ENV=production
# Значение по умолчанию 'deploy' (можно не указывать)
ARG user=deploy
USER $user
EXPOSE 8080
CMD ["node", "app.js"]

Важно, что так не следует передавать секретные данные, поскольку их можно будет увидеть в истории Docker: docker history. Для безопасной передачи секретных данных лучше использовать тома Docker.

VOLUME точка монтирования для работы с постоянным хранилищем

Инструкция VOLUME добавляет тома в образ, том это папка в одном или более контейнерах, проброшенная через Union File System (UFS). Тома могут быть расшарены или повторно использованы между контейнерами. Команда VOLUME используется для организации доступа вашего контейнера к директории на хосте (тоже самое, что и монтирование директории), команда определяет где контейнер будет хранить постоянные данные и получать к ним доступ:

VOLUME ["/opt/project"]

В примере выше создается точка монтирования /opt/project для любого контейнера, созданного из образа.

Многоступенчатая сборка образа

С точки зрения оптимизации сборки, уменьшения размера образа и ускорения приложения, образ можно собирать в несколько этапов. Например, с помощью платформы Node.js произвести сборку веб-приложения на первом этапе, а на втором — запустить готовый бандл с помощью веб-сервера. Операция копирования из первого промежуточного образа во второй целевой пройдёт совершенно незаметно. После сборки образ будет занимать мало дискового пространства, в нем будет все самое необходимое для работы веб-приложения:

# Сборка проекта на платформе Node.js
FROM node:lts-alpine as build-stage
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
# Запуск приложения на сервере
FROM nginx:stable-alpine as production-stage
COPY --from=build-stage /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Имя промежуточного образа build-stage служит для передачи результата работы первой стадии сборки.

Рекомендации по сборке

Для того чтобы использовать образы эффективнее, необходимо следовать рекомендациям от команды Docker:

1. Нужно создавать образы так, чтобы жизненным циклом контейнера можно было удобно управлять. Образ не должен хранить внутреннее состояние. Данные внутрь образа можно передать на этапе сборки с помощью аргументов командной строки, а на этапе работы контейнера можно пользоваться томами Docker
2. Необходимо понимать контекст запуска веб-приложения: папка проекта, удалённый ресурс (remote source) или репозиторий
3. Надо понимать, что Dockerfile может запускаться вне контекста через стандартный поток ввода
4. Используйте файл .dockerignore для того, чтобы в образ попадали только нужные файлы и папки. От всего лишнего лучше избавиться на этапе сборки
5. Используйте сборку приложения в несколько стадий. Это позволит существенно уменьшить размер образа
6. Не устанавливайте то, что не будете использовать в образе
7. Необходимо разделять приложения на обособленные части, которые способны выполняться независимо. Этот процесс носит название декаплинга (Decoupling)
8. Минимизируйте количество слоёв в образе. Это повышает производительность образа как при сборке, так и при работе контейнера
9. Если параметры инструкции записываются в несколько строк (с помощью символа переноса строки ) необходимо выстраивать аргументы в алфавитном порядке. Это повышает читаемость файла и упрощает отладку
10. Используйте кэш Docker только для тех слоёв, которые будут нужны для сборки других образов. Для этого достаточно добавить параметр --no-cache=true в команду сборки docker build

Сборка образа

Образ Docker можно собрать тремя способами, чаще всего используется первый способ с указанием пути:

1. Указав путь к папке PATH
2. Указав путь к репозиторию URL
3. Используя стандартный поток ввода –

Создаем новый образ, если вы уже находитесь в папке где есть докер файл вам достаточно указать в инструкции точку, docker попытается найти докер файл в текущую директорию если такой файл был найден в текущей директории, запустится процесс создания нового образа и сверху вниз шаг за шагом выполнятся все инструкции которые указаны в докер файл и в конце если всё прошло успешно будет создан новый образ. В данном примере будет создан новый образ но ID у этого образа будет случайный:

docker build .

Если вы хотите добавить определённое имя созданному образу то нужно использовать опцию -t. Если тег не указан, Docker сам подставит тег latest:

docker build . -t my_calendar:4.1.3

После создания образа, можно создавать контейнер используя указанное ранее имя образа my_calendar.

Использование нескольких Dockerfile

Иногда возникает необходимость использования нескольких вариантов сборок в одном проекте. В этом случае не обойтись без нескольких файлов с инструкциями. При сборке можно указать другое имя для файла конфигурации или относительный путь внутри PATH, нужно использовать флаг -f:

docker build -f containers/dockerfile-mode-1 .

Точно так же можно указать относительный путь для проекта или репозитория по некоторому URL. Например, Docker может скачать не только репозиторий GitHub, но и произвольный архив с проектом, распаковать его и собрать образ (поддерживаются архивы форматов bzip2, gzip, xz):

docker build -f ctx/Dockerfile http://server/ctx.tar.gz

Файлы и папки проекта, исполняемый файл приложения, архив или репозиторий Git составляют контекст образа. Но Docker позволяет собирать образы без контекста из стандартного потока ввода. Собрать такой образ можно командой:

docker build - < Dockerfile

Исключение файлов из сборки .dockerignore

Если вам не нужно включать в образ какие-то папки или файлы из контекста, добавьте в папку файл исключений .dockerignore. В этом файле перечисляются в отдельных строках все пути или маски путей, которые не должны быть помещены в образ. Пример файла:

# Комментарий
*/temp*
*/*/temp*
temp?

• */temp позволяет не включать в образ файлы или папки, имена которых начинаются на temp, и которые находятся в любой папке первого уровня например, /somedir/temporary.txt или /somedir/temp
• */*/temp* делает то же, но для папок второго уровня
• temp? позволяет не включать в образ файлы и папки из корневой папки образа, имена которых начинаются на temp и состоят из пяти символов, последний из которых может быть любым

Примечание: Не путайте RUN и CMD. RUN выполняет команду и делает коммит результата; CMD ничего не выполняет во время сборки, но задает команду которая будет выполнена при запуске образа.

EXPOSE

EXPOSE <port> [<port>...]

Инструкция EXPOSE указывает Docker что контейнер слушает определенные порты после запуска. EXPOSE не делает порты контейнера доступными для хоста. Для этого, вы должны использовать флаг -p (что бы открыть диапазон портов) или флаг -P что бы открыть все порты из EXPOSE. Можно задать один номер порта и пробросить его на другой внешний порт.

ENV <key> <value>
ENV <key>=<value> ...

ENV myName="John Doe" myDog=Rex The Dog 
    myCat=fluffy

ENV myName John Doe
ENV myDog Rex The Dog
ENV myCat fluffy

ADD hom* /mydir/        # adds all files starting with "hom"
ADD hom?.txt /mydir/    # ? is replaced with any single character, e.g., "home.txt"

ADD test relativeDir/       # adds "test" to `WORKDIR`/relativeDir/
ADD test /absoluteDir/   # adds "test" to /absoluteDir/

COPY hom* /mydir/      # adds all files starting with "hom"
COPY hom?.txt /mydir/  # ? is replaced with any single character, e.g., "home.txt"

COPY test relativeDir/   # adds "test" to `WORKDIR`/relativeDir/
COPY test /absoluteDir/  # adds "test" to /absoluteDir/

docker run -i -t --rm -p 80:80 nginx

FROM ubuntu
ENTRYPOINT ["top", "-b"]
CMD ["-c"]

$ docker run -it --rm --name test  top -H
top - 08:25:00 up  7:27,  0 users,  load average: 0.00, 0.01, 0.05
Threads:   1 total,   1 running,   0 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.1 us,  0.1 sy,  0.0 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem:   2056668 total,  1616832 used,   439836 free,    99352 buffers
KiB Swap:  1441840 total,        0 used,  1441840 free.  1324440 cached Mem

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND
    1 root      20   0   19744   2336   2080 R  0.0  0.1   0:00.04 top

$ docker exec -it test ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  2.6  0.1  19752  2352 ?        Ss+  08:24   0:00 top -b -H
root         7  0.0  0.1  15572  2164 ?        R+   08:25   0:00 ps aux

FROM debian:stable
RUN apt-get update && apt-get install -y --force-yes apache2
EXPOSE 80 443
VOLUME ["/var/www", "/var/log/apache2", "/etc/apache2"]
ENTRYPOINT ["/usr/sbin/apache2ctl", "-D", "FOREGROUND"]

#!/bin/bash
set -e

if [ "$1" = 'postgres' ]; then
    chown -R postgres "$PGDATA"

    if [ -z "$(ls -A "$PGDATA")" ]; then
        gosu postgres initdb
    fi

    exec gosu postgres "$@"
fi

exec "$@"

#!/bin/sh
# Note: I've written this using sh so it works in the busybox container too

# USE the trap if you need to also do manual cleanup after the service is stopped,
#     or need to start multiple services in the one container
trap "echo TRAPed signal" HUP INT QUIT TERM

# start service in background here
/usr/sbin/apachectl start

echo "[hit enter key to exit] or run 'docker stop <container>'"
read

# stop service and clean up here
echo "stopping apache"
/usr/sbin/apachectl stop

echo "exited $0"

$ docker exec -it test ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.1  0.0   4448   692 ?        Ss+  00:42   0:00 /bin/sh /run.sh 123 cmd cmd2
root        19  0.0  0.2  71304  4440 ?        Ss   00:42   0:00 /usr/sbin/apache2 -k start
www-data    20  0.2  0.2 360468  6004 ?        Sl   00:42   0:00 /usr/sbin/apache2 -k start
www-data    21  0.2  0.2 360468  6000 ?        Sl   00:42   0:00 /usr/sbin/apache2 -k start
root        81  0.0  0.1  15572  2140 ?        R+   00:44   0:00 ps aux

$ docker top test
PID                 USER                COMMAND
10035               root                {run.sh} /bin/sh /run.sh 123 cmd cmd2
10054               root                /usr/sbin/apache2 -k start
10055               33                  /usr/sbin/apache2 -k start
10056               33                  /usr/sbin/apache2 -k start

$ /usr/bin/time docker stop test
test
real    0m 0.27s
user    0m 0.03s
sys 0m 0.03s

FROM ubuntu
ENTRYPOINT exec top -b

$ docker run -it --rm --name test top
Mem: 1704520K used, 352148K free, 0K shrd, 0K buff, 140368121167873K cached
CPU:   5% usr   0% sys   0% nic  94% idle   0% io   0% irq   0% sirq
Load average: 0.08 0.03 0.05 2/98 6
  PID  PPID USER     STAT   VSZ %VSZ %CPU COMMAND
    1     0 root     R     3164   0%   0% top -b

$ /usr/bin/time docker stop test
test
real    0m 0.20s
user    0m 0.02s
sys 0m 0.04s

FROM ubuntu
ENTRYPOINT top -b
CMD --ignored-param1

$ docker run -it --name test top --ignored-param2
Mem: 1704184K used, 352484K free, 0K shrd, 0K buff, 140621524238337K cached
CPU:   9% usr   2% sys   0% nic  88% idle   0% io   0% irq   0% sirq
Load average: 0.01 0.02 0.05 2/101 7
  PID  PPID USER     STAT   VSZ %VSZ %CPU COMMAND
    1     0 root     S     3168   0%   0% /bin/sh -c top -b cmd cmd2
    7     1 root     R     3164   0%   0% top -b

$ docker exec -it test ps aux
PID   USER     COMMAND
    1 root     /bin/sh -c top -b cmd cmd2
    7 root     top -b
    8 root     ps aux

$ /usr/bin/time docker stop test
test
real    0m 10.19s
user    0m 0.04s
sys 0m 0.03s

Инструкция VOLUME создает точку монтирования с заданным именем и помечает его как внешний смонтированный том из базового хоста или контейнера. Можно использовать JSON массив, VOLUME [«/var/log/»], или текстовую строку с несколькими аргументами, например VOLUME /var/log или VOLUME /var/log /var/db. 

Команда docker run инициализирует новый том с любыми данными которые существуют в указанном месте в пределах базового образа. К примеру, рассмотрим следующий фрагмент кода из Dockerfile:

FROM ubuntu
RUN mkdir /myvol
RUN echo "hello world" > /myvol/greeting
VOLUME /myvol

В результате запуска образа собранного из данного Dockerfile командой docker run, будет создана новая точка монтирования /myvol и в ней будет создан файл greeting.

USER

Инструкция USER устанавливает имя пользователя (UID) от имени которого будет запущен образ, а также инструкции RUN, CMD и ENTRYPOINT содержащиеся в Dockerfile.

WORKDIR

Инструкция WORKDIR устанавливает рабочий каталог для всех инструкций RUN, CMD, ENTRYPOINT, COPY и ADD которые будут выполнены в Dockerfile. Если WORKDIR не задана, то она будет создана даже если в Dockerfile нет ни одной инструкции для которой это необходимо.

Инструкция может быть использована несколько раз в одном Dockerfile. Если указывается относительный путь, он будет определен относительно предыдущего значения WORKDIR. К примеру:

WORKDIR /a
WORKDIR b
WORKDIR c
RUN pwd

В результате команда pwd из Dockerfile вернет значение /a/b/c.

Инструкция WORKDIR может использовать переменные окружения заданные через ENV. Вы можете использовать переменные окружения явно заданные в Dockerfile. К примеру:

ENV DIRPATH /path
WORKDIR $DIRPATH/$DIRNAME
RUN pwd

В результате команда pwd в этом Dockerfile вернет /path/$DIRNAME

ARG

ARG <name>[=<default value>]

Инструкция ARG задает переменные которые пользователь передает сборщику образа docker build с помощью флага —build-arg <varname>=<value>. Если пользователь указывает аргумент сборки, который не был определен в Dockerfile, сборка выдает ошибку.

One or more build-args were not consumed, failing build.

Автор Dockerfile может задать одну переменную задав ARG один раз или несколько переменных использовав ARGнесколько раз. Рассмотрим пример корректного Dockerfile:

FROM busybox
ARG user1
ARG buildno
...

Автор Dockerfile может опционально задать значение по умолчанию для переменной с помощью инструкции ARG:

FROM busybox
ARG user1=someuser
ARG buildno=1
...

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

Задание переменной с помощью инструкции ARG вступает в силу начинаю со строки на которой она была определена в Dockerfile, а не с момента использования в командной строке или где-то еще. Например рассмотрим следующий Dockerfile:

1 FROM busybox
2 USER ${user:-some_user}
3 ARG user
4 USER $user
...

Далее произведем сборку вызвав команду:

$ docker build --build-arg user=what_user Dockerfile

Инструкция USER в строке 2 принимает значение some_user поскольку переменная user задается только в 3 строке. Инструкция USER в строке 4 принимает значение what_user поскольку переменной user было задано значение what_user. До определения с помощью инструкции ARG, любое использование переменной возвращает пустую строку.

Вы можете использовать инструкции ARG или ENV для задания переменных доступных в инструкции RUN. Переменные окружения заданные с помощью ENV всегда заменяют переменные с тем же именем заданные инструкцией ARG. Рассмотрим Dockerfile с инструкциями ENV и ARG.

1 FROM ubuntu
2 ARG CONT_IMG_VER
3 ENV CONT_IMG_VER v1.0.0
4 RUN echo $CONT_IMG_VER

Затем запустим сборку образа следующей командой:

$ docker build --build-arg CONT_IMG_VER=v2.0.1 Dockerfile

В данном случае, инструкция RUN использует v1.0.0 вместо значения ARG заданного в строке пользователемv2.0.1. Это поведение похоже на поведение shell скриптов где локальные переменные переопределяют переменные переданные в качестве аргументов или унаследованные от окружения.

Использовав пример выше, но с другой спецификацией ENV вы можете создать более полезные взаимодействия между инструкциями ARG и ENV:

1 FROM ubuntu
2 ARG CONT_IMG_VER
3 ENV CONT_IMG_VER ${CONT_IMG_VER:-v1.0.0}
4 RUN echo $CONT_IMG_VER

В отличие от инструкции ARG, значения ENV всегда присутствуют в созданном образе. Рассмотрим сборку без флага the —build-arg:

$ docker build Dockerfile

В данном примере Dockerfile, переменная CONT_IMG_VER сохранится в образе, но ее значение будет равно v1.0.0 поскольку оно задано по умолчанию в строке 3 инструкцией ENV.

Техника замены переменных в данном примере позволяет вам передавать аргументы из командной строки и сохранять их в конечном образе с помощью инструкции ENV. Замена переменных поддерживается для ограниченного числа инструкций Dockerfile.

Docker имеет набор предустановленных переменных ARG которые вы можете задавать без предварительной инструкции ARG в Dockerfile.

Для этого, просто передайте нужный аргумент в командной строке с помощью флага —build-arg <varname>=<value>.

Влияние на кэш сборки

Переменные ARG не сохраняются в собранном образе в отличае от ENV переменных. Однако, ARG переменные влияют на кэш сборки аналогичным образом. Если Dockerfile определяет ARG переменную чье значение отличается от предыдущей сборки, кэш не будет использован. В частности, все инструкции RUN следующие после ARG и использующие данную переменную (так же как и в случае с переменными окружения) не будут использовать кэш.

Для примера, рассмотрим два следующих Dockerfile:

1 FROM ubuntu
2 ARG CONT_IMG_VER
3 RUN echo $CONT_IMG_VER

1 FROM ubuntu
2 ARG CONT_IMG_VER
3 RUN echo hello

Если задать —build-arg CONT_IMG_VER=<value> в командной строке, в обоих случаях, строка 2 не вызывает промах кэша, в отличие от строки 3. В случае где команда RUN зависит от CONT_IMG_VER=<value>, если <value> изменится, мы получаем промах кеша.

Рассмотрим другой пример с такой же командной строкой:

1 FROM ubuntu
2 ARG CONT_IMG_VER
3 ENV CONT_IMG_VER $CONT_IMG_VER
4 RUN echo $CONT_IMG_VER

В данном примере, промах кэша происходит в строке 3. Это происходит по тому что значение переменной в ENV зависит от переменной ARG и эта переменная меняется через командную строку. В этом примере, команда ENV включает значение переменной в образ.

Если инструкция ENV заменяет значение переменной в инструкции ARG с тем же именем, как в этом Dockerfile:

1 FROM ubuntu
2 ARG CONT_IMG_VER
3 ENV CONT_IMG_VER hello
4 RUN echo $CONT_IMG_VER

Строка 3 не вызывает промаха кэша по тому что значение CONT_IMG_VER является константой (hello). В результате, переменные окружения и значения используемые в RUN (строка 4) не меняются от сборки к сборке.

ONBUILD

Инструкция ONBUILD добавляет к образу триггерную инструкцию, которая выполняется в последнюю очередь если образ используется в качестве базового для другой сборки. Триггер будет выполнен в дочернем контексте сборки, так если бы инструкция была вставлена сразу после инструкции FROM дочернего Dockerfile.

Любая инструкция сборки может быть установлена в качестве триггера.

Это полезно если вы собираете образ который будет использоваться в качестве базового для сборки другого образа, например вы можете изменить переменные окружения или сделать демон конфигурация которого может быть изменена пользователем.

К примеру, если ваш образ является многократно используемым Python сборщиком приложения, которому требуется исходный код в определенном каталоге, для скрипта-сборщика запускаемого в конце. Вы не можете вызвать ADD и RUN как обычно, по тому что у вас еще нет доступа как исходному коду приложения, и он может отличаться для каждой сборки. Вы могли бы просто предоставить разработчикам приложения шаблонный Dockerfile для вставки в их приложение, но это не эффективно, может спровоцировать ошибки и усложняет обновление.

В качестве решения следует использовать ONBUILD для регистрации дополнительных инструкций для отложенного запуска, при следующем шаге сборки.

Как это работает:

Для примера можно добавить что ни будь вроде этого:

[...]
ONBUILD ADD . /app/src
ONBUILD RUN /usr/local/bin/python-build --dir /app/src
[...]

STOPSIGNAL

Инструкция STOPSIGNAL устанавливает сигнал системного вызова, который будет отправлен для завершения контейнера. Сигнал может быть натуральным числом, которое соответствует позиции в таблице системных вызовов ядра, например 9 или именем сигнала в формате SIGNAME, например SIGKILL.

HEALTHCHECK

Инструкция HEALTHCHECK имеет две формы:

Инструкция HEALTHCHECK указывает Docker как проверить работает ли контейнер. Данная функция может помочь в выявлении ситуаций когда веб-сервер вошел в бесконечный цикл и не принимает соединения, в то время как его процесс все еще работает.

Когда у контейнера задана проверка на работоспособность, он имеет дополнительный статус состояния. Этот статус изначально равен starting. Всякий раз когда проверка состояния проходит успешно, он становится равен healthy (вне зависимости от предыдущего состояния). После определенного числа неудачных проверок статус изменяется на unhealthy.

Перед CMD можно задать следующие опции:

Проверка работоспособности стартует первый раз спустя заданное время после запуска контейнера, а затем повторяется спустя тот же промежуток времени после того как предыдущая проверка была завершена.

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

Параметр retries отвечает за количество неудачных проверок необходимое для смены статуса контейнера на unhealthy.

Можно задать только одну инструкцию HEALTHCHECK в Dockerfile. Если указано несколько HEALTHCHECK, только последняя будет работать.

Команда после ключевого слова CMD может быть либо командой оболочки (например HEALTHCHECK CMD /bin/check-running) или выполнить массив (по аналогии с другими командами Dockerfile; для большей информации читайте документацию по ENTRYPOINT).

Статус завершения команды указывает на состояние контейнера. Возможные значения:

Например, чтобы проверить каждые пять минут или около того, что веб-сервер способен обслуживать главную страницу сайта в течение трех секунд:

HEALTHCHECK --interval=5m --timeout=3s 
  CMD curl -f http://localhost/ || exit 1

Что бы помочь в отладке, любой исходящий текст (в кодировке UTF-8) который возвращают команды в stdout или stderr будет сохранен в статусе состояния и может быть запрошен командой docker inspect. Такой вывод должен быть коротким (только первые 4096 байт сохраняются на текущий момент).

Когда статус состояния контейнера изменяется, событие health_status генерируется с новым статусом.

Функция HEALTHCHECK была добавлена в Docker 1.12.

SHELL

SHELL ["executable", "parameters"]

Инструкция SHELL позволяет заменить стандартную оболочку для выполнения команд на пользовательскую. Оболочкой по умолчанию в Linux является [«/bin/sh», «-c»], а в Windows [«cmd», «/S», «/C»]. Инструкция SHELL записывается в JSON формате в Dockerfile.

Инструкция SHELL в частности полезна в Windows где есть две совершенно разных оболочки: cmd и powershell, а также альтернативные включая sh.

Инструкция SHELL может использоваться несколько раз. Каждая инструкция SHELL заменяет предыдущую инструкцию SHELL, и влияет на все последующие инструкции. К примеру:

FROM windowsservercore

# Executed as cmd /S /C echo default
RUN echo default

# Executed as cmd /S /C powershell -command Write-Host default
RUN powershell -command Write-Host default

# Executed as powershell -command Write-Host hello
SHELL ["powershell", "-command"]
RUN Write-Host hello

# Executed as cmd /S /C echo hello
SHELL ["cmd", "/S"", "/C"]
RUN echo hello

Следующие инструкции могут быть затронуты командой SHELL при использовании shell формы в Dockerfile: RUN, CMD и ENTRYPOINT.

Следующий пример представляет собой общий шаблон для Windows который может быть упрощен с помощью инструкции SHELL:

...
RUN powershell -command Execute-MyCmdlet -param1 "c:foo.txt"
...

Команда выполняемая docker будет выглядеть так:

cmd /S /C powershell -command Execute-MyCmdlet -param1 "c:foo.txt"

Это не эффективно по двум причинам. Во-первых, вызывается не обязательная команда cmd.exe (т. е. оболочка). Во-вторых, каждая инструкция RUN в shell форме требует ставить перед командой powershell -command.

Есть два механизма позволяющих упростить решение. Одно из них, это использование JSON формы для инструкции RUN:

...
RUN ["powershell", "-command", "Execute-MyCmdlet", "-param1 "c:\foo.txt""]
...

В то время как JSON форма является однозначной и не использует не обязательный cmd.exe, но эта форма записи достаточно избыточна из-за необходимости использовать двойные кавычки и экранирование. Альтернытивным решением является использование инструкции SHELL и shell формы команд, что делает синтаксис более естественным для пользователей Windows, особенно при комбинировании с директивой парсера escape:

# escape=`

FROM windowsservercore
SHELL ["powershell","-command"]
RUN New-Item -ItemType Directory C:Example
ADD Execute-MyCmdlet.ps1 c:example
RUN c:exampleExecute-MyCmdlet -sample 'hello world'
В результате получаем:

PS E:dockerbuildshell> docker build -t shell .
Sending build context to Docker daemon 3.584 kB
Step 1 : FROM windowsservercore
 ---> 5bc36a335344
Step 2 : SHELL powershell -command
 ---> Running in 87d7a64c9751
 ---> 4327358436c1
Removing intermediate container 87d7a64c9751
Step 3 : RUN New-Item -ItemType Directory C:Example
 ---> Running in 3e6ba16b8df9

    Directory: C:

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-----         6/2/2016   2:59 PM                Example

 ---> 1f1dfdcec085
Removing intermediate container 3e6ba16b8df9
Step 4 : ADD Execute-MyCmdlet.ps1 c:example
 ---> 6770b4c17f29
Removing intermediate container b139e34291dc
Step 5 : RUN c:exampleExecute-MyCmdlet -sample 'hello world'
 ---> Running in abdcf50dfd1f
Hello from Execute-MyCmdlet.ps1 - passed hello world
 ---> ba0e25255fda
Removing intermediate container abdcf50dfd1f
Successfully built ba0e25255fda
PS E:dockerbuildshell>

Инструкция SHELL также может быть использована для изменения режима работы оболочки. Например, использовав SHELL cmd /S /C /V:ON|OFF в Windows можно разрешить или запретить отложенное расширение переменных среды.

Инструкция SHELL также может быть использована в Linux для переключения на альтернативные оболочки вроде zsh, csh, tcsh и д.т.

Инструкция SHELL была добавлена в Docker 1.12.

Примеры Dockerfile

Ниже вы можете увидеть некоторые примеры синтаксиса Dockerfile.

# Nginx
#
# VERSION               0.0.1

FROM      ubuntu
MAINTAINER Victor Vieux <victor@docker.com>

LABEL Description="This image is used to start the foobar executable" Vendor="ACME Products" Version="1.0"
RUN apt-get update && apt-get install -y inotify-tools nginx apache2 openssh-server

# Firefox over VNC
#
# VERSION               0.3

FROM ubuntu

# Install vnc, xvfb in order to create a 'fake' display and firefox
RUN apt-get update && apt-get install -y x11vnc xvfb firefox
RUN mkdir ~/.vnc
# Setup a password
RUN x11vnc -storepasswd 1234 ~/.vnc/passwd
# Autostart firefox (might not be the best way, but it does the trick)
RUN bash -c 'echo "firefox" >> /.bashrc'

EXPOSE 5900
CMD    ["x11vnc", "-forever", "-usepw", "-create"]

# Multiple images example
#
# VERSION               0.1

FROM ubuntu
RUN echo foo > bar
# Will output something like ===> 907ad6c2736f

FROM ubuntu
RUN echo moo > oink
# Will output something like ===> 695d7793cbe4

# You`ll now have two images, 907ad6c2736f with /bar, and 695d7793cbe4 with
# /oink.

Вы когда-нибудь пытались развернуть собственное приложение где-то за пределами вашей локальной машины? Запустить разработанный продукт (например, сервер на Node.js) на другом компьютере — иногда непростая задача.

Программные зависимости, переменные среды, файлы конфигурации — необходимо все это настроить, чтобы запустить даже самое простое приложение. И делать это вручную — рутинная и ненадежная работа. Нужна автоматизация.

Множество современных технологий стремятся решить проблему различных сред. Контейнеризация — одно из таких направлений. И именно Docker здесь — самый часто используемый инструмент.

Docker позволяет упаковать приложение, окружение и зависимости в так называемый контейнер.

Сперва создается образ приложения — код, библиотеки, файлы конфигурации, переменные среды и окружение. Все, что находится внутри образа, необходимо для сборки и запуска приложения.

Контейнером же называется непосредственно экземпляр этого образа. Если провести аналогию из языков программирования, то образ — это класс, а контейнер — экземпляр этого класса.

В отличие от виртуальной машины, контейнер является лишь процессом операционной системы.

По сути, Docker создает абстракцию над низкоуровневыми инструментами операционной системы, позволяя запускать один или несколько контейнерных процессов внутри виртуализированных экземпляров операционной системы Linux.

Несмотря на то, что Docker отнюдь не панацея в вопросах автоматизации деплоя, он решает множество важных задач:

• Быстро развертывает приложения
• Обеспечивает переносимость между машинами
• Имеет контроль версий
• Позволяет строить гибкую архитектуру с использованием компонентов
• Уменьшает накладные расходы при обслуживание за счет своей компактности

Что необходимо установить?

Прежде чем начать настройку, убедитесь что вы установили все необходимые программы на ваш компьютер. А именно:

• Node.js
• Docker

У нас есть инструкции по установке Docker на Ubuntu, а для Node.js — инструкции для разных операционных систем.

Этот материал предполагает, что читатель уже имеет опыт работы с платформой Node.js, а возможно и знаком с Docker.

Шаг 1 — Создание приложения Node.js

Конфигурация и зависимости

Сперва нужно создать каталог, в котором будут находиться исходные файлы приложения. Назовем его node_app:

mkdir node_app

Теперь можно перейти в этот каталог. В нашем случае он будет считаться корневым:

cd node_app

Как и в любом проекте на Node.js, нам понадобится конфигурационный файл. Создадим и откроем его. В Linux это можно сделать через nano:

nano package.json

Информация о проекте стандартная:

{
  "name": "node-app-by-timeweb",
  "description": "node with docker",
  "version": "1.0.0",
  "main": "timeweb.js",
  "keywords": [
    "nodejs",
    "express",
    "docker"
  ],
  "dependencies": {
    "express": "^4.16.4"
  },
  "scripts": {
    "start": "node timeweb.js"
  }
}

Как вы знаете, этот файл включает в себя общую информацию о проекте, авторе и лицензии. Все это нужно для в пакетного менеджера NPM, который отвечает за установку зависимостей и публикацию проектов в официальную библиотеку.

Обратите внимание, что самые важные параметры в этом package.json:

• Точка входа main для приложения — файл timeweb.js
• В зависимостях dependencies указан сетевой фреймворк Express, на котором построен этот пример

Теперь можно сохранить и закрыть файл. Осталось только установить зависимости:

npm install

Исходный код приложения

Примером будет простое серверное приложение, выводящее статичную веб-страницу по запросу пользователя — index.html.

Структура файлов такая:

• timeweb.js — точка входа, которая обрабатывает запросы и выполняет роутинг;
• index.html — разметка веб-страницы.

Стоит отметить, что CSS-стили для упрощения примера мы напишем сразу в HTML. Разумеется, в реальных проектах визуальное описание веб-страницы располагается в отдельных файлах вроде style.css — часто с применением транспиляторов SASS, LESS или SCSS.

Как и прежде, с помощью nano, создадим и откроем timeweb.js:

nano timeweb.js

Он будет содержать только самый минимальный код для запуска веб-сервера:

const express = require('express'); // подключаем фреймворк Express (модуль)
const app = express(); // создаем экземпляр приложения
const router = express.Router(); // создаем экземпляр роутера
const path = __dirname; // записываем путь до рабочего каталога
const port = 8080; // записываем порт сервера
// выводим в консоль HTTP METHOD при каждом запросе
router.use(function (req,res,next) {
  console.log('/' + req.method);
  next();
});
// отвечаем на запрос главной страницы файлом index.html
router.get('/', function(req,res){
  res.sendFile(path + 'index.html');
});
// подключаем роутер к приложению
app.use('/', router);
// начинаем прослушивать порт 8080, тем самым запуская http-сервер
app.listen(port, function () {
  console.log('Listening on port 8080')
})

Более подробное описание всего функционала фреймворка, а также примеры его использования можно найти в официальной документации Express.

Файл HTML-разметки index.html выглядит довольно тривиально:

<!DOCTYPE html>
<html lang="en">
<head>
    <title>NodeJS app with Docker by TimeWeb</title>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
    <div>Hello World from TimeWeb!</div>
</body>
<style>
body
{
   height: 100vh;
   display: flex;
   align-items: center;
   justify-content: center;
}
body > div
{
   padding: 12px;
   color: white;
   font-weight: bold;
   background: black;
}
</style>
</html>

Чтобы убедиться, что все отображается корректно, вы можете открыть файл index.html в браузере. Фраза “Hello World from TimeWeb!” должна отобразиться в центральной части страницы, вместе с темным обрамлением.

На этом наше импровизированное приложение можно считать законченным. Теперь можно перейти к самой докеризации.

Шаг 2 — Создание Dockerfile

Dockerfile — это такой текстовый документ, который содержит инструкции по сборке Docker-образа.

Все инструкции выполняются ровно в том порядке, в каком они записаны в этом файле. Формат записи прост — указывается название инструкции и ее аргументы. Это чем-то похоже на функции в языках программирования. Комментарии пишутся после #.

# comment
INSTRUCTION arguments

Хотя имена инструкций не чувствительны к регистру, их принято писать большими буквами, чтобы они визуально не сливались с аргументами.

Давайте создадим и откроем Dockerfile, после чего можно перейти к его редактированию:

nano Dockerfile

Установка образа Node.js

Docker будет последовательно выполнять инструкции из Dockerfile каждый раз, когда конечный пользователь будет выполнять развертывание вашего приложения.

Поэтому первое, что ему понадобится — сам Node. Соответствующую инструкцию необходимо добавить в Dockerfile:

FROM node:19-alpine

В данном случае команда FROM устанавливает на машину официальный образ Node.js Alpine Linux 19 версии.

На всякий случай — у Docker есть официальная библиотека Docker Hub, в которой хранятся образы контейнеров от разработчиков со всего мира. Разумеется, Node.js там тоже представлен.

Кстати, если посмотреть на код Node.js на GitHub, то можно заметить аналогичный Dockerfile, который выполняет всю работу по настройке среды для запуска Node на машине пользователя.

Если провести очень простую аналогию, то Dockerfile в Docker — это почти то же самое, что package.json в NPM. Он настраивает проект и «тащит» за собой все зависимости, причем рекурсивно — Dockerfile уровня выше устанавливает образ с Dockerfile-ом уровня ниже и так далее.

Установка рабочего каталога

Образу Docker (который впоследствии превратится в контейнер) нужно указать, в каком каталоге нужно выполнять остальные команды, которые будут оперировать файлами и папками. Например, команды RUN, CMD, ENTRYPOINT, COPY или ADD.

Для этого есть инструкция WORKDIR, которой в качестве аргумента передается путь каталога:

WORKDIR /app

Копирование конфигурационных файлов

С помощью команды COPY нужно скопировать файлы package.json и package-lock.json из каталога проекта на локальном компьютере в файловую систему контейнера, а точнее в указанный ранее каталог:

COPY package.json package-lock.json ./

Из-за того, что Dockerfile находится в каталоге проекта, образ контейнера содержит в себе все необходимые файлы. Однако образ — не контейнер. Поэтому с помощью команды COPY мы сообщаем Docker какие конкретно файлы нужно перенести в «виртуальное пространство» контейнера.

Установка зависимостей NPM

Поскольку установленный ранее каталог приложения уже содержит package.json и package-lock.json, можно загрузить необходимые зависимости из реестра NPM.

Для этих целей обычно выполняется команда npm install. Чтобы Docker сделал это автоматически нужно указать инструкцию RUN:

RUN npm install

Docker выполнит эту команду в ранее указанном каталоге /app.

Обратите внимание, что инструкция RUN выполняет команды во время установки образа (а не запуска контейнера), который впоследствии будет существовать как контейнер. Кстати, команды можно указывать в виде последовательной цепочки:

RUN [“command1”, “command2”, “command3”]

Копирование остальных файлов

После установки всех зависимостей можно скопировать все остальные файлы проекта в каталог /app. Для этого используется та же команда COPY, но с указанием всей директории, а не конкретных файлов:

COPY . ./

Запуск приложения

Теперь можно указать команду, которая будет запускать само приложение. Для этого нужно использовать инструкцию CMD. От инструкции RUN она отличается тем, что выполняет указанные команды уже во время выполнения контейнера, а не в момент установки образа:

CMD npm start

Не забудьте, что в package.json у вас уже определена команда start:

  "scripts": {
    "start": "node timeweb.js"
  }

Итоговая конфигурация образа в Dockerfile

Итак, после указания полной последовательности действий, возложенных на Docker, полный код Dockerfile должен выглядеть следующим образом:

# устанавливаем официальный образ Node.js
FROM node:19-alpine
# указываем рабочую (корневую) директорию
WORKDIR /app
# копируем основные файлы приложения в рабочую директорию
COPY package.json package-lock.json ./
# устанавливаем указанные зависимости NPM на этапе установки образа
RUN npm install
# после установки копируем все файлы проекта в корневую директорию
COPY . ./
# запускаем основной скрипт в момент запуска контейнера
CMD npm start

Все! Минимальный набор инструкций указан. Теперь можно попробовать создать образ и на его основе запустить контейнер.

Немного про файл .dockerignore

.dockerignore — это еще один конфигурационный файл, содержащий каталоги, которые необходимо исключить при создании образа Docker. Скажем так, в папке вашего проекта может быть много файлов, которые никак не связаны с создаваемым образом, хотя и важны при разработке.

На самом деле .dockerignore гораздо важнее, чем может показаться на первый взгляд — он предотвращает попадание слишком больших или конфиденциальных файлов в образ. Он также ограничивает действие команд ADD или COPY, используемых в Dockerfile.

Например, каждый раз, когда вы используете команду docker build, Docker сверяет кеш образа с состоянием файловой системы. Если есть изменения — сборка выполняется заново.

Однако, если некоторые файлы в вашем каталоге довольно часто обновляются, но при это не нужны для построения образа — их следует исключить, чтобы не выполнять бессмысленную пересборку.

Создание и редактирование .dockerignore

Файл .dockerignore создается в корневом каталоге вашего проекта. Внутри него на каждой новой строчке указываются названия файлов и директорий для исключения.

# it's a comment
README.md

Как и Dockerfile, символ # обозначает начало комментария. Кстати, есть и способы и более общего указания файлов:

*/folder

В данном случае все директории (или файлы без расширения) с именем folder в любом каталоге на один уровень ниже будут исключены из сборки.

Впрочем, можно игнорировать директории и файлы рекурсивно — в корневом и во всех уровнях ниже:

**/folder

При этом, с помощью ! файл с конкретным именем можно исключить из исключения. В данном случае кроме README.md файлы с расширением .md не попадут в сборку:

*.md
!README.md

Шаг 3 — Сборка образа Docker

Образ Docker создается на основе описания в Dockerfile. Для этого есть соответствующая команда, которая запускается из корня проекта — там, где расположен Dockerfile:

docker build . -t nodeproject

Флаг -t необходим для установки имени тега нового образа. Впоследствии на него можно будет ссылаться через nodeproject:latest.

После этого можно удостовериться в том, что образ был действительно создан:

docker images nodeproject:latest

Эта команда выводит информацию о конкретном образе Docker:

REPOSITORY     TAG         IMAGE ID             CREATED            SIZE
nodeproject       latest      gk8orf8fre489     3 minutes ago   15MB

Соответственно, если не указывать конкретное название, то в консоли выйдет информация обо всех образах на компьютере.

Шаг 4 — Запуск контейнера Docker

Каждый созданный образ можно запускать в виде контейнера. Для этого указывается его имя:

docker run nodeproject

Запущенный в виде контейнера образ Docker является типичным процессом операционной системы, в котором файловая система, сеть и дерево процессов отделены от хост-компьютера.

Все консольные выводы вашего приложения Node.js будут выводиться в том же терминале, в котором был запущен контейнер. Однако, привязка процесса контейнера к конкретному экземпляру терминала — не лучшее решение.

Поэтому более разумной практикой является запуск контейнера в фоновом режиме с помощью специального флага --detach или -d.

docker run -d nodeproject

Docker запустит контейнер в автономном режиме, написав в терминале специальный идентификатор. Его можно будет использовать для доступа к контейнеру в последующих командах:

9341f8b2532b121e9dea8aeb55563c24302df96710c411c699a612e794e89ee4

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

docker ps

Таким образом можно увидеть идентификатор контейнера, образ на основе которого запущен контейнер, команду, используемую для запуска контейнера, время его создания, текущий статус, порты, предоставляемые контейнером, и само имя контейнера. Кстати, по умолчанию Docker присваивает контейнеру случайное имя, но его можно изменить с помощью флага --name.

Обратите внимание, речь идет именно про имя контейнера, а не образа. Предположим, вы запускаете контейнер с именем myname:

docker run -d --name myname nodeproject

Теперь вы сможете его остановить, указав имя:

docker stop myname

А также удалить:

docker rm myname

Логи автономного контейнера

Запущенный в фоновом режиме контейнер не показывает выводы в консоль в явном виде. Однако, они по прежнему существуют. Их можно увидеть так:

docker logs myname

Теперь все, что успело вывести ваше приложение в консоль, будет напечатано в терминале.

Заключение

Эта статья очень коротко рассказывает, что такое Docker, как он работает и почему он может быть полезен при разработке Node-приложений.

Понимая как правильно форматировать Dockerfile и запускать приложение Node.js с помощью Docker, вы можете автоматизировать процесс развертывания программных продуктов на машинах конечных пользователей.

Подобные решения наиболее актуальный в DevOps-разработке, в частности при построении CI/CD-пайплайнов — непрерывной интеграции и развертывании.