Compilaciones multietapa para mejorar la eficiencia

¡Bienvenido a la optimización avanzada de Dockerfile! Hoy exploraremos las compilaciones multietapa, una técnica potente para crear imágenes de Docker más pequeñas y eficientes.

Las imágenes más pequeñas se descargan más rápido, ofrecen mayor seguridad y aprovechan mejor los recursos.

Al compilar una imagen de Docker, a menudo se incluyen herramientas y dependencias que solo se necesitan durante el proceso de compilación, no durante la ejecución final de la aplicación.

• Descargas más rápidas: Las imágenes pequeñas se descargan más rápido.
• Menos espacio en disco: Se ahorra almacenamiento en los registros y los hosts.
• Menor superficie de ataque: Menos componentes implican menos vulnerabilidades potenciales.
• Mayor seguridad: La imagen de producción solo contiene lo esencial.

Considere una aplicación compilada, como una escrita en Go. Un Dockerfile tradicional de una sola etapa incluiría todo el compilador de Go y las dependencias de desarrollo en la imagen final.

Esto hace que la imagen final sea mucho más grande de lo necesario, ya que el compilador no se necesita para ejecutar el binario compilado.

A continuación se muestra una aplicación sencilla de Go y un Dockerfile que la compila en una sola etapa. Observe que el entorno de compilación se incluye en la imagen final.

main.go:

Este Dockerfile utiliza `golang:1.21-alpine` como base. Después de compilar la aplicación, esta imagen base de gran tamaño, junto con todas sus herramientas de compilación, permanece en la imagen final.

Las compilaciones multietapa resuelven este problema al permitir definir varias instrucciones `FROM` en un solo Dockerfile. Cada `FROM` inicia una nueva etapa de compilación.

• Utilice la palabra clave AS para asignar un nombre a una etapa (por ejemplo, FROM golang:1.21-alpine AS builder).
• A continuación, puede copiar artefactos de una etapa anterior mediante COPY --from=<stage_name>.

Solo la etapa final se guarda como imagen.

Un Dockerfile multietapa típico tiene al menos dos etapas:

• Etapa de compilación: Contiene todas las herramientas y el código fuente necesarios para compilar la aplicación.
• Etapa de ejecución: Una imagen base mínima que solo incluye la aplicación compilada y sus dependencias de ejecución.

La imagen intermedia de la etapa de compilación se descarta, dejando una imagen final ligera.

Reescribamos el Dockerfile de nuestra aplicación de Go mediante un enfoque multietapa. Compilaremos la aplicación en la primera etapa y, después, copiaremos únicamente el binario compilado a una imagen base `alpine` mucho más pequeña.

Al compilar este Dockerfile, Docker ejecuta cada etapa. Sin embargo, solo el contenido de la última instrucción `FROM`, combinado con los archivos copiados de las etapas anteriores, forma la imagen final.

El resultado es una imagen considerablemente más pequeña que la de una compilación de una sola etapa, ya que el compilador de Go y las herramientas de compilación se quedan atrás.

Las compilaciones multietapa son especialmente útiles para:

• Lenguajes compilados: Go, Java, C++ y Rust.
• Frameworks de frontend: Compilar aplicaciones de React o Angular y servir recursos estáticos con Nginx.
• Aplicaciones de Node.js: Instalar `node_modules` en una etapa de compilación y copiar después únicamente `package.json`, `package-lock.json` y la aplicación compilada a una imagen de ejecución ligera.

¿Cuáles de las siguientes son las principales ventajas de utilizar compilaciones multietapa de Docker?

¡Ha aprendido sobre las compilaciones multietapa de Docker!

• Implican varias instrucciones FROM en un solo Dockerfile.
• La palabra clave AS asigna nombres a las etapas, y COPY --from= transfiere artefactos.
• La principal ventaja son unas imágenes finales mucho más pequeñas, seguras y eficientes.

Esta técnica es fundamental para optimizar sus aplicaciones contenerizadas. A continuación, veremos cómo aprovechar la caché de compilación.