CI/CD für Go: Pipeline von Grund auf in 20 Minuten schreiben

Warum Ihr Go-Projekt CI/CD braucht, wie ein Hund Gassi gehen

Sie haben einen coolen Mikroservice in Go geschrieben. Er fliegt, die Tests bestehen, der Code ist schön. Aber jeden Morgen starten Sie manuell go build, laden die Binärdatei per SSH auf den Server und beten, dass nichts abstürzt. Kommt Ihnen das bekannt vor? Wenn ja – ich habe eine Neuigkeit für Sie: Sie verschwenden 15% Ihres Lebens mit etwas, das ein Roboter erledigen kann.

CI/CD (Continuous Integration / Continuous Deployment) ist nicht nur ein modisches Wort aus DevOps-Stellenanzeigen. Es ist Ihr persönlicher Assistent, der:

• bei jedem Push in Git die Tests startet;
• die Binärdatei für Linux/amd64 baut, selbst wenn Sie einen Mac haben;
• Benachrichtigungen an Telegram sendet, wenn der Build fehlschlägt;
• automatisch auf den Server deployed, wenn Sie einen PR in main mergen.

In diesem Artikel richten wir einen CI/CD Pipeline für Go von Grund auf ein. Ohne überflüssige Details, ohne "installieren Sie Jenkins auf 20 Servern". Nur GitHub Actions, Docker und ein bisschen Magie. Los geht's!

Was wir brauchen

Für die Einrichtung benötigen wir:

• Ein Repository auf GitHub (Sie können jetzt gleich ein Test-Repository erstellen);
• Ein Go-Projekt mit Modulen (wir schreiben einen einfachen HTTP-Server);
• Ein Konto bei Docker Hub (oder einer anderen Registry);
• 5 Minuten Aufmerksamkeit und den Wunsch, Routinen zu automatisieren.

Der gesamte Code, den wir verwenden werden, ist öffentlich zugänglich. Sie können ihn kopieren und an Ihr Projekt anpassen. Vergessen Sie nur nicht, die Tokens und Repository-Namen durch Ihre eigenen zu ersetzen.

Schritt 1: Ein einfaches Go-Programm schreiben

Zur Demonstration nehmen wir einen minimalen HTTP-Server. Erstellen Sie 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 CI/CD pipeline!")    })

    http.ListenAndServe(":8080", nil)}

Und die Datei main_test.go zur Überprüfung der Funktionsfähigkeit:

package main

import (    "net/http"    "net/http/httptest"    "testing")

func TestHelloHandler(t *testing.T) {    req := httptest.NewRequest("GET", "/", nil)    w := httptest.NewRecorder()

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {        fmt.Fprintf(w, "Hello from Go CI/CD pipeline!")    })

    http.DefaultServeMux.ServeHTTP(w, req)

    if w.Code != http.StatusOK {        t.Errorf("expected status 200, got %d", w.Code)    }}

Initialisieren Sie das Modul:

go mod init github.com/ihr-benutzername/go-cicd-examplego mod tidy

Überprüfen Sie, ob alles funktioniert:

go test ./... -vgo run main.go

Wenn Sie ok und eine Begrüßung auf localhost:8080 sehen – sind Sie großartig. Machen wir weiter.

Schritt 2: Dockerfile für die Go-Anwendung erstellen

Containerisierung ist ein obligatorischer Schritt des modernen Deployments. Wir werden eine statische Binärdatei (ohne CGO) erstellen und sie in ein minimales Image auf Basis von scratch oder alpine packen. Das ergibt ein Image von etwa 10–15 MB statt über 300 MB.

Erstellen Sie die Datei Dockerfile im Stammverzeichnis des Projekts:

FROM golang:1.22-alpine AS builder

WORKDIR /appCOPY go.mod go.sum ./RUN go mod downloadCOPY . .RUN CGO_ENABLED=0 GOOS=linux go build -o main .

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

Beachten Sie: Wir verwenden einen Multi-Stage-Build. Die erste Stufe ist die Kompilierung in einer vollständigen Go-Umgebung. Die zweite Stufe ist ein minimales Alpine-Image, in das nur die Binärdatei kopiert wird. Das ist der Industriestandard für Go-Anwendungen.

Bauen Sie das Image lokal und überprüfen Sie es:

docker build -t go-cicd-example .docker run -p 8080:8080 go-cicd-example

Wenn alles in Ordnung ist, gehen wir zu