Vad är Infrastructure as Code (CloudFormation, Terraform)?

Question

Accepted Answer

**Infrastructure as Code (IaC)** innebär att du definierar och hanterar din infrastruktur (servrar, nätverk, databaser) genom **kod/konfigurationsfiler** istället för manuell installation. Verktyg som **CloudFormation**, **Terraform** och **CDK** gör infrastrukturen upprepbar, versionskontrollerad och automatiserad.

## Problemet som IaC löser

```text
MANUALLY setting up infrastructure (clicking in the Console) is:
  → not REPEATABLE (hard to recreate identically; error-prone)
  → not VERSIONED (no history of what changed, by whom, why)
  → not DOCUMENTED (the setup lives only in someone's memory/clicks)
  → hard to review, share, or roll back
→ IaC defines infrastructure in CODE → solving all of this.
```

## Hur IaC fungerar

```text
Write infrastructure as code (declarative files describing the DESIRED state):
  → the tool reads the code and CREATES/UPDATES the actual infrastructure to match
  → re-runnable (idempotent): apply the same code → the same infrastructure
  → store in Git → version control, code review, history, collaboration
```

```yaml
# CloudFormation example (YAML): declare an S3 bucket
Resources:
  MyBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: my-app-bucket
# → deploying this creates the bucket; the code IS the source of truth
```

## Vanliga IaC-verktyg

```text
CLOUDFORMATION → AWS's native IaC (JSON/YAML); AWS-only; deeply integrated
TERRAFORM → multi-cloud (HashiCorp); declarative (HCL); the most popular, cloud-agnostic
AWS CDK → define infrastructure in real programming languages (TS, Python) →
  synthesizes to CloudFormation (loops, abstractions, familiar code)
PULUMI → similar to CDK, multi-cloud, real languages
```

## Varför det är viktigt

Att förstå Infrastructure as Code är värdefullt eftersom det är en grundläggande best practice inom modern cloud och DevOps, så det är viktig kunskap för att hantera infrastruktur på ett professionellt sätt.

IaC löser verkliga problem med **manuell infrastrukturkonfiguration** (genom att klicka i konsolen): manuell installation är inte upprepbar (svårt att återskapa identiskt, felbenägen), är inte versionskontrollerad (ingen historik över ändringar), är inte dokumenterad (konfigurationen finns bara i någons åtgärder) och är svår att granska eller återställa. **IaC löser allt detta** genom att definiera infrastruktur i **kod** — vilket gör den **upprepbar** (samma kod producerar samma infrastruktur på ett tillförlitligt sätt), **versionskontrollerad** (lagrad i Git med historik, granskning och samarbete som applikationskod), **dokumenterad** (koden är sanningen) och **automatiserbar** (integrerad i CI/CD).

Detta förvandlar infrastrukturhantering från felbenäget manuellt arbete till en disciplinerad, reproducerbar ingenjörsmetod.

Att förstå de **vanliga verktygen** — **CloudFormation** (AWS:s inhemska IaC), **Terraform** (det populära molnagnostiska, multi-cloud-verktyget), **CDK** (definiering av infrastruktur i riktiga programmeringsspråk) — hjälper till att välja rätt tillvägagångssätt.

Att förstå den deklarativa modellen (att beskriva önskat tillstånd, där verktyget gör verkligheten motsvarar) är kärnkonceptet.

IaC är centralt för modern DevOps och tillförlitlig molndrift — hantering av produktionsinfrastruktur som kod är en allmänt adopterad professionell standard.

Eftersom upprepbar, versionskontrollerad, automatiserad infrastruktur är väsentlig för tillförlitlig molndrift (och manuell installation orsakar verkliga problem), och eftersom IaC (CloudFormation, Terraform, CDK) är den etablerade metoden för att uppnå detta, är förståelse för Infrastructure as Code värdefullt, professionellt viktigt kunnande för modern cloud- och DevOps-arbete — en grundläggande best practice som gör infrastrukturen tillförlitlig, upprepbar och underhållbar, allt mer förväntat i molnfokuserade roller och centralt för hur professionella team hanterar sin infrastruktur.