Kovalibre Logo partenaire

MySQL InnoDB Cluster

1 Module 0 — Mise en place de l’environnement AWS

Ce module est un prérequis technique à toute la formation. Il est à réaliser par le formateur avant le Jour 1 (comptez 30-45 min), et peut être présenté aux participants pour qu’ils comprennent la topologie sur laquelle ils travaillent.

1.1 0.1 Architecture cible

La formation utilise 5 machines EC2 (Ubuntu 22.04 LTS, t3.medium) dans un VPC dédié :

  • node1, node2, node3 : les 3 membres du Group Replication, qui formeront l’InnoDB Cluster.
  • router1 : héberge MySQL Router, MySQL Shell, et sert de serveur backend pour tous les TP.
  • workstation : poste de travail graphique (bureau XFCE + xrdp) pour les apprenants, avec MySQL Workbench, MySQL Shell et un terminal préconfiguré (clé SSH déjà installée, alias ssh node1, ssh router1…). Accès par un simple client RDP (Bureau à distance, intégré à Windows, appli gratuite sur Mac/Linux) — aucune installation ni gestion de clé SSH côté apprenant.

Pourquoi une machine dédiée plutôt que de faire tourner MySQL Workbench sur router1 directement ? Parce que router1 n’a pas d’interface graphique et que l’apprenant n’a besoin, in fine, que d’un client RDP (déjà présent sur son poste) pour accéder à tout l’environnement — ce qui évite complètement la question « comment installer/configurer un client SSH et MySQL Workbench chez moi ».

1.2 0.2 Ports réseau utilisés

Port Protocole Usage
3306 MySQL classic protocol Connexions applicatives / clients
33060 MySQL X Protocol MySQL Shell, MySQL Router Service (MRS)
33061 Group Communication Trafic interne du Group Replication (GCS/XCom)
6446 Classic protocol MySQL Router — Read/Write (toujours le PRIMARY)
6447 Classic protocol MySQL Router — Read/Only (répartition SECONDARY)
6448 X Protocol MySQL Router — Read/Write
6449 X Protocol MySQL Router — Read/Only
8443 HTTPS API REST du Router / MySQL Router Service (MRS)
3389 RDP Accès Bureau à distance au poste workstation (apprenants)

1.3 0.3 Provisioning (côté formateur)

cd aws/
      chmod +x *.sh
      ./00-provision-infra.sh

Ce script (00-provision-infra.sh) : 1. crée le VPC, le subnet public, l’Internet Gateway et la route par défaut ; 2. crée un Security Group ouvrant les ports du tableau ci-dessus, en restreignant SSH à l’IP publique du formateur ; 3. lance les 4 instances EC2 avec 01-bootstrap-node.sh en --user-data (donc exécuté automatiquement au premier démarrage de chaque machine) ; 4. écrit un fichier infra.env avec toutes les IP (privées/publiques) et IDs de ressources — ce fichier est réutilisé par les scripts suivants.

Le script 01-bootstrap-node.sh (exécuté automatiquement sur les 4 machines) installe MySQL 8.0, MySQL Shell, et pré-configure chaque nœud pour être compatible Group Replication (gtid_mode=ON, server_id unique dérivé de l’IP, binlog activé, transaction_write_set_extraction=XXHASH64…).

Pourquoi préconfigurer GTID et le binlog dès le bootstrap ? dba.configureInstance() (Module 4) peut redémarrer MySQL s’il doit changer ces paramètres. Les préconfigurer dans l’AMI évite un redémarrage surprise pendant le TP et fait gagner du temps pédagogique.

1.4 0.3bis Connexion des apprenants au poste de travail (RDP)

Une fois 00-provision-infra.sh terminé, infra.env contient l’IP publique de workstation ainsi que le mot de passe généré (WORKSTATION_PASSWORD).

Côté apprenant, aucune installation n’est nécessaire dans la plupart des cas :

  • Windows : ouvrir « Connexion Bureau à distance » (déjà installée), saisir l’IP publique du workstation.
  • macOS : installer l’appli gratuite Microsoft Remote Desktop (App Store), ou tout client RDP.
  • Linux : Remmina ou tout client RDP standard.

Identifiants à communiquer à chaque apprenant :

Adresse   : <IP_PUBLIQUE_WORKSTATION>
      Utilisateur : stagiaire
      Mot de passe : <WORKSTATION_PASSWORD dans infra.env>

Une fois connecté en RDP, l’apprenant dispose d’un bureau XFCE avec :

  • un aide-mémoire sur le Bureau (AIDE-MEMOIRE.txt) ;
  • un terminal permettant ssh node1, ssh node2, ssh node3, ssh router1 sans mot de passe (clé déjà installée) ;
  • MySQL Workbench et MySQL Shell installés localement.

Note de sécurité : le port RDP (3389) est ouvert à 0.0.0.0/0 dans le script fourni, car les apprenants se connectent à distance depuis des IP non connues à l’avance. Le risque est atténué par la durée de vie très courte de l’infrastructure (3 jours) et un mot de passe fort — mais si vous connaissez à l’avance les IP publiques de vos apprenants, il est préférable de restreindre la règle 0.0.0.0/0 à ces IP précises dans le Security Group.

1.5 0.4 Création du cluster (à faire EN DIRECT avec les apprenants — Module 3/4)

Cette étape n’est volontairement pas automatisée : elle constitue le TP central du Module 4 (MySQL Shell). Le script 02-create-cluster.js est fourni comme corrigé, à ne dévoiler qu’après le TP guidé.

# Depuis router1
      mysqlsh clusteradmin@<IP_NODE1> --js --file 02-create-cluster.js

1.6 0.5 Bootstrap du Router (Module 6)

# Depuis router1, une fois le cluster créé
      ./03-setup-router.sh <IP_PRIVEE_NODE1>

1.7 0.6 TP 0 — Vérification de l’environnement

Objectif : s’assurer que chaque apprenant peut se connecter à ses 4 machines et que la configuration de base est bien en place, avant d’attaquer le Module 1.

  1. Récupérer dans infra.env les IP publiques des 4 machines qui vous sont attribuées.

  2. Se connecter en SSH à node1 :

    ssh -i mysql-innodb-cluster-training-key.pem ubuntu@<IP_PUBLIQUE_NODE1>
  3. Vérifier que MySQL tourne et que GTID est actif :

    sudo mysql -uroot -p'FormationMySQL2026!' -e "SHOW VARIABLES LIKE 'gtid_mode'; SHOW VARIABLES LIKE 'server_id';"
  4. Répéter sur node2 et node3 et vérifier que chaque server_id est différent.

  5. Depuis router1, tester la connectivité réseau vers les 3 nœuds sur le port 3306 :

    for ip in <IP_PRIVEE_NODE1> <IP_PRIVEE_NODE2> <IP_PRIVEE_NODE3>; do
            mysql -h "$ip" -uclusteradmin -p'ClusterAdmin2026!' -e "SELECT @@hostname;"
          done

Critère de réussite : les 3 commandes SELECT @@hostname répondent sans erreur depuis router1 → le réseau et les comptes sont opérationnels, la formation peut démarrer.

1.8 0.7 Démantèlement en fin de formation

cd aws/
      ./99-teardown-infra.sh

Supprime toutes les instances, le Security Group, l’IGW, le Subnet et le VPC pour éviter toute facturation résiduelle.

2 Module 1 — Introduction

2.1 1.1 Objectifs de la formation

À l’issue des 3 jours, chaque participant sera capable de :

  • comprendre le fonctionnement interne de la réplication basée sur les GTID ;
  • expliquer l’architecture et les mécanismes internes du Group Replication (consensus, writesets, flow control…) ;
  • déployer, administrer et superviser un InnoDB Cluster avec MySQL Shell ;
  • mettre en place MySQL Router pour le routage applicatif (R/W Splitting, Connection Sharing, API REST) ;
  • comprendre et opérer une topologie multi-cluster avec InnoDB ClusterSet (reprise après sinistre inter-sites).

2.2 1.2 Pourquoi la haute disponibilité native MySQL ?

Avant InnoDB Cluster, la haute disponibilité MySQL reposait sur des briques externes assemblées manuellement : réplication asynchrone classique, Percona XtraDB Cluster (Galera), Pacemaker/Corosync, DRBD, ou des solutions propriétaires. Chacune de ces briques a ses propres mécanismes de détection de panne, de failover et de cohérence — ce qui complexifie l’exploitation.

MySQL InnoDB Cluster (depuis MySQL 5.7.17 / 8.0) fournit une solution intégrée et officielle composée de 3 briques qui communiquent entre elles :

Brique Rôle
Group Replication Moteur de réplication : garantit que les 3+ nœuds restent cohérents, gère l’élection du PRIMARY, détecte les pannes.
MySQL Shell / AdminAPI Outil d’orchestration (dba.*) : crée le cluster, ajoute/retire des instances, pilote les bascules.
MySQL Router Proxy transparent côté application : redirige toujours les écritures vers le PRIMARY, répartit les lectures.

2.3 1.3 Modes de fonctionnement

  • Single-Primary (mode par défaut, recommandé) : un seul nœud accepte les écritures à un instant T ; les autres sont en lecture seule et appliquent les transactions en parallèle.
  • Multi-Primary : tous les nœuds acceptent les écritures — puissant mais qui déplace la responsabilité de la gestion des conflits applicatifs vers le développeur (voir Module 3).

2.4 1.4 Cas d’usage typiques

  • Haute disponibilité locale (3 nœuds dans le même datacenter/AZ) ;
  • Scalabilité en lecture (Read Scaling) via le Router ;
  • Reprise après sinistre multi-site avec InnoDB ClusterSet (Module 6) ;
  • Migration “zero-downtime” facilitée par le clonage natif (Module 3.12).

2.5 1.5 Positionnement dans l’écosystème MySQL HA

Solution Réplication Cohérence Orchestration intégrée
Réplication asynchrone classique Asynchrone Faible (lag possible) Non
Semi-synchrone Semi-synchrone Moyenne Non
Group Replication / InnoDB Cluster Synchrone (certification) Forte (majorité) Oui (AdminAPI)
Galera / PXC Synchrone (certification) Forte Partielle (outils tiers)

2.6 1.6 Panorama de la formation (fil rouge)

Chaque module s’appuie sur les acquis du précédent : les GTID (Module 2) sont le langage commun que le Group Replication (Module 3) utilise pour certifier les transactions ; MySQL Shell (Module 4) orchestre ce moteur ; le Router (Module 5) l’exploite côté applicatif ; et ClusterSet (Module 6) réplique l’ensemble entre sites.

2.7 1.7 Questions de vérification (oral, 5 min)

  1. Citer les 3 briques logicielles composant une architecture InnoDB Cluster.
  2. Quelle est la différence essentielle entre Single-Primary et Multi-Primary ?
  3. Pourquoi dit-on que Group Replication est une réplication « synchrone par certification » plutôt que strictement synchrone ?

3 Module 2 — GUID & GTID : les fondamentaux

3.1 2.1 GUID : identifiant unique global

Un GUID (Globally Unique Identifier, aussi appelé UUID) est un identifiant de 128 bits construit pour être unique dans le temps et dans l’espace, sans coordination centrale. MySQL utilise un UUID (server_uuid) pour identifier de façon unique chaque instance serveur, indépendamment de son server_id numérique (configurable et donc potentiellement dupliqué par erreur).

# Sur node1
      sudo cat /var/lib/mysql/auto.cnf
[auto]
      server-uuid=3E11FA47-71CA-11E1-9E33-C80AA9429562

Ce fichier est généré une seule fois, au premier démarrage du serveur. Cloner un fichier de données (Module 3.12) sans régénérer ce fichier créerait un doublon de server_uuid → risque de corruption logique de la réplication. C’est justement ce que le clonage MySQL natif gère pour vous.

3.2 2.2 GTID : application des GUID aux transactions

Un GTID (Global Transaction Identifier) est un identifiant unique attribué à chaque transaction commitée, composé de :

GTID = source_id : transaction_id
  • source_id : le server_uuid du serveur sur lequel la transaction a été originellement écrite (pas forcément celui qui l’exécute actuellement).
  • transaction_id : un compteur séquentiel, incrémenté à chaque commit sur cette source.

3.2.1 Pourquoi c’est révolutionnaire par rapport à la réplication classique ?

La réplication classique (binlog_file:position) identifie une transaction par sa position physique dans un fichier binlog — une information locale à chaque serveur, qui change dès qu’on change de topologie (failover, promotion d’un réplica…). Le GTID est global : la même transaction a le même identifiant sur tous les serveurs qui l’ont reçue, ce qui permet :

  • de reconnecter automatiquement un réplica à une nouvelle source après un failover (CHANGE REPLICATION SOURCE TO SOURCE_AUTO_POSITION=1) ;
  • de savoir exactement où en est chaque nœud sans consulter de fichier binlog ;
  • de détecter les transactions manquantes ou dupliquées.

3.3 2.3 Format détaillé des GTID

3E11FA47-71CA-11E1-9E33-C80AA9429562:23
      └──────────────── UUID (36 car.) ───────┘  └┘
              source_id                        transaction_id

Depuis MySQL 8.0.20, un GTID peut également porter un tag (voir 2.5) :

3E11FA47-71CA-11E1-9E33-C80AA9429562:tagname:23
                                            └─────┘
                                         tag optionnel

Règles :

  • transaction_id démarre à 1 et s’incrémente par source_id (donc par tag également s’il y en a un).
  • Une transaction anonyme (avant activation de GTID, ou avec GTID_NEXT=ANONYMOUS) n’a pas de GTID : elle est répliquée par position classique, ce qui empêche la coexistence propre avec Group Replication (qui exige GTID_MODE=ON).

3.4 2.4 GTID Sets

Un GTID Set représente un ensemble (potentiellement discontinu) de GTID, avec une syntaxe compacte utilisant des intervalles :

3E11FA47-71CA-11E1-9E33-C80AA9429562:1-5:10-20,
      2557AC7F-3C56-11E4-B031-0023AE2C7E42:1-10
  • Virgule , : sépare les GTID de sources différentes.
  • Deux-points : : sépare les intervalles pour une même source.
  • Tiret - : décrit un intervalle continu (1-5 = transactions 1,2,3,4,5).

C’est le format utilisé par les variables système GTID_EXECUTED, GTID_PURGED, et par les fonctions GTID_SUBSET() / GTID_SUBTRACT().

3.5 2.5 Tags GTID (MySQL 8.0.20+)

Les tags permettent d’associer une étiquette lisible à une séquence de GTID, utile en particulier avec InnoDB ClusterSet (Module 6) lorsqu’un cluster est promu PRIMARY après un failover : MySQL peut démarrer une nouvelle séquence de GTID taguée pour ce cluster, évitant toute ambiguïté avec l’historique du cluster précédemment PRIMARY.

-- Définir un tag pour les prochaines transactions générées sur ce serveur
      SET GTID_NEXT = 'AUTOMATIC:mytag';

3.6 2.6 Réinitialisation de l’historique d’exécution (Reset execution history)

Deux commandes permettent de repartir “à zéro” — à utiliser avec une extrême prudence en production :

-- Efface GTID_EXECUTED, GTID_PURGED et tous les binlogs
      RESET MASTER;          -- (nom historique, toujours valide en 8.0)
      RESET BINARY LOGS AND GTIDS;   -- nom introduit en 8.0.34 (alias plus explicite)

Piège classique : RESET MASTER remet aussi GTID_PURGED à vide. Sur un serveur qui a déjà servi de réplica avec un historique purgé, cela peut casser la cohérence apparente de l’historique si mal utilisé. À réserver aux resets complets d’environnement (ex. avant de reconstruire un nœud).

3.7 2.7 Variables système clés

Variable Portée Rôle
GTID_EXECUTED Globale (lecture) GTID Set de toutes les transactions déjà commitées sur ce serveur (locales + reçues).
GTID_PURGED Globale Sous-ensemble de GTID_EXECUTED correspondant à des transactions dont le binlog a été purgé — elles ne peuvent plus être renvoyées à un réplica qui les demanderait.
GTID_NEXT Session GTID que la prochaine transaction de cette session doit utiliser. Valeur AUTOMATIC par défaut (le serveur choisit). Utilisée manuellement pour “rejouer” un GTID précis.
SHOW VARIABLES LIKE 'gtid_executed';
      SELECT @@GLOBAL.gtid_purged;
      SELECT @@SESSION.gtid_next;

Relation entre les 3 : GTID_PURGED ⊆ GTID_EXECUTED. La partie encore disponible dans les binlogs est donc GTID_EXECUTED - GTID_PURGED (différence ensembliste, cf. 2.8).

3.8 2.8 Opérations avancées : GTID Subset et Subtract

Deux fonctions SQL permettent de raisonner sur les GTID Sets comme sur des ensembles mathématiques :

-- GTID_SUBSET(set1, set2) : set1 est-il entièrement contenu dans set2 ?
      SELECT GTID_SUBSET(
        '3E11FA47-71CA-11E1-9E33-C80AA9429562:1-5',
        '3E11FA47-71CA-11E1-9E33-C80AA9429562:1-10'
      ); -- -> 1 (TRUE)
      
      -- GTID_SUBTRACT(set1, set2) : GTID présents dans set1 mais PAS dans set2
      SELECT GTID_SUBTRACT(
        '3E11FA47-71CA-11E1-9E33-C80AA9429562:1-10',
        '3E11FA47-71CA-11E1-9E33-C80AA9429562:1-5'
      ); -- -> '3E11FA47-71CA-11E1-9E33-C80AA9429562:6-10'

Usage réel : c’est exactement ce que Group Replication utilise en interne pour déterminer, quand un nœud rejoint le groupe, quelles transactions il lui manque (GTID_SUBTRACT(group_gtid_executed, node_gtid_executed)), et donc quelle partie de la recovery (Module 3.6) doit être rejouée.

3.9 2.9 Schéma de synthèse

3.10 2.10 TP — Manipulation des GTID

Manipulation des GTID

4 Module 3 — Group Replication : Architecture interne (« Under the hood »)

4.1 3.1 Architecture globale

Group Replication (GR) est un plugin MySQL qui transforme un ensemble de serveurs en un système distribué à état répliqué, basé sur un protocole de consensus dérivé de Paxos. Chaque nœud embarque la même pile logique :

Chaque transaction locale passe par ce pipeline avant d’être définitivement commitée : c’est ce qui distingue GR d’une réplication asynchrone classique où le COMMIT local est immédiat et la propagation se fait après-coup.

4.2 3.2 Moteur de communication GCS (Group Communication System)

Le GCS est la couche qui assure :

  • la diffusion atomique des messages (tous les nœuds reçoivent les mêmes messages, dans le même ordre) ;
  • le consensus sur l’ordre total des transactions (via Paxos) ;
  • la détection d’appartenance au groupe (membership) : qui est vivant, qui vient de partir.

En pratique, GCS s’appuie sur le protocole XCom (implémentation MySQL de Paxos), qui communique par défaut sur le port 33061 (distinct du port SQL 3306).

-- Voir les membres actuels du groupe et leur état
      SELECT * FROM performance_schema.replication_group_members;
      
      -- Voir les statistiques de communication (messages, files d'attente...)
      SELECT * FROM performance_schema.replication_group_communication_information;

4.3 3.3 Gestion des métadonnées

GR maintient sa configuration (liste des membres, mode single/multi-primary, version du protocole de communication…) dans des tables systèmes répliquées elles-mêmes via le groupe — il n’y a pas de fichier de config central séparé : la vérité est dans le groupe lui-même.

MySQL Shell / AdminAPI (Module 4) va plus loin en maintenant un schéma de métadonnées applicatif (mysql_innodb_cluster_metadata) sur les instances, utilisé par le Router pour découvrir la topologie.

4.4 3.4 Canaux de réplication (Replication Channels)

GR utilise 2 canaux de réplication internes, visibles dans performance_schema.replication_connection_status / replication_applier_status_by_worker :

Canal Rôle
group_replication_applier Applique les transactions certifiées, reçues du groupe.
group_replication_recovery Canal dédié à la recovery (rattrapage) lorsqu’un nœud rejoint.
SELECT channel_name, service_state
      FROM performance_schema.replication_connection_status;

4.5 3.5 Applier

L’Applier exécute les transactions certifiées. Depuis MySQL 8.0, il peut être multi-threadé (group_replication_applier_channel avec replica_parallel_workers / dépendance logique) afin de rejouer plusieurs transactions non-conflictuelles en parallèle et réduire le lag d’application.

SHOW VARIABLES LIKE 'replica_parallel_workers';  -- ou slave_parallel_workers selon version
      SELECT * FROM performance_schema.replication_applier_status_by_worker
      WHERE channel_name = 'group_replication_applier';

4.6 3.6 Recovery

Quand un nœud rejoint le groupe (ou redémarre), il doit rattraper les transactions qu’il n’a pas :

Si l’écart est trop important (le donneur a déjà purgé les binlogs nécessaires), GR peut automatiquement basculer sur un clonage complet (3.12) plutôt qu’une recovery incrémentale — comportement piloté par group_replication_recovery_use_ssl et surtout, côté AdminAPI, par l’option recoveryMethod: "clone" de addInstance().

4.7 3.7 Writesets

Pour détecter les conflits sans verrouillage distribué, GR ne compare pas les lignes modifiées directement : il calcule, pour chaque transaction, un writeset = l’ensemble des identifiants uniques (hash) des lignes modifiées (clé primaire + valeurs des colonnes indexées uniques, hashées).

SHOW VARIABLES LIKE 'transaction_write_set_extraction';  -- doit être XXHASH64

Ce writeset, beaucoup plus compact que la transaction complète, est diffusé à tous les nœuds pour la certification (3.10) : chaque nœud peut vérifier localement, sans attendre de verrou réseau, si la transaction entre en conflit avec une autre déjà certifiée.

4.8 3.8 Flow Control & Throttling

Si un nœud applique les transactions plus lentement que les autres, son relay log (file d’attente de transactions certifiées mais pas encore appliquées) grossit. Le Flow Control ralentit alors volontairement l’écriture sur les nœuds les plus rapides pour laisser le retardataire rattraper le groupe — évitant un écart de données non borné.

SHOW VARIABLES LIKE 'group_replication_flow_control%';
Variable Rôle
group_replication_flow_control_mode QUOTA (throttling actif) ou DISABLED.
group_replication_flow_control_certifier_threshold Seuil de transactions en attente de certification avant throttling.
group_replication_flow_control_applier_threshold Seuil de transactions en attente d’application avant throttling.

4.9 3.9 Gestion des conflits

En Single-Primary, les conflits d’écriture sont impossibles par construction (un seul nœud écrit). En Multi-Primary, deux nœuds peuvent committer, en parallèle, des transactions qui modifient la même ligne : le writeset de chaque transaction est comparé lors de la certification.

L’application doit donc être prête à rejouer une transaction rejetée en Multi-Primary — c’est la raison principale pour laquelle le mode Single-Primary est recommandé par défaut.

4.10 3.10 Modes Multi-Primary et Single-Primary

-- Basculer en multi-primary (via AdminAPI, recommandé plutôt qu'en SQL brut)
      -- cluster.switchToMultiPrimaryMode()
      -- cluster.switchToSinglePrimaryMode()
      
      SELECT * FROM performance_schema.replication_group_members
      WHERE member_role = 'PRIMARY';
Aspect Single-Primary Multi-Primary
Écritures Un seul nœud (PRIMARY) Tous les nœuds
Conflits applicatifs Impossibles Possibles (rollback automatique)
Élection auto du PRIMARY Oui, en cas de panne N/A (pas de rôle unique)
Compatibilité applicative Totale (comme un serveur classique) Nécessite une app conflict-aware

4.11 3.11 Transactions XA détachées (Detached XA Transactions)

Les transactions XA (protocole de transaction distribuée à 2 phases) posent un problème particulier dans GR : si un nœud tombe entre la phase XA PREPARE et XA COMMIT, la transaction XA est détachée (son exécution ne dépend plus de la session/connexion d’origine). GR gère cette situation en répliquant l’état PREPARED dans le groupe, afin qu’un autre membre puisse terminer (XA COMMIT / XA ROLLBACK) la transaction après un failover, plutôt que de la laisser bloquée indéfiniment.

XA START 'monxid';
      INSERT INTO tp_gtid.compteur VALUES (2, 200);
      XA END 'monxid';
      XA PREPARE 'monxid';
      -- Si le nœud tombe ici, un autre membre du groupe peut :
      XA RECOVER;
      XA COMMIT 'monxid';

4.12 3.12 Limites transactionnelles

Group Replication impose des contraintes qu’il faut connaître avant de concevoir un schéma applicatif :

  • Toutes les tables doivent avoir une clé primaire (indispensable au calcul des writesets — sans PK, GR refuse la transaction en Multi-Primary, ou déclenche un warning en Single-Primary).
  • Le moteur de stockage doit être InnoDB (transactionnel).
  • Pas de SERIALIZABLE isolation level combiné à certaines opérations.
  • Taille de transaction bornée par group_replication_transaction_size_limit (par défaut 143 MB) — au-delà, la transaction est rejetée pour ne pas saturer la diffusion réseau.
  • Pas de tables temporaires répliquées de façon transactionnelle entre membres (chaque nœud gère les siennes localement).
SHOW VARIABLES LIKE 'group_replication_transaction_size_limit';

4.13 3.13 Cache XCom

XCom (implémentation Paxos) maintient un cache mémoire des messages récemment échangés, utilisé pour permettre à un nœud qui a une courte déconnexion réseau de rattraper son retard directement depuis ce cache plutôt que de repasser par une recovery complète.

SHOW VARIABLES LIKE 'group_replication_message_cache_size';

Si la déconnexion dépasse la capacité du cache (trop de transactions manquées), le nœud est expulsé du groupe et devra effectuer une recovery (3.6) — voire un clonage complet (3.14) — pour revenir.

4.14 3.14 Clonage en détail (Clone Plugin)

Le clone plugin, intégré nativement depuis MySQL 8.0.17, permet de copier physiquement (au niveau fichier InnoDB, pas logiquement ligne par ligne) l’intégralité des données d’un donneur vers un nœud receveur — bien plus rapide qu’une recovery transactionnelle pour un gros volume de données.

Étapes manuelles (pour comprendre ce que addInstance(..., {recoveryMethod: "clone"}) fait pour vous) :

-- Sur le nœud receveur ET le donneur
      INSTALL PLUGIN clone SONAME 'mysql_clone.so';
      
      -- Sur le receveur
      SET GLOBAL clone_valid_donor_list = '<IP_DONOR>:3306';
      CLONE INSTANCE FROM 'clusteradmin'@'<IP_DONOR>':3306
        IDENTIFIED BY 'ClusterAdmin2026!';

Points d’attention :

  • Le clonage écrase les données existantes sur le receveur (CLONE INSTANCE échoue si des données de production sont déjà présentes, sauf option de forçage).
  • La version MySQL du donneur et du receveur doivent être compatibles.
  • Le fichier auto.cnf (server_uuid) du receveur est régénéré automatiquement après clonage — c’est ce qui évite le problème d’unicité mentionné en 2.1.

4.15 3.15 TP — Explorer l’architecture interne

Explorer l’architecutre interne

5 Module 4 — MySQL Shell

5.1 4.1 Positionnement

MySQL Shell (mysqlsh) est le client officiel avancé de MySQL, disponible en 3 langages de script (JavaScript, Python, SQL) et qui embarque l’AdminAPI : l’ensemble des objets dba, cluster, clusterset, Session permettant de piloter tout le cycle de vie d’un InnoDB Cluster sans écrire une seule ligne de SQL de bas niveau.

5.2 4.2 Objets principaux et méthode status()

Objet Obtenu via Rôle
dba Toujours disponible Fabrique : createCluster(), configureInstance(), getCluster(), configureReplicaSetInstance()…
cluster dba.getCluster() ou retour de createCluster() Représente le cluster : addInstance(), removeInstance(), status(), rescan(), switchToMultiPrimaryMode()…
clusterSet cluster.createClusterSet() (Module 6) Représente l’ensemble multi-cluster.
session shell.connect() Connexion SQL/X Protocol brute sous-jacente.
// Connexion et récupération du cluster existant
      shell.connect('clusteradmin@10.42.0.11:3306');
      var cluster = dba.getCluster();
      
      // LA commande de diagnostic n°1 en exploitation
      cluster.status();

Extrait typique de sortie de cluster.status() :

{
          "clusterName": "trainingCluster",
          "defaultReplicaSet": {
              "primary": "10.42.0.11:3306",
              "status": "OK",
              "statusText": "Cluster is ONLINE and can tolerate up to ONE failure.",
              "topology": {
                  "10.42.0.11:3306": { "mode": "R/W", "status": "ONLINE" },
                  "10.42.0.12:3306": { "mode": "R/O", "status": "ONLINE" },
                  "10.42.0.13:3306": { "mode": "R/O", "status": "ONLINE" }
              }
          }
      }

cluster.describe() donne la topologie déclarée (sans l’état temps réel) ; cluster.status({extended: 1}) ajoute les métriques de replication lag et de recovery.

5.3 4.3 Gestion des logs

MySQL Shell écrit ses propres logs (distincts des logs MySQL serveur), très utiles pour diagnostiquer un échec d’addInstance() ou de createCluster() :

# Emplacement par défaut
      ~/.mysqlsh/mysqlsh.log
      
      # Augmenter la verbosité pour une session de diagnostic
      mysqlsh --log-level=DEBUG3 --log-file=/tmp/mysqlsh-debug.log

Niveaux de --log-level : 1 (erreurs) à 8 (debug complet), ou les alias SILENT, INFO, DEBUG, DEBUG2, DEBUG3. En formation/production, DEBUG3 avant une opération critique de l’AdminAPI permet de voir exactement quelles commandes SQL/GR sont envoyées à chaque nœud.

5.4 4.4 Plugins et extensions utiles

  • util object : util.checkForServerUpgrade(), util.exportTable(), util.importJson(), util.dumpInstance() / util.loadDump() (le successeur recommandé de mysqldump pour les gros volumes, parallélisé).
  • Extension du Shell en JS/Python : possibilité d’écrire ses propres plugins mysqlsh (dossier ~/.mysqlsh/plugins/) pour automatiser des tâches d’exploitation récurrentes (ex. un script de healthcheck maison exécuté en cron via mysqlsh --file).
  • Reporting intégré : \show query / \watch query pour surveiller une requête en boucle directement dans le Shell, sans script externe.
# Exemple : sauvegarde logique parallélisée d'une base avant une opération risquée
      mysqlsh clusteradmin@10.42.0.11:3306 -- util dump-instance /tmp/backup_pre_tp \
        --threads=4

5.5 4.5 TP — Créer l’InnoDB Cluster avec MySQL Shell

Créer l’InnoDB Cluster

6 Module 5 — MySQL Router

6.1 5.1 Principe de fonctionnement

MySQL Router est un proxy léger, sans état persistant, placé entre l’application et le cluster. Il lit en continu les métadonnées du cluster (via le schéma mysql_innodb_cluster_metadata + les notifications GR) pour savoir, à tout instant, qui est le PRIMARY et quels nœuds sont disponibles en lecture.

Bénéfice clé : l’application n’a jamais besoin de connaître l’IP du PRIMARY courant, ni de gérer elle-même le failover — elle se connecte toujours au même port du Router, qui se charge de rediriger.

6.2 5.2 Bootstrap et configuration

Le bootstrap (--bootstrap) interroge le cluster pour découvrir sa topologie et génère la configuration locale de Router (mysqlrouter.conf) :

mysqlrouter --bootstrap clusteradmin@10.42.0.11:3306 \
        --directory /opt/mysqlrouter \
        --conf-use-gr-notifications \
        --user=mysqlrouter \
        --force

Extrait du fichier généré /opt/mysqlrouter/mysqlrouter.conf :

[DEFAULT]
      user=mysqlrouter
      logging_folder=/opt/mysqlrouter/log
      
      [routing:trainingCluster_rw]
      bind_address=0.0.0.0
      bind_port=6446
      destinations=metadata-cache://trainingCluster/?role=PRIMARY
      routing_strategy=round-robin
      
      [routing:trainingCluster_ro]
      bind_address=0.0.0.0
      bind_port=6447
      destinations=metadata-cache://trainingCluster/?role=SECONDARY
      routing_strategy=round-robin-with-fallback
      
      [metadata_cache:trainingCluster]
      cluster-type=gr
      router_id=1
      user=mysql_router1_xxxx
      metadata_cluster=trainingCluster
      ttl=0.5
      use_gr_notifications=1

L’option --conf-use-gr-notifications fait s’abonner Router directement aux notifications du Group Replication (au lieu d’un simple polling périodique ttl) : la détection de changement de PRIMARY est quasi-instantanée plutôt que bornée par le ttl.

6.3 5.3 Traces et debugging

# Dans mysqlrouter.conf, section [logger]
      [logger]
      level = DEBUG
tail -f /opt/mysqlrouter/log/mysqlrouter.log

Cas fréquents à savoir diagnostiquer :

  • destination_error répété → le Router n’arrive plus à joindre aucun membre listé dans les métadonnées (vérifier le Security Group / le port 33060 pour la découverte X Protocol).
  • Bascule de PRIMARY qui met plusieurs secondes à être prise en compte → vérifier que conf-use-gr-notifications est bien actif et que le port 33060 est ouvert entre Router et les nœuds (nécessaire aux notifications).

6.4 5.4 Read/Write Splitting

Depuis MySQL Router 8.0.32+, il est possible de ne plus séparer les ports R/W et R/O côté application : le Router peut analyser chaque requête SQL entrante sur une connexion unique et la router dynamiquement vers le PRIMARY (écritures) ou un SECONDARY (lectures), en respectant la cohérence de session (une lecture juste après une écriture dans la même transaction reste sur le PRIMARY).

[routing:trainingCluster_splitting]
      bind_address = 0.0.0.0
      bind_port = 6450
      destinations = metadata-cache://trainingCluster/?role=PRIMARY_AND_SECONDARY
      routing_strategy = round-robin
      connection_sharing = 1
      access_mode = auto

access_mode = auto est le paramètre qui active le Read/Write Splitting : le Router inspecte le texte SQL (via son propre parseur léger) pour distinguer lectures et écritures.

6.5 5.5 Connection Sharing

Ouvrir/fermer une connexion MySQL a un coût (TCP + handshake + auth). Le Connection Sharing permet à Router de réutiliser une connexion backend déjà ouverte pour plusieurs connexions client successives (pattern proche du pooling), à condition que l’état de session soit compatible (pas de variables de session incompatibles, pas de transaction en cours) :

[routing:trainingCluster_ro]
      connection_sharing = 1
      connection_sharing_delay = 1.0

C’est particulièrement utile avec des frameworks/ORMs qui ouvrent beaucoup de connexions courtes.

6.6 5.6 API REST

Router expose une API REST HTTPS (port 8443 par défaut) pour la supervision : état des routes, connexions actives, statut de santé.

# Activer l'API REST au bootstrap
      mysqlrouter --bootstrap clusteradmin@10.42.0.11:3306 \
        --directory /opt/mysqlrouter --http-port 8443 --force
      
      # Interroger l'API
      curl -k https://localhost:8443/api/20190715/router/status
      curl -k https://localhost:8443/api/20190715/routes/trainingCluster_rw/status

6.7 5.7 MySQL Router Service (MRS)

MRS transforme le Router en serveur d’API REST/JSON auto-généré directement au-dessus des tables MySQL (comparable à une passerelle GraphQL/REST façon PostgREST ou Hasura, mais native MySQL). Il permet d’exposer une base comme une API HTTP sans écrire de backend applicatif.

Activation (nécessite le schéma mysql_rest_service_metadata, déployé via MySQL Shell) :

// Depuis mysqlsh, contre le cluster
      \js
      util.checkForServerUpgrade();       // vérif préalable classique
      // Configuration MRS via le plugin dédié mrs_plugin (fourni avec MySQL Shell)
mysqlrouter --bootstrap clusteradmin@10.42.0.11:3306 \
        --directory /opt/mysqlrouter --mrs --force

MRS reste une fonctionnalité avancée : dans le cadre de cette formation, on se limite à en présenter le principe et une démonstration guidée par le formateur (le déploiement complet du schéma de métadonnées MRS dépasse le cadre du TP standard, faute de temps).

6.8 5.8 TP — Mettre en place et tester le Router

Mettre en place le router

7 Module 6 — InnoDB ClusterSet

7.1 6.1 Pourquoi ClusterSet ?

Un InnoDB Cluster protège contre la panne d’un nœud, mais pas contre la panne d’un site complet (datacenter, région AWS). InnoDB ClusterSet (depuis MySQL 8.0.27) répond à ce besoin en reliant plusieurs clusters (chacun dans un site différent) par une réplication asynchrone entre le cluster PRIMARY et un ou plusieurs clusters REPLICA.

À l’intérieur de chaque site, la cohérence reste forte (Group Replication, Module 3). Entre les sites, la réplication est asynchrone — un choix délibéré : imposer un consensus synchrone inter-régions rendrait chaque écriture aussi lente que l’aller-retour réseau le plus lent entre sites, souvent inacceptable en pratique.

7.2 6.2 Mécanisme de Fencing

Le fencing est le mécanisme qui empêche un cluster REPLICA de continuer à accepter des écritures locales et de diverger du PRIMARY (scénario de « split-brain » entre sites) :

  • Quand un cluster est REPLICA dans un ClusterSet, ClusterSet le met automatiquement en lecture seule au niveau cluster (super_read_only propagé à tous ses membres), indépendamment du fait que ce cluster, pris isolément, pourrait très bien élire son propre PRIMARY local.
  • En cas de coupure réseau entre les sites, le cluster REPLICA reste fencé : il ne bascule pas automatiquement en accepteur d’écritures, même s’il ne reçoit plus rien du PRIMARY. C’est un choix de sûreté : mieux vaut un site indisponible en écriture qu’un site qui diverge silencieusement.
  • Le failover inter-cluster (promotion du REPLICA en PRIMARY) est donc une décision explicite de l’opérateur (clusterSet.forcePrimaryCluster() ou setPrimaryCluster()), jamais totalement automatique par défaut — contrairement au failover intra-cluster (Module 4) qui lui est automatique.

7.3 6.3 Gestion des GTID Sets incohérents

Le scénario le plus délicat d’un ClusterSet survient après un failover forcé suivi du retour du site initialement PRIMARY : les deux clusters ont potentiellement des historiques de transactions divergents (le Site A a pu committer des transactions localement avant la coupure, jamais reçues par le Site B, qui a lui-même reçu de nouvelles écritures après sa promotion).

C’est ici que les tags GTID (Module 2.5) deviennent essentiels : lorsqu’un cluster REPLICA est promu PRIMARY par forcePrimaryCluster(), ClusterSet lui attribue un nouveau tag pour les transactions futures. Cela permet de distinguer sans ambiguïté :

  • les transactions {101-105} du cluster A original (tag absent ou tag A),
  • des transactions {101-110} générées après la promotion du cluster B (nouveau tag).

Sans les tags, deux GTID pourraient porter le même transaction_id avec le même source_id réutilisé après un rebuild, mais représenter des transactions différentes — un GTID Set redevient alors ambigu. rejoinCluster() utilise cette information pour déterminer si le cluster A, en le réintégrant, doit :

  • être rembobiné/reconstruit depuis un clone du nouveau PRIMARY (cas le plus fréquent, choix sûr par défaut), ou
  • pouvoir rejouer uniquement le delta, si l’AdminAPI détermine que GTID_SUBTRACT entre les deux ensembles ne révèle aucune transaction réellement divergente (cas rare, historique parfaitement compatible).
// Diagnostic avant réintégration
      var clusterSet = dba.getClusterSet();
      clusterSet.status({extended: 1});

7.4 6.4 TP — Mettre en place un ClusterSet (DR multi-site simulé)

ClusterSet

7.5 6.5 Synthèse de fin de formation

Questions de synthèse (débrief oral, 15 min) :

  1. Pourquoi le failover intra-cluster est-il automatique alors que le failover inter-cluster (ClusterSet) nécessite une action explicite ?
  2. En quoi les tags GTID (Module 2) résolvent-ils un problème qui n’existait pas dans une architecture à cluster unique ?
  3. Un client applicatif qui se connecte directement aux nœuds MySQL (sans passer par Router) perd quels bénéfices ?