So stellen Sie PostgreSQL auf Kubernetes bereit

PostgreSQL ist ein beliebtes relationales Datenbank-Management-System (RDBMS), das Hochverfügbarkeitsfunktionen wie Streaming-Replikation, logische Replikation und Failover-Lösungen bietet. Eine Bereitstellung von PostgreSQL auf Kubernetes ermöglicht es Organisationen, robuste Systeme zu bauen, die minimale Ausfallzeiten und Datenverfügbarkeit sicherstellen.

Mit Kubernetes StatefulSets lässt sich eine PostgreSQL-Bereitstellung je nach Bedarf skalieren.

Choose hour server now!

Kubernetes-Umgebung einrichten

Stelle sicher, dass du Folgendes besitzt:

• Kubernetes-Cluster (Cloud oder lokal): Du kannst z. B. bei Hostman binnen Minuten einen Cluster einrichten. Lokal funktionieren Tools wie k3s, minikube, microk8s oder kind.

• kubectl: Mit kubectl interagierst du mit dem Kubernetes-Cluster. Es benötigt eine Konfigurations-YAML-Datei mit Cluster-Details, meist vom Cloud-Provider bereitgestellt.

Sie können diese Konfigurationsdatei einfach per Mausklick über das Hostman-Kontrollfeld herunterladen, wie im folgenden Screenshot gezeigt.

Beispiel:

export KUBECONFIG=/absolute/path/to/file/k8s-cluster-config.yaml

• Helm: Du benötigst die Helm-CLI zur Installation von Charts. Version 3 wird vorausgesetzt.

PostgreSQL mit einem Helm-Chart bereitstellen

Helm ist ein Paketmanager für Kubernetes — ähnlich wie apt für Ubuntu/Debian.
Anstatt viele YAML-Dateien (Pods, Services, PersistentVolumes, Secrets …) manuell zu erstellen, erledigt das Helm-Chart vieles mit einem einzigen Befehl.

Schritt 1: Helm-Repository hinzufügen

helm repo add bitnami https://charts.bitnami.com/bitnami

So synchronisieren Sie Ihr lokales Helm-Repository mit dem Remote-Repository:

helm repo update

Schritt 2: Datenpersistenz verwalten

PostgreSQL benötigt persistenten Speicher, damit Daten nicht verloren gehen, wenn ein Pod abstürzt oder neu geplant wird.

Erstelle eine Datei postgres-local-pv.yaml:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: postgresql-local-pv
spec:
  capacity:
      storage: 5Gi
  accessModes:
      - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: manual
  hostPath:
      path: /mnt/data/postgresql

⚠️ Hinweis: hostPath verweist auf ein lokales Verzeichnis auf einem Node. Das birgt Risiko in Produktionsumgebungen. Empfehlenswert ist cloud-native Speicherung (z. B. Ceph, Portworx, OpenEBS) für Zuverlässigkeit, Skalierbarkeit und Datenschutz.

Erstelle eine Datei postgres-local-pvc.yaml:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgresql-local-pvc
spec:
  accessModes:
      - ReadWriteOnce
  resources:
      requests:
          storage: 5Gi
  storageClassName: manual

Modus ReadWriteOnce bedeutet: Nur ein Node kann das Volume gleichzeitig lesen und schreiben – ReadWriteMany klingt flexibel, kann jedoch in Postgres-Clustern Rennbedingungen, Dateninkonsistenzen oder Datenkorruption erzeugen.

Wenden Sie die Manifeste an:

kubectl apply -f postgres-local-pv.yaml
kubectl apply -f postgres-local-pvc.yaml

Schritt 3: Helm-Chart installieren

helm install tutorial-db bitnami/postgresql --set auth.username=bhuwan \
  --set auth.password=”AeSeigh2gieshe” \
  --set auth.database=k8s-tutorial \
  --set auth.postgresPassword=”Ze4hahshez6dop9vaing” \
  --set primary.persistence.existingClaim=postgresql-local-pvc \
  --set volumePermissions.enabled=true 

Nach einigen Minuten prüfen Sie:

kubectl get all

Schritt 4: Testen und verbinden

export POSTGRES_PASSWORD=$(kubectl get secret --namespace default tutorial-db-postgresql -o jsonpath="{.data.password}" | base64 -d)

kubectl run tutorial-db-postgresql-client --rm --tty -i --restart='Never' \
 --image docker.io/bitnami/postgresql:17.2.0-debian-12-r6 \
 --env="PGPASSWORD=$POSTGRES_PASSWORD" \
 --command -- psql --host tutorial-db-postgresql \
 -U bhuwan -d k8s-tutorial -p 5432

Nach Beendigung wird der Pod wegen --rm automatisch gelöscht.

⚠️ Wenn Helm Release-Name, Benutzer oder Datenbankname geändert wurden, passen Sie die Befehle entsprechend an.

PostgreSQL auf Kubernetes von Grund auf bereitstellen

Ein StatefulSet ist die beste Ressource für zustandsbehaftete Anwendungen wie PostgreSQL: Jeder Pod erhält eine stabile Identität und persistente Volumes.

Zuerst löschen wir bestehende Ressourcen:

helm delete tutorial-db
kubectl delete pvc postgresql-local-pvc
kubectl delete pv postgresql-local-pv

kubectl apply -f postgres-local-pv.yaml -f postgres-local-pvc.yaml

Erstelle eine Datei postgres-statefulset.yaml:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres-statefulset
  labels:
    app: postgres
spec:
  serviceName: "postgresql-headless-svc"
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:17.2
          envFrom:
            - secretRef:
                name: postgresql-secret
          ports:
            - containerPort: 5432
              name: postgresdb
          volumeMounts:
            - name: pv-data
              mountPath: /var/lib/postgresql/db
      volumes:
        - name: pv-data
          persistentVolumeClaim:
            claimName: postgresql-local-pvc

Erstelle zuerst das Secret:

kubectl create secret generic postgresql-secret --from-literal=POSTGRES_PASSWORD=Ze4hahshez6dop9vaing

kubectl apply -f postgres-statefulset.yaml

Wenn der Pod im Zustand Pending bleibt, könnte eine StorageClass fehlen.

Beispiel:

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: manual
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer

Zur Problemanalyse:

kubectl describe pod postgres-statefulset-0

Erstelle eine Headless-Service für interne Nutzung:

postgres-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: postgresql-headless-svc
spec:
  type: ClusterIP
  selector:
	app: postgres
  ports:
  	- port: 5432
    	targetPort: 5432
  clusterIP: None

Dann testen:

kubectl run tutorial-db-postgresql-client --rm --tty -i --restart='Never'  \
--image docker.io/bitnami/postgresql:17.2.0-debian-12-r6 \
--env="PGPASSWORD=Ze4hahshez6dop9vaing"  \
--command -- psql --host postgres-statefulset-0.postgresql-headless-svc  \
-U postgres  -p 5432

Skalierung, Replikation und Backup

Skalieren eines StatefulSets:

kubectl scale statefulset postgres-statefulset --replicas=3 

• Mit einer Headless-Service kannst du Anfragen an bestimmte Pods richten (z. B. postgres-statefulset-1.postgresql-headless-svc).

• Für Backups kannst du einen CronJob mit pg_dump verwenden.

Best Practices

• Ressourcenanforderungen und Limits setzen: CPU/Mem klar definiert für Stabilität

• Backups regelmäßig planen; evtl. Volume Snapshots

• Monitoring & Logs: Prometheus/Grafana für Metriken (Queries, Disk, Replikation)

• PodDisruptionBudgets (PDBs): Zu viele Ausfälle gleichzeitig vermeiden

Choose your server now!

Fazit

Ein Helm-Chart ist der empfohlene Weg für komplexe und produktive Deployments. Helm automatisiert Versionsverwaltung und verbirgt viele Details der Kubernetes-Komponenten. Mit helm template kannst du Charts lokal rendern und YAML-Manifeste anpassen.

Kubernetes bietet Skalierbarkeit, Flexibilität und Automatisierbarkeit für PostgreSQL-Datenbanken. Durch Nutzung von StatefulSets, PersistentVolumes/Claims, PodDisruptionBudgets und Secrets-Management kann deine PostgreSQL-Instanz produktionsreif betrieben werden.