PostgreSQL
 sql >> Base de données >  >> RDS >> PostgreSQL

Comment gérer vos bases de données PostgreSQL à partir de la CLI ClusterControl

Saviez-vous qu'en plus de l'interface utilisateur Web de ClusterControl, vous pouvez également utiliser une interface de ligne de commande pour gérer vos instances PostgreSQL ?

ClusterControl prend en charge la réplication en continu PostgreSQL (réplication asynchrone et synchrone) ainsi que l'instance PostgreSQL autonome. Nous avons fait de notre mieux pour que l'interface de ligne de commande soit proche de l'interface utilisateur en termes de fonctionnalités disponibles.

Pourquoi voudriez-vous utiliser la CLI ?

Il vous permet de déployer une configuration de réplication complète en une seule commande, d'effectuer un basculement ou d'ajouter de nouveaux nœuds à la configuration. Cela s'intègre très bien avec votre code d'automatisation d'infrastructure existant écrit en Ansible, Chef ou Puppet.

Ce billet de blog explique comment gérer un cluster de réplication en continu PostgreSQL à l'aide de l'interface de ligne de commande ClusterControl ou de s9s.

Notez que la plupart des fonctionnalités présentées dans cet article de blog nécessitent l'installation et l'exécution de ClusterControl avec un abonnement valide, soit une licence commerciale, soit une licence d'essai gratuite (valable jusqu'à 30 jours après l'installation de ClusterControl).

Déploiement et importation de cluster

Déployer un nouveau cluster

Avant de déployer un nouveau cluster ou d'importer un cluster PostgreSQL existant dans ClusterControl, assurez-vous que SSH sans mot de passe du nœud ClusterControl à tous les nœuds de base de données est configuré au préalable. Supposons que nous souhaitions déployer une nouvelle réplication en continu PostgreSQL à trois nœuds, exécutez les commandes suivantes sur le nœud ClusterControl :

$ whoami
root
$ ssh-keygen -t rsa # if you haven't generated SSH key
$ ssh-copy-id 192.168.0.91 # PostgreSQL1
$ ssh-copy-id 192.168.0.92 # PostgreSQL2
$ ssh-copy-id 192.168.0.93 # PostgreSQL3

Sur le nœud ClusterControl, vérifiez si vous pouvez exécuter la commande suivante sans mot de passe :

$ ssh 192.168.0.91 "ls /root"

Si vous pouvez voir le contenu du répertoire, vous êtes en bonne forme. Ensuite, utilisez ClusterControl CLI avec l'indicateur --create pour déployer le cluster :

$ s9s cluster \
--create \
--cluster-type=postgresql \
--nodes="192.168.0.91?master;192.168.0.92?slave;192.168.0.93?slave" \
--provider-version='11' \
--db-admin='postgres' \
--db-admin-passwd='s3cr3tP455' \
--os-user=root \
--os-key-file=/root/.ssh/id_rsa \
--cluster-name='PostgreSQL 11 Streaming Replication' \
--wait
Creating PostgreSQL Cluster
\ Job 259 RUNNING    [█▋        ]  15% Installing helper packages

Nous avons spécifié le premier nœud, 192.168.0.91 comme maître et les autres sont des esclaves. Puisque nous avons déjà configuré SSH sans mot de passe via l'utilisateur root, nous avons spécifié l'utilisateur du système d'exploitation comme "root" avec le fichier de clé SSH correspondant en utilisant l'indicateur --os-key-file . L'indicateur --wait signifie que le travail attendra et signalera la progression jusqu'à ce qu'il se termine.

Vous pouvez également surveiller la progression du déploiement à partir de l'interface utilisateur de ClusterControl sous Activité > Tâches > Création d'un cluster PostgreSQL :

Une fois le déploiement terminé, nous pouvons voir le résumé du cluster en cours d'exécution en utilisant l'indicateur --stat :

$ s9s cluster --stat

Importer un cluster existant

Si, par exemple, vous avez déjà déployé manuellement un cluster de réplication en continu PostgreSQL, vous pouvez l'importer dans ClusterControl à l'aide de l'indicateur --register, comme indiqué dans la commande suivante :

$ s9s cluster \
--register \
--cluster-type=postgresql \
--nodes="192.168.0.91;192.168.0.92;192.168.0.93" \
--provider-version='11' \
--db-admin='postgres' \
--db-admin-passwd='s3cr3tP455' \
--os-user=root \
--os-key-file=/root/.ssh/id_rsa \
--cluster-name="PostgreSQL 11" \
--wait
Register PostgreSQL
- Job 263 RUNNING    [        █ ] ---% Importing Cluster

ClusterControl se connectera ensuite aux nœuds spécifiés, découvrira la topologie et enregistrera le cluster dans ClusterControl. Vous pouvez vérifier avec la commande 's9s cluster --stat' comme indiqué ci-dessus.

Gestion des nœuds et des clusters

Contrôle des services

Pour effectuer un redémarrage progressif d'un cluster, spécifiez l'ID du cluster et utilisez l'indicateur --rolling-restart :

$ s9s cluster --rolling-restart --cluster-id=8 --wait
Rolling Restart
- Job 264 RUNNING    [██▊       ]  27% Waiting for 192.168.0.91

Utilisez l'indicateur --stop pour le composant "cluster" pour arrêter un cluster. Pour voir la sortie de la tâche au lieu de la barre de progression, nous pouvons utiliser l'indicateur --log à la place :

$ s9s cluster --stop --cluster-id=8 --log
This is an RPC V2 job (a job created through RPC V2).
The job owner is 'admin'.
Accessing '/.runtime/jobs/jobExecutor' to execute...
Access ok.
Setting cluster to 'SHUTTING_DOWN' state.
192.168.0.91:5432: Stopping PostgreSQL service.
192.168.0.91:5432: Waiting PostgreSQL top stop.
192.168.0.92:5432: Stopping PostgreSQL service.
192.168.0.92:5432: Waiting PostgreSQL top stop.
192.168.0.93:5432: Stopping PostgreSQL service.
192.168.0.93:5432: Waiting PostgreSQL top stop.
Setting cluster to 'STOPPED' state.

Il signalera les mêmes messages de travail que l'interface utilisateur Web. Semblable à ce qui précède, pour démarrer un cluster, utilisez simplement l'indicateur --start (nous utilisons l'indicateur --wait à la place pour voir la progression au lieu des journaux de travail) :

$ s9s cluster --start --cluster-id=8 --wait
Starting Cluster
\ Job 272 RUNNING    [     █    ] ---% Start Cluster

Pour redémarrer le service PostgreSQL sur un nœud de base de données, nous utilisons le composant "node" et l'indicateur --restart :

$ s9s node \
--restart \
--cluster-id=8 \
--nodes=192.168.0.92 \
--log
Preparing to restart host.
192.168.0.92:5432: Stopping PostgreSQL service.
192.168.0.92:5432: Waiting to stop.
192.168.0.92:5432: Starting PostgreSQL.
192.168.0.92:5432: The postgresql service was started.
192.168.0.92:5432: Waiting to start.

Pour arrêter et démarrer un nœud PostgreSQL, appliquez simplement la même commande avec l'indicateur --stop ou --start, comme indiqué ci-dessous :

$ s9s node --stop --cluster-id=8 --nodes=192.168.0.92
$ s9s node --start --cluster-id=8 --nodes=192.168.0.92

Notez que ces actions ne redémarreront pas le système.

Nœud de mise à l'échelle

Pour supprimer un nœud d'un cluster, utilisez l'indicateur --remove-node :

$ s9s cluster \
--remove-node \
--nodes=192.168.0.93 \
--cluster-id=8 \
--log
Removing node 192.168.0.93: checking job parameters.
192.168.0.93:5432: Stopping PostgreSQL service.
192.168.0.93:5432: Waiting to stop.
192.168.0.93:5432: removed PostgreSQL Server
Updating load balancers.

L'ajout d'un nouveau nœud fonctionne de la même manière, mais vous devez vous assurer au préalable que le nœud est accessible via SSH sans mot de passe. Configurez-le d'abord, puis ajoutez le nœud à l'aide de l'indicateur --add-node :

$ s9s cluster \
--add-node \
--nodes=192.168.0.93 \
--cluster-id=8 \
--log
addNode: Verifying job parameters.
Found a master candidate: 192.168.0.91:5432, adding 192.168.0.93:5432 as a slave.
Verifying job parameters.
192.168.0.93:5432: Disabling SELinux/Apparmor.
192.168.0.93: Checking firewall.
192.168.0.93: Disabling firewalld.
192.168.0.93: Flushing iptables.
192.168.0.93:5432: Installing new node.
192.168.0.93:5432: Using the master's data directory '/var/lib/pgsql/11/data'.
192.168.0.91: Checking size of '/var/lib/pgsql/11/data'.
192.168.0.91: /var/lib/pgsql/11/data size is 103.00 MiB.
192.168.0.93: Checking free space in '/var/lib/pgsql/11/data'.
192.168.0.93: /var/lib/pgsql/11/data has 34.19 GiB free space.
192.168.0.93:5432: Setting SELinux in permissive mode.
192.168.0.93:5432: Disabling firewall.
192.168.0.93:5432: Tuning OS parameters.
192.168.0.93:5432: Setting vm.swappiness = 1.
192.168.0.93:5432: Installing helper packages.
192.168.0.93: Upgrading nss.
192.168.0.93: Upgrading ca-certificates.
192.168.0.93: Installing net-tools.
192.168.0.93: Installing netcat.
192.168.0.93: Installing nc.
192.168.0.93: Installing socat.
192.168.0.93: Installing perl-Data-Dumper.
192.168.0.93: Installing which.
192.168.0.93: Installing perl-Data-Dumper-Names.
192.168.0.93: Installing psmisc.
192.168.0.93: Installing rsync.
192.168.0.93: Installing libaio.
192.168.0.93: Installing libevent.
192.168.0.93: Installing wget.
192.168.0.93: Installing curl.
192.168.0.93: Installing gnupg2.
192.168.0.93: Installing pigz.
192.168.0.93: Installing bzip2.
192.168.0.93: Installing iproute2.
192.168.0.93: Installing tar.
192.168.0.93: Installing openssl.
192.168.0.93: Upgrading openssl openssl-libs.
192.168.0.93: Finished with helper packages.
192.168.0.93:5432: Using External repositories.
192.168.0.93:5432: Setting up PostgreSQL repositories.
192.168.0.93:5432: Uninstalling old PostgreSQL packages.
192.168.0.93:5432: Installing PostgreSQL 11 packages (centos-7).
192.168.0.93:5432: PostgreSQL installed, init-name: postgresql-11.
192.168.0.93: Updating PostgreSQL port (5432) and directory.
192.168.0.93:5432: Granting remote access to PostgreSQL server.
192.168.0.93:5432: Granting controller (10.0.2.15,192.168.0.19).
192.168.0.93:5432: Updating configuration.
192.168.0.93:5432: Enabling stat_statements plugin.
192.168.0.93:5432: Setting wal options.
192.168.0.93:5432: Performance tuning.
192.168.0.93:5432: Selected workload type: mixed
Detected system memory: 991.18 MiB
Using the following fine-tuning options:
  checkpoint_completion_target: 0.9
  effective_cache_size: 761229kB
  maintenance_work_mem: 63435kB
  max_connections: 100
  shared_buffers: 253743kB
  wal_keep_segments: 32
  work_mem: 5074kB
Writing file '192.168.0.93:/var/lib/pgsql/11/data/postgresql.conf'.
192.168.0.93:5432: Restarting PostgreSQL service
192.168.0.93:5432: Testing connection (attempt #1).
192.168.0.93:5432: Connected ok.
192.168.0.93:5432: Using the master's data directory '/var/lib/pgsql/11/data'.
192.168.0.91:5432(master): Verifying PostgreSQL version.
Setting up replication 192.168.0.91:5432->192.168.0.93:5432
Collecting server variables.
192.168.0.91:5432: Using the pg_hba.conf contents for the slave.
192.168.0.93:5432: Updating slave configuration.
Writing file '192.168.0.93:/var/lib/pgsql/11/data/postgresql.conf'.
192.168.0.93:5432: GRANT new node on members to do pg_basebackup.
192.168.0.91:5432: granting 192.168.0.93:5432.
192.168.0.93:5432: Stopping slave.
192.168.0.93:5432: Cleaning up slave data directory: /var/lib/pgsql/11/data
192.168.0.93:5432: detected version: 11.1
192.168.0.93:5432: Doing initial sync (pg_basebackup) from 192.168.0.91:5432.
192.168.0.93:5432: Synchronizing pg_hba.conf from master.
Writing file '192.168.0.93:/var/lib/pgsql/11/data/postgresql.conf'.
192.168.0.93:5432: Creating '/var/lib/pgsql/11/data/recovery.conf': Setting 192.168.0.91:5432 as master.
192.168.0.93:5432: Successfully created '/var/lib/pgsql/11/data/recovery.conf'.
192.168.0.93:5432: Restarting PostgreSQL
192.168.0.93:5432: Grant cluster members on the new node (for failover).
Grant connect access for new host in cluster.
Adding grant on 192.168.0.91:5432.
Adding grant on 192.168.0.92:5432.
192.168.0.93:5432: Waiting until service starts.
192.168.0.93:5432: Registering node.
192.168.0.93:5432: Verifying configuration.
192.168.0.93:5432: Checking 'listen_addresses'.
192.168.0.93:5432: Checking variables.
192.168.0.93:5432: Detected PostgreSQL 11.1.
192.168.0.93:5432: Registering host with host manager.
192.168.0.93:5432: Added host to cluster.
Replication slave job finished.
192.168.0.93: Installing cronie.
192.168.0.91:5432: [postgres] Pulling '/var/lib/pgsql/11/data/postgresql.conf'.
192.168.0.92:5432: [postgres] Pulling '/var/lib/pgsql/11/data/postgresql.conf'.
192.168.0.93:5432: [postgres] Pulling '/var/lib/pgsql/11/data/postgresql.conf'.

D'après les journaux de travail, nous pouvons voir que puisque le cluster a déjà un maître en cours d'exécution (192.168.0.91), le nouveau nœud sera déployé en tant qu'esclave du maître. ClusterControl effectuera alors toutes les actions nécessaires et préparera le nouveau nœud en tant que rôle donné en conséquence.

Passage à un nouveau Master

Pour effectuer le basculement, choisissez l'un des esclaves pour devenir le nouveau maître avec l'indicateur --promote-slave :

$ s9s cluster \
--promote-slave \
--nodes=192.168.0.92 \
--cluster-id=8 \
--log
192.168.0.92:5432: Promoting server to master.
192.168.0.92:5432: Current master is 192.168.0.91:5432.

SERVER           HOST_STATUS            STATUS            ROLE RECEIVE/REPLAY
192.168.0.91     CmonHostOnline   NODE_CONNECTED         master 0/9000EF0; 0/9000EF0
192.168.0.92     CmonHostOnline   NODE_CONNECTED         slave  0/9000EF0; 0/9000EF0
192.168.0.93     CmonHostOnline   NODE_CONNECTED         slave  0/9000EF0; 0/9000EF0

Switching over to 192.168.0.92:5432 (previous master is 192.168.0.91:5432)
192.168.0.91:5432: Stopping the current master.
192.168.0.91:5432: Stopping PostgreSQL service.
192.168.0.91:5432: Waiting to stop.
192.168.0.92:5432: Failover, using file.
192.168.0.92:5432: Waiting to become a master.
192.168.0.92:5432: Became master, ok.
Switching slaves to the new master.
192.168.0.93:5432: Stopping PostgreSQL service.
192.168.0.93:5432: Waiting to stop.
192.168.0.92:5432: Granting host (192.168.0.93:5432).
Running /usr/pgsql-11/bin/pg_rewind --target-pgdata=/var/lib/pgsql/11/data --source-server="host=192.168.0.92 port=5432 user=cmon password=***** dbname=postgres"
192.168.0.93: servers diverged at WAL location 0/9000F60 on timeline 1
no rewind required
192.168.0.93:5432: Creating '/var/lib/pgsql/11/data/recovery.conf': Setting 192.168.0.92:5432 as master.
192.168.0.93:5432: Successfully created '/var/lib/pgsql/11/data/recovery.conf'.
192.168.0.93:5432: Starting PostgreSQL.
192.168.0.93:5432: The postgresql service was started.
192.168.0.93:5432: Waiting to start.
192.168.0.93:5432: Restarted with new master.
192.168.0.91:5432: Stopping PostgreSQL service.
192.168.0.91:5432: Waiting to stop.
192.168.0.92:5432: Granting host (192.168.0.91:5432).
Running /usr/pgsql-11/bin/pg_rewind --target-pgdata=/var/lib/pgsql/11/data --source-server="host=192.168.0.92 port=5432 user=cmon password=***** dbname=postgres"
192.168.0.91: servers diverged at WAL location 0/9000F60 on timeline 1
no rewind required
192.168.0.91:5432: Creating '/var/lib/pgsql/11/data/recovery.conf': Setting 192.168.0.92:5432 as master.
192.168.0.91:5432: Successfully created '/var/lib/pgsql/11/data/recovery.conf'.
192.168.0.91:5432: Starting PostgreSQL.
192.168.0.91:5432: The postgresql service was started.
192.168.0.91:5432: Waiting to start.
192.168.0.91:5432: Restarted with new master.
Servers after promote:
SERVER           HOST_STATUS            STATUS            ROLE RECEIVE/REPLAY
192.168.0.91     CmonHostOnline   NODE_CONNECTED         slave  0/9001F90; 0/9001F90
192.168.0.92     CmonHostOnline   NODE_CONNECTED         master 0/9001F90; 0/9001F90
192.168.0.93     CmonHostOnline   NODE_CONNECTED         slave  0/9001F90; 0/9001F90

192.168.0.92:5432: promote finished (this is the new master).
Successfully promoted a new master.

Les messages de travail indiquent que ClusterControl va d'abord découvrir la topologie actuelle et arrêter tous les nœuds du cluster. Ensuite, il configure le nouveau maître et demande aux autres nœuds de se répliquer à partir de celui-ci. Il tentera également d'exécuter pg_rewind pour re-synchroniser les PGDATA du maître déclassé avec une nouvelle sauvegarde de base. À la fin du travail, ClusterControl signale la topologie actuelle et l'état de la promotion.

Nous pouvons ensuite vérifier en répertoriant tous les nœuds pour l'ID de cluster 8 :

$ s9s node --list --cluster-id=8 --long
STAT VERSION    CID CLUSTER       HOST         PORT COMMENT
coC- 1.7.1.2985   8 PostgreSQL 11 192.168.0.19 9500 Up and running.
poS- 11.1         8 PostgreSQL 11 192.168.0.91 5432 Up and running.
poM- 11.1         8 PostgreSQL 11 192.168.0.92 5432 Up and running.
poS- 11.1         8 PostgreSQL 11 192.168.0.93 5432 Up and running.

L'état "poM-" sur la colonne la plus à gauche a la signification suivante :

  • p - nœud PostgreSQL
  • o - en ligne
  • M - maître

Gestion de la base de données

Pour répertorier toutes les bases de données trouvées sur le cluster, utilisez l'indicateur --list-database sur le cluster de composants :

$ s9s cluster \
--list-database \
--long \
--cluster-id=8
SIZE      #TBL #ROWS   OWNER  GROUP  CLUSTER                          DATABASE
  7340032    0       0 system admins PostgreSQL Streaming Replication postgres
  7340032    0       0 system admins PostgreSQL Streaming Replication template1
  7340032    0       0 system admins PostgreSQL Streaming Replication template0
382730240   12 1156642 system admins PostgreSQL Streaming Replication sbtest

Notez que si le cluster a beaucoup de bases de données, cette option peut ne pas en afficher certaines. L'échantillonnage d'un grand nombre de bases de données générerait une charge élevée et le contrôleur a donc une limite supérieure intégrée.

Si vous souhaitez créer une nouvelle base de données pour le cluster, faites simplement :

$ s9s cluster \
--create-database \
--cluster-id=8 \
--db-name=my_shopping_db

Pour créer un nouvel utilisateur de base de données, ainsi qu'une base de données qui lui est associée (en utilisant le même nom de base de données), utilisez le --create-account avec l'indicateur --with-database :

$ s9s cluster \
--create-account \
--cluster-id=1 \
--account=mysystem:[email protected] \
--with-database
Account 'mysystem' created.
192.168.0.91:5432: Allowing connections from 192.168.0.15.
192.168.0.92:5432: Allowing connections from 192.168.0.15.
192.168.0.93:5432: Allowing connections from 192.168.0.15.
Database 'mysystem' created.
Access for 'mysystem' to 'mysystem' granted.

ClusterControl effectuera les actions nécessaires pour créer la base de données et le compte utilisateur avec les privilèges appropriés et l'autorisera sur tous les nœuds de la base de données.

Gestion des sauvegardes

ClusterControl prend en charge deux méthodes de sauvegarde pour PostgreSQL :

  • pgdump - Alias ​​de pg_dumpall, un utilitaire permettant d'écrire toutes les bases de données PostgreSQL d'un cluster dans un seul fichier de script.
  • pg_basebackup - Un utilitaire pour créer une sauvegarde complète au niveau du système de fichiers d'une base de données PostgreSQL.

Création d'une sauvegarde

Pour créer une nouvelle sauvegarde à l'aide de pg_dumpall, choisissez un nœud de base de données et spécifiez "pgdump" dans l'indicateur --backup-method :

$ s9s backup \
--create \
--backup-method=pgdump \
--cluster-id=8 \
--nodes=192.168.0.92 \
--backup-directory=/storage/backups \
    --on-controller

L'indicateur --on-controller indique que nous voudrions que la sauvegarde créée soit stockée dans le répertoire /storage/backups sur le nœud ClusterControl. Omettez l'indicateur si vous souhaitez le stocker sur le nœud de base de données lui-même. La même commande peut être appliquée pour créer une sauvegarde pg_basebackup. Remplacer simplement "pgdump" par "pg_basebackup" ferait l'affaire.

Pour répertorier la sauvegarde, utilisez simplement les indicateurs --list et --cluster-id :

$ s9s backup --list --long --cluster-id=8
ID PI CID V I STATE     OWNER          HOSTNAME     CREATED  SIZE    TITLE
 8  -   8 - F COMPLETED admin          192.168.0.92 08:42:47    1204 Untitled Backup Record
 9  -   8 - F COMPLETED admin          192.168.0.92 08:45:52 3865462 Untitled Backup Record

Planification d'une sauvegarde

La planification d'une sauvegarde est similaire à la commande que nous avons utilisée pour créer une sauvegarde, avec un indicateur supplémentaire --recurrence :

$ s9s backup \
--create \
--backup-method=pg_basebackup \
--cluster-id=8 \
--nodes=192.168.0.92 \
--backup-directory=/storage/backups \
--on-controller \
--recurrence='30 0 * * *'

La valeur de la récurrence doit être jointe à un guillemet et au format crontab.

Restauration d'une sauvegarde

Pour restaurer une sauvegarde sur un cluster, utilisez l'indicateur --restore et indiquez l'ID de sauvegarde que vous souhaitez utiliser :

$ s9s backup \
--restore \
--cluster-id=8 \
--backup-id=9 \
--log
192.168.0.19: Checking 'socat' availability.
Stop slaves as restoring offline backup to master.
192.168.0.91:5432: Stopping PostgreSQL service.
192.168.0.91:5432: Waiting to stop.
192.168.0.93:5432: Stopping PostgreSQL service.
192.168.0.93:5432: Waiting to stop.
192.168.0.92:5432: Stopping node for restoring a base-backup.
192.168.0.92:5432: Stopping PostgreSQL service.
192.168.0.92:5432: Waiting to stop.
192.168.0.92:5432: Backing up the current datadir.
192.168.0.92: Mount point of '/var/lib/pgsql/11/data': '/'
192.168.0.92: Creating copy of datadir (using 'mv'): /var/lib/pgsql/11/data_bak
192.168.0.92: Checking 'socat' availability.
192.168.0.92: Starting: su - postgres -c 'socat -u tcp-listen:9999,reuseaddr stdout | tar -C/var/lib/pgsql/11/data -xzf-' 2>&1 > /tmp/netcat.pg.log
192.168.0.92: socat/nc is started.
192.168.0.92: Restoring from '192.168.0.19':'/storage/backups/BACKUP-9/base.tar.gz'
192.168.0.92:5432: Starting node after restored a base-backup.
192.168.0.92:5432: Starting PostgreSQL.
192.168.0.92:5432: The postgresql service was started.
192.168.0.92:5432: Waiting to start.
You may now rebuild your slaves.
Finished restoring.
Checking the cluster.
Setting cluster to 'STARTING' state.
192.168.0.91:5432: Starting PostgreSQL.
192.168.0.91:5432: The postgresql service was started.
192.168.0.93:5432: Starting PostgreSQL.
192.168.0.93:5432: The postgresql service was started.
Cluster is successfully started.
Cluster status is STARTED.

Notez que pour la sauvegarde de pg_basebackup, l'opération de restauration nécessite un temps d'arrêt de la base de données. Tous les nœuds PostgreSQL seront arrêtés avant la restauration et la restauration aura lieu sur le dernier maître connu. Ce maître sera affiché en premier (suivi de tous les esclaves) une fois la restauration terminée.

Vérification d'une sauvegarde

Pour restaurer et vérifier la sauvegarde, utilisez l'indicateur --verify et spécifiez le serveur de destination à l'aide de l'indicateur --test-server :

$ s9s backup \
--verify \
--cluster-id=8 \
--backup-id=9 \
--test-server=192.168.0.99 \
--log

Le serveur de test ne doit pas faire partie du cluster et doit être accessible via SSH sans mot de passe à partir du nœud ClusterControl. ClusterControl installera d'abord le serveur cible avec la même version de PostgreSQL, diffusera et restaurera la sauvegarde sur ce nœud. La vérification de sauvegarde recherche le dernier code de sortie après la restauration. Si la sauvegarde est restaurable, ClusterControl arrêtera alors le serveur de test et le supprimera de ClusterControl (mais ClusterControl ne l'arrêtera pas). Vous devriez voir ce qui suit une fois la tâche terminée :

Backup 9 was successfully verified.

Créer un cluster à partir d'une sauvegarde

ClusterControl a introduit une nouvelle fonctionnalité dans la v1.7.1, où l'on peut créer un nouveau cluster basé sur une sauvegarde effectuée par un cluster existant. Cela peut être très utile pour tester votre base de données sur une plate-forme ou une version de base de données différente. Dans cet exemple, nous aimerions déployer un cluster PostgreSQL 9.6 à deux nœuds basé sur l'ID de sauvegarde 214 :

$ s9s cluster \
--create \
--cluster-type=postgresql \
--nodes="192.168.0.101?master;192.168.0.102?slave" \
--provider-version=9.6 \
--db-admin=postgres \
--db-admin-passwd='s3cr3tP455' \
--os-user=root \
--os-key-file=/root/.ssh/id_rsa \
--cluster-name="PostgreSQL 9.6 - Test"
--backup-id=214 \
--wait

Notez que le mot de passe de l'utilisateur administrateur pour le nouveau cluster doit être identique au mot de passe administrateur PostgreSQL tel qu'il est inclus dans la sauvegarde. Fondamentalement, ClusterControl effectue le travail de déploiement en fonction de l'ordre suivant :

  1. Installez les logiciels et les dépendances nécessaires sur tous les nœuds PostgreSQL.
  2. Démarrez le premier nœud.
  3. Diffusion et restauration de la sauvegarde sur le premier nœud (avec indicateur de redémarrage automatique).
  4. Configurez et ajoutez le reste des nœuds.

Vous pouvez ensuite vérifier la liste des clusters à l'aide de la commande suivante :

$ s9s cluster --stat

Gestion des configurations

Pour répertorier la configuration PostgreSQL d'un nœud, utilisez l'indicateur --list-config :

$ s9s node --list-config --cluster-id=8 --nodes=192.168.0.92
GROUP OPTION NAME                  VALUE
-     data_directory               '/var/lib/pgsql/11/data'
-     listen_addresses             '*'
-     port                         5432
-     max_connections              100
-     shared_buffers               253743kB
-     work_mem                     5074kB
-     maintenance_work_mem         63435kB
-     dynamic_shared_memory_type   posix
-     wal_level                    hot_standby
-     full_page_writes             on
-     wal_log_hints                on
-     max_wal_size                 1GB
-     min_wal_size                 80MB
-     checkpoint_completion_target 0.9
-     max_wal_senders              16
-     wal_keep_segments            32
-     hot_standby                  on
-     effective_cache_size         761229kB
-     log_destination              'stderr'
-     logging_collector            on
-     log_directory                'log'
-     log_filename                 'postgresql-%a.log'
-     log_truncate_on_rotation     on
-     log_rotation_age             1d
-     log_rotation_size            0
-     log_line_prefix              '%m [%p] '
-     log_timezone                 'UTC'
-     track_activity_query_size    2048
-     datestyle                    'iso, mdy'
-     timezone                     'UTC'
-     lc_messages                  'en_US.UTF-8'
-     lc_monetary                  'en_US.UTF-8'
-     lc_numeric                   'en_US.UTF-8'
-     lc_time                      'en_US.UTF-8'
-     default_text_search_config   'pg_catalog.english'
-     shared_preload_libraries     'pg_stat_statements'
-     pg_stat_statements.track     all

ClusterControl renvoie la sortie de OPTION NAME et VALUE en conséquence. La colonne GROUP n'est pas applicable dans PostgreSQL, vous devriez donc voir la valeur '-'.

Pour modifier une option de configuration, utilisez l'indicateur --change-config et spécifiez le paramètre et la valeur en utilisant respectivement --opt-name et --opt-value :

$ s9s node \
--change-config \
--nodes=192.168.0.92 \
--opt-name=min_wal_size \
--opt-value='100MB'
192.168.0.92:5432: Changed a read-only parameter. Node restart is required for change to take effect.

Vous devriez voir ClusterControl renvoyer l'état de modification de la configuration et conseiller la procédure de suivi pour vous assurer que le changement de configuration prend effet. Vous pouvez ensuite utiliser la commande "s9s node --restart" pour redémarrer le nœud particulier.

Réflexions finales

ClusterControl offre une grande flexibilité en matière de gestion et de surveillance de votre cluster de bases de données PostgreSQL. Vous avez le choix entre l'interface utilisateur Web, qui est assez simple et directe, ainsi que l'interface de ligne de commande, qui vous permet d'obtenir une automatisation complète de la base de données via des scripts. Bonne gestion !