Utilizzo di Kubernetes per distribuire PostgreSQL

Introduzione

Kubernetes è un sistema di orchestrazione di container open source per automatizzare la distribuzione, la scalabilità e la gestione delle applicazioni containerizzate. L'esecuzione di un database PostgreSQL su Kubernetes è un argomento di discussione al giorno d'oggi poiché Kubernetes fornisce modi per eseguire il provisioning di container con stato utilizzando volumi persistenti, set di stati, ecc.

Questo blog intendeva fornire i passaggi per eseguire il database PostgreSQL sul cluster Kubernetes. Non copre l'installazione o la configurazione del cluster Kubernetes, anche se ne abbiamo già parlato in questo blog su MySQL Galera Cluster su Kubernetes.

Prerequisiti

• Gruppo Kubernetes funzionante
• Conoscenza di base di Docker

Puoi eseguire il provisioning del cluster Kubernetes su qualsiasi provider di cloud pubblico come AWS, Azure o Google cloud, ecc. Fai riferimento ai passaggi di installazione e configurazione del cluster Kubernetes per CentOS qui. Puoi anche controllare il post precedente del blog per informazioni di base sulla distribuzione di PostgreSQL nel contenitore Docker.

Per distribuire PostgreSQL su Kubernetes dobbiamo seguire i passaggi seguenti:

• Immagine Docker Postgres
• Config Maps per memorizzare le configurazioni di Postgres
• Volume di archiviazione persistente
• Distribuzione PostgreSQL
• Servizio PostgreSQL

Immagine Docker PostgreSQL

Stiamo usando PostgreSQL 10.4 Immagine Docker dal registro pubblico. Questa immagine fornirà la funzionalità di fornire configurazioni personalizzate/variabili di ambiente di PostgreSQL come nome utente, password, nome e percorso del database, ecc.

Configura mappe per configurazioni PostgreSQL

Useremo le mappe di configurazione per memorizzare le informazioni relative a PostgreSQL. Qui utilizziamo il database, l'utente e la password nella mappa di configurazione che verrà utilizzata dal pod PostgreSQL nel modello di distribuzione.

File:postgres-configmap.yaml

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

Crea una risorsa per le mappe di configurazione di Postgres

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

Volume di archiviazione persistente

Come tutti sapete, i container Docker sono di natura effimera. Tutti i dati generati da o nel contenitore andranno persi dopo la chiusura dell'istanza del contenitore.

Per salvare i dati, utilizzeremo i volumi persistenti e la risorsa di richiesta di volume persistente all'interno di Kubernetes per archiviare i dati su archivi persistenti.

Qui stiamo usando la directory/il percorso locale come risorsa di archiviazione persistente (/mnt/data)

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

Crea implementazioni relative allo storage

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

Distribuzione PostgreSQL

Il manifest PostgreSQL per la distribuzione del contenitore PostgreSQL utilizza l'immagine PostgreSQL 10.4. Sta usando la configurazione di PostgreSQL come nome utente, password, nome del database dalla mappa di configurazione che abbiamo creato in precedenza. Monta anche il volume creato dai volumi persistenti e afferma di rendere persistenti i dati del contenitore PostgreSQL.

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

Crea distribuzione Postgres

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

Servizio PostgreSQL

Per accedere alla distribuzione o al contenitore, è necessario esporre il servizio PostgreSQL. Kubernetes fornisce diversi tipi di servizi come ClusterIP, NodePort e LoadBalancer.

Con ClusterIP possiamo accedere al servizio PostgreSQL all'interno di Kubernetes. NodePort offre la possibilità di esporre l'endpoint del servizio sui nodi Kubernetes. Per accedere a PostgreSQL esternamente, dobbiamo utilizzare un tipo di servizio Load Balancer che esponga il servizio esternamente.

File:postgres-service.yaml

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

Crea un servizio Postgres

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

Connetti a PostgreSQL

Per connettere PostgreSQL, dobbiamo ottenere la porta Node dalla distribuzione del servizio.

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

Dobbiamo usare la porta 31070 per connetterci a PostgreSQL dalla macchina/nodo presente nel cluster kubernetes con le credenziali fornite in precedenza nella mappa di configurazione.

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

Elimina le distribuzioni PostgreSQL

Per eliminare le risorse PostgreSQL, dobbiamo usare i comandi seguenti.

# 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

Si spera che utilizzando i passaggi precedenti sia possibile eseguire il provisioning di un'istanza PostgreSQL autonoma su un cluster Kubernetes.

Conclusione

L'esecuzione di PostgreSQL su Kubernetes aiuta a utilizzare le risorse in un modo migliore rispetto a quando si utilizzano solo macchine virtuali. Kubernetes fornisce anche l'isolamento di altre applicazioni che utilizzano PostgreSQL all'interno della stessa macchina virtuale o cluster Kubernetes.

Questo articolo fornisce una panoramica su come utilizzare PostgreSQL su Kubernetes per l'ambiente di sviluppo/POC. Puoi esplorare/configurare il cluster PostgreSQL utilizzando i set di stati di Kubernetes.

StatefulSets necessari?

In Kubernetes, gli StatefulSet sono necessari per ridimensionare le applicazioni con stato. PostgreSQL può essere facilmente ridimensionato utilizzando StatefulSets con un singolo comando.

Riferimenti

• Installazione di Kubernetes su CentOS:https://www.techrepublic.com/article/how-to-install-a-kubernetes-cluster-oen-centos-7
• Configurazione di Kubectl:https://kubernetes.io/docs/tasks/tools/install-kubectl
• PostgreSQL utilizzando Docker:https://diversealnines.com/blog/deploying-postgresql-docker-container
• Kubernetes:https://kubernetes.io
• Cluster PostgreSQL che utilizza statefulsets https://kubernetes.io/blog/2017/02/postgresql-clusters-kubernetes-statefulsets