{"canonical_url":"https://engineer.company/sv/glossary/high-availability/","content_markdown":"# Hög tillgänglighet\n\n## Vad det är\n\nHög tillgänglighet är den egenskap som gör att en tjänst fortsätter att svara\nnär någon av maskinerna, diskarna, nätförbindelserna eller processerna bakom den\nslutar fungera. Den byggs oftast som ett kluster: flera värdar som var för sig\nkan köra tjänsten, mjukvara som håller koll på dem och en procedur som flyttar\narbetet från en värddator som har gått ner till en frisk.\nClusterLabs-projektet, som underhåller klusterstacken Pacemaker och Corosync\nmed öppen källkod, beskriver ett sådant kluster som något som samordnar start,\növervakning och återställning av tjänster över en uppsättning värdar, ”för att\nminimera driftstopp och samtidigt bevara dataintegriteten”.\n\nDen andra halvan av den meningen väger lika tungt som den första. En tjänst som\nsnabbt kommer tillbaka med fel data har inte blivit mer tillgänglig. Den har\nblivit farlig.\n\nPostgreSQL-dokumentationen skiljer mellan två skäl att låta flera\ndatabasservrar arbeta tillsammans. Det ena är att en andra server snabbt ska\nkunna ta över om den primära fallerar, vilket dokumentationen kallar hög\ntillgänglighet. Det andra är att flera datorer ska kunna leverera samma data,\nvilket den kallar lastbalansering. De två delar ofta maskineri, men de löser\nolika problem: hög tillgänglighet handlar om att överleva ett fel, medan\nlastbalansering och skalbarhet handlar om att klara mer arbete.\n\nTillgänglighet är i sig ett tal. Det traditionella måttet är tidsbaserat: den\nandel av en period då tjänsten gick att använda. Googles SRE-bok förklarar att\nman för tjänster som är spridda över hela världen, där någon del nästan alltid\när igång någonstans, i stället mäter andelen förfrågningar som besvaras\nkorrekt. Båda skrivs som procenttal och anges i antal nior.\n\nAlla högt tillgängliga lösningar byggs av samma fåtal delar:\n\n- **Redundans.** En reserv för varje del vars bortfall skulle stoppa tjänsten:\n  en extra värddator, en standby-databas, en extra nätväg. Pacemaker stöder\n  bland annat aktiv/passiv-par och N+1-uppsättningar, där flera aktiva noder\n  delar på en reserv.\n- **Upptäckt.** Något måste märka att felet har inträffat. Kapitlet om failover\n  i PostgreSQL-dokumentationen beskriver ett heartbeat mellan primär och standby\n  som hela tiden kontrollerar förbindelsen och om den primära fortfarande\n  fungerar.\n- **Failover.** Att flytta arbetet: befordra standby-servern, flytta tjänstens\n  IP-adress, starta processen på en annan värddator.\n- **Fencing.** Att se till att noden som har fallerat verkligen har stannat\n  innan dess arbete startar någon annanstans.\n- **Återuppbyggnad av reserven.** Efter en failover körs systemet utan\n  redundans tills en ny reserv är på plats.\n\nHög tillgänglighet är varken en säkerhetskopia eller katastrofåterställning. Den\nskyddar mot att en enskild del går sönder medan resten av anläggningen\nfortfarande är igång. En säkerhetskopia skyddar mot att data går förlorade\neller förstörs, även när ett kluster troget har kopierat förstörelsen till\nvarenda nod, och katastrofåterställning är planen för att förlora hela\ndatacentret.\n\n## Varför det spelar roll\n\nAlla tjänster har delar som kommer att gå sönder. Hårdvara slutar fungera,\noperativsystemets kärna kraschar, en virtuell maskin raderas av misstag, en\nnätverkspartition skär av en frisk nod från resten av klustret.\nKubernetes-dokumentationen kallar sådant ofrivilliga avbrott och ställer dem\nmot frivilliga avbrott som någon har planerat, till exempel att tömma en nod för\natt reparera eller uppgradera den. Utan redundans blir vart och ett av dem ett\ndriftstopp, även de planerade, eftersom det enda sättet att patcha en ensam\nserver är att stänga av den.\n\nJust det sista är ofta den första fördelen ett team märker. Kapitlet om\nfailover i PostgreSQL-dokumentationen kallar det användbart att regelbundet\nväxla mellan primär och standby: då kan varje maskin tas ner i tur och ordning\nför underhåll, och varje växling testar att failover-mekanismen fungerar när\nden behövs.\n\nNiorna går att räkna om till tid. För ett år på 365 dagar (525 600 minuter) och\nen månad på 30 dagar (43 200 minuter) blir räkningen:\n\n```text\nTillgänglighet   Tillåtet per år       Tillåtet per månad på 30 dagar\n99 %             3,65 dagar            7,2 timmar\n99,9 %           8,76 timmar           43,2 minuter\n99,95 %          4,38 timmar           21,6 minuter\n99,99 %          52,56 minuter         4,32 minuter\n99,999 %         ca 5,26 minuter       ca 26 sekunder\n```\n\nVarje extra nia skär ner utrymmet till en tiondel, och kostnaden stiger\nsnabbare än så. SRE-boken varnar för att ett steg till i tillförlitlighet kan\nkosta hundra gånger så mycket som det förra, och för att användarna efter en\nviss punkt inte märker någon skillnad: den som sitter med en telefon som själv\nbara är 99 % tillförlitlig märker inte om tjänsten bakom kör med 99,99 % eller\n99,999 %. Boken behandlar därför ett tillgänglighetsmål som både ett golv och\nett tak. En tjänst som är mycket mer tillgänglig än den behöver vara har lagt\npengar och utvecklingstid som hade gjort mer nytta någon annanstans.\n\nDärför är målet ett affärsbeslut som fattas tjänst för tjänst. Ett\nservicenivåmål skriver ner siffran; hög tillgänglighet är ingenjörsarbetet som\ngör det möjligt att nå den.\n\n## Så ser det ut i praktiken\n\nTa en tänkt bokningstjänst med tre lager: ett webblager, ett applikationslager\noch en PostgreSQL-databas, var och en på sin egen värddator. Alla siffror nedan\när påhittade för exemplets skull. Om varje lager är uppe 99,9 % av tiden och\ntjänsten behöver alla tre, ska deras tillgänglighet multipliceras. Att\ndubblera ett lager verkar åt andra hållet, eftersom båda kopiorna måste vara\nnere samtidigt:\n\n```text\nTre lager i serie, vart och ett 99,9 % tillgängligt:\n  0,999 × 0,999 × 0,999 ≈ 0,997      ca 26 timmar nere per år\n\nEtt lager dubblerat, om de två kopiorna fallerar oberoende av varandra:\n  1 − 0,001 × 0,001 = 0,999999       ca en halv minut per år\n```\n\nDen andra uträkningen vilar på ett ord: oberoende. Två kopior på samma\nvärddator, i samma rack, bakom samma switch eller i samma zon hos samma\nmolnleverantör delar öde, och då slutar räkningen att gälla. Formeln\nförutsätter också att bytet från den ena kopian till den andra sker omedelbart\noch alltid lyckas, och det kan bara tester visa.\n\nI Kubernetes är det precis det som topology spread constraints finns till för.\nDokumentationens eget exempel är en arbetslast som kan krympa till två poddar:\ndem vill man inte ha på samma nod, där ett enda fel kan slå ut hela\narbetslasten. En regel i poddmallen sprider replikerna över 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` låter schemaläggaren hellre en podd vänta än att placera\nden där zonerna skulle skilja sig åt med mer än en. Planerat underhåll kräver\nytterligare ett skydd. En PodDisruptionBudget begränsar hur många repliker av\nen applikation som får vara nere samtidigt på grund av frivilliga avbrott.\n`kubectl drain` respekterar budgeten, eftersom kommandot ber Eviction-API:et\natt avlägsna varje podd; den som raderar poddar direkt går runt budgeten:\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 rekommenderar `maxUnavailable` framför `minAvailable`,\neftersom den inställningen automatiskt följer med när antalet repliker ändras.\n\nDatabasen är det svåraste lagret, eftersom den har tillstånd. PostgreSQL kan\nhålla en hot standby, som tar emot frågor som bara läser data, eller en warm\nstandby, som man inte kan ansluta till förrän den har befordrats. Att välja\nmellan synkron och asynkron replikering är att välja vad en failover får kosta\ni data. Vid synkron replikering väntar bekräftelsen av en commit på det konfigurerade antalet synkrona standby-servrar på den konfigurerade bekräftelsenivån. Inställningarna `synchronous_standby_names` och `synchronous_commit` anger villkoren. Vid failover måste en standby-server med de bekräftade data väljas; en asynkron standby kan fortfarande ligga efter. Priset för det första är\nhastighet: dokumentationen påpekar att en helt synkron lösning över ett\nlångsamt nätverk kan mer än halvera prestandan.\n\nPostgreSQL avgör inte själv när en failover ska ske. Enligt dokumentationen\nlevererar den ingen systemmjukvara som kan upptäcka en primär som har fallerat\noch meddela standby-servern; den uppgiften hör, liksom flytten av IP-adressen,\ntill extern klustermjukvara. Själva befordran är ett enda steg, `pg_ctl promote`\neller funktionen `pg_promote()`. Det som kommer efteråt är den del som planerna\nglömmer. När den gamla primära är borta körs klustret på en enda server, vilket\ndokumentationen kallar ett degenererat tillstånd, tills en ny standby har\nbyggts. Verktyget `pg_rewind` kan snabba upp det på stora kluster.\n\nHär på webbplatsen visar portföljposten om\n[e-post med failover och leveransloggning](/sv/portfolio/built-email-with-failover-and-delivery-logging/)\nsamma mönster tillämpat på ett externt beroende. Tre e-postleverantörer sitter\nbakom ett gemensamt gränssnitt, failover mellan dem sker automatiskt i stället\nför som en konfigurationsändring under press, och en kontroll vid uppstart\nskickar ett verkligt meddelande, så att staging och produktion vägrar starta\nutan en leverantör som fungerar. Enligt portföljposten blev en leverantör som\nhar en dålig eftermiddag ett nedsatt driftläge i stället för ett avbrott, till\npriset av tre integrationer att hålla vid liv. Hur tillgängligt ett system\nmåste vara är ett beslut i sig: sidan om [servicenivå](/sv/service-levels/)\nförklarar att tillgängligheten skrivs in i avtalet för varje system för sig,\neftersom en rapport som tas fram under natten och en betaltjänst behöver olika\nsiffror.\n\n## Var det går fel\n\n**Redundans som delar öde.** Två kopior på samma värddator, samma\nströmförsörjning, samma switch eller samma zon hos en molnleverantör går sönder\ntillsammans. Följ varje reserv bakåt till det den är beroende av, och sprid\nreplikerna över feldomäner med avsikt i stället för av en slump.\n\n**Split brain.** När noderna i ett kluster tappar kontakten med varandra men\nfortsätter att köra kan varje sida dra slutsatsen att den andra är död och\nsjälv starta tjänsten. Pacemaker-dokumentationen beskriver följden: samma\nIP-adress aktiverad på två värdar gör det oförutsägbart vilken värd de inkommande\npaketen når, och för en databas kan skadan bli förstörda eller divergerande data.\nFencing, även kallat STONITH (Shoot The Other Node In The Head), är skyddet: en\nfence-enhet, till exempel en strömbrytare som klustret styr, kopplar bort noden\nsom har fallerat innan dess arbete startar någon annanstans. Dokumentationen\nslår fast att ett kluster inte säkert kan återhämta sig från en nod som inte\nsvarar utan fencing, och att fence-enheten inte får vara beroende av klustrets\neget nätverk, eftersom det nätverket då blir en enskild felpunkt.\n\n**En failover som ingen har provat.** En standby som aldrig har befordrats är\nett hopp, inte en plan. Byt roller med jämna mellanrum, som\nPostgreSQL-dokumentationen föreslår, skriv ner proceduren och öva på den på\nsamma sätt som chaos engineering övar på andra fel.\n\n**Att glömma det degenererade tillståndet.** Efter en failover finns det ingen\nreserv. Om återuppbyggnaden av standby-servern är långsam eller manuell blir\nnästa fel, hur litet det än är, ett driftstopp. Behandla återställandet av\nredundansen som en del av incidenten, inte som en uppgift till senare.\n\n**Att tro att asynkron replikering inte förlorar något.** Den kan förlora de\nsista transaktionerna som genomfördes före felet. Avgör för varje databas om\ndet är acceptabelt, och gör avvägningen synlig för dem som äger data.\n\n**Att förväxla replikering med en säkerhetskopia.** En standby kopierar en\nfelaktig `DELETE` lika troget som en korrekt skrivning. Hög tillgänglighet\nhåller tjänsten uppe; bara en säkerhetskopia låter ett team gå tillbaka till\ndata så som de var.\n\n**Två noder och ingen skiljedomare.** Pacemaker-dokumentationen påpekar att en\nnod som har fallit bort på grund av strömavbrott ser exakt likadan ut som en\nnod som man har tappat nätverkskontakten med. Med två medlemmar ser varje sida\njust det. Kubernetes kräver minst tre kontrollplansnoder i sin staplade\nuppsättning, och PostgreSQL-dokumentationen nämner en tredje witness-server som\nkan förhindra vissa felaktiga failovers, men varnar för att den extra\nkomplexiteten bara lönar sig med noggrann konfiguration och grundlig testning.\n\n**Att betala för nior som ingen kan se.** Varje extra nia kostar mer än den\nförra, och användarna når tjänsten via nätverk och enheter som är mindre\ntillförlitliga än målet. Välj siffran utifrån vad användarna och verksamheten\nbehöver, och bygg sedan efter den.\n\n## Läs mer\n\n- [ClusterLabs](https://clusterlabs.org/) — klusterstacken med öppen källkod\n  för hög tillgänglighet, med projektets definition av vad ett kluster samordnar\n  och varför det behöver fencing.\n- [High Availability, Load Balancing, and Replication](https://www.postgresql.org/docs/current/high-availability.html)\n  — PostgreSQL-kapitlet om primära servrar och standby-servrar, om synkrona och\n  asynkrona lösningar och om vad de kostar.\n- [Failover](https://www.postgresql.org/docs/current/warm-standby-failover.html)\n  — PostgreSQL om heartbeats, witness-servrar, STONITH, befordran och det\n  degenererade tillståndet.\n- [Fencing](https://clusterlabs.org/projects/pacemaker/doc/3.0/Pacemaker_Explained/html/fencing.html)\n  — Pacemaker Explained om split brain, fence-enheter samt fencing och kvorum.\n- [Embracing Risk](https://sre.google/sre-book/embracing-risk/) — Googles\n  SRE-bok om att mäta tillgänglighet, om vad varje nia kostar och om att välja\n  ett mål.\n- [Disruptions](https://kubernetes.io/docs/concepts/workloads/pods/disruptions/)\n  — frivilliga och ofrivilliga avbrott i Kubernetes, och hur en\n  PodDisruptionBudget begränsar dem.\n\n\u003chttps://engineer.company/sv/glossary/high-availability/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Vad hög tillgänglighet betyder, hur redundans, failover och fencing håller en tjänst igång, vad varje extra nia kostar och var kluster fallerar.","formats":{"gemtext":"https://engineer.company/sv/glossary/high-availability/index.gmi","gopher":"https://engineer.company/sv/glossary/high-availability/gophermap","html":"https://engineer.company/sv/glossary/high-availability/","json":"https://engineer.company/sv/glossary/high-availability/index.json","markdown":"https://engineer.company/sv/glossary/high-availability/index.md","pdf":"https://engineer.company/sv/glossary/high-availability/index.pdf"},"kind":"page","language":"sv","title":"Vad är hög tillgänglighet?","url":"https://engineer.company/sv/glossary/high-availability/","version":1}