В чем разница между образом Docker и контейнером?

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

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

Итак, вопрос: что такое контейнер?

+654
19 мая '14 в 10:15
источник поделиться
21 ответ

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

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

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

+898
19 мая '14 в 11:40
источник

Связанные вопросы


Похожие вопросы

Из моей статьи об автоматизации развертывания 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> и хранилище. Легко забыть о них.

Более подробную информацию об изображениях можно получить из документации и глоссария 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].
+492
16 нояб. '14 в 19:07
источник

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

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

+101
12 нояб. '14 в 11:14
источник

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

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

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

Контейнеры -

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


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


Docker Daemon -

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

Docker клиент -

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

Docker Store -

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

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

Enter image description here

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

Резюме:

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

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

Все начинается с Dockerfile. Файл Dockerfile является исходным кодом изображения.

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

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

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

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

+76
05 мая '15 в 11:06
источник

Workflow

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

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

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

docker image ls

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

docker ps
+37
09 авг. '17 в 18:25
источник

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

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

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

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

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

ОТ убунту: 15.04

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

RUN make/app

CMD python/app/app.py

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

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

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

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

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

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

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

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

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

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

+32
10 авг. '17 в 10:59
источник

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

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

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

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

+22
25 апр. '17 в 1:26
источник

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

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

  • создать изображение
  • запустить контейнер
  • внести изменения в контейнер
  • сохранить контейнер обратно как изображение
+11
05 мая '15 в 10:24
источник

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

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

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

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

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

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

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

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

Смотрите https://en.m.wikipedia.org/wiki/Docker_(Linux_container_engine)

+11
13 окт. '15 в 8:13
источник

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

+11
06 сент. '17 в 10:48
источник

Как много ответов указали на это: Вы строите 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

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

+5
20 сент. '18 в 3:45
источник

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

Изображение - это исходный код.

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

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

+3
19 июн. '17 в 6:28
источник

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

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

+3
20 февр. '18 в 12:14
источник

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

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

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

+3
29 мая '15 в 8:21
источник

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

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

+1
11 мая '18 в 17:41
источник

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

+1
08 мая '18 в 5:42
источник

Короче:

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

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

+1
13 нояб. '17 в 10:10
источник

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

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

0
14 июл. '17 в 0:48
источник

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

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

IContainer newDotNetApp = ImageFactory.DotNetImageFactory.CreateNew(appOptions);
newDotNetApp.ChangeDescription("I am making changes on this instance");
newDotNetApp.Run();
0
30 апр. '18 в 16:17
источник
  1. Изображение - это строительный блок контейнера. На самом деле это своего рода снимок виртуальной машины, но более легкий.

  2. Контейнер - это метод виртуализации операционной системы, позволяющий выполнять приложение и связанные с ним зависимости в процессах, изолированных от ресурсов.

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

Можно просмотреть все изображения, используя следующий код:

докер изображения

Работающие контейнеры можно увидеть с:

докер PS

Если вы хотите увидеть все контейнеры, независимо от того, запущены они или нет:

докер ps -a

0
22 янв. '19 в 13:35
источник

Посмотрите другие вопросы по меткам или Задайте вопрос