{"canonical_url":"https://engineer.company/sv/glossary/replication/","content_markdown":"# Replikering\n\n## Vad det är\n\nReplikering håller kopior av en databas på andra servrar och skickar varje kopia\nalla ändringar som görs i originalet, så att de hålls i takt. Många använder\nockså det engelska ordet replication, och där sammanhanget lämnar utrymme för\ntvivel heter det databasreplikering. PostgreSQL-dokumentationen kallar den enda\nserver som tar emot skrivningar primary och servrarna som följer den standby; på\nsvenska säger man gärna primärnoden och standbyservrarna. Redis talar om en\nmaster och dess repliker.\n\nPostgreSQL har två sorter, och de kopierar olika saker.\n\nFysisk replikering kopierar write-ahead-loggen (WAL), loggen som varje ändring\nskrivs till innan den når datafilerna. En standby spelar upp loggen och blir en\nblock-för-block-kopia av hela klustret. Vid strömmande replikering håller\nstandbyn en anslutning öppen mot primärnoden och tar emot WAL-posterna allt\neftersom de skrivs, i stället för att vänta på att färdiga WAL-filer skickas\növer. En standby som bara spelar upp och inte tar emot anslutningar förrän den\nbefordras är en warm standby; en som också svarar på skrivskyddade frågor är en\nhot standby.\n\nLogisk replikering kopierar ändringar i rader. En publisher skickar vidare de\ninfogningar, uppdateringar och borttagningar som görs i utvalda tabeller, varje\nrad identifierad genom sin replica identity, oftast primärnyckeln, och en\nsubscriber tillämpar dem på sina egna tabeller. Eftersom den arbetar med rader\noch inte diskblock kan den nöja sig med några få tabeller i stället för hela\nklustret, till och med över till en annan huvudversion av PostgreSQL.\n\nStrömmande replikering är asynkron som standard. Primärnoden bekräftar en commit\nså snart WAL ligger på dess egen disk och skickar den vidare efteråt;\ndokumentationen anger fördröjningen till normalt under en sekund när standbyn\nhinner med. Med synkron replikering påslagen väntar varje commit tills en\nstandby också har WAL.\n\n## Varför det spelar roll\n\nDet första skälet är att överleva förlusten av en server. När primärnoden går\nner kan en standby som redan har datan befordras och ta över trafiken, långt\nsnabbare än en backup kan läsas tillbaka på en ny maskin.\n\nDet andra är att sprida läsningarna. I många applikationer läser de flesta\nfrågor bara, och en hot standby kan besvara dem, så att primärnoden är ledig för\nskrivningarna, som bara den kan ta emot.\n\nDet tredje är att flytta data. Logisk replikering kan kopiera just de tabeller\nen rapportdatabas behöver, eller föra över data till en server med en annan\nhuvudversion av PostgreSQL.\n\nVarje kopia kommer med ett val mellan att vänta och att förlora. Asynkron\nreplikering kostar ingenting när man committar, men en standby ligger alltid\nlite efter: en läsning från den kan missa en skrivning som just har skett, och\nom primärnoden dör kan commits som den redan har bekräftat aldrig nå fram till\nden standby som tar över. Synkron replikering stänger den luckan och lägger en\ntur fram och tillbaka över nätverket i varje commit.\n\nReplikering är inte heller en backup. En standby spelar troget upp en oavsiktlig\n`DELETE` utan `WHERE`, så några ögonblick senare har alla kopior felet. Det\nkrävs fortfarande en backup för att ångra det.\n\n## Så ser det ut i praktiken\n\nEn webbutik kör sin databas på en primärnod på `10.0.0.1` och lägger till en\nserver till, `db2`, som strömmande replik. På `db2`, där PostgreSQL är\ninstallerat och stoppat:\n\n```sh\npg_basebackup -h 10.0.0.1 -U replicator -D /srv/pgdata \\\n    -R -C -S db2_slot -P\n```\n\n`pg_basebackup` kopierar hela det körande klustret till katalogen som `-D` pekar\npå; katalogen skapas om den saknas och måste annars vara tom. Som standard\nströmmar den samtidigt med sig den WAL som skrivs under kopieringen.\n`-C -S db2_slot` skapar först en replikeringsslot på primärnoden, så att den\nsparar varje WAL-post tills den nya standbyn har tagit emot den. `-R` skapar\nfilen `standby.signal` och skriver anslutningsinställningarna i\n`postgresql.auto.conf`, där även slotnamnet hamnar. `-P` visar förloppet. Rollen\n`replicator` behöver attributet `REPLICATION` eller superanvändarrättigheter,\noch primärnodens `pg_hba.conf` måste tillåta replikeringsanslutningen.\n\nNär PostgreSQL startar på `db2` får `standby.signal` den att gå som standby och\nströmma från primärnoden, och eftersom `hot_standby` är påslaget som standard\ntar den emot skrivskyddade frågor så snart den är konsistent. På primärnoden\nvisar en rad per standby hur det går:\n\n```sql\nSELECT application_name, state, sync_state, replay_lsn, replay_lag\nFROM   pg_stat_replication;\n```\n\nEn frisk replik visar `streaming` i `state` och `async` i `sync_state`.\n`replay_lag` är en uppskattning av hur lång tid nya commits tog på sig att bli\nsynliga där; när standbyn har kommit ikapp och WAL-aktiviteten upphör står den\npå NULL i stället för noll.\n\nAnteckningen om att\n[optimera databasen innan du shardar den](/sv/notes/optimise-before-you-shard/)\nförklarar varför en butik gör så. Det mesta av trafiken är läsning:\nproduktsidan, varukorgen, orderhistoriken. Inget av det behöver primärnoden, som\nmåste hållas fri för skrivningar. En strömmande replik tar de läsningarna, och\nanteckningen påpekar att det är konfiguration att lägga till en, där en shard är\nett projekt. Den nämner två förbehåll. En replik ligger lite efter, så det en\nanvändare just har skrivit bör läsas från primärnoden. Och en lång rapport på en\nreplik kan avbrytas när den håller upp ändringar som repliken ska spela upp.\n\nDet krävs en inställning på primärnoden för att låta en commit vänta på en\nstandby. Varje standby får ett namn genom `application_name` i sin\n`primary_conninfo`, och primärnoden listar de namn den får vänta på:\n\n```ini\nsynchronous_standby_names = 'ANY 1 (db2, db3)'\n```\n\nNu väntar varje commit tills dess WAL ligger på disk både på primärnoden och på\nminst en av `db2` och `db3`. `synchronous_commit` kan sättas per användare, per\ndatabas eller per transaktion, så att ordern som tar betalt kan vänta medan en\nräknare för sidvisningar committar i lokal takt. Anteckningen om att\n[sälja den sista biljetten exakt en gång](/sv/notes/selling-limited-stock-without-overselling/)\nvisar varför det spelar roll för lagersaldot. Med asynkron replikering kan en\nprimärnod bekräfta en försäljning och dö innan repliken har fått den; repliken\nbefordras, försäljningen är borta, och samma enhet säljs igen. Anteckningens\nlösning är en synkron standby eller ett lagringssystem byggt på Raft, och priset\när extra latens vid varje commit.\n\nLogisk replikering sätts upp med två satser. Publishern behöver\n`wal_level = logical`, och tabellerna måste redan finnas hos subscribern,\neftersom deras definitioner inte kopieras:\n\n```sql\n-- på publishern\nCREATE PUBLICATION shop_pub FOR TABLE orders, customers;\n\n-- på subscribern\nCREATE SUBSCRIPTION shop_sub\n    CONNECTION 'host=10.0.0.1 dbname=shop user=replicator'\n    PUBLICATION shop_pub;\n```\n\nPrenumerationen kopierar först de rader som redan finns i tabellerna och\ntillämpar sedan alla senare ändringar.\n\n## Var det går fel\n\n**Användaren ser inte det som just sparades.** Applikationen skriver till\nprimärnoden och läser tillbaka resultatet från en replik som fortfarande ligger\nett ögonblick efter, så en sparad inställning verkar hoppa tillbaka. Skicka en\nanvändares läsningar till primärnoden en kort stund efter varje skrivning. Där\ndata måste synas på standbyn i samma ögonblick som commit returnerar väntar\n`synchronous_commit = remote_apply` tills de synkrona standbyservrarna har\nspelat upp transaktionen, till ett högre pris per commit.\n\n**Långa frågor på repliken avbryts.** Standbyn måste spela upp ändringar som\nkrockar med en fråga som körs: vacuum som tar bort radversioner som frågan\nfortfarande kan se, eller det exklusiva lås som `DROP TABLE` och många former av\n`ALTER TABLE` tar. Uppspelningen väntar upp till `max_standby_streaming_delay`,\n30 sekunder som standard, och avbryter sedan frågan. En replik för rapporter kan\nfå en längre frist och halkar då längre efter medan den väntar.\n`hot_standby_feedback = on` stoppar de avbrott som vacuum orsakar, men\ndokumentationen varnar för att det kan blåsa upp primärnoden.\n`pg_stat_database_conflicts` på standbyn räknar avbrotten per orsak, och\napplikationen bör köra om en avbruten fråga.\n\n**En bortglömd slot fyller primärnodens disk.** En replikeringsslot håller kvar\nWAL tills dess standby har tagit emot den, även när standbyn är avstängd eller\nsedan länge borta, och `max_slot_wal_keep_size` är -1 som standard, alltså ingen\ngräns. Kontrollera dem regelbundet:\n\n```sql\nSELECT slot_name, active, wal_status, safe_wal_size\nFROM   pg_replication_slots;\n```\n\nTa bort en slot vars standby är borta. Sätter man `max_slot_wal_keep_size` får\nvarje slot ett tak för hur mycket den får hålla kvar; en standby som hamnar\nlängre efter får sin slot ogiltigförklarad, och `wal_status` visar `lost`.\n`idle_replication_slot_timeout`, avstängd som standard, ogiltigförklarar slots\nsom har varit inaktiva längre än den angivna tiden.\n\n**Skrivningarna stannar när en synkron standby gör det.** Är bara en standby\nnamngiven och den ligger nere väntar varje commit på primärnoden, kanske för\nalltid. Namnge fler kandidater än det antal som krävs, som i `ANY 1 (db2, db3)`.\nGår inte det, sänk antalet eller töm `synchronous_standby_names` och läs in\nkonfigurationen på nytt.\n\n**Två servrar tror båda att de är primärnoden.** PostgreSQL befordrar en standby\nnär man ber om det, med `pg_ctl promote` eller `SELECT pg_promote()`, men har\ningen egen programvara som upptäcker att primärnoden har fallit bort, och\ningenting hindrar den gamla från att komma tillbaka och ta emot skrivningar.\nDokumentationen varnar för att det leder till förvirring och till sist\ndataförlust. Stäng ute den gamla primärnoden, genom att stänga av den eller kapa\ndess nätverk, innan standbyn befordras, och bygg om den som standby innan den\nsläpps in igen.\n\n**Logisk replikering lämnar saker efter sig.** Schemaändringar replikeras inte,\nså en kolumn som läggs till hos publishern stoppar replikeringen tills\nsubscribern också har den; gör ändringar som bara lägger till något hos\nsubscribern först. Sekvenser replikeras inte heller: raderna kommer med sina\nid:n, men subscriberns sekvenser står kvar på sina startvärden, och efter ett\nbyte misslyckas infogningar på dubblettnycklar. Sätt varje sekvens förbi det\nhögsta värdet som används innan bytet.\n\n**En Redis-master startar om tom och tar replikerna med sig.** Är persistens\navstängd på mastern och något startar om den automatiskt kommer den tillbaka med\nen tom datamängd, och replikerna kopierar den och raderar sina egna data. Låt\npersistensen vara påslagen, eller låt inte mastern starta om automatiskt.\n\n## Läs mer\n\n- [High availability](https://www.postgresql.org/docs/current/high-availability.html)\n  — PostgreSQL-dokumentationens översikt över primär- och standbyservrar,\n  synkron och asynkron replikering och failover.\n- [Log-Shipping Standby Servers](https://www.postgresql.org/docs/current/warm-standby.html)\n  — strömmande replikering, replikeringsslots och hur synkron replikering ställs\n  in.\n- [Hot Standby](https://www.postgresql.org/docs/current/hot-standby.html) —\n  skrivskyddade frågor på en standby, konflikterna som avbryter dem och\n  inställningarna som väger fördröjning mot avbrott.\n- [pg_basebackup](https://www.postgresql.org/docs/current/app-pgbasebackup.html)\n  — att kopiera ett körande kluster för att starta en standby, med alla flaggor\n  som används ovan.\n- [Restrictions](https://www.postgresql.org/docs/current/logical-replication-restrictions.html)\n  — det som logisk replikering inte tar med sig: schema, sekvenser, large\n  objects och allt annat än tabeller.\n- [Redis replication](https://redis.io/docs/latest/operate/oss_and_stack/management/replication/)\n  — hur Redis-repliker följer en master, varför replikeringen är asynkron och\n  faran i att starta om utan persistens.\n\n\u003chttps://engineer.company/sv/glossary/replication/\u003e\n","date_modified":"2026-10-29T11:17:41Z","description":"Så håller replikering standbyservrar i takt med databasen: strömmande och logisk replikering i PostgreSQL, synkront eller inte, och felen att planera för.","formats":{"gemtext":"https://engineer.company/sv/glossary/replication/index.gmi","gopher":"https://engineer.company/sv/glossary/replication/gophermap","html":"https://engineer.company/sv/glossary/replication/","json":"https://engineer.company/sv/glossary/replication/index.json","markdown":"https://engineer.company/sv/glossary/replication/index.md","pdf":"https://engineer.company/sv/glossary/replication/index.pdf"},"kind":"page","language":"sv","title":"Vad är replikering?","url":"https://engineer.company/sv/glossary/replication/","version":1}