tag - imagenes docker




¿Cuál es la diferencia entre una imagen de Docker y un contenedor? (14)

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?


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

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 "


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:

  1. 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).
  2. 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.
  3. 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 .
  4. 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 .
  5. La columna TAG es solo la parte [: TAG] de la etiqueta completa . Esta es una terminología desafortunada.
  6. La latest etiqueta 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 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:

  1. 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.
  2. docker ps solo da salida a contenedores. Puede ver todos los contenedores (en ejecución o detenidos ) con la docker ps -a .
  3. 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:

  1. Siempre retire un contenedor inútil y detenido con la docker rm [CONTAINER_ID] .
  2. 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)


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)

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();

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 :)


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.


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.





docker-image