Comment déployer PostgreSQL sur Kubernetes

Présentation

PostgreSQL est un système de base de données relationnelle fiable et robuste avec des transactions conformes à ACID. Il est conçu pour gérer des charges de travail de toutes tailles, ce qui en fait un bon choix pour un usage personnel et des déploiements à grande échelle tels que des entrepôts de données, des serveurs Big Data ou des services Web.

Le déploiement de PostgreSQL sur Kubernetes crée une instance PostgreSQL évolutive et portable, tirant parti des bons côtés du SGBDR et de la plate-forme d'orchestration.

Cet article vous montrera deux méthodes de déploiement de PostgreSQL sur Kubernetes :à l'aide d'un graphique Helm ou en créant manuellement votre configuration.

Prérequis

Un cluster Kubernetes avec kubectl installé
Helm 3 installé
Privilèges administratifs sur votre système

Déployer PostgreSQL à l'aide de Helm

Helm vous offre un moyen simple et rapide de déployer une instance PostgreSQL sur votre cluster.

Étape 1 :Ajouter un référentiel Helm

1. Recherchez dans Artifact Hub un graphique Helm PostgreSQL que vous souhaitez utiliser. Ajoutez le référentiel du graphique à votre installation Helm locale en saisissant :

helm repo add [repository-name] [repository-address]

Cet article utilise le graphique Bitnami Helm pour l'installation de PostgreSQL.

2. Après avoir ajouté le référentiel, mettez à jour vos référentiels locaux.

helm repo update

Le système confirme la réussite de la mise à jour.

Étape 2 :Créer et appliquer un volume de stockage persistant

Les données de votre base de données Postgres doivent persister lors des redémarrages de pod.

1. Pour ce faire, créez une ressource PersistentVolume dans un fichier YAML, à l'aide d'un éditeur de texte tel que nano.

nano postgres-pv.yaml

Le contenu du fichier définit :

La ressource elle-même.
La classe de stockage.
La quantité d'espace de stockage alloué.
Les modes d'accès.
Le chemin de montage sur le système hôte.

Cet exemple utilise la configuration suivante :

apiVersion: v1
kind: PersistentVolume
metadata:
  name: postgresql-pv
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"

2. Enregistrez le fichier et quittez. Appliquez ensuite la configuration avec kubectl :

kubectl apply -f postgres-pv.yaml

Le système confirme la création du volume persistant.

Étape 3 :Créer et appliquer une revendication de volume persistant

1. Créez une demande de volume persistant (PVC) pour demander le stockage alloué à l'étape précédente.

nano postgres-pvc.yaml

L'exemple utilise la configuration suivante :

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgresql-pv-claim
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

2. Enregistrez le fichier et quittez. Appliquer la configuration avec kubectl :

kubectl apply -f postgres-pvc.yaml

Le système confirme la création réussie du PVC.

3. Utilisez kubectl get pour vérifier si le PVC est correctement connecté au PV :

kubectl get pvc

La colonne d'état indique que la revendication est liée .

Étape 4 :Installer le graphique Helm

Installez le graphique helm avec l'helm install commande. Ajouter --set flags à la commande pour connecter l'installation au PVC que vous avez créé et activer les autorisations de volume :

helm install [release-name] [repo-name] --set persistence.existingClaim=[pvc-name] --set volumePermissions.enabled=true

Le système affiche un rapport une fois l'installation réussie.

Étape 5 :Connectez-vous au client PostgreSQL

1. Exportez le POSTGRES_PASSWORD variable d'environnement pour pouvoir se connecter à l'instance PostgreSQL :

export POSTGRES_PASSWORD=$(kubectl get secret --namespace default psql-test-postgresql -o jsonpath="{.data.postgresql-password}" | base64 --decode)

2. Ouvrez une autre fenêtre de terminal et tapez la commande suivante pour rediriger le port Postgres :

kubectl port-forward --namespace default svc/psql-test-postgresql 5432:5432

Le système commence à gérer la connexion du port.

3. Réduisez la fenêtre de redirection de port et revenez à la précédente. Tapez la commande pour vous connecter à psql, un client PostgreSQL :

PGPASSWORD="$POSTGRES_PASSWORD" psql --host 127.0.0.1 -U postgres -d postgres -p 5432

Le psql l'invite de commande apparaît et PostgreSQL est prêt à recevoir votre entrée.

Déployez PostgreSQL en créant une configuration à partir de zéro

La configuration manuelle de Postgres sur Kubernetes vous permet d'affiner la configuration de votre déploiement.

Étape 1 :Créer et appliquer ConfigMap

La ressource ConfigMap contient les données utilisées pendant le processus de déploiement.

1. Créez un fichier ConfigMap YAML dans un éditeur de texte.

nano postgres-configmap.yaml

2. La partie la plus importante du fichier est la section des données, où vous fournissez un nom pour la base de données , le nom d'utilisateur , et le mot de passe pour se connecter à l'instance PostgreSQL.

L'exemple utilise les paramètres suivants dans le fichier ConfigMap.

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

3. Enregistrez le fichier et quittez. Appliquez ensuite la ressource avec kubectl :

kubectl apply -f postgres-configmap.yaml

Le système confirme la création réussie du fichier de configuration.

Étape 2 :Créer et appliquer un volume de stockage persistant et une revendication de volume persistant

1. Créez un fichier YAML pour la configuration du stockage.

nano postgres-storage.yaml

2. La méthode de déploiement de la charte Helm utilisait deux fichiers distincts pour le volume persistant et la demande de volume persistant, mais vous pouvez également placer les deux configurations dans un seul fichier, comme dans l'exemple ci-dessous.

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

3. Enregistrez le fichier et quittez. Appliquer les ressources avec kubectl :

kubectl apply -f postgres-storage.yaml

Le système confirme la création réussie du PV et du PVC.

4. Vérifiez que le PVC est connecté au PV avec la commande suivante :

kubectl get pvc

Le statut du PVC est Lié , et le PVC est prêt à être utilisé dans le déploiement PostgreSQL.

Étape 3 :Créer et appliquer le déploiement PostgreSQL

1. Créez un fichier YAML de déploiement.

nano postgres-deployment.yaml

2. Le fichier de déploiement contient la configuration du déploiement PostgreSQL et fournit des spécifications pour les conteneurs et les volumes :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:10.1
          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

3. Enregistrez le fichier et quittez. Appliquer le déploiement avec kubectl :

kubectl apply -f postgres-deployment.yaml

Le système confirme la création réussie du déploiement.

Étape 4 :Créer et appliquer le service PostgreSQL

1. Enfin, créez le fichier YAML pour configurer le service PostgreSQL.

nano postgres-service.yaml

2. Spécifiez le type de service et les ports. L'exemple utilise la configuration suivante :

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

3. Enregistrez le fichier et quittez. Appliquer la configuration avec kubectl :

kubectl apply -f postgres-service.yaml

Le système confirme la création réussie du service.

4. Utilisez la commande suivante pour répertorier toutes les ressources du système.

kubectl get all

Le pod et le déploiement affichent le 1/1 état prêt. Le nombre souhaité de jeux de répliques reflète ce qui est configuré dans le fichier YAML de déploiement.

Étape 5 :Connectez-vous à PostgreSQL

1. Lorsque toutes les ressources sont prêtes, utilisez kubectl exec pour se connecter à l'instance PostgreSQL.

kubectl exec -it [pod-name] --  psql -h localhost -U admin --password -p [port] postgresdb

2. Le système demande le mot de passe. Tapez le mot de passe défini à l'étape 1 et appuyez sur Entrée . Le psql l'invite de commande apparaît.

La base de données est maintenant prête à recevoir les entrées des utilisateurs.