Sauvegardes incrémentielles de PostgreSQL avec pgbackrest - cours pour les débutants par le développeur

Avertissement

Je suis développeur. J'écris du code, et j'interagis avec la base de données uniquement en tant qu'utilisateur. Je ne revendique en aucun cas le poste d'administrateur système, et encore moins celui de DBA. Mais...

Il se trouve que j'avais besoin d'organiser la sauvegarde d'une base de données PostgreSQL. Pas de solutions cloud — fais-le avec SSH et assure-toi que tout fonctionne sans demander d'argent. Que faisons-nous dans de tels cas ? Correct, nous mettons pg_dump dans cron, sauvegardons tout dans une archive chaque jour et si cela devient trop compliqué, nous envoyons cette archive ailleurs.

Cette fois, la complexité résidait dans le fait que la base devait croître d'environ +- 100 Mo par jour. Évidemment, après quelques semaines, le désir de sauvegarder tout avec pg_dump disparaîtra. C'est là que les sauvegardes incrémentielles entrent en jeu.

Ça vous intéresse ? Bienvenue en bas.

Une sauvegarde incrémentielle est un type de sauvegarde où seules les nouvelles et modifiées depuis la création de la copie précédente des fichiers sources sont copiées.

Comme tout développeur, qui NE SOUHAITE ABSOLUMENT PAS (à ce moment-là) comprendre les subtilités de Postgres, je voulais trouver un bouton vert. Vous savez, comme dans AWS, DigitalOcean : un clic et vous obtenez la réplication, un autre clic et vous configurez les sauvegardes, et un troisième, et tout est restauré à quelques heures en arrière. Je n'ai pas trouvé de bouton ni d'outil avec une belle interface utilisateur. Si vous connaissez un tel outil (gratuit ou peu coûteux), veuillez le mentionner dans les commentaires.

Après une recherche sur Google, j'ai trouvé deux outils pgbarman et pgbackrest. Avec le premier, je n'ai simplement pas eu de chance (documentation très limitée, j'ai essayé de tout installer avec de vieux manuels), mais pour le second, la documentation était à niveau, bien qu'avec des défauts. Cet article a été écrit pour simplifier le travail de ceux qui rencontreront une tâche similaire.

En lisant cet article, vous apprendrez à créer des sauvegardes incrémentielles, à les stocker sur un serveur distant (un dépôt de sauvegardes) et à les restaurer en cas de perte de données ou d'autres problèmes sur le serveur principal.

Préparation

Pour reproduire ce manuel, vous aurez besoin de deux VPS. Le premier sera le stockage (le dépôt où les sauvegardes seront stockées), et le deuxième sera le serveur avec PostgreSQL (dans mon cas, version 11 de PostgreSQL).

Il est supposé que sur le serveur avec postgres, vous avez un utilisateur root, un utilisateur sudo, un utilisateur postgres et que postgres est installé (l'utilisateur postgres est créé automatiquement lors de l'installation de postgresql), et sur le serveur de dépôt, il y a un utilisateur root et un utilisateur sudo (dans le manuel, le nom d'utilisateur pgbackrest sera utilisé).

Pour que vous ayez moins de problèmes lors de la reproduction de l'instruction, je rédige en italique où, avec quel utilisateur et avec quels droits j'ai exécuté la commande pendant la rédaction et la vérification de l'article.

Installation de pgbackrest

Dépôt (utilisateur pgbackrest):

1. Téléchargez l'archive de pgbackrest et déplacez son contenu dans le dossier /build:

sudo mkdir /build
sudo wget -q -O - 
       https://github.com/pgbackrest/pgbackrest/archive/release/2.18.tar.gz | 
       sudo tar zx -C /build

2. Installez les dépendances nécessaires à la compilation :

sudo apt-get update
sudo apt-get install build-essential libssl-dev libxml2-dev libperl-dev zlib1g-dev 
       libpq-dev

3. Compilez pgbackrest :

cd /build/pgbackrest-release-2.18/src && sudo ./configure
sudo make -s -C /build/pgbackrest-release-2.18/src

4. Copiez l'exécutable dans le répertoire /usr/bin:

sudo cp /build/pgbackrest-release-2.18/src/pgbackrest /usr/bin
sudo chmod 755 /usr/bin/pgbackrest

5. Pgbackrest nécessite Perl. Installer :

sudo apt-get install perl

6. Créez des répertoires pour les journaux, en leur attribuant certains droits :

sudo mkdir -p -m 770 /var/log/pgbackrest
sudo chown pgbackrest:pgbackrest /var/log/pgbackrest
sudo mkdir -p /etc/pgbackrest
sudo mkdir -p /etc/pgbackrest/conf.d
sudo touch /etc/pgbackrest/pgbackrest.conf
sudo chmod 640 /etc/pgbackrest/pgbackrest.conf
sudo chown pgbackrest:pgbackrest /etc/pgbackrest/pgbackrest.conf

7. Vérifiez :

pgbackrest version

Serveur Postgres (utilisateur sudo ou root) :

Le processus d'installation de pgbackrest sur le serveur avec postgres est similaire au processus d'installation sur le dépôt (oui, pgbackrest doit être installé sur les deux serveurs), mais au point 6, remplacez la deuxième et la dernière commande :

sudo chown pgbackrest:pgbackrest /var/log/pgbackrest
sudo chown pgbackrest:pgbackrest /etc/pgbackrest/pgbackrest.conf

par :

sudo chown postgres:postgres /var/log/pgbackrest
sudo chown postgres:postgres /etc/pgbackrest/pgbackrest.conf

Configuration de l'interaction entre les serveurs via SSH sans mot de passe

Pour que pgbackrest fonctionne correctement, il est nécessaire de configurer l'interaction entre le serveur postgres et le dépôt via une clé de fichier.

Dépôt (utilisateur pgbackrest):

Créer une paire de clés :

mkdir -m 750 /home/pgbackrest/.ssh
ssh-keygen -f /home/pgbackrest/.ssh/id_rsa 
       -t rsa -b 4096 -N ""

Attention ! Les commandes mentionnées ci-dessus sont exécutées sans sudo.

Serveur Postgres (utilisateur sudo ou root) :

Créer une paire de clés :

sudo -u postgres mkdir -m 750 -p /var/lib/postgresql/.ssh
sudo -u postgres ssh-keygen -f /var/lib/postgresql/.ssh/id_rsa 
       -t rsa -b 4096 -N ""

Dépôt (utilisateur sudo) :

Copiez la clé publique du serveur postgres sur le serveur de dépôt :

(echo -n 'no-agent-forwarding,no-X11-forwarding,no-port-forwarding,' && 
       echo -n 'command="/usr/bin/pgbackrest ${SSH_ORIGINAL_COMMAND#* }" ' && 
       sudo ssh root@ cat /var/lib/postgresql/.ssh/id_rsa.pub) | 
       sudo -u pgbackrest tee -a /home/pgbackrest/.ssh/authorized_keys

À cette étape, il vous sera demandé le mot de passe de l'utilisateur root. Vous devez entrer exactement le mot de passe de l'utilisateur root du serveur postgres !

Serveur Postgres (utilisateur sudo) :

Nous copions la clé publique du dépôt sur le serveur avec postgres :

(echo -n 'no-agent-forwarding,no-X11-forwarding,no-port-forwarding,' && 
       echo -n 'command="/usr/bin/pgbackrest ${SSH_ORIGINAL_COMMAND#* }" ' && 
       sudo ssh root@ cat /home/pgbackrest/.ssh/id_rsa.pub) | 
       sudo -u postgres tee -a /var/lib/postgresql/.ssh/authorized_keys

À cette étape, il vous sera demandé le mot de passe de l'utilisateur root. Vous devez entrer exactement le mot de passe de l'utilisateur root du dépôt !

Vérifions :

Dépôt (utilisateur root, pour des raisons d'expérimentation) :

sudo -u pgbackrest ssh postgres@

Serveur Postgres (utilisateur root, pour des raisons d'expérimentation) :

sudo -u postgres ssh pgbackrest@

Nous nous assurons d'accéder sans problème.

Configuration du serveur postgres

Serveur Postgres (utilisateur sudo ou root) :

1. Autorisons les connexions au serveur postgres depuis des ip externes. Pour cela, éditons le fichier postgresql.conf (situé dans le dossier /etc/postgresql/11/main), en ajoutant la ligne suivante :

listen_addresses = '*'

Si cette ligne existe déjà, soit décommentez-la, soit définissez la valeur du paramètre sur ‘*’.

Dans le fichier pg_hba.conf (se trouve également dans le dossier /etc/postgresql/11/main) ajoutons les lignes suivantes :

hostssl  all  all  0.0.0.0/0  md5
host  all  all  0.0.0.0/0  md5

où :

hostssl/host - nous connectons via SSL (ou non)
all - autoriser la connexion à toutes les bases de données
all - nom d'utilisateur autorisé à se connecter (tout le monde)
0.0.0.0/0 - masque réseau depuis lequel on peut se connecter
md5 - méthode de cryptage du mot de passe

2. Apportons les paramètres nécessaires dans postgresql.conf (il se trouve dans le dossier /etc/postgresql/11/main) pour le fonctionnement de pgbackrest :

archive_command = 'pgbackrest --stanza=main archive-push %p' # Où main est le nom du cluster. Lors de l'installation de postgres, le cluster main est créé automatiquement.
archive_mode = on
max_wal_senders = 3
wal_level = replica

3. Apportons les paramètres nécessaires dans le fichier de configuration pgbackrest (/etc/pgbackrest/pgbackrest.conf) :

[main]
pg1-path=/var/lib/postgresql/11/main

[global]
log-level-file=detail
repo1-host=

4. Redémarrons postgresql :

sudo service postgresql restart

Configuration du serveur de dépôt

Dépôt (utilisateur pgbackrest) :

Apportons les paramètres nécessaires dans le fichier de configuration pgbackrest
(/etc/pgbackrest/pgbackrest.conf):

[main]
pg1-host=
pg1-path=/var/lib/postgresql/11/main

[global]
repo1-path=/var/lib/pgbackrest
repo1-retention-full=2 # Paramètre indiquant combien de sauvegardes complètes conserver. C'est-à-dire, si vous avez deux sauvegardes complètes et que vous en créez une troisième - les deux premières seront supprimées avec les incrémentales.
start-fast=y # Démarre la sauvegarde immédiatement, vous pouvez lire sur ce paramètre ici https://postgrespro.ru/docs/postgrespro/9.5/continuous-archiving

Création d'un espace de stockage

Dépôt (utilisateur pgbackrest) :

Créons un nouvel espace de stockage pour le cluster main:

sudo mkdir -m 770 /var/lib/pgbackrest
sudo chown -R pgbackrest /var/lib/pgbackrest/
sudo -u pgbackrest pgbackrest --stanza=main stanza-create

Vérification

Serveur Postgres (utilisateur sudo ou root) :

Vérifions sur le serveur postgres :

sudo -u postgres pgbackrest --stanza=main --log-level-console=info check

Dépôt (utilisateur pgbackrest) :

Vérifions sur le serveur de dépôt :

sudo -u pgbackrest pgbackrest --stanza=main --log-level-console=info check

Nous nous assurons que la sortie affiche la ligne « check command end: completed successfully ».

Fatigué ? Passons à la partie la plus intéressante.

Faisons une sauvegarde

Dépôt (utilisateur pgbackrest) :

1. Effectuons la sauvegarde :

sudo -u pgbackrest pgbackrest --stanza=main backup

2. Nous nous assurons que la sauvegarde a été créée :

ls /var/lib/pgbackrest/backup/main/

Pgbackrest créera la première sauvegarde complète. Si vous le souhaitez, vous pouvez relancer la commande de sauvegarde et être sûr que le système créera une sauvegarde incrémentale.

Si vous souhaitez recréer une sauvegarde complète, indiquez un flag supplémentaire :

sudo -u pgbackrest pgbackrest --stanza=main --type=full backup

Si vous souhaitez une sortie détaillée dans la console, indiquez également :

sudo -u pgbackrest pgbackrest --stanza=main --type=full --log-level-console=info backup

Restaurons la sauvegarde

Serveur Postgres (utilisateur sudo ou root) :

1. Arrêtons le cluster en cours d'exécution :

sudo pg_ctlcluster 11 main stop

2. Restaurons-nous à partir de la sauvegarde :

sudo -u postgres pgbackrest --stanza=main --delta restore

3. Démarrons le cluster :

sudo pg_ctlcluster 11 main start

Après la restauration de la sauvegarde, nous devons effectuer une nouvelle sauvegarde :

Dépôt (utilisateur pgbackrest) :

sudo pgbackrest --stanza=main backup

C'est tout. En conclusion, je tiens à rappeler que je ne prétends pas être un senior dba et que je vais utiliser le cloud à chaque fois que cela sera possible. Actuellement, je commence à étudier divers sujets tels que la sauvegarde, la réplication, la surveillance, etc. et j'écris de petits rapports sur les résultats pour apporter une petite contribution à la communauté et garder de petites notes.

Dans les prochains articles, je tenterai de parler des fonctionnalités supplémentaires - restauration des données sur un cluster propre, chiffrement des sauvegardes et publication sur S3, sauvegardes via rsync.

Source : habr.com