Principes de base de la réplication MySQL

MySQLMySQLBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, nous allons explorer les bases de la réplication MySQL. L'objectif principal est de configurer un environnement de réplication maître-esclave de base, permettant la synchronisation des données entre deux serveurs MySQL.

Le laboratoire commence par la configuration d'un serveur maître avec la journalisation binaire activée, qui est essentielle pour enregistrer toutes les modifications de données. Nous allons éditer le fichier de configuration MySQL (/etc/mysql/mysql.conf.d/mysqld.cnf) pour définir log_bin = mysql-bin et server_id = 1. Ensuite, nous allons configurer un serveur esclave pour répliquer les données du maître, vérifier l'état de la réplication à l'aide de la commande SHOW SLAVE STATUS, et enfin, simuler et résoudre une erreur de réplication pour comprendre les techniques de dépannage.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL mysql(("MySQL")) -.-> mysql/BasicKeywordsandStatementsGroup(["Basic Keywords and Statements"]) mysql(("MySQL")) -.-> mysql/TransactionManagementandSecurityGroup(["Transaction Management and Security"]) mysql(("MySQL")) -.-> mysql/SystemManagementToolsGroup(["System Management Tools"]) mysql/BasicKeywordsandStatementsGroup -.-> mysql/create_database("Database Creation") mysql/BasicKeywordsandStatementsGroup -.-> mysql/create_table("Table Creation") mysql/BasicKeywordsandStatementsGroup -.-> mysql/select("Data Retrieval") mysql/BasicKeywordsandStatementsGroup -.-> mysql/insert("Data Insertion") mysql/TransactionManagementandSecurityGroup -.-> mysql/grant_permission("Permission Granting") mysql/SystemManagementToolsGroup -.-> mysql/show_status("Status Overview") mysql/SystemManagementToolsGroup -.-> mysql/show_variables("Configuration Overview") subgraph Lab Skills mysql/create_database -.-> lab-550913{{"Principes de base de la réplication MySQL"}} mysql/create_table -.-> lab-550913{{"Principes de base de la réplication MySQL"}} mysql/select -.-> lab-550913{{"Principes de base de la réplication MySQL"}} mysql/insert -.-> lab-550913{{"Principes de base de la réplication MySQL"}} mysql/grant_permission -.-> lab-550913{{"Principes de base de la réplication MySQL"}} mysql/show_status -.-> lab-550913{{"Principes de base de la réplication MySQL"}} mysql/show_variables -.-> lab-550913{{"Principes de base de la réplication MySQL"}} end

Configurer un serveur maître avec journalisation binaire

Dans cette étape, nous allons configurer un serveur MySQL pour qu'il agisse comme le maître dans une configuration de réplication. Une partie cruciale de cette configuration consiste à activer la journalisation binaire. Les journaux binaires enregistrent toutes les modifications de données apportées à la base de données, qui sont ensuite utilisées par le serveur esclave pour répliquer les changements.

Tout d'abord, comprenons pourquoi la journalisation binaire est importante. Sans journalisation binaire, le serveur esclave n'aurait aucun moyen de savoir quelles modifications répliquer du maître. Les journaux binaires agissent comme un journal de transactions, garantissant que le serveur esclave reste synchronisé avec le maître.

Maintenant, configurons le serveur maître.

  1. Éditer le fichier de configuration MySQL :

    Le fichier de configuration MySQL est généralement situé à /etc/mysql/mysql.conf.d/mysqld.cnf. Nous allons utiliser nano pour éditer ce fichier.

    sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf
  2. Activer la journalisation binaire :

    Ajoutez les lignes suivantes à la section mysqld du fichier de configuration. Si la section mysqld n'existe pas, localisez la ligne [mysqld] et ajoutez les configurations suivantes en dessous.

    log_bin = mysql-bin
    server_id = 1
    • log_bin = mysql-bin : Cela active la journalisation binaire et définit le nom de base des fichiers journaux sur mysql-bin. MySQL ajoutera automatiquement un numéro de séquence à ce nom de base (par exemple, mysql-bin.000001, mysql-bin.000002, etc.).
    • server_id = 1 : Cela définit un identifiant unique pour le serveur maître. Chaque serveur dans une configuration de réplication doit avoir un server_id unique.

    La section mysqld de votre fichier de configuration devrait maintenant ressembler à ceci :

    [mysqld]
    #
    ## * Paramètres de base
    #
    user            = mysql
    pid-file        = /var/run/mysqld/mysqld.pid
    socket          = /var/run/mysqld/mysqld.sock
    port            = 3306
    basedir         = /usr
    datadir         = /var/lib/mysql
    tmpdir          = /tmp
    lc-messages-dir = /usr/share/mysql
    log_bin = mysql-bin
    server_id = 1
    ## ... autres configurations ...

    Appuyez sur Ctrl+X, puis Y, puis Entrée pour enregistrer les modifications et quitter nano.

  3. Redémarrer le serveur MySQL :

    Pour appliquer les modifications, redémarrez le serveur MySQL. Étant donné que nous sommes dans un conteneur Docker, nous ne pouvons pas utiliser systemctl. Au lieu de cela, nous allons utiliser le script mysql.server.

    sudo /etc/init.d/mysql restart

    Vous devriez voir une sortie similaire à :

    [ ok ] Redémarrage de mysql (via systemctl) : mysql.service.
  4. Vérifier que la journalisation binaire est activée :

    Connectez-vous au serveur MySQL en tant qu'utilisateur root. Vous devrez peut-être utiliser sudo pour accéder à MySQL si vous n'avez pas encore configuré de mot de passe pour l'utilisateur root.

    sudo mysql -u root

    Exécutez la requête SQL suivante pour vérifier l'état de la journalisation binaire :

    SHOW VARIABLES LIKE 'log_bin';

    La sortie devrait être :

    +---------------+-------+
    | Variable_name | Value |
    +---------------+-------+
    | log_bin       | ON    |
    +---------------+-------+
    1 row in set (0.00 sec)

    Cela confirme que la journalisation binaire est activée.

    Vous pouvez également vérifier l'identifiant du serveur :

    SHOW VARIABLES LIKE 'server_id';

    La sortie devrait être :

    +---------------+-------+
    | Variable_name | Value |
    +---------------+-------+
    | server_id     | 1     |
    +---------------+-------+
    1 row in set (0.00 sec)

    Quittez le moniteur MySQL :

    exit

Vous avez maintenant configuré avec succès le serveur maître avec la journalisation binaire. L'étape suivante consistera à configurer le serveur esclave pour répliquer les données de ce maître.

Configurer un serveur esclave pour répliquer les données

Dans cette étape, nous allons configurer un serveur MySQL pour qu'il agisse comme un esclave, répliquant les données du serveur maître configuré à l'étape précédente. Cela implique de configurer les paramètres du serveur esclave et d'établir une connexion au maître.

  1. Configurer le serveur esclave :

    Tout d'abord, nous devons configurer le serveur esclave avec un server_id unique et activer la journalisation des relais. Les journaux de relais sont utilisés par le serveur esclave pour stocker les événements des journaux binaires reçus du maître avant de les appliquer à sa propre base de données.

    Éditez le fichier de configuration MySQL sur le serveur esclave (généralement situé à /etc/mysql/mysql.conf.d/mysqld.cnf) :

    sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

    Ajoutez ou modifiez les lignes suivantes dans la section [mysqld] :

    server_id = 2
    relay_log = mysql-relay-bin
    • server_id = 2 : Cela définit un identifiant unique pour le serveur esclave. Il doit être différent de l'server_id du serveur maître.
    • relay_log = mysql-relay-bin : Cela active la journalisation des relais et définit le nom de base des fichiers de journal de relais.

    La section mysqld de votre fichier de configuration devrait maintenant ressembler à ceci :

    [mysqld]
    #
    ## * Paramètres de base
    #
    user            = mysql
    pid-file        = /var/run/mysqld/mysqld.pid
    socket          = /var/run/mysqld/mysqld.sock
    port            = 3306
    basedir         = /usr
    datadir         = /var/lib/mysql
    tmpdir          = /tmp
    lc-messages-dir = /usr/share/mysql
    server_id = 2
    relay_log = mysql-relay-bin
    ## ... autres configurations ...

    Appuyez sur Ctrl+X, puis Y, puis Entrée pour enregistrer les modifications et quitter nano.

  2. Redémarrer le serveur MySQL sur l'esclave :

    Redémarrez le serveur MySQL pour appliquer les modifications :

    sudo /etc/init.d/mysql restart

    Vous devriez voir une sortie similaire à :

    [ ok ] Redémarrage de mysql (via systemctl) : mysql.service.
  3. Créer un utilisateur de réplication sur le serveur maître :

    Sur le serveur maître, connectez-vous au serveur MySQL en tant qu'utilisateur root :

    sudo mysql -u root

    Créez un utilisateur dédié pour la réplication. Remplacez 'slave_user' par le nom d'utilisateur souhaité et 'password' par un mot de passe fort. Remplacez également '%' par l'adresse IP de votre serveur esclave pour plus de sécurité. Si vous n'êtes pas sûr de l'adresse IP du serveur esclave, vous pouvez utiliser '%' pour autoriser les connexions depuis n'importe quel hôte (non recommandé pour les environnements de production).

    CREATE USER 'slave_user'@'%' IDENTIFIED BY 'password';
    GRANT REPLICATION SLAVE ON *.* TO 'slave_user'@'%';
    FLUSH PRIVILEGES;
    • CREATE USER 'slave_user'@'%' IDENTIFIED BY 'password' : Crée un nouvel utilisateur MySQL nommé slave_user qui peut se connecter depuis n'importe quel hôte ('%').
    • GRANT REPLICATION SLAVE ON *.* TO 'slave_user'@'%' : Accordez le privilège REPLICATION SLAVE à l'utilisateur slave_user sur toutes les bases de données et tables. Ce privilège est nécessaire pour que le serveur esclave puisse demander des mises à jour des journaux binaires au maître.
    • FLUSH PRIVILEGES : Recharge les tables de privilèges pour appliquer les nouveaux privilèges.

    Quittez le moniteur MySQL sur le serveur maître :

    exit
  4. Configurer l'esclave pour se connecter au maître :

    Sur le serveur esclave, connectez-vous au serveur MySQL en tant qu'utilisateur root :

    sudo mysql -u root

    Indiquez au serveur esclave comment se connecter au serveur maître. Remplacez 'master_host' par l'adresse IP ou le nom d'hôte de votre serveur maître, 'slave_user' par le nom d'utilisateur de réplication que vous avez créé et 'password' par le mot de passe de réplication.

    CHANGE MASTER TO
        MASTER_HOST='master_host',
        MASTER_USER='slave_user',
        MASTER_PASSWORD='password',
        MASTER_LOG_FILE='mysql-bin.000001',
        MASTER_LOG_POS=4;
    • MASTER_HOST : Le nom d'hôte ou l'adresse IP du serveur maître.
    • MASTER_USER : Le nom d'utilisateur que l'esclave utilisera pour se connecter au maître.
    • MASTER_PASSWORD : Le mot de passe de l'utilisateur de réplication.
    • MASTER_LOG_FILE : Le nom du fichier de journal binaire du maître à partir duquel commencer la réplication. Vous pouvez le trouver en exécutant SHOW MASTER STATUS; sur le serveur maître. Pour une nouvelle configuration, c'est généralement mysql-bin.000001.
    • MASTER_LOG_POS : La position dans le fichier de journal binaire à partir de laquelle commencer la réplication. Vous pouvez le trouver en exécutant SHOW MASTER STATUS; sur le serveur maître. Pour une nouvelle configuration, c'est généralement 4.

    Important : Vous devez déterminer les valeurs correctes de MASTER_LOG_FILE et MASTER_LOG_POS à partir du serveur maître. Sur le serveur maître, exécutez la requête suivante :

    SHOW MASTER STATUS;

    La sortie affichera le File (qui correspond à MASTER_LOG_FILE) et la Position (qui correspond à MASTER_LOG_POS). Utilisez ces valeurs dans la commande CHANGE MASTER TO sur le serveur esclave.

    Après avoir exécuté la commande CHANGE MASTER TO, démarrez l'esclave :

    START SLAVE;

    Quittez le moniteur MySQL sur le serveur esclave :

    exit

Vous avez maintenant configuré le serveur esclave pour répliquer les données du serveur maître. Dans l'étape suivante, nous allons vérifier que la réplication fonctionne correctement.

Vérifier la réplication avec SHOW SLAVE STATUS

Dans cette étape, nous allons vérifier que le serveur esclave réplique avec succès les données du serveur maître. Nous utiliserons la commande SHOW SLAVE STATUS pour vérifier l'état des threads de réplication et identifier tout problème potentiel.

  1. Vérifier l'état de l'esclave :

    Sur le serveur esclave, connectez-vous au serveur MySQL en tant qu'utilisateur root :

    sudo mysql -u root

    Exécutez la commande suivante pour afficher l'état de l'esclave :

    SHOW SLAVE STATUS\G

    Le \G à la fin de la commande formate la sortie verticalement, la rendant plus facile à lire.

  2. Interpréter la sortie :

    La sortie de SHOW SLAVE STATUS fournit des informations détaillées sur le processus de réplication. Voici quelques champs clés à rechercher :

    • Slave_IO_State : Cela indique l'état actuel du thread d'E/S, qui est responsable de la lecture des événements des journaux binaires depuis le maître. Idéalement, il devrait afficher Waiting for master to send event.
    • Slave_IO_Running : Cela indique si le thread d'E/S est en cours d'exécution. Il devrait être Yes.
    • Slave_SQL_Running : Cela indique si le thread SQL est en cours d'exécution. Le thread SQL applique les événements reçus du maître à la base de données de l'esclave. Il devrait être Yes.
    • Last_IO_Error : Si des erreurs sont liées au thread d'E/S, elles seront affichées ici.
    • Last_SQL_Error : Si des erreurs sont liées au thread SQL, elles seront affichées ici.
    • Master_Log_File : Le nom du fichier de journal binaire sur le serveur maître à partir duquel l'esclave lit actuellement.
    • Read_Master_Log_Pos : La position dans le fichier de journal binaire que l'esclave a lue jusqu'à présent.
    • Relay_Log_File : Le nom du fichier de journal de relais sur le serveur esclave à partir duquel le thread SQL lit actuellement.
    • Relay_Log_Pos : La position dans le fichier de journal de relais que le thread SQL a lue jusqu'à présent.
    • Seconds_Behind_Master : Cela indique combien de secondes l'esclave est en retard par rapport au maître. Une valeur de 0 signifie que l'esclave est à jour. Une valeur plus élevée indique que l'esclave est en retard.

    Une configuration de réplication réussie aura Slave_IO_Running et Slave_SQL_Running définis sur Yes, et Seconds_Behind_Master devrait être proche de 0.

    Exemple de sortie réussie de SHOW SLAVE STATUS (tronquée) :

    *************************** 1. row ***************************
                   Slave_IO_State: Waiting for master to send event
                      Master_Host: master_host
                      Master_User: slave_user
                      Master_Port: 3306
                    Connect_Retry: 60
                  Master_Log_File: mysql-bin.000001
              Read_Master_Log_Pos: 154
                   Relay_Log_File: mysql-relay-bin.000002
                    Relay_Log_Pos: 311
            Relay_Master_Log_File: mysql-bin.000001
                 Slave_IO_Running: Yes
                Slave_SQL_Running: Yes
                  Replicate_Do_DB:
              Replicate_Ignore_DB:
               Replicate_Do_Table:
           Replicate_Ignore_Table:
          Replicate_Wild_Do_Table:
      Replicate_Wild_Ignore_Table:
                       Last_Errno: 0
                       Last_Error:
                     Skip_Counter: 0
              Exec_Master_Log_Pos: 154
                  Relay_Log_Space: 472
                  Until_Condition: None
                   Until_Log_File:
                    Until_Log_Pos: 0
               Master_SSL_Allowed: No
                Master_SSL_CA_File:
                Master_SSL_CA_Path:
                   Master_SSL_Cert:
                 Master_SSL_Cipher:
                    Master_SSL_Key:
             Seconds_Behind_Master: 0
    ...
  3. Créer une base de données de test et une table sur le maître :

    Pour vérifier davantage la réplication, créez une base de données de test et une table sur le serveur maître :

    sudo mysql -u root
    CREATE DATABASE test_replication;
    USE test_replication;
    CREATE TABLE test_table (
        id INT AUTO_INCREMENT PRIMARY KEY,
        data VARCHAR(255)
    );
    INSERT INTO test_table (data) VALUES ('This is a test record from master');
    exit
  4. Vérifier les données sur l'esclave :

    Sur le serveur esclave, connectez-vous au serveur MySQL en tant qu'utilisateur root :

    sudo mysql -u root

    Vérifiez si la base de données test_replication et la table test_table ont été répliquées :

    USE test_replication;
    SELECT * FROM test_table;
    exit

    Vous devriez voir les données insérées sur le serveur maître :

    +----+-----------------------------------------+
    | id | data                                    |
    +----+-----------------------------------------+
    |  1 | This is a test record from master       |
    +----+-----------------------------------------+
    1 row in set (0.00 sec)

Si vous voyez la base de données de test, la table et les données sur le serveur esclave, la réplication fonctionne correctement.

Simuler une erreur de réplication et la corriger

Dans cette étape, nous allons simuler une erreur de réplication courante et montrer comment la résoudre. Cela vous aidera à comprendre comment résoudre les problèmes de réplication dans un scénario réel.

  1. Simuler une erreur :

    Une erreur de réplication courante se produit lorsque le serveur esclave rencontre une incohérence de données. Nous allons simuler cela en insérant manuellement une ligne dans la table test_replication.test_table sur le serveur esclave, ce qui causera un conflit lorsque le maître tentera de répliquer la même ligne.

    Sur le serveur esclave, connectez-vous au serveur MySQL en tant qu'utilisateur root :

    sudo mysql -u root

    Insérez une ligne dans la table test_replication.test_table :

    USE test_replication;
    INSERT INTO test_table (data) VALUES ('This is an intentionally conflicting record on the slave');
    exit
  2. Déclencher la réplication :

    Maintenant, insérez une autre ligne dans la table test_replication.test_table sur le serveur maître :

    sudo mysql -u root
    USE test_replication;
    INSERT INTO test_table (data) VALUES ('This is a new record from master');
    exit

    Cette insertion sur le maître déclenchera la réplication vers l'esclave. Cependant, comme nous avons inséré manuellement une ligne conflictuelle sur l'esclave, le processus de réplication rencontrera probablement une erreur.

  3. Vérifier l'état de l'esclave :

    Sur le serveur esclave, connectez-vous au serveur MySQL en tant qu'utilisateur root :

    sudo mysql -u root

    Vérifiez l'état de l'esclave :

    SHOW SLAVE STATUS\G

    Examinez la sortie. Vous devriez voir que Slave_SQL_Running est probablement défini sur No, et le champ Last_SQL_Error contiendra un message d'erreur indiquant une clé en double ou un conflit similaire.

    Exemple de sortie d'erreur :

    ...
                   Slave_IO_State: Waiting for master to send event
                      Master_Host: master_host
                      Master_User: slave_user
                      Master_Port: 3306
                    Connect_Retry: 60
                  Master_Log_File: mysql-bin.000002
              Read_Master_Log_Pos: 154
                   Relay_Log_File: mysql-relay-bin.000003
                    Relay_Log_Pos: 311
            Relay_Master_Log_File: mysql-bin.000002
                 Slave_IO_Running: Yes
                Slave_SQL_Running: No
                  Replicate_Do_DB:
              Replicate_Ignore_DB:
               Replicate_Do_Table:
           Replicate_Ignore_Table:
          Replicate_Wild_Do_Table:
      Replicate_Wild_Ignore_Table:
                       Last_Errno: 1062
                       Last_Error: Duplicate entry '1' for key 'PRIMARY'
                     Skip_Counter: 0
              Exec_Master_Log_Pos: 154
                  Relay_Log_Space: 472
                  Until_Condition: None
                   Until_Log_File:
                    Until_Log_Pos: 0
               Master_SSL_Allowed: No
                Master_SSL_CA_File:
                Master_SSL_CA_Path:
                   Master_SSL_Cert:
                 Master_SSL_Cipher:
                    Master_SSL_Key:
             Seconds_Behind_Master: NULL
    ...
  4. Corriger l'erreur de réplication :

    Pour corriger cette erreur, nous allons sauter l'événement problématique sur le serveur esclave. Cela indique à l'esclave d'ignorer l'événement qui a causé l'erreur et de continuer la réplication à partir de l'événement suivant.

    Tout d'abord, arrêtez le thread SQL de l'esclave :

    STOP SLAVE SQL_THREAD;

    Ensuite, sautez l'événement d'erreur :

    SET GLOBAL SQL_SLAVE_SKIP_COUNTER = 1;

    Cette commande indique à l'esclave de sauter l'événement suivant dans le journal de relais.

    Enfin, démarrez le thread SQL de l'esclave :

    START SLAVE SQL_THREAD;
  5. Vérifier que la réplication fonctionne à nouveau :

    Vérifiez à nouveau l'état de l'esclave :

    SHOW SLAVE STATUS\G

    Vous devriez maintenant voir que Slave_SQL_Running est défini sur Yes, et Last_SQL_Error est vide. La réplication devrait fonctionner normalement à nouveau.

  6. Vérifier la cohérence des données :

    Sur le serveur esclave, vérifiez le contenu de la table test_replication.test_table :

    USE test_replication;
    SELECT * FROM test_table;
    exit

    Vous devriez voir à la fois l'enregistrement conflictuel intentionnel et le nouvel enregistrement du maître. L'enregistrement conflictuel était déjà présent, et le nouvel enregistrement a été répliqué avec succès après avoir sauté l'erreur.

    +----+-----------------------------------------------------+
    | id | data                                                |
    +----+-----------------------------------------------------+
    |  1 | This is a test record from master                   |
    |  2 | This is an intentionally conflicting record on the slave |
    |  3 | This is a new record from master                    |
    +----+-----------------------------------------------------+
    3 rows in set (0.00 sec)

Vous avez maintenant simulé avec succès une erreur de réplication et la corrigé en sautant l'événement problématique. Il s'agit d'une technique courante pour résoudre les problèmes de réplication causés par des incohérences de données. N'oubliez pas que le saut d'événements doit être effectué avec prudence, car cela peut entraîner une divergence des données si cela n'est pas géré correctement. Il est crucial de comprendre la cause de l'erreur avant de sauter des événements.

Résumé

Dans ce laboratoire (lab), la première étape consiste à configurer un serveur MySQL en tant que maître dans une configuration de réplication en activant la journalisation binaire. Cela implique de modifier le fichier de configuration de MySQL, généralement situé à /etc/mysql/mysql.conf.d/mysqld.cnf, et d'ajouter les lignes log_bin = mysql-bin et server_id = 1 dans la section mysqld.

L'activation de la journalisation binaire est cruciale car elle permet au serveur maître d'enregistrer toutes les modifications de données, qui sont ensuite utilisées par le serveur esclave pour répliquer les changements, garantissant ainsi la synchronisation des données. La directive log_bin spécifie le nom de base pour les fichiers de journal binaire, tandis que server_id attribue un identifiant unique au serveur maître dans l'environnement de réplication.