Présentation de la réplication au niveau du volume pour PostgreSQL à l'aide de DRBD

La réplication est le partage de données transactionnelles sur plusieurs serveurs pour assurer la cohérence entre les nœuds de base de données redondants. Un maître prendra des insertions ou des mises à jour et les appliquera à son ensemble de données, tandis que les esclaves modifieront leurs données conformément aux modifications apportées à l'ensemble de données maître. Le maître est communément appelé primaire et il enregistre les modifications apportées dans un journal WAL (Write Ahead Log). D'autre part, les esclaves sont appelés secondaires et ils répliquent leurs données à partir des journaux REDO - dans ce cas, le WAL.

Il existe au moins 3 approches de réplication dans PostgreSQL :

Réplication intégrée ou réplication en continu.

Dans cette approche, les données sont répliquées du nœud principal vers le nœud secondaire. Cependant, il s'accompagne d'un certain nombre de revers qui sont :

Difficultés à introduire un nouveau secondaire. Il vous faudra répliquer l'intégralité de l'état, ce qui peut nécessiter beaucoup de ressources.
Absence de surveillance et de basculement intégrés. Un secondaire doit être promu à un primaire en cas d'échec de ce dernier. Souvent, cette promotion peut entraîner des incohérences dans les données pendant l'absence du principal.

Reconstruire à partir de WAL

Cette approche utilise en quelque sorte l'approche de réplication en continu puisque les secondaires sont reconstruits à partir d'une sauvegarde effectuée par le primaire. Le primaire entreprend une sauvegarde complète de la base de données après chaque jour en plus d'une sauvegarde incrémentielle toutes les 60 secondes. L'avantage de cette approche est qu'aucune charge supplémentaire n'est soumise au primaire jusqu'à ce que les secondaires soient suffisamment proches du primaire pour qu'ils commencent à diffuser le journal WAL (Write Ahead Log) afin de le rattraper. Avec cette approche, vous pouvez ajouter ou supprimer des répliques sans affecter les performances de votre base de données PostgreSQL.

Réplication au niveau du volume pour PostgreSQL (Mise en miroir de disque)

Il s'agit d'une approche générique qui s'applique non seulement à PostgreSQL, mais également à toutes les bases de données relationnelles. Nous utiliserons Distributed Replicated Block Device (DRBD), un système de stockage répliqué distribué pour Linux. Il est censé fonctionner en mettant en miroir le contenu stocké dans le stockage d'un serveur sur un autre. Une illustration simple de la structure est présentée ci-dessous.

DRBD peut être considéré comme une abstraction du périphérique de disque qui héberge la base de données PostgreSQL, mais le système d'exploitation ne saura jamais que ses données se trouvent également sur un autre serveur. En utilisant cette approche, vous pouvez non seulement partager les données mais aussi le système de fichiers sur plus d'un serveur. Les écritures sur le DRBD sont donc réparties entre tous les serveurs, chaque serveur écrivant des informations sur un disque dur physique local (dispositif bloc). Lorsqu'une opération d'écriture est appliquée au primaire, elle est ensuite enregistrée dans le DRBD puis distribuée aux serveurs DRBD secondaires. D'autre part, si le secondaire reçoit les opérations d'écriture via le DRBD, elles sont alors écrites sur le périphérique physique local. En cas de prise en charge du basculement, le DRBD fournit une haute disponibilité des données puisque les informations sont partagées entre un nœud principal et de nombreux nœuds secondaires qui sont alignés de manière synchrone au niveau du bloc.

La configuration DRBD nécessiterait une ressource supplémentaire connue sous le nom de Heartbeat, dont nous parlerons dans un autre article, afin d'améliorer la prise en charge du basculement automatique. Le package gère essentiellement l'interface sur plusieurs serveurs et configure automatiquement l'un des serveurs secondaires en serveur principal en cas de panne.

Installation et configuration du DRBD

La méthode préférée d'installation de DRBD consiste à utiliser les packages d'installation binaires pré-construits. Assurez-vous que la version du noyau des packages correspond à votre noyau actuel actif.

Les fichiers de configuration de tous les nœuds principaux ou secondaires doivent être identiques. De plus, s'il est nécessaire que vous mettiez à niveau votre version du noyau, assurez-vous que le kernel-module-drdb correspondant est disponible pour votre nouvelle version du noyau.

Configuration DRBD pour le nœud principal

Il s'agit de la première étape où vous devrez créer un périphérique bloc DRBD et un système de fichiers avec lequel vous pourrez stocker vos données. Le fichier de configuration se trouve dans /etc/drbd.conf. Le fichier définit un certain nombre de paramètres pour la configuration DRBD, notamment :la taille des blocs, la définition des informations de sécurité des périphériques DRBD que vous souhaitez créer et la fréquence des mises à jour. Les configurations peuvent être contraintes d'être globales ou liées à une certaine ressource. Les étapes impliquées sont :

Taux de synchronisation qui définit le taux auquel les périphériques sont liés de manière synchrone en arrière-plan après un remplacement de disque, une panne ou une configuration initiale. Cela peut être défini en modifiant le paramètre de taux dans le bloc de synchronisation :
```
syncer{
rate 15M
}
```
Configuration de l'authentification pour s'assurer que seuls les hôtes avec le même secret partagé peuvent rejoindre le groupe de nœuds DRBD. Le mot de passe est un mécanisme d'échange de hachage pris en charge dans le DRBD.
```
cram-hmac-alg “sha1”
shared-secret “hash-password-string”
```
Configuration des informations sur l'hôte. Les informations de nœud telles que l'hôte peuvent être trouvées dans le fichier drbd.conf de chacun des nœuds. Certains des paramètres à configurer sont :
- Adresse :adresse IP et numéro de port de l'hôte qui contient le périphérique DRBD.
- Périphérique :le chemin du périphérique de bloc logique créé par le DRBD.
- Disque :il fait référence au périphérique de bloc stockant les données.
- Méta-disque :il stocke les métadonnées de l'appareil DRBD. Sa taille peut aller jusqu'à 128 Mo. Vous pouvez le définir comme disque interne afin que le DRBD utilise un périphérique de bloc physique pour stocker ces informations dans les dernières sections du disque.
Une configuration simple pour le primaire :
```
on drbd-one {
device /dev/drbd0;
disk /dev/sdd1;
address 192.168.103.40:8080;
meta-disk internal;
}
```
La configuration doit être répétée avec les secondaires avec l'adresse IP correspondant à son hôte correspondant.
```
on drbd-two {
device /dev/drbd0;
disk /dev/sdd1;
address 192.168.103.41:8080;
meta-disk internal;
}
```
Création des métadonnées pour les appareils à l'aide de cette commande :
```
$ drbdadm create create-md all
```
Ce processus est obligatoire avant de démarrer le nœud principal.
Démarrez le DRBD avec cette commande :
```
$ /etc/init.d/drbd start
```
Cela permet au DRBD de démarrer, d'initialiser et de créer les appareils définis par le DRBD.
Marquez le nouvel appareil comme principal et initialisez-le à l'aide de cette commande :
```
$ drbdadm -- --overwrite-data-of-peer primary all
```
Créez un système de fichiers sur le périphérique bloc afin de rendre utilisable un périphérique bloc standard créé par le DRBD.
Rendez le primaire prêt à l'emploi en montant le système de fichiers. Cette commande devrait le préparer pour vous :
```
$ mkdir /mnt/drbd
$ mount /dev/drbd0 /mnt/drbd
$ echo “DRBD Device” > /mnt/drbd/example_file
```

Configuration DRBD pour le nœud secondaire

Vous pouvez utiliser les mêmes étapes ci-dessus, sauf pour créer le système de fichiers sur un nœud secondaire puisque les informations sont automatiquement transférées depuis le nœud principal.

Copiez le fichier /etc/drbd.conf du nœud principal vers le nœud secondaire. Ce fichier contient les informations et la configuration nécessaires.
Sur le périphérique de disque sous-jacent, créez les métadonnées DRBD à l'aide de la commande :
```
$ drbdadm create-md all
```

Démarrez le DRBD avec la commande :

$ /etc/init.d/drbd start

DRBD commencera à copier les données du nœud principal vers le nœud secondaire, et le temps dépend de la taille des données à transférer. Si vous affichez le fichier /proc/drbd, vous pouvez voir la progression.

$ cat /proc/drbd
version: 8.0.0 (api:80/proto:80)
  SVN Revision: 2947 build by [email protected], 2018-08-24 16:43:05
   0: cs:SyncSource st:Primary/Secondary ds:UpToDate/Inconsistent C r---
       ns:252284 nr:0 dw:0 dr:257280 al:0 bm:15 lo:0 pe:7 ua:157 ap:0
       [==>.................] sync'ed: 12.3% (1845088/2097152)K
       finish: 0:06:06 speed: 4,972 (4,580) K/sec
       resync: used:1/31 hits:15901 misses:16 starving:0 dirty:0 changed:16
       act_log: used:0/257 hits:0 misses:0 starving:0 dirty:0 changed:0

Surveillez la synchronisation à l'aide de la commande watch à des intervalles spécifiques
```
$ watch -n 10 ‘cat /proc/drbd‘
```

Gestion des installations DRBD

Pour suivre l'état du périphérique DRBD, nous utilisons /proc/drbd.

Vous pouvez définir l'état de tous les appareils locaux comme principaux à l'aide de la commande

$ drbdadm primary all

Rendre un appareil principal secondaire

$ drbdadm secondary all

Pour déconnecter les nœuds DRBD

$ drbdadm disconnect all

Reconnectez les nœuds DRBD

$ drbd connect all

Téléchargez le livre blanc aujourd'hui PostgreSQL Management &Automation with ClusterControlDécouvrez ce que vous devez savoir pour déployer, surveiller, gérer et faire évoluer PostgreSQLTélécharger le livre blanc

Configuration de PostgreSQL pour DRBD

Cela implique de sélectionner un périphérique pour lequel PostgreSQL stockera les données. Pour une nouvelle installation, vous pouvez choisir d'installer PostgreSQL entièrement sur le périphérique DRBD ou sur un répertoire de données situé sur le nouveau système de fichiers et devant se trouver dans le nœud principal. En effet, le nœud principal est le seul autorisé à monter un système de fichiers de périphérique DRBD en lecture/écriture. Les fichiers de données Postgres sont souvent archivés dans /var/lib/pgsql alors que les fichiers de configuration sont stockés dans /etc/sysconfig/pgsql.

Configuration de PostgreSQL pour utiliser le nouveau périphérique DRBD

Si vous avez des PostgreSQL en cours d'exécution, arrêtez-les avec cette commande :
```
$  /etc/init.d/postgresql -9.0
```
Mettez à jour le périphérique DRBD avec les fichiers de configuration à l'aide des commandes :
```
$ mkdir /mnt/drbd/pgsql/sysconfig
$ cp /etc/sysconfig/pgsql/* /mnt/drbd/pgsql/sysconfig
```
Mettez à jour le DRBD avec le répertoire de données PostgreSQL et les fichiers système en utilisant :
```
$ cp -pR /var/lib/pgsql /mnt/drbd/pgsql/data
```
Créez un lien symbolique vers le nouveau répertoire de configuration sur le système de fichiers du périphérique DRBD à partir de /etc/sysconfig/pgsql à l'aide de la commande :
```
$ ln -s /mnt/drbd/pgsql/sysconfig  /etc/sysconfig/pgsql
```
Supprimez le répertoire /var/lib/pgsql, démontez /mnt/drbd/pgsql et montez le périphérique drbd sur /var/lib/pgsql.
Démarrez PostgreSQL avec la commande :
```
$ /etc/init.d/postgresql -9.0 start
```

Les données PostgreSQL doivent maintenant être présentes sur le système de fichiers en cours d'exécution sur votre périphérique DRBD sous le périphérique configuré. Le contenu des bases de données est également copié sur le nœud DRBD secondaire mais il n'est pas accessible car le périphérique DRBD travaillant dans le nœud secondaire peut être absent.

Caractéristiques importantes avec l'approche DRBD

Les paramètres de réglage sont hautement personnalisables.
Les déploiements existants peuvent facilement être configurés avec DRBD sans aucune perte de données.
Les demandes de lecture sont également équilibrées
L'authentification par secret partagé sécurise la configuration et ses données.