Camadas e Otimização de Imagens

As imagens Docker não são um único arquivo gigantesco. Em vez disso, elas são formadas por uma série de camadas somente leitura. Pense nessas camadas como transparências empilhadas.

Cada camada representa uma alteração na imagem, tornando as imagens eficientes e flexíveis. Essa estrutura em camadas é fundamental para o funcionamento do Docker.

Ao escrever um Dockerfile, quase toda instrução cria uma nova camada sobre a anterior. Instruções como FROM, RUN, COPY e ADD contribuem para a criação de novas camadas.

O Docker executa essas instruções sequencialmente, criando cada nova camada com base no estado da anterior.

Você pode ver as camadas que compõem uma imagem usando o comando docker history. Esse comando mostra cada instrução, seu tamanho e quando ela foi criada, ajudando você a entender como a imagem cresceu.

Essa é uma ferramenta poderosa para investigar problemas relacionados ao tamanho da imagem.

O Docker usa um cache de criação inteligente. Se uma instrução do seu Dockerfile e o contexto correspondente (por exemplo, os arquivos que estão sendo copiados) não tiverem mudado desde a última criação, o Docker reutilizará a camada existente.

Essa reutilização acelera significativamente as criações seguintes, pois o Docker não precisa executar novamente as etapas que não foram alteradas.

A ordem das instruções no seu Dockerfile é fundamental para um armazenamento em cache eficiente. Coloque no início as instruções que mudam com pouca frequência (como a instalação de dependências do sistema).

As instruções que mudam frequentemente (como a cópia do código do aplicativo) devem ficar mais abaixo. Assim, se apenas o código mudar, o Docker poderá reutilizar as camadas armazenadas em cache para as dependências estáveis.

Compare estes dois trechos de Dockerfile. A ordem adequada coloca primeiro as dependências estáveis, permitindo que o Docker as armazene em cache e recrie apenas as camadas do código do aplicativo que muda.

Cada comando RUN normalmente cria uma nova camada. Você pode reduzir o número de camadas e, muitas vezes, o tamanho final da imagem combinando vários comandos em uma única instrução RUN.

Use o operador && \ para encadear comandos, fazendo com que eles façam parte de uma única camada atômica.

Em vez de usar vários comandos RUN, encadeie-os com && \. Isso cria uma única camada mais eficiente para todas essas operações.

Sempre limpe os arquivos necessários apenas durante o processo de criação. Por exemplo, caches do gerenciador de pacotes (como apt-get clean) ou artefatos temporários de criação podem aumentar significativamente o tamanho das camadas da sua imagem.

Limpá-los dentro do mesmo comando RUN que os criou garante que eles não persistam em uma camada anterior.

Considere o seguinte trecho de Dockerfile:

FROM alpine:latest
COPY . /app
RUN apk add --no-cache git
RUN apk add --no-cache make
CMD ["sh"]

Qual das alterações a seguir otimizaria melhor este Dockerfile para reduzir o tamanho da imagem e potencialmente acelerar novas criações?

Você aprendeu que as imagens Docker são criadas em camadas, e que cada instrução normalmente cria uma nova camada. Entender isso é essencial para a otimização!

• Organize as instruções cuidadosamente para maximizar os acertos do cache de criação.
• Combine vários comandos RUN em um só para reduzir o número de camadas.
• Limpe os arquivos temporários dentro dos respectivos comandos RUN para manter as camadas pequenas.

Essas técnicas ajudam a criar imagens Docker menores e mais rápidas de criar, essenciais para implantações eficientes.