Belajar Dasar OpenTofu

Pahami konsep fundamental OpenTofu, siklus kerja IaC (init, plan, apply, destroy), dan jalankan container Docker pertama Anda secara lokal.

OpenTofu adalah tool Infrastructure as Code (IaC) open-source yang merupakan fork dari Terraform (berlisensi MPL 2.0) di bawah naungan Linux Foundation. OpenTofu mengadopsi pendekatan deklaratif menggunakan sintaks HCL (HashiCorp Configuration Language).

Dengan pendekatan deklaratif, Anda cukup mendefinisikan kondisi akhir infrastruktur yang diinginkan (desired state), bukan menulis langkah-langkah prosedural satu per satu. OpenTofu yang akan menghitung perbedaan antara kondisi riil dengan kode Anda, lalu mengeksekusi perubahannya secara otomatis.

Prasyarat

Sebelum memulai latihan, pastikan Anda telah menyiapkan:

OpenTofu CLI: Terpasang di komputer Anda. Anda dapat memverifikasinya melalui terminal:
```
tofu -version
```
(Jika belum terpasang di macOS/Linux, Anda bisa memasangnya via Homebrew dengan brew install opentofu).
Docker: Docker Engine atau Docker Desktop dalam keadaan berjalan:
```
docker info
```

Konsep Inti OpenTofu

Ada lima konsep fundamental yang menjadi pondasi setiap proyek OpenTofu:

Provider: Plugin perantara yang menghubungkan OpenTofu dengan API target (seperti Docker, AWS, GCP, Cloudflare, Kubernetes, atau Hetzner).
Resource: Objek infrastruktur konkret yang ingin dibuat dan dikelola (seperti container Docker, VM, subnet, atau DNS record).
Data Source: Komponen untuk mengambil dan membaca informasi dari infrastruktur yang sudah ada tanpa perlu membuatnya kembali.
State (tofu.tfstate): File catatan berformat JSON yang memetakan kode deklaratif Anda dengan kondisi nyata di target API. File ini adalah single source of truth yang digunakan OpenTofu untuk mendeteksi perubahan (drift).
Variables & Outputs: Variabel input digunakan untuk parameterisasi konfigurasi agar fleksibel dan dapat dipakai ulang, sedangkan output digunakan untuk menampilkan data hasil proses (seperti alamat IP atau port URL) ke terminal.

Siklus Kerja Utama (The Core Workflow)

Alur kerja sehari-hari di OpenTofu berputar pada empat perintah utama yang dijalankan secara berurutan:

tofu init — Menginisialisasi direktori kerja, mengunduh provider plugin yang dibutuhkan ke direktori .terraform/, dan mengunci versinya di .terraform.lock.hcl.
tofu plan — Membaca konfigurasi dan membandingkannya dengan state saat ini untuk menyusun execution plan. Perintah ini memperlihatkan resource mana yang akan dibuat (+), diubah (~), atau dihapus (-) tanpa menyentuh infrastruktur riil.
tofu apply — Mengeksekusi rencana perubahan ke infrastruktur riil setelah meminta konfirmasi persetujuan (yes), lalu memperbarui file state lokal.
tofu destroy — Menghapus seluruh resource yang terdaftar di dalam konfigurasi secara aman dan bersih.

Praktik: Menjalankan Infrastruktur Pertama dengan Docker

Cara paling praktis dan gratis untuk mempelajari OpenTofu tanpa memerlukan kartu kredit atau akun cloud adalah menggunakan provider Docker di komputer lokal.

Buat direktori baru untuk latihan, lalu buat file main.tf:

mkdir belajar-opentofu && cd belajar-opentofu
touch main.tf

Salin konfigurasi berikut ke dalam main.tf:

terraform {
  required_providers {
    docker = {
      source  = "kreuzwerker/docker"
      version = "~> 4.6.0"
    }
  }
}

provider "docker" {
  # Socket default untuk sistem Unix / macOS / Linux
  host = "unix:///var/run/docker.sock"
}

# Mengunduh Docker Image Nginx
resource "docker_image" "nginx" {
  name         = "nginx:alpine"
  keep_locally = false
}

# Menjalankan Docker Container Nginx
resource "docker_container" "web" {
  image = docker_image.nginx.image_id
  name  = "belajar-opentofu-nginx"

  ports {
    internal = 80
    external = 8080
  }
}

# Menampilkan URL akses web setelah apply
output "container_url" {
  description = "URL untuk mengakses web Nginx"
  value       = "http://localhost:${docker_container.web.ports[0].external}"
}

Catatan Kompatibilitas: Blok konfigurasi tetap diawali dengan terraform { ... } karena OpenTofu mempertahankan kompatibilitas 100% dengan ekosistem sintaks HCL Terraform.

Langkah Eksekusi

1. Inisialisasi Proyek (`tofu init`)

Jalankan inisialisasi untuk mengunduh provider Docker:

tofu init

OpenTofu akan mendeteksi kebutuhan provider kreuzwerker/docker, mengunduh plugin biner ke folder tersembunyi .terraform/, dan mencatat checksum versi di file .terraform.lock.hcl.

2. Pratinjau Perubahan (`tofu plan`)

Lihat rencana eksekusi yang akan dilakukan:

tofu plan

Output akan menampilkan simbol hijau + pada docker_image.nginx dan docker_container.web. Ini menandakan dua resource baru akan dibuat.

3. Terapkan Konfigurasi (`tofu apply`)

Jalankan proses pembuatan infrastruktur:

tofu apply

OpenTofu akan meminta konfirmasi Anda. Ketik yes lalu tekan Enter.

Setelah proses selesai, OpenTofu akan menampilkan nilai output:

Apply complete! Resources: 2 added, 0 changed, 0 destroyed.

Outputs:

container_url = "http://localhost:8080"

Buka peramban (browser) Anda di http://localhost:8080 atau jalankan curl http://localhost:8080. Anda akan melihat halaman selamat datang standar “Welcome to nginx!”.

Membedah Anatomi Konfigurasi

1. Blok Provider dan Argumen `host`

Argumen host memberitahu OpenTofu ke mana ia harus mengirimkan perintah Docker API.

Pada Linux dan macOS, nilai standarnya adalah socket Unix: unix:///var/run/docker.sock.
Jika Anda menggunakan Windows atau Docker Desktop dengan environment variable standar, Anda bahkan dapat mengosongkan isi blok menjadi provider "docker" {}. Provider akan otomatis membaca variable lingkungan seperti DOCKER_HOST.

2. Format Blok `resource` dan Dua Labelnya

Setiap blok resource pada HCL OpenTofu wajib memiliki dua label string:

resource "<RESOURCE_TYPE>" "<LOCAL_NAME>" {
  # ... konfigurasi atribut ...
}

Contoh:
resource "docker_container" "web" { ... }
             ▲                ▲
             │                └─ 2. Local Name (Nama referensi / alias unik)
             └────────────────── 1. Resource Type (Tipe resource bawaan provider)

Resource Type (docker_container): Jenis resource yang disediakan oleh provider.
Local Name (web): Nama alias lokal yang Anda tentukan sendiri untuk dijadikan referensi di dalam kode OpenTofu lainnya.

3. Ketergantungan Implisit (Implicit Dependency)

Perhatikan baris berikut pada resource docker_container:

image = docker_image.nginx.image_id

Di sini kita tidak memasukkan ID image secara manual (hardcode), melainkan mereferensikan atribut image_id dari docker_image.nginx.

Dengan referensi ini, OpenTofu secara otomatis memahami bahwa container web bergantung pada image nginx. OpenTofu akan otomatis mengunduh image terlebih dahulu sebelum menyalakan container tanpa Anda perlu mengatur urutan secara manual.

Menginspeksi dan Mengelola State

Setelah tofu apply sukses, OpenTofu membuat file terraform.tfstate di direktori proyek Anda. Anda dapat menginspeksi resource yang sedang dikelola:

Melihat daftar resource aktif:
```
tofu state list
```
Melihat seluruh konfigurasi dan atribut detail (IP address, ID container, ports):
```
tofu show
```

Peringatan Keamanan: Jangan pernah mengubah file *.tfstate secara manual dengan teks editor. Selain itu, pastikan menambahkan *.tfstate dan *.tfstate.backup ke dalam .gitignore karena state file bisa memuat informasi sensitif atau kredensial.

Membersihkan Resource (`tofu destroy`)

Jika latihan telah selesai dan Anda ingin membersihkan container serta image yang telah dibuat:

tofu destroy

Ketik yes saat konfirmasi muncul. OpenTofu akan menghentikan dan menghapus container Nginx serta membersihkan resource terkait tanpa meninggalkan sisa.

Rangkuman & Langkah Berikutnya

Dalam tutorial ini, Anda telah mempelajari:

Filosofi deklaratif OpenTofu dan perannya dalam IaC.
Empat siklus kerja utama: init, plan, apply, dan destroy.
Membuat provider Docker, mendefinisikan image, container, dan output.
Cara OpenTofu mengelola ketergantungan implisit dan melacak infrastruktur lewat state.

Di bagian berikutnya, kita akan mempelajari Variabel dan Parameterisasi di OpenTofu agar konfigurasi infrastruktur Anda menjadi lebih modular, dinamis, dan siap digunakan di berbagai environment (development, staging, dan production).

Belajar Dasar OpenTofu

Prasyarat

Konsep Inti OpenTofu

Siklus Kerja Utama (The Core Workflow)

Praktik: Menjalankan Infrastruktur Pertama dengan Docker

Langkah Eksekusi

1. Inisialisasi Proyek (tofu init)

2. Pratinjau Perubahan (tofu plan)

3. Terapkan Konfigurasi (tofu apply)