Automasi Infrastruktur Skala Masif dengan Terraform dan Ansible di Lingkungan Hybrid Cloud

1. Konteks Industri & Analisis Akar Masalah

Dalam lanskap enterprise modern, organisasi teknologi sering kali terjebak dalam kompleksitas pengelolaan infrastruktur yang terdistribusi di berbagai lingkungan (On-Premises, AWS, GCP, dan Cloudflare Edge). Pendekatan tradisional seperti Configuration Management manual atau skrip Bash ad-hoc menciptakan celah besar yang dikenal sebagai Configuration Drift. Masalah ini tidak hanya menyebabkan ketidakkonsistenan antar-lingkungan, tetapi juga memperpanjang Time-to-Market, meningkatkan risiko kegagalan sistem saat deployment, serta membuka celah keamanan akibat kelalaian manusia (human error).

Bottleneck performa dan keamanan yang sering ditemui di dunia nyata meliputi:

• Inkonsistensi State: Lingkungan staging yang menggunakan spesifikasi berbeda dari production menyebabkan bug yang lolos dari pengujian.
• Waktu Provisioning Lambat: Pembuatan server, konfigurasi database MySQL/MariaDB, dan setup web server Nginx secara manual memakan waktu berjam-jam.
• Manajemen Secret yang Buruk: Kunci API, sertifikat SSL Let's Encrypt, dan kredensial database yang diletakkan secara hardcode dalam skrip deployment.

Sebelum vs Sesudah Penerapan

• Sebelum: Tim infrastruktur membuat mesin virtual secara manual melalui Cloud Console, lalu menjalankan skrip Bash satu per satu untuk menginstal PHP-FPM, Redis, dan Postfix. Risiko kegagalan tinggi, audit trail tidak jelas, dan sulit melakukan rollback.
• Sesudah: Seluruh infrastruktur dideklarasikan sebagai kode menggunakan Terraform (Infrastructure as Code). Konfigurasi sistem operasi, keamanan WAF (Fail2ban), dan optimasi kernel di-otomasi sepenuhnya oleh Ansible. Perubahan terlacak dalam sistem Version Control (Git), memastikan reproduktifitas mutlak dan zero-downtime deployment.

2. Konsep Inti & Deep Dive Arsitektur

Arsitektur hybrid cloud yang robust memerlukan pemisahan tanggung jawab yang jelas antara Terraform dan Ansible:

• Terraform: Bertindak sebagai Provisioning Engine. Fokusnya adalah menciptakan sumber daya infrastruktur dasar: VPC, Subnet, Firewall Rules, Virtual Machines (EC2/Compute Engine), Storage (S3/MinIO), dan DNS Records.
• Ansible: Bertindak sebagai Configuration Management & Orchestration Engine. Begitu Terraform selesai membuat VM, Ansible mengambil alih untuk mengonfigurasi OS, memasang Nginx, Node.js/Go backend, mengatur Redis caching, dan mengonfigurasi Supervisor untuk memelihara proses background worker.

+-------------------------------------------------------------------------+
|                           Git Version Control                           |
+-------------------------------------------------------------------------+
                                     |
                                     v
+------------------+         +------------------+
|    Terraform     | ------> |  Hybrid Cloud    | (AWS / On-Prem)
|  (Provisioning)  |         |  (VMs, VPC, S3)  |
+------------------+         +------------------+
                                     |
                                     v (Dynamic Inventory)
                             +------------------+ 
                             |     Ansible      | 
                             | (Configuration)  | 
                             +------------------+
                                     |
                                     v
                             +------------------+
                             | Web, DB, Redis,  |
                             | Postfix, Nginx   |
                             +------------------+

3. Perbandingan Komparatif / Analisis Pendekatan

[!IMPORTANT] Jangan pernah menggunakan Ansible untuk memprovisi infrastruktur cloud dasar secara masif dalam skala besar, karena Ansible tidak memiliki manajemen state terpusat seperti Terraform yang dapat mendeteksi perubahan out-of-band.

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum menjalankan pipeline automasi, pastikan dependensi berikut terinstal pada mesin runner atau control node:

• Terraform v1.6+
• Ansible v2.15+
• Python 3.10+ dengan pustaka boto3 dan botocore (jika menggunakan AWS)
• SSH Keypair dengan akses sudo tanpa password ke target nodes.

Verifikasi instalasi awal dengan perintah:

terraform version
ansible --version
python3 -c "import boto3; print(boto3.__version__)"

5. Panduan Implementasi Langkah demi Langkah

Langkah 1: Terraform Configuration (main.tf)

File ini mendefinisikan infrastruktur dasar pada AWS EC2.

terraform {
  required_version = ">= 1.6.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
  backend "s3" {
    bucket         = "enterprise-terraform-state-prod"
    key            = "hybrid/terraform.tfstate"
    region         = "ap-southeast-1"
    encrypt        = true
    dynamodb_table = "terraform-locks"
  }
}

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

resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name = "enterprise-vpc"
  }
}

resource "aws_subnet" "public" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  map_public_ip_on_launch = true

  tags = {
    Name = "enterprise-public-subnet"
  }
}

resource "aws_security_group" "web_sg" {
  name        = "web_server_sg"
  description = "Allow HTTP, HTTPS, and SSH"
  vpc_id      = aws_vpc.main.id

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

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

  ingress {
    description = "SSH from Admin"
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["203.0.113.50/32"]
  }

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

resource "aws_instance" "web_server" {
  ami           = "ami-0c55b159cbfafe1f0" # Ubuntu 22.04 LTS
  instance_type = "t3.medium"
  subnet_id     = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web_sg.id]
  key_name      = "production-deployer-key"

  tags = {
    Name = "Enterprise-Web-Node"
  }
}

output "web_instance_ip" {
  value = aws_instance.web_server.public_ip
}

Langkah 2: Ansible Inventory Dinamis (inventory.aws_ec2.yml)

Mengambil IP server secara otomatis dari instance yang dibuat oleh Terraform.

plugin: amazon.aws.aws_ec2
regions:
  - ap-southeast-1
keyed_groups:
  - key: tags.Name
    prefix: tag
filters:
  instance-state-name: running
hostnames:
  - ip-address

Langkah 3: Ansible Playbook (site.yml)

Playbook untuk mengonfigurasi Nginx, PHP-FPM, Redis, dan Fail2ban.

---
- hosts: tag_Enterprise_Web_Node
  become: true
  vars:
    php_version: "8.2"
  tasks:
    - name: Update apt cache
      apt:
        update_cache: yes
        cache_valid_time: 3600

    - name: Install essential packages
      apt:
        name:
          - curl
          - git
          - ufw
          - fail2ban
          - redis-server
        state: present

    - name: Add PPA for PHP
      apt_repository:
        repo: "ppa:ondrej/php"
        state: present

    - name: Install Nginx and PHP-FPM
      apt:
        name:
          - nginx
          - php{{ php_version }}-fpm
          - php{{ php_version }}-mysql
          - php{{ php_version }}-redis
          - php{{ php_version }}-curl
        state: present

    - name: Configure Fail2ban for SSH protection
      copy:
        dest: /etc/fail2ban/jail.local
        content: |
          [sshd]
          enabled = true
          port = ssh
          logpath = %(sshd_log)s
          maxretry = 3
          bantime = 3600
      notify: Restart fail2ban

    - name: Ensure Nginx is running and enabled
      service:
        name: nginx
        state: started
        enabled: yes

  handlers:
    - name: Restart fail2ban
      service:
        name: fail2ban
        state: restarted

6. Bedah Kode & Penjelasan Detail Baris Kunci

1. Terraform backend "s3": Baris ini menyimpan file state Terraform di Amazon S3 dengan enkripsi aktif dan penguncian konkurensi menggunakan DynamoDB. Hal ini mencegah dua engineer atau pipeline CI/CD melakukan apply secara bersamaan yang dapat merusak state file.
2. Ansible become: true: Menjalankan tugas-tugas konfigurasi dengan hak akses superuser (root), yang mutlak diperlukan saat menginstal paket sistem seperti Nginx dan memodifikasi konfigurasi firewall.
3. Ansible notify: Restart fail2ban: Mekanisme handler memastikan bahwa layanan Fail2ban hanya akan direstart jika ada perubahan aktual pada file konfigurasi /etc/fail2ban/jail.local, menghindari restart yang tidak perlu.

7. Skenario Produksi & Studi Kasus Dunia Nyata

Pada sistem e-commerce berskala tinggi dengan concurrency mencapai 50.000 request per detik, arsitektur di atas dikembangkan dengan menambahkan Load Balancer (AWS ALB) di depan auto-scaling group instance Nginx, serta menghubungkan cluster Redis terpusat untuk manajemen sesi PHP dan caching database MariaDB.

[!TIP] Gunakan Ansible mitogen plugin untuk mempercepat waktu eksekusi playbook hingga 4x lipat pada ratusan node target secara simultan.

8. Common Pitfalls, Anti-Patterns & Solusi

• Anti-Pattern 1: Menyimpan secret key langsung di dalam file Terraform atau Ansible vars.
  • Solusi: Gunakan HashiCorp Vault atau AWS Secrets Manager, lalu ambil nilainya secara dinamis saat eksekusi.
• Anti-Pattern 2: Menjalankan terraform apply langsung dari mesin lokal tanpa Remote State.
  • Solusi: Seluruh eksekusi produksi wajib melalui pipeline CI/CD (GitHub Actions / GitLab CI) dengan Remote Backend yang terkunci.

9. Benchmark, Metrik Kinerja & Tuning Performa

Lakukan pengujian beban menggunakan k6 untuk memvalidasi performa Nginx dan PHP-FPM setelah dikonfigurasi:

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

export const options = {
  stages: [
    { duration: '1m', target: 1000 },
    { duration: '3m', target: 5000 },
    { duration: '1m', target: 0 },
  ],
};

export default function () {
  const res = http.get('http://your-load-balancer-endpoint/');
  check(res, { 'status was 200': (r) => r.status === 200 });
  sleep(1);
}

Tuning parameter pada kernel Linux (/etc/sysctl.conf) untuk menangani koneksi TCP masif:

net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 8192
net.ipv4.tcp_tw_reuse = 1

10. Checklist Penerapan Produksi & Kesimpulan

• Remote state Terraform terenkripsi dan terlindungi dengan DynamoDB locking.
• Semua secret telah dipindahkan dari source code ke Secret Manager.
• Firewall (UFW/Security Groups) hanya membuka port esensial (80, 443, 22 terbatas).
• Fail2ban dan SSH Key-based authentication aktif.
• Ansible idempotent check lulus tanpa changed berlebih pada eksekusi kedua.

Penerapan Terraform dan Ansible secara sinergis menciptakan fondasi infrastruktur hybrid cloud yang lincah, aman, dan siap menghadapi beban skala masif tanpa mengorbankan stabilitas operasional.