Een databaseschema wijzigen terwijl applicaties schrijven en lezen, vraagt om meer dan een migratiescript. Je leest hoe migraties, versiecompatibiliteit, dataverwerking en herstelstrategieën samen bepalen of een schemawijziging beheersbaar blijft.
Databasewijzigingen behandelen als onderdeel van applicatiedeployments
Je past een schemawijziging niet alleen toe op de database. Die raakt alles wat met je database praat: applicatie, achtergrondprocessen, rapportage, integraties, dat soort dingen. Dus, als code en database niet samen zijn aangepast, heb je al snel fouten. Zelfs als het individueel werkt, als contract helpt het niet als beide niet op elkaar aansluiten.
Breng goed in beeld welke processen en applicaties met het betreffende deel van het schema werken voordat je iets verandert. Zet niet alleen webapps op je lijstje, maar juist ook workers, schedulers, exporttools en trouwens de grotere rapportages niet vergeten. Vooral processen die lang draaien blijven vaak onopgemerkt; een worker uit een eerdere release kan nog actief zijn terwijl jouw database al vernieuwd is. Soms draaien oude en nieuwe applicatieversies tegelijk, zeker bij gefaseerde deploys.
Maak duidelijk welke versie van het schema op elk moment nodig is, en welke applicatieversies hiermee overweg kunnen. Dat dwingt een werkbare migratievolgorde af: eerst uitbreiden met compatibele aanpassingen, daarna code die nieuwe dingen gebruikt, en pas daarna het opschonen van wat je niet meer nodig hebt. En nee, dat een migratie lokaal of op test gewoon werkt, zegt niks over productie. Productiedata, echte belasting en transacties kunnen de uitkomst totaal veranderen. transacties
Door schemawijzigingen als deployment issue te behandelen, zie je afhankelijkheden op tijd. Denk niet dat het schema een passieve laag is; het is een actief onderdeel, net als je applicatiecode. Je beheert de levenscyclus van beide samen. Werk je met PHP? Bekijk PHP-ontwikkeling. Ook bij een webshop moeten database en applicatiecode samen worden beheerd.
Expand-contract-migraties voor wijzigingen zonder downtime
Met een expand-contract-aanpak splits je een grotere wijziging op in aparte stappen. In de eerste ronde, de expand, voeg je een nieuwe kolom, tabel of index toe zonder direct het oude te slopen. Vaak is dat een nullable kolom of een extra index. Je oude code draait gewoon verder, terwijl de database al voorbereid is op nieuwe code.
Daarna pas je de applicatie aan zodat die werkt met de nieuwe structuur. Stel je vervangt naam door weergavenaam: de code kan nu, tijdelijk, beiden gebruiken en in allebei schrijven. Na het kopiëren van oude naar nieuwe waarden check je of de nieuwe kolom goed gevuld is. Zodra geen enkele actieve app of worker de oude kolom nog leest of schrijft, begin je aan de contract-fase: schoon op, haal het oude pad weg, verwijder de oude kolom.
Dubbel schrijven klinkt overzichtelijk, maar dat kan alsnog voor gedonder zorgen. Je loopt risico dat gegevens niet synchroon blijven als ergens een bug zit. Bepaal dus welke kolom centraal is, hoe je verschillen opspoort en wanneer je het parallel schrijven stopt. Zet als nodig een feature flag in, daarmee kan je leesgedrag per omgeving of per instantie omzetten, maar hou je focus op integriteitscontrole.
Het zijn meer stappen en je hebt tijdelijk meer opslag en meer code. Maar, elke stap levert wel een werkende situatie op. Dat telt mee als je geen alles-in-een deploy doet of verschillende servers niet tegelijk kunt vernieuwen.
Migraties versioneren en veilig uitvoerbaar maken
Elk migratiebestand beschrijft een concrete stap van het ene schema naar het volgende. Geef elke migratie een uniek volgnummer, bewaar de bestanden in je versiebeheersysteem, bij de juiste codeversie natuurlijk. Houd in een database-tabel bij welke migratiestappen zijn uitgevoerd. Zo weet je exact welke migraties nog moeten en voorkom je dat dezelfde wijziging onnodig opnieuw draait.
Houd migraties zo klein mogelijk. Maak liever meerdere aparte scripts voor dingen als tabellen hernoemen, data aanpassen, constraints wijzigen. Grote alles-in-een scripts zijn onhandig te testen en terug te draaien. Check goed hoe de database transacties met DDL verwerkt. Sommige wijzigingen zijn transactioneel, andere niet. Soms grijpt de database ineens een commit door, of gelden speciale beperkingen, verschilt per systeem en versie.
Herhaalbaarheid is wat anders dan omkeerbaarheid. Een herhaalbare migratie stopt niet met fouten als je hem opnieuw start, doordat hij bijvoorbeeld checkt of een kolom al bestaat. Maar herstel naar een vorige staat? Lukt alleen als je data niet kwijt bent, na het weggooien van een kolom is die data weg, die DDL draai je niet zomaar terug.
Start migraties altijd via een expliciet deployproces. Wie mag een migratie starten? Een app die schemawijzigingen doet bij elke start, dat wil je niet, je loopt risico dat twee instanties tegelijk dingen proberen of dat je blokkeert. Bewaar naast status per migratie ook de log-uitvoer van je proces. Bij fouten kun je beter zien wat er precies al gedaan is, en wat niet.
Compatibiliteit tussen oude en nieuwe applicatieversies
Als je een rolling deployment draait, werken oude en nieuwe applicatieversies vaak tegelijk met dezelfde database. Dus een schemawijziging moet niet alleen de allernieuwste versie blij maken maar ook nog oudere code ondersteunen. Verwijder je te snel een kolom, dan krijg je fouten zodra een oud proces daarop leunt. Sommigen denken dat alleen de hoofdapp licht telt, maar vergeet ook workers, cronjobs en message consumers niet: ze kunnen allemaal oude queries uitvoeren.
Zet per stap op een rij: welke appversie werkt met welk schema, waar is overlap, waar zitten blockers? Was je schema uitgebreid, dan moet de oude code kunnen werken met nieuwe kolommen, liefst nullable of met een default. Maar let op, een defaultwaarde kan zich anders gedragen bij bestaande data dan bij nieuwe rijen. Test fiks door: inserts door oude én nieuwe code.
Bij het verwijderen van data-elementen wacht je tot alle code overschakelt en geen enkele query de kolom nog gebruikt. Pas daarna ruim je op. Test vanuit je CI niet alleen ORM-migraties maar kijk kritisch naar alle SQL in rapporten, scripts en dashboards. Vaak staan daar nog verwijzingen naar oude velden. Contracttests of integratietests leggen die verwachtingen expliciet vast.
Grote datamigraties uitvoeren met gecontroleerde backfills
Kleine schemawijziging? Vaak snel klaar. Maar als je miljoenen bestaande rijen wilt vullen of aanpassen, kan dat je database flink belasten. Zo’n backfill over veel records kan lang duren, flink wat locks zetten en je logging of replicatie onder druk zetten. Pak daarom backfills batch-gewijs aan. Werk op primaire sleutelreeksen, commit na elke batch, dan kunnen andere transacties tussendoor hun werk doen en kun je na haperen weer verder op het laatst bereikte punt.
Maak de update idempotent. Je mag zonder risico’s dezelfde batch nog eens uitvoeren, zonder dat data dubbel of fout weggeschreven wordt. Check bijvoorbeeld alleen rijen waar de nieuwe kolom leeg is. Houd je progressie vast, liefst in een checkpoint die niet verloren gaat bij een crash.
Passen de batchgrootte en de snelheid bij wat je database aankan? Stem af op metrics als latentie, I/O en eventuele replicatie. Een backfill in piekuren kan je hele systeem beïnvloeden, waar een nachtelijke run soepel loopt. Let op als tijdens de backfill ook live writes plaatsvinden: als alleen de oude kolom nog wordt beschreven, duurt het niet lang voor je nieuwe kolom achterloopt. Verplicht je applicatie beide velden te vullen, totdat alles over is.
Valideer achteraf niet alleen dat je script einde-melding heeft gegeven, maar controleer op daadwerkelijk complete, correcte data. Vergelijk aantallen, steekproefsgewijs inhoud of geldigheid van constraints. Een zelfstandige validatie kan een groot verschil maken bij complexe transformatiestappen, zodat je geen foute basis legt voor verder gebruik.
Locking, indexen en de belasting van DDL-wijzigingen
Elke wijziging aan het databaseschema draait mee in de normale transacties. Je kunt zomaar zien dat een banale kolomtoevoeging weinig doet, waar een typewijziging of een strengere constraint juist langdurige locks veroorzaakt of tabellen herschrijft. Vergeet niet: wat snel lijkt op een lege testdatabase, kan in productie een volle minuut alles blokkeren als er zware queries lopen.
Check voor elke command welke lock er gebruikt wordt, hoe lang hij actief blijft, en of je database het daadwerkelijk online uitvoert. Sommige systemen kunnen een index online opbouwen, waardoor schrijfacties nagenoeg doorgaan, maar let op: het maakt het proces niet per se foutloos of snel. Haakt er iets af, dan heb je kans op een half-afgebouwde index die je nog moet opsporen.
Stel waar mogelijk een korte locktimeout in: beter dat een migratie gecontroleerd faalt dan dat alles in de wachtrij belandt. Trouwens, een timeout is geen wonderoplossing. Denk erover na hoeveel pogingen je toelaat en of een vorige poging soms restschade heeft achtergelaten. Plan je zwaardere DDL buiten de piek, maar vertrouw daar niet blind op: geen enkel rustig tijdstip is een garantie tegen locking.
Monitor de migratie actief: kijk naar wachtrijen, reads, writes, CPU, I/O, en vertrouw nooit alleen op het succes van een enkele query. Met vastgelegde exit-criteria heeft een beheerder helder wanneer stoppen beter is dan doorzetten, zelfs bij kleine schijnbaar onschuldige wijzigingen. indexen
Rollbackstrategieën wanneer een migratie problemen veroorzaakt
Terugdraaien? Dat is soms twee regels, soms nagenoeg onmogelijk. Een kolom toevoegen is meestal simpel ongedaan te maken als die verder niet gebruikt is. Maar zaken als samenvoegen van data of het verwijderen van kolommen vernielen vaak details die je niet meer terugtovert. Dus, check op voorhand of je herstel mogelijk is: herstel je met oude code, omgekeerde DDL, moet je een back-up terugzetten, of moet je misschien verbeteren met een correctiescript?
Met expand-contract-migraties kun je makkelijker terug naar oude code zolang je oude structuur nog bestaat, uiteraard zolang de nieuwe code niet nieuwe data geschreven heeft waar oude code niet mee overweg kan. Leg goed vast wanneer rollback kan, en test die route eens buiten productie. Als je geen beurt neemt om te oefenen, werkt het straks vast niet als het nodig is. Zie een rollback niet als "aan/uit-knop".
Gaat het echt mis bij destructieve stappen? Dan kun je soms alleen nog met een back-up of point-in-time recovery terug. Dat kost vaak meer tijd en kan transacties kwijtraken die je niet wilde verliezen. Als alternatief kun je via een handmatige correctie of tijdelijke kopie herstel uitvoeren, maar alleen als je over de juiste data beschikt. Dus, begrijp en test je herstelmethodes op voorhand, plus alle afhankelijkheden.
Is een migratie halverwege stukgelopen? Kijk eerst welke stappen zijn uitgevoerd en controleer per onderdeel (tabellen, indexen, constraints, data, migratietabel). Laat je niet verleiden het script klakkeloos opnieuw te draaien zonder te weten wat wel en niet gebeurd is. Soms is het veiliger een eigen herstelstap te maken op basis van de actuele situatie dan op een gok een theoretisch rollback-scenario uit te voeren.
Migraties testen op productieachtige data en omstandigheden
Test je migratie alleen op een kleine test- of ontwikkelomgeving? Dan controleer je feitelijk alleen of de code syntactisch klopt. Je weet helemaal niet of het werkt met veel data of typische productietoestanden. Werk met een dataset die qua grootte, spreiding, ontbrekende waarden en indexen aansluit bij productie. Neem dan ook geanonimiseerde data natuurlijk, maar zorg dat de karakteristieken overeind blijven.
Test elke relevante fase: de oude applicatieversie, het schema met extra kolommen, de uiteindelijke versie en het moment waarop oude velden echt weg zijn. Lees en schrijf in elke fase, liefst ook buiten de standaardflow om. Denk aan missende waarden, dubbele entries, afwijkende enumtypes of records die gebruikers buiten de applicatie om hebben toegevoegd.
Dwing storingen en herstel af. Stop een backfill ergens halverwege en check of het daarna door kan, zonder fouten of dubbele zekerheid. Laat een locktimeout forceren en leer wat daarvan overblijft in je database. Voor veranderingen aan data: leg niet alleen voorbeelden van eindstatus vast, maar vergelijk constraint- en aantalverschillen voor en na de migratie.
Noteer databaseversie, configuratie en migraties ('even aan denken'). Verschillen tussen lokaal, test, staging en productie beïnvloeden gedrag sterker dan je vaak denkt. Alleen als dezelfde tussenstappen ontstaan in al die omgevingen weet je echt wat een migratie doet.
Migraties volgen met logs, metrics en expliciete controlepunten
Operationeel grip houden? Dat kan alleen als je precies weet welke migratie, wanneer, door welke versie, met welk resultaat gestart of afgerond is. Bij een backfill wil je aantallen verwerken, welke sleutel als laatste klaar was, fouten per batch, niet alleen een of andere foutmelding zonder context. Sla geen rij-inhoud op in je logs, maar voldoende signaal om issues terug te zoeken.
Koppel je monitoring niet los van het echte databasegedrag. Als je progressie-log doorloopt maar de applicatie traag is, mis je belangrijke signalen. Meet dus latency, fouten, locks, schijfgebruik, replicatieachterstanden. Zet van tevoren grenzen: wanneer pauzeer je, wanneer breek je echt af? Anders heeft monitoring weinig zin als niemand weet wat te doen bij problemen.
Tussenstappen kun je alleen beoordelen langs expliciete controlepunten. Controleer tussen elke relevante fase of het resultaat klopt: kolom zichtbaar, backfill ruim voldoende gevuld, oude code niet meer actief. Automatisering kan checks uitvoeren, maar een mens moet blijven kijken naar belasting of onverwachte uitzonderingen. Je wilt niet voor een dichte deur komen staan bij een langlopende migratie.
Bewaar je logs en migratiestatus buiten de applicatie om. Kan zomaar gebeuren: proces faalt na de schemawijziging maar vóór het updaten van je statusveld. Door databaseobjecten, status en logs naast elkaar te vergelijken krijg je meer zekerheid over waar iets écht is gestopt. Voor WordPress-deploys kan WP-CLI onderdeel zijn van dat proces.
Veelgestelde vragen
Hoe voorkom ik schema drift tussen ontwikkel-, test- en productieomgevingen?
Voer alleen via versiebeheerde migraties schemawijzigingen uit. Vergelijk actieve schema’s regelmatig met het schema zoals dat hoort te zijn. Een sporadische handmatige wijziging kan voor een omgeving tijdelijk nodig zijn, maar registreer elke aanpassing direct als migratiebestand. Neem controles op verschillen tussen schema en verwachte situatie in je releaseflow. Zo voorkom je dat een deploy in test slaagt, maar in productie faalt vanwege een onzichtbare afwijking.
Hoe test ik een migratie met realistische data zonder productiegegevens te kopiëren?
Kies voor synthetische of geanonimiseerde datasets die qua grootte, verdeling en uitzonderingen lijken op je productiedata. Een kleine kopie uit testomgeving roept zelden problemen op die spelen in de echte situatie. Zorg dat je dataset veel, lange tekstvelden, lege plekken en bijzondere (rand)waarden bevat. Controleer voor het testen dat anonimisering geen gevoelige informatie achterlaat. Zo kun je echt beoordelen of de migratie productie aan zou kunnen, zonder privacy te schenden.
Wat moet ik doen als een migratie halverwege is mislukt?
Kijk eerst naar de echte toestand. Check op de database welke stappen zijn uitgevoerd, welke tabellen, indexen en constraints nu aanwezig zijn, wat je migratietabel meldt, en vergelijk dat met de logoutput. Pas daarna bepaal je hoe je verdergaat: veilig hervatten, gedeeltelijk terugdraaien of herstellen met een extra migratie. Je doet er niet goed aan scripts zomaar weer te starten of handmatig als voltooid aan te merken als het niet is gecontroleerd. Documenteer je herstelmaatregel en de uiteindelijke status.
Hoe controleer ik of een back-up bruikbaar is voor herstel na een mislukte migratie?
Test de bruikbaarheid door daadwerkelijk te herstellen in een testomgeving. Kijk niet alleen of het bestand bestaat, maar open de database en check of gegevens kloppen en of applicaties verbinding kunnen maken. Meet terugzetduur en vergelijk met het acceptabele maximum. Voor herstel op tijdstip: controleer dat je alle transactielogs hebt die nodig zijn. Je hebt niets aan alleen een succesvolle back-up, het herstelproces zelf moet betrouwbaar zijn.
Hoe voorkom ik conflicten tussen databasemigraties uit verschillende ontwikkelbranches?
Geef migraties een unieke, centraal bepaalde volgorde, en baseer branches voor samenvoegen altijd op de laatste bekende migratie(s) van elkaar. Twee mensen kunnen ongemerkt hetzelfde nummer kiezen of een logische volgorde in hun eigen branch hebben die elders niet werkt. Check bij code review de voorgestelde migratieserie vanaf een schone database. Als het botst: maak een (nieuwe) logische volgorde, herschrijf geen migraties die al live zijn geweest.
Foto: CK Seng