Hoe ga je om met databasemigraties in CI/CD?

Question

Accepted Answer

**Databasemigraties** (schemawijzigingen) zijn een van de lastigste onderdelen van CI/CD — anders dan stateless applicatiecode bevatten databases **state** die niet zomaar kan worden vervangen of teruggerold. Migraties zorgvuldig afhandelen (automatisering, achterwaartse compatibiliteit, veilige patronen) is essentieel voor betrouwbare deployments.

## Waarom het belangrijk is

```text
App code is stateless (replace it, roll back freely). DATABASES hold STATE:
  → can't just "roll back" a migration that dropped a column or transformed data
    (the data may be gone) → rollbacks are risky/impossible for destructive changes
  → during deployment, OLD and NEW app code may run SIMULTANEOUSLY (rolling deploy) —
    both must work with the database schema at that moment
→ Schema changes need careful coordination with code deployment.
```

## Migraties automatiseren in de pipeline

```text
→ Migrations defined as CODE (versioned migration files; Flyway, Liquibase, ORM tools)
→ Run migrations as a pipeline STEP (apply pending migrations on deploy)
→ Migrations are versioned and applied in order, idempotently
→ Test migrations in staging before production
```

## Veilige migratie-patronen (achterwaartse compatibiliteit)

```text
KEY PRINCIPLE: make migrations BACKWARD-COMPATIBLE so old AND new code both work during
the transition. Use the EXPAND-CONTRACT (parallel change) pattern:
  1. EXPAND → add the new schema (e.g. add a new column) — old code still works
  2. MIGRATE → deploy code that writes to both / reads new; backfill data
  3. CONTRACT → once all code uses the new schema, remove the old (in a LATER deploy)
→ NEVER drop/rename in the same deploy that needs it gone — split across deploys.
→ This enables zero-downtime deploys and safe rollbacks.
```

## Waarom het belangrijk is

Begrip van hoe je databasemigraties in CI/CD afhandelt is belangrijk omdat **migraties een van de moeilijkste, riskantste onderdelen van geautomatiseerde implementatie zijn**, dus het is waardevolle praktische kennis voor betrouwbare delivery.

De kernuitdaging is dat, anders dan stateless applicatiecode (die vrijelijk kan worden vervangen en teruggerold), **databases state bevatten** — dus een migratie die een kolom verwijdert of gegevens transformeert **kan niet zomaar worden teruggerold** (de gegevens kunnen weg zijn), waardoor destruktieve wijzigingen risicovol of onomkeerbaar zijn, en tijdens rolling deployments **oude en nieuwe code tegelijk draaien**, beide moeten werken met het schema op dat moment.

Dit vereist dat schemawijzigingen zorgvuldig worden gecoördineerd, anders dan de rest van CI/CD.

Begrip van hoe je **migraties automatiseert** (ze als versiebeheerde code definieert via tools zoals Flyway, Liquibase of ORM migraties, ze als pipelinestap toepast in volgorde en idempotent, en eerst test in staging) brengt migraties veilig in de geautomatiseerde pipeline.

Het meest belangrijk is om **veilige migratiepatronen** te begrijpen — migraties **achterwaarts compatibel** maken zodat oude en nieuwe code beide werken tijdens de overgang, het **expand-contract (parallel change) patroon** gebruiken (expand: nieuw schema toevoegen zonder oude code te breken; migrate: code overzetten en gegevens backfill; contract: oud schema verwijderen in een latere deploy) en **nooit verwijderen/hernoemen in dezelfde deploy waarin het nodig is** — is de sleutelkunst die **zero-downtime deployments en veilige rollbacks** mogelijk maakt ondanks de stateful aard van databases.

Dit is echt lastige, belangrijke real-world kennis die degenen onderscheidt die databasewijzigingen veilig kunnen implementeren van degenen die outages of gegevensverlies veroorzaken.

Omdat databasemigraties een moeilijk, risicovol, onvermijdelijk onderdeel zijn van het implementeren van toepassingen met databases, en omdat ze zorgvuldig afhandelen (automatisering plus achterwaarts-compatibele expand-contract patronen) essentieel is voor betrouwbare, zero-downtime deployments, is het begrijpen van databasemigraties in CI/CD waardevolle, praktisch-belangrijke kennis — gericht op een van de lastigste aspecten van continuous delivery en weerspiegelend van de volwassenheid die nodig is om stateful toepassingen veilig in te zetten.