0Pricing
DevOps Bootcamp · Aula

Criações em Vários Estágios para Maior Eficiência

Utilize criações em vários estágios para produzir imagens de produção menores e mais seguras, separando as dependências de criação e execução.

Criações em Vários Estágios para Maior Eficiência é uma aula grátis de DevOps Bootcamp no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de DevOps Bootcamp, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de DevOps Bootcamp inclui 4 aulas no total.

Introdução às compilações em várias etapas

Boas-vindas à otimização avançada de Dockerfiles! Hoje, vamos explorar as compilações em várias etapas, uma técnica poderosa para criar imagens do Docker menores e mais eficientes.

Imagens menores resultam em downloads mais rápidos, segurança aprimorada e melhor utilização dos recursos.

Criações em Vários Estágios para Maior Eficiência — ilustração 1

Por que imagens menores são importantes

Ao criar uma imagem do Docker, ela frequentemente inclui ferramentas e dependências necessárias apenas durante o processo de compilação, e não durante a execução do aplicativo final.

  • Downloads mais rápidos: Imagens menores são baixadas mais rapidamente.
  • Menos espaço em disco: Economiza armazenamento nos registros e hosts.
  • Superfície de ataque reduzida: Menos componentes significam menos vulnerabilidades potenciais.
  • Segurança aprimorada: Sua imagem de produção contém apenas o que é essencial.

O problema de uma única etapa

Considere um aplicativo compilado, como um escrito em Go. Um Dockerfile tradicional de uma única etapa incluiria o compilador Go completo e as dependências de desenvolvimento na imagem final.

Isso torna a imagem final muito maior do que o necessário, pois o compilador não é necessário para executar o binário compilado.

Exemplo de uma única etapa (Go)

Veja um aplicativo Go simples e um Dockerfile que o cria em uma única etapa. Observe que o ambiente de compilação é incluído na imagem final.

main.go:

package main

import "fmt"

func main() {
    fmt.Println("Hello from Single-Stage Docker!")
}

Dockerfile de uma única etapa

Este Dockerfile usa `golang:1.21-alpine` como base. Depois de criar o aplicativo, essa imagem-base grande, juntamente com todas as ferramentas de compilação, permanece na imagem final.

FROM golang:1.21-alpine
WORKDIR /app
COPY main.go .
RUN go build -o myapp main.go
EXPOSE 8080
CMD ["./myapp"]

Anatomia das compilações em várias etapas

As compilações em várias etapas resolvem esse problema permitindo definir várias instruções `FROM` em um único Dockerfile. Cada `FROM` inicia uma nova etapa de compilação.

  • Use a palavra-chave AS para nomear uma etapa (por exemplo, FROM golang:1.21-alpine AS builder).
  • Em seguida, você pode copiar artefatos de uma etapa anterior usando COPY --from=<stage_name>.

Apenas a etapa final é salva como imagem.

Estrutura em várias etapas

Um Dockerfile típico de várias etapas tem pelo menos duas etapas:

  • Etapa de compilação: Contém todas as ferramentas e o código-fonte necessários para compilar o aplicativo.
  • Etapa de execução: Uma imagem-base mínima que inclui apenas o aplicativo compilado e suas dependências de execução.

A imagem intermediária da etapa de compilação é descartada, deixando uma imagem final enxuta.

Exemplo de várias etapas (Go)

Vamos reescrever o Dockerfile do nosso aplicativo Go usando uma abordagem de várias etapas. Criaremos o aplicativo na primeira etapa e depois copiaremos apenas o binário compilado para uma imagem-base `alpine` muito menor.

# Stage 1: Build the application
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY main.go .
RUN go build -o myapp main.go

# Stage 2: Create the final lightweight image
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/myapp .
EXPOSE 8080
CMD ["./myapp"]

Executando uma compilação em várias etapas

Ao criar este Dockerfile, o Docker executa cada etapa. No entanto, apenas o conteúdo da última instrução `FROM`, combinado com os arquivos copiados das etapas anteriores, forma a imagem final.

Isso resulta em uma imagem significativamente menor em comparação com a compilação de uma única etapa, pois o compilador Go e as ferramentas de compilação são deixados para trás.

Benefícios das compilações em várias etapas

As compilações em várias etapas são extremamente úteis para:

  • Linguagens compiladas: Go, Java, C++, Rust.
  • Estruturas de frontend: Criar aplicativos React/Angular e servir recursos estáticos com Nginx.
  • Aplicativos Node.js: Instalar `node_modules` em uma etapa de compilação e depois copiar apenas `package.json`, `package-lock.json` e o aplicativo criado para uma imagem de execução enxuta.

Verifique seus conhecimentos

Quais das opções a seguir são os principais benefícios de usar compilações do Docker em várias etapas?

Recapitulação: eficiência em várias etapas

Você aprendeu sobre as compilações do Docker em várias etapas!

  • Elas envolvem várias instruções FROM em um único Dockerfile.
  • A palavra-chave AS nomeia as etapas, e COPY --from= transfere artefatos.
  • O principal benefício são imagens finais muito menores, mais seguras e eficientes.

Essa técnica é essencial para otimizar seus aplicativos conteinerizados. Em seguida, veremos como aproveitar o cache de compilação!

Perguntas Frequentes

A aula “Criações em Vários Estágios para Maior Eficiência” é grátis?

Sim — o texto completo de “Criações em Vários Estágios para Maior Eficiência” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de DevOps Bootcamp, atualize para CoddyKit PRO. O curso de DevOps Bootcamp inclui 4 aulas no total.

O que vou aprender em “Criações em Vários Estágios para Maior Eficiência”?

Utilize criações em vários estágios para produzir imagens de produção menores e mais seguras, separando as dependências de criação e execução. Você pratica DevOps Bootcamp com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar DevOps Bootcamp?

Nenhuma experiência prévia é necessária. DevOps Bootcamp no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Criações em Vários Estágios para Maior Eficiência”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de DevOps Bootcamp?

Sim. Cada aula de DevOps Bootcamp inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Criações em Vários Estágios para Maior Eficiência
  2. Aproveitando o Cache de Criação
  3. Boas Práticas de Segurança para Dockerfiles
  4. Minimização do tamanho de imagens com bases Slim e Distroless
← Voltar para DevOps Bootcamp