Cuando usamos Docker, comenzamos con una imagen base. Lo arrancamos, creamos cambios y esos cambios se guardan en capas formando otra imagen.

Así que eventualmente tengo una imagen para mi instancia de PostgreSQL y una imagen para mi aplicación web, cambios a los que persisten.

¿Qué es un contenedor?

Una instancia de una imagen se llama contenedor. Tiene una imagen, que es un conjunto de capas como usted describe. Si inicia esta imagen, tiene un contenedor en ejecución de esta imagen. Puede tener muchos contenedores en ejecución de la misma imagen.

Puede ver todas sus imágenes con docker imagesmientras que puede ver sus contenedores en ejecución con docker ps(y puede ver todos los contenedores con docker ps -a).

Entonces, una instancia en ejecución de una imagen es un contenedor.

De mi artículo sobre Automatización de implementaciones de Docker :

Imágenes Docker vs. Contenedores

En Dockerland, hay imágenes y hay contenedores . Los dos están estrechamente relacionados, pero son distintos. Para mí, comprender esta dicotomía ha aclarado inmensamente a Docker.

¿Qué es una imagen?

Una imagen es un archivo inerte, inmutable, que es esencialmente una instantánea de un contenedor. Las imágenes se crean con el comando de compilación y producirán un contenedor cuando se inicie con la ejecución . Las imágenes se almacenan en un registro de Docker como el registro.hub.docker.com . Debido a que pueden llegar a ser bastante grandes, las imágenes están diseñadas para estar compuestas de capas de otras imágenes, lo que permite enviar una cantidad mínima de datos al transferir imágenes a través de la red.

Las imágenes locales se pueden enumerar ejecutando 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

Algunas cosas a tener en cuenta:

1. ID DE IMAGEN son los primeros 12 caracteres del identificador verdadero para una imagen. Puede crear muchas etiquetas de una imagen determinada, pero sus ID serán todas iguales (como se indicó anteriormente).
2. TAMAÑO VIRTUAL es virtual porque suma los tamaños de todas las capas subyacentes distintas. Esto significa que la suma de todos los valores en esa columna es probablemente mucho mayor que el espacio en disco utilizado por todas esas imágenes.
3. El valor en la columna REPOSITORIO proviene del -tindicador del docker buildcomando o de docker taguna imagen existente. Puede etiquetar imágenes usando una nomenclatura que tenga sentido para usted, pero sepa que Docker usará la etiqueta como ubicación de registro en un docker pusho docker pull.
4. La forma completa de una etiqueta es [REGISTRYHOST/][USERNAME/]NAME[:TAG]. Por ubuntuarriba, REGISTRYHOST se infiere que ser registry.hub.docker.com. Entonces, si planea almacenar su imagen llamada my-applicationen un registro en docker.example.com, debe etiquetar esa imagen docker.example.com/my-application.
5. La columna TAG es solo la parte [: TAG] de la etiqueta completa . Esta es una terminología desafortunada.
6. La latestetiqueta no es mágica, es simplemente la etiqueta predeterminada cuando no especifica una etiqueta.
7. Puede tener imágenes sin etiquetar solo identificables por sus ID de IMAGEN. Estos obtendrán la <none>etiqueta y el repositorio. Es fácil olvidarse de ellos.

Más información sobre las imágenes está disponible en la documentación y el glosario de Docker .

¿Qué es un contenedor?

Para usar una metáfora de programación, si una imagen es una clase, entonces un contenedor es una instancia de una clase, un objeto de tiempo de ejecución. Con suerte, los contenedores son por qué estás usando Docker; son encapsulaciones ligeras y portátiles de un entorno en el que ejecutar aplicaciones.

Ver contenedores locales en ejecución con 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

Aquí estoy ejecutando una versión dockerizada del registro de docker, para tener un lugar privado para almacenar mis imágenes. De nuevo, algunas cosas a tener en cuenta:

1. Al igual que la ID DE IMAGEN, la ID DE CONTENEDOR es el verdadero identificador del contenedor. Tiene la misma forma, pero identifica un tipo diferente de objeto.
2. docker pssolo salidas que ejecutan contenedores. Puede ver todos los contenedores (en ejecución o detenidos ) con docker ps -a.
3. NOMBRES se pueden usar para identificar un contenedor iniciado a través de la --namebandera.

Cómo evitar la acumulación de imágenes y contenedores

Una de mis primeras frustraciones con Docker fue la acumulación aparentemente constante de imágenes sin etiquetar y contenedores detenidos . En un puñado de ocasiones, esta acumulación dio como resultado que los discos duros al máximo desaceleren mi computadora portátil o detengan mi tubería de compilación automatizada. ¡Habla sobre "contenedores en todas partes"!

Podemos eliminar todas las imágenes sin etiquetar combinando docker rmicon la dangling=trueconsulta reciente :

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

Docker no podrá eliminar imágenes que están detrás de los contenedores existentes, por lo que es posible que docker rmprimero deba eliminar los contenedores detenidos con :

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

Estos son puntos débiles conocidos con Docker y pueden abordarse en futuras versiones. Sin embargo, con una comprensión clara de las imágenes y los contenedores, estas situaciones se pueden evitar con un par de prácticas:

1. Siempre retire un recipiente inútil y detenido con docker rm [CONTAINER_ID].
2. Siempre quite la imagen detrás de un contenedor inútil y detenido con docker rmi [IMAGE_ID].

En palabras fáciles

Imágenes -

El sistema de archivos y la aplicación de configuración (solo lectura) que se utiliza para crear contenedores. Más detalle .

contenedores -

Estas son instancias en ejecución de imágenes Docker. Los contenedores ejecutan las aplicaciones reales. Un contenedor incluye una aplicación y todas sus dependencias. Comparte el núcleo con otros contenedores y se ejecuta como un proceso aislado en el espacio del usuario en el sistema operativo host. Más detalle .

Otros términos importantes a tener en cuenta:

Docker Demonio -

El servicio en segundo plano que se ejecuta en el host que administra el edificio, la ejecución y la distribución de contenedores Docker.

Acoplable cliente -

La herramienta de línea de comandos que permite al usuario interactuar con el demonio Docker.

Tienda Docker -

Store es, entre otras cosas, un registro de imágenes de Docker. Puede pensar en el registro como un directorio de todas las imágenes Docker disponibles.

Una imagen de esta publicación de blog vale más que mil palabras.

(Para una comprensión más profunda, lea esto ).

Resumen:

• Extraiga la imagen de Docker Hub o compile desde un Dockerfile => Da una imagen de Docker (no editable).
• Ejecutar la imagen ( docker run image_name:tag_name) => Da una imagen en ejecución, es decir, contenedor (editable)

Si bien es más simple pensar en un contenedor como una imagen en ejecución, esto no es del todo exacto.

Una imagen es realmente una plantilla que se puede convertir en un contenedor. Para convertir una imagen en un contenedor, el motor Docker toma la imagen, agrega un sistema de archivos de lectura y escritura en la parte superior e inicializa varias configuraciones, incluidos los puertos de red, el nombre del contenedor, la ID y los límites de recursos. Un contenedor en ejecución tiene un proceso en ejecución actualmente, pero también se puede detener un contenedor salir en la terminología de Docker). Un contenedor salido no es lo mismo que una imagen, ya que puede reiniciarse y conservará su configuración y cualquier cambio en el sistema de archivos.

Quizás explicar todo el flujo de trabajo puede ayudar.

Todo comienza con el Dockerfile . El Dockerfile es el código fuente de la imagen.

Una vez que se crea el Dockerfile, lo crea para crear la imagen del contenedor. La imagen es solo la "versión compilada" del "código fuente" que es el Dockerfile.

Una vez que tenga la imagen del contenedor, debe redistribuirla utilizando el registro . El registro es como un repositorio Git: puede insertar y extraer imágenes.

A continuación, puede usar la imagen para ejecutar contenedores . Un contenedor en ejecución es muy similar, en muchos aspectos, a una máquina virtual (pero sin el hipervisor ).

Flujo de trabajo

Aquí está el flujo de trabajo de extremo a extremo que muestra los diversos comandos y sus entradas y salidas asociadas. Eso debería aclarar la relación entre una imagen y un contenedor.

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

Para enumerar las imágenes que puede ejecutar, ejecute:

docker image ls

Para enumerar los contenedores en los que podría ejecutar comandos:

docker ps

No pude entender el concepto de imagen y capa a pesar de leer todas las preguntas aquí y finalmente me topé con esta excelente documentación de Docker (¡duh!).

El ejemplo allí es realmente la clave para entender todo el concepto. Es una publicación larga, así que estoy resumiendo los puntos clave que deben ser realmente comprendidos para obtener claridad.

• Imagen : una imagen de Docker se crea a partir de una serie de capas de solo lectura

• Capa : cada capa representa una instrucción en el Dockerfile de la imagen.

Example: El siguiente Dockerfile contiene cuatro comandos, cada uno de los cuales crea una capa.

DE ubuntu: 15.04

COPIAR . / app

EJECUTAR marca / aplicación

CMD python /app/app.py

Es importante destacar que cada capa es solo un conjunto de diferencias con respecto a la capa anterior.

• Contenedor . Cuando crea un nuevo contenedor, agrega una nueva capa de escritura encima de las capas subyacentes . Esta capa a menudo se llama la "capa contenedor". Todos los cambios realizados en el contenedor en ejecución, como escribir nuevos archivos, modificar archivos existentes y eliminar archivos, se escriben en esta delgada capa de contenedor grabable.

Por lo tanto, la principal diferencia entre un contenedor y una imagen es la capa superior de escritura . Todas las escrituras en el contenedor que agregan datos nuevos o modificados se almacenan en esta capa de escritura. Cuando se elimina el contenedor, la capa de escritura también se elimina. La imagen subyacente permanece sin cambios.

Comprensión de imágenes y contenedores desde una perspectiva de tamaño en disco

Para ver el tamaño aproximado de un contenedor en ejecución, puede usar el docker ps -scomando. Obtiene sizey virtual sizecomo dos de las salidas:

• Tamaño: la cantidad de datos (en disco) que se usa para la capa de escritura de cada contenedor

• Tamaño virtual: la cantidad de datos utilizados para los datos de imagen de solo lectura utilizados por el contenedor. Varios contenedores pueden compartir algunos o todos los datos de imagen de solo lectura. Por lo tanto, estos no son aditivos. Es decir, no puede agregar todos los tamaños virtuales para calcular cuánto tamaño de disco utiliza la imagen.

Otro concepto importante es la estrategia de copiar y escribir

Si existe un archivo o directorio en una capa inferior dentro de la imagen, y otra capa (incluida la capa grabable) necesita acceso de lectura, solo usa el archivo existente. La primera vez que otra capa necesita modificar el archivo (al construir la imagen o ejecutar el contenedor), el archivo se copia en esa capa y se modifica.

Espero que eso ayude a alguien como yo.

Dockerfile → (Construir) → Imagen → (Ejecutar) → Contenedor .

• Dockerfile : contiene un conjunto de instrucciones de Docker que aprovisiona su sistema operativo de la manera que desee e instala / configura todo su software.

• Imagen : Dockerfile compilado. Le ahorra tiempo al reconstruir el Dockerfile cada vez que necesita ejecutar un contenedor. Y es una forma de ocultar su código de provisión.

• Contenedor : el propio sistema operativo virtual. Puede ingresar y ejecutar cualquier comando que desee, como si fuera un entorno real. Puede ejecutar más de 1000 contenedores desde la misma imagen.

Simplemente dicho, si una imagen es una clase , entonces un contenedor es una instancia de una clase es un objeto de tiempo de ejecución .

Un contenedor es solo un binario ejecutable que debe ejecutar el sistema operativo host bajo un conjunto de restricciones que están preestablecidas utilizando una aplicación (por ejemplo, Docker) que sabe cómo indicarle al sistema operativo qué restricciones aplicar.

Las restricciones típicas están relacionadas con el aislamiento del proceso, la seguridad (como usar SELinux protección ) y los recursos del sistema (memoria, disco, CPU y redes).

Hasta hace poco, solo los núcleos en sistemas basados ​​en Unix soportaban la capacidad de ejecutar ejecutables bajo estrictas restricciones. Es por eso que la mayoría de las conversaciones de contenedores de hoy implican principalmente distribuciones Linux u otras distribuciones Unix.

Docker es una de esas aplicaciones que sabe cómo decirle al sistema operativo (Linux en su mayoría) bajo qué restricciones ejecutar un ejecutable. El ejecutable está contenido en la imagen de Docker, que es solo un archivo tar. Ese ejecutable suele ser una versión simplificada de una distribución de Linux (Ubuntu, CentOS, Debian, etc.) preconfigurada para ejecutar una o más aplicaciones dentro.

Aunque la mayoría de las personas usan una base de Linux como ejecutable, puede ser cualquier otra aplicación binaria siempre que el sistema operativo host pueda ejecutarla (vea cómo crear una imagen base simple usando scratch ). Si el binario en la imagen de Docker es un sistema operativo o simplemente una aplicación, para el host del sistema operativo es solo otro proceso, un proceso contenido regido por los límites preestablecidos del sistema operativo.

Otras aplicaciones que, como Docker, pueden indicarle al sistema operativo host qué límites aplicar a un proceso mientras se está ejecutando, incluyen LXC , libvirt y systemd . Docker solía usar estas aplicaciones para interactuar indirectamente con el sistema operativo Linux, pero ahora Docker interactúa directamente con Linux usando su propia biblioteca llamada " libcontainer ".

Entonces, los contenedores son solo procesos que se ejecutan en modo restringido, similar a lo que chroot solía hacer .

En mi opinión, lo que diferencia a Docker de cualquier otra tecnología de contenedores es su repositorio (Docker Hub) y sus herramientas de administración, lo que hace que trabajar con contenedores sea extremadamente fácil.

Ver Docker (software) .

El concepto central de Docker es facilitar la creación de "máquinas" que en este caso pueden considerarse contenedores. El contenedor ayuda a la reutilización, lo que le permite crear y soltar contenedores con facilidad.

Las imágenes representan el estado de un contenedor en cada momento. Entonces el flujo de trabajo básico es:

1. crear una imagen
2. comenzar un contenedor
3. hacer cambios en el contenedor
4. guardar el contenedor como una imagen

Como muchas respuestas señalaron esto: construye Dockerfile para obtener una imagen y ejecuta la imagen para obtener un contenedor .

Sin embargo, los siguientes pasos me ayudaron a tener una mejor idea de lo que son la imagen y el contenedor de Docker:

1) Construir Dockerfile:

docker build -t my_image dir_with_dockerfile

2) Guarde la imagen en el .tararchivo

docker save -o my_file.tar my_image_id

my_file.taralmacenará la imagen. Ábrelo con tar -xvf my_file.tar, y podrás ver todas las capas. Si profundiza en cada capa, puede ver qué cambios se agregaron en cada capa. (Deben estar bastante cerca de los comandos en el Dockerfile).

3) Para mirar dentro de un contenedor, puede hacer:

sudo docker run -it my_image bash

y puedes ver que es muy parecido a un sistema operativo.

La imagen es equivalente a una definición de clase en OOP y las capas son diferentes métodos y propiedades de esa clase.

El contenedor es la instanciación real de la imagen al igual que un objeto es una instanciación o una instancia de una clase.

Creo que es mejor explicarlo al principio.

Supongamos que ejecuta el comando docker run hello-world. ¿Lo que pasa?

Llama a Docker CLI, que es responsable de tomar los comandos de Docker y transformarlos para llamar a los comandos del servidor de Docker . Tan pronto como el servidor Docker recibe un comando para ejecutar una imagen , comprueba si el caché de imágenes contiene una imagen con ese nombre.

Supongamos que hello-world no existe. El servidor Docker va a Docker Hub (Docker Hub es solo un repositorio gratuito de imágenes) y pregunta, oye Hub, ¿tienes una imagen llamada hello-world? Respuestas del centro: sí, lo hago. Entonces dámelo, por favor. Y comienza el proceso de descarga. Tan pronto como se descarga la imagen de Docker , el servidor de Docker la coloca en el caché de imágenes .

Entonces, antes de explicar qué son las imágenes y los contenedores de Docker, comencemos con una introducción sobre el sistema operativo en su computadora y cómo ejecuta el software.

Cuando ejecuta, por ejemplo, Chrome en su computadora, llama al sistema operativo, el sistema operativo en sí llama al núcleo y pregunta, oye, quiero ejecutar este programa. El núcleo logra ejecutar archivos desde su disco duro.

Ahora imagine que tiene dos programas, Chrome y Node.js. Chrome requiere Python versión 2 para ejecutarse y Node.js requiere Python versión 3 para ejecutarse. Si solo instaló Python v2 en su computadora, solo se ejecutará Chrome.

Para que ambos casos funcionen, de alguna manera necesita usar una función del sistema operativo conocida como espacio de nombres. Un espacio de nombres es una característica que le brinda la oportunidad de aislar procesos, discos duros, redes, usuarios, nombres de host, etc.

Entonces, cuando hablamos de una imagen , en realidad hablamos de una instantánea del sistema de archivos. Una imagen es un archivo físico que contiene instrucciones y metadatos para construir un contenedor específico . El contenedor en sí es una instancia de una imagen ; aísla el disco duro utilizando espacios de nombres que solo están disponibles para este contenedor . Por lo tanto, un contenedor es un proceso o conjunto de procesos que agrupa diferentes recursos asignados a él.

Una imagen de Docker empaqueta la aplicación y el entorno requeridos por la aplicación para ejecutarse, y un contenedor es una instancia en ejecución de la imagen.

Las imágenes son la parte de empaque de Docker, análoga al "código fuente" o un "programa". Los contenedores son la parte de ejecución de Docker, análoga a un "proceso".

En la pregunta, solo se hace referencia a la parte del "programa" y esa es la imagen. La parte "en ejecución" de Docker es el contenedor. Cuando se ejecuta un contenedor y se realizan cambios, es como si el proceso realizara un cambio en su propio código fuente y lo guarda como la nueva imagen.

Como en el aspecto de programación,

La imagen es el código fuente.

Cuando el código fuente se compila y compila el , se llama una aplicación.

Similar a "cuando se crea una instancia para la imagen", se denomina " contenedor ".

Una imagen es una "instantánea" de un contenedor . Puede crear imágenes desde un contenedor (nuevas "instantáneas") y también puede iniciar nuevos contenedores desde una imagen (crear una instancia de la "instantánea").

Por ejemplo, puede crear una instancia de un nuevo contenedor a partir de una imagen base, ejecutar algunos comandos en el contenedor y luego tomar una instantánea como una nueva imagen. Luego puede ejecutar 100 contenedores desde esa nueva imagen.

Otras cosas a considerar:

• Una imagen está hecha de capas, y las capas son instantáneas "diffs" (por lo tanto, cuando empuja una imagen, solo necesita enviar la "diff" al registro).
• Un Dockerfile define algunos comandos en la parte superior de una imagen base, que crea nuevas capas ("diffs") que dan como resultado una nueva imagen ("instantánea").
• Las etiquetas de imagen no son solo etiquetas. Son el "nombre completo" de la imagen ("repositorio: etiqueta"). Si la misma imagen tiene varios nombres, se muestra varias veces al hacerlo docker images.

Me gustaría llenar la parte que falta aquí entre docker imagesy containers. Docker utiliza un sistema de archivos de unión ( UFS ) para contenedores, que permite que varios sistemas de archivos se monten en una jerarquía y aparezcan como un solo sistema de archivos. El sistema de archivos de la imagen se ha montado como una read-onlycapa, y cualquier cambio en el contenedor en ejecución se realiza en una read-writecapa montada encima de esto. Debido a esto, Docker solo tiene que mirar la capa superior de lectura y escritura para encontrar los cambios realizados en el sistema en ejecución.

Para una analogía ficticia de programación, puede pensar que Docker tiene un ImageFactory abstracto que contiene ImageFactories que vienen de la tienda .

Luego, una vez que desee crear una aplicación a partir de esa ImageFactory, tendrá un nuevo contenedor y podrá modificarlo como desee. DotNetImageFactory será inmutable, ya que actúa como una clase abstracta de fábrica, donde solo ofrece las instancias que desee.

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

En breve:

El contenedor es una división (virtual) en un núcleo que comparte un sistema operativo común y ejecuta una imagen (imagen Docker).

Un contenedor es una aplicación autosostenible que tendrá paquetes y todas las dependencias necesarias juntas para ejecutar el código.

Un contenedor Docker está ejecutando una instancia de una imagen. Puede relacionar una imagen con un programa y un contenedor con un proceso :)

Una imagen es para una clase como un contenedor para un objeto.

Un contenedor es una instancia de una imagen como un objeto es una instancia de una clase.

Dockerfile es como su script Bash que produce un tarball (imagen Docker).

Los contenedores Docker son como la versión extraída del tarball. Puede tener tantas copias como desee en diferentes carpetas (los contenedores).