Kubernetes gebruiken om PostgreSQL te implementeren

Inleiding

Kubernetes is een open source containerorkestratiesysteem voor het automatiseren van implementatie, schaling en beheer van gecontaineriseerde applicaties. Het runnen van een PostgreSQL-database op Kubernetes is tegenwoordig een onderwerp van discussie, aangezien Kubernetes manieren biedt om stateful containers in te richten met behulp van persistente volumes, statefulsets, enz.

Deze blog is bedoeld om stappen te geven om de PostgreSQL-database op het Kubernetes-cluster uit te voeren. Het dekt niet de installatie of configuratie van het Kubernetes-cluster, hoewel we er eerder over schreven in deze blog op MySQL Galera Cluster op Kubernetes.

Vereisten

Werkende Kubernetes-cluster
Basiskennis van Docker

U kunt het Kubernetes-cluster inrichten op elke openbare cloudprovider, zoals AWS, Azure of Google-cloud, enz. Raadpleeg hier de installatie- en configuratiestappen voor Kubernetes-clusters voor CentOS. Je kunt ook de eerdere blogpost raadplegen voor basisinformatie over het implementeren van PostgreSQL op de Docker-container.

Om PostgreSQL op Kubernetes te implementeren, moeten we de onderstaande stappen volgen:

Postgres Docker-afbeelding
Config Maps voor het opslaan van Postgres-configuraties
Persistent opslagvolume
PostgreSQL-implementatie
PostgreSQL-service

PostgreSQL Docker-afbeelding

We gebruiken PostgreSQL 10.4 Docker-image uit het openbare register. Deze afbeelding biedt de functionaliteit van het leveren van aangepaste configuraties/omgevingsvariabelen van PostgreSQL zoals gebruikersnaam, wachtwoord, databasenaam en pad, enz.

Config Maps voor PostgreSQL-configuraties

We zullen configuratiekaarten gebruiken voor het opslaan van PostgreSQL-gerelateerde informatie. Hier gebruiken we de database, gebruiker en wachtwoord in de configuratiemap die door de PostgreSQL-pod in de implementatiesjabloon zal worden gebruikt.

Bestand:postgres-configmap.yaml

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

Bron voor Postgres-configuratiekaarten maken

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

Persistent opslagvolume

Zoals jullie allemaal weten, zijn Docker-containers kortstondig van aard. Alle gegevens die door of in de container worden gegenereerd, gaan verloren na beëindiging van de containerinstantie.

Om de gegevens op te slaan, gebruiken we persistente volumes en persistente volumeclaimresources binnen Kubernetes om de gegevens op te slaan op permanente opslagplaatsen.

Hier gebruiken we lokale map/pad als Persistente opslagbron (/mnt/data)

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

Opslaggerelateerde implementaties maken

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

PostgreSQL-implementatie

PostgreSQL-manifest voor implementatie van PostgreSQL-container gebruikt PostgreSQL 10.4-afbeelding. Het gebruikt PostgreSQL-configuratie zoals gebruikersnaam, wachtwoord, databasenaam van de configmap die we eerder hebben gemaakt. Het koppelt ook het volume aan dat is gemaakt op basis van de persistente volumes en beweert dat de gegevens van de PostgreSQL-container blijven bestaan.

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-implementatie maken

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

Download de whitepaper vandaag PostgreSQL-beheer en -automatisering met ClusterControlLees wat u moet weten om PostgreSQL te implementeren, bewaken, beheren en schalenDownload de whitepaper

PostgreSQL-service

Om toegang te krijgen tot de implementatie of container, moeten we de PostgreSQL-service beschikbaar stellen. Kubernetes biedt verschillende soorten services, zoals ClusterIP, NodePort en LoadBalancer.

Met ClusterIP hebben we toegang tot de PostgreSQL-service binnen Kubernetes. NodePort biedt de mogelijkheid om het service-eindpunt op de Kubernetes-knooppunten weer te geven. Voor externe toegang tot PostgreSQL moeten we een Load Balancer-servicetype gebruiken dat de service extern beschikbaar stelt.

Bestand:postgres-service.yaml

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

Postgres-service maken

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

Verbinden met PostgreSQL

Om PostgreSQL te verbinden, hebben we de Node-poort nodig van de service-implementatie.

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

We moeten poort 31070 gebruiken om verbinding te maken met PostgreSQL vanaf de machine/node die aanwezig is in het kubernetes-cluster met de referenties die eerder in de configmap zijn gegeven.

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

PostgreSQL-implementaties verwijderen

Voor het verwijderen van PostgreSQL-bronnen moeten we onderstaande opdrachten gebruiken.

# 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

Hopelijk kunt u met behulp van de bovenstaande stappen een zelfstandige PostgreSQL-instantie inrichten op een Kubernetes-cluster.

Conclusie

Het uitvoeren van PostgreSQL op Kubernetes helpt om bronnen op een betere manier te gebruiken dan wanneer alleen virtuele machines worden gebruikt. Kubernetes biedt ook isolatie van andere applicaties die gebruikmaken van PostgreSQL binnen dezelfde virtuele machine of Kubernetes-cluster.

Dit artikel geeft een overzicht van hoe we PostgreSQL op Kubernetes kunnen gebruiken voor ontwikkel-/POC-omgevingen. U kunt PostgreSQL-clusters verkennen/instellen met statefulsets van Kubernetes.

StatefulSets vereist?

In Kubernetes zijn StatefulSets vereist om stateful-toepassingen te schalen. PostgreSQL kan eenvoudig worden geschaald met StatefulSets met een enkele opdracht.

Referenties

Kubernetes-installatie op CentOS:https://www.techrepublic.com/article/how-to-install-a-kubernetes-cluster-oen-centos-7
Kubectl-configuratie:https://kubernetes.io/docs/tasks/tools/install-kubectl
PostgreSQL met Docker:https://severalnines.com/blog/deploying-postgresql-docker-container
Kubernetes:https://kubernetes.io
PostgreSQL-cluster met statefulsets https://kubernetes.io/blog/2017/02/postgresql-clusters-kubernetes-statefulsets