Docker und Go: Containerisierung von Anwendungen von A bis Z

Einleitung: Warum Docker und Go das ideale Paar sind?

Go (Golang) und Docker sind zwei Werkzeuge, die die Herangehensweise an die Entwicklung und Bereitstellung von Backend-Diensten verändert haben. Go wird in eine einzige statische Binärdatei kompiliert, und Docker ermöglicht es, diese Binärdatei in eine isolierte Umgebung zu packen. Zusammen ergeben sie minimalistische, schnelle und sichere Container, die überall ausgeführt werden können: vom Entwickler-Laptop bis zum Produktions-Kubernetes-Cluster.

In diesem Artikel gehen wir den Weg von Null bis zu einer produktionsreifen Go-Anwendung, die in Docker verpackt ist. Sie erfahren, wie Sie ein Dockerfile schreiben, die Image-Größe optimieren, Multi-Stage-Builds verwenden und Container mit einem Go-Dienst ausführen.

1. Grundlagen: Go-Anwendung und einfaches Dockerfile

Beginnen wir mit einem einfachen HTTP-Server in Go. Erstellen wir die Datei main.go:

package main

import (    "fmt"    "net/http")

func main() {    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {        fmt.Fprintf(w, "Hello from Go inside Docker!")    })

    fmt.Println("Server is running on :8080")    http.ListenAndServe(":8080", nil)}

Jetzt schreiben wir ein minimales Dockerfile:

FROM golang:1.22-alpine AS builder

WORKDIR /appCOPY go.mod go.sum ./RUN go mod downloadCOPY . .RUN go build -o server .

FROM alpine:3.19RUN apk --no-cache add ca-certificatesWORKDIR /root/COPY --from=builder /app/server .EXPOSE 8080CMD ["./server"]

Erstellen wir das Image und starten den Container:

docker build -t go-server .docker run -p 8080:8080 go-server

Öffnen Sie nun Ihren Browser und gehen Sie zu http://localhost:8080 – Sie sehen die Begrüßung der Go-Anwendung, die innerhalb des Containers läuft.

Warum Multi-Stage-Build?

In der ersten Stufe verwenden wir das offizielle Go-Image mit dem vollständigen Satz an Tools für die Kompilierung. In der zweiten Stufe verwenden wir minimales Alpine Linux, in das nur die fertige Binärdatei kopiert wird. Dadurch erhalten wir ein Image mit einer Größe von etwa 15-20 MB anstelle von 500+ MB, wenn wir das vollständige Go-Image behalten würden.

2. Image-Optimierung: Minimierung von Größe und Build-Geschwindigkeit

Ein kleines Image spart nicht nur Speicherplatz, sondern ermöglicht auch schnellere Downloads und eine kleinere Angriffsfläche. Betrachten wir die wichtigsten Techniken für Go-Anwendungen.

2.1. Verwenden von .dockerignore

Erstellen Sie eine Datei .dockerignore im Stammverzeichnis des Projekts:

.git*.mdDockerfile.dockerignorenode_modules/test/

Dies verhindert das Kopieren unnötiger Dateien in den Build-Kontext und beschleunigt den Prozess.

2.2. Caching von Abhängigkeiten

In unserem Dockerfile kopieren wir zuerst nur go.mod und go.sum und führen dann go mod download aus. Docker cached jede Schicht, und solange sich diese Dateien nicht ändern, werden die Abhängigkeiten bei jeder Codeänderung nicht neu heruntergeladen.

2.3. CGO und statische Kompilierung

Go verwendet standardmäßig CGO für einige Operationen (z. B. Netzwerkzugriff über Systemaufrufe). Um eine vollständig statische Binärdatei ohne Abhängigkeiten von libc zu erhalten, verwenden Sie die folgenden Compiler-Flags:

RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o server .

Dies stellt sicher, dass die Binärdatei auf jeder Linux-Distribution funktioniert, einschließlich minimaler Images wie scratch.

2.4. Scratch – das leichteste Basis-Image

Wenn Ihre Anwendung keine Shell, ping oder andere Dienstprogramme benötigt, verwenden Sie das leere Image scratch:

FROM scratchCOPY --from=builder /app/server /EXPOSE 8080CMD ["/server"]

Die Größe eines solchen Images entspricht der Größe der Binärdatei selbst – oft weniger als 10 MB.

3. Docker Compose: Multi-Container-Go-Anwendung

Reale Anwendungen bestehen selten aus e