Docker — самая распространенная система контейнеризации, позволяющая запускать необходимое для разработки ПО в контейнерах не устанавливая его на локальную систему. В рамках данного материала разберем docker управление контейнерами.
Над всей структурой выстроена особым образом сеть, что позволяет пробрасывать желаемым образом порты и делать контейнер доступным снаружи (по умолчанию он работает на локальном IP адресе) через виртуальный бридж. Контейнер при этом может быть доступен как миру, так и одному адресу.
Установим Docker на Ubuntu или Debian сервер если он еще не установлен по инструкции . Лучше выполнять команды от имени непривилегированного пользователя через sudo
Запуск самого простого контейнера покажет, что все работает
Базовые комагды для управления контейнерами
Вывести все активные контейнеры можно так
С ключем -a будут выведены все контейнеры, в том числе неактивные
Dicker назначает имена контейнерам случайным образом, при необходимости можно указать имя непосредственно
docker run —name hello-world
Запускаем контейнер с именем my-linux-container на основе образа ubuntu и переходим в консоль контейнера указывая оболчку bash
docker run -it —name my-linux-container ubuntu bash
Чтобы выйти из контейнера и вновь оказаться на хост системе нужно выполнить
Все образы, на основе которых создаются контейнеры скачиваются с hub.docker.com автоматически при первом создании контейнера, те, что уже существуют локально можно увидеть выполнив docker images
Создание контейнера из уже скачанного образа будет происходить значительно быстрее (практически мгновенно)
При выходе из контейнера с exit он останавливается, чтобы этого не происходило выходить можно сочетанием клавиш CTRL + A + P
Можно убрать все контейнеры, не являющиеся активными
docker rm $(docker ps -a -f status=exited -q)
Или удалять их по одному
Вместо идентификатора в последней команде можно указать имя
В docker управление контейнерами производится за счет небольшого количества интуативно понятных команд:
docker container start ID
docker container stop ID
docker container restart ID
docker container inspect ID
Последняя особенно полезна, она выводит всю информацию о контейнере, конфигурационных файлах и используемых разделах диска. Весь список команд можно легко найти в помощи или на официальном сайте Docker-а
Образы обычно создаются из уже существующих за счет использования дополнительных опций, указанных в Dockerfile
FROM ubuntu
CMD echo «hello world»
Сейчас создается новый образ на основе стандартного с ubuntu
Собираем образ дав ему имя (точка в конце команды означает, что используется текущий каталог, а значит и Dockerfile в нем)
docker build -t my-ubuntu .
docker images теперь покажет и созданный только что образ my-ubuntu
Его можно запустить, в консоль при этом будет выведено hello world и это единственное отличие от дефолтного образа
Обычно нужны более сложные правила, например в образ нам нужно включить python3 — перйдем в новый каталог и создадим Dockerfile
FROM ubuntu
CMD apt-get update && apt-get install python3
Все инструкции записываются в одну строку
docker build -t my-ubuntu-with-python3 .
Запускаем контейнер переходя внутрь
docker run -it my-ubuntu-with-python3 bash
Внутри от имени root нужно выполнить dpkg -l | grep python3 , команда покажет, что пакет присутствие в системе, что означает успех
Docker это популярный инструмент, который благодаря использованию контейнеров предоставляет все необходимое для запуска приложений. Используя Docker-контейнеры, вы можете быть уверенными в том, что приложение будет работать одинаково на любых машинах, на которых вы его запустите.
Из этого руководства вы узнаете о связи контейнеров и образов Docker, а также о том, как устанавливать, запускать, останавливать и удалять контейнеры.
Образ Docker можно представить в качестве некоторого шаблона, который используется для создания контейнеров. Образы обычно начинаются с корневой файловой системы, к которой затем сверху слоями добавляются различные изменения и соответствующие им параметры запуска. В отличие от типичных дистрибутивов Linux, образ Docker обычно содержит только части, которые необходимы для запуска приложения. У образов нет статусов, и они не изменяются. Правильнее сказать, что они являются исходной точкой, основой для контейнеров Docker.
Образы «оживают» в тот момент, когда вы вводите команду docker run - она сразу же создает контейнер в результате добавления поверх образа новый уровень для чтения и записи. Эта комбинация уровней только для чтения (поверх которых добавляется уровень для чтения и записи) также известна как UnionFS - файловая система, производящая каскадно-объединённое монтирование файловых систем. Когда в существующий файл запущенного контейнера вносится какое-либо изменение, файл копируется из области только для чтения на уровень для записи и чтения, где и применяются эти изменения. И теперь изначальный файл скрыт версией с уровнем для записи и чтения, но он не удален. Подобные изменения в уровне для записи и чтения существуют только внутри данного отдельного контейнера. Когда контейнер удаляется, все изменения также теряются (если они не были сохранены).
Каждый раз, когда вы используете команду docker run, из того образа, который вы указываете, создается новый контейнер. Ниже будут рассмотрены более конкретные примеры.
Шаг 1: создание двух контейнеров
Написанная ниже команда docker run создает новый контейнер, который в качестве основания будет использовать образ Ubuntu. Ключ -t предоставит терминал, а -i - возможность взаимодействовать с ним. Для того, чтобы оказаться внутри контейнера, можно использовать стандартную команду bash. То есть вы можете ввести:
$ docker run -ti ubuntu
$ docker run -i -t ubuntu:14.04 /bin/bash
(во втором случае вы запустите команду /bin/bash внутри контейнера и автоматически окажетесь внутри контейнера)
В командной строке появится подтверждение того, что вы находитесь внутри контейнера в качестве суперпользователя. После знака @ вы увидите ID контейнера, в котором находитесь:
Root@11cc47339ee1:/#
Теперь, используя команду echo, внесите изменения в директорию /tmp, а затем проверьте, что изменения были записаны при помощи команды cat:
Echo "Example1" > /tmp/Example1.txt cat /tmp/Example1.txt
На экране вы должны увидеть:
Теперь выйдите из контейнера:
Как только данная команда была выполнена, и вы вышли из командной строки, контейнер Docker перестал работать. Увидеть это вы можете, если используете команду docker ps:
Среди запущенных контейнеров вы не увидите тот, который использовался выше:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
Однако вы можете добавить ключ -a для того, чтобы увидеть все контейнеры - как работающие, так и остановленные - и тогда вам высветится контейнер, в котором вы работали ранее:
$ docker ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 11cc47339ee1 ubuntu "/bin/bash" 9 minutes ago Exited (127) 10 seconds ago small_sinoussi
Когда создается контейнер, у него появляется ID и автоматически сгенерированное название. В данном случае 11cc47339ee1 - это идентификационный номер (ID) контейнера, а small_sinoussi - сгенерированное имя. Команда ps -a показывает эти данные, а также образ, из которого контейнер был создан (в данном случае ubuntu), когда контейнер был создан (9 минут назад), и какая команда была в нем запущена ("/bin/bash”). Также вы можете посмотреть статус контейнера (из него вышли 10 секунд назад). В том случае, если бы контейнер до сих пор работал, вы бы увидели статус "Up" и время, которое он уже работает.
Теперь вы можете еще раз ввести команду для создания контейнера:
$ docker run -ti ubuntu
Несмотря на то, что команда выглядит так же, как и в прошлый раз, она создаст абсолютно новый контейнер - он будет иметь другой идентификационный номер, а если вы попробуете посмотреть содержимое файла Example1, который редактировали ранее, то вы его не найдете.
Root@6e4341887b69:/# cat /tmp/Example1
Вывод будет:
Cat: /tmp/Example1: No such file or directory
Вам может показаться, что данные исчезли, но дело, конечно же, не в этом. Выйдите из второго контейнера, чтобы убедиться, что оба контейнера (в том числе первый с нужным файлом) существуют в системе.
Root@6e4341887b69:/# exit $ docker ps -a
Вывод будет:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 6e4341887b69 ubuntu "/bin/bash" About a minute ago Exited (1) 6 seconds ago kickass_borg 11cc47339ee1 ubuntu "/bin/bash" 15 minutes ago Exited (127) 6 minutes ago small_sinoussi
Шаг 2: перезапуск первого контейнера
Для того, чтобы заново запустить уже созданный контейнер, необходимо команду start использовать с двумя ключами -ai. В конце вам необходимо написать идентификационный номер контейнера, с которым вы хотите работать, либо его название. В итоге ваша команда будет выглядеть следующим образом:
Docker start -ai 11cc47339ee1
Теперь вы снова находитесь в оболочке bash внутри контейнера и можете убедиться в том, что файл, который вы создавали в начале статьи, все еще находится здесь:
Cat /tmp/Example1.txt
Вы увидите на экране:
Теперь вы можете выйти из контейнера:
Таким образом, все изменения внутри контейнера сохраняются, даже если вы останавливаете и потом заново запускаете контейнер. Данные удаляются лишь в том случае, когда удаляется сам контейнер. Также пример выше показывает, что изменения касаются одного отдельного контейнера (а не всех контейнеров сразу).
Шаг 3: удаление обоих контейнеров
Завершающим шагом будет удаление двух контейнеров, которые вы создали, следуя данному руководству. Для этого необходимо использовать команду docker rm. Однако она действует только на остановленные контейнеры. После команды необходимо указать идентификационный номер либо название одного или нескольких контейнеров. К примеру, чтобы удалять контейнеры, созданные ранее, необходимо ввести команду:
Docker rm 6e4341887b69 small_sinoussi
На экране высветится:
6e4341887b69 small_sinoussi
Теперь оба контейнера были удалены.
Из данного руководства вы узнали об основных командах для работы в Docker и научились создавать, останавливать, вновь запускать и удалять контейнеры.
Уже несколько месяцев использую docker для структуризации процесса разработки/доставки веб-проектов. Предлагаю читателям «Хабрахабра» перевод вводной статьи о docker - «Understanding docker» .
Платформа и средства контейнерной виртуализации могут быть полезны в следующих случаях:
Например, ваши разработчики пишут код локально и делятся своим стеком разработки (набором docker образов) с коллегами. Когда они готовы, отравляют код и контейнеры на тестовую площадку и запускают любые необходимые тесты. С тестовой площадки они могут оправить код и образы на продакшен.
Портируемость и легковесная природа docker позволяет легко динамически управлять вашей нагрузкой. Вы можете использовать docker, чтобы развернуть или погасить ваше приложение или сервисы. Скорость docker позволяет делать это почти в режиме реального времени.
Docker использует архитектуру клиент-сервер. Docker клиент общается с демоном Docker, который берет на себя тяжесть создания, запуска, распределения ваших контейнеров. Оба, клиент и сервер могут работать на одной системе, вы можете подключить клиент к удаленному демону docker. Клиент и сервер общаются через сокет или через RESTful API.
Одна из причин, по которой docker легковесен - это использование таких уровней. Когда вы изменяете образ, например, обновляете приложение, создается новый уровень. Так, без замены всего образа или его пересборки, как вам возможно придётся сделать с виртуальной машиной, только уровень добавляется или обновляется. И вам не нужно раздавать весь новый образ, раздается только обновление, что позволяет распространять образы проще и быстрее.
В основе каждого образа находится базовый образ. Например, ubuntu, базовый образ Ubuntu, или fedora, базовый образ дистрибутива Fedora. Так же вы можете использовать образы как базу для создания новых образов. Например, если у вас есть образ apache, вы можете использовать его как базовый образ для ваших веб-приложений.
Примечание! Docker обычно берет образы из реестра Docker Hub.
Docker образы могут создаться из этих базовых образов, шаги описания для создания этих образов мы называем инструкциями. Каждая инструкция создает новый образ или уровень. Инструкциями будут следующие действия:
Эти инструкции хранятся в файле Dockerfile . Docker считывает это Dockerfile , когда вы собираете образ, выполняет эти инструкции, и возвращает конечный образ.
С помощью docker клиента вы можете искать уже опубликованные образы и скачивать их на вашу машину с docker для создания контейнеров.
Docker Hub предоставляет публичные и приватные хранилища образов. Поиск и скачивание образов из публичных хранилищ доступно для всех. Содержимое приватных хранилищ не попадает в результат поиска. И только вы и ваши пользователи могут получать эти образы и создавать из них контейнеры.
$ sudo docker run -i -t ubuntu /bin/bash
Давайте разберемся с этой командой. Клиент запускается с помощью команды docker , с опцией run , которая говорит, что будет запущен новый контейнер. Минимальными требованиями для запуска контейнера являются следующие атрибуты:
Что же происходит под капотом, когда мы запускаем эту команду?
Docker, по порядку, делает следующее:
Это создает изолированный уровень, каждый аспект контейнера запущен в своем простанстве имен, и не имеет доступ к внешней системе.
Список некоторых пространств имен, которые использует docker:
Справка по командам управления образами и контейнерами Docker.
Образ - это статический билд на основе определенной OS.
Контейнер - это запущенный инстанс образа.
Чтобы запускать Docker контейнеры под своим пользователем (без sudo), нужно добавиться в соответствующую группу:
Sudo usermod -aG docker YOU_USER
Управление сервисом Docker"а:
Sudo service docker start|stop|restart|status sudo restart docker # алиас
Список доступных образов:
Docker images
Скачать образ (или весь репозиторий) из официального регистра (хранилища образов):
Docker pull ubuntu:14.04
Посмотреть информацию об образе:
Docker inspect ubuntu
Удалить образ:
Docker commit CONTAINER_ID IMAGE_NAME
После запуска Docker контейнера сервисы/демоны (как-то SSH, Supervisor и прочие) не будут запускаться автоматически! Я потратил несколько часов на отладку ошибки: "ssh_exchange_identification: read: Connection reset by peer ", при попытке подключиться к контейнеру по SSH. А оказалось, что всего-то не запускался демон sshd. Вы должны будете вручную запускать нужные демоны или супервизор после старта контейнера:
Docker exec CONTAINER_ID bash -c "service ssh start"
Список всех контейнеров (запущенных и остановленных):
Docker ps -a
Удалить контейнер(ы):
Docker rm CONTAINER_ID CONTAINER_ID
Удалить все контейнеры:
Docker rm $(docker ps -aq)
Создать и запустить Docker контейнер c Ubuntu 14.04 в интерактивном режиме (открыть shell этого контейнера):
Docker run -it ubuntu bash docker run [опции] образ [команда] -i Интерактивный режим, держим STDIN открытым -t Allocate/creates a pseudo-TTY that attaches stdin and stdout --name Имя контейнера вместо ID -w Указать рабочую директорию (--workdir) -e Установить переменную окружения в контейнере -u Пользователь:группа под которым должен быть запущен контейнер -v Смонтировать в контейнер файл или каталог хост-системы -p Пробросить порт(ы) контейнера - <порт хост-системы>:<порт контейнера> (--publish=) --entrypoint Заменить дефолтную команду из ENTRYPOINT файла Dockerfile
Чтобы отсоединить TTY без остановки контейнера нажмите Ctr + P + Ctrl + Q .
Создать и запустить Docker контейнер в режиме демона с пробросом SSH порта:
Docker run -itd -p 127.0.0.1:221:22 ubuntu
Создать и запустить контейнер с последующим удалением этого контейнера после остановки (полезно для отладки):
Docker run -i -t --rm ubuntu bash
Запустить остановленный контейнер интерактивно:
Docker start -i CONTAINER_ID
Подключиться к демонизированному контейнеру:
Docker attach CONTAINER_ID
В том, что Docker - это действительно must have инструмент для разработчика и администратора сколько-нибудь крупного проекта. Но даже если это не так, Docker все равно нужно знать: уже в самом ближайшем будущем он будет везде, начиная от десктопного Linux-дистрибутива и заканчивая пулом серверов на AWS. А самое приятное, что разобраться с Docker довольно легко, если, конечно, правильно понимать принцип его работы.
Docker базируется на технологиях namespaces и cgroups (первая обеспечивает изоляцию, вторая - группировку процессов и ограничение ресурсов), поэтому в плане виртуализации он мало чем отличается от привычных нам LXC/OpenVZ, и рассказывать тут особо не о чем. Та же нативная скорость работы, те же методы изоляции, основанные на механизмах ядра Linux. Однако уровнем выше начинается совсем другая история. Изюминка Docker в том, что он позволяет развернуть полноценное виртуальное окружение и запустить в нем приложение так же просто, как, например, перезапустить веб-сервер.
Абстрагируемся от деталей конкретных дистрибутивов и представим, что у нас есть чистый CentOS и мы хотим запустить в нем определенную команду в полностью виртуальном окружении без доступа к основной системе. Придется скачивать образы дистрибутивов, разворачивать их в систему и настраивать виртуальное окружение? Вовсе нет, все, что нужно сделать, - это запустить две команды:
$ sudo yum install docker-io $ sudo docker run -t ubuntu:latest /usr/bin/top
И это все. Мы только что запустили утилиту top внутри контейнера с окружением на базе последней доступной на данный момент версии Ubuntu с выводом информации в текущий терминал. И все это с помощью одной простой команды (установка не в счет). Неплохо, не правда ли? В общем-то, мы можем даже «зайти» в этот контейнер и делать все то, что обычно делают со свежеустановленной системой:
$ sudo docker run -t -i ubuntu:latest /bin/bash
# apt-get update
# apt-get install nginx
#
Как видишь, с сетью тоже все ОK, поэтому мы можем обновить систему, установить и настроить любой софт. Немного похоже на магию, но на самом деле все очень просто. Docker - это своего рода apt-get в мире контейнеров, только вместо пакетов здесь образы файловой системы, а вместо официальных Debian/Ubuntu-репозиториев - облачное хранилище, называемое Docker Hub.
Когда мы выполнили «docker run...», система сделала следующее:
Изюминка такой модели в том, что Docker Hub открыт для всех и любой может подготовить собственный образ (об этом позже) и опубликовать его с целью установки на другую машину и/или другим человеком. На момент написания статьи в Docker Hub было опубликовано более 45 тысяч образов на все случаи жизни, начиная от образов «голых» дистрибутивов и заканчивая образами с преднастроенными серверными и десктопными приложениями, работающими в минималистичном Linux-окружении.
Что, если мы хотим запустить Firefox внутри виртуального окружения? Нет ничего проще, открываем Docker Hub в браузере, нажимаем Browse & Search и вбиваем firefox. На экран вывалится список результатов. Смотрим, kennethkl/firefox вроде вполне подходит. Клацаем по нему и видим инфу, как все это дело запустить. Автор говорит нам выполнить такую команду:
$ sudo docker run -d --name firefox -e DISPLAY=$DISPLAY \ -v /tmp/.X11-unix:/tmp/.X11-unix kennethkl/firefox
Пробуем. Да, действительно, после недолгого скачивания образа получаем на экране стандартный Firefox. На этом же примере, кстати, можно ознакомиться с еще четырьмя полезными опциями команды docker run:
В данном случае переменная и файл нужны для того, чтобы Firefox смог получить доступ к дисплею локальной машины. Это довольно небезопасно, так как любой процесс в контейнере не только сможет запускать любой софт на твоем десктопе, но и, например, перехватывать нажатия клавиш или передвижения курсора. Но для примера сойдет.
Есть и более простой способ поиска образов Docker, с помощью команды docker search:
$ sudo docker search nginx
Любой пользователь Docker может запустить свой личный приватный Hub. Он носит название «реестр» и доступен в виде уже готового образа. Все, что нужно сделать, - это просто запустить его: docker run -p 5555:5555 registry.
Демон Docker доступен не только с помощью клиента, но и с использованием RESTful API, причем как локально, так и с удаленной машины. Стандартные порты Docker - tcp/2375 e tcp/2376.
Образ Docker не обязательно запускать сразу после скачивания, можно сначала скачать его на локальную машину с помощью команды docker pull, а лишь затем запустить: docker pull ubuntu.
Docker позволяет сделать работу с виртуальными окружениями максимально удобной, упрощая как процесс разворачивания окружений, так и настройки их взаимодействия с хост-системой (чего стоит только последний пример). Но это не единственная его изюминка.
Если ты уже успел поиграть с образом Ubuntu из первых двух примеров, то наверняка заметил, что каждый новый запуск контейнера происходит «с нуля», а все изменения, сделанные в прошлом сеансе, теряются. Это вовсе не баг, это одна из ключевых особенностей архитектуры Docker, которая делает его еще более интересным и привлекательным решением.
Дело в том, что в подавляющем большинстве случаев «образ Docker» - это вовсе не монолитный образ файловой системы, а своего рода слоеный пирог, состоящий из нескольких образов файловых систем, на основе которых формируется контейнер. При этом отдельно взятые образы ФС вовсе не отвечают за те или иные части структуры каталога (как, например, в случае с разбиением диска под Linux на разделы /home, /var, /boot), а наслаиваются друг на друга с помощью механизма AUFS ядра Linux (также есть поддержка той же функциональности через использование btrfs, device mapper и overlay).
Чтобы разобраться с тем, как это работает, вернемся к нашей контейнерной Ubuntu. Запускаем контейнер и устанавливаем nginx, как показано во втором примере в начале статьи, но не завершаем его. Вместо этого запускаем еще один терминал и смотрим список запущенных контейнеров:
$ sudo docker ps
Эта команда покажет все запущенные контейнеры вместе с их ID, используемым образом, запущенной командой, временем работы и прочим. Нас интересует значение в столбце CONTEINER ID. Копируем его и запускаем следующую команду:
$ sudo docker commit ID-контейнера ubuntu-nginx
После того как она отработает, можно выйти из контейнера, таким образом завершив его работу. А далее просто запускаем контейнер ubuntu-nginx и видим, что nginx никуда не пропал и находится на своем месте:
$ sudo docker run -i -t ubuntu-nginx /bin/bash
# which nginx
/usr/sbin/nginx
Что же мы сделали? Мы создали еще один слой, то есть дополнительный образ ФС, и сгенерировали новый Docker-образ на основе уже существующего Docker-образа Ubuntu с включением нашего образа ФС, который содержит nginx. Звучит немного путано, правда? На самом деле все довольно просто.
Мы уже выяснили, что каждый Docker-образ состоит из нескольких образов ФС. Когда мы запускаем контейнер, эти образы монтируются и собираются в одну структуру каталога с помощью AUFS. Например, первый образ может содержать только базовую установку Ubuntu, второй добавляет к ней набор стандартных демонов, третий - утилиты администрирования и так далее. Docker монтирует все слои в режиме «только чтение», но, чтобы мы имели возможность изменять содержимое образа, сверху подключается еще один изначально пустой слой в режиме «чтение/запись».
По умолчанию после завершения контейнера (которое происходит после завершения последнего работающего в нем процесса) последний слой стирается и все наши изменения пропадают. Однако, используя команду docker commit, мы можем «зафиксировать» изменения, создав новый Docker-образ на основе уже существующих образов ФС плюс образа ФС с нашими изменениями. Так внесенные нами изменения сохранятся. По желанию мы можем запустить контейнер ubuntu-nginx, внести в него изменения и точно так же сохранить в новый Docker-образ с помощью commit, добавив еще один слой. Чтобы посмотреть список всех получившихся в итоге (и полученных из Docker Hub) образов, можно использовать команду docker images, а для просмотра истории формирования слоев - команду docker history:
$ sudo docker history ubuntu-nginx
Такой подход к формированию образов дает большую гибкость в управлении контейнерами, экономит уйму времени и позволяет с легкостью переносить уже сконфигурированные Docker-образы между машинами (образ можно выложить на Docker Hub и затем развернуть на другой машине). Менее очевидный плюс - экономия дискового пространства. Если мы развернем на машине целый зоопарк контейнеров, каждый из которых будет изначально основан на одном базовом образе (той же Ubuntu, например) - они все будут ссылаться на этот базовый образ и не дублировать его содержимое.
Единственный способ запустить Docker в OS X или Windows - это установить его в виртуальную машину. Не обязательно делать это вручную, можно воспользоваться уже готовым решением, например boot2docker. Это набор скриптов, которые позволяют быстро развернуть виртуальную машину с Linux и Docker внутри VirtualBox и запустить ее с автоматическим открытием доступа по SSH. Инструкцию по его использованию и сам инсталлятор можно найти на официальном сайте Docker .
Для того чтобы контейнеры могли общаться между собой и с внешним миром, Docker автоматически поднимает виртуальный сетевой мост и настраивает правила маскарадинга (NAT) для внешнего сетевого интерфейса. Это значит, что извне достучаться до контейнеров не получится. Однако мы можем настроить проброс портов, чтобы запрос к определенным портам внешнего сетевого интерфейса машины автоматически перенаправлялся на указанные порты контейнера. Например, в компании Mirantis главный узел Fuel (это такой GUI для деплоя и настройки OpenStack) запускается в Docker и использует функцию проброса портов, чтобы открыть доступ к контейнеру ful/nginx (порт 8000):
$ sudo docker run -d -p 8000:8000 fuel/nginx_6.0:latest /usr/local/bin/start.sh
Мы могли бы пробросить порт 8000 на любой другой порт контейнера, просто изменив второе число в опции -p, но в данной конфигурации это не имеет смысла.
В начале статьи мы уже познакомились с флагом -v, позволяющим пробросить в контейнер любой файл или каталог из хост-системы. Это очень удобная функция, ее можно использовать как для хранения каких-либо временных данных, так и для расшаривания файлов между несколькими контейнерами. В Mirantis эта функция используется для проброса файлов конфигурации сервиса Fuel/astute (/etc/astute) внутрь контейнера:
$ sudo docker run -d -v /etc/astute fuel/astute_6.0:latest /usr/local/bin/start.sh
То же самое можно сделать с помощью команды VOLUME в Dockerfile. Сам по себе Dockerfile - это местный эквивалент Makefile, но если последний предназначен для сборки приложений из исходных текстов, то Dockerfile позволяет собирать образы для Docker. Его назначение - упростить создание новых образов без необходимости запускать контейнер, производить в нем какие-то операции и выполнять коммит. Ты можешь просто написать Dockerfile, и Docker сделает все за тебя. Для примера рассмотрим Dockerfile для сборки Fuel/astute:
FROM fuel/centos MAINTAINER Matthew Mosesohn [email protected] RUN rm -rf /etc/yum.repos.d/*;\ echo -e "\nname=Nailgun Local Repo\nbaseurl=http://$(route -n | awk "/^0.0.0.0/ { print $2 }"):_PORT_/os/x86_64/\ngpgcheck=0" > /etc/yum.repos.d/nailgun.repo;\ yum clean all;\ yum --quiet install -y ruby21-nailgun-mcagents sysstat ADD etc /etc ADD start.sh /usr/local/bin/start.sh RUN puppet apply --detailed-exitcodes -d -v /etc/puppet/modules/nailgun/examples/astute-only.pp; [[ $? == 0 || $? == 2 ]] RUN chmod +x /usr/local/bin/start.sh;\ echo -e "\nname=Nailgun Local Repo\nbaseurl=file:/var/www/nailgun/centos/x86_64\ngpgcheck=0" > /etc/yum.repos.d/nailgun.repo; yum clean all VOLUME /etc/astute CMD /usr/local/bin/start.sh
Нетрудно понять, для чего он предназначен. Он создает образ на базе fuel/centos, запускает несколько команд для подготовки образа, добавляет в образ файлы из текущего каталога, применяет манифест Puppet, меняет права доступа на некоторые файлы, пробрасывает в контейнер каталог /etc/asture/ из хост-системы и запускает контейнер с помощью команды /usr/local/bin/start.sh.
Для сборки контейнера достаточно положить Dockerfile и все файлы, которые будут добавлены в него, в какой-нибудь каталог и выполнить следующую команду:
$ sudo docker build fuel/astute_6.0:latest
В данном случае мы выбрали имя fuel/astute_6.0:latest, хотя оно может быть любым.
Docker построен вокруг идеи о том, что в каждом контейнере должен работать только один сервис. Ты расфасовываешь Apache, MySQL, nginx, Varnish и все, что может понадобится для проекта, по разным контейнерам, а затем используешь Docker для сборки всего этого вместе. Такой подход дает большую гибкость, так как позволяет с легкостью менять конфигурацию, тестировать обновления и выполнять миграцию отдельных сервисов на другие машины.
По этой же причине Docker не принято использовать для запуска полноценных Linux-окружений с демоном init, демонами cron и syslog и другими стандартными компонентами дистрибутива. Вместо этого мы просто запускаем нужный нам сервис, и он работает в виртуальном окружении в полном одиночестве:
$ sudo docker run -d -p 80 ubuntu-nginx /usr/sbin/nginx
Но здесь есть небольшая проблема. Docker завершает работу контейнера сразу после того, как будет завершен запущенный в нем процесс (в данном случае nginx), а так как nginx по умолчанию демонизируется, то есть форкает новый процесс и завершает тот, что мы запустили руками, то Docker сразу после этого завершает и контейнер, прибивая форкнутый Docker.
В случае с nginx обойти эту проблему можно, добавив daemon off; первой строкой в его конфиг. Для других демонов потребуются свои настройки, а некоторым можно запретить демонизироваться прямо из командной строки. Например, в sshd для этого предусмотрен флаг -D:
$ sudo docker run -d -p 22 ubuntu-ssh /usr/sbin/sshd -D
В любой момент к контейнеру можно подключиться с помощью команды docker exec с целью просмотреть логи или изменить настройки (здесь и далее ID-контейнера - это либо ID, которое можно увидеть в выводе docker ps, либо имя, заданное при запуске в опции --name):
$ sudo docker exec -ti ID-контейнера /bin/bash
Но и здесь есть одна небольшая загвоздка. Как мы знаем, вся накопленная во время работы виртуального окружения информация потеряется, если мы завершим работу виртуального окружения, а вместе с ней исчезнут логи и изменения, внесенные в настройки. Бесконечно создавать слои мы тоже не можем (хотя бы потому, что их может быть не больше 127), но мы можем пойти немного другим путем и воспользоваться встроенной в Docker системой агрегации логов. Конечно, Docker не умеет собирать логи отдельных приложений, но умеет накапливать вывод STDOUT, то есть любой консольный вывод. Все, что нам остается, - это изменить конфиг nginx так, чтобы логи сыпались в /dev/stdout, а затем просматривать их с помощью команды docker logs:
$ sudo docker logs ID-контейнера
Другой и более правильный вариант - это просто вынести логи (а если нужно, и настройки) на хост-систему с помощью уже описанной опции -v:
$ sudo mkdir /root/logs $ sudo docker run -d -v /root/logs:/var/logs -p 80 ubuntu-nginx /usr/sbin/nginx
При необходимости контейнер можно остановить корректно, завершив работающий в нем сервис с помощью команды docker stop:
$ sudo docker stop ID-контейнера
А если корректно остановить по какой-то причине не выходит, то можно и прибить его с помощью kill:
$ sudo docker kill ID-контейнера
При этом происходит одна важная вещь, о которой забывают многие новички: Docker сохраняет метаинформацию о контейнере. На деле это значит, что если ты запускаешь, например, nginx, указав с помощью аргументов команды docker run его имя, каталоги, которые нужно пробросить в контейнер, порты, переменные окружения и тому подобное, то вся эта информация будет сохранена при завершении контейнера и, чтобы запустить его в следующий раз, тебе уже не придется ее указывать, а достаточно просто выполнить такую команду (вместо ID можно использовать имя):
$ sudo docker start ID-контейнера
Если в сохранении состояния нет необходимости (например, для тестирования или проверки какой-то функциональности), то можно использовать флаг --rm, который заставит Docker полностью уничтожить контейнер после его завершения (с сохранением образа):
$ sudo docker run --rm -i -t busybox /bin/bash
Уничтожить все ранее сохраненные контейнеры можно с помощью такой команды:
# docker rm $(docker ps -a -q)
Docker умеет самостоятельно перезапускать контейнеры в случае их падения и даже запускать их во время старта системы. Все, что для этого нужно сделать, - просто использовать опцию --restart:
$ sudo docker run --restart=always \ -d -v /root/logs:/var/logs -p 80 \ ubuntu-nginx /usr/sbin/nginx
В любой момент образ можно экспортировать в единый файл и затем импортировать на другой машине. Для этого предусмотрены команды docker save и docker restore. Использовать их очень просто, экспорт выполняется так:
$ sudo docker save -o ubuntu-nginx.img ubuntu-nginx
А импорт так:
$ sudo docker load -i ubuntu-nginx.img
Docker - превосходный инструмент. Для непосвященного человека он может показаться игрушкой, которая не годится больше ни для чего, кроме запуска софта в песочнице, однако с его помощью можно решать огромный спектр задач, о чем мы и поговорим в следующей статье.