Paris, le 28 août 2025

Ceci est le second article dans la série sur l’industrialisation de PostgreSQL. Nous allons voir dans celui-ci comment installer pglift et les composants additionnels requis. Nous allons ensuite déployer une instance accompagnée d’un exporter prometheus pour sa supervision.

pglift est le composant au cœur de la plateforme, il permet le déploiement industriel des instances. Il peut être manipulé en ligne de commande, ou par le biais d’un module Ansible, ce qui sera la méthode favorisée dans le reste de cet article.

Installation de pglift, PostgreSQL et ses outils satellites

L’outil pglift, développé en Python, requiert une version 3.10 ou plus de Python sous une distribution Linux. Quant à PostgreSQL, la version officielle est supporté sur plusieurs distributions Linux (Debian, Red Hat/Rocky, Ubuntu…). L’installation présentée ici sera réalisé à l’aide d’Ansible et des collections Dalibo publiques sur une machine virtuelle Rocky Linux 9. Cela nécessite donc quelques prérequis à installer sur cette machine virtuelle.

Prérequis

Sur le nœud managé :

• Python >=3.10
• Une connexion SSH sur un utilisateur avec les droits sudo

Sur le nœud de contrôle Ansible :

• Ansible Core >=2.13.0
• Python >=3.9

De plus, il est nécessaire d’installer les collections Ansible sur le nœud de contrôle qui seront utilisés au sein des playbooks. Pour faciliter l’installation des différentes collections, nous allons les consigner au sein d’un fichier :

$ cat requirements.yaml
collections:
  - dalibo.pglift
  - dalibo.essential
  - dalibo.extras

Puis procéder à l’installation avec la commande suivante :

$ ansible-galaxy install -r requirements.yaml 

Le fichier d’inventaire

Dans l’exemple de cet article, l’inventaire Ansible sera relativement simple étant donné que nous allons déployer pglift et PostgreSQL au sein d’une seule machine virtuelle :

$ cat inventory 
srv-pg1 ansible_host=192.168.122.19 ansible_user=ansible

[database]
srv-pg1

Nous ajoutons donc notre hôte srv-pg1 dans un groupe nommé database.

Un playbook simple

Voici un exemple de playbook simple pour la partie installation (setup.yaml):

---

- name: Install Repos, pglift and PostgreSQL
  hosts: database
  gather_facts: true
  become: true
  vars:
    postgresql_major_version: 17
    pglift_lingering_mode: true
    pglift_configure_shell_completion: true
    pglift_settings_content:
      systemd: {}
      postgresql:
        default_version: '17'
        datadir: '/var/lib/pgsql/{version}/{name}/data'
        waldir: '/var/lib/pgsql/{version}/{name}/wal'
  pre_tasks:
    - name: Ensure the crb repository is enabled
      community.general.dnf_config_manager:
        name: crb
        state: enabled
  roles:
    - dalibo.extras.repo_epel
    - dalibo.extras.repo_dalibo_labs
    - dalibo.essential.repo_pgdg
    - dalibo.essential.postgresql
    - dalibo.essential.prometheus_postgres_exporter
    - dalibo.essential.pglift

Avec ce playbook, le groupe d’hôtes database est ciblé. Plusieurs rôles seront alors exécutés afin d’installer les dépôts de paquets nécessaires à l’installation de PostgreSQL et quelques outils satellites.

Par la suite, l’installation de PostgreSQL et de l’exporter prometheus postgres-exporter est réalisée à l’aide du rôle dalibo.essential.postgresql et dalibo.essential.prometheus_postgres_exporter. La version de PostgreSQL est déterminée par la variable Ansible postgresql_major_version.

Le rôle dalibo.essential.pglift se chargera d’installer pglift, en utilisant pip et d’appliquer une configuration initiale. Cette configuration est assurée par la variable pglift_settings_content, au format YAML.

Nous pouvons désormais exécuter ce playbook avec l’inventaire créé précédemment :

$ ansible-playbook -i inventory setup.yaml

À la fin de cette exécution, nous pourrons alors déployer notre première instance à l’aide du module dalibo.pglift.instance de la collection dalibo.pglift.

Déploiement de l’instance avec le module Ansible pglift

Maintenant que pglift est installé et configuré, il est possible de déployer des instances.

Le déploiement de l’instance PostgreSQL peut se faire à l’aide d’un playbook. Celui-ci appelle le module dalibo.pglift.instance dans une tâche à destination de notre groupe d’hôtes database :

---
- name: Deploy PostgreSQL instance
  hosts: database
  become: true
  become_user: postgres
  become_flags: "-i"
  tasks:
    - name: Instance main
      dalibo.pglift.instance:
        name: main
        port: 5432
        settings:
          shared_buffers: 1GB
        roles:
          - name: alice
            login: true
        databases:
          - name: db1
            owner: alice

Contrairement au playbook d’installation qui contenait seulement une clause become: true, ce playbook contient également la clause become_user: postgres pour spécifier que les actions sont à exécuter en tant que postgres sur le serveur. On ajoute également become_flags: "-i" pour que le PATH de l’utilisateur postgres soit bien chargé lors de l’exécution, ce qui permet de s’assurer de la disponibilité du binaire de pglift.

Le module accepte des options de configuration pour PostgreSQL. Ici, nous configurons un cache disque (shared_buffers) de 1GB.

Il est également possible de créer des rôles et bases de données dès le déploiement de l’instance en les spécifiant lors de l’appel du module. La base de données db1 et le rôle alice sont ainsi créés sur notre instance sans action supplémentaire.

Exécuter le playbook pour procéder au déploiement de l’instance :

$ ansible-playbook -i inventory instance_main.yaml

Depuis le serveur PostgreSQL, en tant que postgres, on peut vérifier la présence de notre nouvelle instance :

[postgres@srv-pg1 ~]$ pglift instance list
┏━━━━━━┳━━━━━━━━━┳━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┓
┃ name ┃ version ┃ port ┃ datadir                     ┃ status  ┃
┡━━━━━━╇━━━━━━━━━╇━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━┩
│ main │ 17      │ 5432 │ /var/lib/pgsql/17/main/data │ running │
└──────┴─────────┴──────┴─────────────────────────────┴─────────┘

Pour obtenir une instance similaire avec l’interface de ligne de commande de pglift, on aurait exécuté les commandes suivantes :

$ pglift instance create main --port 5432
$ pglift pgconf set shared_buffers=1GB
$ pglift role create alice --login
$ pglift database create db1 --owner alice

Administration de l’instance PostgreSQL

Gestion de l’état de l’instance

Pour arrêter, démarrer, ou redémarrer l’instance via Ansible, on peut jouer sur la clause state du module dalibo.pglift.instance. Pour un état arrêté, on lui passe la valeur stopped. Pour l’état démarré, la valeur started. Enfin, pour la redémarrer, la valeur restarted.

Ainsi, à chaque exécution du playbook suivant, l’instance est redémarée :

- name: Deploy PostgreSQL instance
  hosts: database
  become: true
  gather_facts: true
  become_flags: "-i"
  become_user: postgres
  tasks:
    - name: Instance main
      dalibo.pglift.instance:
        name: main
        port: 5432
        settings:
          shared_buffers: 1GB
        roles:
          - name: alice
            login: true
        databases:
          - name: db1
            owner: alice
        state: restarted

En ligne de commande, la gestion d’état se fait avec les commandes pglift suivantes :

$ pglift instance stop main
$ pglift instance start main
$ pglift instance restart main

Gestion du paramètrage

Pour faire évoluer le paramétrage de l’instance avec Ansible, il est possible de modifier la configuration dans notre playbook, et le re-exécuter.

Ainsi, le playbook suivant peut être exécuté pour modifier la valeur du cache disque (shared_buffers), tout en définissant une valeur pour work_mem.

- name: Deploy PostgreSQL instance
  hosts: database
  become: true
  gather_facts: true
  become_flags: "-i"
  become_user: postgres
  tasks:
    - name: Instance main
      dalibo.pglift.instance:
        name: main
        port: 5432
        settings:
          shared_buffers: 500MB
          work_mem: 20MB
        roles:
          - name: alice
            login: true
        databases:
          - name: db1
            owner: alice
        state: restarted

Nous conservons la clause state: restarted ajoutée à l’étape précédente, ici elle nous rend même service. En effet, le paramètre shared_buffers nécessite un redémarrage de l’instance pour être pris en compte. Lors de l’exécution de ce playbook ainsi modifié, l’instance est redémarrée après la mise à jour des paramètres.

Après l’exécution du playbook, la nouvelle valeur pour shared_buffers est donc directement effective, en plus de celle du work_mem :

[17/main] postgres@~=# show shared_buffers;
 shared_buffers
----------------
 500MB
(1 row)

[17/main] postgres@~=# show work_mem;
 work_mem
----------
 20MB
(1 row)

En ligne de commande, la modification des paramètres se fait avec la commande pglift pgconf, de la façon suivante :

$ pglift pgconf set work_mem=20MB
$ pglift pgconf set shared_buffers=500MB

Lorsque le paramètre modifié peut être pris en compte à chaud, la configuration de l’instance est simplement rechargée, mais lorsque le paramètre nécessite un redémarrage, comme par exemple le shared_buffers, la commande propose de redémarrer l’instance via un prompt interactif :

$ pglift pgconf set shared_buffers=500MB;
INFO     configuring PostgreSQL
WARNING  instance 17/main needs restart due to parameter changes: shared_buffers
> PostgreSQL needs to be restarted; restart now? [y/n] (n): y
INFO     restarting systemd unit pglift-postgresql@17-main.service
shared_buffers: 1GB -> 500MB

Bases de données et rôles

Nous avons vu que le module dalibo.pglift.instance était capable de déployer pour nous des bases de données et rôles lors de la création d’instance. On pourrait imaginer gérer ces derniers dans le playbook de création d’instance, mais pglift fournit aussi des modules dédiés à la gestion des bases de données (dalibo.pglift.database) et des rôles (dalibo.pglift.role).

Il est ainsi possible d’éxecuter le playbook suivant pour ajouter un rôle bob et la base de données db2, dont il sera propriétaire, et qui sera initalisée avec un schéma s1 :

- name: Deploy role and database
  hosts: database
  become: true
  gather_facts: true
  become_flags: "-i"
  become_user: postgres
  tasks:
    - name: Role bob
      dalibo.pglift.role:
        name: bob
        instance: main
        login: true
        createdb: true
    - name: Database db2
      dalibo.pglift.database:
        name: db2
        instance: main
        owner: bob
        schemas:
          - name: s1
            owner: bob

En ligne de commande, il est possible de créer des rôles et bases de données avec les commandes suivantes :

$ pglift role create bob --login --createdb
$ pglift database create db2 --owner bob --schema s1

Ressources utiles

Pour aller plus loin dans l’utilisation de pglift et des collections Ansible, voici une sélection de ressources :

• Documentation de pglift
• Collections Ansible Dalibo
• Dalibo Labs

D’autres fonctionnalités utiles de pglift seront également abordées dans cette serie d’article sur l’industrialisation de PostgreSQL.

Conclusion

Avec l’aide des collections Ansible ainsi que du module pglift, l’installation et la configuration d’une instance PostgreSQL sont simplifiées et intégrables dans une démarche d’industrialisation. Avec quelques fichiers déclaratifs et une commande Ansible, on obtient une instance avec ses bases de données et rôles, fonctionnelle tout en suivant les bonnes pratiques.

Ce second article est une introduction à l’utilisation de pglift. Les prochains articles couvriront des sujets plus avancés comme la sauvegarde logique ou physique, la supervision ou encore la haute-disponibilité.