Capas y optimización de imágenes

Las imágenes de Docker no son un único archivo enorme. En su lugar, se construyen a partir de una serie de capas de solo lectura. Imagine estas capas como transparencias apiladas.

Cada capa representa un cambio en la imagen, lo que hace que las imágenes sean eficientes y flexibles. Esta estructura en capas es fundamental para el funcionamiento de Docker.

Cuando escribe un Dockerfile, casi todas las instrucciones crean una capa nueva sobre la anterior. Instrucciones como FROM, RUN, COPY y ADD contribuyen a crear nuevas capas.

Docker ejecuta estas instrucciones secuencialmente y crea cada capa nueva a partir del estado de la anterior.

Puede ver las capas que componen una imagen mediante el comando docker history. Este comando muestra cada instrucción, su tamaño y cuándo se creó, lo que le ayuda a comprender cómo creció la imagen.

Es una herramienta muy útil para depurar problemas relacionados con el tamaño de las imágenes.

Docker utiliza una caché de compilación inteligente. Si una instrucción de su Dockerfile y su contexto (por ejemplo, los archivos que se copian) no han cambiado desde la última compilación, Docker reutiliza la capa existente.

Esta reutilización acelera considerablemente las compilaciones posteriores, ya que Docker no necesita volver a ejecutar los pasos que no han cambiado.

El orden de las instrucciones en su Dockerfile es crucial para aprovechar la caché. Coloque al principio las instrucciones que cambian con poca frecuencia (como la instalación de dependencias del sistema).

Las instrucciones que cambian a menudo (como la copia del código de la aplicación) deben colocarse más abajo. De este modo, si solo cambia el código, Docker puede reutilizar las capas en caché correspondientes a las dependencias estables.

Compare estos dos fragmentos de Dockerfile. El orden correcto coloca primero las dependencias estables, lo que permite que Docker las almacene en caché y solo vuelva a crear las capas correspondientes al código de la aplicación que cambia.

Cada comando RUN suele crear una capa nueva. Puede reducir el número de capas y, a menudo, el tamaño final de la imagen combinando varios comandos en una sola instrucción RUN.

Utilice el operador && \ para encadenar comandos y convertirlos en parte de una única capa atómica.

En lugar de utilizar varios comandos RUN, encadénelos con && \. Así creará una única capa más eficiente para todas estas operaciones.

Limpie siempre los archivos que solo sean necesarios durante el proceso de compilación. Por ejemplo, las cachés de los gestores de paquetes (como apt-get clean) o los artefactos temporales de compilación pueden aumentar considerablemente el tamaño de las capas de la imagen.

Limpiarlos dentro del mismo comando RUN que los creó garantiza que no persistan en una capa anterior.

Considere el siguiente fragmento de Dockerfile:

FROM alpine:latest
COPY . /app
RUN apk add --no-cache git
RUN apk add --no-cache make
CMD ["sh"]

¿Cuál de los siguientes cambios optimizaría mejor este Dockerfile para reducir el tamaño de la imagen y posiblemente acelerar las reconstrucciones?

Ha aprendido que las imágenes de Docker se construyen en capas y que cada instrucción suele crear una nueva. Comprender esto es fundamental para optimizarlas.

• Ordene las instrucciones cuidadosamente para maximizar los aciertos de la caché de compilación.
• Combine varios comandos RUN en uno para reducir el número de capas.
• Limpie los archivos temporales dentro de los comandos RUN correspondientes para mantener las capas pequeñas.

Estas técnicas ayudan a crear imágenes de Docker más pequeñas y rápidas de compilar, esenciales para realizar implementaciones eficientes.