Automasi Infrastruktur Skala Enterprise Menggunakan Terraform dan Ansible di AWS Multi-Region

1. Konteks Industri & Analisis Akar Masalah

Di era komputasi modern, kegagalan infrastruktur bukanlah sebuah kemungkinan (probability), melainkan kepastian waktu (certainty). Perusahaan berskala enterprise yang mengandalkan satu region cloud tunggal menghadapi risiko fatal ketika terjadi bencana alam, pemadaman zona ketersediaan (Availability Zone), atau kegagalan jaringan global. Bottleneck utama dari manajemen infrastruktur manual adalah tingginya human error, inkonsistensi konfigurasi antara environment Staging dan Production, serta lambatnya waktu pemulihan (Recovery Time Objective - RTO).

Sebelum penerapan automasi lintas region dengan Terraform dan Ansible, sebuah enterprise biasanya mengalami:

• Konfigurasi Drift: Perbedaan status server manual yang menyebabkan aplikasi berjalan di server A namun gagal di server B.
• Downtime Signifikan: Proses failover DNS dan database memakan waktu berjam-jam karena harus dilakukan secara manual.
• Kepatuhan & Keamanan yang Lemah: Kesulitan menerapkan kebijakan keamanan IAM, firewall, dan enkripsi secara seragam di seluruh belahan dunia.

Sesudah penerapan automasi penuh (Infrastructure as Code + Configuration Management):

• Immutable Infrastructure: Setiap perubahan berbasis versi, dapat di-rollback seketika.
• Multi-Region Active-Active / Active-Passive: Beban traffic didistribusikan secara global melalui Cloudflare dan Route 53, dengan replikasi database real-time.
• Zero Downtime Deployment: Pembaruan sistem dilakukan melalui rolling update otomatis tanpa menghentikan layanan web server Nginx atau backend Go/Node.js.

2. Konsep Inti & Deep Dive Arsitektur

Arsitektur enterprise modern menggabungkan Terraform untuk Provisioning (membangun VPC, EC2, RDS, S3, ALB) dan Ansible untuk Configuration Management (menginstal Nginx, PHP-FPM, Redis, memonitor log, mengatur SSL Let's Encrypt).

+-----------------------------------------------------------------------------------+
|                                Global Traffic (Cloudflare/Route 53)               | 
+-----------------------------------------------------------------------------------+
          |                                                          |
          v                                                          v
+----------------------------------+       +----------------------------------+
| AWS Region A (us-east-1)         |       | AWS Region B (eu-central-1)      |
|                                  |       |                                  |
|  [ Application Load Balancer ]   |       |  [ Application Load Balancer ]   |
|          |                       |       |          |                       |
|          v                       |       |          v                       |
|  [ EC2 Web Nodes (Auto Scaling) ]|<----->|  [ EC2 Web Nodes (Auto Scaling) ]|
|    - Nginx + PHP-FPM / Go        |       |    - Nginx + PHP-FPM / Go        |
|    - Ansible Configured          |       |    - Ansible Configured          |
|          |                       |       |          |                       |
|          v                       |       |          v                       |
|  [ Amazon Aurora Global DB ]     |<=====>|  [ Amazon Aurora Global DB ]     |
+----------------------------------+       +----------------------------------+

Alur eksekusi sistem:

1. Terraform Apply: Membangun fondasi jaringan (VPC, Subnet Public/Private, Route Table), security group, instance EC2, dan database RDS Aurora di dua region secara paralel menggunakan Terraform Workspaces atau Providers Aliases.
2. Dynamic Inventory: Ansible membaca output state Terraform secara dinamis untuk mengetahui IP publik/privat instance yang baru dibuat.
3. Ansible Playbook: Mengeksekusi hardening OS, instalasi Nginx, konfigurasi PHP-FPM/Go, setup Redis Cache, penarikan sertifikat SSL, dan inisialisasi Supervisor untuk background worker.

3. Perbandingan Komparatif / Analisis Pendekatan

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum memulai, pastikan tools berikut telah terinstal pada mesin kontrol (CI/CD Runner atau Workstation Engineer):

• Terraform: Versi >= 1.5.0
• Ansible: Versi >= 2.15
• AWS CLI: Terkonfigurasi dengan hak akses Administrator (atau policy IAM yang memadai untuk EC2, VPC, IAM, RDS, Route53).
• Git: Untuk manajemen repositori kode.

Verifikasi instalasi:

terraform -version
ansible --version
aws sts get-caller-identity

[!WARNING] Jangan pernah menggunakan kredensial AWS Root Account. Buatlah IAM User atau IAM Role khusus dengan policy minimum privilege yang mencakup hak akses infrastruktur cloud.

5. Panduan Implementasi Langkah demi Langkah

Struktur Direktori Proyek

enterprise-infra/
├── terraform/
│   ├── main.tf
│   ├── variables.tf
│   ├── outputs.tf
│   ├── providers.tf
│   └── modules/
│       └── vpc_web/
│           ├── main.tf
│           ├── variables.tf
│           └── outputs.tf
└── ansible/
    ├── inventory.aws_ec2.yml
    ├── site.yml
    └── roles/
        └── webserver/
            ├── tasks/
            │   └── main.yml
            └── templates/
                └── nginx.conf.j2

A. Terraform: Konfigurasi Multi-Region

Buat file terraform/providers.tf untuk mendefinisikan dua region AWS (us-east-1 dan eu-central-1).

terraform {
  required_version = ">= 1.5.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
  backend "s3" {
    bucket         = "enterprise-terraform-state-lock-prod"
    key            = "global/infrastructure.tfstate"
    region         = "us-east-1"
    dynamodb_table = "terraform-lock-table"
  }
}

provider "aws" {
  alias  = "primary"
  region = "us-east-1"
}

provider "aws" {
  alias  = "secondary"
  region = "eu-central-1"
}

Buat modul dasar web server di terraform/modules/vpc_web/main.tf:

variable "region_name" { type = string }
variable "vpc_cidr" { type = string }

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

  tags = {
    Name = "VPC-${var.region_name}"
  }
}

resource "aws_subnet" "public" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = cidrsubnet(var.vpc_cidr, 4, 1)
  availability_zone = "${var.region_name}a"

  tags = {
    Name = "Subnet-Public-${var.region_name}"
  }
}

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

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
  }
}

resource "aws_route_table_association" "a" {
  subnet_id      = aws_subnet.public.id
  route_table_id = aws_route_table.public.id
}

resource "aws_security_group" "web_sg" {
  name   = "web-sg-${var.region_name}"
  vpc_id = aws_vpc.main.id

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"] # Sesuaikan dengan IP Bastion Host Anda
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_instance" "web" {
  ami           = data.aws_ami.ubuntu.id
  instance_type = "t3.medium"
  subnet_id     = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web_sg.id]
  associate_public_ip_address = true

  tags = {
    Name = "WebServer-${var.region_name}"
    Role = "webserver"
  }
}

data "aws_ami" "ubuntu" {
  most_recent = true
  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*"]
  }
  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }
  owners = ["099720109477"]
}

output "web_public_ip" {
  value = aws_instance.web.public_ip
}

Panggil modul tersebut di terraform/main.tf:

module "vpc_us_east_1" {
  source      = "./modules/vpc_web"
  providers   = { aws = aws.primary }
  region_name = "us-east-1"
  vpc_cidr    = "10.100.0.0/16"
}

module "vpc_eu_central_1" {
  source      = "./modules/vpc_web"
  providers   = { aws = aws.secondary }
  region_name = "eu-central-1"
  vpc_cidr    = "10.200.0.0/16"
}

B. Ansible: Dynamic Inventory & Playbook

Buat file ansible/inventory.aws_ec2.yml untuk mengambil instance EC2 secara otomatis dari AWS berdasarkan tag:

plugin: amazon.aws.aws_ec2
regions:
  - us-east-1
  - eu-central-1
filters:
  tag:Role: webserver
  instance-state-name: running
keyed_groups:
  - key: tags.Name
    prefix: region
hostnames:
  - public-ip-address

Buat Ansible Playbook ansible/site.yml:

---
- hosts: all
  become: yes
  gather_facts: yes
  roles:
    - webserver

Buat role webserver ansible/roles/webserver/tasks/main.yml:

---
- name: Update apt cache and upgrade packages
  apt:
    update_cache: yes
    upgrade: safe

- name: Install Nginx, PHP-FPM, and Redis
  apt:
    name:
      - nginx
      - php8.1-fpm
      - php8.1-mysql
      - php8.1-redis
      - redis-server
    state: present

- name: Configure Nginx virtual host
  template:
    src: nginx.conf.j2
    dest: /etc/nginx/sites-available/default
    owner: root
    group: root
    mode: '0644'
  notify: Restart Nginx

- name: Ensure Nginx and PHP-FPM are running and enabled
  systemd:
    name: "{{ item }}"
    state: started
    enabled: yes
  loop:
    - nginx
    - php8.1-fpm
    - redis-server

handlers:
  - name: Restart Nginx
    systemd:
      name: nginx
      state: restarted

Template konfigurasi Nginx ansible/roles/webserver/templates/nginx.conf.j2:

server {
    listen 80 default_server;
    listen [::]:80 default_server;

    root /var/www/html;
    index index.php index.html index.htm index.nginx-debian.html;

    server_name _;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
    }

    location ~ /.ht {
        deny all;
    }
}

6. Bedah Kode & Penjelasan Detail Baris Kunci

• Remote State Locking (backend "s3" & dynamodb_table): Baris ini mencegah dua engineer atau pipeline CI/CD melakukan terraform apply secara bersamaan yang dapat merusak file state (.tfstate). DynamoDB bertindak sebagai pengunci atomik.
• cidrsubnet(var.vpc_cidr, 4, 1): Fungsi bawaan Terraform untuk memecah blok CIDR utama secara matematis menjadi subnet yang lebih kecil tanpa risiko tumpang tindih alamat IP.
• Plugin amazon.aws.aws_ec2: Mengeliminasi kebutuhan hardcode IP address di file inventory Ansible. Ansible akan berkomunikasi langsung dengan AWS API untuk melakukan discovery instance aktif berdasarkan tag.

7. Skenario Produksi & Studi Kasus Dunia Nyata

Pada perayaan Flash Sale akhir tahun, sebuah platform e-commerce mengalami lonjakan traffic hingga 500.000 Request Per Second (RPS). Dengan infrastruktur multi-region ini:

1. Cloudflare Load Balancing mendeteksi latensi dari region Asia/Eropa dan mengarahkan pengguna ke region AWS terdekat (us-east-1 atau eu-central-1).
2. Auto Scaling Group (ASG) yang di- provisioning Terraform secara otomatis menambah jumlah node EC2 dari 5 menjadi 50 instance.
3. Ansible secara otomatis menjalankan background hook untuk mengonfigurasi node baru dan mendaftarkannya ke target Nginx Upstream.
4. Session pengguna disimpan di cluster Redis terdistribusi, memastikan tidak ada data keranjang belanja yang hilang meskipun pengguna berpindah-pindah node web server.

8. Common Pitfalls, Anti-Patterns & Solusi

• Anti-Pattern 1: Menyimpan Secret di dalam Terraform/Ansible Code. Solusi: Gunakan AWS Secrets Manager atau HashiCorp Vault. Jangan pernah menulis database password atau API key secara plaintext di dalam git repository.
• Anti-Pattern 2: Menggunakan local-exec berlebihan di Terraform untuk provisioning OS. Solusi: Pisahkan tugas. Gunakan Terraform murni untuk infrastruktur (IaaS) dan Ansible untuk konfigurasi OS/Aplikasi (Configuration Management).
• Pitfalls 3: Lupa Mengatur lifecycle { create_before_destroy = true } pada resource penting. Solusi: Selalu tambahkan blok tersebut pada resource seperti ALB Target Groups atau Launch Templates untuk menghindari downtime saat pembaruan infrastruktur.

9. Benchmark, Metrik Kinerja & Tuning Performa

Untuk menguji ketahanan server web Nginx + PHP-FPM di atas instance EC2 hasil automasi, gunakan tool k6 atau wrk:

wrk -t12 -c400 -d30s http://<AWS_WEB_PUBLIC_IP>/

Parameter Tuning Lanjutan pada /etc/sysctl.conf (Diterapkan via Ansible):

# Optimasi Kernel Linux untuk High Concurrency Web Server
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 8192
net.ipv4.ip_local_port_range = 1024 65535
fs.file-max = 2097152

10. Checklist Penerapan Produksi & Kesimpulan

• Remote State S3 dan DynamoDB Table terenkripsi dan aktif.
• IAM Role memiliki hak akses terkecil (Least Privilege Principle).
• Ansible Playbook telah diuji pada staging environment menggunakan ansible-playbook --check (Dry Run).
• Monitoring CloudWatch dan sistem alerting (PagerDuty/Slack Webhook) terhubung ke seluruh instance.
• Disaster Recovery Drill (simulasi matinya satu region AWS) berhasil diuji tanpa kehilangan data.

Melalui kombinasi Terraform dan Ansible pada arsitektur AWS Multi-Region, organisasi Anda tidak hanya mencapai efisiensi operasional yang tinggi, tetapi juga ketahanan sistem tingkat enterprise yang siap menghadapi lonjakan beban ekstrim tanpa single point of failure.