Réplication MySQL5 MASTER-MASTER

De Le wiki de Fred sur gantzer.eu

Sommaire

Introduction

La réplication dual-Master sous MySql permet de synchroniser deux bases MySql en utilisant le principe de la réplication maître-esclave offerte par MySql en standard. Le fonctionnement en "dual master" n'est pas natif. On détourne juste le principe master-slave en déclarant les deux machines comme maître et esclave chacune l'une d'entre-elles.


Etude de cas

Dans cet exemple, nous allons synchroniser deux bases qui sont sur deux serveurs mySql différents. Les deux bases portent le même nom : mysqlsync.

  • Sur la première machine le user mysql1 sera déclaré.
  • Sur la deuxième machine, c'est le user mysql2 qui sera déclaré.

En va tester le fait que l'écriture dans une table sur le serveur1 et bien répliquée sur le serveur 2 et vis-et-versa.

Installation de la maquette avec deux serveurs sur la même machine physqique

Vu que l'on ne dispose pas de deux machines, on va faire fonctionner deux serveurs mysql distincts sur une même machine physique.

Installation des packages mySql

Sous linux, installer Mysql par :

  yum install mysql
  yum install mysql-server

Configuration de deux users mysql disctincts

  • Pour faire fonctionner indépendemment les deux serveurs mysql, créer deux users mysql:
  vi /etc/passwd
  
  mysql1:x:27:27:MySQL Server:/var/lib/mysql1:/bin/bash
  mysql2:x:26:27:MySQL Server:/var/lib/mysql2:/bin/bash
  vi /etc/group
  
  mysql:x:27:
  pwconv
  
  mkdir /var/lib/mysql1
  chown mysql1:mysql /var/lib/mysql1
  mkdir /var/lib/mysql2 
  chown mysql2:mysql /var/lib/mysql2
  • Mettre à jour leurs profils:
  vi /var/lib/mysql1/.profile
  
  MYSQL_UNIX_PORT=/var/lib/mysql1/mysql.sock
  MYSQL_TCP_PORT=3307
  export MYSQL_TCP_PORT MYSQL_UNIX_PORT
  vi /var/lib/mysql2/.profile
  MYSQL_UNIX_PORT=/var/lib/mysql2/mysql.sock
  MYSQL_TCP_PORT=3308
  export MYSQL_TCP_PORT MYSQL_UNIX_PORT

Ceci permet du définir deux sockets et deux ports différents pour l'éxecution des deux serveurs Unix.


Configuration des fichiers my.cnf

Vu que l'on veut faire fonctionner deux serveurs mySql, on prépare deux fichiers de configuration myX.cnf.


  vi /etc/my1.cnf
  
  [mysqld]
  datadir=/var/lib/mysql1
  socket=/var/lib/mysql1/mysql.sock
  user=mysql1
  old_passwords=1
  
  [mysqld_safe]
  log-error=/var/log/mysql/mysqld1.log
  pid-file=/var/run/mysqld/mysqld1.pid


  vi /etc/my2.cnf
  
  [mysqld]
  datadir=/var/lib/mysql2
  socket=/var/lib/mysql2/mysql.sock
  user=mysql2
  old_passwords=1
  
  [mysqld_safe]
  log-error=/var/log/mysql/mysqld2.log
  pid-file=/var/run/mysqld/mysqld2.pid

Installation des bases mysql standard

  su - mysql1
  /usr/bin/mysql_install_db --force --datadir=/var/lib/mysql1
  su - mysql2
  /usr/bin/mysql_install_db --force --datadir=/var/lib/mysql2


Arrêt / Relance des deux serveurs MySQL

  • Pour le premier serveur:
  # su - mysql1
  # cd /usr ; /usr/bin/mysqld_safe --defaults-file=/etc/my1.cnf &
  [1] 31637
  Starting mysqld daemon with databases from /var/lib/mysql1
     
  # kill $(cat /var/run/mysqld/mysqld1.pid)
  #STOPPING server from pid file /var/run/mysqld/mysqld1.pid
  081030 11:26:47  mysqld ended
  • Pour le deuxième serveur:
  # su - mysql2
  # cd /usr ; /usr/bin/mysqld_safe --defaults-file=/etc/my2.cnf &
  [1] 31637
  Starting mysqld daemon with databases from /var/lib/mysql2
     
  # kill $(cat /var/run/mysqld/mysqld2.pid)
  STOPPING server from pid file /var/run/mysqld/mysqld2.pid
  081030 11:26:47  mysqld ended


Création des bases mysqlsync sur les deux serveurs

  • Sur le serveur 1
  su - mysql1
  #cd /usr ; /usr/bin/mysqld_safe --defaults-file=/etc/my1.cnf &
  [1] 32015
  
  # mysql -u root
  mysql> show databases;
  +--------------------+
  | Database           |
  +--------------------+
  | information_schema |
  | mysql              |
  | test               |
  +--------------------+
  3 rows in set (0.03 sec)
  mysql> drop database test;
  Query OK, 0 rows affected (0.00 sec)

Création de la base mysqlsync:

  mysql> CREATE DATABASE mysqlsync;
  Query OK, 1 row affected (0.00 sec)

Création du user mysql1 avec droit de connexion depuis localhost et 10.45.58.105 qui représente le host distant (ici la machine elle-même car on a les deux serveurs sur le même host):

  mysql> use mysql;
  Database changed
  mysql> GRANT ALL PRIVILEGES ON *.* TO 'mysql1'@'localhost' IDENTIFIED BY 'mysql1' WITH GRANT OPTION;
  Query OK, 0 rows affected (0.00 sec)
  
  mysql> GRANT ALL PRIVILEGES ON *.* TO 'mysql1'@'10.45.58.105' IDENTIFIED BY 'mysql1' WITH GRANT OPTION;
  Query OK, 0 rows affected (0.00 sec)
  
  mysql> flush privileges;
  Query OK, 0 rows affected (0.00 sec)
  
  mysql> select Host, User, Password, Select_priv, Reload_priv, Super_priv, Repl_slave_priv from user;
  +--------------+--------+------------------+-------------+-------------+------------+-----------------+
  | Host         | User   | Password         | Select_priv | Reload_priv | Super_priv | Repl_slave_priv |
  +--------------+--------+------------------+-------------+-------------+------------+-----------------+
  | localhost    | root   |                  | Y           | Y           | Y          | Y               |
  | vrssi01t     | root   |                  | Y           | Y           | Y          | Y               |
  | 127.0.0.1    | root   |                  | Y           | Y           | Y          | Y               |
  | localhost    | mysql1 | 3c20015562ff421e | Y           | Y           | Y          | Y               |
  | 10.45.58.105 | mysql1 | 3c20015562ff421e | Y           | Y           | Y          | Y               |
  +--------------+--------+------------------+-------------+-------------+------------+-----------------+
  5 rows in set (0.00 sec)
  
  • Sur le serveur 2 :

On effectue la même opération mais cette fois sur le serveur 2:

  su - mysql2
  cd /usr ; /usr/bin/mysqld_safe --defaults-file=/etc/my2.cnf &
  mysql -u root
  mysql> CREATE DATABASE mysqlsync;
  mysql> use mysql
  mysql> GRANT ALL PRIVILEGES ON *.* TO 'mysql2'@'localhost' IDENTIFIED BY 'mysql2' WITH GRANT OPTION;
  mysql> GRANT ALL PRIVILEGES ON *.* TO 'mysql2'@'10.45.58.105' IDENTIFIED BY 'mysql2' WITH GRANT OPTION;
  mysql> flush privileges;
  

Mise en place de la configuration dual Server

Dans cette configuration, on va déclarer les deux serveurs comme étant maître-esclave respectivement l'un de l'autre.

  • Avant de commencer à paramétrer nos serveurs, il faut leur donner un identifiant unique permettant de faire cohabiter plusieurs réplications sur notre réseau. Cet identifiant est spécifié dans le fichier de configuration à l'aide de la directive : server-id
  • MySQL utilise un format de log binaire afin de stocker son état. Le serveur esclave va se connecter au maître afin de regarder sa position dans le log binaire. Si la position du maître est différente de la sienne, il va mettre à jour sa base de données afin de se retrouver à la même position que son maître. Pour activer les logs binaires, il faut utiliser la directive : log-bin.
  • On va positionner un offset d'auto-incrémentation pour éviter la colision de clés primaires entre les deux serveurs. Le serveur 1 utilisera des clés paires et le 2ième des clés impaires.
  • Les relay-logs contiennent l'état du serveur par rapport aux logs binaires du serveur maître.

Configuration des my.cnf maître-esclave

  • Sur le serveur 1, on modifie la configuration /etc/my1.cnf créée précédemment:
  vi /etc/my1.cnf
  
  [mysqld]
  datadir=/var/lib/mysql1
  socket=/var/lib/mysql1/mysql.sock
  user=mysql1
  old_passwords=1
  
  # ID du serveur 1
  server-id = 1
  # 0 pour éviter les réplication infinies
  replicate-same-server-id = 0
  
  # Offset d'auto incrément --> paire pour le serveur 1
  auto-increment-increment = 2
  auto-increment-offset = 1  
  
  # IP du serveur 2 
  master-host=10.45.58.105
  # Port Mysql utilisé par le serveur 2
  master-port=3308
  
  # User/mdp utilisé pour se connecter sur le serveur 2
  master-user=mysql2
  master-password=mysql2
  # Timeout sur la connexion
  master-connect-retry=60
  
  # Restriction de la réplication sur la base mysqlsync
  replicate-do-db=mysqlsync
  
  # Cible des logs binaires générés sur ce serveur
  log-bin=/var/lib/mysql1/mysqld1-bin
  # Cible des relay-log générés sur ce serveur.
  relay-log=/var/lib/mysql1/mysqld1-relay-bin
  
  # Log binaires générés uniquement pour la base mysqlsync
  binlog-do-db=mysqlsync
  
  [mysqld_safe]
  log-error=/var/log/mysql/mysqld1.log
  pid-file=/var/run/mysqld/mysqld1.pid


  • Sur le serveur 2, on modifie la configuration /etc/my2.cnf créée précédemment:
  [mysqld]
  datadir=/var/lib/mysql2
  socket=/var/lib/mysql2/mysql.sock
  user=mysql2
  old_passwords=1
  
  server-id = 2
  replicate-same-server-id = 0
  auto-increment-increment = 2
  auto-increment-offset = 2
  master-host = 10.45.58.105
  master-user = mysql1
  master-port = 3307
  master-password = mysql1
  master-connect-retry = 60
  replicate-do-db = mysqlsync
  
  log-bin=/var/lib/mysql2/mysqld2-bin
  relay-log=/var/lib/mysql2/mysqld2-relay-bin
  binlog-do-db = mysqlsync
  
  [mysqld_safe]
  log-error=/var/log/mysql/mysqld2.log
  pid-file=/var/run/mysqld/mysqld2.pid
  

Démarrage des serveurs mysql

On démarre les deux serveurs mysql:

  su - mysql1 ; cd /usr ; /usr/bin/mysqld_safe --defaults-file=/etc/my1.cnf &
  su - mysql2 ; cd /usr ; /usr/bin/mysqld_safe --defaults-file=/etc/my2.cnf &

On vérifie les logs pour voir si les serveurs se voient l'un & l'autre:

  # cat mysqld1.log
  
  081030 13:10:49  mysqld started
  081030 13:10:49  InnoDB: Started; log sequence number 0 43655
  081030 13:10:49 [Note] /usr/libexec/mysqld: ready for connections.
  Version: '5.0.45-log'  socket: '/var/lib/mysql1/mysql.sock'  port: 3307  Source distribution
  081030 13:10:49 [Note] Slave SQL thread initialized, starting replication in log 'mysqld2-bin.000001' at position 98, relay log '/var/lib/mysql1/mysqld1-relay-bin.000002' position: 237
  081030 13:10:49 [Note] Slave I/O thread: connected to master 'mysql2@10.45.58.105:3308',  replication started in log 'mysqld2-bin.000002' at position 98


  # cat mysqld2.log
  
  081030 13:07:02  mysqld started
  081030 13:07:03  InnoDB: Started; log sequence number 0 43655
  081030 13:07:03 [Note] /usr/libexec/mysqld: ready for connections.
  Version: '5.0.45-log'  socket: '/var/lib/mysql2/mysql.sock'  port: 3308  Source distribution
  081030 13:07:03 [Note] Slave SQL thread initialized, starting replication in log 'FIRST' at position 0, relay log '/var/lib/mysql2/mysqld2-relay-bin.000001' position: 98
  081030 13:07:03 [Note] Slave I/O thread: connected to master 'mysql1@10.45.58.105:3307',  replication started in log 'FIRST' at position 4


Test du bon fontionnement manuel de la synchro

Création et Insertion des données dans une table sur le SERVEUR 1

  # su - mysql1
  # mysql -u mysql1 -p
  mysql> use mysqlsync
  Database changed
  
  mysql> CREATE TABLE utilisateurs (
   -> id int(4) NOT NULL UNIQUE AUTO_INCREMENT,
   -> nom VARCHAR(50) NOT NULL,
   -> adresse VARCHAR(200) NOT NULL);
  Query OK, 0 rows affected (0.03 sec)
  
  mysql> INSERT INTO utilisateurs VALUES(,'user 1','adresse du user1');
  mysql> INSERT INTO utilisateurs VALUES(,'user 2','adresse du user2');
  mysql> INSERT INTO utilisateurs VALUES(,'user 3','adresse du user3');
  mysql> INSERT INTO utilisateurs VALUES(,'user 4','adresse du user4');
  mysql> INSERT INTO utilisateurs VALUES(,'user 5','adresse du user5');
  
  mysql> select * from utilisateurs;
  +----+--------+------------------+
  | id | nom    | adresse          |
  +----+--------+------------------+
  |  1 | user 1 | adresse du user1 |
  |  3 | user 2 | adresse du user2 |
  |  5 | user 3 | adresse du user3 |
  |  7 | user 4 | adresse du user4 |
  |  9 | user 5 | adresse du user5 |
  +----+--------+------------------+
  5 rows in set (0.00 sec)

On voit bien que l'incrémentation de la clé primaire est faite par pas de deux sur des clés impaires.


Activation manuelle de la réplication sur le serveur 2

A ce stade, nous n'avons pas encore activé la réplication automatique sur le serveur 2. Par conséquent:

  su - mysql2
  mysql -u mysql2 -p
  mysql> select * from utilisateurs;
  ERROR 1146 (42S02): Table 'mysqlsync.utilisateurs' doesn't exist

On effectue une synchronisation manuelle:

  mysql> load data from master;
  Query OK, 0 rows affected (0.07 sec)
  
  mysql> select * from utilisateurs;
  +----+--------+------------------+
  | id | nom    | adresse          |
  +----+--------+------------------+
  |  1 | user 1 | adresse du user1 |
  |  3 | user 2 | adresse du user2 |
  |  5 | user 3 | adresse du user3 |
  |  7 | user 4 | adresse du user4 |
  |  9 | user 5 | adresse du user5 |
  +----+--------+------------------+

On voit bien que le serveur 2 s'est synchronisé sur le serveur 1.

  • On va insérer 2 lignes sur sur le serveur 2:
  mysql> INSERT INTO utilisateurs VALUES(,'user 6','adresse du user6');
  mysql> INSERT INTO utilisateurs VALUES(,'user 7','adresse du user7');
  mysql> select * from utilisateurs;
  +----+--------+------------------+
  | id | nom    | adresse          |
  +----+--------+------------------+
  |  1 | user 1 | adresse du user1 |
  |  3 | user 2 | adresse du user2 |
  |  5 | user 3 | adresse du user3 |
  |  7 | user 4 | adresse du user4 |
  |  9 | user 5 | adresse du user5 |
  | 10 | user 6 | adresse du user6 |
  | 12 | user 7 | adresse du user7 |
  +----+--------+------------------+
  

On remarque que l'incrémentation est bien paire sur le serveur 2

  • Sur le serveur 1, on lance une synchronisation manuelle:
  mysql> load data from master;
  
  mysql> select * from utilisateurs;
  +----+--------+------------------+
  | id | nom    | adresse          |
  +----+--------+------------------+
  |  1 | user 1 | adresse du user1 |
  |  3 | user 2 | adresse du user2 |
  |  5 | user 3 | adresse du user3 |
  |  7 | user 4 | adresse du user4 |
  |  9 | user 5 | adresse du user5 |
  | 10 | user 6 | adresse du user6 |
  | 12 | user 7 | adresse du user7 |
  +----+--------+------------------+
  

Cette fois c'est le serveur 1 qui s'est synchronisé sur le serveur 2.

Conclusion

En faisant des synchronisations manuelles, on voit bien que les deux serveurs se synchronisent l'un par rapport à l'autre. Dans le chapitre suivant, on va mettre en place la configuration pour que les machines effectuent la synchronisation de façon automatique.


Activation de la synchronisation automatique

récupération des offsets

Sur chaque serveur, on va récupérer le numéro d'offset et le log-bin en cours:

  • Sur le serveur 1:
  mysql> show master status;
  +--------------------+----------+--------------+------------------+
  | File               | Position | Binlog_Do_DB | Binlog_Ignore_DB |
  +--------------------+----------+--------------+------------------+
  | mysqld1-bin.000002 |     1405 | mysqlsync    |                  |
  +--------------------+----------+--------------+------------------+
  • Sur le serveur 2:
  mysql> show master status;
  +--------------------+----------+--------------+------------------+
  | File               | Position | Binlog_Do_DB | Binlog_Ignore_DB |
  +--------------------+----------+--------------+------------------+
  | mysqld2-bin.000002 |      810 | mysqlsync    |                  |
  +--------------------+----------+--------------+------------------+
  • Le serveur 1 est en position 1405 et le 2 en 810.


Activation de la synchronisation

On active la synchronisation sur les deux "master"/"esclave" en disant à chaque machine à quel offset en est son hôte tiers:

  • Sur le Serveur 1 :
  mysql> CHANGE MASTER TO MASTER_HOST='10.45.58.105',
         MASTER_PORT=3308 ,MASTER_USER='mysql2',MASTER_PASSWORD='mysql2', 
         MASTER_LOG_FILE='mysqld2-bin.000002', MASTER_LOG_POS=810;
  • Sur le Serveur 2 :
  mysql> CHANGE MASTER TO MASTER_HOST='10.45.58.105',
         MASTER_PORT=3307 ,MASTER_USER='mysql1',
         MASTER_LOG_FILE='mysqld1-bin.000002',MASTER_PASSWORD='mysql1', MASTER_LOG_POS=1405;


  • Sur les deux serveurs, on fait un mysql> start slave; pour démarrer le host en tant qu'esclave.
  • Pour vérifier que la synchro est opérationnelle, utiliser la commande:
  mysql>  show slave status;

Et vérifier que Slave_IO_Running et Slave_SQL_Running sont bien à 'yes' sur la bonne base.

  • A ce stade, une modification faite dans la base d'un des hosts est répliquée sur l'autre et vis et versa. Pour preuve:
    • Sur le serveur 1:
  INSERT INTO utilisateurs VALUES(,'user insere sur mysql1','adresse du user');
    • Sur le serveur 2:
  INSERT INTO utilisateurs VALUES(,'user insere sur mysql2','adresse du user');
    • On retrouve bien sur les deux serveurs les inserts sans aucune action manuelle:
  +----+------------------------+------------------+
  | id | nom                    | adresse          |
  +----+------------------------+------------------+
  | 13 | user insere sur mysql1 | adresse du user  |
  | 16 | user insere sur mysql2 | adresse du user  |
  +----+------------------------+------------------+


Tests de reprise sur incident

Test 1 : Arrêt propre d'un des serveurs et insertion de données dans l'autre

  • On purge la table utilisateurs par un truncate pour répartir de zéro. Sur un des deux serveurs:
  mysql> truncate table utilisateurs;
  Query OK, 0 rows affected (0.00 sec)

Bien entendu, la table est vidée sur les deux serveurs à cause de la réplication qui est active.

  • On arrête le serveur 2:
  $ id
  uid=26(mysql2) gid=27(mysql) groups=27(mysql)
  $ kill $(cat /var/run/mysqld/mysqld2.pid)
  $ STOPPING server from pid file /var/run/mysqld/mysqld2.pid
  081030 14:06:45  mysqld ended
  • On insère des lignes sur serveur 1:

mysql> INSERT INTO utilisateurs VALUES(,'user 16','adresse du user16'); mysql> INSERT INTO utilisateurs VALUES(,'user 17','adresse du user17');

  • on redémarre le serveur 2 et on vérifie que la synchro est tout de même faite:
  $ cd /usr ; /usr/bin/mysqld_safe --defaults-file=/etc/my2.cnf &
     $ mysql -u mysql2 -p
  mysql> select * from utilisateurs;
  mysql> use mysqlsync;
  Database changed
  mysql> select * from utilisateurs;
  +----+---------+-------------------+
  | id | nom     | adresse           |
  +----+---------+-------------------+
  |  1 | user 16 | adresse du user16 |
  |  3 | user 17 | adresse du user17 |
  +----+---------+-------------------+

--> c'est OK.

Test 2 : Arrêt de la communication entre les serveurs et insertion de donnéés dans la deux bases distantes

On va simuler une perte de réseau entre les deux serveurs en modifiant le mot de passe des users mysql1 et mysql2.

Changement des mots de passe pour simuler perte de réseau

  • Sur les serveur 1 & 2:
  mysql> use mysql
  mysql> set password for  mysql1@'10.45.58.105' = PASSWORD('bidon');
  mysql> flush privileges;
  mysql> use mysql
  mysql> set password for  mysql2@'10.45.58.105' = PASSWORD('bidon');
  mysql> flush privileges;
  • Si on regarde les logs, on voit bien que la synchro est HS:
  081030 14:26:53 [ERROR] Error running query, slave SQL thread aborted. Fix the problem, and restart the slave SQL thread with "SLAVE START". We stopped at log 'mysqld2-bin.000003' position 98

Insertion de lignes dans les tables des deux serveurs

  • Sur le serveur 1:
  INSERT INTO utilisateurs VALUES(,'user 1 insere sur mysql1','adresse du user1');
  INSERT INTO utilisateurs VALUES(,'user 2 insere sur mysql1','adresse du user2');
  • Sur le serveur 2:
  INSERT INTO utilisateurs VALUES(,'user 1 insere sur mysql2','adresse du user1');
  INSERT INTO utilisateurs VALUES(,'user 2 insere sur mysql2','adresse du user2');

On vérifie: la réplication n'a effectivement pas eu lieu.

Remise en place des mots de passe

On remet les bons mots de passe pour que la communication entre les deux serveurs fonctionne à nouveau:

  • Sur les serveurs 1 & 2:
  mysql> use mysql
  mysql> set password for  mysql1@'10.45.58.105' = PASSWORD('mysql1');
  mysql> flush privileges;
  mysql> use mysql
  mysql> set password for  mysql2@'10.45.58.105' = PASSWORD('mysql2');
  mysql> flush privileges;
  • Arrêt/relance des serveurs mySql ou stop slave/start slave sur les deux machines


Etat de la synchronisation à la relance

  • Sur le serveur 1:
  mysql>  select * from utilisateurs;
  +----+--------------------------+-------------------+
  | id | nom                      | adresse           |
  +----+--------------------------+-------------------+
  |  1 | user 16                  | adresse du user16 |
  |  3 | user 17                  | adresse du user17 |
  | 15 | user 2 insere sur mysql1 | adresse du user2  |
  | 13 | user 1 insere sur mysql1 | adresse du user1  |
  +----+--------------------------+-------------------+

--> Les deux lignes insérées sur le serveur 2 n'ont pas été répliquées !

  • Sur le serveur 2
  mysql>  select * from utilisateurs;
  +----+--------------------------+-------------------+
  | id | nom                      | adresse           |
  +----+--------------------------+-------------------+
  |  1 | user 16                  | adresse du user16 |
  |  3 | user 17                  | adresse du user17 |
  | 15 | user 2 insere sur mysql1 | adresse du user2  |
  | 13 | user 1 insere sur mysql1 | adresse du user1  |
  | 14 | user 2 insere sur mysql2 | adresse du user2  |
  | 12 | user 1 insere sur mysql2 | adresse du user1  |
  +----+--------------------------+-------------------+

--> La synchronisation a bien eu lieu à la reprise de la connexion


Reset de la synchronisation

Dans le test 2, on a bien vu que la synchronisation a été perdue et qu'une des deux machines (le serveur 1) n'est plus en phase.

On a deux solutions pour refaire la synchronisation:

reset par forcage du reload

Sur la machine qui n'est plus synchro:

  mysql> load data from master

Cette solution fonctionne, mais peu avoir des effets de bords (constaté durant les tests... certaines synchros suivantes peuvent poser problème)

reset par suppression des relay-log

C'est la méthode la plus efficace. Nous avions vu plus haut que les relay-log sont une image des log-bin de la machine distante. Leur suppression va entraîner une resynchronisation complète.

Sur les deux serveurs

  • Arrêt du serveur mysql:
  su - mysql1 ; kill $(cat /var/run/mysqld/mysqld1.pid)
  su - mysql2 ; kill $(cat /var/run/mysqld/mysqld1.pid)
  • Supression des log-bin et relay-log :
  cd /var/lib/mysql1 ; rm master.info relay-log.info ; rm mysqld1-relay-bin* ; rm mysqld1-bin*
  cd /var/lib/mysql2 ; rm master.info relay-log.info ; rm mysqld2-relay-bin* ; rm mysqld2-bin*
  • Redémarrage des serveurs.
  • Arrêt du slave sur chaque serveur par mysql> stop slave;
  • On fait une synchronisation manuelle sur les deux hosts par mysql> load data from master
  • On refait sur chaque machine la procédure (voir plus haut dans la mise en place de la synchro)
  CHANGE MASTER TO MASTER_HOST='10.45.58.105',
  MASTER_PORT=330X ,MASTER_USER='mysqlX',MASTER_PASSWORD='mysqlX',
  MASTER_LOG_FILE='mysqldX-bin.00000X', MASTER_LOG_POS=XX;
  • Puis start slave;
  • c'est réparti et les deux serveurs doivent être OK et synchros


Conclusion

La synchronisation dual Master fonctionne bien et de façon efficace.

Par contre, il existe un problème de taille majeure. En cas de coupure réseau entre les deux machines faisant la réplication mySQL, on arrive très vite à une situation de désynchronisation. Cette désynchronisation n'empêche pas la réplication d'être fonctionnelle quand la connexion revient à nouveau. Le status est normal, mais des données peuvent être manquantes d'une part et d'autre. Seul un RAZ des relay-log et un reload manuel permettent de revenir dans un état correct...

Outils personnels
Navigation