Gestionar la caché de construcción con --cache-from y --cache-to
En este paso, aprenderás a gestionar la caché de construcción de Docker usando los flags --cache-from y --cache-to. La caché de construcción puede acelerar significativamente builds posteriores al reutilizar capas de builds anteriores. --cache-from te permite especificar una imagen como fuente de caché, y --cache-to te permite exportar la caché de construcción a una ubicación específica (como un registro o directorio local).
Primero, asegúrate de estar en el directorio ~/project.
cd ~/project
Modifiquemos ligeramente nuestro Dockerfile para simular un cambio que normalmente invalidaría la caché. Añadiremos una instrucción RUN simple.
Abre el Dockerfile con nano:
nano Dockerfile
Añade la siguiente línea después de la instrucción ARG en la etapa builder:
RUN echo "Adding a new layer"
El Dockerfile actualizado debería verse así:
## Stage 1: Builder stage
FROM ubuntu:latest as builder
ARG GREETING="Hello from build argument!"
RUN echo "Adding a new layer"
RUN echo $GREETING > /app/greeting.txt
## Stage 2: Final stage
FROM ubuntu:latest
COPY --from=builder /app/greeting.txt /greeting.txt
CMD ["cat", "/greeting.txt"]
Guarda el Dockerfile y sal de nano.
Ahora, construyamos la imagen nuevamente sin usar opciones específicas de caché. Docker usará automáticamente la caché local si está disponible.
docker build -t my-cached-image .
Verás que algunas capas se construyen desde cero porque añadimos una nueva instrucción, invalidando la caché para instrucciones posteriores.
Ahora, simulemos un escenario donde quieras usar una imagen previamente construida como fuente de caché, quizás desde un registro u otro build. Para demostración, usaremos my-cached-image como fuente de caché para un nuevo build.
Primero, hagamos otro pequeño cambio al Dockerfile para simular otra modificación.
Abre el Dockerfile:
nano Dockerfile
Cambia el mensaje en la instrucción RUN nueva:
RUN echo "Adding another new layer"
El Dockerfile actualizado debería verse así:
## Stage 1: Builder stage
FROM ubuntu:latest as builder
ARG GREETING="Hello from build argument!"
RUN echo "Adding another new layer"
RUN echo $GREETING > /app/greeting.txt
## Stage 2: Final stage
FROM ubuntu:latest
COPY --from=builder /app/greeting.txt /greeting.txt
CMD ["cat", "/greeting.txt"]
Guarda y sal de nano.
Ahora, construye la imagen nuevamente, pero esta vez usa el flag --cache-from para especificar my-cached-image como fuente de caché.
docker build --cache-from my-cached-image -t my-cached-image-from .
Observarás que Docker intenta usar capas de my-cached-image. La capa correspondiente a la primera instrucción RUN probablemente se reconstruirá porque la instrucción cambió, pero capas posteriores podrían tomarse de la caché si coinciden.
El flag --cache-to se usa para exportar la caché de construcción. Esto es particularmente útil en pipelines CI/CD para compartir caché entre builds. Para usar --cache-to, normalmente necesitas un controlador de construcción que soporte exportación de caché, como el controlador docker-container.
Primero, instalemos Docker Compose, que se usa frecuentemente con buildx.
sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
Ahora, creemos una instancia de constructor buildx.
docker buildx create --use
Ahora, construyamos la imagen y exportemos la caché a un directorio local. Usaremos el exportador de caché local.
docker buildx build --cache-to type=local,dest=./build-cache -t my-exported-cache-image . --load
docker buildx build: Usa la herramienta buildx para construir--cache-to type=local,dest=./build-cache: Exporta la caché a un directorio local llamado build-cache-t my-exported-cache-image: Etiqueta la imagen resultante.: Especifica el contexto de construcción (directorio actual)--load: Carga la imagen construida en la caché local de Docker
Verás una salida indicando la construcción y exportación de caché. Se creará un directorio build-cache en tu directorio ~/project.
Ahora, simulemos un entorno de construcción limpio e intentemos construir usando la caché exportada. Primero, eliminemos las imágenes construidas.
docker rmi my-cached-image my-cached-image-from my-exported-cache-image
Ahora, construye la imagen nuevamente, esta vez usando la caché exportada como fuente.
docker buildx build --cache-from type=local,src=./build-cache -t my-imported-cache-image . --load
--cache-from type=local,src=./build-cache: Importa la caché del directorio local build-cache
Observarás que Docker usa las capas de la caché exportada, acelerando significativamente el proceso de construcción comparado con construir desde cero.
