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.
La formation utilise 5 machines EC2 (Ubuntu 22.04 LTS, t3.medium) dans un VPC dédié :
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
router1directement ? Parce querouter1n’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 ».
| 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) |
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.
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 :
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 :
AIDE-MEMOIRE.txt) ;ssh node1, ssh node2, ssh node3, ssh router1 sans mot de passe (clé déjà installée) ;Note de sécurité : le port RDP (3389) est ouvert à
0.0.0.0/0dans 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ègle0.0.0.0/0à ces IP précises dans le Security Group.
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é.
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 :
Vérifier que MySQL tourne et que GTID est actif :
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 :
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.
Supprime toutes les instances, le Security Group, l’IGW, le Subnet et le VPC pour éviter toute facturation résiduelle.
À l’issue des 3 jours, chaque participant sera capable de :
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. |
| 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) |
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.
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).
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.
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.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 :
CHANGE REPLICATION SOURCE TO SOURCE_AUTO_POSITION=1) ;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).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).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
, : sépare les GTID de sources différentes.: : sépare les intervalles pour une même source.- : 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().
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.
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 MASTERremet aussiGTID_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).
| 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. |
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).
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.
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.
Le GCS est la couche qui assure :
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).
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.
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. |
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.
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().
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).
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.
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é.
| 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. |
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.
| 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 |
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.
Group Replication impose des contraintes qu’il faut connaître avant de concevoir un schéma applicatif :
SERIALIZABLE isolation level combiné à certaines opérations.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.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.
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.
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) :
Points d’attention :
CLONE INSTANCE échoue si des données de production sont déjà présentes, sauf option de forçage).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.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.
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. |
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.
MySQL Shell écrit ses propres logs (distincts des logs MySQL serveur), très utiles pour diagnostiquer un échec d’addInstance() ou de createCluster() :
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.
util object : util.checkForServerUpgrade(), util.exportTable(), util.importJson(), util.dumpInstance() / util.loadDump() (le successeur recommandé de mysqldump pour les gros volumes, parallélisé).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).\show query / \watch query pour surveiller une requête en boucle directement dans le Shell, sans script externe.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.
Le bootstrap (--bootstrap) interroge le cluster pour découvrir sa topologie et génère la configuration locale de Router (mysqlrouter.conf) :
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=1L’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.
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).conf-use-gr-notifications est bien actif et que le port 33060 est ouvert entre Router et les nœuds (nécessaire aux notifications).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 = autoaccess_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.
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) :
C’est particulièrement utile avec des frameworks/ORMs qui ouvrent beaucoup de connexions courtes.
Router expose une API REST HTTPS (port 8443 par défaut) pour la supervision : état des routes, connexions actives, statut de santé.
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) :
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).
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.
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) :
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.clusterSet.forcePrimaryCluster() ou setPrimaryCluster()), jamais totalement automatique par défaut — contrairement au failover intra-cluster (Module 4) qui lui est automatique.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é :
{101-105} du cluster A original (tag absent ou tag A),{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 :
GTID_SUBTRACT entre les deux ensembles ne révèle aucune transaction réellement divergente (cas rare, historique parfaitement compatible).Questions de synthèse (débrief oral, 15 min) :