Простое развертывание веб-приложений с поддержкой Redis с помощью Docker

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

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

Docker пытается использовать этот уровень удобства и перенести его в мир серверов. Это естественное расширение таких инструментов, как Vagrant, которые позволяют развертывать ту же виртуальную машину, которую вы используете при разработке, в рабочих средах. Виртуальные машины в стиле Vagrant великолепны, но они тяжелые. Для их запуска требуется много ресурсов, большая часть которых избыточна: образ Vagrant загружает всю новую копию Linux внутри существующей. Разве не было бы лучше, если бы вы могли использовать удобство и единообразие Vagrant, но вам не пришлось бы перезагружать всю операционную систему? Ну, это именно то, что делает Докер.

Вступление

В этом уроке я расскажу вам весь рабочий процесс Docker. Сначала мы пройдемся по шагам, чтобы получить простое веб-приложение Python, которое имеет пару зависимостей Python и зависит от базы данных Redis для сохранения и запуска. Затем мы установим Docker и установим все требования веб-приложения (зависимости Redis, Python и Python) в один образ Docker. Затем мы будем использовать этот образ и развернуть его на другом сервере.

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

Для начала вам понадобится либо Linux-система с последней версией Ubuntu, либо виртуальная машина с последней версией Ubuntu. Если вы хотите полностью следовать учебному пособию и развернуть приложение, вам также потребуется вторая машина (или вторая виртуальная машина) для развертывания.

Установка Docker

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

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

После установки Vagrant создайте новую папку, откройте там командную строку и выполните следующие действия:

Vagrant только что позаботился о создании виртуальной машины под управлением Ubuntu 12.04 для вас, и теперь вы в SSH’d. Теперь мы можем следовать инструкциям Docker по установке Ubuntu. Проверьте сайт на наличие каких-либо изменений с момента его написания, но, скорее всего, вы можете напрямую вставить следующие команды в терминал:

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

… в SSH обратно в вашу виртуальную машину. Теперь, когда предварительные требования Docker успешно установлены, нам нужно продолжить и установить сам Docker. Вставьте следующую команду:

… который запустит простой скрипт установки Docker с сайта Docker и запустит его. Докер теперь должен быть успешно установлен, поэтому давайте начнем с него играть.

Начало работы с Docker

Как только apt-get закончит свою магию, сделайте следующее:

… проверить и убедиться, что установка прошла успешно. Если это сработает, Docker продолжит загрузку образа Ubuntu Docker и через некоторое время вы получите то, что похоже на приглашение root. Не стесняйтесь немного поиграть, вы заметите, что находитесь в среде, полностью отделенной от вашего хост-компьютера. Вы, вероятно, заметили в приглашении root и знак # . Вы работаете как пользователь root в новой виртуальной среде. Если вы введете команду users , вы увидите, что других ваших пользователей больше нет.

Стоит потратить минуту, чтобы объяснить, что сделала команда docker вы только что набрали, и как произошло это волшебство.

Команда run

Утилита Docker, кажется, черпала вдохновение из интерфейса командной строки git и, как следствие, использует подкоманды. В этом случае мы запустили подкоманду run . Команда run требует двух аргументов: изображение и команда.

Это также разумно, так что если (как в данном случае) у вас не установлен этот образ, он запросит центральный репозиторий Docker и скачает его для вас. Здесь мы сказали ему запустить образ ubuntu и сообщили Docker, что он должен запустить /bin/bash внутри этого образа. -t и -i говорят Docker назначить TTY и запускать в «интерактивном режиме», другими словами, чтобы получить командную строку. Причина этого в том, что Docker работает немного иначе, чем другие программы для виртуализации, с которыми вы, возможно, знакомы. Образы Docker не «загружаются», они просто запускаются. Они используют существующую установку Linux, поэтому запуск образа Docker может быть немедленным. В некотором смысле Docker ближе к команде chroot в Linux, чем к более традиционным инструментам виртуализации, таким как VMWare или VirtualBox.

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

Теперь, когда вы делаете:

Он с радостью распечатает:

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

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

… вы заметите, что вещи больше не ведут себя так, как вы ожидаете. Если вы попытаетесь отследить файл, который мы создали в прошлый раз, вы получите сообщение об ошибке:

Так что же происходит? Изменения в изображениях Docker не сохраняются по умолчанию. Чтобы сохранить изменения в образе Docker, вы должны их commit , стиль git . Это может занять некоторое привыкание, но это довольно мощно, потому что это означает, что вы также можете «разветвлять» их стиль git (подробнее об этом позже).

Сохранение новых изображений

А пока давайте сделаем что-нибудь более полезное. Давайте установим python , redis и несколько других утилит, которые мы будем использовать для запуска нашего демонстрационного приложения в ближайшее время. После этого мы commit сохранять наши изменения. Запустите копию Docker на последнем образе Ubuntu:

Базовый образ Ubuntu может не включать Python, поэтому проверьте, есть ли у вас копия, набрав в приглашении python . Если вы получите сообщение об ошибке, давайте установим его:

Все идет нормально. Возможно, что позже мы захотим создать другие проекты, использующие Python, поэтому давайте продолжим и сохраним эти изменения. Откройте другую командную строку (если вы используете установку Vagrant, рекомендованную выше, вам придется снова выполнить vagrant ssh из отдельной подсказки) и сделать следующее:

Вы получите список всех запущенных в данный момент Docker-контейнеров, как показано ниже:

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

Теперь, когда у нас установлен Python, давайте сохраним наши изменения. Для этого вы используете команду commit которая принимает два аргумента: контейнер, изменения которого вы хотите сохранить, и имя изображения. Соглашение Docker заключается в использовании идентификатора пользователя, за которым следует / и короткое имя изображения. Итак, в этом случае, давайте назовем это tuts/python . Выполните следующую команду, чтобы сохранить установку Python, убедившись в том, чтобы заменить идентификатор вашего контейнера с последнего шага

Через несколько секунд он вернется с серией букв и цифр. Это идентификатор изображения, которое вы только что сохранили. Вы можете запускать этот образ в любое время и ссылаться на него либо по этому идентификационному номеру, либо по легче запоминаемому имени tuts/python мы ему присвоили.

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

На этом этапе у вас должно быть открыто два окна терминала, на которых выполняются два отдельных сеанса Docker.

Теперь вы заметите, что если вы python в любом из них, вы больше не получите сообщение об ошибке. Попробуйте создать файл во втором окне:

Теперь вернитесь в исходное окно Docker и попробуйте посмотреть на файл:

Вы получите сообщение об ошибке. Это потому, что вы используете совершенно другую «виртуальную машину», основанную на образе, который вы создали с помощью команды docker commit . Ваши файловые системы полностью отделены.

Если вы откроете еще один терминал (опять же, вам придется запустить vagrant ssh при использовании Vagrant) и сделать следующее:

… вы увидите, что в docker теперь перечислены два запущенных образа, а не только одно. Вы можете отдельно зафиксировать каждое из этих изображений. Чтобы продолжить с метафорой git , вы теперь работаете с двумя ветвями, и они могут свободно «расходиться».

Давайте продолжим и закроем последнее окно, которое мы открыли. Если вы снова запустите docker ps , в списке будет только один идентификатор. Но что, если вы хотите вернуться к предыдущему контейнеру? Если вы введете:

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

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

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

… и запишите идентификатор и tuts/pyredis его под именем tuts/pyredis :

Итак, теперь у нас есть образ Docker, который содержит необходимые инструменты для запуска небольшого веб-приложения Python с Redis в качестве бэкэнда. Если у вас есть какие-либо будущие проекты, которые будут использовать тот же стек, все, что вам нужно сделать, чтобы их запустить, это: docker run -t -i tuts/pyredis /bin/bash и зафиксируйте после добавления исходного кода.

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

Получение вашего исходного приложения в изображение

Я создал небольшой пример приложения, в котором используются модули Redis и Python, которые мы установили до сих пор. Приложение довольно простое, все, что он делает, это отображает список клавиш Redis и предоставляет элементарный интерфейс для их добавления и редактирования. Давайте сначала доставим исходный код на ваш хост-компьютер (сессию vagrant ssh ):

В домашнем каталоге вашего хоста у вас теперь будет папка pyredis содержащая скрипт Python, который мы будем использовать. Итак, как нам скопировать это приложение в образ Docker?

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

Это так же, как наши команды run , с добавлением параметра -v .

По сути, эта команда позволяет вам совместно использовать папку между Docker и вашим хостом. Символы : указывают пути для обмена. В нашем случае мы разделяем нашу папку pyredis , расположенную на ~/pyredis на нашей машине, и монтируем ее в /tuts внутри образа Docker. rw в конце предназначена для «чтения-записи» и означает, что изменения, внесенные в образ Docker, также будут отображаться на нашей машине.

По приглашению Docker вы можете сделать:

… и посмотрите содержимое папки ~/pyredis на вашем компьютере.

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

Поскольку изменения в файловых системах Docker по умолчанию эфемерны, давайте сохраним это в образе, снова выполнив docker ps чтобы получить идентификатор нашего контейнера и зафиксировав наши изменения:

Здесь вы заметите, что мы взяли на себя то же имя, которое мы использовали в прошлый раз, tuts/pyredis . Docker обновит изображение и сохранит журнал всех ваших изменений за вас. Как и в git , если вы запутались, вы можете вернуться к хорошей версии, просто docker run ее идентификатор. Чтобы увидеть историю изображения, попробуйте следующее:

Вы увидите что-то вроде этого:

Это история всех tuts/pyredis , которые мы сделали в процессе создания tuts/pyredis , включая те, которые мы зафиксировали под разными именами, такими как tuts/python . Если вы хотите вернуться к фиксации непосредственно перед тем, как мы скопировали наше приложение pyredis в /pyredis вы можете попробовать (изменив идентификаторы в соответствии с тем, что показывает ваш):

… и вы обнаружите, что нет /pyredis .

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

Так что теперь у нас есть все части на месте. Следующий шаг — запустить приложение из контейнера. Поскольку мы развертываем веб-приложение, нам также потребуется указать способ доступа к приложению через Интернет. Команда run вас снова охватит. Команда запуска Docker поддерживает параметр -p который позволяет указать, как будут сопоставляться порты.

Если вы используете Vagrant для запуска Docker, вам нужно настроить перенаправление портов Vagrant, прежде чем мы сможем провести какие-либо значимые тесты. Если вы не используете Vagrant, просто пропустите этот шаг.

Настройка Vagrant Port Forwards

Если вы используете Vagrant для проверки этого, вам нужно настроить переадресацию портов, чтобы веб-браузер вашего локального компьютера мог получать доступ к портам на виртуальной машине Vagrant, которая, в свою очередь, будет перенаправлять на порт экземпляра Docker. Таким образом, в нашем случае мы tuts/pyredis порт нашей локальной машины 9000 для пересылки на нашу Vagrant VM 9000, которая, в свою очередь, перенаправит на порт 8080 нашего tuts/pyredis Docker.

На вашем локальном компьютере вернитесь в папку, где вы впервые набрали vagrant init . Там вы найдете текстовый файл, который называется просто Vagrantfile . Откройте его в вашем любимом текстовом редакторе и найдите следующую часть:

Раскомментируйте заключительную строку и измените порты с 80 и 8080 на 8080 и 9000 . Результат должен выглядеть так:

Теперь запустите:

… что приведет к перезагрузке виртуальной машины Vagrant с правильным перенаправлением портов. После этого вы можете снова запустить vagrant ssh и продолжить обучение.

Наше маленькое приложение pyredis по умолчанию открывает небольшой веб-сервер на порту 8080. Следующая команда позволит вам получить доступ к порту 8080 через порт 9000 на вашем хост-компьютере:

Вы получите приглашение root от Docker, так что давайте запустим наше приложение:

Если все пройдет хорошо, вы увидите следующее:

Это означает, что сервер работает. На локальном компьютере запустите веб-браузер и укажите его на localhost:9000 (если вы делаете это руководство на удаленном сервере, убедитесь, что у вас есть сетевой доступ к порту 9000, и замените localhost на адрес вашего веб-сервера. ).

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

Сохранение конфигурации запуска

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

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

Для нашего скрипта у нас есть только две команды для запуска при запуске:

Самый простой способ сделать это — создать небольшой скрипт запуска, который запускает эти две команды. Давайте снова запустим наш tuts/pyredis и добавим небольшой скрипт запуска (просто скопируйте и вставьте нижеприведенное в строку Docker):

Это сохранило команды, которые мы используем для запуска нашего Python-сервера, в небольшой скрипт bash, называемый launch.sh и устанавливает исполняемый бит, чтобы его было легче запускать.

Теперь, когда сценарий находится в образе успешно, с другого терминала, передайте его так, чтобы он сохранялся (не забудьте сделать docker ps чтобы сначала получить идентификатор вашего последнего контейнера):

Давайте проверим это. Если вы выйдете из окна Docker и снова запустите его с помощью следующей команды, вы сможете получить доступ к веб-приложению pyredis по адресу localhost:9000 , как и в прошлый раз.

Хорошо, теперь мы можем запустить наше маленькое приложение одной командой. Но это еще не все! Docker позволяет вам сохранять некоторую информацию о конфигурации по умолчанию с вашими коммитами. Таким образом, нам не нужно каждый раз вводить информацию о командах сопоставления портов и запуска, и вы можете просто передать образ Docker кому-то другому. Затем они могут запустить его с помощью простого docker run <image_name> и Docker позаботится обо всем остальном.

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

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

Сохраните этот фрагмент JSON в файл с именем runconfig.json и давайте обновим Docker, чтобы использовать его.

Теперь, если вы делаете:

Вы увидите, как bottle запускается, и вы можете получить доступ к приложению через браузер.

Развертывание общедоступных изображений на сервере через общедоступный реестр Docker

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

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

Развертывание частных изображений на сервере (простой способ)

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

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

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

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

Первым шагом является экспорт вашего контейнера в архив .tar . Вы можете сделать это с помощью команды export Docker. Чтобы развернуть пример приложения, которое мы использовали в этом руководстве, вы должны сделать что-то вроде этого:

Докер будет сидеть и обрабатывать некоторое время, но после этого у вас будет файл pyredis.tar , содержащий созданное вами изображение. Затем вы можете скопировать pyredis.tar на ваш сервер и запустить следующее:

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

Наше учебное приложение развернуто, и вы можете запустить его с помощью той же команды запуска, что и раньше:

Развертывание частных изображений на сервере (крутой способ)

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

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

Это означает, что ваш реестр Docker запущен и работает (в своем собственном контейнере Docker) и доступен для вашего локального компьютера через порт 5000. Немного ошеломляющий, но потрясающий. Давайте сначала установим наши учетные данные для входа, а затем добавим образ Docker, который мы создали ранее в руководстве, в наш новый реестр. В новом терминале запустите следующее

Идите вперед и введите имя пользователя, пароль и адрес электронной почты, которые вы хотели бы использовать в своем хранилище Docker.

Чтобы tuts/pyredis приложение tuts/pyredis в tuts/pyredis , нам сначала нужно «пометить» его адресной информацией частного репозитория, например:

Это говорит Docker создать новый «тег» tuts/pyredis и связать его с tuts/pyredis работающим на localhost:5000 . Вы можете думать об этом теге как об имени этого изображения в хранилище. Для согласованности я сохранил имена одинаковыми и пометил их как localhost:5000/tuts/pyredis , но это имя может легко отличаться (например, localhost:5000/pyredis_prod .)

Если вы запустите docker images сейчас, вы увидите, что в списке есть новое изображение с именем localhost:5000/tuts/pyredis . Механизм докера для определения репозиториев тесно связан с его механизмом именования (или маркировки, как это делает Docker), так что это все, что вам нужно.

Чтобы вставить изображение, которое мы создали, в наш репозиторий, просто docker push и введите полное имя тегового изображения (включая адрес):

Docker подключится к вашему репозиторию, работающему по адресу localhost:5000 и начнет вносить изменения. Вы увидите много сообщений о различных HTTP-запросах, появляющихся в другом окне терминала (в котором запущен samalba/docker-registry ), и информация о загрузке будет проходить в этом. Это займет некоторое время, так что вы можете взять кофе.

Одно предостережение: поскольку наш репозиторий Docker сам работает внутри контейнера Docker, нам нужно зафиксировать образ репозитория после того, как мы завершим отправку. В противном случае, поскольку изменения в файловой системе Docker эфемерны, по умолчанию изображение, которое мы samalba/docker-registry исчезнет, ​​как только мы samalba/docker-registry наш локальный контейнер Docker samalba/docker-registry .

Для этого выполните обычный docker ps чтобы получить идентификатор работающего samalba/docker-registry а затем зафиксируйте его в новом контейнере. Это не идеально, если вы делаете это в рабочей среде, вам нужно настроить тома Docker или использовать опцию -v выше, чтобы сохранить файл репозитория непосредственно на сервере, а не внутри контейнера, но это выходит за рамки данного руководства ,

Теперь самое интересное: размещение нашего нового образа Docker на новом сервере. Поскольку на момент написания этой статьи в Docker-репозиториях не было механизмов безопасности или аутентификации, мы будем работать над безопасными туннелями SSH. Из виртуальной машины, на которой вы установили tuts/pyredis , tuts/pyredis ssh на свой tuts/pyredis сервер и перенаправьте порт 5000 следующим образом:

Флаг -R для ssh означает, что когда вы подключаетесь к localhost:5000 на своем производственном сервере, SSH перенаправляет соединение обратно на порт 5000 на вашей виртуальной машине, который, в свою очередь, перенаправляется в samalba/docker-registry где наш репо живет.

Если Docker не установлен на этом сервере, установите его в соответствии с инструкциями по установке. После запуска Docker развернуть образ так же просто, как:

Поскольку мы создали туннель через SSH, Docker будет думать, что он получает данные с локального хоста удаленного сервера: 5000, но на самом деле он будет туннелирован на локальный хост вашей локальной виртуальной машины: 5000, который, в свою очередь, будет перенаправлен на Docker. Дайте ему время для загрузки, но как только это будет сделано, вы сможете запустить наше приложение pyredis точно так же, как мы запустили его на исходной ВМ, включая сохраненную конфигурацию запуска и порты:

Подведение итогов и следующие шаги

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

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

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

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