Файл: Обязательные для изучения материалы.pdf

Учебник Docker
В этом учебнике объединяются статьи, позволяющие освоить Docker в кратчайшие сроки фактически с самого нуля. Крайне желательно, чтобы вы знакомились с материалами раздела "Обязательные для
изучения материалы" в том порядке, в котором они для вас подготовлены. Это существенно облегчит вам знакомство с этой увлекательной темой. Тем не менее, вы всегда можете выбрать именно тот раздел,
который вам нравится больше всего прямо сейчас! Happy Dockering!
Что такое Docker Engine?
Docker Engine — это клиент-серверное приложение, содержащее следующие основные компоненты:
•
Сервер, по сути являющийся долго работающим приложением, называемым демоном
•
REST API, определяющее интерфейсы для взаимодействия, которые могут использовать другие программы.
•
Консольный (CLI) клиент
Консольный клиент использует Docker REST API для управления или взаимодействия с демоном Docker при помощи скриптов или непосредственных консольных команд.
Демон создает и управляет объектами Docker, такими как образы (images), контейнеры, сети и тома данных (data volumes)
На заметку: Docker распространяется под открытой Apache 2.0 лицензией.
Для чего я могу использовать Docker?
Быстрая, последовательная доставка ваших приложений

Docker может упростить жизненный цикл разработки, позволяя разработчикам работать в стандартизованных окружениях, используя локальные контейнеры, в которых может работать ваше приложение или сервисы. Вы также можете интегрировать Docker в ваши процессы непрерывной интеграции (continuous integration) и непрерывной доставки (continuous deployment).
Представьте следующий примерный сценарий. Ваши разработчики пишут код локально и делятся своей работой с коллегами при помощи контейнеров Docker. Они могут использовать Docker для помещения своих приложений в тестовые среды и запуска автоматических и ручных тестов. Когда разработчики находят проблему, они могут исправить ее в разработческом окружении и повторно поместить контейнеры в тестовое окружение. Когда же тестирование завершено, доставить исправление в ПО
конечному заказчику становится также просто как положить новые контейнеры в продуктивное окружение.
Адаптивная доставка и масштабируемость
Использующая контейнеры платформа Docker позволяет хорошо переносить нагрузки. Контейнеры
Docker могут работать на локальной машине разработчика, на физическом или виртуальном сервере в датацентре, в Облаке, или в смешанном окружении.
Переносимость и легковесная природа Docker также позволяют просто управлять нагрузкой,
масштабировать приложения и сервисы вверх или вниз настолько быстро, насколько этого требует бизнес, почти в реальном времени.
Обслуживание больших нагрузок на том же самом железе
Docker легковесен и очень быстр. Он предоставляет жизнеспособную и экономически эффективную альтернативу виртуальным машинам, запускаемым в гипервизорах, позволяя вам использовать больше ваших вычислительных мощностей для достижения ваших бизнес целей. Это особенно важно при использовании его в очень уплотненных окружениях при доставке приложений малых или средних размеров там, где необходимо сделать больше меньшими усилиями.
Архитектура Docker
Docker использует клиент-серверную архитектуру. Клиент Docker общается с Docker демоном, который обслуживает тяжеловесную сборку, работу, а также размещение ваших контейнеров. Демон и клиент
Docker могут работать на одной системе или же клиент Docker может подключаться к удаленному
Docker демону. Клиент и демон Docker взаимодействуют при помощи REST API, через UNIX сокеты или при помощи сетевого интерфейса.

Демон Docker
Демон Docker работает на хостовом сервере. Пользователь использует клиент Docker для взаимодействия с демоном.
Клиент Docker
Клиент Docker в формате исполняемого файла docker — это основной пользовательский интерфейс для Docker. Он принимает команды и конфигурационные флаги от пользователя и взаимодействует с демоном Docker. Один клиент может взаимодействовать с множеством несвязанных демонов.
Внутри Docker
Для понимания внутренностей Docker вам необходимо знать про образы (images), реестры (registries) и контейнеры (containers).
Образы Docker
Образ Docker — это шаблон в формате «только для чтения» с инструкциями для создания контейнера
Docker. Например, образ может содержать в себе ОС Ubuntu с web-сервером Apache и вашим установленным внутрь web-приложением. Вы можете собрать или обновить образ с нуля, или загрузить и использовать образы, созданные другими людьми. Образ может быть основан или расширять один или более других образов. Образ Docker описан в текстовом файле Dockerfile, который имеет простой и вполне определенный синтаксис. Для получения большей информации о образах, смотрите «
Как работают образы Docker?
«.
Образы Docker — это основной строительный компонент Docker.
Контейнеры Docker
Контейнер Docker — это запускаемый экземпляр Docker образа. Вы можете запустить, остановить,
переместить или удалить контейнер, используя Docker API или консольный клиент. Когда вы запускаете контейнер, вы можете предоставить конфигурационные метаданные такие как сетевая информация или переменные окружения. Каждый контейнер — это изолированная и безопасная платформа для приложений, однако, ему может быть предоставлен доступ к ресурсам, работающим на другом хосте

или контейнере, таким как постоянный сторадж (persistent storage) или база данных. Для получения большей информации о контейнерах, смотрите «
Как работает контейнер?
«
Контейнеры Docker — это рабочий компонент Docker.
Реестры Docker
Реестр Docker — это библиотека образов. Реестр может быть публичным, приватным, а также может быть установлен на том же сервере, что и демон или клиент Docker или же на совсем частном сервере.
Для получения большей информации о реестре, смотрите
Как работает реестр Docker?
Реестры Docker — это компонент распространения Docker.
Сервис Docker
Сервис Docker позволяет целому рою (swarm) Docker узлов работать одновременно, обслуживая определенное количество экземпляров реплицированной задачи (replica task), представляющей собой образ Docker. Вы можете определить количество одновременных запускаемых реплицированных задач и кластерный менеджер убедится, что нагрузка распределена You can specify the number of concurrent replica tasks to run, and the swarm manager ensures that the load is spread равномерно по рабочим узлам.
Для конечного потребителя сервис Docker представляется как одно приложение. Docker Engine поддерживает режим работы swarm mode с Docker 1.12 и выше.
Сервисы Docker — это компоненты масштабирования Docker.
Как работают образы Docker?
Образы Docker — это шаблоны в формате «только чтение» из которых запускаются Docker контейнеры.
Каждый образ состоит из последовательности слоев. Docker использует union file systems для объединения этих слоев в единый образ. Union FS позволяет файлам и директориям отдельных файловых систем известным как ветки (branches) быть прозрачно наложенными друг на друга, чтобы образовать единую связную файловую систему.
Эти слои одна из причин, почему Docker настолько легковесный. Когда вы изменяете образ Docker,
например, в процессе обновления приложения на новую версию, собирается только новый слой,
заменяет только тот слой, который обновляется. Остальные слои остаются нетронутыми. Для распространения обновления все, что вам нужно, это передать обновленный слой. Механизм работы со слоями увеличивает скорость распространения образов Docker. Docker сам определяет, какой слой должен быть обновлен в рантайме.
Образ определяется в Dockerfile. Каждый образ начинается с основного образа (base image), такого как ubuntu (основного образа ОС Ubuntu) или fedora (основного образа ОС Fedora). Вы можете также самостоятельно использовать доступные образы в качестве основы для новых, например, вам доступен базовый образ web-сервера Apache, и вы можете использовать его для всех образов ваших web- приложений. Базовый образ определяется при помощи ключевого слова FROM в Dockerfile.
Заметка:
Docker Store
— это публичный реестр и хранилище образов Docker
Образ Docker собирается на основе базового образа при помощи простого
The docker image is built from the base image using a simple, наглядного набора шагов,
которые называются инструкциями, которые последовательно записаны в Dockerfile. Каждая инструкция создает новый слой внутри образа. Некоторые примеры инструкций Dockerfile:

•
Определить базовый образ (FROM)
•
Определить ответственного за поддержку (MAINTAINER)
•
Выполнить команду (RUN)
•
Добавить файл или директорию (ADD)
•
Создать переменную окружения (ENV)
•
Какой процесс запустить, когда будет запускаться контейнер из этого образа (CMD)
Docker читает Dockerfile когда вы запускаете сборку (build) образа, выполняет инструкции и возвращает образ.
Как работает реестр Docker?
Реестр Docker хранит Docker образы. После того как вы собрали Docker образ, вы можете отправить
(push) его в публичный реестр, такой как
Docker Store или приватный реестр, закрытый вашим межсетевым экраном. Вы можете также искать уже существующие образы и скачивать (pull) их из реестра на хост.
Docker Store позволяет вам не только хранить, но и покупать и продавать Docker образы. Например, вы можете купить образ Docker, содержащий приложение или сервис от какого-либо вендора программного обеспечения и использовать его в процессе разворачивания вашего приложения в тестовое,
промежуточное или продуктивное окружение, а также обновлять его и ваше приложение просто скачивая (pull) новую версию доступных образов и переразворачивая ваши контейнеры.
Как работает контейнер?
В процессе своей работы контейнер использует Linux ядро хостовой машины, состоит из какого-то количества дополнительных файлов, которые были добавлены к нему в процессе его создания, а также метаданных, связываемых с контейнером в процессе его создания или когда контейнер уже запущен.
Каждый контейнер собирается из образа. Образ определяет содержимое контейнера, какой процесс запустить, когда контейнер начинает работать, а также другие всевозможные подробности конфигурации. Образ Docker не изменяем. Когда Docker запускает контейнер из образа, он добавляет дополнительный слой поверх этого образа, который доступен для записи (при помощи UnionFS, как мы видели ранее).
Что происходит, когда вы запускаете контейнер?
Когда вы используете docker run консольную команду или эквивалентный API-вызов, клиент Docker
Engine отдает задачу Docker демону на запуск контейнера. В этом примере клиент сообщает Docker демону инструкцию по запуску контейнера из ubuntu образа Docker, (-i) используется,
чтобы оставаться войти в контейнер в интерактивном режиме и запустить команду /bin/bash.
$ docker run -i -t ubuntu /bin/bash
Конда вы запускаете эту команду, Docker Engine выполняет следующие действия:
1. Скачивает (pull) образ ubuntu: Docker Engine проверяет наличие образа ubuntu в кеше на хосте, на котором работает Docker Engine. Если образ уже существует локально, Docker Engine использует его для запуска нового контейнера. В противном случае Docker Engine скачивает этот образ с
Docker Store
2. Создает новый контейнер: Docker использует указанный образ для создания контейнера.

3. Выделяет место на файловой системе хоста и монтирует слой доступный для
записи: Контейнер создан на файловой системе и доступный для записи слой добавлен к его образу.
4. Выделяет сетевой / bridge интерфейс: Создает сетевой интерфейс, который позволяет Docker контейнеру взаимодействовать с локальным хостом, на котором установлен Docker Engine.
5. Назначает IP адрес: Находит и присоединяет доступный IP-адрес из пула.
6. Выполняет процесс, который вы определили: Выполняет команду /bin/bash.
7. Захватывате и предоставляет вывод приложения: Подключается и логирует стандартный поток ввода, вывода и ошибок, чтобы показать вам, как исполняется ваше приложение, т.к. вы работаете в интерактивном режиме.
С текущего момента контейнер запущен. Вы можете управлять и взаимодействовать с ним, использовать сервисы и приложения, которые он предоставляет, а также при необходимости остановить и удалить его.
Базовые технологии
Docker написан на
Go и использует несколько возможностей Linux ядра для реализации собственной функциональности.
Пространства имен (Namespaces)
Docker использует технологию, называемую пространством имен (namespaces) для предоствления изолированного рабочего пространства, называемого контейнер. Когда вы запускаете контейнер, Docker создает набор пространств имен для этого контейнера.
Эти пространства имен организуют слой изоляции. Каждый аспект контейнера запускается в отдельном пространстве имен и его доступ ограничен этим пространством имен.
Docker Engine использует следующие пространства имен в Linux:
•
Пространство имен pid: Изоляция процесса (PID: ID процесса).
•
Пространство имен net: Управление сетевыми интерфейсами (NET: Сеть).
•
Пространство имен ipc: Управление доступом к IPC ресурсам (IPC: Межпроцессное взаимодействие).
•
Пространство имен mnt: Управление точками монтирования файловой системы (MNT:
Монтирование).
•
Пространство имен uts: Изолирование идентификаторов ядра и версий. (UTS: Unix система разделения времени).
Группы управления (Control groups)
Docker Engine в Linux также основывается на другой технологии, называемой группами
управления (cgroups). каждая cgroup лимитирует приложение в доступе к определенному набору ресурсов. Группы управления позволяют Docker Engine разделять доступные аппаратные ресурсы между контейнерами и при необходимости применять лимиты и ограничения. Например, вы можете ограничить определенному контейнеру доступную оперативную память.
Union FS
Файловая система Union или UnionFS — это файловая система, которая работает путем создания слоев,
делая их оучень легковесными и быстрыми. Docker Engine использует UnionFS как «строительные

блоки» для контейнеров. Docker Engine может использовать множество различных реализаций UnionFS,
т.к. AUFS, btrfs, vfs, а также DeviceMapper.
Формат контейнеров
Docker Engine объединяет пространства имен, группы управления и UnionFS в обертку (wrapper),
называемую контейнерным форматом. Основной формат контейнеров — это libcontainer. В
будущем Docker возможно будет поддерживать другие форматы контейнеров, интегрируясь с такими технологиями как BSD Jails или Solaris Zones.
Docker: управление вашими данными
-
Андрей Максимов
0 комментариев
В этой статье будет рассмотрен вопрос управления данными внутри контейнеров Docker, совместное использование данных разными контейнерами, а также резервное копирование этих данных.
Согласно последней документации, в Docker существует два способа организации работы с данными:
•
Docker тома (Docker volumes)
•
Контейнеры Docker томов (Docker volume containers)
Но прежде чем рассказать о них чуть подробнее, необходимо еще раз обратить ваше внимание на то, как работает файловая система в контейнерах Docker. Образы Docker, из которых запускаются контейнеры, представляют собой последовательность неизменяемых (только чтение) слоев. Набор этих слоев, можно посмотреть при помощи команды docker history, например, для контейнера nginx версии latest это делается так:
$ docker pull nginx
$ docker history nginx
IMAGE CREATED CREATED BY SIZE COMMENT
a39777a1a4a6 20 hours ago /bin/sh -c #(nop) CMD ["nginx" "-g" "daemon 0 B
20 hours ago /bin/sh -c #(nop) EXPOSE 443/tcp 80/tcp 0 B
20 hours ago /bin/sh -c ln -sf /dev/stdout /var/log/nginx/ 22 B
20 hours ago /bin/sh -c apt-key adv --keyserver hkp://pgp. 58.58
MB
20 hours ago /bin/sh -c #(nop) ENV NGINX_VERSION=1.11.8-1 0 B
20 hours ago /bin/sh -c #(nop) MAINTAINER NGINX Docker Ma 0 B
42 hours ago /bin/sh -c #(nop) CMD ["/bin/bash"] 0 B
42 hours ago /bin/sh -c #(nop) ADD file:89ecb642d662ee7edb 123
MB
Полный вывод истории образа можно получить, добавив к последней команде ключ --no-trunc. А еще детализацию любого образа можно посмотреть воспользовавшись проектом https://imagelayers.io
При запуске из образа нового контейнера к этому набору неизменяемых слоев присоединяется слой, который можно изменять. С этого момента, если в контейнере попытаться изменить какой-нибудь существующий файл, то этот файл будет скопирован из одного из нижележащих неизменяемых слоев, в котором он был создан, в изменяемый слой, куда и запишутся все его изменения. Версия изменяемого слоя скрывает нижележащий файл, но не удаляет его. Когда вы удаляете запущенный контейнер и

перезапускаете его из того же образа, все ваши изменения будут потеряны. Так работает
UnionFS
, которую использует Docker, для организации своей работы с данными.
Для того, чтобы иметь возможность сохранять ваши данные, а также использовать эти данные несколькими контейнерами, Docker предоставляем вам возможность использовать так называемые тома
(Docker volumes). Если совсем просто, то тома — это обычные директории (или файлы) хостовой файловой системы сервера, на котором работает Docker, монтируемые в любую директорию контейнера.
Существует несколько способов инициализировать тома, у которых есть несколько важных отличий, которые необходимо понимать. Самый прямой способ — это определить использование тома контейнером при его запуске при помощи флага -v:
$ docker run -it --name nginx_example -h nginx-container -v /opt/static nginx /bin/bash root@nginx-container:/# ls /opt/static/
Данная команда запустит контейнер с именем nginx_example именем хоста контейнера (-h) nginx-
container из образа nginx в интерактивном режиме работы (-it), передаст управление интерпретатору
/bin/bash, предварительно создав безымянный том (-v) и смонтировав его в /opt/static. При этом в директория /opt/static будет создана автоматически, она будет жить вне UnionFS и будет доступна для записи внутри контейнера, т.е. все файлы, которые вы сохраните в этой директории будут помещены внутрь тома. Вы можете определить расположение тома на файловой системе хостового сервера, на котором работает Docker, при помощи команды docker inspect:
$ docker inspect -f "{{json .Mounts}}" nginx_example | jq .
[
{
"Name":
"e01cb937734c02790c94c14339bc563159a88c025e266d298d48398352ea477d",
"Source":
"/var/lib/docker/volumes/e01cb937734c02790c94c14339bc563159a88c025e266d298
d48398352ea477d/_data",
"Destination": "/opt/static",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
}
]
В этом примере используется фильтр (-f) всего вывода docker inspect nginx_example, показывающий только часть содержимого, которое относится к блоку Mounts. При этом вывод форматируется утилитой jq
После того, как мы знаем имя тома (ключ Name), мы можем получить ту же информацию при помощи команды docker volume inspect:
$ docker volume inspect e01cb937734c02790c94c14339bc563159a88c025e266d298d48398352ea477d
[

{
"Name":
"e01cb937734c02790c94c14339bc563159a88c025e266d298d48398352ea477d",
"Driver": "local",
"Mountpoint":
"/var/lib/docker/volumes/e01cb937734c02790c94c14339bc563159a88c025e266d298
d48398352ea477d/_data",
"Labels": null,
"Scope": "local"
}
]
В обоих случаях вывод показывает вам, что Docker смонтировал /opt/static внутрь контейнера как директорию
/var/lib/docker/volumes/e01cb937734c02790c94c14339bc563159a88c025e266d298d
48398352ea477d/_data. Чтобы убедиться в этом, создайте, например, файл test на хостовом сервере, на котором запущен Docker, внутри этой директории.
$ sudo touch
/var/lib/docker/volumes/e01cb937734c02790c94c14339bc563159a88c025e266d298d
48398352ea477d/_data/test
А затем посмотрите на содержимое /opt/static внутри контейнера.
root@nginx-container:/# ls /opt/static test
Если вы отключились от интерактивного режима работы с контейнером, выполните команду docker start для запуска контейнера с интерактивным (-ai) к нему подключением:
$ docker start -ai nginx_example
Вы увидели этот результат только потому что /opt/static — это всего лишь директория на хостовом сервере, которая была смонтирована внутрь контейнера.
Тот же самый эффект будет достигнут при использовании инструкции VOLUME в Dockerfile:
FROM nginx
VOLUME /opt/static
Еще один способ создавать тома — это использовать команду docker volume create:
$ docker volume create --name nginx_static_data nginx_static_data
Который в последствие может быть подключен к вашему контейнеру. Обратите внимание, том может быть подключен только к новому контейнеру, поэтому старый контейнер предварительно придется удалить:
$ docker rm nginx_example nginx_example
$ docker run -it --name nginx_example -h nginx-container -v nginx_static_data:/opt/static nginx /bin/bash root@nginx-container:/# ls /opt/static

Есть еще один часто используемый способ создания тома, реализуемый только при помощи параметра
-v, монтирующий указанную директорию хостового сервера внутрь контейнера. Для этого создайте на хостовом сервере директорию folder_test, внутри этой директории файл test_file, а затем пересоздайте контейнер, указав полный путь до директории folder_test:
$ mkdir folder_test
$ touch folder_test/test_file
$ docker rm nginx_example nginx_example
$ docker run -it --name nginx_example -h nginx-container -v
/home/docker/folder_test:/opt/static nginx /bin/bash root@nginx-container:/# ls /opt/static/
test_file
Как видите, содержимое директории folder_test стало доступно внутри запущенного контейнера.
Этот способ работы с томами очень удобно использовать, например, в процессе разработке приложений.
В целях сохранения свойства переносимости контейнеров, директория, использующаяся для тома на хостовом сервере, не может быть указана в Dockerfile (ведь эта директория совершенно не обязательно должна быть доступна во всех контейнерах). В случае использования этой формы работы с томами (монтирование тома при помощи флага -v в процессе создания контейнера) файлы, возможно содержащиеся внутри директории образа, не копируются внутрь тома (в данном случае в директорию на хостовом сервере). Docker не управляет такого рода томами как показано в прошлых примерах, и поэтому такие тома не появятся в выводе команды docker volume ls и никогда не будут удалены демоном Docker.
Совместное использование данных контейнерами
Для того чтобы дать доступ одному контейнеру к томам другого, вы должны указать аргумент
--volumes-from для команды docker run. Например:
$ docker run -it --name nginx_example1 -h nginx-container1 --volumes- from=nginx_example nginx /bin/bash root@nginx-container1:/# ls /opt/static/
test_file
Это сработает вне зависимости от того, запущен контейнер nginx_example или нет. Причем, том не будет удален до тех пор, пока хотя бы один контейнер к нему подключен. Вы можете также монтировать том указывая в качестве значения аргумента -v имя тома, например:
$ docker rm nginx_example1
nginx_example1
$ docker run -it --name nginx_example1 -h nginx-container1 -v e01cb937734c02790c94c14339bc563159a88c025e266d298d48398352ea477d:/opt/stat ic nginx /bin/bash root@nginx-container1:/# ls /opt/static/
test_file

Контейнеры Docker томов (Docker volume containers)
До момента появления в Docker команд docker volume широко использовались «контейнеры томов» для хранения и организации совместной работы с данными. Этот подход означает, что контейнер по своей сути становился «пространством имен» (namespace) для данных. Тем не менее в современных версиях Docker этот подход никогда не нужно использовать. Вместо этого просто создайте том с нужным вам именем при помощи команды docker volume create --name.
Права доступа
Часто вам может требоваться выставить привилегии и владельца содержимого Docker тома или поместить внутрь тома данные по-умолчанию или конфигурационные файлы. Ключевой важный момент в процессе создания образа вашего контейнера это то, что после инструкции VOLUME в
Dockerfile Docker не сможет выполнить никаких изменений внутри тома, например:
FROM nginx:latest
RUN useradd foo
VOLUME /opt/static
RUN touch /opt/static/some_file
RUN chown -R foo:foo /opt/static
Не будет работать, как ожидается. Нам необходимо выполнить команду touch на файловой системе будущего образа, но она будет исполнена в томе временного слоя, использующегося при сборке.
Работать будет немного по-другому:
FROM nginx:latest
RUN useradd foo
RUN mkdir /opt/static && touch /opt/static/static_file
RUN chown -R foo:foo /opt/static
VOLUME /opt/static
Docker достаточно интеллектуален, чтобы скопировать любые файлы, существующие в образе в нижележащих слоях в точку монтирования тома и выставить правильные привилегии. Этого не произойдет, если вы смонтируете директорию на хостовом сервере в качестве тома.
Удаление тома
Если вы всегда использовали команду docker rm для удаления ваших контейнеров, велики шансы, что у вас есть большое количество не удаленных томов, занимающих место.
Тома автоматически удаляются только в том случае, если родительский контейнер был удален при помощи команды docker rm -v (использование флага -v очень важно) или же если флаг -rm был использован во время выполнения команды docker run. И даже после этого том будет удален только тогда, когда ни один другой контейнер не ссылается на него. Тома в виде директорий, смонтированные внутрь контейнера из хостового сервера, никогда не удаляются.
Чтобы посмотреть на все тома, существующие на хостовом сервере, выполните команду docker volume ls:
$ docker volume ls
DRIVER VOLUME NAME

local e01cb937734c02790c94c14339bc563159a88c025e266d298d48398352ea477d local nginx_static_data
Для удаления всех не использующихся томов, выполните команду:
$ docker volume rm $(docker volume ls -q)
Резервное копирование, восстановление и миграция томов
Еще одна функция, которую можно выполнять с томами — это их резервное копирование, восстановление и использование этих операций для осуществления миграции данных. Резервное копирование выполняется при помощи использования —volumes-from аргумента в процессе создания нового контейнера, который будет архивировать данные уже существующего:
$ docker run --rm --volumes-from nginx_example -v $(pwd):/backup ubuntu tar cvf /backup/backup.tar /opt/static
Эта команда запустит новый контейнер из образа ubuntu и запустит внутри него команду архивирования директории /opt/static (команда для исполнения внутри контейнера tar cvf
/backup/backup.tar /opt/static), предварительно смонтировав текущую директорию $(pwd)
в директорию /backup контейнера.
Восстановить данные тома в тот же самый контейнер или в другой контейнер в любом другом месте
(backup.tar легко передается при помощи scp) можно, например, командой:
$ docker volume create --name new_volume_for_static_data
$ docker run -v new_volume_for_static_data:/opt/static --name nginx_restored nginx /bin/bash
$ docker run --rm --volumes-from nginx_restored -v $(pwd):/backup ubuntu bash -c "cd /opt/static && tar xvf /backup/backup.tar --strip 1"
Эти команды могут быть использованы вами для автоматизации резервного копирования, восстановления или миграции данных томов ваших контейнеров.
Резервное копирование, восстановление и миграция контейнеров
Если же в процессе работы контейнера изменялись данные не тома, а непосредственно контейнера, то эти изменения тоже можно сохранить, например в образ при помощи команды docker commit:
$ docker commit nginx_example nginx_example_backup:19.01.2017
sha256:0dcad379614806b0485f2cad48fcd5208e413363e7a04819ca7edf81b92cf280
$ docker images
REPOSITORY TAG IMAGE ID
CREATED SIZE
nginx_example_backup 19.01.2017 0dcad3796148 4 seconds ago 181.5 MB
Далее вы можете сохранить этот образ в публичный или частный Docker реестр при помощи команды docker push, или же вы можете сохранить образ в tar-файл для передачи на другой удаленный сервер:
$ docker save -o nginx_example_backup_19.01.2017.tar nginx_example_backup:19.01.2017
Чтобы впоследствие создать из него образ, но уже на другом удаленном сервере, где установлен Docker:

$ docker load -i nginx_example_backup_19.01.2017.tar
По материалам:
•
Manage data in containers
•
Understanding Docker Volumes
•
Docker backup – Easy steps to backup and restore your containers
….
Docker Machine
-
Андрей Максимов
0 комментариев
Вне зависимости от того, в какой операционной системе вы работаете, начинать работу с Docker необходимо с того, чтобы понимать, с каким Docker Engine (см.
Docker: Введение
) вы сейчас работаете и в каком состоянии он находится. Для решения этой задачи и создана Docker Machine.
Docker Machine используется для:
•
Установки и запуска Docker на Mac или Windows
•
Установка, настройка и управление множества удаленных Docker хостов
•
Установка, настройка и управление Swarm кластерами
Docker Machine — это утилита, которая нужна вам для того, чтобы устанавливать Docker Engine на удаленные физические или виртуальные сервера, а также управлять ими при помощи команды docker-machine. Вы можете использовать Docker Machine для создания Docker хостов на вашем Mac или Windows ПК, в корпоративной сети вашей компании, в вашем датацентре или в различных Облаках, т.к. например, AWS или
Digital Ocean
Используя команды docker-machine, вы можете запустить, проверить,
остановить, перезапустить управляемый ей хост, обновить клиент и демон Docker, а также настроить клиент Docker на работу с удаленным хостом.
Почему я должен использовать Docker Machine?
Docker Machine позволяет вам легко устанавливать, настраивать и управлять множеством Docker хостов,
каждый из которых может работать на различном Linux дистрибутиве.
Более того, Docker Machine позволяет вам запускать Docker на старых Mac или Windows системах.
У Docker Machine есть два основных сценария использования.

•
У меня есть устаревший ПК, и я хочу иметь возможность запустить Docker на Mac
или Windows
Если вы работаете на устаревшем Mac или Windows ноутбуке или рабочей станции, которые не удовлетворяют последним требованиям
Docker для
Mac или
Docker для
Windows
, значит, вам необходима Docker Machine, чтобы все таки “запустить Docker” (имеется в виду, Docker Engine) у себя локально. Во время такой установки Docker Machine на ваш Mac или Windows при помощи
Docker Toolbox
, на самом деле у вас на ПК устанавливается локальная виртуальная машина, внутри которой и будет работать Docker Engine. Docker Machine в данном случае даст вам возможность настроить подключение клиента Docker (команда docker) к Docker Engine в этой виртуальной машине.
•
Я хочу установить Docker на удаленные виртуальные машины или физические серверы
Docker Engine — это нативное приложение для Linux систем. Если у вас Linux в качестве основной системы и вам нужно иметь возможность запускать команду docker, все что вам нужно сделать — это скачать и установить Docker Engine. Тем не менее, если вам нужен эффективный способ работать с множеством Docker хостов в сети, в Облаке или же локально, вам нужна Docker Machine.
Вне зависимости от того, используете ли вы Mac, Windows или Linux, вы можете установить Docker
Machine и использовать команду docker-machine для подготовки и управления большим количеством Docker хостов. Она автоматически устанавливает на хост Docker, т.е. устанавливает Docker
Engine, затем помогает настроить и клиент docker.
Какова разница между Docker Engine и Docker Machine?
Когда говорят “Docker”, обычно имеют в виду Docker Engine, т.е. клиент-серверное программное обеспечение, состоящее из демона Docker, REST API, который определяет интерфейсы взаимодействия с демоном и клиентский консольный командный интерфейс, т.е. клиента docker, который общается с демоном при помощи обертки над REST API. Docker Engine принимает команды docker, такие

как docker run для запуска контейнера из образа, docker ps для отображения запущенных контейнеров, docker images для отображения доступных образов и т.д.
Docker Machine — это утилита для подготовки и управления вашими докеризированными хостами
(имеются в виду хосты с установленным на них Docker Engine). Обычно Docker Machine устанавливается на вашу локальную систему. У Docker Machine есть свой консольный клиент docker- machine так же, как клиент для Docker Engine — docker. Вы можете использовать Docker Machine для установки Docker Engine на один или более виртуальных серверов. Эти виртуальные серверы могут быть локальными или удаленными. Докеризированные хосты при этом называются управляемыми машинами (“machines”).
Замечание: для того, чтобы Docker Machine могла подготовить Docker хост, этот Docker хост должен иметь подключение к интернет.
Использование Docker Machine
После установки Docker Machine посмотреть на список управляемых ей Docker хостов можно командой:

$ docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
default - virtualbox Stopped Unknown
Я использую Mac и в качестве Docker хоста у меня используется виртуальная машина, управляемая
VirtualBox. Как видно из примера, эта виртуальная машина называется default и в настоящий момент она остановлена. Чтобы запустить эту виртуальную машину и иметь возможность использовать ее в качестве Docker хоста, нужно выполнить команду:
$ docker-machine start default
Starting "default"...
(default) Check network to re-create if needed...
(default) Waiting for an IP...
Machine "default" was started.
Waiting for SSH to be available...
Detecting the provisioner...
Started machines may have new IP addresses. You may need to re-run the
`docker-machine env` command.
Docker хост успешно запущен. Проверим этот факт:
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
default * virtualbox Running tcp://192.168.99.100:2376 v1.12.4
Звездочка (*) показывает, что данный Docker хост в настоящий момент активен, т.е. при запуске утилиты docker, все ее команды будут выполняться на этом хосте. Если звездочка в выводе отсутствует, то необходимо настроить переменные окружения для корректной работы клиента Docker.
Посмотреть переменные окружения для работы с Docker хостом default можно командой:
$ docker-machine env default export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://192.168.99.100:2376"
export DOCKER_CERT_PATH="/Users/amaksimov/.docker/machine/machines/default"
export DOCKER_MACHINE_NAME="default"
# Run this command to configure your shell:
# eval $(docker-machine env default)
Эта команда сама подсказывает, как применить эти переменные в вашем окружении, чтобы настроить клиента:
$ eval $(docker-machine env default)
После выполнения данной команды, клиент docker будет настроен на работу с Docker хостом default.
Помимо подготовки и настройки Docker хоста Docker Machine может осуществлять к нему ssh подключение:
$ docker-machine ssh default
Boot2Docker version 1.12.4, build HEAD : d0b8fd8 - Tue Dec 13 18:21:26 UTC
2016
Docker version 1.12.4, build 1564f02

docker@default:$
При помощи плагинов Docker Machine при помощи команды docker-machine create может сразу запускать виртуальные серверы в Облаке, например, AWS или
DigitalOcean
. Если же у вас есть просто
Linux сервер, которым необходимо управлять удаленно, то предлагаю вам ознакомиться со статьей
Использование Docker в Облаке КРОК,
где этот вопрос освящается подробнее.
….
Docker Compose: Введение
-
Андрей Максимов
0 комментариев
Docker Compose — это утилита для определения и запуска многоконтейнерных Docker приложений.
При работе с Docker Compose вы используете docker-compose.yml файл для настройки сервисов вашего приложения. Далее, используя всего лишь одну команду, вы создаете и запускаете сервисы из вашей конфигурации.
Docker Compose отлично подходит для разработки, тестирования, создания промежуточных окружений, а также процессов непрерывной интеграции (CI).
Использование Docker Compose обычно представляет собой трех этапный процесс.
1. Определить окружение вашего приложения при помощи Dockerfile так, чтобы оно могло быть воспроизведено где угодно.
2. Определить сервисы, которые составляют ваше приложение в docker-compose.yml так, чтобы они могли быть запущены вместе в изолированном окружении.
3. Наконец, запустить docker-compose up и Docker Compose запустит определенное вами приложение.
Файл docker-compose.yml выглядит следующим образом:
version: '2'
services:
web:
build: .
ports:
- "5000:5000"
volumes:
- .:/code
- logvolume01:/var/log links:
- redis redis:
image: redis volumes:
logvolume01: {}
У Docker Compose есть несколько команд, предназначенных для управления всем жизненным циклом вашего приложения:
•
Запуск, остановка и пересборка сервисов
•
Просмотр и получение статуса запущенных сервисов
•
Отображение логов запущенных служб
•
Выполнение одной команды за раз на сервис

Упаковка простого Flask приложения в Docker
контейнер
-
Андрей Максимов
0 комментариев
Из этой статьи вы узнаете, как создать и упаковать простое Flask приложение в Docker контейнер.
Требования
•
Docker
•
python 2.7 или выше
К окончанию статьи у вас должна получиться следующая структура директорий и файлов
Создание простого Flask приложения
Создайте пустой каталог, в котором будут содержаться файлы проекта, а внутри него virtualenv окружение
$ mkdir my_project
$ cd my_project
$ virtualenv venv
Активируйте окружение и установите в него Flask
$ source venv/bin/activate
$ pip install flask
Создайте отдельную директорию, в которой будет находиться Flask приложение
$ mkdir my_flask_app
Сохраните список установленных в окружении пакетов в requirements.txt в каталоге my_flask_app
$ pip freeze > my_flask_app/requirements.txt
Содержимое my_flask_app/requirements.txt будет следующим
$ cat my_flask_app/requirements.txt click==6.7 Flask==0.12
itsdangerous==0.24
Jinja2==2.9.4
MarkupSafe==0.23
Werkzeug==0.11.15
wheel==0.24.0

Создайте файл app.py в каталоге my_flask_app, который будет содержать наше простое python Flask Web- приложение
#!/usr/bin/env python
# -*- coding: utf-8 -*- from flask import Flask app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Moe Flask приложение в контейнере Docker.'
if __name__ == '__main__':
app.run(debug=True,host='0.0.0.0')
Проверьте работоспособность вашего приложения, запустив его командой
$ python my_flask_app/app.py
* Running on (Press CTRL+C to quit)
* Restarting with stat
* Debugger is active!
* Debugger pin code: 160-707-431
После чего в браузере на странице http://127.0.0.1:5000/ можно будет увидеть строку «Moe Flask приложение в контейнере Docker.»
Упаковка Flask приложения в контейнер
Dockerfile
Для сборки Docker образа используется специальный
Dockerfile,
который необходимо создать в директории my_flask_app. Содержимое Dockerfile файла в нашем случае будет:
$ cat my_flask_app/Dockerfile
FROM ubuntu:latest
MAINTAINER Andrey Maksimov 'maksimov.andrei@gmail.com'
RUN apt-get update -y
RUN apt-get install -y python-pip python-dev build-essential
COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt
ENTRYPOINT ['python']
CMD ['app.py']

Описание инструкций Dockerfile
Инструкция
Описание
FROM ubuntu:latest
В качестве базового образа будет использоваться latest версия образа Ubuntu.
MAINTAINER Andrey Maksimov
«maksimov.andrei@gmail.com»
Справочная информация. Не обязательный параметр. Укажите контакты создателя образа.
RUN apt-get update -y
Обновить информацию о репозиториях внутри контейнера
RUN apt-get install -y python-pip python-dev build-essential
Установить внутрь контейнера пакеты: python-pip, python-dev, build-essential
COPY . /app
Скопировать содержимое текущей директории «.» в директорию
/app внутри образа. Внимание: текущей директорией в процессе сборки будет считаться директория, содержащая Dockerfile, т.е. в нашем случае my_flask_app/
WORKDIR /app
Сменить рабочую директорию внутри контейнера. Все команды далее будут запускаться внутри директории /app внутри контейнера
RUN pip install -r requirements.txt
Установить зависимости, сохраненные вами в requirements.txt.
Данная команда установить Flask и все, что необходимо для его запуска внутри контейнера.
ENTRYPOINT [«python»]
Запускать интерпретатор python по умолчанию
CMD [«app.py»]
В сочетании с использованием ENTRYPOINT интерпретатору python будет передан дополнительный аргумент app.py. Другими словами, во время запуска контейнера последней инструкцией будет выполнена команда python app.py из директории /app
Создание образа контейнера
Для создания собственного контейнера, содержащего ваше простое Flask приложение, находясь внутри директории my_project необходимо выполнить команду:
$ docker build -t my_flask_app:v0.1 my_flask_app/
Ключ -t предназначен для того, чтобы присвоить вашему образу метку (label) «my_flask_app» и его версию «v0.1». Метка и версия могут быть произвольными. Если в качестве версии использовать
«latest», то собранный вами образ будет помечен как имеющий самую свежую версию.
В процессе выполнения команды как описано в вашем Dockerfile будет произведена загрузка последнего образа ubuntu, внутри него установлены все необходимые зависимости, создана директория /app, в которую будет помещено содержимое директории my_flask_app/, установлены все зависимости из файла requirements.txt, а сам образ настроен на запуск вашего Flask приложения из директории /app, находящейся внутри образа.
После успешного выполнения команды в списке ваших образов появится только что созданный образ my_flask_app:v0.1
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
my_flask_app v0.1 afe8322ae297 8 minutes ago 440.9 MB
Запуск контейнера из собранного образа
Для запуска Docker контейнера из подготовленного вами образа необходимо выполнить команду
$ docker run -d -p 5000:5000 my_flask_app:v0.1

Ключ -d предназначен для запуска вашего контейнера в фоновом режиме (необходим для того, чтобы вернуть управление терминалу, в котором вы работаете).
Ключ -p заставит Docker Machine пробрасывать подключения, приходящие на порт 5000 внешнего адреса Docker Machine на порт 5000 контейнера, на котором будет слушать подключения ваше Flask приложение. Использование -p [порт на Docker Machine:порт контейнера].
Проверить, что контейнер успешно запущен можно командой
$ docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
5a166878f263 my_flask_app:v0.1 'python app.py' About a minute ago Up About a minute 0.0.0.0:5000->5000/tcp stoic_allen
После чего в браузере по адресу http://192.168.99.100:5000/ будет выведена строка «Moe Flask приложение в контейнере Docker.» так же, как это было сделано при тестовом запуске Flask приложения локально.
Адрес 192.168.99.100 обычно используется Docker Machine для публикации портов ваших контейнеров.
Этот адрес обычно сообщается в выводе настроек вашей виртуальной машины в переменной
DOCKER_HOST.
Посмотреть список всех созданных вами Docker машин, выполните команду
$ docker-machine ls
NAME ACTIVE DRIVER STATE URL SWARM DOCKER ERRORS
default * virtualbox Running tcp://192.168.99.100:2376 v1.12.4
Посмотреть настройки Docker машины с именем default выполните команду
$ docker-machine env default export DOCKER_TLS_VERIFY='1'
export DOCKER_HOST='tcp://192.168.99.100:2376'
export DOCKER_CERT_PATH='/Users/amaksimov/.docker/machine/machines/default'
export DOCKER_MACHINE_NAME='default'
# Run this command to configure your shell:
# eval $(docker-machine env default)
Остановка и удаление запущенного контейнера
Для того, чтобы выполнить какие-либо операции с тем или иным контейнером сначала необходимо узнать идентификатор.
$ docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
5a166878f263 my_flask_app:v0.1 'python app.py' 3 hours ago Up 3 hours
0.0.0.0:5000->5000/tcp stoic_allen

В моем случае — это 5a166878f263.
Остановка запущенного контейнера выполняется командой
$ docker stop 5a166878f263
А для того, чтобы удалить запущенный контейнер, необходимо выполнить команду
$ docker rm 5a166878f263
Заключение
Упаковывать любые приложения в контейнеры крайне просто, а их запуск после занимает считанные мгновения. В следующей статье вы узнаете как использовать Docker Compose.
Итоговый Docker образ, созданный в статье можно найти на
Docker Hub
, а сходный код приложения на
GitHub
Работа с контейнерами в Docker Compose
-
Андрей Максимов
0 комментариев
В статье «
Упаковка простого Flask приложения в Docker контейнер
» вы создали простое Flask приложение и заставили его запускаться внутри контейнера. В этой статье мы продолжим начатый вами проект, добавив к нему поддержку
Docker Compose
, предназначенного для автоматизации процесса запуска большого количества связанных контейнеров в сложных приложениях.
Файл docker-compose.yml
В директории нашего проекта my_project создайте файл docker-compose.yml, в который необходимо добавить следующее содержимое
$ cat docker-compose.yml web:
build: ./my_flask_app ports:
- "5000:5000"
volumes:
- ./my_flask_app:/app
Описание содержания docker-compose.yml
Строка
Описание web:
Название компонента приложения, управляемого Docker Compose. Каждый компонент запускается в отдельном контейнере или их группе build: ./my_flask_app
Обозначение того, что данный компонент будет запускаться из образа, который необходимо собрать. Инструкции по сборке будут искаться в

Строка
Описание
Dockerfile в директории ./my_flask_app относительно docker-compose.yml файла ports:
- "5000:5000"
Обозначение того, что необходимо выполнить публикацию порта 5000 данного компонента в порт 5000, доступный по внешнему IP-адресу хоста
(или виртуальной машины), на котором будет запущено приложение.
volumes:
- ./my_flask_app:/app
Обозначение того, что внутрь контейнера, отвечающего за данный компонент приложения, необходимо подключить Docker диск (
Docker
Volume
). В данном случае в роли Docker диска будет выступать директория ./my_flask_app, которая будет cмонтирована в директорию /app внутрь контейнера. Эта операция выполнена для того, чтобы можно было легко менять Flask приложение и наблюдать изменения обновляя окно браузера, а не выполняя пересборку всего контейнера целиком. Попробуйте изменить вывод функции hello_world в файле
./my_flask_app/app.py, чтобы в этом убедиться
Если вы еще не остановили запущенный в прошлой статье контейнер, сделайте это, чтобы не возникло конфликта с использованием порта 5000 в процессе запуска нового контейнера, который будет управляться Docker Compose.
Работа с контейнерами в Docker Compose
Запуск контейнера
Сборка и запуск нового контейнера выполняется командой
$ docker-compose up -d
Ключ -d необходим, чтобы запустить ваше приложение, состоящее из одного контейнера, и вернуть управление терминалу, в котором вы вызывали docker-compose.
После успешной сборки и запуска контейнера, вы сможете снова увидеть вывод «Moe Flask приложение в контейнере Docker.» в браузере по адресу http://192.168.99.100:5000/.
Для того, чтобы пересобрать ваше приложение после сделанных вами изменений выполните команду
$ docker-compose build
А перезапуск контейнера вместе с предварительной пересборкой, выполняется командой
$ docker-compose up -d --build
Просмотр запущенных docker-compose контейнеров, а также информации по опубликованным ими портам осуществляется командой
$ docker-compose ps
Name Command State Ports
---------------------------------------------------------------- myproject_web_1 python app.py Up 0.0.0.0:5000->5000/tcp

Остановка и удаление приложения
Остановка приложения выполняется командой
$ docker-compose stop
Stopping myproject_web_1 ... done
Одновременная остановка и удаление выполняются командой
$ docker-compose down
Stopping myproject_web_1 ... done
Removing myproject_web_1 ... done
Заключение
Использование Docker Compose существенно облегчает сборку, запуск и остановку вашего приложения. Наибольший эффект от его использования достигается при управлении приложением, состоящим из нескольких связанных контейнеров, о чем я расскажу в следующей статье.
Docker Compose: запуск Flask приложения с
MongoDB
-
Андрей Максимов
6 комментариев
В прошлой статье «
Работа с контейнерами в Docker Compose
» вы узнали как использовать Docker
Compose для автоматизации сборки и запуска простого Flask приложения
В этой статье вы узнаете как добавить к существующему приложению MongoDB, превратив его в прототип записной книжки дел.
Требования
•
Docker (1.11.0 или выше)
•
Docker Compose (1.8.0 или выше)
•
Python 2.7 или выше
Структура файлов проекта
Обновление Flask приложения
Обновим содержимое Flask приложения для того, чтобы оно могло использовать MongoDB в качестве
СУБД, отредактировав файл my_flask_app/app.py.

#!/usr/bin/env python
# -*- coding: utf-8 -*- import os from flask import Flask, redirect, url_for, request, render_template from pymongo import MongoClient app = Flask(__name__)
client = MongoClient('mongodb', 27017)
db = client.tododb
@app.route('/')
def todo():
_items = db.tododb.find()
items = [item for item in _items]
return render_template('todo.html', items=items)
@app.route('/new', methods=['POST'])
def new():
item_doc = {
'task': request.form['task'],
'description': request.form['description']
}
db.tododb.insert_one(item_doc)
return redirect(url_for('todo'))
if __name__ == "__main__":
app.run(host='0.0.0.0', debug=True)
Важно отметить, что в строке подключения в качестве имени хоста используется «mongodb«. Это имя хоста получает контейнер, запускаемый Docker Compose по имени запускаемого сервиса (mongodb). Контейнер web знает о контейнере mongodb, т.к. в его описании присутствует параметр links, указывающий на этот сервис (см. Обновление docker-compose.yml).
Также в директории my_flask_app создадим директорию templates, в которой необходимо создать шаблон страницы todo.html, использующийся в вашем приложении.

  1   2   3

Новая запись

Список дел