HomePtNotíciaComo fazer com que o Docker reconstrua uma imagem sem seu cache

Como fazer com que o Docker reconstrua uma imagem sem seu cache

- Advertisement -


O Docker armazena em cache os resultados da criação da imagem para acelerar as reconstruções subsequentes. Embora esse mecanismo seja geralmente confiável, às vezes você desejará reconstruir uma imagem sem usar o cache. Isso pode ser feito para diagnosticar problemas ou verificar se todo o procedimento de compilação pode ser reproduzido em um ambiente limpo.

Neste artigo, você aprenderá como obter uma nova compilação sem excluir manualmente o cache. Você também verá como extrair imagens de base atualizadas para que sua compilação corresponda ao que uma nova instalação do Docker produziria.

Como funciona o cache

Aqui está um Dockerfile simples:

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

Preencha os arquivos de amostra em seu diretório de trabalho e construa a imagem:

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

A saída será semelhante a esta:

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

agora modifique 2.txt e, em seguida, reconstrua a imagem:

$ 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

A segunda etapa da construção mostra Using cache porque o conteúdo de 1.txt Eu não mudei a camada do meio com ID db61ff73c0b5 reaproveitado para novas construções.

Desativar cache

Você pode desabilitar o uso do cache da camada intermediária incluindo o --no-cache marca quando você corre 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

Desta vez, uma nova camada de imagem, ID 1590b2407dd4foi criado pelo segundo estágio de compilação, embora 1.txt permanece inalterado.

você pode usar o --no-cache marque para forçar uma reconstrução quando suspeitar que o cache está obsoleto ou se quiser começar do zero. O desempenho da compilação diminuirá porque o Docker precisará recriar cada camada.

Outra forma de armazenamento em cache refere-se às imagens base referenciadas pelo seu Dockerfile em seu FROM instruções. A imagem de exemplo acima usa alpine:latest como seu fundamento. O Docker não puxará automaticamente uma versão atualizada do alpine:latesta menos que a imagem ainda não exista em seu host.

Isso significa que a primeira compilação de um Dockerfile implantará as imagens de base necessárias, desde que ainda não as tenha. As reconstruções subsequentes não atualizarão as imagens, portanto, você pode estar construindo sobre uma base desatualizada. Construir a imagem em um host Docker diferente pode não produzir o mesmo resultado se esse host extrair uma versão mais recente da base.

Você pode forçar o Docker a verificar imagens de base atualizadas no momento da compilação adicionando o --pull bandeira para você docker build domínio. Isso é à parte --no-cache. Vestindo --pull irá recuperar o manifesto da tag de imagem do seu registro e compará-lo com a versão em sua máquina. A nova imagem será extraída do registro quando houver uma incompatibilidade nos manifestos.

$ 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

O exemplo acima mostra como a saída da compilação muda quando o --pull bandeira é usada. O Docker tenta extrair a imagem base do Alpine, mesmo que já esteja na máquina de compilações de amostra anteriores. O resumo da imagem (SHA) é impresso no terminal. Nesse caso, o resumo não muda da versão local, então o Docker informa que a imagem já está atualizada.

a --no-cache S --pull Os sinalizadores podem ser usados ​​independentemente ou em combinação. Adicioná-los a ambos dá a você o slate mais limpo para iniciar sua compilação, forçando o Docker a verificar se há imagens de base atualizadas e descartar camadas criadas anteriormente. É equivalente a executar a compilação em um host Docker recém-instalado.

Usando a composição do Docker

O Docker Compose suporta tanto o --no-cache S --pull bandeiras também. Eles têm o mesmo efeito que seus docker build homólogos

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

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

Limpar cache de compilação

Você pode limpar o cache de compilação para garantir que ele não seja usado. Isso também ajuda a liberar espaço em disco em excesso consumido pelas camadas de compilação em cache.

execute o docker builder prune comando para liberar seu cache. Ele só funciona quando você cria imagens com o moderno mecanismo de construção BuildKit.

$ docker builder prune

A execução do comando sem argumentos apenas remove o cache de compilação pendente. Isso está relacionado a caches relacionados a imagens que não estão mais presentes em seu host. Adicione o -a sinalizador para liberar completamente o cache, incluindo camadas usadas por imagens:

$ docker builder prune -a

A poda também aceita um --filter sinalizador que pode ser usado para apontar para caches modificados antes ou depois de um determinado período de tempo.

# 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

Resumo

O cache de compilação do Docker melhora o desempenho reutilizando camadas de imagem intermediárias entre as compilações. Isso evita desperdício de trabalho para recriar camadas que já existem e não foram alteradas. Embora o cache de compilação seja geralmente desejável, há cenários em que você pode querer executar uma compilação sem ele. Adicionando o --no-cache marcar suas compilações fornece uma visão precisa do que a compilação produziria quando executada em um novo host.

Imagens de base desatualizadas também devem ser consideradas junto com o cache de compilação. O Docker reutiliza versões locais de imagens de base por padrão, o que pode fazer com que você crie novas imagens sobre uma base desatualizada. Usando o --pull sinalizador força o Docker a verificar imagens de base atualizadas antes do início da compilação, oferecendo mais consistência em diferentes ambientes.

- Advertisement -
- Advertisement -
Stay Connected
16,985FansLike
2,458FollowersFollow
61,453SubscribersSubscribe
Must Read
- Advertisement -
Related News
- Advertisement -
%d bloggers like this: