Belajar Chef - Konsep Dasar & Arsitektur Utama

#Pendahuluan

Di episode 1 kalian sudah memahami mengapa Chef ada: menyelesaikan configuration drift, menjamin idempotency, dan menjadikan infrastruktur sebagai kode dengan model pull-based. Pertanyaan berikutnya yang wajar muncul adalah: bagaimana semua itu bekerja di balik layar?

Episode 2 ini menjawabnya dengan membedah arsitektur utama Chef. Kita akan menelusuri alur lengkap sebuah Chef client run — mulai dari Ohai yang mengumpulkan fakta node, mengunduh cookbook dan run_list, meng-compile recipe, mengkonvergen state, hingga melaporkan hasilnya. Kemudian kita akan membahas peran tiga komponen utama (Workstation, Chef Infra Server, Nodes) dan mengenal sembilan komponen inti yang akan kalian pakai setiap hari.

Ini adalah episode konseptual terpenting di fase awal series. Setelah menguasai peta arsitektur ini, seluruh episode praktik berikutnya hanyalah detail dari kerangka yang sama. Mari kita mulai dari jantungnya: alur chef-client.

#Alur Chef Client Run

Saat sebuah node menjalankan chef-client, terjadi serangkaian langkah yang berurutan. Pahami alur ini dengan baik karena seluruh troubleshooting Chef bermuara pada memahami fase mana yang gagal.

1. Ohai        ── kumpulkan fakta node (OS, memory, network, dll)
2. Unduh       ── ambil cookbook & run_list dari Chef Infra Server
3. Compile     ── terjemahkan recipe menjadi kumpulan resource
4. Converge    ── terapkan setiap resource (sesuai desired state)
5. Report      ── kirim hasil run ke server untuk diaudit

#1. Ohai — Mengumpulkan Fakta Node

Langkah pertama, chef-client menjalankan Ohai: tool yang mengumpulkan fakta (disebut attributes) tentang node — sistem operasi, versi kernel, memory, disk, hostname, IP address, dan ribuan data lainnya. Fakta ini tersimpan sebagai attribute node yang bisa dibaca recipe nanti (akan dibahas di episode 5).

#2. Unduh Cookbook & Run List

Node memiliki run_list — daftar berurutan recipe yang harus diterapkan. Berdasarkan run_list ini, node mengunduh cookbook-cookbook yang dibutuhkan dari Chef Infra Server, beserta semua dependency-nya.

#3. Compile Recipe

Recipe Ruby diterjemahkan menjadi kumpulan resource dalam memory. Fase ini belum mengubah apa pun — ia hanya membangun "rencana" resource yang ingin diterapkan, lengkap dengan properti dan action masing-masing.

#4. Converge — Terapkan State

Fase inti: Chef mengeksekusi setiap resource. Untuk setiap resource, ia memeriksa state saat ini di node dan hanya melakukan aksi jika terjadi perbedaan dari desired state. Inilah idempotency yang bekerja — resource yang sudah sesuai dilewati tanpa melakukan apa-apa.

#5. Report

Terakhir, hasil run — resource mana yang berhasil, berubah, atau gagal — dikirim kembali ke server untuk disimpan dan diaudit. Di ekosistem modern, laporan ini bisa ditampilkan di Chef Automate.

#Tiga Komponen Arsitektur

Arsitektur Chef dibagi menjadi tiga peran besar yang tidak bisa dipisahkan:

+------------------+      +----------------------+      +----------------+
|  WORKSTATION     | ---> |  CHEF INFRA SERVER   | <--- |     NODES      |
|  menulis kode    |      |  registry & store    |      |  jalankan      |
|  (author)        |      |  cookbook, data,     |      |  chef-client   |
+------------------+      |  node data, policies |      +----------------+
   upload / knife         +----------------------+          pull & apply

#Workstation

Workstation adalah mesin tempat kalian sebagai developer menulis kode: membuat cookbook, menulis recipe, menguji lokal, lalu meng-upload hasilnya ke server menggunakan knife atau berks. Inilah "kursi penulis" infrastruktur.

#Chef Infra Server

Chef Infra Server adalah pusat registry dan gudang penyimpanan. Ia menyimpan cookbook, node data, data bag, environment, roles, dan kebijakan (policy). Setiap node berkomunikasi dengan server ini untuk mendapatkan konfigurasi yang harus diterapkan.

#Nodes

Nodes adalah mesin yang dikelola (managed node). Di setiap node berjalan agent chef-client, yang secara berkala menarik konfigurasi dari server dan menerapkannya. Node bisa berupa server fisik, VM, container, maupun instance cloud.

#Komponen Inti yang Wajib Dikenal

Ini adalah sembilan komponen yang akan menemani kalian sepanjang series. Pahami perannya satu per satu:

#Cookbook

Unit terbesar organisasi kode Chef. Sebuah cookbook berisi recipe, attribute, template, file, library, dan metadata — semuanya untuk mengelola satu area konfigurasi, misalnya cookbook nginx.

#Recipe

File Ruby yang berisi resource-resource untuk dikonvergen. Recipe adalah "resep masakan" — urutan resource yang mendeskripsikan bagaimana node harus dikonfigurasi.

#Resource

Unit terkecil dan paling fundamental: satu pernyataan tentang apa yang diinginkan. Contoh package, service, file, template. Resource akan dibahas mendalam di episode 4.

#Attribute

Data tentang node, baik dari Ohai (otomatis) maupun dari cookbook (default/override). Attribute memberi recipe "konteks" seperti OS dan versi aplikasi.

#Run List

Daftar urutan recipe (dan/atau role) yang harus dijalankan node. Run list adalah jembatan antara node dan cookbook.

#Data Bag

Penyimpanan data global yang terstruktur di server, misalnya daftar user atau pengaturan aplikasi. Bisa dienkripsi untuk menyimpan secret (dibahas di episode 7).

#Environment

Pengelompokan logis node, misalnya development, staging, production. Environment memungkinkan konfigurasi berbeda per tahap tanpa mengubah cookbook.

#Role

Template run list yang bisa dipakai ulang. Role webserver bisa berisi beberapa recipe dan dipasang ke banyak node sekaligus.

#Knife

CLI utama Chef untuk berinteraksi dengan server: knife node list, knife cookbook upload, knife data bag create, dan lainnya.

knife node list                       # daftar semua node terdaftar
knife cookbook upload nginx           # upload cookbook ke server
knife data bag create admins          # buat data bag baru
knife environment show production     # lihat detail environment

#Hubungan Antar Komponen

Mari kita rangkum bagaimana komponen-komponen itu bekerja sama dalam satu skenario nyata: sebuah node baru ingin dipasangi nginx.

1. Workstation membuat cookbook nginx berisi recipe default yang mendeklarasikan resource package 'nginx' dan service 'nginx'.
2. Workstation meng-upload cookbook ke Chef Infra Server dengan knife cookbook upload nginx.
3. Node memiliki run_list recipe[nginx::default].
4. chef-client menarik run_list dan cookbook dari server, meng-compile recipe menjadi resource, lalu mengkonvergen: menginstall package nginx dan memastikan service-nya berjalan.
5. Hasil run dilaporkan kembali ke server.

package 'nginx' do
  action :install
end
 
service 'nginx' do
  action [:enable, :start]
end

#Penutup

Di episode 2 ini kita sudah membedah arsitektur Chef secara menyeluruh: alur lima fase chef client run (Ohai, unduh, compile, converge, report), peran tiga komponen utama (Workstation, Chef Infra Server, Nodes), dan sembilan komponen inti yang membentuk bahasa kerja Chef.

Inti yang harus dibawa pulang:

• Alur chef-client adalah Ohai → Unduh → Compile → Converge → Report.
• Workstation menulis kode, Chef Infra Server menyimpan dan mendistribusikan, Nodes menjalankan chef-client.
• Cookbook berisi recipe, recipe berisi resource — inilah hierarki kode Chef.
• Run list adalah jembatan antara node dan cookbook yang akan diterapkan.
• Knife adalah CLI yang menghubungkan kalian dengan Chef Infra Server.

Sekarang peta arsitektur sudah jelas di kepala kalian. Di episode 3 selanjutnya, kita langsung turun tangan: setup dan instalasi — menginstall Chef Workstation dan Chef Client, menjalankan chef-client dalam mode client, solo, maupun zero, melakukan bootstrap node, dan membuat struktur cookbook pertama dengan chef generate cookbook.