Como funcionam as camadas de imagem Docker e o cache de build?

Question

IT Interview Practice · Accepted Answer

As imagens Docker são construídas em **camadas** — cada instrução do Dockerfile cria uma camada, e Docker **armazena em cache** as camadas para acelerar reconstruções. Entender camadas e cache é fundamental para escrever Dockerfiles eficientes que constroem rapidamente e produzem imagens menores.

## Camadas — cada instrução adiciona uma camada

```text
Each Dockerfile instruction (FROM, RUN, COPY, etc.) creates a read-only LAYER:
  → layers stack to form the image; layers are CACHED and SHARED between images
  → if a layer is unchanged, Docker REUSES the cached layer (skips rebuilding it)
→ Layer caching makes rebuilds fast — only changed layers (and those AFTER) rebuild.
```

## A regra de cache (ordem importa)

```text
Docker caches layers IN ORDER. When an instruction's input changes, that layer AND
ALL layers AFTER IT are rebuilt (cache invalidated from that point down).
→ Put STABLE things EARLY and FREQUENTLY-CHANGING things LATE in the Dockerfile.
```

## A otimização clássica: dependências antes do código

```dockerfile
# ✅ GOOD — copy dependency manifest first, install, THEN copy code
COPY package*.json ./
RUN npm install          # this layer is cached UNLESS package.json changes
COPY . .                 # code changes here don't invalidate the npm install layer

# ❌ BAD — copy everything first
COPY . .                 # ANY code change invalidates...
RUN npm install          # ...so npm install RE-RUNS on every code change (slow!)
```

Ao copiar arquivos de dependência e instalar **antes** de copiar o resto do código, a camada (lenta) de instalação de dependências permanece em cache através de mudanças de código — uma otimização extremamente importante que torna as reconstruções rápidas.

## Reduzindo o tamanho da imagem

```text
✓ Combine related RUN commands (fewer layers) and clean up in the SAME layer
  RUN apt-get update && apt-get install -y x && rm -rf /var/lib/apt/lists/*
✓ Use small base images (alpine, slim, distroless)
✓ Use .dockerignore to exclude unneeded files from the build context
✓ Use multi-stage builds (build artifacts in one stage, copy only what's needed)
```

## Por que isso importa

Entender camadas Docker e cache de build é importante para **escrever Dockerfiles eficientes** que constroem rapidamente e produzem imagens menores, então é conhecimento prático valioso que afeta significativamente a produtividade do desenvolvedor e a implantação.

O conceito fundamental — cada instrução do Dockerfile cria uma **camada** armazenada em cache e reutilizável, e Docker **reutiliza camadas em cache inalteradas** enquanto reconstrói camadas alteradas e tudo após elas — explica como tornar os builds rápidos.

A **regra de cache crítica** (o cache é invalidado a partir da primeira instrução alterada para baixo, então a ordem importa: coisas estáveis no início, coisas que mudam frequentemente no final) orienta a **otimização mais importante**: copiar arquivos de dependência e instalar dependências **antes** de copiar o código da aplicação, de modo que a camada lenta de instalação de dependências permaneça em cache através de mudanças frequentes de código (em vez de executar `npm install`/`pip install` em cada mudança de código — uma diferença entre builds rápidos e reconstruções dolorosamente lentas).

Entender esse padrão sozinho melhora dramaticamente os tempos de build, uma preocupação constante com a experiência do desenvolvedor.

Conhecer técnicas para **reduzir o tamanho da imagem** — combinar comandos RUN com limpeza na mesma camada, usar imagens base pequenas (alpine, slim, distroless), `.dockerignore` para excluir arquivos desnecessários, e builds multi-stage — produz imagens menores e mais rápidas para implantar (reduzindo armazenamento, tempo de transferência e superfície de ataque).

Como builds Docker acontecem constantemente (em desenvolvimento e CI/CD) e builds lentos ou imagens inchadas prejudicam a produtividade e implantação, e como entender camadas e cache é o que permite escrever Dockerfiles que constroem rapidamente e permanecem pequenos, entender camadas e cache Docker — o modelo de camadas, a regra de cache dependente de ordem, a otimização de dependências-antes-de-código, e técnicas de redução de tamanho — é conhecimento valioso e frequentemente aplicado para uso eficiente de Docker, uma habilidade fundamental que distingue aqueles que escrevem Dockerfiles rápidos e enxutos daqueles que sofrem com builds lentos e imagens inchadas.

Camadas — cada instrução adiciona uma camada

A regra de cache (ordem importa)

A otimização clássica: dependências antes do código

Reduzindo o tamanho da imagem

Por que isso importa

Perguntas relacionadas