library - ¿Cuál es la diferencia entre una imagen de Docker y un contenedor?

dockers container download (20)

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 listar las imágenes que puedes ejecutar, ejecuta:

docker image ls

Para listar los contenedores puede ejecutar comandos en:

docker ps

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

Así que, finalmente, tengo una imagen para mi instancia de PostgreSQL y una imagen para mi aplicación web, cambios en los que seguir siendo persistente.

Entonces la pregunta es: ¿Qué es un contenedor?

Como en el aspecto de la programación,

La imagen es un código fuente.

Cuando el código fuente es compilado y construido, se llama como aplicación.

Al igual que "cuando se crea una instancia para la imagen", se llama " Contenedor "

Como muchas respuestas lo señalaron: usted 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 qué imagen y contenedor de Docker son:

1) Construir Dockerfile:

docker build -t my_image dir_with_dockerfile

2) Guardar la imagen en un archivo .tar

docker save -o my_file.tar my_image_id

my_file.tar almacenará la imagen. tar -xvf my_file.tar con tar -xvf my_file.tar , y verás 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 echar un vistazo dentro de un contenedor, puedes hacer:

sudo docker run -it my_image bash

y se puede ver que es muy parecido a un sistema operativo.

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 distintos. Para mí, captar 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 build , y producirán un contenedor cuando se inicien con la run . Las imágenes se almacenan en un registro de Docker como registry.hub.docker.com . Debido a que pueden llegar a ser bastante grandes, las imágenes están diseñadas para estar compuestas por capas de otras imágenes, lo que permite que se envíe una cantidad de datos de manera crucial al transferir imágenes a través de la red.

Las imágenes locales se pueden listar 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:

ID DE IMAGEN son los primeros 12 caracteres del verdadero identificador para una imagen. Puede crear muchas etiquetas de una imagen determinada, pero sus ID serán todas iguales (como se mencionó anteriormente).
El TAMAÑO VIRTUAL es virtual porque agrega 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.
El valor en la columna REPOSITORIO proviene de la docker tag -t del comando de docker build de la docker build , o de la docker tag ventana docker tag la imagen existente. Usted es libre de etiquetar imágenes usando una nomenclatura que tenga sentido para usted, pero sabe que la ventana acoplable utilizará la etiqueta como la ubicación de registro en un docker push o docker pull .
La forma completa de una etiqueta es [REGISTRYHOST/][USERNAME/]NAME[:TAG] . Para ubuntu arriba, se infiere que REGISTRYHOST es registry.hub.docker.com . Entonces, si planea almacenar su imagen llamada my-application en un registro en docker.example.com , debe etiquetar esa imagen docker.example.com/my-application .
La columna TAG es solo la parte [: TAG] de la etiqueta completa . Esta es una terminología desafortunada.
La latest etiqueta no es mágica, es simplemente la etiqueta predeterminada cuando no especifica una etiqueta.
Puede tener imágenes sin etiquetar solo identificables por sus ID de IMAGEN. Estos obtendrán el TAG <none> y el REPOSITORIO. Es fácil olvidarse de ellos.

Más información sobre las imágenes está disponible en los documentos y el glossary Docker .

¿Qué es un contenedor?

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

Ver los contenedores locales en ejecución con la 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 la ventana acoplable, de modo que tengo un lugar privado para almacenar mis imágenes. De nuevo, algunas cosas a tener en cuenta:

Al igual que la IDENTIFICACIÓN DE IMAGEN, la ID DEL CONTENEDOR es el verdadero identificador del contenedor. Tiene la misma forma, pero identifica un tipo diferente de objeto.
docker ps solo da salida a contenedores. Puede ver todos los contenedores (en ejecución o detenidos ) con la docker ps -a .
Los NOMBRES se pueden usar para identificar un contenedor iniciado a través de la --name .

¿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 resultó en un máximo de unidades de disco duro que ralentizaron mi computadora portátil o detuvieron mi compilación automatizada. Habla de "contenedores por todas partes"!

Podemos eliminar todas las imágenes sin etiquetar al combinar docker rmi con la reciente consulta dangling=true :

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

Docker no podrá eliminar las imágenes que están detrás de los contenedores existentes, por lo que es posible que primero tenga que eliminar los contenedores detenidos con la docker rm :

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

Estos son puntos de dolor 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:

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

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

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

El concepto central de la ventana acoplable 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. Así que el flujo de trabajo básico es:

crear una imagen
empezar un contenedor
hacer cambios en el contenedor
Guarda el contenedor como una imagen.

En breve:

Container es una división (virtual) en un kernel 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 para ejecutar el código.

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 kernel con otros contenedores y se ejecuta como un proceso aislado en el espacio de usuario en el sistema operativo host. Más detalle .

Otros términos importantes a tener en cuenta:

Demonio Docker -

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

Cliente Docker -

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

Docker Store -

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

Una imagen vale mas que mil palabras.

(Para una comprensión más profunda por favor lea this ).

Resumen:

Extraiga la imagen del concentrador de Docker 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, un contenedor (editable)

En pocas palabras, si una imagen es una clase, un contenedor es una instancia de una clase es un objeto de tiempo de ejecución.

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 es realmente la clave para entender todo el concepto. Es una publicación larga, por lo que estoy resumiendo los puntos clave que se deben comprender para obtener claridad.

Imagen : una imagen de Docker se construye 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 archivo de Docker contiene cuatro comandos, cada uno de los cuales crea una capa.

DESDE ubuntu: 15.04
DUPDO . / aplicación
Ejecutar make / app
CMD python /app/app.py

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

Contenedor Cuando crea un nuevo contenedor, agrega una nueva capa grabable en la parte superior de las capas subyacentes . Esta capa a menudo se llama la "capa de 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 capa de contenedor de escritura delgada .

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 modifican datos existentes se almacenan en esta capa grabable. Cuando se elimina el contenedor, también se elimina la capa de escritura. La imagen subyacente se mantiene sin cambios.

Comprensión de imágenes cnd Contenedores desde una perspectiva de tamaño en disco

Para ver el tamaño aproximado de un contenedor en ejecución, puede usar el comando docker ps -s . Usted obtiene el size y virtual size como dos de las salidas:

Tamaño: la cantidad de datos (en disco) que se utiliza para la capa grabable 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 la cantidad de tamaño que utiliza la imagen en el disco.

Otro concepto importante es la estrategia de copia en escritura.

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

Espero que ayude a alguien como yo.

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

Luego, una vez que desee crear una aplicación a partir de ese 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 entrega las instancias que desee.

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

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 que se está ejecutando actualmente, pero un contenedor también se puede detener (o 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.

Tal vez la explicación de 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 creas 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 de git: puede empujar y extraer imágenes.

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

Esta publicación explica muchas cosas básicas acerca de los contenedores docker (se trata de Docker y Puppet, pero hay muchos conceptos que se pueden usar en cualquier contexto)

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

Un contenedor es solo un binario ejecutable que debe ser ejecutado por el sistema operativo del host bajo un conjunto de restricciones que están preestablecidas usando una aplicación (por ejemplo, docker) que sabe cómo decirle al sistema operativo qué restricciones aplicar.

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

Hasta hace poco, solo los kernels en sistemas basados en Unix admitían la capacidad de ejecutar ejecutables bajo restricciones estrictas. Es por eso que la mayoría de las conversaciones en contenedor de hoy involucran principalmente a Linux u otras distribuciones de Unix.

Docker es una de esas aplicaciones que sabe cómo decirle al sistema operativo (Linux en su mayoría) las restricciones para 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. (Ver creando una imagen base simple usando scratch ). Ya sea que el binario en la imagen de la ventana acoplable sea un sistema operativo o simplemente una aplicación, para el host del sistema operativo es solo otro proceso, un proceso contenido que se rige por los límites preestablecidos del sistema operativo.

Otras aplicaciones que, como Docker, pueden decirle al sistema operativo host qué límites aplicar a un proceso mientras se ejecuta 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 utilizando su propia biblioteca llamada " libcontainer ".

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

IMO 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 https://en.m.wikipedia.org/wiki/Docker_(Linux_container_engine)

Una imagen de Docker empaqueta la aplicación y el entorno requerido 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 embalaje de la ventana acoplable, análoga al "código fuente" o un "programa". Los contenedores son la parte de ejecución de la ventana acoplable, análoga a un "proceso".

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

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.

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. Puedes tener muchos contenedores corriendo de la misma imagen.

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

Así que una instancia en ejecución de una imagen es un contenedor.

Dockerfile > (Build)> Image > (Run)> Container .

Dockerfile : contiene un conjunto de instrucciones de docker que aprovisionan su sistema operativo de la forma que desee, e instala / configura todo el 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 sistema operativo virtual en sí mismo, puede ssh en él y ejecutar cualquier comando que desee, como si fuera un entorno real. Puede ejecutar más de 1000 contenedores desde la misma imagen.

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

Contenedor es la instanciación real de la imagen tal como un objeto es una instanciación o una instancia de una clase.