Étiquette : Replication

Mise en place d’une réplication synchrone entre deux bases PostgreSQL
Nous allons mettre en place une réplication synchrone entre deux bases PostgreSQL

On part du principe que PostgreSQL est installé sur les serveurs

Dans notre exemple il y aura deux serveurs
- 192.168.1.114 qui sera le Master
- 192.168.1.184 qui sera le Slave
Dans notre exemple PostgreSQL est en version 17.7

1 – Préparer le master

Toutes les commandes seront à écrire sur le serveur master
- Éditer le fichier /etc/postgresql/17/main/postgresql.conf
```
nano /etc/postgresql/17/main/postgresql.conf
```
- Modifier / créer / de-commenter les lignes suivantes
```
listen_addresses = '*'
wal_level = replica
max_wal_senders = 10
max_replication_slots = 10
wal_keep_size = 1GB

# Pour la réplication synchrone :
synchronous_standby_names = 'node184'
synchronous_commit = on
```
(node184 sera le nom du standby que l’on paramétrera plus tard)
- Éditer le fichier /etc/postgresql/17/main/pg_hba.conf
```
nano /etc/postgresql/17/main/pg_hba.conf
```
- Rajouter sous host all all 0.0.0.0/0 md5
```
host    replication     replicator     192.168.1.184/32     md5
```
(Attention aux tabulations)

(192.168.1.184 est l’ip du slave selon la configuration)

(replicator est le nom de l’utilisateur qui fera la réplication et que l’on va créer à l’étape suivante)
- Créer l’utilisateur qui va servir pour la réplication
```
sudo -i -u postgres
psql
CREATE ROLE replicator WITH REPLICATION LOGIN ENCRYPTED PASSWORD 'motdepasse';
```
(Penser à mettre un mot de passe fort pour l’utilisateur)
- Relancer PostgreSQL pour mettre à jour le nouveau paramétrage
```
systemctl reload postgresql
```
2 – Préparer le Slave

Toutes les commandes seront à écrire sur le serveur slave
- On stoppe PostgreSQL
```
systemctl stop postgresql
```
- on supprime les données sur le serveur
```
rm -rf /var/lib/postgresql/17/main/*
```
- on récupére la base du Master
```
pg_basebackup -h 192.168.1.114 -U replicator -D /var/lib/postgresql/17/main -Fp -Xs -P -R
```
(Attention le 192.168.1.114 est l’ip du master à adapter selon la configuration)

-R pour créer automatiquement le fichier standby.signal et postgresql.auto.conf (ces fichiers servent à dire au serveur qu’il n’est plus un serveur en lecture-écriture mais que l’écriture se fait exclusivement à partir du master)

-Xs pour copier les WAL necessaires
- On va vérifier le fichier /var/lib/postgresql/17/main/postgresql.auto.conf
```
nano /var/lib/postgresql/17/main/postgresql.auto.conf
```
- on devrait avoir une ligne comme ça dedans
```
primary_conninfo = 'user=replicator password=motdepasse channel_binding=prefer host=192.168.1.114 port=5432 sslmode=prefer sslnegotiation=postgres sslcompression=0 sslcertmode=allow sslsni=1 ssl_min_protocol_version=TLSv1.2 gssencmode=prefer krbsrvname=postgres gssdelegation=0 target_session_attrs=any load_balance_hosts=disable'
```
(Bien vérifier le mot de passe et l’ip du master)
- Modifier la ligne pour ajouter application_name=node184 aprés port =5432
(node184 correspond au node que l’on a mis à l’étape 1 dans le fichier /etc/postgresql/17/main/postgresql.conf à la ligne synchronous_standby_names =)
- Changer les droits du fichier standby.signal pour les donner à postgres
```
chown postgres:postgres /var/lib/postgresql/17/main/standby.signal
chmod 600 /var/lib/postgresql/17/main/standby.signal
```
3 – Configuration de la réplication sur le Slave
- Éditer le fichier /etc/postgresql/17/main/postgresql.conf
- Ajouter / modifier / de-commenter
```
hot_standby = on
```
- Mettre au propre les droits du slave
```
chown -R postgres:postgres /var/lib/postgresql/17/main
chmod 700 /var/lib/postgresql/17/main
```
- Démarrer postgresql
```
systemctl start postgresql
```
4 – Vérification

4.1 Sur le master
```
sudo -i -u postgres
psql
SELECT application_name, state, sync_state FROM pg_stat_replication;
```
On devrait avoir
```
SHOW synchronous_standby_names;
SHOW synchronous_commit;
```
Tout est bien sur on

4.2 Sur PgAdmin (si installé)
- On insère une données sur le master
- La donnée est bien envoyées sur le slave
12 février 2026
Mise en place d’une réplication asynchrone PostgreSQL
Nous allons mettre en place une réplication asynchrone entre deux serveurs PostgreSQL

1 – Prérequis

Il faut avoir installé PostgreSQL sur les serveurs

2 – Préambule

Dans notre exemple on va avoir deux serveurs
- Le 192.168.1.114 qui va être considéré comme le Master. C’est lui qui enverra ses données au Slave
- Le 192.168.1.184 qui va être considéré comme le Slave. C’est lui qui recevra les données du Master
3 – Préparation du Master

Toutes les commandes seront faites sur le Master

3.1 – Création de l’utilisateur qui fera la réplication
- on se connecte au master
```
sudo -i -u postgres
```
(L’utilisateur postgre est crée automatiquement lors de l’installation de PostgreSQL. Se reporter à l’article parlant de l’installation de PostgreSQL)
```
psql
```
- Créer l’utilisateur qui fera la réplication
```
CREATE ROLE replicator WITH REPLICATION LOGIN PASSWORD 'motdepasseutilisateur';
```
3.2 – Modification des fichiers PostgreSQL
- Modifier le fichier /etc/postgresql/*/main/postgresql.conf
- De-commenter, ajouter ou modifier les lignes suivantes
```
listen_addresses = '*'
wal_level = replica
max_wal_senders = 10
wal_keep_size = 512MB
```
- En option mais recommandé pour archiver les WAL
- De-commenter, ajouter ou modifier les lignes suivantes
```
archive_mode = on
archive_command = 'cp %p /var/lib/postgresql/wal_archive/%f'
```
- Enregistrer le fichier /etc/postgresql/*/main/postgresql.conf
- Modifier le fichier /etc/postgresql/*/main/pg_hba.conf
- commenter
```
host    replication     all             127.0.0.1/32            scram-sha-256
host    replication     all             ::1/128                 scram-sha-256
```
- Ajouter
```
host    replication     replicator     192.168.1.184/32     md5
```
(Attention, l’ip est l’ip du Slave, penser à la modifier si le Slave n’a pas l’ip 192.168.1.184)

(Attention aux tabulations)
- Sauvegarder le fichier
3.3 Redémarrer le service PostgreSQL
```
sudo systemctl restart postgresql
```
4 – Préparation du Slave

Toutes les commandes seront faites sur le Slave

4.1 Arrêter le service PostgreSQL
```
sudo systemctl stop postgresql
```
4.2 Supprimer toutes les données de l’instance (On va récupérer les données du master plus tard)
```
sudo rm -rf /var/lib/postgresql/17/main/*
```
4.3 Cloner le master
```
pg_basebackup -h 192.168.1.114 -U replicator -D /var/lib/postgresql/17/main -Fp -Xs -P
```
(Attention, l’ip est l’ip du Master, si 192.168.1.114 n’est pas l’ip du Master il faut bien mettre l’ip du Master)

(Le mot de passe de l’utilisateur replicator rentré à l’étape 3.1 est demandé)

5 – Activation du mode standby

Le mode standby permet de dire au serveur que ce n’est pas un serveur normal mais qu’il doit se connecter à un master pour avoir ses données

5.1 – Créer le fichier standby.signal
```
sudo -u postgres touch /var/lib/postgresql/17/main/standby.signal
```
5.2 – Configurer la connexion au master
- Modifier le fichier /var/lib/postgresql/*/main/postgresql.auto.conf
- ajouter
```
primary_conninfo = 'host=192.168.1.114 port=5432 user=replicator password=motdepasseutilisateur'
```
(Attention, l’ip est l’ip du Master, le mot de passe est le mot de passe rentré à l’étape 3.1)
- Enregistrer le fichier
6 – Démarrer le service PostgreSQL sur le Slave
```
sudo systemctl start postgresql@17-main
```
7 – Vérifications

On va faire trois vérifications

7.1 – Sur le master, rentrer en mode sql
```
sudo -i -u postgres
psql
```
- Écrire
```
SELECT pid, state, client_addr FROM pg_stat_replication;
```
Le retour dois être xxxx streaming ip_du_slave

Le Master est bien configuré

7.2 – Sur le Slave, rentrer en mode sql
```
sudo -i -u postgres
psql
```
- Écrire
```
SELECT pg_is_in_recovery();
```
- T pour true, le slave est bien configuré
7.3 – Sur PGAdmin (si installé)
- On crée un enregistrement sur la base Master
- On vérifie sur la base Slave
Les données sont bien renvoyées sur le Slave
10 février 2026
Mettre en place une réplication entre plusieurs bases de données MariaDB
1 – Préambule

Nous allons mettre en place une réplication entre deux bases de données mariadb, ce qui signifie que ce qui se passe sur une base sera automatiquement renvoyé sur l’autre base

Attention : il faut prévoir un maître et un ou des esclaves

Le maître sera celui qui envoie les données, le ou les esclaves seront ceux qui recevront les données

Un cas précis serait de mettre une base en écriture et une ou plusieurs bases en lecture

Cela permettrai de rediriger le trafic entre les utilisateurs qui vont écrire dans la base (faire des commandes, etc…) et les utilisateurs qui vont lire la base (voir leurs infos, voir leurs commandes, etc…)

Cela permet, à terme, une scalabilité horizontale d’une application

Dans notre exemple nous allons avoir le « Master » qui aura l’ip 192.168.1.169 et un seul « Slave » qui aura l’ip 192.168.1.91

Notre base de données sera nommée test et aura une seule table nommée test

2 – Préparation du master

Toutes les commandes seront à faire sur le serveur « Maître »

2.1 – Modifier la configuration de MariaDB

Éditer le fichier /etc/mysql/mariadb.conf.d/50-server.cnf
```
sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf
```
Repérer la ligne bind-address, et mettre à la place
```
bind-address = 0.0.0.0
server-id = 1
log_bin = mariadb-bin
binlog_format = ROW
```
Enregistrer le fichier

Redémarrer MariaDB
```
sudo systemctl restart mariadb
```
2.2 – Création de l’utilisateur qui va servir pour la réplication

Se connecter à mariaBD
```
sudo mysql -u root
```
Créer l’utilisateur
```
CREATE USER 'nomutilisateurreplication'@'192.168.1.%' IDENTIFIED BY 'motdepasseutilisateur';
```
Changer le nomutilisateurreplication par le nom désiré et le motdepasseutilisateur par le mot de passe désiré

Donner les accès à l’utilisateur pour qu’il puisse répliquer
```
GRANT REPLICATION SLAVE ON *.* TO 'nomutilisateurreplication'@'192.168.1.%';
FLUSH PRIVILEGES;
```
2.3 – Verrouillage des tables et récupération des infos Binlog
```
FLUSH TABLES WITH READ LOCK;
SHOW MASTER STATUS;
```
Noter les valeurs dans un coin

2.4 – Faire une sauvegarde de la base master pour pouvoir la réinjecter dans le slave
```
mysqldump -u root -p --all-databases --master-data=2 > dump.sql
```
Récupérer le fichier dump.sql sur le poste – voir tuto SCP si nécessaire

Déverrouiller le master
```
UNLOCK TABLES;
```
3 – Préparation du slave

Toutes les commandes seront à faire sur le serveur « Esclave »

3.1 – Éditer le fichier /etc/mysql/mariadb.conf.d/50-server.cnf
```
sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf
```
Après bind-adress rajouter
```
server-id = 2
relay_log = relay-bin
```
Enregistrer le fichier

Redémarrer MariaDB
```
sudo systemctl restart mariadb
```
3.2 – Importer le fichier dump crée à l’étape 2.4

Voir le tuto sur SCP si nécessaire pour mettre le fichier sur le serveur esclave
```
mysql -u root -p < dump.sql
```
3.3 – Configurer la réplication

Se connecter sur mariaDB
```
mysql -u root -p
```
Passer la commande suivante en modifiant les valeurs que l’on a mises tout au long de ce tuto
```
CHANGE MASTER TO
  MASTER_HOST='ipdumaster',
  MASTER_USER='nomutilisateurreplication',
  MASTER_PASSWORD='motdepasseutilisateur',
  MASTER_LOG_FILE='nomfichieretape2.3',
  MASTER_LOG_POS=positionetape2.3;
```
Démarrer l’esclave
```
START SLAVE;
```
3.4 – Vérification
```
SHOW SLAVE STATUS\G
```
Vérifier surtout
- Slave_IO_Running : Yes
- Slave_SQL_Running : Yes
- Seconds_Behind_Master : 0 (ou proche)
4 – Tester une insertion dans la base pour voir si ça réplique bien

Et sur le slave

5 – Bonus

Pour rajouter d’autres slave, on reprends au 2.3 pour retrouver le fichier et la position

Et dans l’étape 3.1 on mets un server-id à 3, ou 4, ou 5, etc…
8 février 2026

Étiquette : Replication

Mise en place d’une réplication synchrone entre deux bases PostgreSQL

Mise en place d’une réplication asynchrone PostgreSQL

Mettre en place une réplication entre plusieurs bases de données MariaDB