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. |
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).
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).
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) |
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
».
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) |
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.
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
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.
Récupérer dans infra.env les IP publiques des
4 machines qui vous sont attribuées.
Se connecter en SSH à node1 :
ssh -i mysql-innodb-cluster-training-key.pem ubuntu@<IP_PUBLIQUE_NODE1>
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';"
Répéter sur node2 et node3 et
vérifier que chaque server_id est
différent.
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.
Module 1 — GTID avancé et cohérence des données
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.
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.
![]()
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.
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.
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.
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.
Cohérence inter-nœuds —
check-list de diagnostic
SELECT @@GLOBAL.gtid_executed; sur chaque
membre.
- Comparer deux à deux avec
GTID_SUBTRACT dans les
deux sens.
- 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).
- Croiser avec
performance_schema.replication_group_member_stats
(COUNT_TRANSACTIONS_IN_QUEUE) pour distinguer retard
transitoire d’incident bloqué.
Module 2 — Internals de MySQL Group Replication
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).
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.
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;
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.
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;
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.
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).
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.
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).
![]()
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).
Module 4 — Exploitation avancée de MySQL Shell
Objectifs
- Utiliser MySQL Shell pour diagnostiquer et réparer un cluster
dégradé.
- Exploiter les fonctionnalités avancées et les plugins.
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.
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”.
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.
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');
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
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).
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
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.
Module 6 — Dépannage avancé
Objectifs
- Résoudre les incidents critiques les plus fréquents en
astreinte.
- Restaurer la disponibilité d’un cluster dégradé.
Nœud bloqué en
RECOVERING
Un membre qui reste en RECOVERING sans jamais
atteindre ONLINE a généralement une des causes
suivantes :
- Le canal recovery ne trouve pas de donneur valide (réseau,
comptes de réplication mal configurés).
- 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).
- 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.
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.
Redémarrage complet du
cluster
Voir Module 4.3 (rebootClusterFromCompleteOutage)
pour la commande — la procédure complète de dépannage associée
:
- 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.
- 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).
- Lancer
rebootClusterFromCompleteOutage() depuis
ce nœud uniquement.
- Réintégrer les autres membres un par un, en vérifiant
cluster.status() entre chaque ajout.
Incohérences GTID —
procédure de reprise
Combine les diagnostics des Modules 1.4-1.6 :
- Identifier le type d’incohérence (transaction errante vs
simple retard vs purge dépassée).
- Décider clone vs recovery incrémentale vs correction manuelle
ciblée.
- 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.
Module 7 — MySQL Router en production
Objectifs
- Comprendre le comportement du routage en profondeur.
- Diagnostiquer les problèmes applicatifs liés au cluster via le
Router.
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 :
- Le cache metadata (rafraîchi selon
ttl, ou en push via
use-gr-notifications).
- Les connexions déjà établies (qui ne sont pas
coupées automatiquement lors d’un changement de topologie — voir
7.4).
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).
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.
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.
Comportement en cas de
failover — chronologie
![]()
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
Module 8 — Clonage et recovery avancé
Objectifs
- Analyser la reconstruction d’un nœud par clonage.
- Diagnostiquer un échec de recovery ou de clonage.
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';
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;
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 |
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.
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).
Module 10 — Fencing et bascule inter-cluster
Objectifs
- Sécuriser une bascule inter-cluster.
- Éviter le split-brain entre sites.
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
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.
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.