Un plan de déplacement de bases qui respecte les groupes de basculement
Déplacer une base géo-répliquée entre pools : secondaire d'abord, contrôles de capacité des deux côtés, lien géo, pause des consommateurs, vérification et retour arrière.
Une base qui appartient à un groupe de basculement existe en double : une copie primaire dans un pool d'un serveur, une copie géo-secondaire dans un pool d'un autre serveur. La déplacer vers un autre pool oblige à toucher les deux copies, dans le bon ordre, sans casser le lien de géo-réplication, et souvent sans prévenir les applications. Voici le plan que je suis, écrit une fois pour toutes sous forme de script pour qu'il soit identique à chaque fois.
Le modèle
Dans mon parc, chaque pool a un jumeau de même nom sur le serveur partenaire, et chaque paire de pools a son propre groupe de basculement. Le placement d'une base se compose donc de quatre faits : pool primaire, pool secondaire, groupe de basculement, et serveur actuellement primaire. Un déplacement peut changer le pool seul, ou le pool et le groupe (quand le pool cible appartient à un autre groupe). Je le découpe en deux tâches :
| Tâche | Quand | Quoi |
|---|---|---|
| Tâche 1, pool | En journée, risque faible | Déplacer la copie secondaire, puis la copie primaire, vers le pool cible |
| Tâche 2, groupe de basculement | Le soir, hors heures de bureau | Retirer la base de son groupe, l'ajouter au groupe du pool cible |
Ce découpage compte : la tâche 1 est une opération de mise à l'échelle en ligne, la tâche 2 change le point de connexion des applications et exige une fenêtre calme.
Séquence
sequenceDiagram
participant Plan as Table du plan
participant Run as Script de déplacement
participant Sec as Serveur secondaire
participant Pri as Serveur primaire
participant Cons as Consommateurs
Plan->>Run: déplacement ouvert (pool source, pool cible)
Run->>Run: contrôles de capacité des deux pools cibles
Run->>Sec: déplacer la copie secondaire vers le pool cible
Sec-->>Run: pool vérifié
Run->>Pri: déplacer la copie primaire vers le pool cible
Pri-->>Run: pool vérifié
Run->>Plan: tamponner la tâche 1
Run->>Cons: mettre les consommateurs en pause
Run->>Pri: retirer de l'ancien groupe, ajouter au nouveau
Run->>Run: vérifier l'état du lien géo
Run->>Cons: reprendre les consommateurs
Run->>Plan: tamponner la tâche 2
Pourquoi le secondaire d'abord
Le secondaire doit pouvoir suivre le primaire. Si le primaire arrive en premier dans son pool, il peut produire des changements qu'un secondaire resté dans un pool plus petit ou plus chargé n'absorbe pas. La recommandation documentée pour redimensionner des bases géo-répliquées est la même : changer d'abord le secondaire. Cela offre aussi un test gratuit : si le pool cible refuse la base, la production n'a encore subi aucun changement.
Arbre de décision
flowchart TD
A["Déplacement ouvert"] --> B{"Les deux pools cibles ont de la place ?"}
B -->|"non"| X["Ignorer, noter la raison"]
B -->|"oui"| C{"Maximum de bases par pool respecté ?"}
C -->|"non"| X
C -->|"oui"| D{"Lien géo sain ?"}
D -->|"non"| X
D -->|"oui"| E{"Le groupe change ?"}
E -->|"non"| F["Tâche 1 seule"]
E -->|"oui"| G["Tâche 1 maintenant, tâche 2 le soir"]
Contrôles de capacité des deux côtés
Avant tout changement, je lis l'état réel des deux pools cibles, pas mon inventaire :
- nombre de bases par rapport au maximum autorisé pour le pool ;
- espace de données alloué après le déplacement, avec une marge (je garde le pool au moins 15 % sous sa limite de stockage) ;
- même orientation : une base dont le primaire est sur le serveur A doit arriver dans un pool dont le groupe est aussi primaire sur A.
Un pool qui n'existe que sur un serveur est ignoré par le plan.
Le déplacement
function Move-DbToPool {
param($Rg, $Server, $Db, $Pool)
$current = Get-AzSqlDatabase -ResourceGroupName $Rg -ServerName $Server -DatabaseName $Db
if ($current.ElasticPoolName -eq $Pool) { return 'AlreadyThere' } # idempotent
Set-AzSqlDatabase -ResourceGroupName $Rg -ServerName $Server `
-DatabaseName $Db -ElasticPoolName $Pool | Out-Null
$after = Get-AzSqlDatabase -ResourceGroupName $Rg -ServerName $Server -DatabaseName $Db
if ($after.ElasticPoolName -ne $Pool) { throw "Pool of $Db is $($after.ElasticPoolName)" }
'Moved'
}
# ordre : secondaire d'abord, puis primaire
Move-DbToPool $rg $secondaryServer $db $targetPool
Move-DbToPool $rg $primaryServer $db $targetPool
Pour le changement de groupe, je retire la base du groupe puis je l'ajoute à l'autre, sur le serveur primaire. Le lien de géo-réplication n'est pas rompu : le nouveau groupe hérite du lien existant. C'est pourquoi je n'utilise jamais un utilitaire qui supprime une copie « orpheline » du serveur partenaire avant l'ajout : cette copie est le secondaire vivant.
Garder le lien géo sain
Après chaque tâche, je lis l'état du lien de réplication et je m'arrête s'il n'est pas sain. Un secondaire qui rattrape son retard après un déplacement est normal ; un lien qui reste malsain est une raison d'arrêter le plan, pas d'insister.
Mettre les consommateurs en pause
Entre le retrait de la base de son groupe et le moment où les applications connaissent le nouveau point de connexion, les connexions via l'ancien listener échouent. Chez moi, les travailleurs d'arrière-plan qui se connectent aux bases sont réduits ou exclus pour les bases concernées, et j'attends qu'ils soient inactifs avant le changement de groupe. L'attente a une limite ; passé ce délai je continue mais je marque l'exécution en échec, pour qu'un humain regarde.
Vérification et retour arrière
- Vérifier en relisant : chaque tâche ne tamponne la ligne du plan que lorsque le pool, le groupe et l'état du lien réels correspondent à la cible.
- Rejeu idempotent : le script lit les lignes ouvertes et ne fait que le reste ; une étape faite à la main est détectée et tamponnée.
- Retour arrière : un déplacement en sens inverse, écrit comme nouvelle ligne de plan. Je ne modifie jamais l'historique : chaque tâche écrit une ligne avec le pool et le groupe avant et après.
- Une ligne périmée est refusée, par exemple si un basculement a échangé les rôles depuis l'écriture du plan.
Pièges
- Contrôler le rôle géo à l'exécution, pas à la planification.
- Ne pas lancer l'étape de journalisation à la main : elle ajoute une ligne à chaque appel.
- Commencer par une seule base de bout en bout pour valider les droits sur chaque système touché.