{"canonical_url":"https://engineer.company/da/glossary/high-availability/","content_markdown":"# Høj tilgængelighed\n\n## Hvad det er\n\nHøj tilgængelighed er den egenskab, at en tjeneste bliver ved med at svare, når\nen af de maskiner, diske, netforbindelser eller processer, den hviler på,\nsvigter. Den bygges som regel som en klynge: flere værter, der hver især kan\nkøre tjenesten, software, der holder øje med dem, og en procedure, der flytter\narbejdet fra en vært, der er gået ned, til en rask. ClusterLabs-projektet, der\nvedligeholder open source-klyngestakken Pacemaker og Corosync, beskriver sådan\nen klynge som noget, der koordinerer opstart, overvågning og genopretning af\ntjenester på tværs af en række værter, »for at minimere nedetid og samtidig\nbevare dataenes integritet«.\n\nSidste halvdel af den sætning vejer lige så tungt som den første. En tjeneste,\nder hurtigt kommer op igen med forkerte data, er ikke blevet mere tilgængelig.\nDen er blevet farlig.\n\nPostgreSQL-dokumentationen skelner mellem to grunde til at lade flere\ndatabaseservere arbejde sammen. Den ene er, at en anden server hurtigt kan tage\nover, hvis den primære svigter; det kalder dokumentationen høj tilgængelighed.\nDen anden er, at flere computere kan levere de samme data; det kalder den\nbelastningsfordeling. De to deler ofte maskineri, men de svarer på forskellige\nspørgsmål: høj tilgængelighed handler om at overleve en fejl, mens\nbelastningsfordeling og skalerbarhed handler om at kunne bære mere arbejde.\n\nTilgængelighed er i sig selv et tal. Det traditionelle mål er tidsbaseret: den\nandel af en periode, hvor tjenesten kunne bruges. Googles SRE-bog forklarer, at\nman for tjenester, der er spredt over hele verden, og hvor en del næsten altid\nkører et eller andet sted, i stedet måler andelen af forespørgsler, der bliver\nbesvaret korrekt. Begge dele skrives som procenter og omtales i antal nitaller.\n\nAlle højt tilgængelige løsninger er bygget af de samme få dele:\n\n- **Redundans.** En reserve for hver del, hvis svigt ville stoppe tjenesten: en\n  ekstra vært, en standby-database, en ekstra netvej. Pacemaker understøtter\n  blandt andet aktiv/passiv-par og N+1-opstillinger, hvor flere aktive noder\n  deler én reserve.\n- **Opdagelse.** Noget skal opdage fejlen. Kapitlet om failover i\n  PostgreSQL-dokumentationen beskriver et heartbeat mellem primær og standby,\n  der løbende tjekker forbindelsen, og om den primære stadig fungerer.\n- **Failover.** At flytte arbejdet: forfremme standby-serveren, flytte\n  tjenestens IP-adresse, starte processen på en anden vært.\n- **Fencing.** At sikre sig, at den svigtende node virkelig er stoppet, før\n  dens arbejde starter et andet sted.\n- **Genopbygning af reserven.** Efter en failover kører systemet uden\n  redundans, indtil en ny reserve er på plads.\n\nHøj tilgængelighed er hverken backup eller katastrofegendannelse. Den beskytter\nmod, at en enkelt del svigter, mens resten af installationen stadig kører. En\nbackup beskytter mod tab eller ødelæggelse af data, også den ødelæggelse, som en\nklynge trofast kopierer til hver eneste node, og katastrofegendannelse er planen\nfor at miste hele datacentret.\n\n## Hvorfor det betyder noget\n\nAlle tjenester har dele, der vil svigte. Hardware går i stykker,\noperativsystemkerner går ned, en virtuel maskine slettes ved en fejl, en\nnetværkspartition skærer en rask node af fra resten af klyngen.\nKubernetes-dokumentationen kalder den slags ufrivillige afbrydelser og stiller\ndem op over for frivillige, som nogen har planlagt, for eksempel at tømme en\nnode for at reparere eller opgradere den. Uden redundans bliver hver eneste af\ndem et udfald, også de planlagte, for den eneste måde at patche en enkelt\nserver på er at tage den ned.\n\nNetop det sidste er ofte den første fordel, et team mærker. Kapitlet om\nfailover i PostgreSQL-dokumentationen kalder det nyttigt at skifte jævnligt\nmellem primær og standby: så kan hver maskine tages ned efter tur til\nvedligeholdelse, og hvert skift tester, at failover-mekanismen virker, når der\ner brug for den.\n\nNitallene kan omregnes til tid. For et år på 365 dage (525.600 minutter) og en\nmåned på 30 dage (43.200 minutter) giver regnestykket:\n\n```text\nTilgængelighed   Tilladt pr. år        Tilladt pr. måned på 30 dage\n99 %             3,65 dage             7,2 timer\n99,9 %           8,76 timer            43,2 minutter\n99,95 %          4,38 timer            21,6 minutter\n99,99 %          52,56 minutter        4,32 minutter\n99,999 %         ca. 5,26 minutter     ca. 26 sekunder\n```\n\nHvert ekstra nital skærer rammen ned til en tiendedel, og prisen stiger\nhurtigere end det. SRE-bogen advarer om, at ét skridt mere i pålidelighed kan\nkoste hundrede gange så meget som det forrige, og at brugerne efter et vist\npunkt ikke kan mærke forskel: Den, der sidder med en telefon, som selv kun er\n99 % pålidelig, opdager ikke, om tjenesten bag den kører med 99,99 % eller\n99,999 %. Bogen behandler derfor et tilgængelighedsmål som både et gulv og et\nloft. En tjeneste, der er langt mere tilgængelig, end den behøver at være, har\nbrugt penge og udviklingstid, som kunne have gjort mere gavn andre steder.\n\nDerfor er målet en forretningsbeslutning, der træffes tjeneste for tjeneste. Et\nservice level objective skriver tallet ned; høj tilgængelighed er det\ningeniørarbejde, der gør tallet muligt at nå.\n\n## Sådan ser det ud i praksis\n\nTag en opdigtet bookingtjeneste med tre lag: et weblag, et applikationslag og en\nPostgreSQL-database, hver på sin egen vært. Alle tal herunder er opfundet til\neksemplet. Hvis hvert lag er oppe 99,9 % af tiden, og tjenesten har brug for\nalle tre, skal deres tilgængelighed ganges sammen. At fordoble et lag virker den\nanden vej, fordi begge kopier skal være nede på samme tid:\n\n```text\nTre lag i serie, hvert 99,9 % tilgængeligt:\n  0,999 × 0,999 × 0,999 ≈ 0,997      ca. 26 timer nede om året\n\nÉt lag fordoblet, hvis de to kopier svigter uafhængigt af hinanden:\n  1 − 0,001 × 0,001 = 0,999999       ca. et halvt minut om året\n```\n\nDen anden udregning hviler på ét ord: uafhængigt. To kopier på samme vært, i\nsamme rack, bag samme switch eller i samme zone hos samme cloududbyder deler\nskæbne, og så holder regnestykket op med at gælde. Formlen forudsætter også, at\nskiftet fra den ene kopi til den anden sker øjeblikkeligt og altid lykkes, og\ndet kan kun test vise.\n\nI Kubernetes er det netop det, topology spread constraints er til.\nDokumentationens eget eksempel er en arbejdsbyrde, der kan skrumpe til to pods:\nDem vil man ikke have på samme node, hvor én fejl kan tage hele arbejdsbyrden\noffline. En regel i pod-skabelonen spreder replikaerne over zoner:\n\n```yaml\ntopologySpreadConstraints:\n    - maxSkew: 1\n      topologyKey: topology.kubernetes.io/zone\n      whenUnsatisfiable: DoNotSchedule\n      labelSelector:\n          matchLabels:\n              app: booking\n```\n\nMed `DoNotSchedule` lader scheduleren hellere en pod vente end at placere den,\nså zonerne kommer til at afvige med mere end én. Planlagt vedligeholdelse\nkræver en sikring mere. Et PodDisruptionBudget begrænser, hvor mange replikaer\naf en applikation der må være nede på samme tid på grund af frivillige\nafbrydelser. `kubectl drain` respekterer budgettet, fordi kommandoen beder\nEviction API'et om at fjerne hver pod; sletter man pods direkte, går man uden\nom budgettet:\n\n```yaml\napiVersion: policy/v1\nkind: PodDisruptionBudget\nmetadata:\n    name: booking-pdb\nspec:\n    maxUnavailable: 1\n    selector:\n        matchLabels:\n            app: booking\n```\n\nDokumentationen anbefaler `maxUnavailable` frem for `minAvailable`, fordi det\nautomatisk følger med, når antallet af replikaer ændrer sig.\n\nDatabasen er det sværeste lag, fordi den rummer tilstand. PostgreSQL kan holde\nen hot standby, der besvarer skrivebeskyttede forespørgsler, eller en warm\nstandby, som man ikke kan forbinde sig til, før den er forfremmet. At vælge\nmellem synkron og asynkron replikering er at vælge, hvad en failover må koste\naf data. Ved synkron replikering venter bekræftelsen af en commit på det konfigurerede antal synkrone standby-servere på det konfigurerede bekræftelsesniveau. Indstillingerne `synchronous_standby_names` og `synchronous_commit` fastlægger betingelserne. Ved failover skal der vælges en standby-server med de bekræftede data; en asynkron standby kan stadig være bagud. Prisen for det første er\nhastighed: Dokumentationen bemærker, at en fuldt synkron løsning over et\nlangsomt netværk kan mere end halvere ydeevnen.\n\nPostgreSQL afgør ikke selv, hvornår der skal skiftes. Ifølge dokumentationen\nleverer den ingen systemsoftware, der kan opdage en svigtende primær og give\nstandby-serveren besked; den opgave hører, ligesom flytningen af IP-adressen,\ntil ekstern klyngesoftware. Selve forfremmelsen er ét trin, `pg_ctl promote`\neller funktionen `pg_promote()`. Det, der kommer bagefter, er den del, planerne\nglemmer. Når den gamle primære er væk, kører klyngen på én server, hvad\ndokumentationen kalder en degenereret tilstand, indtil en ny standby er bygget.\nVærktøjet `pg_rewind` kan gøre det hurtigere på store klynger.\n\nHer på sitet viser casen om\n[e-mail med failover og leveringslog](/da/portfolio/built-email-with-failover-and-delivery-logging/)\nsamme mønster brugt på en ekstern afhængighed. Tre e-mailudbydere sidder bag én\ngrænseflade, failover mellem dem sker automatisk i stedet for som en ændring i\nkonfigurationen foretaget under pres, og et tjek ved opstart sender en rigtig\nbesked, så staging og produktion nægter at starte uden en udbyder, der virker.\nIfølge casen betyder en udbyders dårlige eftermiddag nu en forringet vej frem\nfor et udfald, til gengæld for tre integrationer, der skal holdes i live. Hvor\ntilgængeligt et system skal være, er en beslutning for sig: Siden om\n[serviceniveau](/da/service-levels/) forklarer, at tilgængeligheden skrives ind\ni aftalen for hvert system for sig, fordi en rapport, der dannes om natten, og\nen betalingstjeneste kræver forskellige tal.\n\n## Hvor det går galt\n\n**Redundans, der deler skæbne.** To kopier på én vært, én strømforsyning, én\nswitch eller én zone hos en cloududbyder svigter sammen. Følg hver reserve\ntilbage til det, den afhænger af, og spred replikaer over fejldomæner med vilje\nfrem for ved et tilfælde.\n\n**Split brain.** Når noderne i en klynge mister forbindelsen til hinanden, men\nbliver ved med at køre, kan hver side konkludere, at den anden er død, og selv\nstarte tjenesten. Pacemaker-dokumentationen beskriver følgen: Den samme IP-adresse\naktiveret på to værter gør det uforudsigeligt, hvilken vært de indgående pakker når,\nog for en database kan skaden være ødelagte eller divergerende data. Fencing,\nogså kaldet STONITH (Shoot The Other Node In The Head), er værnet: En\nfence-enhed, for eksempel en strømafbryder, som klyngen styrer, kobler den\nsvigtende node fra, før dens arbejde starter et andet sted. Dokumentationen\nslår fast, at en klynge ikke sikkert kan komme sig over en node, der ikke\nsvarer, uden fencing, og at fence-enheden ikke må afhænge af klyngens eget\nnetværk, for så bliver det netværk et enkelt fejlpunkt.\n\n**En failover, ingen har prøvet.** En standby, der aldrig er blevet forfremmet,\ner et håb, ikke en plan. Skift roller efter en fast plan, som\nPostgreSQL-dokumentationen lægger op til, skriv proceduren ned, og øv den, som\nchaos engineering øver andre fejl.\n\n**At glemme den degenererede tilstand.** Efter en failover er der ingen\nreserve. Hvis genopbygningen af standby-serveren er langsom eller manuel,\nbliver den næste fejl, hvor lille den end er, et udfald. Behandl\ngenetableringen af redundansen som en del af driftshændelsen, ikke som en\nopgave til senere.\n\n**At tro, at asynkron replikering ikke mister noget.** Den kan miste de sidste\ntransaktioner, der blev gennemført før fejlen. Afgør for hver database, om det\ner acceptabelt, og gør afvejningen synlig for dem, der ejer dataene.\n\n**At forveksle replikering med backup.** En standby kopierer en fejlagtig\n`DELETE` lige så trofast som en korrekt skrivning. Høj tilgængelighed holder\ntjenesten oppe; kun en backup lader et team vende tilbage til dataene, som de\nvar.\n\n**To noder og ingen til at afgøre striden.** Pacemaker-dokumentationen påpeger,\nat en node, der er faldet ud på grund af strømsvigt, ser præcis ud som en node,\nman har mistet netværksforbindelsen til. Med to medlemmer ser hver side netop\ndet. Kubernetes kræver mindst tre kontrolplan-noder i sin stablede opstilling,\nog PostgreSQL-dokumentationen nævner en tredje witness-server, der kan\nforhindre nogle forkerte failovers, men advarer om, at den ekstra kompleksitet\nkun er umagen værd med omhyggelig opsætning og grundig test.\n\n**At betale for nitaller, ingen kan se.** Hvert ekstra nital koster mere end\ndet forrige, og brugerne når tjenesten gennem netværk og enheder, der er mindre\npålidelige end målet. Vælg tallet ud fra, hvad brugerne og forretningen har\nbrug for, og byg derefter.\n\n## Læs mere\n\n- [ClusterLabs](https://clusterlabs.org/) — open source-klyngestakken til høj\n  tilgængelighed med projektets definition af, hvad en klynge koordinerer, og\n  hvorfor den har brug for fencing.\n- [High Availability, Load Balancing, and Replication](https://www.postgresql.org/docs/current/high-availability.html)\n  — PostgreSQL-kapitlet om primære servere og standby-servere, om synkrone og\n  asynkrone løsninger og om, hvad de koster.\n- [Failover](https://www.postgresql.org/docs/current/warm-standby-failover.html)\n  — PostgreSQL om heartbeats, witness-servere, STONITH, forfremmelse og den\n  degenererede tilstand.\n- [Fencing](https://clusterlabs.org/projects/pacemaker/doc/3.0/Pacemaker_Explained/html/fencing.html)\n  — Pacemaker Explained om split brain, fence-enheder samt fencing og kvorum.\n- [Embracing Risk](https://sre.google/sre-book/embracing-risk/) — Googles\n  SRE-bog om at måle tilgængelighed, om hvad hvert nital koster, og om at vælge\n  et mål.\n- [Disruptions](https://kubernetes.io/docs/concepts/workloads/pods/disruptions/)\n  — frivillige og ufrivillige afbrydelser i Kubernetes, og hvordan et\n  PodDisruptionBudget begrænser dem.\n\n\u003chttps://engineer.company/da/glossary/high-availability/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvad høj tilgængelighed betyder, hvordan redundans, failover og fencing holder en tjeneste kørende, hvad hvert ekstra nital koster, og hvor klynger fejler.","formats":{"gemtext":"https://engineer.company/da/glossary/high-availability/index.gmi","gopher":"https://engineer.company/da/glossary/high-availability/gophermap","html":"https://engineer.company/da/glossary/high-availability/","json":"https://engineer.company/da/glossary/high-availability/index.json","markdown":"https://engineer.company/da/glossary/high-availability/index.md","pdf":"https://engineer.company/da/glossary/high-availability/index.pdf"},"kind":"page","language":"da","title":"Hvad er høj tilgængelighed?","url":"https://engineer.company/da/glossary/high-availability/","version":1}