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

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

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

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

Вы можете видеть все ваши изображения с помощью, docker imagesтогда как вы можете видеть ваши работающие контейнеры с docker ps(и вы можете видеть все контейнеры с docker ps -a).

Таким образом, работающий экземпляр изображения является контейнером.

Из моей статьи об автоматизации развертывания Docker :

Изображения Docker против Контейнеров

В Dockerland есть изображения и есть контейнеры . Два тесно связаны, но различны. Для меня, понимание этой дихотомии очень сильно прояснило Докера.

Что такое изображение?

Изображение - это инертный, неизменный файл, который по сути является снимком контейнера. Образы создаются командой build , и они будут создавать контейнер при запуске с run . Изображения хранятся в реестре Docker, например registry.hub.docker.com . Поскольку они могут стать достаточно большими, изображения создаются так, чтобы они состояли из слоев других изображений, что позволяет передавать минимальный объем данных при передаче изображений по сети.

Локальные изображения могут быть перечислены, запустив docker images:

REPOSITORY                TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
ubuntu                    13.10               5e019ab7bf6d        2 months ago        180 MB
ubuntu                    14.04               99ec81b80c55        2 months ago        266 MB
ubuntu                    latest              99ec81b80c55        2 months ago        266 MB
ubuntu                    trusty              99ec81b80c55        2 months ago        266 MB
<none>                    <none>              4ab0d9120985        3 months ago        486.5 MB

Некоторые вещи, на которые стоит обратить внимание:

1. ИД ИЗОБРАЖЕНИЯ - это первые 12 символов истинного идентификатора изображения. Вы можете создать много тегов для данного изображения, но их идентификаторы будут одинаковыми (как указано выше).
2. ВИРТУАЛЬНЫЙ РАЗМЕР является виртуальным, поскольку он складывает размеры всех отдельных нижележащих слоев. Это означает, что сумма всех значений в этом столбце, вероятно, намного больше, чем дисковое пространство, используемое всеми этими образами.
3. Значение в столбце REPOSITORY берется из -tфлага docker buildкоманды или из docker tag-ing существующего изображения. Вы можете помечать изображения с помощью номенклатуры, которая имеет смысл для вас, но знайте, что докер будет использовать этот тег в качестве расположения реестра в docker pushили docker pull.
4. Полная форма тега есть [REGISTRYHOST/][USERNAME/]NAME[:TAG]. Для ubuntuвыше, REGISTRYHOST выводится как registry.hub.docker.com. Так что, если вы планируете хранить свое изображение my-applicationв реестре по адресу docker.example.com, вы должны пометить это изображениеdocker.example.com/my-application .
5. Столбец TAG - это только часть [: TAG] полного тега. Это неудачная терминология.
6. latestТег не волшебно, это просто тег по умолчанию , если вы не укажете тег.
7. Вы можете иметь изображения без тегов, идентифицируемые только по их идентификаторам IMAGE. Они получат <none>TAG и хранилище. Про них легко забыть.

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

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

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

Просмотр локально работающих контейнеров с помощью docker ps:

CONTAINER ID        IMAGE                               COMMAND                CREATED             STATUS              PORTS                    NAMES
f2ff1af05450        samalba/docker-registry:latest      /bin/sh -c 'exec doc   4 months ago        Up 12 weeks         0.0.0.0:5000->5000/tcp   docker-registry

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

1. Как и IMAGE ID, CONTAINER ID является истинным идентификатором контейнера. Он имеет ту же форму, но идентифицирует другой тип объекта.
2. docker psтолько выводит запущенные контейнеры. Вы можете просмотреть все контейнеры ( запущенные или остановленные ) с помощью docker ps -a.
3. Имена могут быть использованы для идентификации запущенного контейнера через --nameфлаг.

Как избежать накопления изображения и контейнера

Одним из моих ранних разочарований в Docker было, казалось бы, постоянное накопление нетегированных изображений и остановленных контейнеров . В некоторых случаях такое накопление приводило к тому, что использование жестких дисков максимально увеличивало скорость работы моего ноутбука или останавливало конвейер автоматической сборки. Поговорим о «контейнерах везде»!

Мы можем удалить все непомеченные изображения в сочетании docker rmiс последним dangling=trueзапросом:

docker images -q --filter "dangling=true" | xargs docker rmi

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

docker rm `docker ps --no-trunc -aq`

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

1. Всегда удаляйте ненужный, остановленный контейнер с docker rm [CONTAINER_ID].
2. Всегда удаляйте изображение за бесполезным, остановленным контейнером с docker rmi [IMAGE_ID].

Проще говоря.

Изображения -

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

Контейнеры -

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

Другие важные условия, на которые следует обратить внимание:

Docker Daemon -

Фоновая служба, запущенная на хосте, которая управляет сборкой, запуском и распространением контейнеров Docker.

Docker клиент -

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

Docker Store -

Store - это, помимо прочего, реестр образов Docker. Вы можете рассматривать реестр как каталог всех доступных образов Docker.

Картинка из этого поста стоит тысячи слов.

(Для более глубокого понимания, пожалуйста, прочитайте это .)

Резюме:

• Извлечь изображение из Docker-концентратора или построить из Dockerfile => Дает изображение Docker (не редактируется).
• Run image ( docker run image_name:tag_name) => Дает работающее изображение, т.е. контейнер (редактируемый)

Хотя контейнер проще всего представить как бегущее изображение, это не совсем точно.

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

Может быть, объяснение всего рабочего процесса может помочь.

Все начинается с Dockerfile . Dockerfile - это исходный код изображения.

Как только Dockerfile создан, вы создаете его для создания образа контейнера. Образ - это просто «скомпилированная версия» «исходного кода», который является Dockerfile.

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

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

Workflow

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

+------------+  docker build   +--------------+  docker run -dt   +-----------+  docker exec -it   +------+
| Dockerfile | --------------> |    Image     | --------------->  | Container | -----------------> | Bash |
+------------+                 +--------------+                   +-----------+                    +------+
                                 ^
                                 | docker pull
                                 |
                               +--------------+
                               |   Registry   |
                               +--------------+

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

docker image ls

Для вывода списка контейнеров вы можете выполнить команды:

docker ps

Я не мог понять концепцию изображения и слоя, несмотря на то, что прочитал все вопросы здесь, а потом, в конце концов, наткнулся на эту превосходную документацию от Докера (да!).

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

• Изображение : изображение Docker состоит из ряда слоев только для чтения

• Слой : каждый слой представляет инструкцию в Dockerfile изображения.

Example: Приведенный ниже Dockerfile содержит четыре команды, каждая из которых создает слой.

ОТ убунту: 15.04

КОПИЯ. /приложение

RUN make / app

CMD python /app/app.py

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

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

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

Понимание изображений и контейнеров с точки зрения размера на диске

Чтобы просмотреть приблизительный размер работающего контейнера, вы можете использовать docker ps -sкоманду. Вы получаете sizeи в virtual sizeкачестве двух выходов:

• Размер: объем данных (на диске), который используется для слоя записи каждого контейнера

• Виртуальный размер: объем данных, используемых для данных изображения только для чтения, используемых контейнером. Несколько контейнеров могут совместно использовать некоторые или все данные изображения только для чтения. Следовательно, они не являются аддитивными. Т.е. вы не можете добавить все виртуальные размеры, чтобы вычислить, какой размер диска используется образом.

Другая важная концепция - стратегия копирования при записи.

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

Я надеюсь, что это помогает кому-то, как я.

Dockerfile → (Сборка) → Изображение → (Выполнить) → Контейнер .

• Dockerfile : содержит набор инструкций Docker, которые настраивают вашу операционную систему так, как вам нравится, и устанавливает / настраивает все ваше программное обеспечение.

• Изображение : скомпилированный Dockerfile. Экономит ваше время от пересоздания Dockerfile каждый раз, когда вам нужно запустить контейнер. И это способ скрыть ваш код предоставления.

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

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

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

Типичные ограничения связаны с изоляцией процесса, с безопасностью (например, с использованием защиты SELinux ) и с системными ресурсами (память, диск, процессор и сеть).

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

Docker - одно из тех приложений, которые знают, как указать ОС (в основном Linux), под какими ограничениями запускать исполняемый файл. Исполняемый файл содержится в образе Docker, который является просто tar-файлом. Этот исполняемый файл обычно представляет собой урезанную версию дистрибутива Linux (Ubuntu, CentOS, Debian и т. Д.), Предварительно настроенную для запуска одного или нескольких приложений.

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

Другие приложения, такие как Docker, могут указывать операционной системе хоста, какие границы применять к процессу во время его работы, в том числе LXC , libvirt и systemd . Docker использовал эти приложения для косвенного взаимодействия с ОС Linux, но теперь Docker взаимодействует напрямую с Linux, используя свою собственную библиотеку, называемую « libcontainer ».

Таким образом, контейнеры - это просто процессы, работающие в ограниченном режиме, аналогично тому, что делал chroot .

IMO, что отличает Docker от любых других контейнерных технологий, это его хранилище (Docker Hub) и инструменты управления, которые делают работу с контейнерами чрезвычайно простой.

Смотрите Docker (программное обеспечение) .

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

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

1. создать образ
2. начать контейнер
3. внести изменения в контейнер
4. сохранить контейнер обратно как изображение

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

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

1) Построить Dockerfile:

docker build -t my_image dir_with_dockerfile

2) Сохранить изображение в .tarфайл

docker save -o my_file.tar my_image_id

my_file.tarбудет хранить изображение. Откройте его tar -xvf my_file.tar, и вы увидите все слои. Если вы погрузитесь глубже в каждый слой, вы сможете увидеть, какие изменения были добавлены в каждый слой. (Они должны быть довольно близки к командам в Dockerfile).

3) Чтобы заглянуть внутрь контейнера, вы можете сделать:

sudo docker run -it my_image bash

и вы можете видеть, что это очень похоже на ОС.

Изображение является эквивалентом определения класса в ООП, а слои - это разные методы и свойства этого класса.

Контейнер - это фактическое создание экземпляра изображения, так же, как объект является экземпляром или экземпляром класса.

Я думаю, что лучше объяснить в начале.

Предположим, вы запускаете команду docker run hello-world. Что просходит?

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

Предположим, что hello-world не существует. Сервер Docker переходит в Docker Hub (Docker Hub - это просто бесплатное хранилище изображений) и спрашивает: эй, Hub, у вас есть изображение под названием hello-world? Ответы центра - да, я делаю. Тогда дайте это мне, пожалуйста. И процесс загрузки начинается. Как только образ Docker загружен, сервер Docker помещает его в кэш изображений .

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

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

Теперь представьте, что у вас есть две программы, Chrome и Node.js. Для запуска Chrome требуется Python версии 2, а для Node.js - Python версии 3. Если на вашем компьютере установлен только Python v2, будет запущен только Chrome.

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

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

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

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

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

Как и в аспекте программирования,

Изображение является исходным кодом.

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

Аналогично тому, «когда экземпляр создается для изображения», он называется « контейнером ».

Изображение является «моментальный снимок» из контейнера . Вы можете создавать изображения из контейнера (новые «снимки»), а также запускать новые контейнеры из изображения (создавать «снимок»).

Например, вы можете создать новый контейнер из базового образа, выполнить некоторые команды в контейнере, а затем сделать снимок этого нового изображения. Затем вы можете запустить 100 контейнеров из этого нового образа.

Другие вещи для рассмотрения:

• Изображение состоит из слоев, а слои представляют собой снимки «diff» (поэтому, когда вы нажимаете изображение, вам нужно только отправить «diff» в реестр).
• Dockerfile определяет некоторые команды поверх базового изображения, которые создают новые слои («diffs»), которые приводят к новому изображению («snapshot»).
• Теги изображений - это не просто теги. Это «полное имя» изображения («хранилище: тег»). Если одно и то же изображение имеет несколько имен, оно показывается несколько раз при выполнении docker images.

Я хотел бы заполнить недостающую часть здесь между docker imagesи containers. Docker использует объединенную файловую систему ( UFS ) для контейнеров, которая позволяет монтировать несколько файловых систем в иерархии и отображаться как одна файловая система. Файловая система из образа была смонтирована как read-onlyслой, и любые изменения в работающем контейнере вносятся в read-writeслой, смонтированный поверх этого. Из-за этого Docker должен смотреть только на верхний уровень чтения-записи, чтобы найти изменения, внесенные в работающую систему.

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

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

IContainer newDotNetApp = ImageFactory.DotNetImageFactory.CreateNew(appOptions);
newDotNetApp.ChangeDescription("I am making changes on this instance");
newDotNetApp.Run();

Короче говоря:

Контейнер - это разделение (виртуальное) в ядре, которое использует общую ОС и запускает образ (образ Docker).

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

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

Изображение для класса как контейнер для объекта.

Контейнер является экземпляром изображения, так как объект является экземпляром класса.

Dockerfile похож на ваш Bash-скрипт, который создает тарбол (изображение Docker).

Контейнеры Docker похожи на извлеченную версию тарбола. Вы можете иметь сколько угодно копий в разных папках (контейнерах).