Bereitstellung einer Go-Anwendung auf Kubernetes: Ein grundlegender Leitfaden

Einleitung: Warum Go und Kubernetes das ideale Paar sind

Go (Golang) und Kubernetes sind zwei Schlüsselwerkzeuge in der modernen Entwicklung. Go, entwickelt bei Google, ist eine kompilierte, statisch typisierte Sprache, die sich ideal für die Erstellung leistungsstarker Microservices eignet. Kubernetes wiederum ist der De-facto-Standard für die Container-Orchestrierung. Ihre Kombination ergibt ein leistungsstarkes Ökosystem: Sie schreiben leichten, schnellen Code in Go, verpacken ihn in ein Docker-Image, und Kubernetes verwaltet dessen Ausführung, Skalierung und Wiederherstellung.

In dieser Anleitung werden wir Schritt für Schritt eine einfache Go-Anwendung auf Kubernetes bereitstellen. Sie erfahren, wie Sie ein Dockerfile schreiben, Deployment- und Service-Manifeste erstellen und diese in einem Cluster anwenden. Der Artikel richtet sich an Entwickler, die bereits mit den Grundlagen von Go vertraut sind und ein grundlegendes Verständnis von Docker haben.

Schritt 1: Erstellen und Containerisieren der Go-Anwendung

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

package main

import (    "fmt"    "net/http"    "os")

func main() {    port := os.Getenv("PORT")    if port == "" {        port = "8080"    }    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {        fmt.Fprintf(w, "Hello from Go on Kubernetes!")    })    http.ListenAndServe(":"+port, nil)}

Dieser Code lauscht auf dem Port, der durch die Umgebungsvariable PORT festgelegt wird (standardmäßig 8080), und gibt eine einfache Nachricht zurück.

Erstellen des Docker-Images

Jetzt erstellen wir ein Dockerfile für einen mehrstufigen Build – dies reduziert die Größe des endgültigen Images:

# Build-StufeFROM golang:1.21-alpine AS builderWORKDIR /appCOPY go.mod go.sum ./RUN go mod downloadCOPY . .RUN CGO_ENABLED=0 GOOS=linux go build -o /app/server .

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

Erstellen Sie das Image und senden Sie es an eine Registry (z. B. Docker Hub):

docker build -t yourusername/go-k8s-app:v1 .docker push yourusername/go-k8s-app:v1

Schritt 2: Das Deployment-Manifest

Kubernetes verwendet YAML-Manifeste, um den gewünschten Zustand des Clusters zu beschreiben. Erstellen Sie die Datei deployment.yaml:

apiVersion: apps/v1kind: Deploymentmetadata:  name: go-app-deployment  labels:    app: go-appspec:  replicas: 3  selector:    matchLabels:      app: go-app  template:    metadata:      labels:        app: go-app    spec:      containers:      - name: go-app        image: yourusername/go-k8s-app:v1        ports:        - containerPort: 8080        env:        - name: PORT          value: "8080"        readinessProbe:          httpGet:            path: /            port: 8080          initialDelaySeconds: 5          periodSeconds: 10        livenessProbe:          httpGet:            path: /            port: 8080          initialDelaySeconds: 15          periodSeconds: 20

Erklärung der Schlüsselfelder:

• replicas: 3 – Kubernetes wird 3 laufende Instanzen (Pods) der Anwendung aufrechterhalten.
• readinessProbe – Prüft, ob der Pod bereit ist, Traffic zu empfangen (Anfragen an /).
• livenessProbe – Prüft, ob der Pod lebt; falls nicht, wird Kubernetes ihn neu starten.

Schritt 3: Das Service-Manifest

Um die Anwendung innerhalb des Clusters oder von außen erreichbar zu machen, wird ein Service benötigt. Erstellen Sie service.yaml:

apiVersion: v1kind: Servicemetadata:  name: go-app-servicespec:  selector:    app: go-app  ports:    - protocol: TCP      port: 80      targetPort: 8080  type: LoadBalancer

• selector – Verbindet den Service mit den Pods, die das Label