Cómo hacer que Docker reconstruya una imagen sin su caché

Docker almacena en caché los resultados de la creación de imágenes para acelerar las reconstrucciones posteriores. Si bien este mecanismo generalmente es confiable, a veces querrá reconstruir una imagen sin usar el caché. Esto podría ser para diagnosticar problemas o verificar que el procedimiento de compilación completo sea reproducible en un entorno limpio.

En este artículo, aprenderá cómo lograr una compilación nueva sin eliminar manualmente el caché. También verá cómo extraer imágenes base actualizadas para que su compilación coincida con el resultado que produciría una nueva instalación de Docker.

Cómo funciona el caché

Aquí hay un Dockerfile simple:

FROM alpine:latest
COPY 1.txt /1.txt
COPY 2.txt /2.txt

Complete los archivos de muestra en su directorio de trabajo y cree la imagen:

$ echo 1 > 1.txt
$ echo 2 > 2.txt
$ docker build -t demo:latest .

La salida se verá similar a esto:

Sending build context to Docker daemon   5.12kB
Step 1/3 : FROM alpine:latest
 ---> 9c6f07244728
Step 2/3 : COPY 1.txt /1.txt
 ---> db61ff73c0b5
Step 3/3 : COPY 2.txt /2.txt
 ---> f1129e47fc12
Successfully built f1129e47fc12
Successfully tagged demo:latest

Ahora modifica 2.txt y luego reconstruir la imagen:

$ echo two > 2.txt
$ docker build -t demo:latest .
Sending build context to Docker daemon   5.12kB
Step 1/3 : FROM alpine:latest
 ---> 9c6f07244728
Step 2/3 : COPY 1.txt /1.txt
 ---> Using cache
 ---> db61ff73c0b5
Step 3/3 : COPY 2.txt /2.txt
 ---> 75ba7d786049
Successfully built 75ba7d786049
Successfully tagged demo:latest

La segunda etapa de construcción muestra Using cache porque el contenido de 1.txt no he cambiado La capa intermedia con ID db61ff73c0b5 se reutiliza para la nueva construcción.

Deshabilitar el caché

Puede deshabilitar el uso de la caché de la capa intermedia al incluir el --no-cache marca cuando corres docker build:

$ echo second > 2.txt
$ docker build --no-cache -t demo:latest .
Sending build context to Docker daemon   5.12kB
Step 1/3 : FROM alpine:latest
 ---> 9c6f07244728
Step 2/3 : COPY 1.txt /1.txt
 ---> 1590b2407dd4
Step 3/3 : COPY 2.txt /2.txt
 ---> afb31630ce32
Successfully built afb31630ce32
Successfully tagged demo:latest

Esta vez una nueva capa de imagen, ID 1590b2407dd4ha sido creado por la segunda etapa de compilación, aunque 1.txt permanece sin modificar.

Puedes usar el --no-cache marcar para forzar una reconstrucción cuando sospeche que el caché está obsoleto o si desea comenzar desde cero. El rendimiento de la compilación se reducirá porque Docker necesitará recrear cada capa.

Extracción de imágenes base actualizadas

Otra forma de almacenamiento en caché se refiere a las imágenes base a las que hace referencia su Dockerfile en su FROM instrucciones. La imagen de ejemplo de arriba usa alpine:latest como su base. Docker no extraerá automáticamente una versión actualizada de alpine:latesta menos que la imagen aún no exista en su host.

Esto significa que la primera compilación de un Dockerfile desplegará las imágenes base que necesita, siempre que no las tenga. Las reconstrucciones posteriores no actualizarán las imágenes, por lo que podría estar construyendo sobre una base obsoleta. Es posible que la creación de la imagen en un host de Docker diferente no produzca el mismo resultado si ese host extrae una versión más nueva de la base.

Puede obligar a Docker a buscar imágenes base actualizadas en el momento de la compilación agregando el --pull bandera a tu docker build dominio. Esto es aparte de --no-cache. Usando --pull recuperará el manifiesto de la etiqueta de imagen de su registro y lo comparará con la versión en su máquina. La nueva imagen se extraerá del registro cuando haya una discrepancia en los manifiestos.

$ docker build --no-cache --pull -t demo:latest .
Sending build context to Docker daemon   5.12kB
Step 1/3 : FROM alpine:latest
latest: Pulling from library/alpine
Digest: sha256:bc41182d7ef5ffc53a40b044e725193bc10142a1243f395ee852a8d9730fc2ad
Status: Image is up to date for alpine:latest
 ---> 9c6f07244728
Step 2/3 : COPY 1.txt /1.txt
 ---> 4fee970dfaab
Step 3/3 : COPY 2.txt /2.txt
 ---> 60d2e3fff0fb
Successfully built 60d2e3fff0fb
Successfully tagged demo:latest

El ejemplo anterior muestra cómo cambia la salida de compilación cuando el --pull se utiliza la bandera. Docker intenta extraer la imagen base de Alpine, aunque ya está en la máquina de las compilaciones de ejemplo anteriores. El resumen de imagen (SHA) se imprime en el terminal. En este caso, el resumen no cambia con respecto a la versión local, por lo que Docker informa que la imagen ya está actualizada.

los --no-cache y --pull Las banderas se pueden utilizar de forma independiente o en combinación. Agregarlos a ambos le brinda la pizarra más limpia para comenzar su compilación, lo que obliga a Docker a buscar imágenes base actualizadas y descartar las capas creadas previamente. Es equivalente a ejecutar la compilación en un host Docker recién instalado.

Uso de composición de Docker

Docker Compose admite tanto el --no-cache y --pull banderas también. Tienen el mismo efecto que sus docker build contrapartes

# Compose v2
$ docker compose build --no-cache --pull

# Compose v1
$ docker-compose build --no-cache --pull

Limpieza de la caché de compilación

Puede limpiar el caché de compilación para garantizar que no se use. Esto también ayuda a liberar el exceso de espacio en disco consumido por las capas de compilación almacenadas en caché.

ejecutar el docker builder prune comando para vaciar su caché. Solo funciona cuando crea imágenes con el moderno motor de compilación BuildKit.

$ docker builder prune

Ejecutar el comando sin argumentos solo elimina el caché de compilación pendiente. Esto se relaciona con cachés que se relacionan con imágenes que ya no están presentes en su host. Añade el -a bandera para vaciar completamente el caché, incluidas las capas que utilizan las imágenes:

$ docker builder prune -a

La poda también acepta una --filter indicador que se puede usar para apuntar a cachés modificados antes o desde un período de tiempo particular.

# Delete caches modified in the past two hours
$ docker build prune --filter since=2h

# Delete caches modified more than two hours ago
$ docker build prune --filter until=2h

Resumen

La memoria caché de compilación de Docker mejora el rendimiento mediante la reutilización de capas de imágenes intermedias entre compilaciones. Esto evita el trabajo desperdiciado para recrear capas que ya existen y no han cambiado. Si bien la caché de compilación generalmente es deseable, hay escenarios en los que es posible que desee ejecutar una compilación sin ella. Agregando el --no-cache marca a sus compilaciones proporciona una perspectiva precisa de lo que produciría la compilación cuando se ejecuta en un nuevo host.

Las imágenes base obsoletas también deben considerarse junto con la caché de compilación. Docker reutiliza las versiones locales de las imágenes base de forma predeterminada, lo que puede hacer que construyas nuevas imágenes sobre una base obsoleta. Utilizando el --pull flag obliga a Docker a verificar si hay imágenes base actualizadas antes de que comience la compilación, lo que le brinda una mayor coherencia en diferentes entornos.