Configurer la réplication source-réplica MySQL

La réplication de données source-réplica vous permet de copier des données répliquées sur plusieurs ordinateurs pour la sauvegarde et l'analyse par plusieurs parties. Vous devez soumettre les modifications nécessaires identifiées par un membre du groupe au principal désigné du nœud. Cela diffère de la réplication source-source, dans laquelle tout contributeur autorisé du groupe peut mettre à jour les données.

Cet article décrit les étapes de configuration de la réplication de la base de données du réplica source MySQL® entre deux serveurs cloud. Le système d'exploitation utilisé pour les exemples de l'article est CentOS® 6, construit à partir d'une image de base Rackspace CloudServers.

Avant de commencer

Les étapes de cet article utilisent deux serveurs cloud, db01 et db02 Les serveurs .Cloud ont deux adresses IP (une publique, une privée). Les exemples illustrent la configuration de la réplication sur l'interface IP privée afin qu'aucun frais de bande passante ne soit encouru. Pendant toute la durée de l'article, db01 est considéré comme la source Serveur MySQL (fonctionnant en mode lecture-écriture) et db02 est considéré comme la réplique serveur (fonctionnant en mode lecture seule).

Si vous avez déjà une base de données MySQL en cours d'exécution sur le nœud source, un vidage et une restauration dans le nœud de réplique sont requis avant de configurer la réplication entre eux. Vous utilisez le mysqldump pour vider une base de données dans un fichier, puis la transférer et la restaurer dans la réplique. Une fois la configuration nécessaire effectuée, la réplication est sans effet. Pour plus d'informations, consultez la section Configurer la réplication.

Créer les serveurs cloud

Créez deux serveurs cloud Linux® à l'aide de l'image de base Centos 6. Utilisez les étapes suivantes pour créer chaque serveur séparément.

Connectez-vous au panneau de configuration du cloud.
Dans la barre de navigation supérieure, cliquez sur Sélectionner un produit puis Rackspace Cloud .
Sélectionnez Serveurs puis Serveurs cloud .
Cliquez sur Créer un serveur .
Nommez les serveurs afin de pouvoir les identifier facilement lors de la configuration.
Sélectionnez l'image de base Centos 6.
Sélectionnez la configuration RAM (type) appropriée aux exigences de votre base de données.
Cliquez sur Créer un serveur .

Les commandes décrites dans les sections suivantes doivent être exécutées par un utilisateur root ou sudo privilégié. Toutes les chaînes ou valeurs spécifiées entre parenthèses doivent être remplacées par des données spécifiques à votre configuration.

Installer MySQL

Vous devez installer le mysql-server package sur les deux serveurs cloud CentOS.

Avant d'installer MySQL, vérifiez que la base de données du package est à jour en exécutant la commande suivante :
```
#yum update
```
Installez MySQL et activez-le pour qu'il s'exécute automatiquement au démarrage :
```
 #yum install mysql-server
#chkconfig mysqld on
```
Démarrez le mysqld service :
```
#service mysqld start
```

Après le mysqld service a été démarré, définissez votre mot de passe racine du serveur MySQL à l'aide des commandes suivantes :

/usr/bin/mysqladmin -u root password 'new-password'
/usr/bin/mysqladmin -u root -h web01 password 'new-password'

Remarque :Vous pouvez également exécuter le script d'installation sécurisée fourni avec l'installation de MySQL :

# /usr/bin/mysql_secure_installation
Enter current password for root (enter for none):
...
Set root password? [Y/n] Y
...
Remove anonymous users? [Y/n] Y
...
Disallow root login remotely? [Y/n] Y
...
Remove test database and access to it? [Y/n] Y
...
Reload privilege tables now? [Y/n] Y

Pour autoriser les connexions sur le port 3306 (le mysqld port par défaut), ajouter une règle du port TCP 3306 avec une insertion au dernier numéro de ligne dans le RH-Firewall-1-INPUT chaîne (dans ce cas, ligne 10) :
```
# iptables -I RH-Firewall-1-INPUT 10 -p tcp --dport 3306 -j ACCEPT
```
Enregistrez la configuration du pare-feu :
```
# service iptables save
```

Complétez la section suivante pour apporter les modifications de configuration pertinentes afin d'activer la réplication.

Configurer la réplication

Un utilisateur MySQL est requis sur le serveur source (db01 ) à utiliser pour la réplication.

Exécutez les commandes suivantes pour configurer l'utilisateur MySQL, en mettant à jour les entrées entre parenthèses avec les chaînes ou les valeurs que vous prévoyez d'utiliser avec votre configuration :

Remarque : Vous n'aurez peut-être pas besoin de créer l'utilisateur dans le code suivant.
```
# mysql -u root -p
mysql> create user [replication_username]@'[private IP of db02]' identified by '[some password]';
mysql> grant replication slave on *.* TO [replication_username]@'[private IP of db02]';
mysql> flush privileges;
mysql> quit
```

Modifiez le fichier /etc/my.cnf fichier et ajoutez les entrées suivantes :

bind-address = 0.0.0.0
server-id = 1
log-bin = mysql-bin
binlog-ignore-db = "mysql"

Après avoir terminé la mise à jour de /etc/my.cnf fichier, redémarrez mysqld services.
```
#service mysqld restart
```
Avant de démarrer la réplication, les données sur les serveurs source et réplique doivent être identiques. Pour réaliser cette duplication, videz les données de la source (db01 ) serveur et ajoutez-le à la réplique (db02 ) serveur.
Utilisez la commande suivante pour vous assurer que rien ne peut écrire dans la base de données source lors d'un vidage de base de données. Notez également le nom de fichier et la position du journal binaire car vous avez besoin de ces valeurs pour terminer la configuration de la réplication sur db02 :
```
# mysql -u root -p
mysql> FLUSH TABLES WITH READ LOCK;
mysql> SHOW MASTER STATUS;

+------------------+--------------------------+------------------+
| File             | Position  | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+--------------------------+------------------+
| mysql-bin.000010 |        10 |              | mysql            |
+------------------+--------------------------+------------------+
1 row in set (0.00 sec)
```
Remarque 1 : Enregistrez le nom de fichier et la position du journal binaire car vous avez besoin de ces valeurs pour terminer la configuration de la réplication sur db02 .

Remarque 2 : Gardez cette session ouverte, la fermer libère le verrou !

Effectuer un vidage de base de données en utilisant mysqldump comme suit :

# mysqldump -u root -p --databases [database-1] [database-2] ...  > /root/db_dump.sql

Une fois le vidage de la base de données terminé, levez le verrou de lecture de la source (db01 ) en saisissant ce qui suit ou en quittant la session ouverte :
```
mysql> UNLOCK TABLES;
```
Copiez le fichier de vidage de la base de données sur le serveur réplica afin qu'il puisse être restauré à l'aide de la commande suivante :
```
scp /root/db_dump.sql [private-IP-of-db02]:/root/
```

Sur db02 , modifiez le fichier /etc/my.cnf fichier et ajoutez les entrées suivantes :

bind-address = 0.0.0.0
server-id = 2
master-host =  [private-IP-of-db01]
master-user = [replication-username]
master-password = [replication-password]
master-connect-retry = 60

Importez le fichier db_dump.sql fichier copié précédemment et redémarrez le service MySQL.
```
# mysql -u root -p < /root/db_dump.sql
# service mysqld restart
```
Effectuez les étapes de réplication du réplica :
```
# mysql -u root -p
mysql> SLAVE STOP;
mysql> CHANGE MASTER TO MASTER_HOST='[private-IP-of-db01]',
MASTER_USER='[replication-username]',
MASTER_PASSWORD='[replication-password]',
MASTER_LOG_FILE='[file-listed-on-master-status]',
MASTER_LOG_POS=[log-position-listed-on-master-status];
mysql> START SLAVE;
mysql> SHOW SLAVE STATUS\G
```
Remarque : Le Slave_IO_State le champ doit afficher "Attente de l'événement master tosend". S'il affiche "Connexion au maître", vérifiez votre fichier journal MySQL. Par défaut, il s'agit de /var/log/mysqld.log , mais il peut être configuré différemment sur votre système. Comme toujours, /etc/my.cnf définit l'emplacement de votre fichier journal.

Tester la réplication

Pour tester la configuration de la réplication, créez une nouvelle base de données et la table associée sur db01 et insérez des données pour confirmer que les modifications sont reflétées sur db02 . Dans l'exemple suivant, la nouvelle base de données est nommée testing , et la nouvelle table est nommée users :

# mysql -u root -p
mysql> create database testing;
mysql> use testing
mysql> create table users(id int not null auto_increment, primary key(id), username varchar(30) not null);
mysql> insert into users (username) values ('foo');
mysql> insert into users (username) values ('bar');
mysql> exit

Vous devriez voir les changements sur db02 immédiatement.