Pular para o conteúdo
15 min de leitura

Imagens de Container do Zero: scratch, distroless e Multi-Stage sem Gordura

Compartilhar

Por Equipe Nebular ·

Por que imagens menores são mais seguras e rápidas: multi-stage builds, base scratch e distroless, superfície de ataque e o custo real de um shell na imagem.

Neste artigo

Quando você digita FROM ubuntu no topo de um Dockerfile, não está trazendo apenas um lugar para o seu binário morar. Está herdando um sistema operacional inteiro: um shell interativo, um gerenciador de pacotes, dezenas de utilitários de linha de comando, bibliotecas compartilhadas que nenhuma linha do seu código jamais vai chamar e um histórico de CVEs que se acumula a cada dia que passa sem um rebuild. A imagem final pode ter 200, 400, 800 megabytes — e a esmagadora maioria desse peso é composta de coisas que existem para a conveniência de um humano operando um servidor, não para servir requisições HTTP.

O minimalismo de imagem é a disciplina de reverter esse padrão. Em vez de partir de um sistema completo e tentar remover o que sobra, você parte do vazio e adiciona apenas o estritamente necessário para o processo rodar. O resultado não é só uma imagem que baixa mais rápido — é uma imagem com uma superfície de ataque radicalmente menor, menos itens para escanear, menos pacotes para atualizar e muito menos ferramentas úteis para quem eventualmente conseguir executar código dentro do container. Este guia trata exatamente disso: scratch, distroless, multi-stage builds e a economia real de tirar a gordura da imagem.

O ponto de partida é entender que cada byte dentro de uma imagem é uma decisão de segurança, não apenas de performance. Uma imagem enxuta é um artefato mais previsível, mais auditável e mais barato de operar ao longo de meses de produção. Vamos construir esse raciocínio da base até as recomendações práticas por linguagem.

Por que o tamanho e o conteúdo importam além de "puxa mais rápido"

A justificativa preguiçosa para imagens pequenas é a velocidade de pull e o consumo de disco no registro. Isso é verdade, mas é o argumento menos interessante. O que realmente pesa é que cada binário, cada biblioteca compartilhada e cada script dentro da imagem é superfície de ataque e é um CVE em potencial. Um scanner de vulnerabilidades como o Trivy ou o Grype não sabe se você usa aquele libxml2 desatualizado — ele apenas reporta que o pacote está presente e que existe uma vulnerabilidade conhecida associada a ele. Cada pacote que você não precisava traz consigo o risco de aparecer numa lista de CVEs no meio da noite, disparar um alerta e obrigar um rebuild emergencial de uma coisa que a sua aplicação nunca sequer carregou na memória.

Há um efeito composto aqui. Imagem gorda significa mais coisa para escanear em cada pipeline, mais coisa para manter atualizada quando um CVE aparece e mais coisa capaz de vazar informação ou dar alavanca a um atacante. Uma base Debian completa costuma reportar dezenas de vulnerabilidades conhecidas em qualquer varredura, a maioria em pacotes que a sua aplicação jamais invoca. Você acaba gastando tempo de engenharia triando CVEs de perl, apt e bash numa imagem cujo único trabalho é servir JSON. O minimalismo elimina essa classe inteira de trabalho: o que não está na imagem não pode ser vulnerável, não precisa ser escaneado e não precisa ser corrigido.

Existe também a dimensão da imutabilidade e da reprodutibilidade. Uma imagem pequena, montada a partir de um artefato único e bem definido, é muito mais fácil de raciocinar. Você sabe exatamente o que está lá dentro. Numa imagem com sistema completo, a fronteira entre "o que eu coloquei" e "o que veio junto" se dissolve, e é justamente nessa névoa que os problemas de segurança e de compliance se escondem.

A imagem base cheia é uma caixa de ferramentas para o atacante

Vale detalhar o que exatamente vem numa base ubuntu ou debian e por que isso é perigoso. Além das bibliotecas de sistema, você recebe um shell (bash, sh), um gerenciador de pacotes (apt, dpkg), e utilitários de rede e arquivo como curl, wget, nc, tar, find e chmod. Para o desenvolvedor, essa é a caixa de ferramentas do dia a dia. Para um atacante que conseguiu executar código dentro do seu container — via uma falha de deserialização, um SSRF que virou RCE, uma injeção qualquer — essa mesma caixa de ferramentas é o kit de movimentação lateral.

O padrão de ataque pós-comprometimento depende quase sempre dessas ferramentas. O invasor usa curl ou wget para baixar um segundo estágio de payload, usa o shell para encadear comandos, usa o gerenciador de pacotes para instalar o que faltar, usa nc para abrir um túnel reverso. Tire tudo isso da imagem e você não fecha todas as portas, mas encarece brutalmente cada passo. Um container onde não existe sh, não existe curl e não existe interpretador nenhum força o atacante a carregar suas próprias ferramentas — o que é mais barulhento, mais difícil e muito mais detectável. Reduzir a imagem é, na prática, uma forma de negar recursos ao adversário depois que a primeira linha de defesa falhou.

Multi-stage build: separar a fábrica do produto

A ferramenta que torna tudo isso viável é o multi-stage build. A ideia é conceitualmente simples e transforma a economia da imagem por completo. Você declara dois (ou mais) estágios no mesmo Dockerfile. O primeiro estágio, o de build, é onde mora toda a bagunça necessária para compilar e testar: o compilador, as bibliotecas de desenvolvimento, os headers, o cache de dependências, os frameworks de teste. Esse estágio pode ser gordo à vontade, porque ele não vai a lugar nenhum. O segundo estágio, o final, parte de uma base minúscula e recebe, via instrução de cópia entre estágios, apenas o artefato pronto: o binário compilado, ou o bundle da aplicação.

O ganho é duplo. Primeiro, o tamanho despenca, porque todo o toolchain de compilação — que costuma ser a maior parte do peso — simplesmente não existe na imagem final. Segundo, e mais importante do ponto de vista de segurança, você remove as ferramentas de build do ambiente de produção. Compilador em produção é ferramenta para o atacante; pacote de desenvolvimento em produção é superfície de ataque a mais. Com multi-stage, o go build ou o cargo build acontece no estágio descartável, e o que chega ao runtime é só o resultado, limpo de qualquer coisa que serviu para produzi-lo.

Um detalhe que amplifica o valor do multi-stage é a possibilidade de usar o próprio estágio de build para rodar os testes e as verificações de qualidade. O estágio intermediário tem tudo o que precisa para isso, e um build que falha no teste nunca produz a imagem final. Assim, o mesmo mecanismo que enxuga a imagem também serve de portão de qualidade — a linha de montagem valida o produto antes de embarcá-lo, e a fábrica inteira fica de fora da caixa que sai pela porta.

scratch: partir do vazio absoluto

No extremo do minimalismo está a base scratch. Ela não é uma imagem no sentido usual — é a ausência de imagem, um ponto de partida completamente vazio, sem nenhum sistema operacional, nenhum arquivo, nenhuma biblioteca. Você copia o seu binário para dentro e é só isso que existe. Para linguagens que compilam para binários estáticos, como Go e Rust, scratch é o destino natural: o binário carrega dentro de si tudo de que precisa, então não há por que arrastar um sistema junto.

O preço de partir do vazio é que você perde uma série de coisas que normalmente dá como garantidas. Não há shell, então esqueça docker exec para dar uma olhada. Não há certificados de autoridade certificadora, então qualquer chamada HTTPS de saída vai falhar na validação do certificado a menos que você copie o pacote ca-certificates explicitamente para dentro da imagem. Não há arquivo /etc/passwd nem /etc/group, o que complica rodar como usuário nomeado. Não há dados de fuso horário (tzdata), então formatação de datas dependente de timezone se comporta de forma inesperada. E não há resolvedor de nomes configurado da forma habitual, o que às vezes esbarra em particularidades de resolução DNS.

A boa notícia é que cada uma dessas ausências tem solução limpa e explícita, e a disciplina de resolvê-las uma a uma é justamente o que torna a imagem auditável. Você copia o ca-certificates.crt a partir do estágio de build. Você cria um usuário não-root não pela ferramenta de gerenciamento de usuários — que não existe — mas apontando o processo para rodar sob um UID numérico direto, algo como um identificador alto e sem privilégios definido na instrução que declara o usuário do container. Você copia o tzdata se precisar. O resultado é uma imagem que muitas vezes tem só alguns megabytes, contém exatamente um binário mais um punhado de arquivos de suporte, e não oferece absolutamente nada a quem tente explorá-la por dentro.

distroless: o meio-termo com runtime, mas sem shell

Nem toda aplicação compila para um binário estático. Java precisa de uma JVM, Python precisa do interpretador e das bibliotecas compartilhadas, Node precisa do runtime do V8. Para esses casos, scratch não serve, porque o runtime da linguagem tem dependências de sistema reais. É aqui que entram as imagens distroless, mantidas originalmente pelo Google. A proposta é oferecer o mínimo necessário para rodar uma aplicação: as bibliotecas de runtime, o interpretador ou a máquina virtual quando aplicável, os certificados de CA e os dados de fuso horário — e nada além disso.

O que distroless corta é justamente a camada de conveniência humana. Não há shell. Não há gerenciador de pacotes. Não há os utilitários de linha de comando que povoam uma base completa. Você fica com o runtime da sua linguagem e as bibliotecas que ele exige, num pacote muito menor e muito mais seguro do que uma base Debian cheia, mas ainda funcional para linguagens que não sabem viver sozinhas. Existem variantes específicas para os principais runtimes, e todas partem da mesma filosofia de remover tudo o que não seja estritamente runtime.

Como a ausência de shell dificulta o troubleshooting, os mantenedores publicam também uma variante :debug de cada imagem distroless. Ela inclui um shell mínimo (tipicamente o BusyBox) e alguns utilitários básicos, com um propósito único: ser puxada temporariamente quando você precisa entrar no container para investigar um problema. A regra de ouro é que a variante :debug nunca vai para produção — ela é a exceção controlada, usada em ambiente de investigação, e a imagem que roda de verdade continua sendo a versão sem shell nenhum. Distroless entrega, assim, boa parte do benefício de segurança do scratch para linguagens que precisam de runtime, sem exigir que você resolva na mão cada arquivo de suporte que faltaria numa base verdadeiramente vazia.

O que a imagem enxuta ganha em segurança

Vale consolidar os ganhos de segurança, porque eles se somam de formas que não são óbvias quando olhadas isoladamente.

  • Menos pacotes, menos CVEs. É a relação mais direta. A superfície de vulnerabilidades de uma imagem é aproximadamente proporcional à quantidade de software que ela contém. Cortar o sistema operacional corta a maior parte dos alertas que um scanner produziria.
  • Rodar como não-root. Nenhuma imagem minimalista dispensa isso, mas o minimalismo facilita. Um processo que roda sob um UID sem privilégios, dentro de um container sem ferramentas, tem muito pouco com que trabalhar caso seja comprometido. Rodar como root dentro do container é um risco que se combina perigosamente com falhas de isolamento do runtime.
  • Sem shell, exploração mais difícil. Boa parte das cadeias de ataque pós-comprometimento assume a existência de um interpretador de comandos. Sem sh, o atacante não encadeia comandos com a naturalidade de sempre e precisa recorrer a técnicas mais complexas e mais ruidosas.
  • Sistema de arquivos imutável e read-only. Uma imagem enxuta combina especialmente bem com montar o rootfs como somente leitura. Se o container não precisa escrever no próprio sistema de arquivos — e uma app bem projetada raramente precisa — negar a escrita elimina a possibilidade de o atacante depositar um payload em disco.

Nenhuma dessas medidas é uma bala de prata sozinha. Juntas, elas transformam um container de uma máquina genérica e cheia de recursos numa jaula estreita onde há muito pouco a fazer além de rodar o processo pretendido.

Trade-offs e desafios reais

Seria desonesto pintar o minimalismo como puro ganho. Ele impõe custos concretos, e ignorá-los leva a soluções frágeis.

O mais sentido no dia a dia é a dificuldade de debugar sem shell. O reflexo de fazer docker exec e olhar em volta simplesmente deixa de funcionar. A resposta moderna para isso são os containers de debug efêmeros: em Kubernetes, o kubectl debug anexa um container temporário, com as ferramentas que você quiser, ao mesmo namespace de processo do container problemático — sem nunca colocar essas ferramentas na imagem de produção. É a abordagem correta, porque preserva o minimalismo do artefato que roda e concentra o ferramental de investigação num container separado e descartável.

Outro ponto delicado são os healthchecks. Um padrão antigo e comum é definir o healthcheck como uma chamada a curl contra um endpoint local. Numa imagem sem curl e sem shell, isso quebra. A solução é fazer o healthcheck de dentro da própria aplicação — um endpoint que ela mesma expõe e que o orquestrador consulta pela rede — ou embarcar um pequeno binário de healthcheck estático dedicado a isso. Depender de utilitários de sistema para verificar saúde é uma amarra à base gorda.

Há ainda a questão do binário estático de verdade. Em Go, produzir um binário sem dependências de libc costuma ser questão de desabilitar o cgo. Em outras linguagens e em partes do ecossistema Go que dependem de bibliotecas nativas, você esbarra na diferença entre glibc e musl. Um binário linkado contra glibc pode não rodar numa imagem baseada em musl (como a do Alpine) e vice-versa; garantir o link estático correto, ou escolher a base compatível, é parte do trabalho de chegar ao scratch sem surpresas em runtime. E, por fim, nada disso substitui o escaneamento: mesmo uma imagem distroless deve passar por Trivy ou Grype no pipeline, porque o runtime da linguagem e suas bibliotecas ainda podem ter vulnerabilidades. A imagem menor reduz o volume de achados, não a necessidade de olhar.

Boas práticas que sustentam o minimalismo

Algumas práticas complementares transformam o minimalismo de um truque pontual numa disciplina consistente.

  • Pin por digest. Referenciar a base por tag (:latest, :1.21) é referenciar um alvo móvel. Fixar a imagem base pelo digest imutável (o hash sha256) garante que o build de hoje e o de daqui a três meses partem exatamente do mesmo ponto, o que é essencial para reprodutibilidade e para rastrear de onde veio um CVE.
  • .dockerignore disciplinado. O contexto de build enviado ao daemon não deve carregar .git, node_modules local, segredos, artefatos de teste. Um .dockerignore bem feito evita que lixo entre acidentalmente na imagem e reduz o tamanho do contexto.
  • Camadas ordenadas por volatilidade. Coloque o que muda pouco (instalação de dependências) antes do que muda muito (o seu código). Assim o cache de camadas do Docker é aproveitado ao máximo e os rebuilds ficam rápidos, sem que isso comprometa a enxutez do estágio final.
  • SBOM e escaneamento no CI. Gerar um Software Bill of Materials — a lista formal de tudo o que a imagem contém — e passar o scanner de vulnerabilidades no pipeline, com um portão que barra o merge diante de CVEs de severidade alta, fecha o ciclo. O minimalismo dá o menor número possível de itens nesse relatório; o escaneamento garante que os poucos que restam estão sob controle.

Por onde começar, por linguagem

A recomendação prática se organiza pela natureza do runtime. Se a sua aplicação compila para um binário estático — o caso de Go e de Rust — mire em scratch ou na variante static das imagens distroless. Você compila no estágio de build, copia o binário mais o ca-certificates para o estágio final vazio, define um UID numérico não-root e pronto: uma imagem de poucos megabytes, sem shell, sem sistema, sem quase nada para atacar. É o cenário ideal, e as duas linguagens foram desenhadas de forma a torná-lo natural.

Se a sua aplicação precisa de um runtime — Java, Python, Node — o destino é uma imagem distroless específica para aquele runtime. Você não tem como fugir da JVM, do interpretador ou do V8, mas tira todo o resto: o shell, o gerenciador de pacotes, os utilitários. Use a variante :debug apenas quando precisar investigar, e nunca em produção. Em ambos os caminhos, o multi-stage build é o mecanismo comum: a fábrica gorda fica no primeiro estágio, o produto limpo vai para o segundo. Comece por aí — troque a base cheia por um estágio final minimalista no seu serviço mais crítico, meça a queda no relatório do scanner, e você terá o argumento pronto para levar a disciplina ao resto da frota.

Compartilhar

Compartilhar

Leituras relacionadas

Nenhum comentário ainda

Seja o primeiro a comentar.

Deixe seu comentário

Entre com sua conta Canverly para comentar. Você pode usar a mesma conta em qualquer site da rede.

Entrar com Canverly