Automasi Infrastruktur Skala Enterprise Menggunakan Terraform dan Ansible

1. Konteks Industri & Analisis Akar Masalah

Dalam lanskap enterprise modern, infrastruktur web tidak lagi dikelola secara manual (manual provisioning) menggunakan Secure Shell (SSH) langsung ke instance cloud atau on-premise. Pendekatan lama seperti Configuration Drift—di mana server-server yang seharusnya identik menjadi berbeda karena modifikasi ad-hoc yang tidak tercatat—menyebabkan kegagalan sistem yang sulit didiagnosis. Ketika sebuah platform web enterprise memerlukan skalabilitas tinggi untuk menangani lonjakan traffic, proses pembuatan server baru secara manual akan memakan waktu berjam-jam, rentan terhadap human error, dan mengabaikan standar keamanan organisasi.

Bottleneck utama terletak pada tidak adanya sinkronisasi antara Infrastructure as Code (IaC) untuk provisioning sumber daya komputasi dan Configuration Management untuk pengelolaan sistem operasi serta service di dalamnya. Seringkali, tim terjebak dalam skrip Bash monolitik yang rapuh (fragile shell scripts) tanpa idempotensi, sehingga menjalankan skrip dua kali dapat merusak sistem yang sudah berjalan.

Perbandingan Kondisi:

• Sebelum Penerapan Automasi (Manual): Waktu provisioning per server 2-4 jam, inkonsistensi konfigurasi antar environment (Dev, Staging, Prod), tidak ada audit trail yang jelas, pemulihan bencana (disaster recovery) memakan waktu berhari-hari.
• Sesudah Penerapan Automasi (Terraform + Ansible): Waktu provisioning total < 10 menit, lingkungan identik secara mutlak (immutable infrastructure approach), riwayat perubahan terdokumentasi dalam Git (GitOps workflow), dan pemulihan bencana dapat diselesaikan hanya dengan menjalankan ulang pipeline.

2. Konsep Inti & Deep Dive Arsitektur

Automasi infrastruktur enterprise mengombinasikan dua pilar utama: Terraform untuk provisioning sumber daya level cloud (IaaS/PaaS) dan Ansible untuk manajemen konfigurasi, deployment aplikasi, serta hardening sistem operasi.

+-------------------------------------------------------------------------+
|                        Developer / GitOps Pipeline                      |
+-------------------------------------------------------------------------+
          |                                       |
          v                                       v
+--------------------+                  +--------------------+
|     Terraform      |                  |      Ansible       |
| (Provisioning IaC) |                  | (Configuration Mgmt)|
+--------------------+                  +--------------------+
          |                                       |
          v                                       v
+-------------------------------------------------------------------------+
|                        Cloud Provider (AWS/GCP/Azure)                   |
|  - VPC / Subnets / Security Groups / EC2 Instances / Load Balancers       |
+-------------------------------------------------------------------------+
          |
          v (Dynamic Inventory)
+-------------------------------------------------------------------------+
|                         Target Web Servers                              |
|  - OS Hardening / Nginx / PHP-FPM / Redis / MySQL Client / Fail2ban       |
+-------------------------------------------------------------------------+

Alur Eksekusi (Execution Flow)

1. Inisialisasi & Plan Terraform: Engineer mendefinisikan state target dalam file .tf. Terraform memvalidasi state saat ini melalui file terraform.tfstate dan merencanakan perubahan diff.
2. Provisioning Infrastruktur: Terraform mengeksekusi API cloud provider untuk menciptakan VPC, Subnet, Security Group, dan Instance EC2/Compute.
3. Dynamic Inventory: Ansible memanfaatkan plugin inventory Terraform untuk membaca IP instance yang baru dibuat secara otomatis.
4. Konfigurasi & Hardening: Playbook Ansible berjalan secara paralel (atau berurutan) untuk memasang web server Nginx, mengatur konfigurasi PHP-FPM, mengaktifkan UFW/Fail2ban, serta memasang SSL/TLS dari Let's Encrypt.

3. Perbandingan Komparatif / Analisis Pendekatan

Untuk memilih tool yang tepat dalam ekosistem enterprise, kita perlu memahami keunggulan dan trade-off dari masing-masing pendekatan automasi:

[!TIP] Gunakan Terraform khusus untuk mengatur infrastruktur fisik/virtual cloud (Network, Compute, Storage), dan gunakan Ansible untuk mengatur apa yang ada di dalam server tersebut (Software stack, Security hardening, Application deployment).

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum memulai implementasi, pastikan environment kerja Anda memenuhi spesifikasi enterprise berikut:

• Control Machine: Linux (Ubuntu 22.04 LTS / RHEL 9) atau macOS dengan spesifikasi minimal 2 vCPU, 4GB RAM.
• Software Dependencies:
  • Terraform >= 1.6.0
  • Ansible >= 2.15.0
  • AWS CLI / GCP SDK (sesuai cloud provider yang digunakan)
  • Git
• Autentikasi & Izin:
  • Kredensial Cloud Provider dengan hak akses penuh (AdministratorAccess atau PowerUser untuk lab).
  • Kunci SSH (id_rsa / id_ed25519) untuk komunikasi Ansible ke remote server.

Verifikasi instalasi dengan perintah berikut pada terminal:

terraform -version
ansible --version
aws --version

5. Panduan Implementasi Langkah demi Langkah

Struktur Direktori Project

Organisasi file enterprise harus bersih dan modular:

enterprise-infra/
├── terraform/
│   ├── main.tf
│   ├── variables.tf
│   ├── outputs.tf
│   └── terraform.tfvars
└── ansible/
    ├── inventory.yml
    ├── playbook.yml
    └── roles/
        └── webserver/
            ├── tasks/
            │   └── main.yml
            └── templates/
                └── nginx.conf.j2

A. Implementasi Terraform (terraform/main.tf)

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

provider "aws" {
  region = var.aws_region
}

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

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

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        = "enterprise-web-sg"
  description = "Security group for web servers"
  vpc_id      = aws_vpc.main.id

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

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

  ingress {
    description = "Allow SSH from Bastion"
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["10.0.0.0/16"]
  }

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

  tags = {
    Name = "web-sg"
  }
}

resource "aws_instance" "web_server" {
  ami           = "ami-0c7217cdde317cfec" # 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      = "enterprise-deploy-key"

  root_block_device {
    volume_size           = 50
    volume_type           = "gp3"
    encrypted             = true
    delete_on_termination = false
  }

  tags = {
    Name        = "enterprise-web-node"
    Environment = "production"
  }
}

output "web_instance_ip" {
  value       = aws_instance.web_server.public_ip
  description = "Public IP of the provisioned web server"
}

B. Implementasi Ansible Playbook & Role

File Ansible Inventory (ansible/inventory.yml):

all:
  hosts:
    web_node_1:
      ansible_host: 54.254.120.15 # Sesuaikan dengan output Terraform
      ansible_user: ubuntu
      ansible_ssh_private_key_file: ~/.ssh/enterprise-deploy-key.pem

Ansible Role Tasks (ansible/roles/webserver/tasks/main.yml):

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

- name: Install Nginx, PHP-FPM, and essential utilities
  apt:
    name:
      - nginx
      - php8.1-fpm
      - php8.1-cli
      - php8.1-mysql
      - php8.1-redis
      - fail2ban
      - ufw
    state: present

- name: Configure UFW firewall rules
  ufw:
    rule: allow
    port: "{{ item }}"
    proto: tcp
  loop:
    - "22"
    - "80"
    - "443"

- name: Enable and start UFW
  ufw:
    state: enabled
    policy: deny

- name: Deploy custom Nginx configuration
  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 at boot
  systemd:
    name: "{{ item }}"
    state: started
    enabled: yes
  loop:
    - nginx
    - php8.1-fpm
    - fail2ban

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

Nginx Template (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 _;

    client_max_body_size 64M;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

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

    location ~ /\.ht {
        deny all;
    }
}

Main Playbook (ansible/playbook.yml):

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

6. Bedah Kode & Penjelasan Detail Baris Kunci

• Backend S3 Terraform (backend "s3"): Menyimpan file state terraform.tfstate di cloud storage terpusat dengan enkripsi aktif serta menggunakan DynamoDB untuk State Locking. Ini mencegah dua engineer menjalankan terraform apply secara bersamaan yang dapat merusak struktur state.
• Root Block Device Encryption (encrypted = true): Memastikan volume EBS AWS terenkripsi secara default untuk mematuhi standar kepatuhan keamanan enterprise (SOC2, ISO 27001).
• Ansible Idempotency (apt, systemd, ufw modules): Seluruh modul Ansible yang digunakan bersifat idempotent. Artinya, Ansible mengecek kondisi aktual server sebelum melakukan perubahan; jika service Nginx sudah berjalan, Ansible tidak akan melakukan restart yang tidak perlu.
• UFW Default Policy (policy: deny): Mengamankan server dengan menutup seluruh port inbound secara default dan hanya membuka port 22 (SSH), 80 (HTTP), dan 443 (HTTPS).

7. Skenario Produksi & Studi Kasus Dunia Nyata

Dalam skenario enterprise dengan traffic tinggi (misalnya flash sale e-commerce dengan 50.000 concurrent users), arsitektur tunggal tidak akan mencukupi. Pendekatan yang diterapkan:

1. Auto Scaling Group (ASG) Terraform: Terraform mendefinisikan Launch Template dan Auto Scaling Group alih-alih instance tunggal. Parameter min_size = 3, max_size = 15, dengan Target Tracking Scaling Policy berdasarkan utilisasi CPU (70%).
2. Application Load Balancer (ALB): Ditempatkan di depan node web untuk mendistribusikan beban secara merata melalui algoritma Least Outstanding Requests.
3. Dynamic Inventory Ansible untuk ASG: Ansible menggunakan AWS EC2 plugin inventory (aws_ec2.yaml) untuk secara otomatis mendeteksi instance baru yang diciptakan oleh ASG dan langsung memasang konfigurasi web stack dalam waktu kurang dari 3 menit setelah instance booting.

8. Common Pitfalls, Anti-Patterns & Solusi

• Anti-Pattern 1: Menyimpan Secret dalam File Konfigurasi IaC.
  • Dampak: Kunci API, password database, atau private key bocor ke publik jika repository Git bersifat open-source atau terjadi kebocoran internal.
  • Solusi: Gunakan HashiCorp Vault, AWS Secrets Manager, atau Ansible Vault untuk mengenkripsi data sensitif.
• Anti-Pattern 2: Hardcoding IP Address pada Playbook Ansible.
  • Dampak: Playbook gagal ketika server di-provision ulang dan mendapatkan IP baru.
  • Solusi: Selalu gunakan Dynamic Inventory yang terhubung langsung dengan state Terraform atau tag cloud provider.
• Anti-Pattern 3: Tidak Menggunakan State Locking pada Terraform.
  • Dampak: Terjadi korupsi state (state corruption) saat kolaborasi tim.
  • Solusi: Selalu aktifkan backend remote dengan dukungan locking (contoh: S3 + DynamoDB).

9. Benchmark, Metrik Kinerja & Tuning Performa

Setelah infrastruktur otomatis selesai di-deploy, lakukan pengujian performa menggunakan tool wrk untuk mensimulasikan beban tinggi pada web server Nginx + PHP-FPM:

wrk -t12 -c400 -d30s http://54.254.120.15/

Parameter Tuning Lanjutan (Nginx & PHP-FPM):

Terapkan optimasi berikut pada file konfigurasi sistem operasi (/etc/sysctl.conf) melalui Ansible untuk menangani koneksi konkuren masif:

# Meningkatkan batas file descriptor
fs.file-max = 2097152

# Optimasi TCP backlog dan SYN flood protection
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 8192
net.ipv4.ip_local_port_range = 1024 65535

10. Checklist Penerapan Produksi & Kesimpulan

Gunakan checklist berikut sebelum merilis infrastruktur automasi ke lingkungan production:

• Semua file state Terraform disimpan di remote backend terenkripsi dengan locking aktif.
• Tidak ada password atau secret plain-text di dalam repositori Git.
• Firewall (UFW/Security Group) dikonfigurasi dengan prinsip deny-by-default.
• Seluruh playbook Ansible telah diuji pada staging environment dan terbukti idempotent.
• Log sistem (Nginx access/error log, Syslog) terintegrasi dengan sistem centralized logging (ELK / Grafana Loki).
• Prosedur backup otomatis untuk database dan storage telah terjadwal melalui cron/Ansible.

Automasi infrastruktur menggunakan Terraform dan Ansible bukan sekadar tren teknologi, melainkan fondasi fundamental dalam membangun sistem enterprise yang tangguh, dapat diulang (repeatable), dan aman dari configuration drift. Dengan memisahkan tugas provisioning dan konfigurasi, organisasi mencapai efisiensi operasional tingkat tinggi serta ketahanan sistem yang optimal.