0Pricing
Go Academy · Lección

Compilaciones Docker de varias etapas para Go

Etapa de compilación con una imagen final scratch/alpine

Compilaciones Docker de varias etapas para Go es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

¿Por qué utilizar varias etapas?

Una compilación de una sola etapa que compila código Go produce una imagen grande con toda la cadena de herramientas de Go. Las compilaciones de varias etapas compilan en una etapa y copian solo el binario en una imagen final mínima.

Dockerfile básico de varias etapas

La etapa de compilación compila el binario; la etapa final lo copia en una 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

Una imagen FROM scratch no contiene nada: ni shell ni bibliotecas del sistema operativo. El binario de Go debe enlazarse estáticamente (CGO_ENABLED=0) e incluir explícitamente todos los archivos necesarios.

FROM distroless

Las imágenes distroless de Google proporcionan bibliotecas mínimas del sistema operativo (certificados de CA y datos de zona horaria) sin shell; son más seguras que scratch para binarios que necesitan libc o certificados TLS.

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

FROM alpine para disponer de un shell

Utilice Alpine como base final cuando necesite un shell para depurar o si el binario utiliza CGO. Alpine añade unos 5 MB, pero incluye un shell y un gestor de paquetes.

Almacenamiento en caché de capas para go.mod

Copie primero go.mod y go.sum y ejecute go mod download antes de copiar el código fuente. Esta capa se almacena en caché hasta que cambian las dependencias, lo que acelera las compilaciones posteriores.

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

-ldflags="-s -w"

-s elimina la tabla de símbolos; -w elimina la información de depuración DWARF. En conjunto, reducen el tamaño del binario entre un 30 y un 50 % sin ningún impacto en tiempo de ejecución.

Argumentos de compilación

Utilice ARG para inyectar información de versión en tiempo de compilación:

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

Usuario no root

Ejecute el binario como un usuario que no sea root por motivos de seguridad. Añada un usuario en una imagen base o utilice la etiqueta nonroot de distroless:

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

Tamaño de la imagen final

Un binario de Go típico creado desde scratch ocupa entre 5 y 20 MB. Alpine añade unos 5 MB. Una imagen completa de golang ocupa unos 800 MB. Las compilaciones de varias etapas reducen considerablemente la superficie de ataque y el tiempo de descarga de la imagen.

.dockerignore

Añada un .dockerignore para excluir archivos del contexto de compilación: vendor/, .git/, *.test, *.prof. Esto acelera la compilación de Docker y evita incluir archivos confidenciales.

.git
vendor
*.test
*.prof
.env

Comprobación rápida

¿Por qué debe establecerse CGO_ENABLED=0 al compilar un binario de Go para una imagen de Docker FROM scratch?

Repaso: compilaciones de Docker de varias etapas

Puntos clave:

  • Etapa de compilación: imagen de golang; etapa final: scratch/distroless/alpine
  • CGO_ENABLED=0 para obtener un binario estático (necesario para scratch)
  • Copie go.mod primero para almacenar las capas en caché; utilice -ldflags="-s -w" para reducir el tamaño del binario
  • Utilice .dockerignore para excluir .git, vendor y archivos de pruebas

Preguntas frecuentes

¿La lección «Compilaciones Docker de varias etapas para Go» es gratis?

Sí — el texto completo de «Compilaciones Docker de varias etapas para Go» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Compilaciones Docker de varias etapas para Go»?

Etapa de compilación con una imagen final scratch/alpine Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Compilaciones Docker de varias etapas para Go»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Compilaciones Docker de varias etapas para Go
  2. Configuración del entorno y secretos
  3. Docker Compose para desarrollo local
  4. Comprobaciones de estado y ajustes para producción
← Volver a Go Academy