Hur hanterar du databasmigreringar i CI/CD?

Question

Accepted Answer

**Databasmigreringar** (schemaförändringar) är en av de knepigaste delarna av CI/CD — till skillnad från tillståndslös applikationskod innehåller databaser **tillstånd** som inte helt enkelt kan ersättas eller återställas. Att hantera migreringar noggrant (automatisering, bakåtkompatibilitet, säkra mönster) är väsentligt för pålitliga distributioner.

## Varför databasmigreringar är svåra

```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.
```

## Automatisera migreringar i 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
```

## Säkra migreringmönster (bakåtkompatibilitet)

```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.
```

## Varför det spelar roll

Att förstå hur man hanterar databasmigreringar i CI/CD är viktigt eftersom **migreringar är en av de svåraste och mest riskfyllda delarna av automatiserad distribution**, så det är värdeful praktisk kunskap för pålitlig leverans.

Huvudutmaningen är att, till skillnad från tillståndslös applikationskod (som kan ersättas och återställas fritt), **databaser innehåller tillstånd** — så en migrering som släpper en kolumn eller transformerar data **kan inte helt enkelt återställas** (data kan vara borta), vilket gör destruktiva ändringar riskfyllda eller irreversibla, och under rullande distributioner **körs gammal och ny kod samtidigt**, både behöver fungera med schemat vid det ögonblicket.

Detta kräver att schemaändringar koordineras noggrant, till skillnad från resten av CI/CD.

Att förstå hur man **automatiserar migreringar** (definierar dem som versionerad kod via verktyg som Flyway, Liquibase eller ORM-migreringar, kör dem som ett pipelinesteg tillämpat i ordning och idempotent, och testar i staging först) för migreringar in i den automatiserade pipelinen säkert.

Viktigast av allt är att förstå **säkra migreringmönster** — göra migrieringar **bakåtkompatibla** så gammal och ny kod både fungerar under övergången, använd **expand-contract-mönstret (parallell ändring)** (expand: lägg till nytt schema utan att bryta gammal kod; migrate: övergång kod och fylla på data; contract: ta bort gammalt schema i en senare distribution) och **aldrig släppa/byta namn i samma distribution som behöver det borta** — är nyckelfärdigheten som möjliggör **noll-driftstopp-distributioner och säkra återställningar** trots databasers tillståndsbaserade natur.

Detta är genuint knepig, viktig verklig kunskap som skiljer dem som kan distribuera databasändringar säkert från dem som orsakar avbrott eller dataförlust.

Since databasmigreringar är en svår, riskfylld, oundviklig del av distribution av applikationer med databaser, och eftersom att hantera dem noggrant (automatisering plus bakåtkompatibla expand-contract-mönster) är väsentligt för pålitlig, noll-driftstopp-distribution, är förståelse för databasmigreringar i CI/CD värdefull, praktisk viktig kunskap — adresserar en av de knepigaste aspekterna av continuous delivery och reflekterar mogenheten som behövs för att distribuera tillståndsberoende applikationer säkert.