{"canonical_url":"https://engineer.company/nb/glossary/change-data-capture/","content_markdown":"# Change data capture\n\n## Hva det er\n\nChange data capture, som regel forkortet til CDC, betyr å lese endringene i en\ndatabase og sende dem videre til andre systemer etter hvert som de skjer. Hver\ninnsetting, oppdatering og sletting blir en hendelse som noe annet kan reagere\npå: en rapportkopi som holder seg oppdatert, en søkeindeks, en annen tjeneste\nsom må vite at en ordre er lagt inn. Databasen der endringen skjer, forblir den\nautoritative kilden, og de andre systemene følger etter.\n\nDet finnes grovt sett to måter å finne endringene på. Den enkle er å spørre: med\nnoen minutters mellomrom kjører en spørring etter rader der tidsstempelet for\nsiste oppdatering er nyere enn forrige kjøring. Den andre er å lese databasens\negen oversikt over hva den har endret. PostgreSQL fører den oversikten i\nwrite-ahead-loggen (WAL), og dokumentasjonen beskriver prinsippet bak: endringer\ni datafilene skrives først når postene som beskriver dem, er skrevet til\npermanent lagring. Fordi loggen allerede inneholder hver endring i den\nrekkefølgen den skjedde, gir den en fullstendig historikk uten at tabellene\ntrenger å leses i det hele tatt. Det er den andre tilnærmingen, loggbasert CDC,\nman som regel mener med uttrykket i dag.\n\nI PostgreSQL heter mekanismen logisk dekoding. Dokumentasjonen beskriver den som\nprosessen som trekker ut alle varige endringer i tabellene til en database i et\nsammenhengende format som kan leses uten kjennskap til databasens indre\ntilstand. Tre deler virker sammen. Loggen på serveren må inneholde nok detaljer,\nog det styres av innstillingen `wal_level`: standardverdien, `replica`, holder\nfor å kopiere data mellom servere, mens `logical` legger til det dekodingen\ntrenger. Et replikeringsspor (replication slot) står for én strøm av endringer\nfra én database, som spilles av for en klient i den rekkefølgen de ble gjort, og\nsporet husker hvor langt klienten har kommet. En output-plugin omsetter de\ninterne postene i loggen til det formatet klienten ønsker.\n\nDe fleste skriver ikke klienten selv. Debezium beskriver seg selv som en samling\nkildekonnektorer for Apache Kafka Connect, der hver enkelt leser endringer fra\nen bestemt database gjennom databasens egne CDC-funksjoner. Konnektoren for\nPostgreSQL leser enten gjennom `pgoutput`, som Debezium-dokumentasjonen omtaler\nsom den innebygde output-pluginen i PostgreSQL, eller gjennom `decoderbufs`, en\nplugin som Debezium-fellesskapet vedlikeholder. Debezium kan også kjøre som et\nbibliotek i en JVM-applikasjon eller som Debezium Server, som sender\nendringshendelsene videre til systemer som Amazon Kinesis, Google Cloud Pub/Sub\nog Apache Pulsar.\n\n## Hvorfor det er viktig\n\nPolling ser billigere ut, og for en liten tabell som sjelden endres, stemmer det\nofte. Debezium-dokumentasjonen lister opp hva lesing av loggen får til som\npolling ikke gjør. Den fanger hver endring, der en spørring bare ser tilstanden\ntil raden i det øyeblikket den kjører, så en rad som ble endret tre ganger\nmellom to kjøringer, bare dukker opp én gang. Den fanger slettinger, der en\nslettet rad rett og slett mangler i neste resultat. Den krever ingen ekstra\nkolonne i datamodellen, som et «Last Updated»-felt som all kode som skriver til\ntabellen, må huske å fylle ut. Den kan ta med den tidligere tilstanden til raden\nog metadata, for eksempel hvilken transaksjon som gjorde endringen. Og den\nleverer endringene med svært liten forsinkelse uten den CPU-belastningen som\nhyppig polling gir: for PostgreSQL og MySQL ligger forsinkelsen ifølge Debezium\ni millisekundområdet.\n\nDet andre argumentet er at databasen og meldingene som andre systemer mottar,\nsier det samme. Debezium nevner dobbeltskriving (dual writes) som den andre\ntilnærmingen den sammenligner seg med: applikasjonen lagrer en endring i\ndatabasen sin og sender deretter en melding om den. Stopper prosessen mellom de\nto stegene, er databasen og meldingsstrømmen uenige, og ingenting registrerer\nhvilken av dem som tar feil. CDC fjerner den andre skrivingen. Applikasjonen lagrer\nén gang, og meldingen avledes av det som faktisk ble lagret. Outbox-mønsteret\ngår et steg videre: applikasjonen skriver selve meldingen i en outbox-tabell i\nden samme transaksjonen som endringen, og CDC publiserer radene i den tabellen.\nOutbox Event Router fra Debezium beskriver formålet som å unngå inkonsistens\nmellom en tjenestes egen tilstand og hendelsene som andre tjenester\nmottar.\n\nDet tredje argumentet er rekkefølgen. Et replikeringsspor leverer endringene i\nden rekkefølgen de ble gjort på kildeserveren, samlet etter transaksjonen som\ngjorde dem, slik eksemplet nedenfor viser. En konsument som tar dem i bruk i den\nrekkefølgen, gjenskaper den samme tilstanden steg for steg. For en ETL-lasting\ngjør det den inkrementelle lastingen ærlig: en nattlig jobb kan ta nøyaktig de\nendringene som har kommet siden forrige kjøring, slettinger medregnet, i stedet\nfor å laste hele tabeller på nytt eller stole på en tidsstempelkolonne som én\nkodesti glemte å oppdatere.\n\n## Slik ser det ut i praksis\n\nDet minste eksemplet som fungerer, bruker bare PostgreSQL. Det krever `wal_level\n= logical` i serverkonfigurasjonen, noe som først trer i kraft etter en omstart,\nog et ledig replikeringsspor; `max_replication_slots` er 10 som standard. Økten\nnedenfor kjører som superbruker, slik dokumentasjonens eget eksempel gjør, og\nbruker `test_decoding`, output-pluginen fra det eksemplet, som skriver ut hver\nendring som en tekstlinje.\n\n```sql\n-- postgresql.conf: wal_level = logical (trer i kraft etter en omstart)\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 lagt inn');\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 lagt inn'\n-- COMMIT 10301\n\nSELECT data FROM pg_logical_slot_get_changes('shop_cdc', NULL, NULL);\n-- de samme fire radene; kallet bruker dem opp, så et nytt kall gir ingen\n\nSELECT pg_drop_replication_slot('shop_cdc');\n```\n\nOrdren og outbox-meldingen kommer ut sammen, innenfor transaksjonen som skrev\ndem. `pg_logical_slot_peek_changes` leser uten å flytte sporet og gir derfor de\nsamme radene ved neste kall, mens `pg_logical_slot_get_changes` bruker dem opp.\nEn `CREATE TABLE` ville bare gitt en tom `BEGIN` og `COMMIT`, fordi logisk\ndekoding ikke tar med DDL. Den siste linjen er den viktigste: et spor som blir\nglemt, fortsetter å holde på ressursene til serveren.\n\nI produksjon er det Debezium som leser. Første gang konnektoren for PostgreSQL\nstarter, tar den et konsistent øyeblikksbilde (snapshot) av tabellene den fanger\nendringer fra, og strømmer deretter endringer fra punktet der øyeblikksbildet\nble tatt. Standardverdien for `snapshot.mode`, `initial`, tar bare\nøyeblikksbildet når det ikke finnes lagrede offsets, så en omstart fortsetter\nfra den sist registrerte posisjonen. Hver hendelse har et `before`- og et\n`after`-bilde av raden, en `source`-blokk, et tidsstempel og en `op`-kode: `c`\nfor opprettelse, `u` for oppdatering, `d` for sletting, `r` for en rad lest\nunder et øyeblikksbilde og `t` for truncate. Etter en sletting sender\nkonnektoren i tillegg en tombstone, en hendelse med samme nøkkel og verdien\nnull, slik at log compaction i Kafka kan fjerne de tidligere meldingene med den\nnøkkelen.\n\nBegge mønstrene fra denne artikkelen finnes på selskapets egne sider. Mellom 2022 og 2024 [utviklet grunnleggeren 600 ETL/ELT-pipeliner i PL/pgSQL](/nb/portfolio/engineered-600-pl-pgsql-etl-elt-pipelines/) på tvers av flere utviklings- og produksjonsmiljøer i PostgreSQL, blant annet inkrementelle lastinger med CDC og tidsstempelbaserte deltaer. Notatet [Å selge den siste billetten nøyaktig én gang](/nb/notes/selling-limited-stock-without-overselling/) utformer et lynsalg rundt en outbox: hvert trinn registrerer meldingen sin i outboxen i samme transaksjon som endringen, change data capture publiserer outboxen, og fordi en melding kan komme mer enn én gang, er hver konsument idempotent, med ordren som nøkkel.\n\n## Hvor det går galt\n\n**Ingenting setter tak på hva et spor kan holde på.** Et spor holder på hver bit\nav write-ahead-loggen som konsumenten ikke har bekreftet, og\nstandardinnstillingene i PostgreSQL setter ingen grense for det.\n`max_slot_wal_keep_size` er `-1`, så spor kan beholde en ubegrenset mengde logg,\nog `idle_replication_slot_timeout` er `0`, noe som slår av ugyldiggjøringen av\nspor som står ubrukt. En konnektor som stoppet under en mislykket\nproduksjonssetting, kan derfor fylle disken lenge etter at alle har glemt den.\nHold øye med `pg_replication_slots` for spor som ikke lenger er aktive, og sett\n`max_slot_wal_keep_size` til det disken tåler, vel vitende om at en konsument\nsom havner lenger bak enn det, kanskje ikke kan fortsette. Veien tilbake går\ngjennom et nytt spor, og et nytt spor begynner der loggen står nå: Debezium\nadvarer om at et spor som slettes og opprettes på nytt, i det stille kan hoppe\nover hendelsene i mellomtiden, så ta et nytt øyeblikksbilde etterpå.\n\n**En stille tabell holder loggen tilbake.** Debezium-dokumentasjonen beskriver\nen mer lumsk variant. Et spor hører til én database, og konnektoren flytter bare\nden bekreftede posisjonen sin fremover når den ser endringer den fanger. Endres\ntabellene den fanger, sjelden, mens andre tabeller eller andre databaser på den\nsamme serveren skriver mye, flytter posisjonen seg nesten ikke, og loggen bak\nden fortsetter å vokse. Løsningen er et hjerteslag (heartbeat):\n`heartbeat.interval.ms` får konnektoren til å sende heartbeat-hendelser med et\nfast intervall, og `heartbeat.action.query` lar den skrive jevnlig til en liten\ntabell i databasen den fanger endringer fra. Tabellen må være med i\npublikasjonen (publication) som konnektoren leser, slik at sporet flytter seg\nfremover også når ingenting annet skjer der.\n\n**Konsumentene går ut fra at hver endring kommer én gang.** Et logisk spor\nsender ut hver endring én gang under normal drift, men posisjonen lagres bare\nved sjekkpunkter (checkpoints), så etter et krasj kan det gå tilbake til et\ntidligere punkt og sende de siste endringene på nytt. PostgreSQL-dokumentasjonen\noverlater konsekvensene til klienten. En konsument som legger hvert beløp til en\nløpende sum, teller de endringene to ganger. Gjør hver konsument idempotent: ta\ni bruk hver endring som en upsert med primærnøkkelen til raden som nøkkel, eller\nregistrer hvilke hendelser som allerede er behandlet, slik at en ny levering\nikke endrer noe.\n\n**Oppdateringer og slettinger kommer uten de gamle verdiene.** Hva en hendelse\nfor en oppdatering eller sletting forteller om den tidligere raden, avhenger av\nreplica identity for tabellen. Med `REPLICA IDENTITY DEFAULT` inneholder\nhendelsene fra Debezium høyst de tidligere verdiene av primærnøkkelen, og for en\ntabell uten primærnøkkel sender konnektoren ingen hendelser for oppdateringer\neller slettinger i det hele tatt. `REPLICA IDENTITY FULL` legger alle tidligere\nkolonner i `before`, men det koster: PostgreSQL-dokumentasjonen påpeker at det\nøker mengden WAL, særlig når mange `UPDATE`- og `DELETE`-setninger kjøres. Gi\nhver tabell som fanges, en primærnøkkel, og bytt bare til `FULL` på tabellene\nder konsumentene trenger de gamle verdiene.\n\n## Les mer\n\n- [Debezium Features](https://debezium.io/documentation/reference/stable/features.html)\n  — hva loggbasert CDC fanger som polling og dobbeltskriving går glipp av, pluss\n  øyeblikksbilder, filtre og maskering.\n- [Debezium connector for PostgreSQL](https://debezium.io/documentation/reference/stable/connectors/postgresql.html)\n  — output-plugins, øyeblikksbilder, formatet på hendelsene, replica identity og\n  diskplass til WAL.\n- [Logical Decoding Concepts](https://www.postgresql.org/docs/current/logicaldecoding-explanation.html)\n  — replikeringsspor, output-plugins, og hvorfor et spor som ingen trenger, bør\n  slettes.\n- [Logical Decoding Examples](https://www.postgresql.org/docs/current/logicaldecoding-example.html)\n  — å opprette et spor, kikke på og bruke opp endringer og slette sporet igjen.\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ønsteret, og hvordan Debezium sender outbox-rader videre til topics.\n\n\u003chttps://engineer.company/nb/glossary/change-data-capture/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvordan change data capture leser databasens logg over endringer og sender dem videre, hvorfor det slår polling, og fire måter det går galt på i det stille.","formats":{"gemtext":"https://engineer.company/nb/glossary/change-data-capture/index.gmi","gopher":"https://engineer.company/nb/glossary/change-data-capture/gophermap","html":"https://engineer.company/nb/glossary/change-data-capture/","json":"https://engineer.company/nb/glossary/change-data-capture/index.json","markdown":"https://engineer.company/nb/glossary/change-data-capture/index.md","pdf":"https://engineer.company/nb/glossary/change-data-capture/index.pdf"},"kind":"page","language":"nb","title":"Hva er change data capture?","url":"https://engineer.company/nb/glossary/change-data-capture/","version":1}