Brug af Kubernetes til at implementere PostgreSQL

Introduktion

Kubernetes er et open source container-orkestreringssystem til automatisering af udrulning, skalering og styring af containeriserede applikationer. Kørsel af en PostgreSQL-database på Kubernetes er et diskussionsemne i dag, da Kubernetes tilbyder måder at klargøre stateful container ved hjælp af vedvarende volumener, statefulsets osv.

Denne blog havde til formål at give trin til at køre PostgreSQL-databasen på Kubernetes-klyngen. Det dækker ikke installationen eller konfigurationen af ​​Kubernetes-klyngen, selvom vi tidligere har skrevet om det i denne blog på MySQL Galera Cluster på Kubernetes.

Forudsætninger

• Working Kubernetes Cluster
• Grundlæggende forståelse af Docker

Du kan klargøre Kubernetes-klyngen på enhver offentlig cloud-udbyder som AWS, Azure eller Google cloud osv. Se installations- og konfigurationstrinene til Kubernetes-klyngen for CentOS her. Du kan også tjekke det tidligere blogindlæg for grundlæggende oplysninger om implementering af PostgreSQL på Docker-container.

For at implementere PostgreSQL på Kubernetes skal vi følge nedenstående trin:

• Postgres Docker-billede
• Konfigurer kort til lagring af Postgres-konfigurationer
• Vedholdende lagervolumen
• PostgreSQL-implementering
• PostgreSQL-tjeneste

PostgreSQL Docker-billede

Vi bruger PostgreSQL 10.4 Docker-billede fra det offentlige register. Dette billede vil give funktionaliteten til at levere tilpassede konfigurationer/miljøvariabler af PostgreSQL som brugernavn, adgangskode, databasenavn og sti osv.

Konfigurer kort til PostgreSQL-konfigurationer

Vi vil bruge config maps til at gemme PostgreSQL relaterede oplysninger. Her bruger vi databasen, brugeren og adgangskoden i konfigurationskortet, som vil blive brugt af PostgreSQL-pod'en i implementeringsskabelonen.

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

Opret Postgres config maps ressource

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

Vedholdende lagervolumen

Som I alle ved, at Docker-containere er flygtige i naturen. Alle data, der er genereret af eller i containeren, vil gå tabt efter afslutning af containerforekomsten.

For at gemme dataene vil vi bruge persistente volumener og vedvarende volumenkravsressourcer i Kubernetes til at gemme dataene på vedvarende lager.

Her bruger vi lokal mappe/sti som vedvarende lagerressource (/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

Opret lagerrelaterede implementeringer

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

PostgreSQL-implementering

PostgreSQL-manifest til udrulning af PostgreSQL-container bruger PostgreSQL 10.4-image. Det bruger PostgreSQL-konfiguration som brugernavn, adgangskode, databasenavn fra configmap, som vi oprettede tidligere. Den monterer også den volumen, der er oprettet fra de vedvarende volumener og hævder at få PostgreSQL-beholderens data til at fortsætte.

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

Opret Postgres-implementering

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

PostgreSQL-tjeneste

For at få adgang til implementeringen eller containeren skal vi eksponere PostgreSQL-tjenesten. Kubernetes leverer forskellige typer tjenester som ClusterIP, NodePort og LoadBalancer.

Med ClusterIP kan vi få adgang til PostgreSQL-tjenesten i Kubernetes. NodePort giver mulighed for at afsløre tjenesteslutpunkter på Kubernetes-knuderne. For at få adgang til PostgreSQL eksternt, skal vi bruge en Load Balancer-tjenestetype, som eksponerer tjenesten eksternt.

Fil:postgres-service.yaml

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

Opret Postgres Service

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

Opret forbindelse til PostgreSQL

For at forbinde PostgreSQL skal vi hente Node-porten fra serviceimplementeringen.

$ 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 skal bruge port 31070 for at oprette forbindelse til PostgreSQL fra maskine/node, der er til stede i kubernetes-klyngen med legitimationsoplysninger givet i configmap tidligere.

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

Slet PostgreSQL-implementeringer

For sletning af PostgreSQL-ressourcer skal vi bruge nedenstående kommandoer.

# 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

Forhåbentlig er du ved at bruge ovenstående trin i stand til at klargøre en selvstændig PostgreSQL-instans på en Kubernetes-klynge.

Konklusion

At køre PostgreSQL på Kubernetes hjælper med at udnytte ressourcer på en bedre måde, end når man kun bruger virtuelle maskiner. Kubernetes giver også isolering af andre applikationer, der bruger PostgreSQL inden for den samme virtuelle maskine eller Kubernetes-klynge.

Denne artikel giver et overblik over, hvordan vi kan bruge PostgreSQL på Kubernetes til udvikling/POC-miljø. Du kan udforske/opsætte PostgreSQL-klynge ved hjælp af Kubernetes-statefulsets.

StatefulSets påkrævet?

I Kubernetes kræves StatefulSets for at skalere stateful-applikationer. PostgreSQL kan nemt skaleres ved hjælp af StatefulSets med en enkelt kommando.

Referencer

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