Använder Kubernetes för att distribuera PostgreSQL

Introduktion

Kubernetes är ett containerorkestreringssystem med öppen källkod för automatisering av distribution, skalning och hantering av containeriserade applikationer. Att köra en PostgreSQL-databas på Kubernetes är ett diskussionsämne nuförtiden eftersom Kubernetes tillhandahåller sätt att tillhandahålla stateful container med beständiga volymer, statefulset etc.

Den här bloggen syftade till att ge steg för att köra PostgreSQL-databas på Kubernetes-kluster. Den täcker inte installationen eller konfigurationen av Kubernetes-klustret, även om vi tidigare skrivit om det i den här bloggen på MySQL Galera Cluster på Kubernetes.

Förutsättningar

• Fungerande Kubernetes-kluster
• Grundläggande förståelse för Docker

Du kan tillhandahålla Kubernetes-klustret på alla offentliga molnleverantörer som AWS, Azure eller Google cloud, etc. Se installations- och konfigurationssteg för Kubernetes-kluster för CentOS här. Du kan också läsa det tidigare blogginlägget för grunderna om att distribuera PostgreSQL på Docker-behållare.

För att distribuera PostgreSQL på Kubernetes måste vi följa stegen nedan:

• Postgres Docker-bild
• Konfigurera kartor för att lagra Postgres-konfigurationer
• Ihållande lagringsvolym
• PostgreSQL-distribution
• PostgreSQL-tjänst

PostgreSQL Docker Image

Vi använder PostgreSQL 10.4 Docker-bild från det offentliga registret. Den här bilden kommer att tillhandahålla funktionen att tillhandahålla anpassade konfigurationer/miljövariabler för PostgreSQL som användarnamn, lösenord, databasnamn och sökväg, etc.

Konfigurera kartor för PostgreSQL-konfigurationer

Vi kommer att använda konfigurationskartor för att lagra PostgreSQL-relaterad information. Här använder vi databasen, användaren och lösenordet i konfigurationskartan som kommer att användas av PostgreSQL-podden i distributionsmallen.

Fil:postgres-configmap.yaml

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

Skapa Postgres config maps resurs

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

Ihållande lagringsvolym

Som ni alla vet att Docker-containrar är tillfälliga till sin natur. All data som genereras av eller i containern kommer att gå förlorad efter avslutad containerinstans.

För att spara data kommer vi att använda beständiga volymer och beständiga volymanspråksresurser inom Kubernetes för att lagra data på beständiga lagringar.

Här använder vi lokal katalog/sökväg som beständig lagringsresurs (/mnt/data)

Fil: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

Skapa lagringsrelaterade distributioner

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

PostgreSQL-distribution

PostgreSQL-manifest för distribution av PostgreSQL-behållare använder PostgreSQL 10.4-avbildning. Den använder PostgreSQL-konfiguration som användarnamn, lösenord, databasnamn från configmap som vi skapade tidigare. Den monterar också volymen som skapas från de beständiga volymerna och hävdar att PostgreSQL-behållarens data kvarstår.

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

Skapa Postgres-distribution

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

PostgreSQL-tjänst

För att komma åt distributionen eller behållaren måste vi exponera PostgreSQL-tjänsten. Kubernetes tillhandahåller olika typer av tjänster som ClusterIP, NodePort och LoadBalancer.

Med ClusterIP kan vi komma åt PostgreSQL-tjänsten inom Kubernetes. NodePort ger möjlighet att exponera tjänstens slutpunkt på Kubernetes-noderna. För att komma åt PostgreSQL externt måste vi använda en Load Balancer-tjänstetyp som exponerar tjänsten externt.

Fil:postgres-service.yaml

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

Skapa Postgres-tjänst

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

Anslut till PostgreSQL

För att ansluta PostgreSQL måste vi hämta nodporten från tjänstedistributionen.

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

Vi måste använda port 31070 för att ansluta till PostgreSQL från maskin/nod som finns i kubernetes-klustret med autentiseringsuppgifter som gavs i configmap tidigare.

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

Ta bort PostgreSQL-distributioner

För radering av PostgreSQL-resurser måste vi använda nedanstående kommandon.

# 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

Förhoppningsvis kan du, genom att använda stegen ovan, tillhandahålla en fristående PostgreSQL-instans i ett Kubernetes-kluster.

Slutsats

Att köra PostgreSQL på Kubernetes hjälper till att utnyttja resurser på ett bättre sätt än när man bara använder virtuella maskiner. Kubernetes tillhandahåller också isolering av andra applikationer som använder PostgreSQL inom samma virtuella maskin eller Kubernetes-kluster.

Den här artikeln ger en översikt om hur vi kan använda PostgreSQL på Kubernetes för utveckling/POC-miljö. Du kan utforska/konfigurera PostgreSQL-kluster med hjälp av tillståndsuppsättningar av Kubernetes.

StatefulSets krävs?

I Kubernetes krävs StatefulSets för att skala stateful applikationer. PostgreSQL kan enkelt skalas med StatefulSets med ett enda kommando.

Referenser

• Kubernetes-installation på CentOS:https://www.techrepublic.com/article/how-to-install-a-kubernetes-cluster-oen-centos-7
• Kubectl-installation:https://kubernetes.io/docs/tasks/tools/install-kubectl
• PostgreSQL med Docker:https://severalnines.com/blog/deploying-postgresql-docker-container
• Kubernetes:https://kubernetes.io
• PostgreSQL-kluster med statefulsets https://kubernetes.io/blog/2017/02/postgresql-clusters-kubernetes-statefulsets