Pulumi vs Terraform 2026: Infrastructure as Code met TypeScript en Sollicitatievragen

Pulumi vs Terraform vertegenwoordigt de centrale Infrastructure as Code-beslissing voor DevOps-teams in 2026. Beide tools provisioneren cloud-resources declaratief, maar verschillen in taalondersteuning, state management en ecosysteemrijpheid. Deze vergelijking behandelt de technische afwegingen, codevoorbeelden in TypeScript en HCL, en de sollicitatievragen die naar voren komen wanneer kandidaten IaC-keuzes bespreken.

Kernarchitectuur: Pulumi's Engine vs Terraform's Plan-Apply Cyclus

Terraform gebruikt een domeinspecifieke taal (HCL) en een tweefasige workflow: terraform plan genereert een uitvoeringsplan, terraform apply voert het uit. Het state-bestand volgt resource-metadata en wordt lokaal of in remote backends zoals S3 of Terraform Cloud opgeslagen.

Pulumi integreert zijn engine in general-purpose runtimes. Programma's geschreven in TypeScript, Python, Go of C# worden direct uitgevoerd tegen cloud-API's via Pulumi's providers. State wordt standaard opgeslagen in Pulumi Cloud, met opties voor zelfbeheerde backends waaronder S3, Azure Blob Storage en lokale bestanden.

Het architecturale verschil wordt direct zichtbaar in hoe elke tool omgaat met loops, conditionals en abstracties. Terraform's for_each en count werken binnen de beperkingen van HCL. Pulumi-programma's gebruiken native taalconstructies: for...of in TypeScript, list comprehensions in Python, range in Go.

import * as aws from "@pulumi/aws";
import * as pulumi from "@pulumi/pulumi";

// Native TypeScript array methods work directly
const environments = ["dev", "staging", "prod"];

const buckets = environments.map(env => 
  new aws.s3.BucketV2(`data-${env}`, {
    bucket: `myapp-data-${env}-${pulumi.getStack()}`,
    tags: {
      Environment: env,
      ManagedBy: "pulumi",
    },
  })
);

// Export bucket ARNs as stack outputs
export const bucketArns = buckets.map(b => b.arn);

De equivalente Terraform-configuratie vereist HCL-syntax voor iteratie:

# main.tf - Terraform HCL example
variable "environments" {
  type    = list(string)
  default = ["dev", "staging", "prod"]
}

resource "aws_s3_bucket" "data" {
  for_each = toset(var.environments)

  bucket = "myapp-data-${each.key}-${terraform.workspace}"

  tags = {
    Environment = each.key
    ManagedBy   = "terraform"
  }
}

output "bucket_arns" {
  value = [for b in aws_s3_bucket.data : b.arn]
}

Beide snippets creëren drie S3-buckets. De Terraform-versie is beknopt en leesbaar voor iedereen die bekend is met HCL. De Pulumi-versie gebruikt standaard TypeScript, wat betekent dat IDE-autocompletion, type checking en integratie met bestaande codebases mogelijk zijn zonder een nieuwe taal te leren.

TypeScript-ondersteuning: Native Taal vs CDKTF (Afgeschaft)

Pulumi ondersteunde TypeScript vanaf de eerste publieke release. De SDK stelt getypeerde resource-klassen beschikbaar, en pulumi.Output<T> wrapt asynchrone waarden die tijdens deployment worden opgelost. Refactoring-tools, linters en test-frameworks uit het TypeScript-ecosysteem zijn direct toepasbaar.

Terraform's antwoord op general-purpose taalondersteuning was CDKTF (Cloud Development Kit for Terraform). CDKTF stelde teams in staat TypeScript of Python te schrijven dat compileerde naar Terraform JSON. HashiCorp schafte CDKTF af in december 2025 en archiveerde de repository. Bestaande CDKTF-projecten blijven draaien, maar er worden geen updates geleverd voor nieuwe Terraform-versies of provider-wijzigingen.

Voor teams die TypeScript IaC willen in 2026 is Pulumi de actief onderhouden optie. Teams die al in CDKTF hebben geïnvesteerd kunnen hun stacks blijven draaien, maar migratie naar HCL of Pulumi is de weg vooruit voor nieuwe ontwikkeling.

import * as aws from "@pulumi/aws";
import * as pulumi from "@pulumi/pulumi";

// Custom component encapsulating VPC, subnets, and routing
export class StandardVpc extends pulumi.ComponentResource {
  public readonly vpcId: pulumi.Output<string>;
  public readonly publicSubnetIds: pulumi.Output<string>[];

  constructor(name: string, args: { cidr: string; azCount: number }, opts?: pulumi.ComponentResourceOptions) {
    super("mycompany:network:StandardVpc", name, {}, opts);

    const vpc = new aws.ec2.Vpc(`${name}-vpc`, {
      cidrBlock: args.cidr,
      enableDnsHostnames: true,
      tags: { Name: name },
    }, { parent: this });

    this.vpcId = vpc.id;

    // Create public subnets across availability zones
    const azs = aws.getAvailabilityZones({ state: "available" });
    this.publicSubnetIds = [];

    for (let i = 0; i < args.azCount; i++) {
      const subnet = new aws.ec2.Subnet(`${name}-public-${i}`, {
        vpcId: vpc.id,
        cidrBlock: `10.0.${i}.0/24`,
        availabilityZone: azs.then(az => az.names[i]),
        mapPublicIpOnLaunch: true,
        tags: { Name: `${name}-public-${i}` },
      }, { parent: this });
      this.publicSubnetIds.push(subnet.id);
    }

    this.registerOutputs({ vpcId: this.vpcId });
  }
}

Dit Pulumi-component creëert een herbruikbare VPC-abstractie. Gebruikers instantiëren het met new StandardVpc("prod", { cidr: "10.0.0.0/16", azCount: 3 }). Het equivalent in Terraform is een module-directory met variabelen, outputs en HCL-bestanden. Beide benaderingen maken hergebruik mogelijk; de Pulumi-versie erft TypeScript's tooling voor documentatie, testen en versionering.

State Management en Backend-opties

State management is waar operationele verschillen zichtbaar worden. Terraform state bevat resource-ID's, provider-metadata en gevoelige waarden. Teams moeten remote backends configureren om samenwerking mogelijk te maken en locking implementeren om gelijktijdige wijzigingen te voorkomen.

Terraform backend-configuratie ondersteunt S3, Azure Blob, Google Cloud Storage, Terraform Cloud en anderen. Elk backend vereist zijn eigen authenticatie-setup. State locking gebruikt DynamoDB voor S3-backends, blob leases voor Azure, of native locking in Terraform Cloud.

Pulumi Cloud handelt state-opslag, locking en geschiedenis standaard af. Teams maken een gratis account, voeren pulumi login uit, en state management is geconfigureerd. Voor teams die zelfbeheerde state vereisen, ondersteunt Pulumi S3, Azure Blob, GCS en lokale bestandsbackends met het pulumi login-commando.

# Pulumi: login to self-managed S3 backend
pulumi login s3://my-pulumi-state-bucket

# Terraform: configure S3 backend in HCL
# backend.tf
terraform {
  backend "s3" {
    bucket         = "my-terraform-state"
    key            = "prod/terraform.tfstate"
    region         = "us-east-1"
    dynamodb_table = "terraform-locks"
    encrypt        = true
  }
}

Pulumi Cloud biedt een web-UI voor stack-geschiedenis, resource-visualisatie en team-permissies. Terraform Cloud biedt vergelijkbare functies met policy enforcement via Sentinel. Self-hosted opties bestaan voor beide: Pulumi's self-hosted backend en Terraform Enterprise.

Provider-ecosysteem en Multi-Cloud Ondersteuning

Terraform's provider-ecosysteem is het grootste in IaC. De Terraform Registry vermeldt meer dan 4.000 providers die AWS, Azure, GCP, Kubernetes en honderden SaaS-platforms dekken. Provider-kwaliteit varieert: officiële HashiCorp- en cloud vendor-providers ontvangen regelmatige updates, terwijl community-providers mogelijk achterlopen op API-wijzigingen.

Pulumi-providers wrappen Terraform-providers met behulp van een bridge die getypeerde SDK's genereert. De Pulumi Registry stelt providers beschikbaar voor grote clouds, Kubernetes, databases en monitoring-services. Omdat Pulumi Terraform-providers bridget, is de ecosysteemcoverage vergelijkbaar, hoewel nieuwe Terraform-provider-versies bridge-updates vereisen voordat Pulumi-SDK's wijzigingen weerspiegelen.

Pulumi biedt ook native providers die direct tegen cloud-API's zijn geschreven. Native providers voor AWS, Azure en Kubernetes leveren same-day ondersteuning voor nieuwe API-features. De afweging is dat native providers alleen bestaan voor grote clouds; minder gangbare services gebruiken gebridgede providers.

// Using Pulumi's native AWS provider for Lambda
import * as aws from "@pulumi/aws";
import * as pulumi from "@pulumi/pulumi";

const role = new aws.iam.Role("lambda-role", {
  assumeRolePolicy: aws.iam.assumeRolePolicyForPrincipal({
    Service: "lambda.amazonaws.com",
  }),
});

const lambdaFunction = new aws.lambda.Function("api-handler", {
  runtime: aws.lambda.Runtime.NodeJS20dX,
  handler: "index.handler",
  role: role.arn,
  code: new pulumi.asset.AssetArchive({
    "index.js": new pulumi.asset.StringAsset(
      `exports.handler = async () => ({ statusCode: 200, body: "OK" });`
    ),
  }),
});

export const functionArn = lambdaFunction.arn;

Infrastructuurcode Testen

Testen is waar taalkeuze divergentie creëert. Pulumi-programma's zijn standaardcode, dus unit tests gebruiken bekende frameworks. De @pulumi/pulumi/runtime-module biedt mocking voor resource-creatie, waardoor tests configuratie kunnen verifiëren zonder resources te deployen.

import { describe, it, expect, beforeAll } from "vitest";
import * as pulumi from "@pulumi/pulumi";

// Mock Pulumi runtime
pulumi.runtime.setMocks({
  newResource: (args: pulumi.runtime.MockResourceArgs) => {
    return { id: `${args.name}-id`, state: args.inputs };
  },
  call: (args: pulumi.runtime.MockCallArgs) => {
    return args.inputs;
  },
});

describe("S3 Bucket Configuration", () => {
  let bucketTags: Record<string, string>;

  beforeAll(async () => {
    // Import the Pulumi program after mocks are set
    const infra = await import("../infra/index");
    // Extract outputs for testing
    bucketTags = await new Promise(resolve => {
      infra.buckets[0].tags.apply(tags => resolve(tags as Record<string, string>));
    });
  });

  it("should tag buckets with Environment", () => {
    expect(bucketTags).toHaveProperty("Environment");
  });

  it("should tag buckets with ManagedBy", () => {
    expect(bucketTags.ManagedBy).toBe("pulumi");
  });
});

Terraform-testen gebruiken terraform test (geïntroduceerd in Terraform 1.6) of externe tools zoals Terratest. terraform test voert HCL-testbestanden uit die echte resources creëren in geïsoleerde configuraties. Terratest is een Go-library die Terraform-commando's wrapt en assertions biedt.

# tests/bucket.tftest.hcl - Terraform native test
run "bucket_tags" {
  command = plan

  assert {
    condition     = aws_s3_bucket.data["dev"].tags["Environment"] == "dev"
    error_message = "Bucket must be tagged with Environment"
  }

  assert {
    condition     = aws_s3_bucket.data["dev"].tags["ManagedBy"] == "terraform"
    error_message = "Bucket must be tagged with ManagedBy"
  }
}

Beide benaderingen valideren infrastructuurconfiguratie. Pulumi's voordeel is integratie met TypeScript test runners en coverage-tools. Terraform's native tests draaien zonder externe dependencies maar vereisen HCL-syntax.

Sollicitatievragen: Pulumi vs Terraform

DevOps-sollicitatiegesprekken in 2026 bevatten vaak IaC-toolvergelijkingen. Hier zijn vragen die kandidaten onderscheiden die beide tools in productie hebben gebruikt.

"Wat gebeurt er wanneer Terraform state afwijkt van de werkelijke infrastructuur?"

Verwacht antwoord: terraform plan detecteert drift door state te vergelijken met de echte infrastructuur. Het plan toont resources om te updaten, creëren of vernietigen. Drift treedt op wanneer wijzigingen buiten Terraform worden gemaakt (console, CLI, andere tools). Opties zijn terraform refresh om state te updaten, terraform import om resources onder management te brengen, of het plan accepteren om de gewenste state te herstellen.

"Hoe handelt Pulumi secrets anders af dan Terraform?"

Verwacht antwoord: Pulumi versleutelt secrets in state standaard met een passphrase of cloud KMS. De pulumi.secret()-functie markeert waarden als gevoelig, en ze blijven versleuteld at rest. Terraform slaat secrets op in plaintext in state-bestanden; teams vertrouwen op backend-encryptie (S3 server-side encryptie) en toegangscontroles. Terraform 1.4 voegde sensitive variabele-markering toe, maar waarden verschijnen nog steeds onversleuteld in state.

"Waarom heeft HashiCorp CDKTF afgeschaft, en wat zijn de migratieopties?"

Verwacht antwoord: CDKTF voegde maintenance-overhead toe zonder de update-cadans van Terraform bij te houden. Nieuwe provider-versies en Terraform-features vereisten handmatige updates van CDK-bindings. HashiCorp koos ervoor om te focussen op HCL en Terraform Cloud. Migratieopties zijn: converteren naar HCL met cdktf convert, herschrijven in Pulumi als TypeScript vereist is, of bestaande CDKTF-stacks blijven draaien zonder updates.

"Wanneer zou je Pulumi kiezen boven Terraform voor een nieuw project?"

Verwacht antwoord: Kies Pulumi wanneer het team al TypeScript/Python/Go gebruikt en IaC in dezelfde taal als applicatiecode wil, wanneer complexe abstracties echte programmeerconstructies vereisen (generics, interfaces, test-frameworks), of wanneer ingebouwde secret-encryptie een vereiste is. Kies Terraform wanneer het team HCL kent, wanneer het provider-ecosysteem niche- of community-providers moet bevatten, of wanneer organisatorische tooling (Atlantis, Spacelift) integreert met Terraform.

Migratiestrategieën: Terraform naar Pulumi

Pulumi biedt pulumi import om bestaande cloud-resources onder management te brengen zonder ze opnieuw te creëren. Voor teams met Terraform state vertaalt pulumi convert HCL naar Pulumi-programma's. De conversie is niet perfect: complexe modules en dynamische blokken vereisen handmatige aanpassing.

# Convert Terraform HCL to Pulumi TypeScript
pulumi convert --from terraform --language typescript

# Import existing AWS resources into Pulumi state
pulumi import aws:s3/bucketV2:BucketV2 my-bucket my-existing-bucket-name

Een gefaseerde migratie stelt teams in staat beide tools te draaien tijdens de transitie. Terraform beheert bestaande stacks terwijl Pulumi nieuwe infrastructuur provisioneert. Zodra teams Pulumi-ervaring opdoen, converteren ze Terraform-stacks incrementeel. State wordt niet gedeeld tussen tools, dus resource-beheer moet duidelijk worden verdeeld om conflicten te voorkomen.

Beslissingskader voor 2026

Belangrijkste Inzichten voor Infrastructure as Code in 2026

• Terraform 1.16 is de stabiele keuze voor HCL-gebaseerd IaC met het grootste provider-ecosysteem en volwassen tooling (Atlantis, Spacelift, env0).
• Pulumi v3.263 biedt TypeScript, Python, Go en C# met native taaltesten, IDE-integratie en ingebouwde secret-encryptie.
• CDKTF is afgeschaft sinds december 2025. Teams die TypeScript IaC willen, moeten Pulumi evalueren in plaats van nieuwe CDKTF-projecten te starten.
• Beide tools ondersteunen multi-cloud deployments, remote state backends en teamsamenwerking. De keuze hangt af van taalvoorkeur en bestaande teamexpertise.
• Sollicitatiegesprekken moeten begrip tonen van state management, drift-detectie, provider-ecosystemen en de afwegingen tussen DSL-eenvoud en general-purpose taalpower.
• Migratie van Terraform naar Pulumi is mogelijk met pulumi convert en pulumi import, maar vereist zorgvuldige planning en gefaseerde uitrol.