Pulumi vs Terraform 2026: Infrastructure as Code dengan TypeScript dan Pertanyaan Interview

Pulumi vs Terraform menjadi keputusan utama dalam pemilihan Infrastructure as Code bagi tim DevOps di tahun 2026. Kedua alat ini menyediakan provisioning cloud resources secara deklaratif, namun berbeda dalam dukungan bahasa pemrograman, state management, dan kematangan ekosistem. Perbandingan ini membahas tradeoff teknis, contoh kode dalam TypeScript dan HCL, serta pertanyaan interview yang sering muncul saat kandidat mendiskusikan pilihan IaC.

Arsitektur Inti: Engine Pulumi vs Siklus Plan-Apply Terraform

Terraform menggunakan domain-specific language (HCL) dan workflow dua fase: terraform plan menghasilkan execution plan, terraform apply menjalankannya. State file melacak resource metadata dan disimpan secara lokal atau di remote backend seperti S3 atau Terraform Cloud.

Pulumi menyematkan engine-nya dalam runtime bahasa pemrograman umum. Program yang ditulis dalam TypeScript, Python, Go, atau C# dieksekusi langsung terhadap cloud API melalui provider Pulumi. State disimpan di Pulumi Cloud secara default, dengan opsi untuk self-managed backend termasuk S3, Azure Blob Storage, dan file lokal.

Perbedaan arsitektur ini langsung terlihat pada cara masing-masing alat menangani loop, conditional, dan abstraksi. for_each dan count Terraform bekerja dalam batasan HCL. Program Pulumi menggunakan konstruksi bahasa native: for...of di TypeScript, list comprehension di Python, range di Go.

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

// Method array TypeScript native bekerja langsung
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 ARN sebagai stack output
export const bucketArns = buckets.map(b => b.arn);

Konfigurasi Terraform yang setara memerlukan sintaks HCL untuk iterasi:

# main.tf - Contoh Terraform HCL
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]
}

Kedua snippet membuat tiga S3 bucket. Versi Terraform ringkas dan mudah dibaca bagi siapa pun yang familiar dengan HCL. Versi Pulumi menggunakan TypeScript standar, yang berarti IDE autocompletion, type checking, dan integrasi dengan codebase yang ada tanpa perlu mempelajari bahasa baru.

Dukungan TypeScript: Bahasa Native vs CDKTF (Deprecated)

Pulumi mendukung TypeScript sejak rilis publik pertamanya. SDK mengekspos typed resource class, dan pulumi.Output<T> membungkus nilai asynchronous yang di-resolve selama deployment. Tool refactoring, linter, dan test framework dari ekosistem TypeScript dapat langsung digunakan.

Jawaban Terraform untuk dukungan bahasa pemrograman umum adalah CDKTF (Cloud Development Kit for Terraform). CDKTF memungkinkan tim menulis TypeScript atau Python yang dikompilasi ke Terraform JSON. HashiCorp men-deprecate CDKTF pada Desember 2025 dan mengarsipkan repositorinya. Proyek CDKTF yang ada masih bisa berjalan, tetapi tidak ada update untuk versi Terraform atau perubahan provider baru.

Bagi tim yang menginginkan TypeScript IaC di tahun 2026, Pulumi adalah opsi yang actively maintained. Tim yang sudah berinvestasi di CDKTF dapat terus menjalankan stack mereka, tetapi migrasi ke HCL atau Pulumi adalah jalan ke depan untuk pengembangan baru.

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

// Custom component yang mengenkapsulasi VPC, subnet, dan 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;

    // Buat public subnet di seluruh availability zone
    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 });
  }
}

Pulumi component ini membuat abstraksi VPC yang reusable. Consumer menginstansiasi dengan new StandardVpc("prod", { cidr: "10.0.0.0/16", azCount: 3 }). Padanan di Terraform adalah direktori module dengan variables, outputs, dan file HCL. Kedua pendekatan memungkinkan reuse; versi Pulumi mewarisi tooling TypeScript untuk dokumentasi, testing, dan versioning.

State Management dan Opsi Backend

State management adalah tempat perbedaan operasional muncul. State Terraform berisi resource ID, provider metadata, dan sensitive values. Tim harus mengkonfigurasi remote backend untuk kolaborasi dan mengimplementasikan locking untuk mencegah modifikasi bersamaan.

Konfigurasi backend Terraform mendukung S3, Azure Blob, Google Cloud Storage, Terraform Cloud, dan lainnya. Setiap backend memerlukan setup autentikasi tersendiri. State locking menggunakan DynamoDB untuk S3 backend, blob lease untuk Azure, atau native locking di Terraform Cloud.

Pulumi Cloud menangani state storage, locking, dan history secara default. Tim membuat akun gratis, menjalankan pulumi login, dan state management sudah terkonfigurasi. Bagi tim yang memerlukan self-managed state, Pulumi mendukung S3, Azure Blob, GCS, dan file backend lokal dengan perintah pulumi login.

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

# Terraform: konfigurasi S3 backend di 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 menyediakan web UI untuk stack history, visualisasi resource, dan permission tim. Terraform Cloud menawarkan fitur serupa dengan policy enforcement melalui Sentinel. Opsi self-hosted tersedia untuk keduanya: self-hosted backend Pulumi dan Terraform Enterprise.

Ekosistem Provider dan Dukungan Multi-Cloud

Ekosistem provider Terraform adalah yang terbesar dalam IaC. Terraform Registry mencantumkan lebih dari 4.000 provider yang mencakup AWS, Azure, GCP, Kubernetes, dan ratusan platform SaaS. Kualitas provider bervariasi: provider resmi HashiCorp dan cloud vendor menerima update reguler, sementara community provider mungkin tertinggal dari perubahan API.

Provider Pulumi membungkus provider Terraform menggunakan bridge yang menghasilkan typed SDK. Pulumi Registry mengekspos provider untuk cloud utama, Kubernetes, database, dan layanan monitoring. Karena Pulumi mem-bridge provider Terraform, cakupan ekosistem sebanding, meskipun versi provider Terraform baru memerlukan update bridge sebelum SDK Pulumi mencerminkan perubahan.

Pulumi juga menawarkan native provider yang ditulis langsung terhadap cloud API. Native provider untuk AWS, Azure, dan Kubernetes memberikan dukungan same-day untuk fitur API baru. Tradeoff-nya adalah native provider hanya ada untuk cloud utama; layanan yang kurang umum menggunakan bridged provider.

// Menggunakan native AWS provider Pulumi untuk 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;

Testing Infrastructure Code

Testing adalah tempat pilihan bahasa menciptakan divergensi. Program Pulumi adalah kode standar, jadi unit test menggunakan framework familiar. Module @pulumi/pulumi/runtime menyediakan mocking untuk resource creation, memungkinkan test memverifikasi konfigurasi tanpa men-deploy resource.

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 program Pulumi setelah mock di-set
    const infra = await import("../infra/index");
    // Extract output untuk 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");
  });
});

Testing Terraform menggunakan terraform test (diperkenalkan di Terraform 1.6) atau alat eksternal seperti Terratest. terraform test menjalankan file test HCL yang membuat resource nyata dalam konfigurasi terisolasi. Terratest adalah library Go yang membungkus perintah Terraform dan menyediakan assertion.

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

  assert {
    condition     = aws_s3_bucket.data["dev"].tags["Environment"] == "dev"
    error_message = "Bucket harus di-tag dengan Environment"
  }

  assert {
    condition     = aws_s3_bucket.data["dev"].tags["ManagedBy"] == "terraform"
    error_message = "Bucket harus di-tag dengan ManagedBy"
  }
}

Kedua pendekatan memvalidasi konfigurasi infrastructure. Keunggulan Pulumi adalah integrasi dengan test runner dan coverage tool TypeScript. Test native Terraform berjalan tanpa dependensi eksternal tetapi memerlukan sintaks HCL.

Pertanyaan Interview: Pulumi vs Terraform

Interview DevOps di tahun 2026 sering menyertakan perbandingan IaC tool. Berikut pertanyaan yang membedakan kandidat yang telah menggunakan kedua alat di production.

"Apa yang terjadi ketika state Terraform drift dari infrastructure aktual?"

Jawaban yang diharapkan: terraform plan mendeteksi drift dengan membandingkan state dengan infrastructure nyata. Plan menunjukkan resource yang perlu di-update, create, atau destroy. Drift terjadi ketika perubahan dibuat di luar Terraform (console, CLI, alat lain). Opsinya termasuk terraform refresh untuk update state, terraform import untuk membawa resource di bawah management, atau menerima plan untuk mengembalikan desired state.

"Bagaimana Pulumi menangani secret secara berbeda dari Terraform?"

Jawaban yang diharapkan: Pulumi mengenkripsi secret dalam state secara default menggunakan passphrase atau cloud KMS. Fungsi pulumi.secret() menandai nilai sebagai sensitive, dan tetap terenkripsi saat rest. Terraform menyimpan secret dalam plaintext di state file; tim mengandalkan enkripsi backend (enkripsi server-side S3) dan access control. Terraform 1.4 menambahkan marking variabel sensitive, tetapi nilai tetap muncul tidak terenkripsi dalam state.

"Mengapa HashiCorp men-deprecate CDKTF, dan apa opsi migrasinya?"

Jawaban yang diharapkan: CDKTF menambah overhead maintenance tanpa mengimbangi cadence update Terraform. Versi provider baru dan fitur Terraform memerlukan update manual ke CDK binding. HashiCorp memilih fokus pada HCL dan Terraform Cloud. Opsi migrasi adalah: konversi ke HCL menggunakan cdktf convert, tulis ulang di Pulumi jika TypeScript diperlukan, atau terus menjalankan stack CDKTF yang ada tanpa update.

"Kapan memilih Pulumi daripada Terraform untuk proyek baru?"

Jawaban yang diharapkan: Pilih Pulumi ketika tim sudah menggunakan TypeScript/Python/Go dan menginginkan IaC dalam bahasa yang sama dengan kode aplikasi, ketika abstraksi kompleks memerlukan konstruksi pemrograman nyata (generic, interface, testing framework), atau ketika enkripsi secret bawaan adalah keharusan. Pilih Terraform ketika tim menguasai HCL, ketika ekosistem provider harus mencakup provider niche atau community, atau ketika tooling organisasi (Atlantis, Spacelift) terintegrasi dengan Terraform.

Untuk persiapan interview infrastructure as code lebih lanjut, lihat Pertanyaan Interview Terraform: Panduan Lengkap Infrastructure as Code dan modul Terraform Advanced.

Strategi Migrasi: Terraform ke Pulumi

Pulumi menyediakan pulumi import untuk membawa cloud resource yang ada di bawah management tanpa membuatnya ulang. Bagi tim dengan state Terraform, pulumi convert menerjemahkan HCL ke program Pulumi. Konversi tidak sempurna: module kompleks dan dynamic block memerlukan penyesuaian manual.

# Konversi Terraform HCL ke Pulumi TypeScript
pulumi convert --from terraform --language typescript

# Import resource AWS yang ada ke state Pulumi
pulumi import aws:s3/bucketV2:BucketV2 my-bucket my-existing-bucket-name

Migrasi bertahap memungkinkan tim menjalankan kedua alat selama transisi. Terraform mengelola stack yang ada sementara Pulumi mem-provision infrastructure baru. Setelah tim mendapatkan pengalaman Pulumi, mereka mengkonversi stack Terraform secara bertahap. State tidak dibagikan antar alat, jadi pengelolaan resource harus dibagi dengan jelas untuk menghindari konflik.

Framework Keputusan untuk 2026

Poin Utama untuk Infrastructure as Code di 2026

• Terraform 1.16 adalah pilihan stabil untuk IaC berbasis HCL dengan ekosistem provider terbesar dan tooling matang (Atlantis, Spacelift, env0).
• Pulumi v3.263 menawarkan TypeScript, Python, Go, dan C# dengan testing bahasa native, integrasi IDE, dan enkripsi secret bawaan.
• CDKTF deprecated sejak Desember 2025. Tim yang menginginkan TypeScript IaC sebaiknya mengevaluasi Pulumi daripada memulai proyek CDKTF baru.
• Kedua alat mendukung deployment multi-cloud, remote state backend, dan kolaborasi tim. Pilihan tergantung pada preferensi bahasa dan keahlian tim yang ada.
• Diskusi interview harus mendemonstrasikan pemahaman tentang state management, drift detection, ekosistem provider, dan tradeoff antara kesederhanaan DSL dan kekuatan bahasa pemrograman umum.
• Migrasi dari Terraform ke Pulumi dimungkinkan menggunakan pulumi convert dan pulumi import, tetapi memerlukan perencanaan cermat dan rollout bertahap.