{"canonical_url":"https://engineer.company/da/glossary/change-data-capture/","content_markdown":"# Change data capture\n\n## Hvad det er\n\nChange data capture, som regel forkortet CDC, betyder at aflæse ændringerne i en\ndatabase og sende dem videre til andre systemer, efterhånden som de sker. Hver\nindsættelse, opdatering og sletning bliver til en hændelse, som noget andet kan\nreagere på: en rapportkopi, der holder sig ajour, et søgeindeks, en anden\ntjeneste, der skal vide, at en ordre er afgivet. Databasen, hvor ændringen sker,\ner fortsat den autoritative kilde, og de andre systemer følger efter.\n\nDer er groft sagt to måder at finde ændringerne på. Den enkle er at spørge: med\nfå minutters mellemrum kører en forespørgsel efter rækker, hvis tidsstempel for\nseneste opdatering er nyere end sidste kørsel. Den anden er at læse databasens\negen optegnelse over, hvad den har ændret. PostgreSQL fører den optegnelse i sin\nwrite-ahead-log (WAL), og dokumentationen beskriver princippet bag: ændringer i\ndatafilerne skrives først, når de poster, der beskriver dem, ligger sikkert på\npermanent lager. Fordi loggen allerede rummer hver ændring i den rækkefølge, den\nskete, giver den en komplet historik, uden at tabellerne skal forespørges\noverhovedet. Det er den anden fremgangsmåde, logbaseret CDC, man som regel mener\nmed udtrykket i dag.\n\nI PostgreSQL hedder mekanismen logisk dekodning. Dokumentationen beskriver den\nsom den proces, der trækker alle varige ændringer i en databases tabeller ud i\net sammenhængende format, som kan læses uden kendskab til databasens indre\ntilstand. Tre dele arbejder sammen. Serveren skal skrive detaljer nok i loggen,\nog det styres af indstillingen `wal_level`: standardværdien, `replica`, rækker\ntil at kopiere data mellem servere, mens `logical` tilføjer det, dekodningen har\nbrug for. En replikeringsslot står for én strøm af ændringer fra én database,\nsom afspilles for en klient i den rækkefølge, de blev foretaget, og den husker,\nhvor langt klienten er nået. Et output-plugin omsætter loggens interne poster\ntil det format, klienten ønsker.\n\nDe færreste skriver selv klienten. Debezium beskriver sig selv som en samling\nkildekonnektorer til Apache Kafka Connect, hvor hver enkelt læser ændringer fra\nen bestemt database gennem databasens egne CDC-funktioner. Konnektoren til\nPostgreSQL læser enten gennem `pgoutput`, som Debeziums dokumentation omtaler\nsom det indbyggede output-plugin i PostgreSQL, eller gennem `decoderbufs`, et\nplugin, som Debezium-fællesskabet vedligeholder. Debezium kan også køre som et\nbibliotek i en JVM-applikation eller som Debezium Server, der sender\nændringshændelserne videre til systemer som Amazon Kinesis, Google Cloud Pub/Sub\nog Apache Pulsar.\n\n## Hvorfor det betyder noget\n\nPolling ser billigere ud, og for en lille tabel, der sjældent ændres, er det\nofte rigtigt. Debeziums dokumentation opregner, hvad læsning af loggen kan, som\npolling ikke kan. Den fanger hver ændring, hvor en forespørgsel kun ser rækkens\ntilstand i det øjeblik, den kører, så en række, der blev ændret tre gange mellem\nto kørsler, kun dukker op én gang. Den fanger sletninger, hvor en slettet række\nbare mangler i næste resultat. Den kræver ingen ekstra kolonne i datamodellen,\nsom et »Last Updated«-felt, som al kode, der skriver til tabellen, skal huske at\nudfylde. Den kan tage rækkens tidligere tilstand med og metadata, for eksempel\nhvilken transaktion der foretog ændringen. Og den leverer ændringerne med meget\nlille forsinkelse uden den CPU-belastning, som hyppig polling giver: for\nPostgreSQL og MySQL ligger forsinkelsen ifølge Debezium i millisekundområdet.\n\nDet andet argument er, at databasen og de beskeder, andre systemer modtager,\nsiger det samme. Debezium nævner dobbeltskrivning (dual writes) som den anden\nfremgangsmåde, den sammenligner sig med: applikationen gemmer en ændring i sin\ndatabase og sender bagefter en besked om den. Stopper processen mellem de to\ntrin, er databasen og beskedstrømmen uenige, og intet registrerer, hvilken af\ndem der tager fejl. CDC fjerner den anden skrivning. Applikationen gemmer én\ngang, og beskeden udledes af det, der faktisk blev gemt. Outbox-mønstret går et\nskridt videre: applikationen skriver selve beskeden i en outbox-tabel i samme\ntransaktion som ændringen, og CDC udgiver rækkerne i den tabel. Debeziums Outbox\nEvent Router beskriver formålet som at undgå uoverensstemmelser mellem en\ntjenestes egen tilstand og de hændelser, som andre tjenester modtager.\n\nDet tredje argument er rækkefølgen. En replikeringsslot udleverer ændringerne i\nden rækkefølge, de blev foretaget på kildeserveren, samlet efter den\ntransaktion, der foretog dem, som eksemplet nedenfor viser. En forbruger, der\nanvender dem i den rækkefølge, genskaber den samme tilstand trin for trin. For\nen ETL-indlæsning gør det den inkrementelle indlæsning ærlig: et natligt job kan\ntage præcis de ændringer, der er kommet siden sidste kørsel, sletninger\nmedregnet, i stedet for at genindlæse hele tabeller eller stole på en\ntidsstempelkolonne, som én kodesti glemte at opdatere.\n\n## Sådan ser det ud i praksis\n\nDet mindste eksempel, der virker, bruger kun PostgreSQL. Det kræver `wal_level =\nlogical` i serverens konfiguration, hvilket først træder i kraft efter en\ngenstart, og en ledig replikeringsslot; `max_replication_slots` er som standard\n10. Sessionen nedenfor kører som superbruger, ligesom dokumentationens eget\neksempel, og bruger `test_decoding`, output-pluginnet fra det eksempel, der\nskriver hver ændring ud som en tekstlinje.\n\n```sql\n-- postgresql.conf: wal_level = logical (træder i kraft efter en genstart)\nSELECT * FROM pg_create_logical_replication_slot('shop_cdc', 'test_decoding');\n\nBEGIN;\nINSERT INTO orders (id, status) VALUES (42, 'pending');\nINSERT INTO outbox (id, event) VALUES (7, 'ordre 42 afgivet');\nCOMMIT;\n\nSELECT data FROM pg_logical_slot_peek_changes('shop_cdc', NULL, NULL);\n-- BEGIN 10301\n-- table public.orders: INSERT: id[integer]:42 status[text]:'pending'\n-- table public.outbox: INSERT: id[integer]:7 event[text]:'ordre 42 afgivet'\n-- COMMIT 10301\n\nSELECT data FROM pg_logical_slot_get_changes('shop_cdc', NULL, NULL);\n-- de samme fire rækker; kaldet bruger dem op, så et nyt kald giver ingen\n\nSELECT pg_drop_replication_slot('shop_cdc');\n```\n\nOrdren og dens outbox-besked kommer ud sammen, inden for den transaktion, der\nskrev dem. `pg_logical_slot_peek_changes` læser uden at flytte slotten og giver\nderfor de samme rækker ved næste kald, mens `pg_logical_slot_get_changes` bruger\ndem op. En `CREATE TABLE` ville kun give et tomt `BEGIN` og `COMMIT`, fordi\nlogisk dekodning ikke tager DDL med. Den sidste linje er den vigtigste: en slot,\nder bliver glemt, bliver ved med at holde på serverens ressourcer.\n\nI produktion er det Debezium, der læser. Første gang konnektoren til PostgreSQL\nstarter, tager den et konsistent øjebliksbillede (snapshot) af de tabeller, den\nopfanger ændringer fra, og streamer derefter ændringer fra det punkt, hvor\nøjebliksbilledet blev taget. Standardværdien for `snapshot.mode`, `initial`,\ntager kun øjebliksbilledet, når der ikke findes gemte offsets, så en genstart\nfortsætter fra den senest registrerede position. Hver hændelse har et `before`-\nog et `after`-billede af rækken, en `source`-blok, et tidsstempel og en\n`op`-kode: `c` for oprettelse, `u` for opdatering, `d` for sletning, `r` for en\nrække læst under et øjebliksbillede og `t` for truncate. Efter en sletning\nsender konnektoren desuden en tombstone, en hændelse med samme nøgle og værdien\nnull, så Kafkas log compaction kan fjerne de tidligere beskeder med den nøgle.\n\nBegge mønstre fra denne artikel går igen på virksomhedens egne sider.\nMellem 2022 og 2024\n[udviklede grundlæggeren 600 ETL/ELT-pipelines i PL/pgSQL](/da/portfolio/engineered-600-pl-pgsql-etl-elt-pipelines/)\npå tværs af flere udviklings- og produktionsmiljøer med PostgreSQL,\nherunder inkrementelle indlæsninger med CDC og tidsstempelbaserede\ndeltaer. Noten\n[At sælge den sidste billet præcis én gang](/da/notes/selling-limited-stock-without-overselling/)\nbygger et lynudsalg op omkring en outbox: hvert trin lægger sin\nbesked i outboxen i samme transaktion som ændringen, change data\ncapture udgiver outboxen, og fordi en besked kan komme mere end én\ngang, er hver forbruger idempotent, med ordren som nøgle.\n\n## Hvor det går galt\n\n**Intet sætter loft over, hvad en slot må gemme.** En slot holder på hvert\nstykke write-ahead-log, som dens forbruger ikke har bekræftet, og\nstandardindstillingerne i PostgreSQL sætter ingen grænse for det.\n`max_slot_wal_keep_size` er `-1`, så slots må beholde en ubegrænset mængde log,\nog `idle_replication_slot_timeout` er `0`, hvilket slår ugyldiggørelsen af\nubrugte slots fra. En konnektor, der gik i stå under en mislykket udrulning, kan\nderfor fylde disken længe efter, at alle har glemt den. Hold øje med\n`pg_replication_slots` for slots, der ikke længere er aktive, og sæt\n`max_slot_wal_keep_size` til det, disken kan bære, vel vidende at en forbruger,\nder kommer længere bagud end det, måske ikke kan fortsætte. Vejen tilbage går\ngennem en ny slot, og en ny slot begynder i nuet: Debezium advarer om, at en\nslot, der slettes og oprettes igen, i det stille kan springe hændelserne imellem\nover, så tag et nyt øjebliksbillede bagefter.\n\n**En stille tabel holder loggen tilbage.** Debeziums dokumentation beskriver en\nmere lumsk variant. En slot hører til én database, og konnektoren rykker kun sin\nbekræftede position frem, når den ser ændringer, den opfanger. Ændres de\nopfangede tabeller sjældent, mens andre tabeller eller andre databaser på samme\nserver skriver meget, flytter positionen sig næsten ikke, og loggen bag den\nbliver ved med at vokse. Løsningen er et hjerteslag (heartbeat):\n`heartbeat.interval.ms` får konnektoren til at sende heartbeat-hændelser med et\nfast interval, og `heartbeat.action.query` lader den skrive jævnligt til en\nlille tabel i den opfangede database. Tabellen skal være med i den publikation\n(publication), som konnektoren læser, så slotten rykker frem, også når der\nellers ikke sker noget.\n\n**Forbrugerne går ud fra, at hver ændring kommer én gang.** En logisk slot\nudsender hver ændring én gang under normal drift, men dens position gemmes kun\nved checkpoints, så efter et nedbrud kan den vende tilbage til et tidligere\npunkt og sende de seneste ændringer igen. PostgreSQL-dokumentationen overlader\nfølgerne til klienten. En forbruger, der lægger hvert beløb til en løbende sum,\ntæller de ændringer to gange. Gør hver forbruger idempotent: anvend hver ændring\nsom en upsert med rækkens primærnøgle som nøgle, eller registrér, hvilke\nhændelser der allerede er behandlet, så en ny levering ikke ændrer noget.\n\n**Opdateringer og sletninger kommer uden de gamle værdier.** Hvad en hændelse\nfor en opdatering eller sletning fortæller om den tidligere række, afhænger af\ntabellens replica identity. Med `REPLICA IDENTITY DEFAULT` indeholder Debeziums\nhændelser højst de tidligere værdier af primærnøglen, og for en tabel uden\nprimærnøgle sender konnektoren slet ingen hændelser for opdateringer eller\nsletninger. `REPLICA IDENTITY FULL` lægger alle tidligere kolonner i `before`,\nmen det koster: PostgreSQL-dokumentationen bemærker, at det øger mængden af WAL,\nisær når der køres mange `UPDATE`- og `DELETE`-sætninger. Giv hver opfanget\ntabel en primærnøgle, og skift kun til `FULL` på de tabeller, hvis forbrugere\nhar brug for de gamle værdier.\n\n## Læs mere\n\n- [Debezium Features](https://debezium.io/documentation/reference/stable/features.html)\n  — hvad logbaseret CDC fanger, som polling og dobbeltskrivning overser, plus\n  øjebliksbilleder, filtre og maskering.\n- [Debezium connector for PostgreSQL](https://debezium.io/documentation/reference/stable/connectors/postgresql.html)\n  — output-plugins, øjebliksbilleder, hændelsernes format, replica identity og\n  diskplads til WAL.\n- [Logical Decoding Concepts](https://www.postgresql.org/docs/current/logicaldecoding-explanation.html)\n  — replikeringsslots, output-plugins, og hvorfor en slot, som ingen bruger,\n  skal slettes.\n- [Logical Decoding Examples](https://www.postgresql.org/docs/current/logicaldecoding-example.html)\n  — at oprette en slot, kigge på og bruge ændringer og slette slotten igen.\n- [Replication (server configuration)](https://www.postgresql.org/docs/current/runtime-config-replication.html)\n  — `max_replication_slots`, `max_slot_wal_keep_size` og\n  `idle_replication_slot_timeout`.\n- [Outbox Event Router](https://debezium.io/documentation/reference/stable/transformations/outbox-event-router.html)\n  — outbox-mønstret, og hvordan Debezium sender outbox-rækker videre til topics.\n\n\u003chttps://engineer.company/da/glossary/change-data-capture/\u003e\n","date_modified":"2026-11-08T02:22:23Z","description":"Hvordan change data capture læser databasens log over ændringer og sender dem videre, hvorfor det slår polling, og fire måder, det går galt på i det stille.","formats":{"gemtext":"https://engineer.company/da/glossary/change-data-capture/index.gmi","gopher":"https://engineer.company/da/glossary/change-data-capture/gophermap","html":"https://engineer.company/da/glossary/change-data-capture/","json":"https://engineer.company/da/glossary/change-data-capture/index.json","markdown":"https://engineer.company/da/glossary/change-data-capture/index.md","pdf":"https://engineer.company/da/glossary/change-data-capture/index.pdf"},"kind":"page","language":"da","title":"Hvad er change data capture?","url":"https://engineer.company/da/glossary/change-data-capture/","version":1}