Belajar DevOps Engineer - Infrastructure as Code (Terraform)

#Pendahuluan

Di episode 8 kalian men-deploy aplikasi ke Kubernetes — tetapi sebelum cluster bisa dipakai, ada lapisan yang lebih rendah yang harus disiapkan: VM, network, load balancer, registry, bahkan node cluster itu sendiri. Di kebanyakan tim, lapisan ini dibuat dengan klik-klik di console cloud. Masalahnya? Klik tidak bisa direview, tidak bisa diuji, tidak bisa diaudit, dan tidak bisa direproduksi.

Infrastructure as Code (IaC) memindahkan pembuatan infrastruktur dari console ke kode. Dan Terraform adalah tool IaC yang paling dominan — dengan turunan open source-nya, OpenTofu. Di episode ini kalian belajar filosofi IaC, konsep inti Terraform, dan praktik memprovision infrastruktur cloud nyata.

#Declarative vs Imperative

IaC terbagi dua pendekatan yang wajib kalian bedakan:

• Imperative — kalian menyebutkan langkah-langkahnya: "buat VM, lalu instal nginx, lalu nyalakan service". Tools seperti Ansible (episode 10) dan skrip shell.
• Declarative — kalian menyebutkan hasil akhirnya: "saya ingin satu VM dengan 2 vCPU, disk 50GB, dan IP publik". Terraform yang menentukan langkah untuk mewujudkannya.

Kekuatan pendekatan deklaratif: idempotensi. Menjalankan Terraform dua kali menghasilkan keadaan yang sama. Ini persis mental model desired state yang kalian lihat di Kubernetes episode 8.

#Konsep Inti Terraform

Pahami posisi state dengan baik: Terraform adalah tool pencocokan — ia membandingkan kode di folder dengan state, lalu menghitung diff. Jika state hilang atau tidak sinkron, Terraform bisa menganggap resource yang ada sebagai baru, atau menghapus yang seharusnya tetap.

#Praktik: Provision Infrastruktur Cloud

Mari buat VM kecil di cloud. File konfigurasi Terraform memakai ekstensi .tf:

terraform {
  required_version = ">= 1.8"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}
 
provider "aws" {
  region = var.region
}
 
resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t3.micro"
 
  tags = {
    Name    = "web-dev"
    Environment = "dev"
    Owner   = "platform"
  }
}
 
output "public_ip" {
  value = aws_instance.web.public_ip
}

Dan file variable-nya:

variable "region" {
  description = "Wilayah AWS"
  type        = string
  default     = "ap-southeast-1"
}

Jalankan siklus hidup Terraform:

terraform init              # unduh provider
terraform fmt               # format kode
terraform validate          # cek sintaks
terraform plan              # pratinjau perubahan
terraform apply             # terapkan (minta konfirmasi)
terraform show              # lihat hasil
terraform destroy           # hapus semua resource

#State: Aset Paling Berharga

File terraform.tfstate berisi seluruh peta resource → cloud. Aturannya sederhana namun krusial:

• Jangan pernah commit state ke Git — ia bisa memuat nilai sensitif.
• Simpan state di remote backend (S3, GCS, Terraform Cloud) agar seluruh tim bekerja pada state yang sama dan terkunci saat operasi.

terraform {
  backend "s3" {
    bucket         = "my-tfstate-bucket"
    key            = "devops-series/web/terraform.tfstate"
    region         = "ap-southeast-1"
    dynamodb_table = "tf-state-lock"
  }
}

Kunci dynamodb_table di atas adalah state locking — mencegah dua orang mengubah infrastruktur yang sama secara bersamaan. Ini analogi git lock untuk infrastruktur.

#Module dan Workspace

Kode Terraform cepat menjadi besar jika ditulis dalam satu file. Module mengelompokkan resource yang bisa dipakai ulang — misalnya "web-server" yang berisi VM + security group + DNS:

variable "name" {}
variable "instance_type" {
  default = "t3.micro"
}
 
resource "aws_instance" "this" {
  ami           = var.ami
  instance_type = var.instance_type
  tags = { Name = var.name }
}

module "web_dev" {
  source = "./modul-web"
  name   = "web-dev"
  ami    = "ami-0c55b159cbfafe1f0"
}
 
module "web_prod" {
  source        = "./modul-web"
  name          = "web-prod"
  instance_type = "m5.large"
  ami           = "ami-0c55b159cbfafe1f0"
}

Dua pemanggilan module dengan name berbeda berjalan di workspace/state yang sama, sehingga resource dev dan prod bisa hidup berdampingan dalam satu basis kode.

#Terraform vs OpenTofu

Pada 2023, Terraform berpindah dari MPL ke lisensi BUSL. Komunitas merespons dengan fork bernama OpenTofu yang diakui sebagai open source oleh CNCF. Secara praktis, sintaks keduanya identik — sebagian besar kode Terraform bisa langsung dijalankan di OpenTofu. Pilihan antara keduanya lebih soal preferensi lisensi dan ekosistem organisasi.

#Pitfall Umum

• State tidak di-backend remote — tim yang sama bisa menghancurkan resource satu sama lain.
• Terraform "konfigurasi" untuk konfigurasi — Terraform untuk provisioning; Ansible (episode 10) untuk konfigurasi di dalam mesin. Keduanya saling melengkapi, bukan menggantikan.
• destroy tanpa review — hapus resource dalam jumlah besar lebih mudah daripada dibuatnya.
• Secret di state — nilai resource seperti password cloud akan tersimpan di state; lindungi backend-nya.
• Refactor tanpa moved block — memindahkan resource antar-module bisa membuat Terraform ingin menghapus dan membuat ulang resource produksi.

#Penutup

Inti yang harus dibawa pulang:

• IaC memindahkan infrastruktur dari console ke kode yang bisa direview, diuji, dan direproduksi.
• Terraform declarative dan idempotent; siklus intinya init → plan → apply → destroy.
• State adalah aset paling berharga: remote backend + locking wajib untuk kerja tim.
• Module menyediakan reuse, workspace memisahkan environment.
• OpenTofu adalah turunan open source yang sintaksnya kompatibel.

Di episode 10 selanjutnya kita belajar Configuration Management dengan Ansible — pasangan alami Terraform. Jika Terraform menyediakan infrastruktur (server, network, database), Ansible mengatur keadaan di dalamnya: instalasi software, konfigurasi service, dan aplikasi policy secara konsisten di banyak mesin sekaligus.