0Pricing
Go Academy · Aula

Builds Docker em várias etapas para Go

Use uma etapa de compilação com uma imagem final scratch/alpine

Builds Docker em várias etapas para Go é uma aula grátis de Go Academy 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 Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Por que usar várias etapas?

Uma compilação de uma única etapa que compila código Go produz uma imagem grande com toda a cadeia de ferramentas do Go. Compilações em várias etapas compilam em uma etapa e copiam apenas o binário para uma imagem final mínima.

Dockerfile básico de várias etapas

A etapa de compilação compila o binário; a etapa final o copia para uma base mínima:

FROM golang:1.22-alpine AS build
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o myapp ./cmd/server

FROM scratch
COPY --from=build /app/myapp /myapp
COPY --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
ENTRYPOINT ["/myapp"]

FROM scratch

Uma imagem FROM scratch não contém nada — nem interpretador de comandos nem bibliotecas do sistema operacional. O binário Go deve ser vinculado estaticamente (CGO_ENABLED=0) e incluir explicitamente todos os arquivos necessários.

FROM distroless

As imagens distroless do Google fornecem bibliotecas mínimas do sistema operacional (certificados CA e dados de fuso horário) sem um interpretador de comandos — são mais seguras que scratch para binários que precisam de libc ou de certificados TLS.

FROM gcr.io/distroless/static-debian12
COPY --from=build /app/myapp /
ENTRYPOINT ["/myapp"]

FROM alpine para ter um interpretador de comandos

Use Alpine como base final quando precisar de um interpretador de comandos para depuração ou quando o binário usar CGO. O Alpine adiciona cerca de 5 MB, mas inclui um interpretador de comandos e um gerenciador de pacotes.

Cache de camadas para go.mod

Copie go.mod e go.sum primeiro e execute go mod download antes de copiar o código-fonte. Essa camada permanece em cache até que as dependências mudem, acelerando as recompilações.

COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN go build ...

-ldflags="-s -w"

-s remove a tabela de símbolos; -w remove as informações de depuração DWARF. Juntos, eles reduzem o tamanho do binário em 30–50%, sem impacto durante a execução.

Argumentos de compilação

Use ARG para inserir informações de versão no momento da compilação:

ARG VERSION=dev
RUN go build -ldflags="-X main.version=${VERSION}" -o myapp .

Usuário sem privilégios

Execute o binário como um usuário sem privilégios para aumentar a segurança. Adicione um usuário em uma imagem base ou use a tag nonroot do distroless:

FROM gcr.io/distroless/static-debian12:nonroot

Tamanho da imagem final

Um binário Go típico a partir de scratch tem de 5 a 20 MB. O Alpine adiciona cerca de 5 MB. Uma imagem completa do golang tem cerca de 800 MB. Compilações em várias etapas reduzem significativamente a superfície de ataque e o tempo de download da imagem.

.dockerignore

Adicione um .dockerignore para excluir arquivos do contexto de compilação: vendor/, .git/, *.test, *.prof. Isso acelera a compilação do Docker e impede a inclusão de arquivos sensíveis.

.git
vendor
*.test
*.prof
.env

Verificação rápida

Por que CGO_ENABLED=0 deve ser definido ao compilar um binário Go para uma imagem Docker FROM scratch?

Recapitulação: compilações Docker em várias etapas

Pontos principais:

  • Etapa de compilação: imagem golang; etapa final: scratch/distroless/alpine
  • CGO_ENABLED=0 para um binário estático (obrigatório para scratch)
  • Copie go.mod primeiro para usar o cache de camadas; -ldflags="-s -w" para reduzir o binário
  • .dockerignore para excluir .git, vendor e arquivos de teste

Perguntas Frequentes

A aula “Builds Docker em várias etapas para Go” é grátis?

Sim — o texto completo de “Builds Docker em várias etapas para Go” é 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 Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Builds Docker em várias etapas para Go”?

Use uma etapa de compilação com uma imagem final scratch/alpine Você pratica Go Academy 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 Go Academy?

Nenhuma experiência prévia é necessária. Go Academy 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 “Builds Docker em várias etapas para Go”?

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 Go Academy?

Sim. Cada aula de Go Academy 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. Builds Docker em várias etapas para Go
  2. Configuração de ambiente e secrets
  3. Docker Compose para desenvolvimento local
  4. Verificações de saúde e ajustes para produção
← Voltar para Go Academy