Ansible

Vad det är

Ansible är automationsprogramvara med öppen källkod som ansluter
till maskiner över SSH och för var och en till den konfiguration som
beskrivs i en uppsättning YAML-filer: vilka programpaket som är
installerade, vilka användare och filer som finns, vilka tjänster
som körs och hur de är inställda. Maskinen som Ansible körs från
kallas kontrollnod, och maskinerna den konfigurerar är hanterade
noder. På dem behöver ingen agent installeras, eftersom Ansible
loggar in med operativsystemets egna inloggningsuppgifter och gör
sitt arbete över den anslutningen. Filerna anger resultatet, och
Ansible kontrollerar på varje värddator om det resultatet redan
gäller.

Delarna har enkla namn. Ett inventory listar de hanterade noderna
och delar in dem i grupper som `web` eller `db`, med variabler som
gäller för en hel grupp eller för en enskild värd. En playbook
rymmer en eller flera plays, och varje play kopplar en grupp värdar
till en lista med uppgifter (tasks). Varje uppgift anropar en modul,
ett litet program som vet hur en sorts sak hanteras: ett paket, en
fil, en tjänst, en användare, en regel i en brandvägg. Projektets
egen dokumentation beskriver playbooks som ett upprepbart,
återanvändbart och enkelt system för konfigurationshantering och
driftsättning på flera maskiner. En roll samlar uppgifter, mallar,
standardvariabler och handlers under ett namn, så att ”en
PostgreSQL-server” eller ”en härdad SSH-daemon” skrivs en gång och
tillämpas på varje värd som behöver den.

En kort play visar formen:

```text
i- name: Web servers serve the site		engineer.company	70
  hosts: web
  become: true
  tasks:
    - name: nginx is installed
      ansible.builtin.package:
        name: nginx
        state: present

    - name: nginx runs now and after a reboot
      ansible.builtin.service:
        name: nginx
        state: started
        enabled: true
```

Varje uppgift anger ett tillstånd, inte en handling. De flesta
moduler kontrollerar först om tillståndet redan gäller och avslutar
utan att göra något om det gör det, så en andra körning av den här
playen på en konfigurerad värd ändrar ingenting och säger det. Den
egenskapen, idempotens, är det som gör det säkert att köra samma
playbook mot hela flottan varje gång, i stället för att hålla reda
på vilken värd som har fått vilket skript.

Den som frågar om Ansible jämför det ofta med tre grannar. Mot ett
skalskript är skillnaden att ett skript räknar upp steg och kör dem
igen oavsett om de behövs, medan en modul kontrollerar innan den
agerar. Mot Terraform eller Bicep är skillnaden skiktet: de
verktygen skapar resurser i ett moln, som nätverk, databaser och
virtuella maskiner, medan Ansible konfigurerar det som körs inuti en
maskin när den väl finns. Många team använder ett av varje. Mot
Puppet och Chef är skillnaden modellen: de kör oftast en agent på
varje maskin som hämtar sin konfiguration från en central server,
medan Ansible skjuter ut ändringar från den plats där det startas
och bara behöver SSH på andra sidan.

Varför det spelar roll

En server som har satts upp för hand går bara att återskapa så länge
den som satte upp den minns hur. Ett halvår senare kan ingen med
säkerhet säga varför en parameter i systemkärnan har sitt värde,
vilket paket som låstes vid en version och varför, eller vad som
måste hända först när maskinen byggs om. När uppsättningen skrivs
ned som playbooks blir minnet filer som kan läsas, granskas i en
pull request och köras igen på en ny maskin med samma resultat.

Den skrivna formen ändrar också vad avdrift betyder. När playbooken
är beskrivningen av värden rapporterar en körning i check mode mot
en körande maskin varje ställe där de två inte stämmer överens. Med
flaggan `--diff` visar rapporten de rader i varje fil som skulle
ändras. En flotta som konvergeras regelbundet håller sig nära sin
beskrivning, och en värd som har redigerats för hand syns som en
ändring nästa gång playbooken körs.

Modellen har sina kostnader. Ansible agerar bara när det körs, så
avdrift mellan körningarna ligger kvar till nästa gång. Uppgifterna
körs i ordning, en i taget över alla matchade värdar, och en stor
playbook mot många maskiner är långsammare än ett skript som gör en
enda sak. Logik som skrivs i YAML och Jinja2-mallar blir svår att
följa när en roll väl har fått många villkor. Och en körning som
stannar halvvägs lämnar sina värdar delvis ändrade, eftersom Ansible
saknar en transaktion att rulla tillbaka.

Så ser det ut i praktiken

Flera projekt på den här webbplatsen visar hur en nedskriven
IT-miljö ser ut över tid, och vad som krävs för att hålla den ärlig.

Företagets infrastruktur som kod omfattar offentliga tjänster i
drift och konfiguration för andra komponenter, däribland backup- och
e-postautomatisering vars aktivering är ett separat steg. Den
dokumenterade implementeringen omfattar 19 playbooks och 34 roller
fördelade på 12.065 rader YAML; siffrorna beskriver det dåvarande
skedet, inte kodförrådets nuvarande storlek. En värd tillhör en
nivågrupp vars variabler anger vilka roller den kör, så
provisionering utan argument för varje värd till dess deklarerade
tillstånd. Idempotens behandlas som ett kontrakt: en konvergerad
värd rapporterar noll ändringar, och en play som inte kan säga det
är inte färdig. Fyra kommandonamnrymder håller löftena åtskilda,
från en kvalitetsgrind som inte rör någon värd till verifiering som
avsiktligt ändrar en värd och lämnar ett utslag. Sidan är tydlig med
kostnaden: varje ändring tar längre tid än att redigera en fil
direkt på servern, och en konvergering som genomförs till hälften är
sämre än en som vägrar börja.

Åtkomstkontroll är ett annat område där en skriftlig beskrivning
lönar sig.

1.000 RBAC-regler konfigurerades med Ansible i utvecklingsmiljöer,
applikationsinstanser, PostgreSQL, MS SQL och Linux-servrar, med
varje regel knuten till en roll och ett system. Det dokumenterade
resultatet är en beskriven rollbaserad regeluppsättning och ett
repeterbart sätt att tillämpa och granska den. Det är detta
underlaget styrker; det kvantifierar inte minskad säkerhetsrisk
eller sparad tid för konfigurering.

Att hålla torrkörningen sanningsenlig krävde ett eget arbete. Check
mode fick tala sanning i hela plattformen efter att en torrkörning i
september 2026 föll på en kontroll som hade fel om värden och rådde
operatören att sätta en flagga som skulle ha luckrat upp en
säkerhetssandlåda. En genomsökning hittade sex sonder som fattade
beslut utifrån värden som maskinen aldrig hade gett. Sonder som
läser tillstånd som körningen inte har rört körs nu även i check
mode. Resten hoppas över med ett meddelande som anger vad som inte
verifierades, och regeln fördes in i utvecklarguiden.

Var det går fel

De flesta problem med Ansible kommer av att man litar mer på en
rapport än på mekanismen bakom den.

En torrkörning rapporterar ett rent resultat för kommandon som den
aldrig körde. Check mode är en simulering. Moduler som stöder läget
förutsäger sin ändring, och enligt dokumentationen rapporterar
moduler utan stöd ingenting och gör ingenting. Modulerna `command`
och `shell` stöder läget bara delvis: om `creates` eller `removes`
saknas hoppar de över kommandot och registrerar ett resultat med tom
utdata. Varje senare `when:` som läser det resultatet fattar beslut
utifrån ett värde som ingen har mätt. En sond som bara läser värden
kan få order att köras ändå, och en som inte kan köras bör säga det:

```text
i- name: Read the firewall state, even in check mode		engineer.company	70
  ansible.builtin.command: ufw status
  register: fw
  check_mode: false
  changed_when: false

i- name: Say what this dry run did not verify		engineer.company	70
  ansible.builtin.debug:
    msg: "check mode: the service restart was not exercised"
  when: ansible_check_mode
```

En körning stannar vid sin nionde uppgift med de åtta första redan
tillämpade. När en uppgift misslyckas på en värd släpper Ansible den
värden från resten av körningen och lämnar det som redan har ändrats
kvar. Kontroller som kan köras innan något rör en värd hör hemma
före konvergeringen. Så gick det efter en ändring av hemligheterna i
företagets egen IT-miljö, och sedan dess validerar en play för
förhandskontroll vault-filen lokalt först, med samma task-filer som
den riktiga konvergeringen och på ungefär en sekund, så en hemlighet
som inte går att slå upp kostar en vägran på två sekunder på en
bärbar dator i stället för en delvis tillämpad ändring på en körande
server. Samma sida pekar ut en fälla: fakta som sätts under en play
överlever den, så en kontroll och en konvergering som kedjas ihop i
ett enda anrop kan dela ett värde som kontrollen borde ha läst om.

En värd som ingen har rört rapporterar ändringar vid varje körning.
Modulerna `command` och `shell` rapporterar en ändring varje gång de
körs, eftersom de inte kan veta vad kommandot gjorde. En playbook
full av dem konvergerar aldrig till noll, och verkliga ändringar
göms i bruset. Välj hellre en modul som hanterar saken direkt, lägg
till `creates` eller `removes`, eller tala om för Ansible när utdata
betyder en ändring med `changed_when`.

Ett lösenord dyker upp i en logg eller i repot. Variabler är
klartext om inget krypterar dem. Ansible Vault krypterar
variabelfiler eller enskilda värden så att de kan ligga i repot, och
`no_log: true` på en uppgift håller dess argument och resultat borta
från utdata. Kör playbooken en gång med hög detaljnivå i en
testmiljö och läs vad den skriver ut innan du litar på någotdera.

Läs mer

  * Ansible Community Documentation — projektets egen ingång till
installation, begrepp och varje guide.

  * Ansible playbooks — plays, uppgifter, moduler, körordning och
vad idempotens betyder i praktiken.

  * Validating tasks: check mode and diff mode — vad en torrkörning
kan och inte kan se, och reglagen för varje uppgift.

  * How to build your inventory — värdar, grupper och variablerna
som hör till dem.

  * Protecting sensitive data with Ansible Vault — att kryptera
filer och enskilda värden som ligger bredvid playbooks.

  * ansible.builtin.command — referensen för modulen, bl.a. dess
delvisa stöd för check mode.

hDen här sidan på webben	URL:https://engineer.company/sv/glossary/ansible/	engineer.company	70
