Verwenden von Kubernetes zum Bereitstellen von PostgreSQL

Einführung

Kubernetes ist ein Open-Source-Container-Orchestrierungssystem zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen. Das Ausführen einer PostgreSQL-Datenbank auf Kubernetes ist heutzutage ein Diskussionsthema, da Kubernetes Möglichkeiten bietet, Stateful-Container mithilfe von persistenten Volumes, Statefulsets usw. bereitzustellen.

Dieser Blog soll Schritte zum Ausführen der PostgreSQL-Datenbank auf einem Kubernetes-Cluster bereitstellen. Die Installation oder Konfiguration des Kubernetes-Clusters wird nicht behandelt, obwohl wir zuvor in diesem Blog zu MySQL Galera Cluster on Kubernetes darüber geschrieben haben.

Voraussetzungen

• Funktionierender Kubernetes-Cluster
• Grundlegendes Verständnis von Docker

Sie können den Kubernetes-Cluster auf jedem öffentlichen Cloud-Anbieter wie AWS, Azure oder Google Cloud usw. bereitstellen. Siehe Installations- und Konfigurationsschritte für Kubernetes-Cluster für CentOS hier. Sie können auch den früheren Blog-Beitrag für Grundlagen zum Bereitstellen von PostgreSQL auf Docker-Containern lesen.

Um PostgreSQL auf Kubernetes bereitzustellen, müssen wir die folgenden Schritte ausführen:

• Postgres-Docker-Image
• Config Maps zum Speichern von Postgres-Konfigurationen
• Persistentes Speichervolume
• PostgreSQL-Bereitstellung
• PostgreSQL-Dienst

PostgreSQL-Docker-Image

Wir verwenden PostgreSQL 10.4 Docker-Image aus der öffentlichen Registrierung. Dieses Image bietet die Funktionalität zum Bereitstellen benutzerdefinierter Konfigurationen/Umgebungsvariablen von PostgreSQL wie Benutzername, Passwort, Datenbankname und -pfad usw.

Config Maps für PostgreSQL-Konfigurationen

Wir werden Konfigurationszuordnungen zum Speichern von PostgreSQL-bezogenen Informationen verwenden. Hier verwenden wir die Datenbank, den Benutzer und das Passwort in der Konfigurationszuordnung, die vom PostgreSQL-Pod in der Bereitstellungsvorlage verwendet werden.

Datei:postgres-configmap.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: postgres-config
  labels:
    app: postgres
data:
  POSTGRES_DB: postgresdb
  POSTGRES_USER: postgresadmin
  POSTGRES_PASSWORD: admin123

Postgres-Konfigurationszuordnungsressource erstellen

$ kubectl create -f postgres-configmap.yaml 
configmap "postgres-config" created

Persistenter Speicherdatenträger

Wie Sie alle wissen, sind Docker-Container von Natur aus kurzlebig. Alle Daten, die vom oder im Container generiert werden, gehen nach Beendigung der Containerinstanz verloren.

Um die Daten zu speichern, werden wir Persistent Volumes und Persistent Volume Claim-Ressourcen in Kubernetes verwenden, um die Daten auf Persistent Storages zu speichern.

Hier verwenden wir lokales Verzeichnis/Pfad als persistente Speicherressource (/mnt/data)

Datei:postgres-storage.yaml

kind: PersistentVolume
apiVersion: v1
metadata:
  name: postgres-pv-volume
  labels:
    type: local
    app: postgres
spec:
  storageClassName: manual
  capacity:
    storage: 5Gi
  accessModes:
    - ReadWriteMany
  hostPath:
    path: "/mnt/data"
---
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: postgres-pv-claim
  labels:
    app: postgres
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 5Gi

Speicherbezogene Bereitstellungen erstellen

$ kubectl create -f postgres-storage.yaml 
persistentvolume "postgres-pv-volume" created
persistentvolumeclaim "postgres-pv-claim" created

PostgreSQL-Bereitstellung

Das PostgreSQL-Manifest für die Bereitstellung des PostgreSQL-Containers verwendet das PostgreSQL 10.4-Image. Es verwendet die PostgreSQL-Konfiguration wie Benutzername, Passwort, Datenbankname aus der zuvor erstellten Konfigurationskarte. Es stellt auch das Volume bereit, das aus den persistenten Volumes erstellt wurde, und behauptet, die Daten des PostgreSQL-Containers persistent zu machen.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: postgres
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:10.4
          imagePullPolicy: "IfNotPresent"
          ports:
            - containerPort: 5432
          envFrom:
            - configMapRef:
                name: postgres-config
          volumeMounts:
            - mountPath: /var/lib/postgresql/data
              name: postgredb
      volumes:
        - name: postgredb
          persistentVolumeClaim:
            claimName: postgres-pv-claim

Postgres-Bereitstellung erstellen

$ kubectl create -f postgres-deployment.yaml 
deployment "postgres" created

PostgreSQL-Dienst

Um auf die Bereitstellung oder den Container zuzugreifen, müssen wir den PostgreSQL-Dienst verfügbar machen. Kubernetes bietet verschiedene Arten von Diensten wie ClusterIP, NodePort und LoadBalancer.

Mit ClusterIP können wir auf den PostgreSQL-Dienst innerhalb von Kubernetes zugreifen. NodePort bietet die Möglichkeit, Dienstendpunkte auf den Kubernetes-Knoten verfügbar zu machen. Für den externen Zugriff auf PostgreSQL müssen wir einen Load Balancer-Diensttyp verwenden, der den Dienst extern verfügbar macht.

Datei:postgres-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: postgres
  labels:
    app: postgres
spec:
  type: NodePort
  ports:
   - port: 5432
  selector:
   app: postgres

Postgres-Dienst erstellen

$ kubectl create -f postgres-service.yaml 
service "postgres" created

Mit PostgreSQL verbinden

Um PostgreSQL zu verbinden, müssen wir den Node-Port von der Dienstbereitstellung abrufen.

$ kubectl get svc postgres
NAME       TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
postgres   NodePort   10.107.71.253   <none>        5432:31070/TCP   5m

Wir müssen Port 31070 verwenden, um eine Verbindung zu PostgreSQL von einem Computer/Knoten herzustellen, der im Kubernetes-Cluster vorhanden ist, mit Anmeldeinformationen, die zuvor in der Konfigurationskarte angegeben wurden.

$ psql -h localhost -U postgresadmin1 --password -p 31070 postgresdb
Password for user postgresadmin1: 
psql (10.4)
Type "help" for help.
 
postgresdb=#

PostgreSQL-Bereitstellungen löschen

Zum Löschen von PostgreSQL-Ressourcen müssen wir die folgenden Befehle verwenden.

# kubectl delete service postgres 
# kubectl delete deployment postgres
# kubectl delete configmap postgres-config
# kubectl delete persistentvolumeclaim postgres-pv-claim
# kubectl delete persistentvolume postgres-pv-volume

Hoffentlich können Sie mit den obigen Schritten eine eigenständige PostgreSQL-Instanz in einem Kubernetes-Cluster bereitstellen.

Schlussfolgerung

Das Ausführen von PostgreSQL auf Kubernetes hilft dabei, Ressourcen besser zu nutzen, als wenn nur virtuelle Maschinen verwendet werden. Kubernetes bietet auch die Isolierung anderer Anwendungen, die PostgreSQL innerhalb derselben virtuellen Maschine oder desselben Kubernetes-Clusters verwenden.

Dieser Artikel bietet einen Überblick darüber, wie wir PostgreSQL auf Kubernetes für Entwicklungs-/POC-Umgebungen verwenden können. Sie können PostgreSQL-Cluster mit Statefulsets von Kubernetes erkunden/einrichten.

StatefulSets erforderlich?

In Kubernetes sind StatefulSets erforderlich, um zustandsbehaftete Anwendungen zu skalieren. PostgreSQL kann mithilfe von StatefulSets einfach mit einem einzigen Befehl skaliert werden.

Referenzen

• Kubernetes-Installation auf CentOS:https://www.techrepublic.com/article/how-to-install-a-kubernetes-cluster-oen-centos-7
• Kubectl-Setup:https://kubernetes.io/docs/tasks/tools/install-kubectl
• PostgreSQL mit Docker:https://severalnines.com/blog/deploying-postgresql-docker-container
• Kubernetes:https://kubernetes.io
• PostgreSQL-Cluster mit Statefulsets https://kubernetes.io/blog/2017/02/postgresql-clusters-kubernetes-statefulsets