Utiliser Kubernetes pour déployer PostgreSQL

Présentation

Kubernetes est un système d'orchestration de conteneurs open source permettant d'automatiser le déploiement, la mise à l'échelle et la gestion des applications conteneurisées. L'exécution d'une base de données PostgreSQL sur Kubernetes est un sujet de discussion de nos jours, car Kubernetes fournit des moyens de provisionner un conteneur avec état à l'aide de volumes persistants, d'ensembles avec état, etc.

Ce blog vise à fournir des étapes pour exécuter la base de données PostgreSQL sur le cluster Kubernetes. Il ne couvre pas l'installation ou la configuration du cluster Kubernetes, bien que nous en ayons déjà parlé dans ce blog sur MySQL Galera Cluster sur Kubernetes.

Prérequis

• Cluster Kubernetes opérationnel
• Compréhension de base de Docker

Vous pouvez provisionner le cluster Kubernetes sur n'importe quel fournisseur de cloud public comme AWS, Azure ou Google cloud, etc. Reportez-vous ici aux étapes d'installation et de configuration du cluster Kubernetes pour CentOS. Vous pouvez également consulter le billet de blog précédent pour connaître les bases du déploiement de PostgreSQL sur le conteneur Docker.

Pour déployer PostgreSQL sur Kubernetes, nous devons suivre les étapes ci-dessous :

• Image Docker Postgres
• Config Maps pour stocker les configurations Postgres
• Volume de stockage persistant
• Déploiement PostgreSQL
• Service PostgreSQL

Image Docker PostgreSQL

Nous utilisons PostgreSQL 10.4 Image Docker du registre public. Cette image fournira la fonctionnalité de fournir des configurations personnalisées/variables d'environnement de PostgreSQL comme le nom d'utilisateur, le mot de passe, le nom et le chemin de la base de données, etc.

Cartes de configuration pour les configurations PostgreSQL

Nous utiliserons des cartes de configuration pour stocker les informations relatives à PostgreSQL. Ici, nous utilisons la base de données, l'utilisateur et le mot de passe dans la carte de configuration qui seront utilisés par le pod PostgreSQL dans le modèle de déploiement.

Fichier :postgres-configmap.yaml

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

Créer une ressource de cartes de configuration Postgres

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

Volume de stockage persistant

Comme vous le savez tous, les conteneurs Docker sont de nature éphémère. Toutes les données générées par ou dans le conteneur seront perdues après la résiliation de l'instance de conteneur.

Pour enregistrer les données, nous utiliserons des volumes persistants et une ressource de demande de volume persistant dans Kubernetes pour stocker les données sur des stockages persistants.

Ici, nous utilisons le répertoire/chemin local comme ressource de stockage persistante (/mnt/data)

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

Créer des déploiements liés au stockage

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

Déploiement PostgreSQL

Le manifeste PostgreSQL pour le déploiement du conteneur PostgreSQL utilise l'image PostgreSQL 10.4. Il utilise la configuration PostgreSQL comme le nom d'utilisateur, le mot de passe, le nom de la base de données du configmap que nous avons créé précédemment. Il monte également le volume créé à partir des volumes persistants et prétend rendre les données du conteneur PostgreSQL persistantes.

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

Créer un déploiement Postgres

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

Service PostgreSQL

Pour accéder au déploiement ou au conteneur, nous devons exposer le service PostgreSQL. Kubernetes fournit différents types de services tels que ClusterIP, NodePort et LoadBalancer.

Avec ClusterIP, nous pouvons accéder au service PostgreSQL dans Kubernetes. NodePort permet d'exposer le point de terminaison de service sur les nœuds Kubernetes. Pour accéder à PostgreSQL en externe, nous devons utiliser un type de service Load Balancer qui expose le service en externe.

Fichier :postgres-service.yaml

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

Créer un service Postgres

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

Se connecter à PostgreSQL

Pour connecter PostgreSQL, nous devons obtenir le port du nœud à partir du déploiement du service.

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

Nous devons utiliser le port 31070 pour nous connecter à PostgreSQL à partir de la machine/nœud présent dans le cluster kubernetes avec les informations d'identification fournies précédemment dans le configmap.

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

Supprimer les déploiements PostgreSQL

Pour supprimer les ressources PostgreSQL, nous devons utiliser les commandes ci-dessous.

# 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

Espérons qu'en suivant les étapes ci-dessus, vous pourrez provisionner une instance PostgreSQL autonome sur un cluster Kubernetes.

Conclusion

L'exécution de PostgreSQL sur Kubernetes permet d'utiliser les ressources de manière plus efficace qu'en utilisant simplement des machines virtuelles. Kubernetes permet également d'isoler d'autres applications utilisant PostgreSQL au sein de la même machine virtuelle ou du même cluster Kubernetes.

Cet article fournit un aperçu de la façon dont nous pouvons utiliser PostgreSQL sur Kubernetes pour l'environnement de développement/POC. Vous pouvez explorer/configurer le cluster PostgreSQL à l'aide des ensembles d'états de Kubernetes.

StatefulSets requis ?

Dans Kubernetes, les StatefulSets sont nécessaires pour mettre à l'échelle les applications avec état. PostgreSQL peut être facilement mis à l'échelle à l'aide de StatefulSets avec une seule commande.

Références

• Installation de Kubernetes sur CentOS :https://www.techrepublic.com/article/how-to-install-a-kubernetes-cluster-oen-centos-7
• Configuration de Kubectl :https://kubernetes.io/docs/tasks/tools/install-kubectl
• PostgreSQL avec Docker :https://severalnines.com/blog/deploying-postgresql-docker-container
• Kubernetes :https://kubernetes.io
• Cluster PostgreSQL utilisant des ensembles d'états https://kubernetes.io/blog/2017/02/postgresql-clusters-kubernetes-statefulsets