Bases de la réplication MySQL

MySQLBeginner
Pratiquer maintenant

Introduction

Dans ce laboratoire, vous apprendrez les bases de la réplication MySQL. La réplication est un processus qui vous permet de maintenir des copies d'une base de données MySQL sur plusieurs serveurs. Ceci est couramment utilisé pour l'équilibrage de charge (load balancing), la sauvegarde de données et la haute disponibilité (high availability).

Vous utiliserez Docker pour créer une configuration de réplication maître-esclave réaliste avec deux conteneurs MySQL distincts. Premièrement, vous démarrerez et vérifierez un conteneur maître, qui est pré-configuré avec le journal binaire (binary logging) activé. Vous créerez un utilisateur de réplication spécial sur le maître. Ensuite, vous configurerez le second conteneur pour qu'il agisse comme esclave, le connecterez au maître et vérifierez que les données sont synchronisées correctement. Cette approche pratique vous aidera à comprendre les étapes clés impliquées dans la gestion d'un environnement de réplication MySQL réel.

Configurer l'environnement Docker

Dans cette première étape, vous allez configurer les conteneurs Docker nécessaires à l'environnement de réplication maître-esclave. Vous allez créer un réseau dédié et lancer deux conteneurs MySQL.

  1. Créer un réseau Docker :

    Un réseau dédié permet aux conteneurs de communiquer entre eux par leur nom. Créez un réseau nommé mysql-net.

    docker network create mysql-net
  2. Démarrer le conteneur MySQL maître :

    Ensuite, démarrez le conteneur maître. Cette commande utilise mysql:5.7 et le configure avec un ID de serveur de 1 et active le journal binaire (binary logging) pour la base de données replication_db.

    docker run -d \
      --name mysql-master \
      --network mysql-net \
      -e MYSQL_ROOT_PASSWORD=lab_password \
      -e MYSQL_DATABASE=replication_db \
      mysql:5.7 \
      mysqld --server-id=1 --log-bin=mysql-bin --binlog-do-db=replication_db
  3. Démarrer le conteneur MySQL esclave :

    Maintenant, démarrez le conteneur esclave. Ce conteneur est également sur le même réseau et est configuré avec un ID de serveur de 2. Nous créons également la base de données replication_db à l'avance, afin que l'esclave puisse appliquer correctement les changements du maître.

    docker run -d \
      --name mysql-slave \
      --network mysql-net \
      -e MYSQL_ROOT_PASSWORD=lab_password \
      -e MYSQL_DATABASE=replication_db \
      mysql:5.7 \
      mysqld --server-id=2 --relay-log=mysql-relay-bin --log-slave-updates=1
  4. Attendre l'initialisation des conteneurs :

    Les conteneurs MySQL ont besoin d'un certain temps pour s'initialiser. Attendez environ 15 secondes pour vérifier si les conteneurs sont en cours d'exécution.

    docker ps
    CONTAINER ID   IMAGE       COMMAND                  CREATED         STATUS         PORTS                 NAMES
    
    cfe8c98d2ad0 mysql:5.7 "docker-entrypoint.s…" 2 minutes ago Up 2 minutes 3306/tcp, 33060/tcp mysql-slave
    fc125bf293ea mysql:5.7 "docker-entrypoint.s…" 2 minutes ago Up 2 minutes 3306/tcp, 33060/tcp mysql-master

Maintenant que votre environnement est configuré, vous pouvez passer à la configuration du serveur maître.

Vérifier la configuration du serveur maître

Maintenant que les conteneurs sont en cours d'exécution, la prochaine étape consiste à s'assurer que le serveur maître est correctement configuré pour la réplication. La responsabilité principale du maître est d'enregistrer toutes les modifications de la base de données dans son journal binaire (binary log), que l'esclave lira ultérieurement.

Ouvrez d'abord un terminal depuis votre bureau.

Nous allons maintenant nous connecter au conteneur maître et vérifier sa configuration.

  1. Connexion au conteneur maître :

    Utilisez docker exec pour ouvrir un shell MySQL à l'intérieur du conteneur mysql-master. Il vous sera demandé d'entrer le mot de passe, qui est lab_password.

    docker exec -it mysql-master mysql -uroot -plab_password
  2. Vérification du journal binaire et de l'ID du serveur :

    Une fois que vous voyez l'invite mysql>, exécutez les commandes suivantes pour vérifier que le journal binaire est activé et que l'ID du serveur est correctement défini.

    SHOW VARIABLES LIKE 'log_bin';

    La sortie devrait indiquer que log_bin est ON.

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

    Ensuite, vérifiez l'ID du serveur.

    SHOW VARIABLES LIKE 'server_id';

    La sortie devrait indiquer que server_id est 1.

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

    Maintenant que vous avez vérifié la configuration, vous pouvez quitter le shell MySQL.

    exit;

Vous avez confirmé avec succès que le serveur maître est prêt pour la réplication.

Créer un utilisateur de réplication et une base de données de test

Le serveur esclave doit se connecter au maître pour lire le journal binaire. Par mesure de sécurité, il est recommandé de créer un compte utilisateur dédié à cet effet avec des privilèges limités. Dans cette étape, vous allez créer un utilisateur de réplication et peupler la base de données de test pour observer la réplication en action.

  1. Connexion au serveur maître :

    Ouvrez un shell MySQL à l'intérieur du conteneur mysql-master.

    docker exec -it mysql-master mysql -uroot -plab_password
  2. Création d'un utilisateur de réplication :

    À l'invite mysql>, exécutez la commande suivante pour créer un utilisateur nommé repl_user avec le mot de passe repl_password. Cet utilisateur sera utilisé par l'esclave pour se connecter. Nous utilisons '@'%' pour permettre à l'utilisateur de se connecter depuis n'importe quel hôte, ce qui inclut notre conteneur esclave sur le réseau Docker.

    CREATE USER 'repl_user'@'%' IDENTIFIED BY 'repl_password';
  3. Octroi des privilèges de réplication :

    Le nouvel utilisateur a besoin du privilège REPLICATION SLAVE, qui lui permet de lire les journaux binaires du maître.

    GRANT REPLICATION SLAVE ON *.* TO 'repl_user'@'%';

    Après avoir accordé les privilèges, rechargez les tables de privilèges (grant tables) pour appliquer immédiatement les modifications.

    FLUSH PRIVILEGES;
  4. Vérification du statut du journal binaire du maître :

    Avant de configurer l'esclave, vous devez connaître les coordonnées exactes dans le journal binaire du maître à partir desquelles l'esclave doit commencer la réplication. La commande SHOW MASTER STATUS fournit ces informations.

    SHOW MASTER STATUS;

    La sortie ressemblera à ceci. Notez les valeurs File et Position, car vous en aurez besoin à l'étape suivante.

    +------------------+----------+------------------+--------------------+-------------------+
    | File             | Position | Binlog_Do_DB     | Binlog_Ignore_DB   | Executed_Gtid_Set |
    +------------------+----------+------------------+--------------------+-------------------+
    | mysql-bin.000001 |      337 | replication_db   |                    |                   |
    +------------------+----------+------------------+--------------------+-------------------+
    1 row in set (0.00 sec)
  5. Création d'une table de test et de données :

    La base de données replication_db a été créée au démarrage du conteneur. Créons une table et insérons quelques données pour tester la réplication.

    USE replication_db;
    CREATE TABLE messages (
        id INT PRIMARY KEY AUTO_INCREMENT,
        content VARCHAR(255)
    );
    INSERT INTO messages (content) VALUES ('Hello from the master!');

    Vous pouvez vérifier que les données ont été insérées correctement.

    SELECT * FROM messages;

    Vous devriez voir la ligne que vous venez d'insérer.

    +----+------------------------+
    | id | content                |
    +----+------------------------+
    |  1 | Hello from the master! |
    +----+------------------------+
    1 row in set (0.00 sec)

    Maintenant, quittez le shell MySQL.

    exit;

Vous avez maintenant préparé le serveur maître en créant un utilisateur de réplication et des données de test.

Configurer et démarrer le serveur esclave

Maintenant que le maître est prêt, vous allez configurer le conteneur esclave. Dans cette étape, vous utiliserez les coordonnées du journal binaire que vous avez enregistrées à partir du maître dans l'Étape 3 pour indiquer à l'esclave où commencer la réplication.

  1. Connexion au conteneur esclave :

    Ouvrez d'abord un shell MySQL à l'intérieur du conteneur mysql-slave.

    docker exec -it mysql-slave mysql -uroot -plab_password
  2. Configuration de l'esclave pour se connecter au maître :

    Maintenant, vous utiliserez la commande CHANGE MASTER TO pour configurer les paramètres de réplication. Utilisez les valeurs File et Position que vous avez notées à partir de SHOW MASTER STATUS dans l'Étape 3. Le MASTER_HOST est 'mysql-master', ce qui fonctionne car les deux conteneurs sont sur le même réseau Docker.

    Note : Remplacez mysql-bin.000001 et le numéro de position par les valeurs réelles que vous avez enregistrées à l'Étape 3. Si vous n'avez pas les valeurs, vous pouvez exécuter docker exec mysql-master mysql -uroot -plab_password -e "SHOW MASTER STATUS;" dans un nouveau terminal pour les obtenir.

    CHANGE MASTER TO
        MASTER_HOST='mysql-master',
        MASTER_USER='repl_user',
        MASTER_PASSWORD='repl_password',
        MASTER_LOG_FILE='mysql-bin.000001',
        MASTER_LOG_POS=337;

    Cette commande configure l'esclave avec toutes les informations nécessaires pour se connecter au maître.

  3. Démarrage des threads de l'esclave :

    Enfin, démarrez le processus de réplication en exécutant la commande START SLAVE. Cela démarrera deux threads : le thread I/O, qui récupère les journaux binaires du maître, et le thread SQL, qui exécute les événements des journaux.

    START SLAVE;

    Vous pouvez maintenant quitter le shell MySQL.

    exit;

L'esclave est maintenant configuré et devrait tenter de se connecter au maître et de répliquer les données.

Vérifier la réplication

Après avoir démarré l'esclave, la dernière étape consiste à vérifier que la réplication fonctionne correctement. Vous allez vérifier le statut de l'esclave et confirmer que les données du maître ont été copiées.

  1. Connexion au serveur esclave :

    Ouvrez un shell MySQL sur le conteneur mysql-slave.

    docker exec -it mysql-slave mysql -uroot -plab_password
  2. Vérification du statut de l'esclave :

    La commande la plus importante pour surveiller la réplication est SHOW SLAVE STATUS. Le modificateur \G formate la sortie verticalement, ce qui la rend beaucoup plus facile à lire.

    SHOW SLAVE STATUS\G

    Recherchez les deux lignes suivantes dans la sortie. Les deux devraient avoir la valeur Yes.

    • Slave_IO_Running: Yes : Ceci confirme que l'esclave est connecté avec succès au maître et reçoit les données du journal binaire.
    • Slave_SQL_Running: Yes : Ceci confirme que l'esclave exécute avec succès les événements du journal binaire.

    Un autre champ important est Seconds_Behind_Master. Une valeur de 0 indique que l'esclave est entièrement synchronisé avec le maître.

    Un statut sain ressemblera à ceci (certaines valeurs peuvent différer) :

    *************************** 1. row ***************************
                   Slave_IO_State: Waiting for master to send event
                      Master_Host: mysql-master
                      Master_User: repl_user
                      Master_Port: 3306
                    Connect_Retry: 60
                  Master_Log_File: mysql-bin.000001
              Read_Master_Log_Pos: 529
                   Relay_Log_File: mysql-relay-bin.000002
                    Relay_Log_Pos: 699
            Relay_Master_Log_File: mysql-bin.000001
                 Slave_IO_Running: Yes
                Slave_SQL_Running: Yes
    ...
             Seconds_Behind_Master: 0
    ...
  3. Vérification des données répliquées :

    Maintenant, vérifiez si la base de données replication_db et ses données ont été copiées depuis le maître.

    SHOW DATABASES;

    Vous devriez voir replication_db dans la liste.

    +--------------------+
    | Database           |
    +--------------------+
    | information_schema |
    | mysql              |
    | performance_schema |
    | replication_db     |
    | sys                |
    +--------------------+

    Basculez vers la base de données et interrogez la table messages.

    USE replication_db;
    SELECT * FROM messages;

    Les données que vous avez insérées sur le maître devraient maintenant être présentes sur l'esclave.

    +----+------------------------+
    | id | content                |
    +----+------------------------+
    |  1 | Hello from the master! |
    +----+------------------------+
    1 row in set (0.00 sec)

    Cela confirme que la réplication fonctionne correctement. Vous pouvez maintenant quitter le shell MySQL.

    exit;

Vous avez configuré et vérifié avec succès un environnement de réplication maître-esclave MySQL de base à l'aide de Docker.

Résumé

Dans ce laboratoire, vous avez appris les étapes fondamentales pour configurer la réplication maître-esclave MySQL à l'aide de Docker. Vous avez commencé par créer deux conteneurs MySQL distincts, un pour le maître et un pour l'esclave, connectés via un réseau Docker. Vous avez vérifié la configuration du maître, qui incluait un journal binaire activé et un ID de serveur unique. Vous avez ensuite créé un utilisateur de réplication dédié sur le maître pour une connexion sécurisée. Après avoir préparé le maître, vous avez configuré le conteneur esclave à l'aide de la commande CHANGE MASTER TO pour établir la connexion avec les coordonnées du journal binaire du maître. Enfin, vous avez vérifié le succès de la réplication en consultant le statut de l'esclave avec SHOW SLAVE STATUS et en confirmant que les données de test étaient correctement synchronisées. Ce laboratoire vous a fourni les compétences essentielles pour configurer, gérer et vérifier une configuration de réplication MySQL réaliste.