{"canonical_url":"https://engineer.company/sv/glossary/immutable-infrastructure/","content_markdown":"# immutable infrastructure\n\n## Vad det är\n\nImmutable infrastructure är ett sätt att driva servrar där en maskin aldrig ändras när den väl har\ntagits i drift. På svenska används också benämningen oföränderlig infrastruktur. HashiCorps\nWell-Architected Framework beskriver det som infrastruktur som aldrig ändras efter driftsättningen,\nutan bara byts ut. En ny version av applikationen, ett uppgraderat bibliotek, en\nsäkerhetsuppdatering och en ändrad inställning kommer alla samma väg: som en ny maskin eller\ncontainer, byggd från en ny avbildning (image), som tar den gamlas plats. Sedan stängs den gamla av\noch raderas.\n\nMotsatsen är mutable infrastructure, där en server lever länge och uppdateras där den står. I juni\n2013 beskrev Chad Fowler vad en sådan server blir efter år av uppgraderingar: patchad gång på gång,\nmed konfigurationsändringar gjorda för hand mitt under ett avbrott och med cronjobb som bara en\nperson känner till, tills teamet varken vågar ändra den eller byta ut den. Hans lösning, som han\nkallade immutable deployments, var att bygga varje system automatiskt och sedan låta det vara orört.\nEn uppgradering eller en ny version innebär då att man bygger en ny server eller en ny avbildning\noch kastar den gamla.\n\nTvå slags avbildningar gör arbetssättet praktiskt möjligt. En maskinavbildning är enligt Packers\ndokumentation en enda statisk enhet med ett förkonfigurerat operativsystem och den installerade\nprogramvaran. Själva Packer är ett communityverktyg som skapar motsvarande maskinavbildningar för\nflera plattformar från en enda källkonfiguration. Containeravbildningar är det andra slaget, och\nDockers dokumentation säger det rakt ut: när en avbildning väl har skapats kan den inte ändras, och\nman kan bara skapa en ny avbildning eller lägga ändringar ovanpå den som nya lager.\n\nBegreppet beskriver hur ett system drivs, inte en produkt man installerar. Det har också en gräns.\nApplikationsservrarna kan bytas ut vid varje release, men de data de arbetar med måste ligga\nnågonstans som överlever varje utbyte, och det är vid den gränsen det mesta av det praktiska\ndesignarbetet ligger.\n\n## Varför det spelar roll\n\nDet första skälet är att servrar glider isär. HashiCorps ramverk säger det rakt ut: manuella\nuppdateringar och ändringar på plats får servrar att med tiden avvika från sin ursprungliga\nkonfiguration. Två servrar som sattes upp likadant med ett års mellanrum blir inte nödvändigtvis\nlika, eftersom var och en har fått sin egen följd av rättelser, nya försök och handredigeringar. När\nvarje server är en färsk kopia av en enda avbildning är avbildningen den fullständiga beskrivningen\nav servern, och det finns ingenting kvar som kan glida isär.\n\nDet andra skälet är att det går att rulla tillbaka. Om en release beter sig fel är ramverkets svar\natt driftsätta den föregående artefakten på nytt i stället för att reparera den nuvarande\ninfrastrukturen. Den föregående avbildningen är ett känt tillstånd som redan har körts i produktion,\nså teamet behöver inte under press återskapa hur servern såg ut i går, ur minnet och skalhistoriken.\n\nDet tredje skälet är färre händer i produktion. Ramverket påpekar att den som loggar in på\nproduktionsservrar och uppdaterar dem för hand bjuder in mänskliga fel som stavfel och glömda steg,\noch att immutable infrastructure tar bort behovet av manuell åtkomst till servrarna. Färre personer\nbehöver över huvud taget en inloggning på en maskin i drift, och de som har en behöver sällan\nanvända den.\n\nDet fjärde skälet är spårbarheten. Revisorer vill enligt samma sida ha belägg för att produktionen\ninte har ändrats utanför de godkända processerna, och manuella ändringar lämnar ofullständiga spår.\nNär varje ändring är en ny artefakt visar versionshanteringen och CI/CD-loggarna vad som ändrades,\nnär och vem som godkände det. En säkerhetsuppdatering följer samma väg som en ny funktion: den blir\nen ny artefakt som ersätter den som körs, så den byggs, testas och registreras på samma sätt.\n\nInget av detta är gratis. Ramverket noterar att avbildningar för virtuella maskiner kräver mer\nresurser än containrar och tar längre tid att starta, medan containrar kräver en orkestrerare för\natt köras. Varje ändring, även en inställning på en rad, innebär nu ett fullständigt bygge och ett\nutbyte, så bygget måste vara automatiskt och snabbt nog för att ingen ska frestas att hoppa över\ndet. Tillståndet måste flyttas bort från de maskiner som byts ut före det första utbytet, inte\nefteråt.\n\n## Så ser det ut i praktiken\n\nEn Packer-mall beskriver hur en maskinavbildning byggs. Den här bygger på exemplet i dokumentationen\nför Packers Amazon EBS-builder, med ett `build`-block tillagt i den form som referensen för\nbuild-blocket visar:\n\n```hcl\nsource \"amazon-ebs\" \"web\" {\n  access_key    = var.aws_access_key\n  secret_key    = var.aws_secret_key\n  region        = \"us-east-1\"\n  source_ami    = \"ami-fce3c696\"\n  instance_type = \"t2.micro\"\n  ssh_username  = \"ubuntu\"\n  ami_name      = \"web {{timestamp}}\"\n}\n\nbuild {\n  sources = [\"source.amazon-ebs.web\"]\n\n  provisioner \"shell\" {\n    scripts = fileset(\".\", \"scripts/{install,secure}.sh\")\n  }\n}\n```\n\n`source`-blocket anger buildern och basavbildningen, `source_ami`, vars rotvolym kopieras och\nprovisioneras på en körande instans. `build`-blocket anger vilka källor som ska byggas och hur de\nska provisioneras. Shell-provisioneraren kör de två skripten inne i den körande maskinen innan den\ngörs om till en statisk artefakt, och artefakten är en ny avbildning. Deklarationerna av de två\nvariablerna är utelämnade här. Ett enda kommando kör alla byggen i mallen och skapar artefakterna:\n\n```sh\npacker build web.pkr.hcl\n```\n\nDriftsättningen är den andra halvan. HashiCorps ramverk ställer de två verktygen sida vid sida:\navbildningar byggs med Packer, driftsätts med Terraform och byts ut helt när de behöver en\nuppdatering. När en ändring inte kan göras på plats är Terraforms standard enligt referensen för\nlifecycle att först ta bort det befintliga objektet och sedan skapa ersättningen. Uppdateringar i det här flödet kräver ingen inloggning på en\nproduktionsserver som är i drift. En ändring i skripten ger en ny avbildning, avbildningen\nger nya maskiner, och de gamla tas bort.\n\nSamma disciplin fungerar också på en enda värd. Portföljexemplet om\n[containrar på Podman och Quadlet](/sv/portfolio/ran-containers-on-podman-and-quadlet/) håller\nprovisionering och driftsättning isär. Root lägger upp driftsättningsvägen en enda gång, och sedan\nsköter en vanlig användare utan särskilda rättigheter utrullningarna; användaren får köra exakt ett\nskript och inget annat. En utrullning är en ny avbildning följd av en omstart av tjänsten, utan\nroot-skal och utan fritt valda kommandon. Exemplet om\n[CI/CD med GitHub Actions](/sv/portfolio/built-github-actions-ci-cd-pipelines/) går längre på\navbildningssidan: frontenden i produktion körs på en distroless-grund som varken har skal eller\npakethanterare, och det är arbetsflödena, inte en person, som för ett bygge vidare från en miljö\ntill nästa. En sådan avbildning har nästan inget att logga in på och inget verktyg att installera\nmed, så att bygga en efterträdare är det enda rimliga sättet att ändra den.\n\nSidan om\n[servrar som går att bygga upp från grunden igen](/sv/portfolio/servers-you-can-rebuild-from-scratch/)\nvisar den andra modellen utförd med omsorg. Ansible för en värd som är i drift till det tillstånd\nsom repot beskriver, varje play är idempotent och repot innehåller konfigurationen för att bygga upp den deklarerade miljön igen.\nSidan döljer inte vad ändringar på plats kostar. Allt tar längre tid än att bara ändra direkt på\nservern, och en körning som stannar halvvägs lämnar värden i sämre skick än en körning som vägrar\nstarta. Därför körs nu en preflight-play före den. En värd som bara är halvt ändrad är ett steg mot\nden sköra server Fowler beskrev, och att byta ut maskinen i stället för att ändra den är den andra\nvägen runt.\n\n## Var det går fel\n\nModellen är enkel att formulera och lätt att urholka. De flesta fel beror på ett enda undantag som\nverkade ofarligt när det gjordes.\n\n**En snabb rättelse över SSH får servrarna att glida isär igen.** Under press loggar någon in på en\nserver i drift och redigerar en fil. Rättelsen fungerar tills nästa driftsättning byter ut maskinen,\noch då är den borta, tillsammans med varje förklaring till varför den behövdes. Fram till dess\nstämmer servern inte längre med sin avbildning, och det är precis det tillstånd som arbetssättet\nfinns till för att förhindra. Lösningen är att skicka varje ändring, även den brådskande, genom\navbildningsbygget och hålla bygget så snabbt att det är den snabbaste vägen. HashiCorps vägledning\när att aldrig logga in på servrar i drift för att göra manuella ändringar eller köra\nuppdateringskommandon.\n\n**Data som skrivs på maskinen raderas tillsammans med den.** Dockers dokumentation säger att när en\ncontainer tas bort försvinner också de filändringar som gjorts inne i den. Uppladdningar, genererade\nfiler eller en lokal databas på en maskin som byts ut försvinner vid nästa release. Lösningen är att\nhålla tillståndet utanför den del som byts ut. Docker-volymer bevarar data bortom livslängden för en\nenskild container, och en ny container som kopplas till samma volym hittar filerna kvar; för\nmaskiner fylls samma roll av en separat disk eller en databastjänst som inte ingår i avbildningen.\n\n**Utbytet tar ner tjänsten.** Terraforms standardordning är att först ta bort det befintliga\nobjektet och sedan skapa ersättningen, vilket lämnar ett fönster då tjänsten står still.\nInställningen `create_before_destroy` i `lifecycle`-blocket för en resurs vänder på ordningen:\n\n```hcl\nresource \"aws_instance\" \"web\" {\n  # ...\n  lifecycle {\n    create_before_destroy = true\n  }\n}\n```\n\nHashiCorp gör detta till ett aktivt val, eftersom många objekttyper har krav på unika namn eller\nandra begränsningar som två exemplar samtidigt skulle bryta mot, och referensen ber dig förstå\nbegränsningarna för varje resurstyp innan du förlitar dig på det.\n\n**Ett nytt bygge utgår i tysthet från en nyare bas.** I stället för en fast `source_ami` kan Amazon\nEBS-buildern fylla i den från ett `source_ami_filter`, och med `most_recent` satt till true väljer\nfiltret den nyaste avbildningen som uppfyller villkoren, vilket dokumentationen kallar mest\nanvändbart för ett dagligt distro-bygge. Det är praktiskt för att hålla sig uppdaterad, men då utgår\ntvå byggen av samma mall på olika dagar från olika baser, och en gammal release blir inte densamma\nnär den byggs om. Lösningen för release-avbildningar är att låsa `source_ami` till en bestämd\navbildning och flytta fram den medvetet, i en granskad commit.\n\n**Hemligheter bakas in i avbildningen.** HashiCorps ramverk är tydligt: artefakter får aldrig\ninnehålla hemligheter som databaslösenord, API-nycklar eller krypteringsnycklar, eftersom alla med\nåtkomst till artefakten kan plocka ut dem, och eftersom rotation av en inloggningsuppgift kräver att\nvarje artefakt byggs och driftsätts på nytt. Lösningen är att hämta hemligheterna när maskinen eller\ncontainern startar. HashiCorps eget mönster använder Vault: en maskin som startar autentiserar sig\noch får tillfälliga inloggningsuppgifter som löper ut, och uppgifterna roteras i Vault utan att\nnågot behöver byggas om. Mallen ovan följer samma regel för sina egna nycklar, som kommer in som\nvariabler och inte står som text i filen.\n\n**Den föregående artefakten är borta när den behövs.** Att rulla tillbaka innebär att driftsätta den\nföregående artefakten på nytt, och det förutsätter att den fortfarande finns. Ett städjobb som\nraderar gamla avbildningar, eller en vana att återanvända ett och samma avbildningsnamn för varje\nbygge, gör det till ett nybygge från gammal källkod på en bas som kan ha flyttat sig. Lösningen är\natt behålla avbildningarna från de senaste releaserna som har körts i produktion, ge var och en ett\nnamn som aldrig återanvänds och öva på att rulla tillbaka till en av dem innan dagen då det gäller.\n\n## Läs mer\n\n- [Create immutable infrastructure](https://developer.hashicorp.com/well-architected-framework/define-and-automate-processes/define/immutable-infrastructure)\n  — ramverkets sida om avvikelser, återgång, avbildningstyper och hemligheter.\n- [Trash Your Servers and Burn Your Code: Immutable Infrastructure and Disposable Components](https://web.archive.org/web/20160418161330/http://chadfowler.com/2013/06/23/immutable-deployments.html)\n  — Chad Fowlers inlägg från juni 2013, läst i en kopia hos Internet Archive.\n- [Introduction to Packer](https://developer.hashicorp.com/packer/docs/intro)\n  — vad Packer bygger och vad en maskinavbildning innehåller.\n- [Amazon EBS builder](https://developer.hashicorp.com/packer/integrations/hashicorp/amazon/latest/components/builder/ebs)\n  — buildern från exemplet, med `source_ami` och `source_ami_filter`.\n- [lifecycle meta-argument reference](https://developer.hashicorp.com/terraform/language/meta-arguments/lifecycle)\n  — Terraforms standard att ta bort före skapande, och `create_before_destroy`.\n- [Persisting container data](https://docs.docker.com/get-started/docker-concepts/running-containers/persisting-container-data/)\n  — varför filer i en container försvinner med den, och hur volymer bevarar dem.\n\n\u003chttps://engineer.company/sv/glossary/immutable-infrastructure/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Vad immutable infrastructure betyder, varför man byter ut servrar i stället för att laga dem, hur en avbildning byggs och tas i drift, och var modellen brister.","formats":{"gemtext":"https://engineer.company/sv/glossary/immutable-infrastructure/index.gmi","gopher":"https://engineer.company/sv/glossary/immutable-infrastructure/gophermap","html":"https://engineer.company/sv/glossary/immutable-infrastructure/","json":"https://engineer.company/sv/glossary/immutable-infrastructure/index.json","markdown":"https://engineer.company/sv/glossary/immutable-infrastructure/index.md","pdf":"https://engineer.company/sv/glossary/immutable-infrastructure/index.pdf"},"kind":"page","language":"sv","title":"Vad är immutable infrastructure?","url":"https://engineer.company/sv/glossary/immutable-infrastructure/","version":1}