{"canonical_url":"https://engineer.company/nb/glossary/replication/","content_markdown":"# Replikering\n\n## Hva det er\n\nReplikering holder kopier av en database på andre servere og sender hver kopi\nalle endringene som gjøres i originalen, slik at de holdes i takt. Mange bruker\nogså det engelske ordet replication, og der sammenhengen gir rom for tvil, heter\ndet databasereplikering. PostgreSQL-dokumentasjonen kaller den ene serveren som\ntar imot skrivinger, primary, og serverne som følger den, standby; på norsk sier\nman gjerne primærnoden og standbyserverne. Redis snakker om en master og\nreplikaene dens.\n\nPostgreSQL har to slag, og de kopierer forskjellige ting.\n\nFysisk replikering kopierer write-ahead-loggen (WAL), loggen hver endring\nskrives til før den når datafilene. En standby spiller av loggen og blir en\nblokk-for-blokk-kopi av hele klyngen. Ved strømmende replikering holder\nstandbyen en forbindelse åpen mot primærnoden og tar imot WAL-postene etter\nhvert som de skrives, i stedet for å vente på at ferdige WAL-filer blir sendt\nover. En standby som bare spiller av og ikke tar imot tilkoblinger før den\nforfremmes, er en warm standby; en som også svarer på skrivebeskyttede\nspørringer, er en hot standby.\n\nLogisk replikering kopierer endringer i rader. En publisher sender videre\ninnsettingene, oppdateringene og slettingene som gjøres i utvalgte tabeller,\nhver rad kjent på sin replica identity, vanligvis primærnøkkelen, og en\nsubscriber legger dem inn i sine egne tabeller. Fordi den arbeider med rader og\nikke diskblokker, kan den nøye seg med noen få tabeller i stedet for hele\nklyngen, til og med over til en annen hovedversjon av PostgreSQL.\n\nStrømmende replikering er asynkron som standard. Primærnoden bekrefter en commit\nså snart WAL ligger på dens egen disk, og sender den videre etterpå;\ndokumentasjonen anslår forsinkelsen til vanligvis under ett sekund når standbyen\nklarer å holde følge. Med synkron replikering slått på venter hver commit til en\nstandby også har WAL.\n\n## Hvorfor det er viktig\n\nDen første grunnen er å overleve at en server går tapt. Når primærnoden svikter,\nkan en standby som allerede har dataene, forfremmes og ta over trafikken, langt\nraskere enn en backup kan legges tilbake på en ny maskin.\n\nDen andre er å spre lesingene. I mange applikasjoner leser de fleste spørringene\nbare, og en hot standby kan svare på dem, slik at primærnoden er ledig for\nskrivingene, som bare den kan ta imot.\n\nDen tredje er å flytte data. Logisk replikering kan kopiere akkurat de tabellene\nen rapporteringsdatabase trenger, eller flytte data over til en server med en\nannen hovedversjon av PostgreSQL.\n\nHver kopi kommer med et valg mellom å vente og å miste. Asynkron replikering\nkoster ingenting når det committes, men en standby ligger alltid litt etter: en\nlesing fra den kan gå glipp av en skriving som nettopp skjedde, og hvis\nprimærnoden dør, kan commits den allerede har bekreftet, aldri nå fram til\nstandbyen som tar over. Synkron replikering tetter det hullet og legger en tur\nfram og tilbake over nettverket inn i hver commit.\n\nReplikering er heller ikke en backup. En standby spiller trofast av en\nutilsiktet `DELETE` uten `WHERE`, så noen øyeblikk senere har alle kopiene\nfeilen. Det trengs fortsatt en backup for å rette den opp.\n\n## Slik ser det ut i praksis\n\nEn nettbutikk kjører databasen sin på én primærnode på `10.0.0.1` og legger til\nen server til, `db2`, som strømmende replika. På `db2`, der PostgreSQL er\ninstallert og stoppet:\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` kopierer hele den kjørende klyngen inn i katalogen `-D` peker\npå, som opprettes om den mangler, og ellers må være tom. Som standard strømmer\nden samtidig med seg WAL-en som skrives mens kopieringen pågår. `-C -S db2_slot`\noppretter først et replikeringsspor (replication slot) på primærnoden, slik at\nden tar vare på hver WAL-post til den nye standbyen har mottatt den. `-R`\noppretter filen `standby.signal` og legger tilkoblingsinnstillingene, sporet\ninkludert, til i `postgresql.auto.conf`. `-P` viser framdriften. Rollen\n`replicator` må ha attributtet `REPLICATION` eller være superbruker, og\n`pg_hba.conf` på primærnoden må tillate replikeringstilkoblingen.\n\nNår PostgreSQL starter på `db2`, får `standby.signal` den til å kjøre som\nstandby og strømme fra primærnoden, og siden `hot_standby` er slått på som\nstandard, tar den imot skrivebeskyttede spørringer så snart den er konsistent.\nPå primærnoden viser én rad per standby hvordan det går:\n\n```sql\nSELECT application_name, state, sync_state, replay_lsn, replay_lag\nFROM   pg_stat_replication;\n```\n\nEn frisk replika viser `streaming` i `state` og `async` i `sync_state`.\n`replay_lag` er et anslag over hvor lang tid nye commits brukte på å bli synlige\nder; når standbyen har tatt igjen alt og WAL-aktiviteten stopper, står den på\nNULL i stedet for null.\n\nNotatet om å\n[optimalisere databasen før du sharder den](/nb/notes/optimise-before-you-shard/)\nforklarer hvorfor en butikk gjør dette. Mesteparten av trafikken er lesing:\nproduktsiden, handlekurven, ordrehistorikken. Ingenting av det trenger\nprimærnoden, som må holdes fri for skrivinger. En strømmende replika tar de\nlesingene, og notatet påpeker at det å legge til en er konfigurasjon, der en\nshard er et prosjekt. Det nevner to forbehold. En replika ligger litt etter, så\ndet en bruker nettopp har skrevet, bør leses fra primærnoden. Og en lang rapport\npå en replika kan bli avbrutt når den holder igjen endringer replikaen skal\nspille av.\n\nDet trengs én innstilling på primærnoden for å få en commit til å vente på en\nstandby. Hver standby får et navn gjennom `application_name` i sin\n`primary_conninfo`, og primærnoden lister opp navnene den kan vente på:\n\n```ini\nsynchronous_standby_names = 'ANY 1 (db2, db3)'\n```\n\nNå venter hver commit til WAL-en ligger på disk både på primærnoden og på minst\nén av `db2` og `db3`. `synchronous_commit` kan settes per bruker, per database\neller per transaksjon, slik at ordren som tar betalt, kan vente mens en teller\nfor sidevisninger committer i lokalt tempo. Notatet om å\n[selge den siste billetten nøyaktig én gang](/nb/notes/selling-limited-stock-without-overselling/)\nviser hvorfor det betyr noe for lagerbeholdningen. Med asynkron replikering kan\nen primærnode bekrefte et salg og dø før replikaen har fått det; replikaen\nforfremmes, salget er borte, og den samme enheten selges på nytt. Løsningen i\nnotatet er en synkron standby eller et datalager bygd på Raft, og prisen er\nekstra latens på hver commit.\n\nLogisk replikering settes opp med to setninger. Publisheren må ha\n`wal_level = logical`, og tabellene må allerede finnes hos subscriberen, fordi\ndefinisjonene deres ikke blir kopiert:\n\n```sql\n-- på publisheren\nCREATE PUBLICATION shop_pub FOR TABLE orders, customers;\n\n-- på subscriberen\nCREATE SUBSCRIPTION shop_sub\n    CONNECTION 'host=10.0.0.1 dbname=shop user=replicator'\n    PUBLICATION shop_pub;\n```\n\nAbonnementet kopierer først radene som allerede ligger i tabellene, og legger\nderetter inn alle senere endringer.\n\n## Hvor det går galt\n\n**Brukeren ser ikke det som nettopp ble lagret.** Applikasjonen skriver til\nprimærnoden og leser resultatet tilbake fra en replika som fortsatt ligger et\nøyeblikk etter, så en lagret innstilling ser ut til å hoppe tilbake. Send en\nbrukers lesinger til primærnoden en kort stund etter hver skriving. Der data må\nvære synlige på standbyen i samme øyeblikk som commit returnerer, venter\n`synchronous_commit = remote_apply` til de synkrone standbyene har spilt av\ntransaksjonen, til en høyere pris per commit.\n\n**Lange spørringer på replikaen blir avbrutt.** Standbyen må spille av endringer\nsom kolliderer med en spørring som kjører: vacuum som fjerner radversjoner\nspørringen fortsatt kan se, eller den eksklusive låsen som `DROP TABLE` og mange\nformer for `ALTER TABLE` tar. Avspillingen venter opptil\n`max_standby_streaming_delay`, 30 sekunder som standard, og avbryter så\nspørringen. En replika for rapporter kan få en lengre frist og blir da liggende\nlenger etter mens den venter. `hot_standby_feedback = on` stopper avbruddene som\nvacuum gir, men dokumentasjonen advarer om at det kan blåse opp primærnoden.\n`pg_stat_database_conflicts` på standbyen teller avbruddene etter årsak, og\napplikasjonen bør prøve en avbrutt spørring på nytt.\n\n**Et glemt replikeringsspor fyller disken på primærnoden.** Et spor holder på\nWAL til standbyen har mottatt den, også når standbyen er slått av eller for\nlengst borte, og `max_slot_wal_keep_size` er -1 som standard, altså ingen\ngrense. Sjekk sporene jevnlig:\n\n```sql\nSELECT slot_name, active, wal_status, safe_wal_size\nFROM   pg_replication_slots;\n```\n\nSlett et spor når standbyen er borte. Setter man `max_slot_wal_keep_size`, får\nhvert spor et tak på hva det kan holde på; en standby som kommer lenger bak, får\nsporet sitt ugyldiggjort, og `wal_status` viser `lost`.\n`idle_replication_slot_timeout`, som er slått av som standard, ugyldiggjør spor\nsom har vært inaktive lenger enn tiden som er angitt.\n\n**Skrivingene stopper når en synkron standby gjør det.** Er bare én standby\nnavngitt, og den er nede, venter hver commit på primærnoden, kanskje for alltid.\nNavngi flere kandidater enn antallet som kreves, som i `ANY 1 (db2, db3)`. Går\nikke det, senk antallet eller tøm `synchronous_standby_names`, og last inn\nkonfigurasjonen på nytt.\n\n**To servere tror begge at de er primærnoden.** PostgreSQL forfremmer en standby\nnår man ber om det, med `pg_ctl promote` eller `SELECT pg_promote()`, men har\ningen egen programvare som oppdager at primærnoden har falt ut, og ingenting\nhindrer den gamle i å komme tilbake og ta imot skrivinger. Dokumentasjonen\nadvarer om at det fører til forvirring og til slutt datatap. Steng den gamle\nprimærnoden ute, ved å slå den av eller kutte nettverket dens, før standbyen\nforfremmes, og bygg den opp igjen som standby før den slippes inn igjen.\n\n**Logisk replikering etterlater noe.** Skjemaendringer replikeres ikke, så en\nkolonne som legges til hos publisheren, stopper replikeringen til subscriberen\nogså har den; gjør endringer som bare legger til noe, hos subscriberen først.\nSekvenser replikeres heller ikke: radene kommer med ID-ene sine, men sekvensene\nhos subscriberen står fortsatt på startverdien, og etter et bytte feiler\ninnsettinger på dupliserte nøkler. Sett hver sekvens forbi den høyeste verdien i\nbruk før byttet.\n\n**En Redis-master starter tom og tar replikaene med seg.** Er persistens slått\nav på masteren, og noe starter den automatisk på nytt, kommer den tilbake med et\ntomt datasett, og replikaene kopierer det og sletter sine egne data. Ha\npersistens slått på, eller ikke la masteren starte på nytt automatisk.\n\n## Les mer\n\n- [High availability](https://www.postgresql.org/docs/current/high-availability.html)\n  — PostgreSQL-dokumentasjonens oversikt over primær- og standbyservere, synkron\n  og asynkron replikering og failover.\n- [Log-Shipping Standby Servers](https://www.postgresql.org/docs/current/warm-standby.html)\n  — strømmende replikering, replikeringsspor og oppsett av synkron replikering.\n- [Hot Standby](https://www.postgresql.org/docs/current/hot-standby.html) —\n  skrivebeskyttede spørringer på en standby, konfliktene som avbryter dem, og\n  innstillingene som veier forsinkelse mot avbrudd.\n- [pg_basebackup](https://www.postgresql.org/docs/current/app-pgbasebackup.html)\n  — kopiering av en kjørende klynge for å starte en standby, med alle valgene\n  som er brukt over.\n- [Restrictions](https://www.postgresql.org/docs/current/logical-replication-restrictions.html)\n  — det logisk replikering ikke tar med: skjema, sekvenser, large objects og alt\n  annet enn tabeller.\n- [Redis replication](https://redis.io/docs/latest/operate/oss_and_stack/management/replication/)\n  — hvordan Redis-replikaer følger en master, hvorfor replikeringen er asynkron,\n  og faren ved å starte på nytt uten persistens.\n\n\u003chttps://engineer.company/nb/glossary/replication/\u003e\n","date_modified":"2026-10-29T11:17:41Z","description":"Slik holder replikering standbyservere i takt med databasen: strømmende og logisk replikering i PostgreSQL, synkront eller ikke, og feilene å planlegge for.","formats":{"gemtext":"https://engineer.company/nb/glossary/replication/index.gmi","gopher":"https://engineer.company/nb/glossary/replication/gophermap","html":"https://engineer.company/nb/glossary/replication/","json":"https://engineer.company/nb/glossary/replication/index.json","markdown":"https://engineer.company/nb/glossary/replication/index.md","pdf":"https://engineer.company/nb/glossary/replication/index.pdf"},"kind":"page","language":"nb","title":"Hva er replikering?","url":"https://engineer.company/nb/glossary/replication/","version":1}