Bereitstellung einer Go-Anwendung auf Kubernetes: Schritt-für-Schritt-Anleitung

Einleitung: Warum Go und Kubernetes das ideale Paar sind

Go (Golang) und Kubernetes sind der moderne Standard für den Aufbau und die Bereitstellung einer Microservice-Architektur. Go wird zu einer statischen Binärdatei kompiliert, benötigt keine Abhängigkeiten auf dem Zielrechner, startet schnell und nutzt Speicher effizient. Kubernetes hingegen automatisiert die Bereitstellung, Skalierung und Verwaltung von Containern.

In dieser Anleitung gehen wir praktisch den gesamten Zyklus der Bereitstellung einer einfachen Go-Anwendung auf Kubernetes durch. Sie erfahren, wie Sie ein Dockerfile schreiben, Manifeste für Kubernetes (Deployment, Service, ConfigMap) erstellen und die Anwendung in einem Cluster starten. Alle Codebeispiele können Sie direkt in Ihren eigenen Projekten verwenden.

1. Vorbereitung der Go-Anwendung für die Containerisierung

Zunächst erstellen wir einen einfachen HTTP-Server in Go, der auf Anfragen antwortet und eine Begrüßung ausgibt. Wichtig ist, dass die Anwendung auf dem Port lauscht, den wir über eine Umgebungsvariable angeben. Dies ist eine gängige Praxis für Kubernetes.

Erstellen Sie die Datei main.go:

package main

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

func main() {    port := os.Getenv("PORT")    if port == "" {        port = "8080"    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {        name := os.Getenv("APP_NAME")        if name == "" {            name = "Go App"        }        fmt.Fprintf(w, "Hallo von %s! Wir arbeiten auf Port %s", name, port)    })

    log.Printf("Server gestartet auf Port %s", port)    log.Fatal(http.ListenAndServe(":"+port, nil))}

Dieser Code liest die Umgebungsvariablen PORT und APP_NAME, was es uns ermöglicht, die Anwendung flexibel über ein ConfigMap in Kubernetes zu konfigurieren.

2. Erstellen eines Dockerfiles für die Go-Anwendung

Für die Bereitstellung auf Kubernetes benötigen wir ein Docker-Image. Wir verwenden einen mehrstufigen Build (Multi-Stage Build) – dies reduziert die Image-Größe und erhöht die Sicherheit.

Erstellen Sie die Datei Dockerfile:

# Build-StufeFROM 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 /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:latest .docker push yourusername/go-k8s-app:latest

3. Kubernetes-Manifeste: Deployment, Service, ConfigMap

Jetzt erstellen wir die Manifeste für die Bereitstellung der Anwendung im Cluster. Es wird empfohlen, sie im Ordner k8s/ zu speichern.

3.1. ConfigMap für die Konfiguration

Wir lagern die Anwendungseinstellungen in ein ConfigMap aus – dies ermöglicht Änderungen ohne Neuerstellung des Images.

Datei k8s/configmap.yaml:

apiVersion: v1kind: ConfigMapmetadata:  name: go-app-configdata:  APP_NAME: "Meine Go-Anwendung"  PORT: "8080"

3.2. Deployment – Beschreibung des Pods

Das Deployment verwaltet die Pod-Replikate und ermöglicht Updates ohne Ausfallzeit.

Datei k8s/deployment.yaml:

apiVersion: apps/v1kind: Deploymentmetadata:  name: go-app-deployment  labels:    app: go-appspec:  replicas: 2  selector:    matchLabels:      app: go-app  template:    metadata:      labels:        app: go-app    spec:      containers:      - name: go-app        image: yourusername/go-k8s-app:latest        ports:        - containerPort: 8080        envFrom:        - configMapRef:            name: go-app-config        livenessProbe:          httpGet:            path: /            port: 8080          initialDelaySeconds: 5          periodSeconds: 10\