Gerenciar o cache de construção com --cache-from e --cache-to
Nesta etapa, você aprenderá como gerenciar o cache de construção do Docker usando as flags --cache-from e --cache-to. O cache de construção pode acelerar significativamente as construções subsequentes, reutilizando camadas de construções anteriores. --cache-from permite que você especifique uma imagem para usar como fonte de cache, e --cache-to permite que você exporte o cache de construção para um local especificado (como um registro ou um diretório local).
Primeiro, certifique-se de estar no diretório ~/project.
cd ~/project
Vamos modificar nosso Dockerfile ligeiramente para simular uma alteração que normalmente quebraria o cache. Adicionaremos uma instrução RUN simples.
Abra o Dockerfile com nano:
nano Dockerfile
Adicione a seguinte linha após a instrução ARG no estágio builder:
RUN echo "Adding a new layer"
O Dockerfile atualizado deve ser assim:
## 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"]
Salve o Dockerfile e saia do nano.
Agora, vamos construir a imagem novamente sem usar nenhuma opção de cache específica. O Docker usará automaticamente o cache local, se disponível.
docker build -t my-cached-image .
Você deve ver que algumas camadas são construídas do zero porque adicionamos uma nova instrução, invalidando o cache para instruções subsequentes.
Agora, vamos simular um cenário em que você pode querer usar uma imagem construída anteriormente como fonte de cache, talvez de um registro ou outra construção. Para fins de demonstração, usaremos o my-cached-image que acabamos de construir como a fonte de cache para uma nova construção.
Primeiro, vamos fazer uma pequena alteração no Dockerfile novamente para simular outra modificação.
Abra o Dockerfile:
nano Dockerfile
Altere a mensagem na nova instrução RUN:
RUN echo "Adding another new layer"
O Dockerfile atualizado deve ser assim:
## 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"]
Salve e saia do nano.
Agora, construa a imagem novamente, mas desta vez use a flag --cache-from para especificar my-cached-image como a fonte de cache.
docker build --cache-from my-cached-image -t my-cached-image-from .
Você deve observar que o Docker tenta usar camadas de my-cached-image. A camada correspondente à primeira instrução RUN provavelmente será reconstruída porque a instrução foi alterada, mas as camadas subsequentes podem ser puxadas do cache se corresponderem.
A flag --cache-to é usada para exportar o cache de construção. Isso é particularmente útil em pipelines CI/CD para compartilhar o cache entre as construções. Para usar --cache-to, você normalmente precisa usar um driver de construção que suporte a exportação de cache, como o driver docker-container.
Primeiro, vamos instalar o Docker Compose, que é frequentemente usado com 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
Agora, vamos criar uma instância do construtor buildx.
docker buildx create --use
Agora, vamos construir a imagem e exportar o cache para um diretório local. Usaremos o exportador de cache local.
docker buildx build --cache-to type=local,dest=./build-cache -t my-exported-cache-image . --load
docker buildx build: Usa a ferramenta buildx para construir.--cache-to type=local,dest=./build-cache: Exporta o cache para um diretório local chamado build-cache no diretório atual.-t my-exported-cache-image: Marca a imagem resultante..: Especifica o contexto de construção (diretório atual).--load: Carrega a imagem construída no cache de imagem Docker local.
Você deve ver a saída indicando a construção e a exportação do cache. Um diretório build-cache será criado em seu diretório ~/project.
Agora, vamos simular um ambiente de construção limpo e tentar construir usando o cache exportado. Primeiro, vamos remover as imagens que construímos.
docker rmi my-cached-image my-cached-image-from my-exported-cache-image
Agora, construa a imagem novamente, desta vez usando o cache exportado como fonte.
docker buildx build --cache-from type=local,src=./build-cache -t my-imported-cache-image . --load
--cache-from type=local,src=./build-cache: Importa o cache do diretório local build-cache.
Você deve observar que o Docker usa as camadas do cache exportado, acelerando significativamente o processo de construção em comparação com a construção do zero.
