Подробное руководство по Docker

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

Что такое Docker?

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

Основные понятия в Docker

Образы Docker

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

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

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

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

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

Теперь давайте рассмотрим пример создания образа Docker с использованием Dockerfile. Обратите внимание, что это только пример, содержащий файл Dockerfile, и для него также нужны ресурсы, на которые он ссылается (например, requirements.txt). Позже я приведу полный рабочий пример.

Dockerfile:

# Используем Python как родительский образ
FROM python:3.10-slim

# Указываем рабочую директорию контейнера
WORKDIR /app

# Копируем содержимое текущей директории
# в указанную директорию /app
COPY . /app

# Устанавливаем необходимые зависимости,
# указанные в requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Открываем порт 80 для работы
# за пределами контейнера
EXPOSE 80

# Объявляем переменную среды
ENV NAME World

# Запускаем app.py при запуске контейнера
CMD ["python", "app.py"]

В данном файле:

1. FROM определяет базовый образ
2. WORKDIR устанавливает рабочий каталог
3. COPY копирует файлы с хоста в контейнер
4. RUN выполняет команды в контейнере
5. EXPOSE открывает порт
6. ENV задает переменные окружения
7. CMD указывает команду для выполнения

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

Контейнеры Docker

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

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

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

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

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

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

docker build -t my-python-app .
docker run -p 4000:80 my-python-app

docker build -t my-python-app . создает образ из dockerfile в текущем каталоге.

docker run -p 4000:80 my-python-app запускает контейнер, сопоставляя порт 4000 на хосте с портом 80 в контейнере.

Когда вы запускаете команду docker run, Docker создает новый контейнер из указанного образа и запускает его. Флаг -p сопоставляет порт хоста с контейнером, предоставляя внешний доступ к приложению, работающему внутри контейнера.

Вы можете управлять жизненным циклом контейнеров с помощью команд Docker:

1. docker start запускает остановленный контейнер
2. docker stop останавливает запущенный контейнер
3. docker restart перезапускает контейнер
4. docker rm удаляет остановленный контейнер
5. docker ps выводит список запущенных контейнеров
6. docker logs отображает журналы контейнера
7. docker exec выполняет команду в запущенном контейнере

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

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

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

Dockerfile

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

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

Популярные, часто используемые инструкции для Dockerfile:

1. FROM: указывает базовый образ, с которого следует начать сборку. Обычно это первая инструкция в файле Dockerfile
2. COPY: копирует файлы и каталоги из хост-системы в образ
3. ADD: аналогично COPY, но также может обрабатывать удаленные URL-адреса и извлекать сжатые файлы
4. RUN: выполняет команды в процессе создания образа, такие как установка зависимостей или запуск сценариев
5. CMD: указывает команду по умолчанию, которая будет выполняться при запуске контейнера из образа
6. ENTRYPOINT: настраивает контейнер для запуска в качестве исполняемого файла, позволяя использовать команды с параметрами
7. ENV: устанавливает переменные окружения внутри образа
8. EXPOSE: открывает порт, который контейнер будет прослушивать во время выполнения
9. WORKDIR: устанавливает рабочий каталог для работы следующих инструкций в Dockerfile
10. USER: задает пользователя и группу для выполнения следующих инструкций и контейнера
11. LABEL: Добавляет метаданные к образу в виде пар ключ-значение

Теперь давайте опишем новый пример Dockerfile и объясним его компоненты более подробно. Этот пример является полностью рабочим и содержит все три описанных файла.

Предположим, что структура следующая:

.
├── Dockerfile
├── app.py
├── requirements.txt

Dockerfile

# Стадия сборки
FROM python:3.10-slim AS build

# Указываем рабочий каталог
WORKDIR /app

# Копируем файл зависимостей
COPY requirements.txt .

# Копируем код приложения
COPY . .

# При необходимости запустите команды сборки
# RUN flask build

# Финальная стадия
FROM python:3.9-slim

# Устанавливаем рабочий каталог
WORKDIR /app

# Копируем созданные объекты на стадии сборки
COPY --from=build /app /app

# Устанавливаем зависимости для сборки
RUN pip install --no-cache-dir -r requirements.txt

# Открываем порт на котором Flask будет работать
EXPOSE 5000

# Указываем команду которая будет запускать Flask через Gunicorn
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

В этом дополненном Dockerfile:

1. Для демонстрации мы используем многоступенчатую сборку, которая обычно используется для оптимизации конечного размера образа. Многоступенчатые сборки позволяют нам использовать несколько инструкций FROM в одном файле Dockerfile, каждая из которых представляет отдельный этап.
2. Первый этап, называемый build (сборка), начинается с образа python:3.10-slim. Этот этап отвечает за сборку приложения и установку зависимостей сборки.
3. Мы устанавливаем рабочий каталог в /app, используя инструкцию WORKDIR.
4. Мы копируем файл requirements.txt в образ, используя инструкцию COPY. Этот файл обычно содержит зависимости Python, необходимые для приложения.
5. Мы копируем весь код приложения в образ, используя другую инструкцию COPY.
6. Если приложению требуются какие-либо шаги по сборке, такие как компиляция ресурсов или создание файлов, мы можем раскомментировать инструкцию RUN flask build и изменить ее в соответствии с конкретными требованиями к сборке приложения Flask.
7. Второй этап начинается с создания нового образа python:3.10-slim. Этот этап отвечает за запуск приложения в рабочей среде.
8. Мы устанавливаем рабочий каталог в /app, используя инструкцию WORKDIR.
9. Мы используем инструкцию COPY --from=build для копирования созданных объектов из каталога /app на этапе сборки в каталог /app на заключительном этапе. Это гарантирует, что в конечный образ будут включены только необходимые файлы.
10. Мы запускаем pip install для установки зависимостей сборки, указанных в файле requirements.txt, используя инструкцию RUN. Флаг --no-cache-dir гарантирует, что кэш пакета не сохраняется, что уменьшает размер образа.
11. Мы открываем порт 5000, используя инструкцию EXPOSE, который является портом по умолчанию для приложений Flask.
12. Наконец, мы указываем команду, которая будет выполняться при запуске контейнера с помощью команды CMD. Для запуска приложения Flask используется Gunicorn, привязывающий его к 0.0.0.0:5000. Синтаксис app:app предполагает, что приложение Flask определено в файле с именем app.py, а экземпляр приложения называется app.

app.py

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Привет мир!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

requirements.txt

flask
gunicorn

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

1. Поместите все три файла (requirements.txt, app.py и Dockerfile) в один и тот же каталог.
2. Откройте терминал и перейдите в каталог, содержащий файл app.py и Dockerfile.
3. Создайте образ Docker, выполнив следующую команду:

docker build -t flask-app .

4. Как только образ будет создан, запустите контейнер, используя следующую команду:

docker run -p 5000:5000 flask-app

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

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

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

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

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

Другие полезные термины Docker

1. Docker Hub: облачный сервис регистрации, который позволяет вам подключаться к хранилищам кода, создавать свои образы и тестировать их. Он предоставляет централизованный ресурс для поиска образов контейнеров, распространения и управления изменениями, совместной работы пользователей и команд, а также автоматизации рабочего процесса на всех этапах разработки.
2. Docker Compose: инструмент для определения и запуска многоконтейнерных приложений Docker. С помощью Compose вы используете файл YAML для настройки служб вашего приложения. Затем с помощью одной команды вы создаете и запускаете все службы из своей конфигурации.
3. Docker Swarm: собственный инструмент кластеризации и оркестрации для контейнеров Docker. Он позволяет управлять кластером узлов Docker как единой виртуальной системой. Swarm использует стандартный Docker API, что означает, что любой инструмент, который уже взаимодействует с демоном Docker, может использовать Swarm для масштабирования на несколько хостов.
4. Docker Volumes: являются предпочтительным механизмом хранения данных, генерируемых и используемых контейнерами Docker. Они предоставляют способ хранения данных за пределами доступного для записи уровня контейнера, что делает данные независимыми от жизненного цикла контейнера.
5. Docker Network: позволяет соединять контейнеры Docker вместе, на одном хосте или на нескольких хостах. Вы можете создавать сети-мосты, оверлейные сети и сети хостов, каждая из которых служит своей цели при взаимодействии с контейнерами Docker.

Полезные команды Docker

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

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

Создание образов

docker build -t <image_name> .

Создает образ Docker из файла Dockerfile в текущем каталоге и присваивает ему указанное имя.

Запуск контейнеров

docker run -p <host_port>:<container_port> <image_name>

Запускает контейнер Docker на основе указанного <image_name>, сопоставляя <container_port> с <host_port> на хост-компьютере.

Список контейнеров

docker ps

Выводит список всех запущенных контейнеров.

docker ps -a

Выводит список всех контейнеров, включая остановленные.

Остановленные контейнеры

docker stop <container_id>

Останавливает запущенный контейнер с указанным <container_id>.

Удаление контейнеров

docker rm <container_id>

Удаляет остановленный контейнер с указанным <container_id>.

Список образов

docker images

Выводит список всех образов Docker на вашем локальном компьютере.

Удаление образов

docker rmi <image_id>

Удаляет образ Docker с указанным <image_id>.

Доступ к логам контейнеров

docker logs <container_id>

Извлекает логи контейнера с указанным <container_id>.

Выполнение команд в запущенном контейнере

docker exec -it <container_id> <command>

Выполняет команду внутри запущенного контейнера с указанным <container_id>. Параметры -it разрешают интерактивную сессию терминала.

Мониторинг контейнерных ресурсов

docker stats

Отображает статистику использования ресурсов контейнера в реальном времени, включая использование процессора, памяти и сети.

Заключение

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