Aproveitando o Cache de Criação

Criar imagens do Docker pode levar algum tempo, especialmente no caso de aplicações complexas. O cache de compilação do Docker é um recurso inteligente que ajuda a acelerar esse processo significativamente!

Ele funciona reutilizando camadas de compilações anteriores, para que o Docker não precise recriar tudo do zero sempre.

Quando cria uma imagem do Docker usando um Dockerfile, o Docker executa cada instrução linha por linha.

• Cada instrução, como FROM, RUN ou COPY, cria uma nova "camada" na sua imagem.
• Essas camadas são empilhadas umas sobre as outras para formar a imagem final.

Antes de executar uma instrução, o Docker verifica se já criou exatamente essa camada antes. Ele compara:

• A própria instrução (por exemplo, RUN apt update).
• O "contexto" de determinadas instruções (por exemplo, os arquivos que estão sendo copiados com COPY).

Se uma camada correspondente for encontrada, o Docker a reutiliza do cache em vez de executar a instrução novamente.

O cache é excelente, mas nem sempre é utilizado. Se o Docker detectar qualquer alteração em uma instrução ou no contexto dela, o cache dessa camada e de todas as camadas seguintes será invalidado.

Isso significa que o Docker recriará a partir desse ponto, ignorando todas as camadas armazenadas em cache abaixo dele.

Para maximizar os acertos do cache, organize as instruções do seu Dockerfile da menos propensa a mudar para a mais propensa a mudar.

• Dependências estáveis primeiro: Instale pacotes do sistema ou dependências da aplicação que mudam com pouca frequência.
• Código da aplicação por último: Copie o código-fonte da sua aplicação, que muda com frequência, o mais tarde possível.

Vamos analisar um exemplo. Ao colocar o comando RUN pip install (que normalmente muda com menos frequência) antes de COPY . . (que muda a cada atualização do código), o Docker pode reutilizar a camada de dependências.

Imagine que requirements.txt contenha flask e gunicorn, e que app.py seja a sua aplicação principal.

Dockerfile:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
CMD ["python", "app.py"]

Se apenas app.py mudar, o Docker recriará somente as últimas camadas COPY e CMD, economizando tempo!

Quando usa COPY . ., o Docker verifica todos os arquivos no contexto da compilação em busca de alterações. Até mesmo arquivos pequenos e irrelevantes (como pastas .git ou dados de teste locais) podem invalidar o cache.

Use um arquivo .dockerignore para excluir arquivos e diretórios desnecessários do contexto da compilação. Isso impede que eles provoquem invalidações do cache.

Coloque um arquivo chamado .dockerignore na raiz do contexto da compilação (ao lado do seu Dockerfile).

Exemplo de .dockerignore:

.git
.venv
__pycache__
*.log
node_modules

Agora, quando usar COPY . ., o Docker ignorará esses arquivos, resultando em acertos do cache mais confiáveis!

Às vezes, pode querer garantir que tudo seja compilado novamente, ignorando totalmente o cache. Isso pode ser útil para depuração ou para garantir que tenha as versões mais recentes possíveis das dependências.

Pode forçar o Docker a recriar a imagem sem usar o cache adicionando a opção --no-cache ao comando de compilação:

docker build --no-cache -t my-app:latest .

Está criando uma imagem do Docker para uma aplicação Node.js. Atualmente, o seu Dockerfile é assim:

FROM node:16-alpine
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

Qual alteração otimizaria melhor este Dockerfile para o armazenamento em cache da compilação?

Excelente trabalho! Aprendeu a aproveitar o cache de compilação do Docker para criar imagens mais rapidamente.

• O Docker cria imagens camada por camada, reutilizando as camadas armazenadas em cache quando possível.
• Alterações em uma instrução ou no contexto dela invalidam o cache a partir desse ponto.
• Otimize ordenando as instruções da menos propensa à alteração para a mais propensa.
• Use .dockerignore para excluir arquivos irrelevantes do contexto da compilação.
• Use --no-cache para forçar uma compilação do zero quando necessário.

O uso eficiente do cache resulta em ciclos de desenvolvimento mais rápidos e implantações mais ágeis!