¿Qué son las capas de imágenes de Docker?

Las imágenes de Docker constan de varias capas que, en conjunto, proporcionan el contenido que ve en sus contenedores. Pero, ¿qué es realmente una capa y en qué se diferencia de una imagen completa?

En este artículo, aprenderá cómo distinguir estos dos conceptos y por qué es importante la diferencia. Si bien puede usar Docker sin una comprensión profunda de las capas, tener conocimiento de su propósito lo ayudará a identificar oportunidades de optimización.

¿Qué es una imagen?

Una "imagen" de Docker se comporta como una plantilla a partir de la cual se pueden crear contenedores coherentes. Si Docker fuera una máquina virtual tradicional, la imagen podría compararse con la ISO utilizada para instalar su VM. Esta no es una comparación sólida, ya que Docker difiere de las máquinas virtuales en términos de concepto e implementación, pero no obstante es un punto de partida útil.

Las imágenes definen el estado inicial del sistema de archivos de los nuevos contenedores. Agrupan el código fuente de su aplicación y sus dependencias en un paquete autónomo que está listo para usar con un tiempo de ejecución de contenedor. Dentro de la imagen, el contenido del sistema de archivos se representa como varias capas independientes.

¿Qué son las capas?

Las capas son el resultado de la forma en que se construyen las imágenes de Docker. Cada paso en un Dockerfile crea una nueva "capa" que es esencialmente una diferencia de los cambios en el sistema de archivos desde el último paso. Instrucciones de metadatos como LABEL y MAINTAINER no cree capas porque no afectan el sistema de archivos.

Esta imagen tiene dos instrucciones (COPY y RUN) por lo que creará dos capas:

FROM ubuntu:latest
COPY foo.txt /foo.txt
RUN date > /built-on.txt

• El primer paso copia foo.txt en una nueva capa que se basa en la ubuntu:latest imagen.
• El segundo paso ejecuta el date y canaliza su salida a un archivo. Esto crea una segunda capa que se basa en la anterior.

Crear foo.txt en su directorio de trabajo:

$ echo "Hello World" > foo.txt

Ahora construye la imagen de muestra:

$ docker build . -t demo:latest
Sending build context to Docker daemon   2.56kB
Step 1/3 : FROM ubuntu:latest
 ---> df5de72bdb3b
Step 2/3 : COPY foo.txt /foo.txt
 ---> 4932aede6a15
Step 3/3 : RUN date > /built-on.txt
 ---> Running in 91d260fc2e68
Removing intermediate container 91d260fc2e68
 ---> 6f653c6a60fa
Successfully built 6f653c6a60fa
Successfully tagged foo:latest

Cada paso de construcción emite el ID de la capa creada. La capa del último paso se convierte en la imagen final, por lo que se etiqueta con foo:latest.

La secuencia revela que las capas son imágenes Docker válidas. Aunque el término "capa" normalmente no se usa para referirse a una imagen etiquetada, todas las imágenes etiquetadas son técnicamente solo capas con un identificador asignado.

Puede iniciar un contenedor desde la imagen de una capa intermedia:

$ docker run -it 4932aede6a15 sh
# cat /foo.txt
Hello World
# cat /built-on.txt
cat: /built-on.txt: No such file or directory

Este ejemplo inicia un contenedor desde la capa creada por el segundo paso de construcción. foo.txt está disponible en el contenedor pero built-on.txt no existe porque no se agrega hasta el tercer paso. Ese archivo solo está disponible en los sistemas de archivos de las capas posteriores.

El papel de las capas

Las capas contienen los cambios creados por un paso de compilación, en relación con la capa anterior en el Dockerfile. FROM Las instrucciones son un caso especial que hace referencia a la capa final de una imagen existente.

Las capas permiten que los pasos de compilación se almacenen en caché para evitar el trabajo redundante. Docker puede omitir instrucciones sin cambios en su Dockerfile al reutilizar la capa creada anteriormente. Basa el siguiente paso en esa capa existente, en lugar de construir una nueva.

Puede ver esto modificando su Dockerfile de la siguiente manera:

FROM ubuntu:latest
COPY foo.txt /foo.txt
RUN date +%Y-%m-%d > /built-on.txt

El tercer paso de compilación ha cambiado. Ahora reconstruye tu imagen:

$ docker build . -t demo:latest
Sending build context to Docker daemon  3.584kB
Step 1/3 : FROM ubuntu:latest
 ---> df5de72bdb3b
Step 2/3 : COPY foo.txt /foo.txt
 ---> Using cache
 ---> 4932aede6a15
Step 3/3 : RUN date +%Y-%m-%d > /built-on.txt
 ---> Running in 2b91ec0462c4
Removing intermediate container 2b91ec0462c4
 ---> c6647ff378c1
Successfully built c6647ff378c1
Successfully tagged demo:latest

El segundo paso de compilación se muestra como Using cache y produce el mismo ID de capa. Docker podría omitir la creación de esta capa, ya que ya se creó anteriormente y foo.txt no ha cambiado desde la primera compilación.

Este almacenamiento en caché solo funciona hasta el punto en que se modifica una capa. Todos los pasos posteriores a esa capa también deberán reconstruirse para que se basen en la nueva revisión del sistema de archivos.

Capas y operaciones de extracción

Otro beneficio de las capas es cómo permiten extraer imágenes parciales. Una vez que haya descargado algunas imágenes a su máquina, a menudo encontrará que los nuevos tirones pueden omitir algunas capas que ya tiene. Esta imagen contiene 13 capas, pero la operación de extracción solo tuvo que descargar seis:

docker pull php:8.0-apache
8.0-apache: Pulling from library/php
7a6db449b51b: Already exists 
ad2afdb99a9d: Already exists 
dbc5aa907229: Already exists 
82f252ab4ad1: Already exists 
bf5b34fc9894: Already exists 
6161651d3d95: Already exists 
cf2adf296ef1: Already exists 
f0d7c5221e44: Pull complete 
f647198f6316: Pull complete 
c37afe1da4e5: Pull complete 
09c93531cbca: Pull complete 
fef371007dd3: Pull complete 
52043dbb1c06: Pull complete 
Digest: sha256:429889e8f9eac0a806a005b0728a004303b0d49d77b09496d39158707abd6280
Status: Downloaded newer image for php:8.0-apache
docker.io/library/php:8.0-apache

Las otras capas ya estaban presentes en el host de Docker para que pudieran reutilizarse. Esto mejora el rendimiento y evita desperdiciar el ancho de banda de la red.

Inspección de capas de imagen

Puede listar las capas dentro de una imagen ejecutando el docker image history dominio. Cada capa muestra el ID de la imagen creada y la instrucción Dockerfile que provocó el cambio. También puede ver el tamaño total del contenido dentro de la capa.

$ docker image history 
IMAGE          CREATED         CREATED BY                                      SIZE      COMMENT
6f653c6a60fa   4 minutes ago   /bin/sh -c date > /built-on.txt                 29B       
f8420d1a96f3   4 minutes ago   /bin/sh -c #(nop) COPY file:a5630a7506b26a37...   0B        
df5de72bdb3b   4 weeks ago     /bin/sh -c #(nop)  CMD ["bash"]                 0B        
<missing>      4 weeks ago     /bin/sh -c #(nop) ADD file:396eeb65c8d737180...   77.8MB    

La última capa se muestra como <missing> porque se refiere a una capa dentro del ubuntu:latest imagen base Esto no está disponible localmente, ya que solo la capa final de la imagen base (df5de72bdb3b) se derriba durante las compilaciones. No es necesario extraer de forma independiente todas las capas intermedias cuando desee utilizar una imagen específica.

Resumen

Las imágenes y las capas de Docker son generalmente términos intercambiables. Una capa es una imagen y una imagen se forma a partir de una o más capas. La principal diferencia radica en las etiquetas: una imagen se etiquetará y diseñará para los usuarios finales, mientras que el término "capa" normalmente se refiere a las imágenes intermedias sin etiquetar creadas como parte de una operación de construcción. Estos no son visibles a menos que vayas a buscarlos.

Hay un tema más que se relaciona con las capas: los contenedores en ejecución agregan una capa de escritura adicional encima de su imagen. Las capas que provienen de la imagen del contenedor son de solo lectura, por lo que las modificaciones del sistema de archivos realizadas por el contenedor apuntan a su capa de escritura efímera. La capa de escritura se descarta cuando el contenedor se detiene o elimina.