{"canonical_url":"https://engineer.company/sv/glossary/change-data-capture/","content_markdown":"# Change data capture\n\n## Vad det är\n\nChange data capture, oftast förkortat CDC, innebär att läsa av ändringarna i en\ndatabas och skicka dem vidare till andra system i takt med att de sker. Varje\ninsättning, uppdatering och borttagning blir en händelse som något annat kan\nreagera på: en rapportkopia som håller sig aktuell, ett sökindex, en annan\ntjänst som behöver veta att en order har lagts. Databasen där ändringen sker\nförblir den auktoritativa källan, och de andra systemen följer efter.\n\nDet finns i stort sett två sätt att hitta ändringarna. Det enkla är att fråga:\nmed några minuters mellanrum körs en databasfråga efter rader vars tidsstämpel\nför senaste uppdatering är nyare än förra körningen. Det andra är att läsa\ndatabasens egen förteckning över vad den har ändrat. PostgreSQL för den\nförteckningen i sin transaktionslogg, write-ahead log (WAL), och dokumentationen\nbeskriver principen bakom: ändringar i datafilerna skrivs först när posterna som\nbeskriver dem har skrivits till permanent lagring. Eftersom loggen redan\ninnehåller varje ändring i den ordning den skedde, ger den en fullständig\nhistorik utan att tabellerna behöver läsas alls. Det är det andra\ntillvägagångssättet, loggbaserad CDC, som man oftast menar med uttrycket i dag.\n\nI PostgreSQL heter mekanismen logisk avkodning. Dokumentationen beskriver den\nsom processen som tar ut alla beständiga ändringar i tabellerna i en databas i\nett sammanhängande format som kan läsas utan kännedom om databasens inre\ntillstånd. Tre delar samverkar. Loggen på servern måste innehålla tillräckligt\nmed detaljer, och det styrs av inställningen `wal_level`: standardvärdet,\n`replica`, räcker för att kopiera data mellan servrar, medan `logical` lägger\ntill det som avkodningen behöver. En replikeringsslot (replication slot) står\nför en ström av ändringar från en databas, som spelas upp för en klient i den\nordning de gjordes, och sloten minns hur långt klienten har kommit. Ett\noutput-plugin översätter loggens interna poster till det format som klienten\nvill ha.\n\nDe flesta skriver inte klienten själva. Debezium beskriver sig som en samling\nkällkonnektorer för Apache Kafka Connect, där var och en läser ändringar från en\nviss databas via databasens egna CDC-funktioner. Konnektorn för PostgreSQL läser\nantingen via `pgoutput`, som Debeziums dokumentation kallar det inbyggda\noutput-pluginet i PostgreSQL, eller via `decoderbufs`, ett plugin som underhålls\nav Debezium-gemenskapen. Debezium kan också köras som ett bibliotek i en\nJVM-applikation eller som Debezium Server, som skickar ändringshändelserna\nvidare till system som Amazon Kinesis, Google Cloud Pub/Sub och Apache Pulsar.\n\n## Varför det spelar roll\n\nPolling ser billigare ut, och för en liten tabell som sällan ändras stämmer det\nofta. Debeziums dokumentation räknar upp vad läsning av loggen klarar som\npolling inte gör. Den fångar varje ändring, medan en databasfråga bara ser\nradens tillstånd i det ögonblick den körs, så en rad som ändrades tre gånger\nmellan två körningar bara dyker upp en gång. Den fångar borttagningar, medan en\nborttagen rad helt enkelt saknas i nästa resultat. Den kräver ingen extra kolumn\ni datamodellen, som ett ”Last Updated”-fält som all kod som skriver till\ntabellen måste komma ihåg att fylla i. Den kan ta med radens tidigare tillstånd\noch metadata, till exempel vilken transaktion som gjorde ändringen. Och den\nlevererar ändringarna med mycket liten fördröjning utan den CPU-belastning som\ntäta pollningar ger: för PostgreSQL och MySQL ligger fördröjningen enligt\nDebezium i millisekundområdet.\n\nDet andra skälet är att databasen och meddelandena som andra system tar emot\nsäger samma sak. Debezium nämner dubbelskrivning (dual writes) som det andra\ntillvägagångssättet den jämför sig med: applikationen sparar en ändring i sin\ndatabas och skickar sedan ett meddelande om den. Stannar processen mellan de två\nstegen är databasen och meddelandeströmmen oense, och ingenting registrerar\nvilken av dem som har fel. CDC tar bort den andra skrivningen. Applikationen\nsparar en gång, och meddelandet härleds från det som faktiskt sparades.\nOutbox-mönstret går ett steg längre: applikationen skriver själva meddelandet i\nen outbox-tabell i samma transaktion som ändringen, och CDC publicerar raderna i\nden tabellen. Debeziums Outbox Event Router beskriver syftet som att undvika\ninkonsekvenser mellan en tjänsts eget tillstånd och de händelser som andra\ntjänster konsumerar.\n\nDet tredje skälet är ordningen. En replikeringsslot lämnar ut ändringarna i den\nordning de gjordes på källservern, grupperade efter transaktionen som gjorde\ndem, som exemplet nedan visar. En konsument som tillämpar dem i den ordningen\nbygger upp samma tillstånd steg för steg. För en ETL-laddning gör det den\ninkrementella laddningen ärlig: ett nattligt jobb kan ta exakt de ändringar som\nhar kommit sedan förra körningen, borttagningar inräknade, i stället för att\nladda om hela tabeller eller lita på en tidsstämpelkolumn som en kodväg glömde\natt uppdatera.\n\n## Så ser det ut i praktiken\n\nDet minsta exemplet som fungerar använder bara PostgreSQL. Det kräver `wal_level\n= logical` i serverns konfiguration, vilket träder i kraft först efter en\nomstart, och en ledig replikeringsslot; `max_replication_slots` är 10 som\nstandard. Sessionen nedan körs som superanvändare, precis som dokumentationens\neget exempel, och använder `test_decoding`, output-pluginet från det exemplet,\nsom skriver ut varje ändring som en textrad.\n\n```sql\n-- postgresql.conf: wal_level = logical (träder i kraft efter 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, 'order 42 lagd');\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]:'order 42 lagd'\n-- COMMIT 10301\n\nSELECT data FROM pg_logical_slot_get_changes('shop_cdc', NULL, NULL);\n-- samma fyra rader; anropet förbrukar dem, så ett nytt anrop ger inga\n\nSELECT pg_drop_replication_slot('shop_cdc');\n```\n\nOrdern och dess outbox-meddelande kommer ut tillsammans, inom transaktionen som\nskrev dem. `pg_logical_slot_peek_changes` läser utan att flytta sloten och ger\ndärför samma rader vid nästa anrop, medan `pg_logical_slot_get_changes`\nförbrukar dem. En `CREATE TABLE` skulle bara ge ett tomt `BEGIN` och `COMMIT`,\neftersom logisk avkodning inte tar med DDL. Den sista raden är viktigast: en\nslot som blir kvar fortsätter att hålla fast vid serverns resurser.\n\nI produktion är det Debezium som läser. Första gången konnektorn för PostgreSQL\nstartar tar den en konsistent ögonblicksbild (snapshot) av tabellerna den fångar\nändringar från och strömmar sedan ändringar från den punkt där ögonblicksbilden\ntogs. Standardvärdet för `snapshot.mode`, `initial`, tar bara ögonblicksbilden\nnär det inte finns några sparade offsets, så en omstart fortsätter från den\nsenast registrerade positionen. Varje händelse har en `before`- och en\n`after`-bild av raden, ett `source`-block, en tidsstämpel och en `op`-kod: `c`\nför skapande, `u` för uppdatering, `d` för borttagning, `r` för en rad som lästs\nunder en ögonblicksbild och `t` för truncate. Efter en borttagning skickar\nkonnektorn dessutom en tombstone, en händelse med samma nyckel och värdet null,\nså att log compaction i Kafka kan ta bort de tidigare meddelandena med den\nnyckeln.\n\nBåda mönstren från den här artikeln återkommer på företagets egna sidor. Mellan\n2022 och 2024 [byggde grundaren 600 ETL/ELT-pipelines i\nPL/pgSQL](/sv/portfolio/engineered-600-pl-pgsql-etl-elt-pipelines/) i flera\nutvecklings- och produktionsmiljöer för PostgreSQL, däribland inkrementella\nladdningar med CDC och tidsstämpelbaserade deltan. Anteckningen [Att sälja den\nsista biljetten exakt en\ngång](/sv/notes/selling-limited-stock-without-overselling/) bygger en blixtrea\nkring en outbox: varje steg lägger sitt meddelande i outboxen i samma\ntransaktion som ändringen, change data capture publicerar outboxen, och eftersom\nett meddelande kan komma fram mer än en gång är varje konsument idempotent, med\nordern som nyckel.\n\n## Var det går fel\n\n**Ingenting sätter tak för hur mycket en slot får behålla.** En slot håller fast\nvid varje del av transaktionsloggen som dess konsument inte har bekräftat, och\nstandardinställningarna i PostgreSQL sätter ingen gräns för det.\n`max_slot_wal_keep_size` är `-1`, så slots får behålla en obegränsad mängd logg,\noch `idle_replication_slot_timeout` är `0`, vilket stänger av\nogiltigförklaringen av slots som står oanvända. En konnektor som stannade under\nen misslyckad driftsättning kan därför fylla disken långt efter att alla har\nglömt den. Håll koll på `pg_replication_slots` efter slots som inte längre är\naktiva, och sätt `max_slot_wal_keep_size` till vad disken tål, med vetskap om\natt en konsument som hamnar längre efter än så kanske inte kan fortsätta. Vägen\ntillbaka går via en ny slot, och en ny slot börjar där loggen står nu: Debezium\nvarnar för att en slot som tas bort och skapas på nytt i tysthet kan hoppa över\nhändelserna däremellan, så ta en ny ögonblicksbild efteråt.\n\n**En stillsam tabell håller tillbaka loggen.** Debeziums dokumentation beskriver\nen lömskare variant. En slot hör till en databas, och konnektorn flyttar bara\nfram sin bekräftade position när den ser ändringar som den fångar. Om tabellerna\nden fångar sällan ändras medan andra tabeller, eller andra databaser på samma\nserver, skriver mycket, flyttar sig positionen knappt, och loggen bakom den\nfortsätter att växa. Lösningen är ett hjärtslag (heartbeat):\n`heartbeat.interval.ms` får konnektorn att skicka heartbeat-händelser med ett\nfast intervall, och `heartbeat.action.query` låter den skriva regelbundet till\nen liten tabell i den databas den fångar ändringar från. Tabellen måste ingå i\nden publikation (publication) som konnektorn läser, så att sloten flyttar sig\nframåt även när inget annat händer där.\n\n**Konsumenterna utgår från att varje ändring kommer en gång.** En logisk slot\nskickar varje ändring en gång vid normal drift, men dess position sparas bara\nvid kontrollpunkter (checkpoints), så efter en krasch kan den gå tillbaka till\nen tidigare punkt och skicka de senaste ändringarna igen. Dokumentationen för\nPostgreSQL lämnar följderna åt klienten. En konsument som lägger till varje\nbelopp i en löpande summa räknar de ändringarna två gånger. Gör varje konsument\nidempotent: tillämpa varje ändring som en upsert med radens primärnyckel som\nnyckel, eller registrera vilka händelser som redan har behandlats, så att en ny\nleverans inte ändrar något.\n\n**Uppdateringar och borttagningar kommer utan de gamla värdena.** Vad en\nhändelse för en uppdatering eller borttagning säger om den tidigare raden beror\npå tabellens replica identity. Med `REPLICA IDENTITY DEFAULT` innehåller\nDebeziums händelser högst primärnyckelns tidigare värden, och för en tabell utan\nprimärnyckel skickar konnektorn inga händelser alls för uppdateringar eller\nborttagningar. `REPLICA IDENTITY FULL` lägger alla tidigare kolumner i `before`,\nmen det kostar: dokumentationen för PostgreSQL påpekar att det ökar mängden WAL,\nsärskilt när många `UPDATE`- och `DELETE`-satser körs. Ge varje tabell som\nfångas en primärnyckel, och byt till `FULL` bara på de tabeller vars konsumenter\nbehöver de gamla värdena.\n\n## Läs mer\n\n- [Debezium Features](https://debezium.io/documentation/reference/stable/features.html)\n  — vad loggbaserad CDC fångar som polling och dubbelskrivning missar, plus\n  ögonblicksbilder, filter och maskering.\n- [Debezium connector for PostgreSQL](https://debezium.io/documentation/reference/stable/connectors/postgresql.html)\n  — output-plugins, ögonblicksbilder, händelseformatet, replica identity och\n  diskutrymme för WAL.\n- [Logical Decoding Concepts](https://www.postgresql.org/docs/current/logicaldecoding-explanation.html)\n  — replikeringsslots, output-plugins och varför en slot som ingen behöver bör\n  tas bort.\n- [Logical Decoding Examples](https://www.postgresql.org/docs/current/logicaldecoding-example.html)\n  — att skapa en slot, titta på och förbruka ändringar och ta bort sloten igen.\n- [Replication (server configuration)](https://www.postgresql.org/docs/current/runtime-config-replication.html)\n  — `max_replication_slots`, `max_slot_wal_keep_size` och\n  `idle_replication_slot_timeout`.\n- [Outbox Event Router](https://debezium.io/documentation/reference/stable/transformations/outbox-event-router.html)\n  — outbox-mönstret och hur Debezium skickar outbox-rader vidare till topics.\n\n\u003chttps://engineer.company/sv/glossary/change-data-capture/\u003e\n","date_modified":"2026-11-08T02:22:23Z","description":"Hur change data capture läser databasens logg över ändringar och skickar dem vidare, varför det slår polling, och fyra sätt det i tysthet kan gå fel på.","formats":{"gemtext":"https://engineer.company/sv/glossary/change-data-capture/index.gmi","gopher":"https://engineer.company/sv/glossary/change-data-capture/gophermap","html":"https://engineer.company/sv/glossary/change-data-capture/","json":"https://engineer.company/sv/glossary/change-data-capture/index.json","markdown":"https://engineer.company/sv/glossary/change-data-capture/index.md","pdf":"https://engineer.company/sv/glossary/change-data-capture/index.pdf"},"kind":"page","language":"sv","title":"Vad är change data capture?","url":"https://engineer.company/sv/glossary/change-data-capture/","version":1}