Go auf Kubernetes bereitstellen: Ein grundlegendes Tutorial für Anfänger

Einleitung: Warum Go und Kubernetes ein ideales Paar sind

Go (Golang) und Kubernetes (K8s) sind füreinander gemacht. Kubernetes selbst ist in Go geschrieben, daher machen die nativen Werkzeuge, die Leistung und die einfache Bereitstellung diese Kombination zum Standard für moderne Microservices. Wenn Sie gerade erst Ihren Weg in DevOps beginnen oder die Bereitstellung Ihrer Go-Anwendung automatisieren möchten, hilft Ihnen dieses Tutorial, alle Schritte zu durchlaufen: vom Schreiben eines einfachen HTTP-Servers in Go bis zum Ausführen in einem Kubernetes-Cluster.

In diesem Artikel behandeln wir:

\n
• Das Erstellen eines Go-Anwendungs-Docker-Images
\n
• Das Erstellen minimaler Kubernetes-Manifeste (Deployment, Service, Ingress)
\n
• Die Bereitstellung und Überprüfung der Funktionsfähigkeit
\n

Es wird vorausgesetzt, dass Sie bereits docker, kubectl und minikube installiert haben (oder Zugriff auf einen beliebigen K8s-Cluster haben).

Schritt 1: Eine einfache Go-Anwendung schreiben

Wir erstellen einen einfachen HTTP-Server, der auf Anfragen antwortet. Erstellen Sie die Datei main.go:

package main\n\nimport (\n    "fmt"\n    "net/http"\n    "os"\n)\n\nfunc main() {\n    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {\n        fmt.Fprintf(w, "Hallo aus Go! Version: %s", os.Getenv("APP_VERSION"))\n    })\n\n    port := os.Getenv("PORT")\n    if port == "" {\n        port = "8080"\n    }\n\n    fmt.Printf("Server gestartet auf Port %s\\n", port)\n    http.ListenAndServe(":"+port, nil)\n}\n

Diese Anwendung liest die Umgebungsvariable APP_VERSION (kann bei der Bereitstellung festgelegt werden) und horcht auf dem in PORT angegebenen Port. Testen wir nun lokal:

go run main.go\n# Öffnen Sie den Browser unter http://localhost:8080\n

Ein Go-Modul erstellen

Initialisieren Sie das Modul für eine einfache Kompilierung:

go mod init my-go-app\n

Schritt 2: Containerisierung mit Docker

Für die Bereitstellung in Kubernetes muss die Anwendung in ein Docker-Image verpackt werden. Wir verwenden einen Multi-Stage-Build, um das Image minimal zu halten.

Erstellen Sie die Datei Dockerfile:

# Build-Stage\nFROM golang:1.22-alpine AS builder\nWORKDIR /app\nCOPY go.mod ./\nCOPY main.go ./\nRUN go build -o my-app .\n\n# Finales Image\nFROM alpine:3.19\nWORKDIR /app\nCOPY --from=builder /app/my-app .\nEXPOSE 8080\nCMD ["./my-app"]\n

Erstellen Sie das Image und überprüfen Sie es:

docker build -t my-go-app:v1 .\ndocker run -p 8080:8080 my-go-app:v1\n# http://localhost:8080\n

Schritt 3: Kubernetes-Manifeste

Jetzt bereiten wir die YAML-Dateien für die Bereitstellung im Cluster vor. Wir werden drei Ressourcen erstellen: Deployment (Pod-Verwaltung), Service (Netzwerkzugriff) und Ingress (externer Zugriff).

3.1. Deployment

Erstellen Sie die Datei deployment.yaml:

apiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: go-app-deployment\n  labels:\n    app: go-app\nspec:\n  replicas: 2\n  selector:\n    matchLabels:\n      app: go-app\n  template:\n    metadata:\n      labels:\n        app: go-app\n    spec:\n      containers:\n      - name: go-app\n        image: my-go-app:v1\n        ports:\n        - containerPort: 8080\n        env:\n        - name: APP_VERSION\n          value: "1.0.0"\n        - name: PORT\n          value: "8080"\n        livenessProbe:\n          httpGet:\n            path: /\n            port: 8080\n          initialDelaySeconds: 5\n          periodSeconds: 10\n

Hier haben wir 2 Replikate, einen Liveness-Probe und Umgebungsvariablen festgelegt.

3.2. Service

Erstellen Sie die Datei service.yaml für den internen Zugriff:

apiVersion: v1\nkind: Service\nmetadata:\n  name: go-app-service\nspec:\n  selector:\n    app: go-app\n  ports:\n  - protocol: TCP\n    port: 80\n    targe