Kovalibre Logo partenaire

MySQL InnoDB Cluster

1 Module 0 —Introduction

1.1 Objectifs de la formation

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

• analyser le fonctionnement interne d’un cluster MySQL InnoDB Cluster ; 
• comprendre les mécanismes avancés de MySQL Group Replication ; 
• diagnostiquer les incidents complexes (quorum, réplication, recovery, GTID) ; 
• utiliser efficacement MySQL Shell pour l’administration avancée et le dépannage ; 
• analyser et dépanner le comportement de MySQL Router en environnement HA ; 
• superviser et restaurer un cluster en situation dégradée ; 
• comprendre et exploiter MySQL InnoDB ClusterSet dans un contexte de PRA ; 
• gérer des scénarios de crise et assurer la continuité de service. 

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.

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).

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).

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)

1.6 Environnement technique

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.7 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.8 Environnement disponible

Une fois connecté, 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.9 Création du cluster

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.10 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.

2 Module 1 — GTID avancé et cohérence des données

2.1 Objectifs

  • Analyser les jeux GTID (GTID Sets) d’un cluster en fonctionnement.
  • Identifier une divergence de transactions entre deux nœuds.
  • Diagnostiquer une incohérence GTID avant qu’elle ne bloque une réplication.

2.2 Rappels ciblés GTID

Un GTID (source_id:transaction_id) identifie une transaction de façon globale et unique. Sur un cluster en production, ce qui compte n’est pas la définition du GTID mais l’écart entre les GTID Sets des différents membres — c’est cet écart qui révèle un problème avant qu’il ne devienne bloquant.

2.3 GTID Sets — lecture experte

SHOW VARIABLES LIKE 'gtid_executed';
SELECT @@GLOBAL.gtid_executed;
SELECT @@GLOBAL.gtid_purged;

Sur un cluster de plusieurs membres, la bonne pratique de diagnostic est de comparer tous les gtid_executed en même temps (script ou requête fédérée via MySQL Shell \js en interrogeant chaque membre), plutôt que de lire un seul nœud isolément — un gtid_executed sain sur un nœud isolé ne dit rien sur l’état du cluster.

2.4 gtid_executed / gtid_purged — pièges d’exploitation

  • gtid_purged grandit à chaque purge de binlog (PURGE BINARY LOGS, rotation automatique par expire_logs_days/binlog_expire_logs_seconds). Un nœud dont le retard dépasse ce qui est encore dans le binlog ne peut plus être rattrapé par recovery incrémentale — seul le clone (Module 8) fonctionne alors.

  • Vérifier avant toute intervention planifiée (maintenance, migration) :

    SELECT @@GLOBAL.gtid_purged;
    SHOW BINARY LOGS;

    Si un nœud doit être arrêté longtemps, augmenter temporairement la rétention des binlogs pour élargir la fenêtre de recovery possible.

2.5 Transactions errantes (errant transactions)

Une transaction errante est une transaction présente dans le gtid_executed d’un membre mais jamais vue par le reste du groupe — typiquement une écriture faite directement sur un membre en contournant Group Replication (super_read_only désactivé par erreur, ou écriture avant l’intégration au groupe).

-- Détection : comparer le gtid_executed local à celui vu par le groupe
SELECT GTID_SUBTRACT(@@GLOBAL.gtid_executed, RECEIVED_TRANSACTION_SET)
FROM performance_schema.replication_connection_status
WHERE channel_name = 'group_replication_applier';

Un résultat non vide = transactions errantes. C’est la cause n°1 d’un dba.checkInstanceState() qui renvoie state: "recoverable" mais avec un avertissement, ou d’un addInstance() qui échoue avec une erreur de compatibilité GTID.

2.6 GTID_SUBSET, GTID_SUBTRACT — usages de diagnostic

-- Le GTID Set A est-il entièrement inclus dans B ?
SELECT GTID_SUBSET(A, B);

-- Qu'est-ce qui est dans A mais pas dans B ?
SELECT GTID_SUBTRACT(A, B);

Cas d’usage concrets en diagnostic : - Avant un addInstance() : GTID_SUBTRACT(gtid_purged_donor, gtid_executed_candidat) non vide → le candidat ne peut pas faire de recovery incrémentale (le donneur a déjà purgé ce qu’il lui faudrait) → clone obligatoire. - Avant un rejoinCluster() (ClusterSet, Module 11) : même logique, entre le cluster qui revient et le cluster resté PRIMARY.

2.7 Cohérence inter-nœuds — check-list de diagnostic

  1. SELECT @@GLOBAL.gtid_executed; sur chaque membre.
  2. Comparer deux à deux avec GTID_SUBTRACT dans les deux sens.
  3. Si écart : GTID_SUBTRACT(local, groupe) non vide → transactions errantes locales (1.4) ; GTID_SUBTRACT(groupe, local) non vide → simple retard de réplication (normal si transitoire, anormal si persistant).
  4. Croiser avec performance_schema.replication_group_member_stats (COUNT_TRANSACTIONS_IN_QUEUE) pour distinguer retard transitoire d’incident bloqué.

2.8 Atelier

Voir TP 1 — Analyse de divergence GTID et validation de réintégration.

3 Module 2 — Internals de MySQL Group Replication

3.1 Objectifs

  • Comprendre le cycle complet d’une transaction dans Group Replication.
  • Analyser les mécanismes internes de réplication (GCS/XCom, writesets, certification, view changes, quorum).

3.2 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.

3.3 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;

3.4 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.

3.5 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;

3.6 Cycle d’une transaction — vue complète

Point clé pour le diagnostic : le COMMIT applicatif n’est confirmé qu’une fois la certification passée par le groupe — un COMMIT lent côté application peut donc avoir pour cause un ralentissement à n’importe quelle étape de ce cycle, pas seulement l’exécution SQL locale.

3.7 GCS / XCom — ce qu’il faut savoir diagnostiquer

SELECT * FROM performance_schema.replication_group_communication_information;
SHOW VARIABLES LIKE 'group_replication_communication%';

Symptômes typiques d’un problème GCS :

  • Latence réseau inter-nœuds élevée → group_replication_member_expel_timeout qui se déclenche à tort (faux positifs d’exclusion).
  • group_replication_communication_max_message_size trop petit pour des transactions volumineuses → érreurs de fragmentation.

3.8 Writesets et certification — diagnostic de conflits

SHOW VARIABLES LIKE 'transaction_write_set_extraction';  -- doit être XXHASH64
SELECT * FROM performance_schema.replication_group_member_stats
\G

Colonnes clés pour le diagnostic de certification :

  • COUNT_TRANSACTIONS_CHECKED : nombre de transactions passées en certification.
  • COUNT_CONFLICTS_DETECTED : conflits détectés (Multi-Primary principalement, ou transaction errante en Single-Primary).
  • COUNT_TRANSACTIONS_ROWS_VALIDATING : writesets encore en attente de certification — une valeur qui croît en continu signale un ralentissement du certifieur lui-même (rare, souvent lié à une charge CPU excessive sur le membre).

3.9 Applier & Recovery channels — lecture croisée

SELECT channel_name, service_state
FROM performance_schema.replication_connection_status;

SELECT channel_name, count_transactions_in_queue, count_transactions_applied,
       count_transactions_applied_wait_time
FROM performance_schema.replication_applier_status_by_coordinator;

Un canal group_replication_recovery actif en dehors d’une phase de jointure est toujours anormal — c’est souvent le premier signal d’un nœud qui boucle sans jamais atteindre ONLINE.

3.10 View changes et quorum

Une view est la vue courante de l’appartenance au groupe (qui est membre, à un instant donné). Chaque changement de membership (arrivée, départ, panne détectée) déclenche un view change, negocié par le groupe.

SELECT * FROM performance_schema.replication_group_members;

Le quorum exige une majorité stricte des membres configurés (pas seulement présents) pour continuer à accepter des écritures :

  • 3 membres → tolère 1 panne (majorité = 2/3).
  • 2 membres restants sur 3 → majorité encore atteinte, écritures possibles.
  • 1 membre restant sur 3 → majorité perdue → cluster bloqué en écriture (voir Module 6, perte de quorum).

3.11 Gestion des conflits — au-delà du Multi-Primary

Même en Single-Primary, un conflit de certification peut survenir dans de rares cas : transaction errante (Module 1.4) qui entre en collision avec une transaction légitime du groupe sur la même ligne. Le comportement est identique à un conflit Multi-Primary (rollback côté certifieur), mais la cause racine est différente et le remède aussi (corriger la source de l’écriture directe, pas gérer un design applicatif Multi-Primary).

3.12 Atelier

Voir TP 2 — Observation des flux de réplication et analyse de la certification.

4 Module 3 — Flow control et performances

4.1 Objectifs

  • Diagnostiquer un ralentissement lié à Group Replication.
  • Comprendre les limites de débit et les variables de régulation.

4.2 Mécanisme de flow control — rappel synthétique

Le flow control ralentit volontairement les membres rapides pour laisser le temps aux membres lents de rattraper leur file d’application, évitant un écart de données non borné entre membres (voir aussi Module 2.4).

SHOW VARIABLES LIKE 'group_replication_flow_control%';
Variable Rôle diagnostic
group_replication_flow_control_mode QUOTA (actif) vs DISABLED. Si DISABLED en prod, aucune protection contre un membre à la dérive.
group_replication_flow_control_certifier_threshold Seuil sur la file de certification.
group_replication_flow_control_applier_threshold Seuil sur la file d’application — le plus souvent celui qui sature en premier.
group_replication_flow_control_period Fréquence de recalcul du throttling (secondes).

4.3 Back pressure — comment la lire

SELECT MEMBER_ID,
       COUNT_TRANSACTIONS_REMOTE_IN_APPLIER_QUEUE,
       COUNT_TRANSACTIONS_LOCAL_IN_APPLIER_QUEUE
FROM performance_schema.replication_group_member_stats;

La back pressure devient visible côté application par une latence de COMMIT accrue sur TOUS les membres, pas seulement sur celui qui est en retard — c’est le point souvent mal compris en astreinte : un ralentissement généralisé peut avoir pour cause un seul membre lent (I/O disque dégradée, CPU throttlé, etc.).

4.4 Saturation de l’applier — diagnostic ciblé

SELECT * FROM performance_schema.replication_applier_status_by_worker
WHERE channel_name = 'group_replication_applier';

Causes fréquentes de saturation de l’applier, à éliminer dans l’ordre :

  1. I/O disque du membre concerné (iostat -x 1, SHOW ENGINE INNODB STATUS — section LOG).
  2. Parallélisme insuffisant : replica_parallel_workers trop bas pour le volume de transactions indépendantes.
  3. Dépendances entre transactions empêchant la parallélisation malgré des workers disponibles (writesets qui se chevauchent).
  4. CPU throttlé (cas cloud : crédits burstable épuisés — vmstat 1, colonne st).

4.5 Variables de régulation — que modifier, et dans quel ordre

En diagnostic live, l’ordre de test recommandé :

  1. Ne pas désactiver le flow control pour “aller plus vite” sans avoir identifié la cause du retard — ça déplace le problème vers une divergence de données non maîtrisée.
  2. Augmenter group_replication_flow_control_applier_threshold temporairement pour absorber un pic ponctuel connu (batch nocturne…), en connaissance de cause.
  3. Traiter la cause racine (I/O, CPU, parallélisme) plutôt que le seuil.

4.6 Atelier

Voir TP 3 — Simulation de charge et analyse du throttling.

5 Module 4 — Exploitation avancée de MySQL Shell

5.1 Objectifs

  • Utiliser MySQL Shell pour diagnostiquer et réparer un cluster dégradé.
  • Exploiter les fonctionnalités avancées et les plugins.

5.2 AdminAPI avancée

Au-delà de createCluster/addInstance (niveau découverte), l’AdminAPI expose des méthodes de diagnostic et de réparation :

var cluster = dba.getCluster();
cluster.status({extended: 1});     // voir 4.2
cluster.describe();                 // topologie déclarée (metadata)
cluster.options();                  // toutes les options effectives
cluster.rescan();                   // resynchronise la vue metadata <-> réalité GR

rescan() est sous-utilisé : il détecte les membres présents dans Group Replication mais absents de la metadata AdminAPI (et inversement) — situation fréquente après une intervention manuelle en SQL brut.

5.3 cluster.status({extended:1}) — lecture experte

cluster.status({extended: 1});

Apporte, par rapport à status() simple : - le replication lag par membre (replicationLag) ; - l’état détaillé de la recovery en cours le cas échéant ; - les transactions behind par membre — la métrique la plus directement actionnable en astreinte pour savoir si un membre est “juste un peu en retard” ou “dans une situation qui ne se résorbe pas”.

5.4 Commandes critiques

5.4.1 Reboot cluster (from complete outage)

Quand tous les membres sont tombés (panne totale) :

// Depuis le membre choisi comme point de redémarrage (celui avec le
// gtid_executed le plus avancé - à vérifier au préalable, Module 1.6)
var cluster = dba.rebootClusterFromCompleteOutage('trainingCluster');

Piège classique : lancer cette commande depuis n’importe quel membre sans avoir vérifié au préalable lequel a le GTID Set le plus avancé — voir l’atelier du Module 6 pour la procédure complète.

5.4.2 Gestion du quorum en situation dégradée

// Forcer le quorum quand la majorité est perdue (DANGER - voir Module 6)
cluster.forceQuorumUsingPartitionOf('clusteradmin@<IP_MEMBRE_SURVIVANT>:3306');

5.5 Gestion des erreurs AdminAPI

Les erreurs AdminAPI encodent souvent la cause exacte dans leur message — la première étape de diagnostic est de lire le message en entier, pas seulement le code d’erreur, avant de chercher en ligne. Activer un niveau de log suffisant AVANT une opération sensible (pas après l’échec) :

mysqlsh --log-level=DEBUG3 --log-file=/tmp/diag.log

5.6 Plugins MySQL Shell

5.6.1 Principes

Un plugin MySQL Shell est un module JS/Python placé dans ~/.mysqlsh/plugins/, chargé automatiquement au démarrage et exposé comme un nouvel objet global (au même niveau que dba ou util).

5.6.2 Cas d’usage en diagnostic

Exemple : un plugin “healthcheck” qui interroge tous les membres et synthétise en une seule sortie les métriques dispersées vues aux Modules 1-3 (GTID, flow control, replication lag), pour un contrôle de routine sans recomposer les requêtes à chaque fois.

# ~/.mysqlsh/plugins/healthcheck/init.py (squelette)
from mysqlsh.plugin_manager import plugin_function

@plugin_function('healthcheck.run')
def run():
    shell = mysqlsh.globals.shell
    cluster = mysqlsh.globals.dba.get_cluster()
    print(cluster.status({"extended": 1}))
    # + requêtes performance_schema complémentaires

5.7 Logs et debugging

Log Contenu
~/.mysqlsh/mysqlsh.log Actions AdminAPI, connexions, erreurs Shell
error.log MySQL (chaque nœud) Événements Group Replication (view changes, expulsions)
logs Router Routage, bascules détectées (Module 7)

En incident, croiser les 3 par horodatage est souvent plus révélateur que n’importe quel log pris isolément.

5.8 Atelier

Voir TP 4 — Diagnostic complet via MySQL Shell et commandes de recovery.

6 Module 5 — Supervision et diagnostic avancé

6.1 Objectifs

  • Analyser l’état interne du cluster à partir des tables système.
  • Identifier les causes d’un incident à partir des métriques et des logs.

6.2 performance_schema — cartographie pour le diagnostic

Table Répond à la question
replication_group_members Qui est membre, quel rôle, quel état ?
replication_group_member_stats Combien de conflits, quelle file d’attente, quel débit ?
replication_connection_status Les canaux sont-ils connectés/actifs ?
replication_applier_status_by_worker L’application est-elle parallélisée efficacement ?
replication_group_communication_information GCS/XCom fonctionne-t-il normalement ?

6.3 États Group Replication — table de référence

MEMBER_STATE Signification Action
ONLINE Fonctionnement normal —
RECOVERING Rattrapage en cours (normal en jointure) Surveiller la durée (Module 6 si bloqué)
OFFLINE Plugin GR arrêté Vérifier pourquoi, relancer si voulu
ERROR Le membre s’est mis en erreur (souvent après un conflit fatal ou une perte de quorum locale) Diagnostic approfondi avant redémarrage
UNREACHABLE Vu par le groupe mais ne répond plus Vérifier réseau avant d’attendre l’expulsion automatique

6.4 Métriques clés à surveiller en continu (supervision)

  • COUNT_TRANSACTIONS_REMOTE_IN_APPLIER_QUEUE (par membre) — tendance sur la durée, pas juste la valeur instantanée.
  • MEMBER_STATE de tous les membres — alerte sur tout état ≠ ONLINE persistant > quelques secondes.
  • Écart de gtid_executed entre membres (Module 1.6), calculé périodiquement.
  • Côté Router : nombre de connexions actives par route, santé perçue des destinations (Module 7).

6.5 Analyse des logs MySQL — grep utiles

# Événements Group Replication significatifs
sudo grep -i "group_replication\|view" /var/log/mysql/error.log | tail -50

# Expulsions et pertes de quorum
sudo grep -iE "expel|quorum" /var/log/mysql/error.log

Sur Ubuntu, le chemin exact peut varier (/var/log/mysql/error.log par défaut, sinon SHOW VARIABLES LIKE 'log_error';).

6.6 Atelier

Voir TP 5 — Diagnostic d’un nœud en erreur et analyse croisée métriques/logs.

7 Module 6 — Dépannage avancé

7.1 Objectifs

  • Résoudre les incidents critiques les plus fréquents en astreinte.
  • Restaurer la disponibilité d’un cluster dégradé.

7.2 Nœud bloqué en RECOVERING

Un membre qui reste en RECOVERING sans jamais atteindre ONLINE a généralement une des causes suivantes :

  1. Le canal recovery ne trouve pas de donneur valide (réseau, comptes de réplication mal configurés).
  2. Le volume de retard dépasse la capacité de recovery incrémentale (Module 1.3) — bascule attendue vers clone qui ne se produit pas (souvent parce que recoveryMethod a été forcé à incremental explicitement).
  3. Une transaction errante (Module 1.4) bloque l’application malgré une connexion réseau saine.

Démarche de diagnostic :

SELECT channel_name, service_state
FROM performance_schema.replication_connection_status
WHERE channel_name = 'group_replication_recovery';

SHOW REPLICA STATUS FOR CHANNEL 'group_replication_recovery'\G

Regarder Last_IO_Error / Last_SQL_Error — c’est souvent là que se trouve la cause exacte, pas dans MEMBER_STATE seul.

7.3 Perte de quorum

Symptôme : plus aucune écriture n’est acceptée sur aucun membre restant (ERROR 3092 (HY000): The server is not configured properly to be an active member of the group, ou équivalent selon version).

Procédure de diagnostic avant intervention :

SELECT * FROM performance_schema.replication_group_members;

Confirmer qu’on est bien dans un cas de perte de majorité réelle (nombre de membres UNREACHABLE/absents ≥ majorité), pas un cas de RECOVERING prolongé (6.1) qui ne nécessite pas la même procédure.

Intervention — forcer le quorum (opération destructive, à documenter) :

// Depuis un membre survivant, en connaissance du risque de perte de
// données côté membres exclus de cette nouvelle partition forcée
cluster.forceQuorumUsingPartitionOf(
  'clusteradmin:ClusterAdmin2026!@<IP_MEMBRE_SURVIVANT>:3306'
);

Cette commande exclut définitivement les membres non listés de la décision de quorum — ils devront être retirés puis réintégrés explicitement une fois revenus, jamais réintégrés automatiquement.

7.4 Redémarrage complet du cluster

Voir Module 4.3 (rebootClusterFromCompleteOutage) pour la commande — la procédure complète de dépannage associée :

  1. Ne redémarrer MySQL sur aucun nœud avant d’avoir un plan — un redémarrage non coordonné peut déclencher des élections/recoveries simultanées confuses.
  2. Comparer les gtid_executed de tous les membres (MySQL démarré, Group Replication encore arrêté) pour identifier le nœud le plus avancé (Module 1.6).
  3. Lancer rebootClusterFromCompleteOutage() depuis ce nœud uniquement.
  4. Réintégrer les autres membres un par un, en vérifiant cluster.status() entre chaque ajout.

7.5 Incohérences GTID — procédure de reprise

Combine les diagnostics des Modules 1.4-1.6 :

  1. Identifier le type d’incohérence (transaction errante vs simple retard vs purge dépassée).
  2. Décider clone vs recovery incrémentale vs correction manuelle ciblée.
  3. Toujours documenter la décision (quelle donnée a été perdue/écrasée, sur quel membre, pourquoi) — un incident GTID mal documenté complique fortement le prochain incident sur le même cluster.

7.6 Atelier

Voir TP 6 — Perte de quorum, redémarrage complet et remise en cohérence.

8 Module 7 — MySQL Router en production

8.1 Objectifs

  • Comprendre le comportement du routage en profondeur.
  • Diagnostiquer les problèmes applicatifs liés au cluster via le Router.

8.2 Architecture Router — ce qui compte en exploitation

Le Router n’a pas d’état persistant propre : toute sa connaissance de la topologie vient de deux sources, qu’il faut savoir distinguer en diagnostic :

  1. Le cache metadata (rafraîchi selon ttl, ou en push via use-gr-notifications).
  2. Les connexions déjà établies (qui ne sont pas coupées automatiquement lors d’un changement de topologie — voir 7.4).

8.3 Bootstrap et métadonnées — diagnostic

cat /opt/mysqlrouter/mysqlrouter.conf

Vérifier en particulier :

  • metadata_cluster correspond au bon nom de cluster.
  • ttl cohérent avec la tolérance de bascule acceptée par l’application.
  • use_gr_notifications actif si une bascule quasi-instantanée est requise.
-- Compte technique utilisé par le Router (créé au bootstrap)
SELECT user, host FROM mysql.user WHERE user LIKE 'mysql_router%';

Un compte Router expiré/révoqué est une cause fréquente et sous-diagnostiquée de perte de routage silencieuse (le Router ne peut plus lire la metadata, mais les connexions existantes peuvent continuer à fonctionner un moment, masquant le problème).

8.4 Read/Write Splitting — comportement en profondeur

Avec access_mode = auto sur une route combinée (PRIMARY_AND_SECONDARY) :

  • Le Router parse le SQL entrant pour distinguer lecture/écriture.
  • Après une écriture dans une session, les lectures suivantes restent sur le PRIMARY un certain temps (cohérence read-your-writes), avant de pouvoir repartir vers un SECONDARY.
  • Ce comportement est par session, pas global — une nouvelle connexion ne “sait” rien de l’état des autres.

8.5 Gestion des connexions — le point le plus mal compris

Une connexion déjà établie n’est PAS automatiquement redirigée lors d’un changement de PRIMARY. Le Router ne fait du routage qu’à l’établissement de la connexion (sauf logique applicative de reconnexion). Une application qui garde un pool de connexions ouvertes longtemps peut donc continuer à écrire vers un ancien PRIMARY… jusqu’à ce que celui-ci refuse l’écriture (super_read_only), provoquant une erreur applicative alors que le Router “a bien fait son travail” côté nouvelles connexions.

Conséquence pratique : en diagnostic d’incident post-failover, toujours vérifier l’âge des connexions en erreur, pas seulement la configuration du Router.

8.6 Comportement en cas de failover — chronologie

8.7 Logs et debugging Router

tail -f /opt/mysqlrouter/log/mysqlrouter.log

Rechercher spécifiquement, en diagnostic de bascule :

grep -iE "primary|metadata|notif" /opt/mysqlrouter/log/mysqlrouter.log | tail -50

8.8 Atelier

Voir TP 7 — Simulation de bascule primaire et diagnostic via les logs Router.

9 Module 8 — Clonage et recovery avancé

9.1 Objectifs

  • Analyser la reconstruction d’un nœud par clonage.
  • Diagnostiquer un échec de recovery ou de clonage.

9.2 Clone plugin — rappel des mécanismes internes

Le clone plugin copie physiquement les fichiers InnoDB du donneur, puis régénère l’identité locale (server_uuid, voir Module 1) avant de redémarrer et de rattraper le delta restant par recovery classique.

INSTALL PLUGIN clone SONAME 'mysql_clone.so';
SET GLOBAL clone_valid_donor_list = '<IP_DONOR>:3306';

9.3 clone_progress — suivre une opération en cours

SELECT * FROM performance_schema.clone_progress;
SELECT * FROM performance_schema.clone_status;

Colonnes clés : STATE (Not Started, In Progress, Completed, Failed), BEGIN_TIME/END_TIME par étape (FILE COPY, PAGE COPY, REDO COPY), et surtout ERROR_NO/ERROR_MESSAGE en cas d’échec.

-- Sur le RECEVEUR pendant/après un clone en échec
SELECT stage, state, error_no, error_message
FROM performance_schema.clone_progress
WHERE error_no != 0;

9.4 Récupération incrémentale vs clone — critère de décision

Critère Recovery incrémentale Clone
Retard dans la fenêtre binlog du donneur Possible Possible mais plus lent que nécessaire
Retard au-delà de la purge binlog Impossible Obligatoire
Volume de données très important Lent (rejeu transaction par transaction) Généralement plus rapide (copie physique)
Version MySQL différente entre membres Sensible aux incompatibilités Requiert compatibilité de version stricte

9.5 Erreurs de recovery/clone fréquentes

  • ER_CLONE_DONOR_TRAFFIC_LIMIT : trop de clones simultanés depuis le même donneur (limite clone_max_concurrency).
  • Incompatibilité de version MySQL donneur/receveur : le clone échoue à la validation initiale, avant tout transfert.
  • Espace disque insuffisant sur le receveur : détecté généralement en cours de FILE COPY, visible dans clone_progress.
  • Donneur non présent dans clone_valid_donor_list : erreur immédiate, avant toute tentative de connexion.

9.6 Logs à croiser

sudo grep -i clone /var/log/mysql/error.log

Sur le donneur ET le receveur — un échec côté receveur a souvent sa cause racine visible uniquement dans les logs du donneur (ex. limite de connexions, charge).

9.7 Atelier

Voir TP 8 — Simulation d’un clone échoué, analyse et correction.

10 Module 9 — Architecture de MySQL InnoDB ClusterSet

10.1 Objectifs

  • Comprendre la réplication multi-cluster.
  • Analyser les architectures PRA basées sur ClusterSet.

10.2 Primary cluster / replica cluster

À l’intérieur de chaque site : cohérence forte (synchrone par certification, Module 2). Entre sites : asynchrone — un choix délibéré, imposer un consensus inter-régions rendrait chaque écriture aussi lente que le trajet réseau le plus lent entre sites.

10.3 Réplication inter-cluster — ce qui la distingue de Group Replication

  • Basée sur un canal de réplication asynchrone classique GTID (auto-position), pas sur GCS/Paxos.
  • Un seul membre du cluster REPLICA reçoit réellement le flux (le membre “receveur” désigné) et le redistribue en interne via son propre Group Replication.
  • Le lag inter-cluster est mesurable et doit être surveillé spécifiquement (différent du lag intra-cluster).
-- Sur le membre "receveur" du cluster REPLICA
SELECT channel_name, service_state
FROM performance_schema.replication_connection_status
WHERE channel_name = 'clusterset_replication';

SELECT * FROM performance_schema.replication_connection_status
WHERE channel_name = 'clusterset_replication'\G
-- Comparer SOURCE_UUID / dernière transaction reçue vs l'horodatage courant

10.4 Topologies multi-sites — variantes

  • 1 PRIMARY + 1 REPLICA : cas simple, PRA à 2 sites.
  • 1 PRIMARY + N REPLICA : diffusion vers plusieurs sites (lecture locale déportée), un seul reste éligible à la promotion à la fois en pratique simple.
  • Chaque cluster (PRIMARY ou REPLICA) garde sa propre tolérance de panne interne (typiquement 3 membres par site) — ClusterSet n’est pas un substitut à Group Replication au sein d’un site, il s’ajoute par-dessus.

10.5 Contraintes WAN — points de vigilance en production

  • Latence : n’affecte pas la latence d’écriture locale (asynchrone), mais détermine le RPO potentiel (combien de transactions récentes peuvent être perdues en cas de bascule non planifiée).
  • Bande passante : doit absorber le débit d’écriture soutenu du PRIMARY, sans quoi le lag inter-cluster croît en continu.
  • Fiabilité de la liaison : des coupures fréquentes déclenchent des cycles répétés de reconnexion du canal clusterset_replication, à surveiller comme un signal de qualité de liaison WAN, pas seulement comme un incident isolé.

10.6 Atelier

Voir TP 9 — Analyse d’une architecture ClusterSet.

11 Module 10 — Fencing et bascule inter-cluster

11.1 Objectifs

  • Sécuriser une bascule inter-cluster.
  • Éviter le split-brain entre sites.

11.2 Mécanisme de fencing — rappel et approfondissement

Un cluster REPLICA est fencé : super_read_only y est appliqué à tous ses membres, indépendamment de son état interne (même s’il pourrait, pris isolément, élire un PRIMARY local qui accepterait des écritures). C’est ce qui empêche un split-brain par construction, plutôt que de compter sur une détection après-coup.

-- Sur n'importe quel membre d'un cluster REPLICA
SELECT @@GLOBAL.super_read_only;   -- doit toujours valoir 1

11.3 Promotion d’un replica cluster — ce qui se passe réellement

clusterSet.forcePrimaryCluster('siteB-cluster');

Étapes internes : 1. Le cluster REPLICA est défenced (super_read_only levé sur ses membres). 2. Un nouveau tag GTID est attribué aux transactions futures de ce cluster (Module 1, tags GTID) — pour distinguer sans ambiguïté les transactions générées après cette promotion de celles de l’ancien PRIMARY. 3. Le cluster précédemment PRIMARY (s’il est encore joignable) est fencé à son tour, pour éviter que les deux acceptent des écritures simultanément.

11.4 Gestion des écritures pendant et après la bascule

Pendant la bascule : aucune écriture n’est garantie acceptée sur aucun cluster (fenêtre de transition courte mais non nulle) — l’application doit gérer les erreurs transitoires avec retry, pas supposer une continuité de service parfaite.

Après la bascule : toutes les écritures doivent être redirigées vers le nouveau PRIMARY. Si un Router est configuré par cluster (plutôt qu’un Router “ClusterSet-aware”), une reconfiguration ou un bootstrap du Router peut être nécessaire — à vérifier dans votre architecture cible.

11.5 Scénarios de bascule — planifiée vs non planifiée

Type Commande Risque de perte de données
Bascule planifiée (maintenance) clusterSet.setPrimaryCluster() Nulle — attend la synchronisation complète avant de basculer
Bascule d’urgence (site PRIMARY inaccessible) clusterSet.forcePrimaryCluster() Possible — les transactions non encore répliquées au moment de la coupure sont perdues (RPO, Module 9.4)

Point de vigilance : ne jamais utiliser forcePrimaryCluster() par réflexe si setPrimaryCluster() est encore possible (site PRIMARY encore joignable) — la bascule planifiée est toujours préférable quand l’option existe.

11.6 Atelier

Voir TP 10 — Simulation de promotion et validation du fencing.

12 Module 11 — Dépannage ClusterSet et PRA

12.1 Objectifs

  • Résoudre les incidents inter-cluster.
  • Gérer un scénario de crise de bout en bout.

12.2 Incohérences GTID inter-cluster

Mêmes principes de diagnostic que Module 1 (GTID_SUBSET/GTID_SUBTRACT), appliqués entre clusters plutôt qu’entre membres d’un même cluster. La différence pratique : les tags GTID (Module 10.2) doivent être pris en compte explicitement — comparer des GTID Sets avec des tags différents sans en tenir compte peut faire croire à une divergence qui n’en est pas une (même transaction logique, tag différent après une promotion).

-- Sur le membre receveur de chaque cluster
SELECT @@GLOBAL.gtid_executed;

Comparer en gardant trace de quel tag correspond à quelle période (avant/après quelle promotion).

12.3 Réplication cassée entre clusters

Symptômes et diagnostic :

SELECT channel_name, service_state, LAST_ERROR_MESSAGE
FROM performance_schema.replication_connection_status
WHERE channel_name = 'clusterset_replication';

Causes fréquentes :

  • Compte de réplication inter-cluster expiré/révoqué.
  • Coupure WAN prolongée dépassant la fenêtre de binlog du PRIMARY (retour au même problème que Module 1.3, à l’échelle inter-cluster).
  • Membre receveur désigné devenu indisponible côté cluster REPLICA (bascule interne vers un autre membre receveur nécessaire).

12.4 rejoinCluster — cas d’échec et alternative

Si clusterSet.rejoinCluster() échoue (transactions trop divergentes, tag incompatible non résolu automatiquement) :

// Retirer complètement l'ancien cluster de l'ensemble, puis le recréer
// comme un nouveau REPLICA cluster from scratch (perte de son historique
// local propre, mais garantit une cohérence repartant de zéro)
clusterSet.removeCluster('siteB-cluster');
// ... puis createReplicaCluster() à nouveau, comme au Module 9 ...

Dernier recours documenté, pas une première option — toujours tenter rejoinCluster() d’abord et comprendre pourquoi il échoue avant de reconstruire.

12.5 Procédures PRA — bascule d’urgence et retour nominal

12.5.1 Bascule d’urgence (résumé opérationnel)

  1. Confirmer l’indisponibilité réelle et durable du site PRIMARY (éviter une bascule pour un incident transitoire qui se serait résorbé seul).
  2. clusterSet.forcePrimaryCluster() depuis le site REPLICA.
  3. Reconfigurer/rediriger les Router applicatifs vers le nouveau PRIMARY si nécessaire (Module 7).
  4. Communiquer le RPO réel de l’incident (transactions perdues, Module 9.4) aux parties prenantes.

12.5.2 Retour nominal (une fois l’ancien site PRIMARY réparé)

  1. Vérifier l’état du site revenu avant toute action (dba.checkInstanceState() équivalent au niveau cluster).
  2. clusterSet.rejoinCluster().
  3. Valider la cohérence post-réintégration (Module 1.6 appliqué à l’échelle du ClusterSet).
  4. Décider si un retour du PRIMARY vers le site d’origine est souhaité (setPrimaryCluster(), bascule planifiée cette fois) ou si le nouveau PRIMARY reste en place durablement.

12.6 Atelier de synthèse

Voir TP 11 — Scénario PRA complet : perte du cluster primaire, bascule et restauration.