Migration de base de données sans interruption : un guide pour la production

La plupart des pannes de migration viennent d'une seule erreur : livrer un changement de schéma et le code qui en dépend d'un même souffle. Découplez-les, faites tourner l'ancien et le nouveau côte à côte un moment, et les parties effrayantes deviennent ennuyeuses. Voici le guide que nous utilisons pour modifier des schémas et déplacer des bases de données en production sans fenêtre de maintenance.

7 min de lecture8 sections22 juin 2026

Écrit par

Kostadin Stamboliev

Fondateur et Imaginator

Fondateur et Imaginator de Pineido. Il travaille dans le conseil informatique, le développement d’applications et de sites web, le SEO technique, l’IA et l’automatisation. Il livre du code en production en sprints de 30 jours, avec un périmètre fixe et des responsabilités claires.

LinkedIn

Ce que « sans interruption » veut vraiment dire

Sans interruption ne veut pas dire magie. Cela veut dire qu'il n'y a jamais un instant où l'application en cours d'exécution ne peut pas lire et écrire ce dont elle a besoin. La version honnête, empruntée à ceux qui déplacent de grosses bases pour gagner leur vie, est « bascule quasi nulle » : le nouvel état reflète l'ancien d'assez près pour que les utilisateurs ne remarquent jamais d'interruption.

Deux problèmes distincts se cachent sous la même expression, et ils demandent des tactiques différentes. Le premier est l'évolution de schéma : modifier des tables, des colonnes, des types et des contraintes au sein d'une base qui reste en place. Le second est la relocalisation : déplacer des données vers une nouvelle base, un nouveau moteur ou une nouvelle région. La règle qui unifie les deux est la même. Une migration doit s'achever pendant que l'ancien code de l'application tourne encore, et le nouveau code doit fonctionner contre l'ancienne et la nouvelle forme durant le recouvrement. Découplez le changement de schéma du déploiement et tout cela cesse d'être un événement unique terrifiant.

Le motif expand-contract est tout le jeu

Presque tout changement de schéma sûr est une variante d'expand-contract, aussi appelé changement parallèle. Au lieu d'une migration atomique qui bascule tout d'un coup, vous découpez le travail en phases qui se livrent chacune indépendamment et restent chacune rétrocompatibles.

Expand : ajoutez la nouvelle colonne, table ou index à côté de l'ancien. Rien ne casse parce que rien n'est supprimé. L'application commence à écrire dans les deux représentations (dual-write) mais lit toujours depuis l'ancienne.

Migrate : remplissez les lignes historiques dans la nouvelle forme, puis vérifiez, puis basculez les lectures vers la nouvelle colonne tandis que la double écriture continue.

Contract : cessez d'écrire dans l'ancienne colonne, renommez-la pour que toute référence oubliée échoue bruyamment, observez, et seulement ensuite supprimez-la.

La raison pour laquelle cela marche, c'est que la frontière entre les phases est l'endroit où vous livrez et observez. Si quelque chose cloche, la phase précédente reste pleinement fonctionnelle. Vous pouvez vous mettre en pause indéfiniment au lieu d'inverser un changement à moitié appliqué pendant que les alertes sonnent. Les changements purement additifs sont le cas facile, l'ancien code ignore simplement la nouvelle colonne. La discipline compte le plus quand vous modifiez ou retirez quelque chose dont l'application en service dépend.

Double écriture : garder les deux copies honnêtes

Pendant la fenêtre de recouvrement, chaque écriture doit atterrir à la fois dans l'ancien et le nouvel emplacement, sinon la nouvelle copie prend silencieusement du retard. Vous avez deux façons de le faire et le choix a de vraies conséquences.

La double écriture au niveau applicatif signifie que votre code écrit explicitement aux deux endroits. Elle apparaît dans les traces et les journaux, donc quand quelque chose diverge vous pouvez le déboguer via la pile d'observabilité à laquelle vous faites déjà confiance. Les déclencheurs de base de données peuvent garder les colonnes synchronisées avec moins de code applicatif, mais le comportement se produit à l'intérieur de la base où votre outillage habituel ne peut pas le voir, ce qui rend le débogage misérable. Pour la plupart des équipes, le petit coût d'une écriture applicative explicite vaut la traçabilité.

Le tranchant de la double écriture, c'est que deux écritures ne sont pas une transaction atomique unique. Si la première réussit et la seconde échoue, les copies dérivent. Pour tout ce où cela compte, routez les écritures via un outbox transactionnel ou une propagation par file de messages, afin qu'une seule transaction validée soit la source de vérité et que la seconde écriture en dérive. C'est aussi là qu'un outil comme pgroll adopte une autre approche sur Postgres : il expose des vues spécifiques à chaque version pour que les anciennes et nouvelles versions de l'app voient chacune le schéma qu'elles attendent, et gère la logique double au niveau de la base plutôt que dans votre code.

Backfill sans faire fondre la base

Les nouvelles écritures vont aux deux copies dès que la double écriture est active, mais les lignes historiques ne se déplacent pas toutes seules. Le backfill copie les données existantes dans la nouvelle forme. Faites-le par lots, typiquement quelques milliers de lignes à la fois, avec une pause délibérée entre les lots pour ne pas saturer l'E/S et affamer le trafic en direct.

Gardez le backfill dans un travail séparé du changement de schéma. Ajouter une colonne NOT NULL avec une valeur par défaut et remplir des millions de lignes dans la même migration, c'est ainsi qu'un changement de deux secondes devient un verrou de plusieurs heures. Sur Postgres, ajoutez d'abord une contrainte NOT NULL en NOT VALID, ce qui est instantané car cela saute le balayage de table, puis exécutez VALIDATE CONSTRAINT séparément, qui prend un verrou plus léger laissant les lectures et écritures continuer.

Planifiez les backfills lourds pour des fenêtres à faible trafic, bridez-les, et surveillez vos réplicas. Si vous faites tourner des réplicas en lecture, ils peuvent porter brièvement un schéma différent du primaire, donc l'application doit tolérer ce décalage pendant la migration.

Validez avant de faire confiance à la nouvelle copie

Compter les lignes n'est pas valider. Les comptes de lignes peuvent concorder alors que les contenus diffèrent. Avant de déplacer les lectures, vérifiez avec des sommes de contrôle ou des hachages sur les tables critiques et des contrôles d'invariants sur des données échantillonnées, pas seulement des totaux. Si vous lisez déjà depuis les deux copies pour certaines requêtes, une comparaison au niveau applicatif qui signale les écarts en temps réel est le signal le plus fort que vous puissiez obtenir.

Le backfill est aussi votre occasion de corriger la qualité des données. Migrer les lignes historiques fait remonter les incohérences que la production tolère silencieusement depuis des années, alors traitez le backfill comme une passe de nettoyage, pas seulement comme une copie.

Ne coupez pas la double écriture trop tôt. Gardez les deux copies vivantes et synchronisées pendant au moins un cycle métier complet après avoir basculé les lectures. Désactiver l'ancien chemin tôt masque des écarts que vous n'avez pas encore attrapés, et vous prive de votre rollback le moins coûteux.

Le verrouillage est la vraie source de l'interruption

L'instruction DDL elle-même est généralement rapide. La panne vient de la contention de verrous autour d'elle. Une défaillance courante : un ALTER demande un verrou exclusif, reste coincé derrière une transaction de longue durée ou une session ouverte oubliée, et chaque requête qui arrive après lui s'aligne derrière le verrou. Un simple changement de schéma dégénère en blocage à l'échelle du service.

Défendez-vous. Fixez toujours un lock_timeout court pour qu'un DDL bloqué échoue vite au lieu d'engorger la file. Sur Postgres, construisez les index avec CREATE INDEX CONCURRENTLY pour que les écritures se poursuivent pendant la construction, et souvenez-vous qu'il attend les transactions démarrées avant lui, alors tuez d'abord les requêtes longues égarées. Postgres enveloppe aussi le DDL dans des transactions, donc une migration ratée se rétracte proprement.

Sur MySQL le tableau dépend de la version. Vérifiez que votre changement supporte ALGORITHM=INPLACE, LOCK=NONE, et sachez que certaines opérations avant 8.0.29 reconstruisent toute la table et bloquent les écritures. Pour les tables à très grand nombre de lignes où même un ALTER en ligne est risqué, tournez-vous vers un outil externe : gh-ost ou pt-online-schema-change sur MySQL, pgroll ou pg_osc sur Postgres. Ils construisent une copie fantôme, la synchronisent par morceaux, et échangent atomiquement pendant que l'original reste pleinement utilisable.

Passer à une nouvelle base : chargement en masse, CDC, bascule

Relocaliser une base, à travers des moteurs, des versions ou des régions, suit trois phases. D'abord, un chargement en masse établit une référence : un dump et restore natifs, ou un snapshot, dans la cible. Ensuite, la capture de données de changement (CDC) ou la réplication logique diffuse chaque insertion, mise à jour et suppression de la source vers la cible, de sorte que l'écart continue de se réduire vers un décalage quasi nul. Pour les déplacements au sein du même moteur, la réplication logique de Postgres ou la réplication binlog de MySQL est généralement le chemin le plus propre, et la réplication logique enjambe même les versions majeures. Appliquez le schéma sur la cible en premier, car la réplication logique ne transporte pas le DDL.

Troisièmement, la bascule. Planifiez-la comme une fenêtre en lecture seule de secondes, pas de minutes : arrêtez brièvement les écritures sur la source, confirmez que le décalage de réplication a atteint zéro, puis redirigez le trafic en échangeant la chaîne de connexion, le DNS ou la route de l'équilibreur de charge. Surveillez la dérive des séquences et de l'auto-incrément : si la séquence de la cible est en retard sur la source, les nouvelles insertions entrent en collision avec les ID répliqués. Après la bascule, lancez VACUUM/ANALYZE ou OPTIMIZE TABLE, et n'éteignez pas la source. Gardez-la vivante, idéalement en lecture seule, pendant au moins 24 heures comme votre rollback. Avant que tout cela ne touche la production, faites une bascule d'essai complète en staging contre des données à l'échelle de la production, car un changement qui prend deux secondes sur un portable peut prendre des heures sur du volume réel.

Des idées opérationnelles chaque semaine

Rejoignez les dirigeants d’entreprises de services qui reçoivent chaque semaine une idée concrète sur les opérations, l’automatisation et la croissance.

Nous vérifions que vous êtes humain. Vous pourrez envoyer dans un instant.

Pas de spam. Désabonnement à tout moment.

Vous êtes inscrit ! Surveillez votre boîte de réception pour le prochain numéro.

Où cela s'inscrit dans notre façon de travailler

Aucune de ces étapes n'est difficile isolément. Le risque réside dans leur séquencement correct, savoir sur quelle phase vous pouvez vous arrêter en sécurité, et avoir un rollback qui fonctionne vraiment sous pression. C'est exactement le genre de travail pour lequel nos sprints à périmètre fixe de 30 jours sont conçus : une migration clairement définie, planifiée en expand-migrate-contract, avec le runbook de backfill, validation et bascule écrit et répété avant que quoi que ce soit ne soit livré.

Si vous migrez entièrement hors d'un ancien système plutôt que de remodeler l'actuel, les mêmes principes pilotent un démantèlement propre : double exécution, prouver le nouveau chemin, puis retirer l'ancien selon un calendrier documenté. Et si vous préférez que quelqu'un porte la stratégie globale de données et d'infrastructure à travers plusieurs de ces changements, c'est le terrain du CTO à temps partagé. Dans tous les cas, l'objectif est le même que celui de tout cet article : rendre la migration ennuyeuse.

Prêt à livrer ?

Dites-nous où vous bloquez. Nous l’examinons et vous envoyons une recommandation ciblée sous un jour ouvré.

Questions fréquentes

Puis-je faire une migration sans interruption en un seul déploiement ?

Non, pas pour quoi que ce soit au-delà d'un changement purement additif. Une migration sûre qui modifie ou supprime une colonne ou une table demande au moins deux cycles de release : un pour ajouter la nouvelle structure, écrire en double et remplir, et un plus tard pour basculer les lectures et supprimer l'ancienne structure. Tout l'intérêt est de garder l'ancien code fonctionnel contre le nouveau schéma pendant le recouvrement, ce qu'un déploiement atomique unique ne peut pas garantir.

La double écriture doit-elle vivre dans l'application ou dans les déclencheurs de base ?

Préférez la couche applicative dans la plupart des cas. Les doubles écritures explicites apparaissent dans vos traces et journaux, donc quand les deux copies divergent vous pouvez déboguer avec les outils d'observabilité que vous utilisez déjà. Les déclencheurs gardent la logique hors de votre code mais s'exécutent à l'intérieur de la base où votre traçage normal ne peut pas les voir, ce qui rend les incidents bien plus durs à diagnostiquer. Pour les écritures critiques en atomicité, routez via un outbox transactionnel ou une file pour que la divergence ne puisse pas se produire silencieusement.

Comment vérifier que les anciennes et nouvelles données concordent vraiment ?

Ne vous fiez pas aux comptes de lignes. Utilisez des sommes de contrôle ou des hachages sur vos tables critiques plus des contrôles d'invariants sur des lignes échantillonnées, car les comptes peuvent concorder alors que les contenus diffèrent. Si votre app lit déjà depuis les deux copies pour certaines requêtes, ajoutez une comparaison en temps réel qui signale les écarts. Gardez la double écriture active et réconciliez pendant au moins un cycle métier complet après avoir basculé les lectures avant de faire confiance à la nouvelle copie seule.

Pourquoi un changement de schéma rapide cause-t-il quand même une panne ?

Presque toujours la contention de verrous, pas le DDL lui-même. Un ALTER qui a besoin d'un verrou exclusif peut caler derrière une transaction de longue durée ou une session ouverte oubliée, et chaque requête arrivant après s'aligne derrière le verrou, transformant un changement rapide en blocage à l'échelle du service. Fixez un lock_timeout court pour que le DDL bloqué échoue vite, utilisez CREATE INDEX CONCURRENTLY sur Postgres, et éliminez les requêtes longues égarées avant de commencer.

Et les tables trop grosses pour un ALTER normal ?

Utilisez un outil de changement de schéma en ligne qui construit une copie fantôme et l'échange. Sur MySQL, gh-ost ou pt-online-schema-change copient les données par morceaux et échangent atomiquement pendant que l'original reste utilisable. Sur Postgres, pgroll gère le motif expand-contract avec des vues conscientes de la version, ou pg_osc gère les gros changements ponctuels. Vous devez toujours comprendre le verrouillage ; les outils gèrent le fichier et l'exécution, mais lock_timeout, CONCURRENTLY et les petites étapes sûres restent de votre ressort.

À quoi ressemble un vrai plan de rollback ?

Le rollback devient plus facile plus vous êtes tôt dans les phases. Depuis la phase expand, la nouvelle colonne est additive et inutilisée pour les lectures, donc vous retirez simplement le code de double écriture et livrez. Au milieu de la bascule, repositionnez le drapeau de lecture sur l'ancienne colonne, gardez la double écriture active, et enquêtez sans perdre les nouvelles données. Lors de la relocalisation vers une nouvelle base, gardez la source vivante et en lecture seule pendant au moins 24 heures après la bascule afin de pouvoir rediriger le trafic en arrière si quelque chose surgit.