{"canonical_url":"https://engineer.company/da/glossary/replication/","content_markdown":"# Replikering\n\n## Hvad det er\n\nReplikering holder kopier af en database på andre servere og sender hver kopi\nalle de ændringer, der laves i originalen, så de holdes i takt. Mange bruger\nogså det engelske ord replication, og hvor sammenhængen kan efterlade tvivl,\ntaler man om databasereplikering. PostgreSQL-dokumentationen kalder den ene\nserver, der tager imod skrivninger, den primære og de servere, der følger den,\nstandbyservere. Redis taler om en master og dens replikaer.\n\nPostgreSQL har to slags, og de kopierer forskellige ting.\n\nFysisk replikering kopierer write-ahead-loggen (WAL), den log, hver ændring\nskrives til, før den når datafilerne. En standby afspiller loggen og bliver en\nblok-for-blok-kopi af hele clusteret. Ved streaming-replikering holder standbyen\nen forbindelse åben til den primære og modtager WAL-posterne, efterhånden som de\nskrives, i stedet for at vente på, at færdige WAL-filer bliver sendt over. En\nstandby, der kun afspiller og ikke tager imod forbindelser, før den forfremmes,\ner en warm standby; en, der også svarer på skrivebeskyttede forespørgsler, er en\nhot standby.\n\nLogisk replikering kopierer ændringer i rækker. En publisher sender de\nindsættelser, opdateringer og sletninger videre, der laves i udvalgte tabeller,\nhver række kendt på sin replica identity, normalt primærnøglen, og en subscriber\nanvender dem på sine egne tabeller. Fordi den arbejder med rækker og ikke med\ndiskblokke, kan den nøjes med nogle få tabeller frem for hele clusteret, endda\nover til en anden hovedversion af PostgreSQL.\n\nStreaming-replikering er asynkron som standard. Den primære bekræfter en commit,\nså snart WAL er på dens egen disk, og sender den videre bagefter;\ndokumentationen sætter forsinkelsen til typisk under et sekund, når standbyen\nkan følge med. Med synkron replikering slået til venter hver commit, til en\nstandby også har WAL.\n\n## Hvorfor det betyder noget\n\nDen første grund er at overleve tabet af en server. Når den primære går ned, kan\nen standby, der allerede har dataene, forfremmes og overtage trafikken, langt\nhurtigere end en backup kan lægges tilbage på en ny maskine.\n\nDen anden er at sprede læsningerne. I mange applikationer læser de fleste\nforespørgsler kun, og en hot standby kan besvare dem, så den primære er fri til\nskrivningerne, som kun den kan tage imod.\n\nDen tredje er at flytte data. Logisk replikering kan kopiere netop de tabeller,\nen rapporteringsdatabase har brug for, eller bringe data over på en server med\nen anden hovedversion af PostgreSQL.\n\nHver kopi kommer med et valg mellem at vente og at miste. Asynkron replikering\nkoster intet, når der committes, men en standby er altid en smule bagefter: en\nlæsning fra den kan overse en skrivning, der lige er sket, og hvis den primære\ndør, når commits, den allerede har bekræftet, måske aldrig frem til den standby,\nder tager over. Synkron replikering lukker hullet og lægger en tur frem og\ntilbage over netværket ind i hver commit.\n\nReplikering er heller ikke en backup. En standby afspiller trofast en utilsigtet\n`DELETE` uden `WHERE`, så få øjeblikke senere har alle kopier fejlen. Det kræver\nstadig en backup at rulle den tilbage.\n\n## Sådan ser det ud i praksis\n\nEn webshop kører sin database på én primær server på `10.0.0.1` og tilføjer en\nserver mere, `db2`, som streaming-replika. På `db2`, hvor PostgreSQL er\ninstalleret 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 det kørende cluster over i den mappe, `-D` peger\npå; mappen oprettes, hvis den mangler, og skal ellers være tom. Som standard\nstreamer den samtidig den WAL, der skrives under kopieringen. `-C -S db2_slot`\nopretter først en replikeringsslot på den primære, så den gemmer hver WAL-post,\nindtil den nye standby har modtaget den. `-R` opretter filen `standby.signal` og\ntilføjer forbindelsesindstillingerne, slotten medregnet, til\n`postgresql.auto.conf`. `-P` viser, hvor langt kopieringen er nået. Rollen\n`replicator` skal have attributten `REPLICATION` eller være superuser, og den\nprimæres `pg_hba.conf` skal tillade replikeringsforbindelsen.\n\nNår PostgreSQL starter på `db2`, får `standby.signal` den til at køre som\nstandby og streame fra den primære, og da `hot_standby` er slået til som\nstandard, tager den imod skrivebeskyttede forespørgsler, så snart den er\nkonsistent. På den primære viser én række pr. 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 sund replika viser `streaming` i `state` og `async` i `sync_state`.\n`replay_lag` er et skøn over, hvor lang tid nye commits var om at blive synlige\ndér; når standbyen har indhentet det hele, og WAL-aktiviteten stopper, står den\npå NULL i stedet for nul.\n\nNoten om at\n[optimere databasen, før man sharder den](/da/notes/optimise-before-you-shard/)\nforklarer, hvorfor en butik gør det. Det meste af trafikken er læsning:\nproduktsiden, kurven, ordrehistorikken. Intet af det har brug for den primære,\nsom skal holdes fri til skrivninger. En streaming-replika tager de læsninger, og\nnoten påpeger, at det er et spørgsmål om konfiguration at tilføje én, mens en\nshard er et projekt. Den nævner to forbehold. En replika halter en smule\nbagefter, så det, en bruger lige har skrevet, skal læses fra den primære. Og en\nlang rapport på en replika kan blive annulleret, når den holder ændringer\ntilbage, som replikaen skal afspille.\n\nDet kræver én indstilling på den primære at få en commit til at vente på en\nstandby. Hver standby får et navn via `application_name` i sin\n`primary_conninfo`, og den primære oplister de navne, den må vente på:\n\n```ini\nsynchronous_standby_names = 'ANY 1 (db2, db3)'\n```\n\nNu venter hver commit, til dens WAL ligger på disken både på den primære og på\nmindst én af `db2` og `db3`. `synchronous_commit` kan sættes pr. bruger, pr.\ndatabase eller pr. transaktion, så ordren, der tager imod betalingen, kan vente,\nmens en tæller for sidevisninger committer i lokalt tempo. Noten om at\n[sælge den sidste billet præcis én gang](/da/notes/selling-limited-stock-without-overselling/)\nviser, hvorfor det betyder noget for lageret. Med asynkron replikering kan en\nprimær bekræfte et salg og dø, før dens replika har det; replikaen forfremmes,\nsalget er væk, og den samme enhed sælges igen. Notens løsning er en synkron\nstandby eller et lager bygget på Raft, og prisen er ekstra latens på hver\ncommit.\n\nLogisk replikering sættes op med to sætninger. Publisheren skal have\n`wal_level = logical`, og tabellerne skal allerede findes hos subscriberen,\nfordi deres definitioner ikke bliver kopieret:\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 de rækker, der allerede ligger i tabellerne, og\nanvender derefter alle senere ændringer.\n\n## Hvor det går galt\n\n**En bruger kan ikke se det, vedkommende lige har skrevet.** Applikationen\nskriver til den primære og læser resultatet tilbage fra en replika, der stadig\nhalter et øjeblik bagefter, så en gemt indstilling ser ud til at springe\ntilbage. Send en brugers læsninger til den primære i et kort stykke tid efter\nhver skrivning. Hvor data skal være synlige på standbyen i samme øjeblik, som\ncommit melder tilbage, venter `synchronous_commit = remote_apply`, til de\nsynkrone standbyer har afspillet transaktionen, til en højere pris pr. commit.\n\n**Lange forespørgsler på replikaen bliver annulleret.** Standbyen skal afspille\nændringer, der støder sammen med en igangværende forespørgsel: vacuum, der\nfjerner rækkeversioner, forespørgslen stadig kan se, eller den eksklusive lås,\nsom `DROP TABLE` og mange former for `ALTER TABLE` tager. Afspilningen venter op\ntil `max_standby_streaming_delay`, som standard 30 sekunder, og annullerer så\nforespørgslen. En replika til rapporter kan få en længere frist og halter så\nlængere bagefter, mens den venter. `hot_standby_feedback = on` stopper de\nannulleringer, vacuum giver, men dokumentationen advarer om, at det kan få den\nprimære til at svulme op. `pg_stat_database_conflicts` på standbyen tæller\nannulleringerne efter årsag, og applikationen bør prøve en annulleret\nforespørgsel igen.\n\n**En glemt slot fylder den primæres disk.** En slot holder på WAL, til dens\nstandby har modtaget den, også når standbyen er slukket eller for længst væk, og\n`max_slot_wal_keep_size` er som standard -1, altså ingen grænse. Tjek slottene\njævnligt:\n\n```sql\nSELECT slot_name, active, wal_status, safe_wal_size\nFROM   pg_replication_slots;\n```\n\nSlet en slot, når dens standby er væk. Sætter man `max_slot_wal_keep_size`, får\nhver slot et loft over, hvad den må holde på; en standby, der kommer længere\nbagud, finder sin slot ugyldiggjort, og `wal_status` viser `lost`.\n`idle_replication_slot_timeout`, der som standard er slået fra, ugyldiggør\nslots, som har været inaktive længere end den angivne tid.\n\n**Skrivningerne går i stå, når en synkron standby gør.** Er der kun navngivet én\nstandby, og er den nede, venter hver commit på den primære, måske for evigt.\nNavngiv flere kandidater end det antal, der kræves, som i `ANY 1 (db2, db3)`.\nKan det ikke lade sig gøre, så sænk antallet eller tøm\n`synchronous_standby_names`, og genindlæs konfigurationen.\n\n**To servere tror begge, at de er den primære.** PostgreSQL forfremmer en\nstandby, når man beder om det, med `pg_ctl promote` eller `SELECT pg_promote()`,\nmen har ingen software, der selv opdager, at den primære er faldet ud, og intet\nforhindrer den gamle i at komme tilbage og tage imod skrivninger.\nDokumentationen advarer om, at det fører til forvirring og i sidste ende til\ndatatab. Luk den gamle primære ude, ved at slukke den eller kappe dens netværk,\nfør standbyen forfremmes, og genopbyg den som standby, før den får lov at komme\nmed igen.\n\n**Logisk replikering efterlader noget.** Skemaændringer replikeres ikke, så en\nkolonne, der tilføjes hos publisheren, stopper replikeringen, til subscriberen\nogså har den; læg tilføjende ændringer på subscriberen først. Sekvenser\nreplikeres heller ikke: rækkerne kommer med deres id'er, men subscriberens\nsekvenser står stadig på deres startværdi, og efter et skifte fejler\nindsættelser på dublerede nøgler. Sæt hver sekvens forbi den højeste værdi i\nbrug, før der skiftes.\n\n**En Redis-master genstarter tom og tager sine replikaer med sig.** Er\npersistens slået fra på masteren, og genstarter noget den automatisk, kommer den\ntilbage med et tomt datasæt, og replikaerne kopierer det og sletter deres egne\ndata. Hold persistens slået til, eller lad være med at lade masteren genstarte\nautomatisk.\n\n## Læs mere\n\n- [High availability](https://www.postgresql.org/docs/current/high-availability.html)\n  — PostgreSQL-dokumentationens overblik over primære servere og standbyservere,\n  synkron og asynkron replikering og failover.\n- [Log-Shipping Standby Servers](https://www.postgresql.org/docs/current/warm-standby.html)\n  — streaming-replikering, replikeringsslots og opsætning af synkron\n  replikering.\n- [Hot Standby](https://www.postgresql.org/docs/current/hot-standby.html) —\n  skrivebeskyttede forespørgsler på en standby, de konflikter, der annullerer\n  dem, og indstillingerne, der afvejer forsinkelse mod annulleringer.\n- [pg_basebackup](https://www.postgresql.org/docs/current/app-pgbasebackup.html)\n  — kopiering af et kørende cluster for at starte en standby, med alle de\n  tilvalg, der er brugt ovenfor.\n- [Restrictions](https://www.postgresql.org/docs/current/logical-replication-restrictions.html)\n  — det, logisk replikering ikke tager med: skema, sekvenser, large objects og\n  alt andet end 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 at genstarte uden persistens.\n\n\u003chttps://engineer.company/da/glossary/replication/\u003e\n","date_modified":"2026-10-29T11:17:41Z","description":"Sådan holder replikering standbyservere i takt med databasen: streaming og logisk replikering i PostgreSQL, synkront eller ej, og fejlene at planlægge for.","formats":{"gemtext":"https://engineer.company/da/glossary/replication/index.gmi","gopher":"https://engineer.company/da/glossary/replication/gophermap","html":"https://engineer.company/da/glossary/replication/","json":"https://engineer.company/da/glossary/replication/index.json","markdown":"https://engineer.company/da/glossary/replication/index.md","pdf":"https://engineer.company/da/glossary/replication/index.pdf"},"kind":"page","language":"da","title":"Hvad er replikering?","url":"https://engineer.company/da/glossary/replication/","version":1}