Implementasi Infrastructure as Code (IaC) Menggunakan Terraform dan AWS

1. Konteks Industri & Analisis Akar Masalah

Dalam lanskap arsitektur web modern, skalabilitas, keamanan, dan reproducibility (kemampuan untuk mereplikasi) infrastruktur adalah tiga pilar utama yang menentukan kesuksesan operasional sebuah perusahaan teknologi. Di era di mana platform e-commerce, aplikasi SaaS, dan layanan finansial menuntut ketersediaan tinggi (high availability) 99.99%, pendekatan tradisional dalam membangun infrastruktur secara manual—yang sering disebut sebagai ClickOps (mengandalkan klik pada AWS Management Console)—telah terbukti menjadi single point of failure yang kronis.

Bottleneck Performa dan Keamanan Dunia Nyata

Ketika sebuah tim infrastruktur mengandalkan konfigurasi manual, beberapa masalah krusial hampir pasti muncul:

1. Configuration Drift (Penyimpangan Konfigurasi): Perubahan kecil yang dilakukan secara langsung (ad-hoc patching) pada server produksi untuk memperbaiki insiden darurat sering kali tidak tercatat dalam dokumentasi, menyebabkan lingkungan staging dan production menjadi tidak sinkron.
2. Human Error: Kesalahan pengetikan parameter keamanan, seperti membuka Security Group AWS pada port 0.0.0.0/0 untuk database MySQL (3306) atau Redis (6379), kerap memicu kebocoran data skala masif.
3. Auditability yang Lemah: Melacak siapa yang mengubah konfigurasi load balancer atau menambah kapasitas instance EC2 menjadi mustahil tanpa riwayat version control yang jelas.

Perbandingan Kondisi: Sebelum vs Sesudah Penerapan IaC (Terraform + AWS)

2. Konsep Inti & Deep Dive Arsitektur

Terraform adalah Declarative Infrastructure as Code (IaC) tool yang dikembangkan oleh HashiCorp. Berbeda dengan pendekatan imperatif (seperti skrip Bash yang mendikte langkah demi langkah bagaimana membuat sesuatu), Terraform memungkinkan Anda mendefinisikan desired state (keadaan yang diinginkan) dari infrastruktur Anda, dan Terraform akan menghitung serta mengeksekusi delta (perbedaan antara kondisi saat ini dan kondisi yang diinginkan).

Alur Kerja Terraform (The Terraform Lifecycle)

1. Write: Menulis konfigurasi infrastruktur dalam bahasa HCL (HashiCorp Configuration Language).
2. Init: Menginisialisasi direktori kerja, mengunduh provider AWS yang diperlukan, dan menyiapkan modul.
3. Plan: Membuat execution plan yang membandingkan kondisi saat ini (berdasarkan state file) dengan file konfigurasi.
4. Apply: Menerapkan perubahan nyata pada infrastruktur AWS melalui AWS API.

+-----------------------+
|     HCL Code (*.tf)   |
+-----------------------+
            |
            v
+-----------------------+
|    terraform plan     | <---> [ AWS Cloud API ]
+-----------------------+
            |
            v
+-----------------------+
|    terraform apply    | ---> [ Real AWS Infrastructure ]
+-----------------------+
            |
            v
+-----------------------+
|  terraform.tfstate    |
+-----------------------+

State file (terraform.tfstate) adalah fondasi dari Terraform. File ini bertindak sebagai single source of truth yang memetakan sumber daya di dunia nyata ke konfigurasi HCL Anda, lengkap dengan metadata dependensi.

3. Perbandingan Komparatif / Analisis Pendekatan

Dalam membangun arsitektur IaC di AWS, terdapat beberapa pilihan tool utama yang sering diperdebatkan oleh para Web Architect.

[!TIP] Gunakan Terraform jika perusahaan Anda berencana mengadopsi strategi multi-cloud (misalnya mengkombinasikan AWS untuk komputasi utama dan Cloudflare untuk Edge Caching/WAF). Gunakan AWS CDK jika tim Anda adalah pure backend developers (Node.js/Python) yang ingin menulis infrastruktur menggunakan bahasa pemrograman yang sama dengan aplikasi web mereka.

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum menyelam ke dalam penulisan kode, pastikan workstation atau CI/CD runner Anda memiliki perangkat lunak berikut terinstal:

• Terraform CLI (Versi 1.5.0 atau lebih baru)
• AWS CLI v2 (Dikonfigurasi dengan kredensial IAM yang memiliki hak akses administratif yang cukup)
• Git (Untuk version control)

Verifikasi instalasi dengan perintah berikut di terminal:

terraform version
aws --version
git --version

Konfigurasikan profil AWS CLI Anda:

aws configure --profile production-admin
# Masukkan AWS Access Key ID, Secret Access Key, Region (misal: ap-southeast-1), dan format output (json)

5. Panduan Implementasi Langkah demi Langkah

Kita akan membangun struktur direktori standar enterprise untuk lingkungan multi-environment (staging dan production) menggunakan sistem remote state yang aman.

Struktur Direktori Proyek

my-infra-project/
├── modules/
│   ├── vpc/
│   │   ├── main.tf
│   │   ├── variables.tf
│   │   └── outputs.tf
│   └── web_server/
│       ├── main.tf
│       ├── variables.tf
│       └── outputs.tf
└── environments/
    ├── staging/
    │   ├── main.tf
    │   ├── variables.tf
    │   └── backend.tf
    └── production/
        ├── main.tf
        ├── variables.tf
        └── backend.tf

Implementasi Modul VPC (modules/vpc/main.tf)

terraform {
  required_version = ">= 1.5.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

resource "aws_vpc" "main" {
  cidr_block           = var.vpc_cidr
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name        = "${var.environment}-vpc"
    Environment = var.environment
    ManagedBy   = "Terraform"
  }
}

resource "aws_subnet" "public" {
  count                   = length(var.public_subnet_cidrs)
  vpc_id                  = aws_vpc.main.id
  cidr_block              = var.public_subnet_cidrs[count.index]
  map_public_ip_on_launch = true

  tags = {
    Name        = "${var.environment}-public-subnet-${count.index + 1}"
    Environment = var.environment
  }
}

resource "aws_internet_gateway" "gw" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name        = "${var.environment}-igw"
    Environment = var.environment
  }
}

resource "aws_route_table" "public" {
  vpc_id = aws_vpc.main.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.gw.id
  }

  tags = {
    Name        = "${var.environment}-public-rt"
    Environment = var.environment
  }
}

resource "aws_route_table_association" "public" {
  count          = length(var.public_subnet_cidrs)
  subnet_id      = aws_subnet.public[count.index].id
  route_table_id = aws_route_table.public.id
}

Variabel Modul VPC (modules/vpc/variables.tf)

variable "environment" {
  type        = string
  description = "Nama lingkungan (staging/production)"
}

variable "vpc_cidr" {
  type        = string
  description = "CIDR block untuk VPC"
}

variable "public_subnet_cidrs" {
  type        = list(string)
  description = "List CIDR block untuk public subnet"
}

Output Modul VPC (modules/vpc/outputs.tf)

output "vpc_id" {
  value       = aws_vpc.main.id
  description = "ID dari VPC yang dibuat"
}

output "public_subnet_ids" {
  value       = aws_subnet.public[*].id
  description = "List ID public subnet"
}

Implementasi Lingkungan Production (environments/production/main.tf)

terraform {
  required_version = ">= 1.5.0"
  backend "s3" {
    bucket         = "company-terraform-state-prod-ap-southeast-1"
    key            = "production/vpc/terraform.tfstate"
    region         = "ap-southeast-1"
    dynamodb_table = "company-terraform-locks-prod"
    encrypt        = true
  }
}

provider "aws" {
  region = "ap-southeast-1"

  default_tags {
    tags = {
      Environment = "production"
      Project     = "E-Commerce Core"
      ManagedBy   = "Terraform"
    }
  }
}

module "vpc" {
  source              = "../../modules/vpc"
  environment         = "production"
  vpc_cidr            = "10.100.0.0/16"
  public_subnet_cidrs = ["10.100.1.0/24", "10.100.2.0/24"]
}

6. Bedah Kode & Penjelasan Detail Baris Kunci

1. State Locking dengan DynamoDB (dynamodb_table = "company-terraform-locks-prod"):
   • Mengapa krusial? Ketika dua engineer atau pipeline CI/CD mencoba menjalankan terraform apply secara bersamaan, state file dapat mengalami korupsi (race condition). DynamoDB mengunci state file selama proses eksekusi berlangsung.
2. Encryption pada S3 (encrypt = true):
   • Memastikan bahwa state file yang disimpan di AWS S3 terenkripsi menggunakan AWS KMS. Hal ini sangat penting karena state file sering kali memuat sensitive data seperti string koneksi database atau password hash.
3. Meta-argument count pada Subnet:
   • count = length(var.public_subnet_cidrs) memungkinkan pembuatan subnet secara dinamis berdasarkan array CIDR yang diberikan, membuat modul dapat digunakan kembali (reusable) untuk berbagai ukuran arsitektur.

7. Skenario Produksi & Studi Kasus Dunia Nyata

Dalam menghadapi traffic peak tinggi (misalnya saat 11.11 Flash Sale pada aplikasi e-commerce berbasis Go/Node.js dengan database MySQL/MariaDB dan caching Redis), arsitektur web harus didesain dengan Auto Scaling Group (ASG) di belakang Application Load Balancer (ALB).

Skrip Terraform untuk ALB dan Target Group:

resource "aws_lb" "web_alb" {
  name               = "prod-web-alb"
  internal           = false
  load_balancer_type = "application"
  security_groups    = [aws_security_group.alb_sg.id]
  subnets            = module.vpc.public_subnet_ids

  enable_deletion_protection = true
}

resource "aws_lb_target_group" "web_tg" {
  name     = "prod-web-tg"
  port     = 80
  protocol = "HTTP"
  vpc_id   = module.vpc.vpc_id

  health_check {
    path                = "/healthz"
    matcher             = "200"
    interval            = 15
    timeout             = 5
    healthy_threshold   = 2
    unhealthy_threshold = 3
  }
}

[!WARNING] Selalu aktifkan enable_deletion_protection = true pada Application Load Balancer dan Database RDS di lingkungan produksi untuk mencegah penghapusan tidak sengaja melalui perintah terraform destroy.

8. Common Pitfalls, Anti-Patterns & Solusi

1. Hardcoding Secret dalam File HCL:
   • Anti-Pattern: Menulis password database secara langsung di dalam file main.tf.
   • Solusi: Gunakan AWS Secrets Manager atau HashiCorp Vault, lalu ambil nilainya menggunakan data source aws_secretsmanager_secret_version.
2. Menyimpan State File secara Lokal:
   • Anti-Pattern: Mengandalkan file terraform.tfstate di laptop pribadi developer.
   • Solusi: Wajib menggunakan Remote Backend (S3 + DynamoDB atau Terraform Cloud) sejak hari pertama proyek dimulai.
3. Mengabaikan terraform import saat Migrasi Infrastruktur Lama:
   • Anti-Pattern: Menghapus infrastruktur lama yang dibuat manual dan membuatnya ulang via Terraform yang berpotensi menyebabkan downtime layanan web.
   • Solusi: Gunakan perintah terraform import aws_instance.web i-1234567890abcdef0 untuk memasukkan sumber daya eksisting ke dalam manajemen state Terraform.

9. Benchmark, Metrik Kinerja & Tuning Performa

Setelah infrastruktur web di-provision, Anda perlu menguji ketahanannya menggunakan tool load testing seperti k6 atau wrk. Berikut adalah skrip pengujian k6 sederhana untuk menguji endpoint web server Nginx/Go di AWS:

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 100 }, // Ramp up ke 100 users
    { duration: '5m', target: 500 }, // Beban puncak 500 concurrent users
    { duration: '2m', target: 0 },   // Ramp down
  ],
};

export default function () {
  const res = http.get('http://prod-web-alb-123456789.ap-southeast-1.elb.amazonaws.com/');
  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time < 200ms': (r) => r.timings.duration < 200,
  });
  sleep(1);
}

Tuning Parameter AWS & Web Server

• OS Kernel (sysctl.conf): Tingkatkan batas file descriptor (fs.file-max) dan optimalkan TCP backlog (net.core.somaxconn = 65535) untuk menangani koneksi WebSocket dan HTTP keep-alive berskala besar.
• AWS EC2 Instance Type: Gunakan instance berbasis AWS Graviton3 (misal: c7g.xlarge) untuk performa komputasi web yang lebih tinggi dengan efisiensi biaya hingga 40% dibandingkan generasi x86.

10. Checklist Penerapan Produksi & Kesimpulan

Sebelum meluncurkan infrastruktur Terraform ke lingkungan produksi, pastikan Anda telah melewati checklist validasi berikut:

• Remote backend S3 dan DynamoDB telah dikonfigurasi dengan enkripsi aktif.
• Seluruh Security Groups tidak ada yang membuka port sensitif ke 0.0.0.0/0 (kecuali port HTTP/HTTPS 80/443).
• Variabel sensitif dikelola via Secret Manager, bukan hardcoded di HCL.
• Fitur prevent_destroy atau enable_deletion_protection aktif untuk sumber daya kritikal (Database, ALB, S3 Bucket).
• Pipeline CI/CD (GitHub Actions / GitLab CI) menjalankan terraform validate dan terraform plan secara otomatis pada setiap Pull Request.

Dengan mengimplementasikan arsitektur Infrastructure as Code menggunakan Terraform dan AWS secara disiplin, tim engineering Anda tidak hanya mendapatkan efisiensi operasional yang masif, tetapi juga fondasi sistem web yang tangguh, aman, dan siap menghadapi pertumbuhan bisnis tanpa batas.