สร้าง Server แบบไม่ต้องกดคลิก ด้วยพลังของ Terraform

ผมมีโอกาสได้ช่วย provision Google Cloud infrastructure ให้กับคนรู้จักอยู่บ่อย ๆ ครับ ตอนแรก ๆ ระบบยังไม่ใหญ่มาก มีแค่ไม่กี่ service ก็เลยค่อย ๆ คลิกตั้งค่าผ่านหน้า UI เอา ยังพอไหวอยู่

แต่พอเริ่มต้องทำบ่อยขึ้น งานเดิม ๆ ขั้นตอนเดิม ๆ ทำซ้ำไปซ้ำมา ก็เริ่มรู้สึกเบื่อครับ เลยเริ่มคิดว่า น่าจะมีอะไรที่เอามาใช้ซ้ำได้บ้าง จะได้ไม่ต้องมานั่งคลิกใหม่ทุกครั้ง

ก็เลยไปเจอกับ Terraform ครับ เป็นเครื่องมือที่ช่วยให้เราสร้าง infrastructure ด้วยโค้ด แทนการกดผ่านหน้าเว็บ พอได้ลองใช้แล้วรู้สึกว่ามันสะดวก และเป็นระบบขึ้นเยอะมาก

บทความนี้ก็เลยอยากมาเล่าให้ฟังแบบสบาย ๆ ว่า Terraform คืออะไร และมันช่วยให้ชีวิตการ provision infrastructure ง่ายขึ้นยังไงครับ 🙂

Terraform คืออะไร?

ในยุคที่ Cloud Computing กลายเป็นหัวใจหลักของการทำระบบ หลายคนน่าจะคุ้นเคยกับการเข้าไปกดคลิกสร้าง Virtual Machine, Database หรือ Network ผ่านหน้า Console ของเจ้าใหญ่ ๆ อย่าง GCP, AWS หรือ Azure กันอยู่แล้ว

ช่วงแรก ๆ อาจจะยังไม่รู้สึกอะไร แต่พอโปรเจกต์เริ่มใหญ่ขึ้น มี resource มากขึ้น การจัดการทุกอย่างด้วยมือก็เริ่มซับซ้อน ใช้เวลาเยอะ และมีโอกาสพลาดได้ง่ายขึ้น

Terraform คือเครื่องมือประเภท Infrastructure as Code (IaC) ที่พัฒนาโดย HashiCorp ซึ่งช่วยให้เราสามารถ “เขียนโค้ด” เพื่อกำหนดโครงสร้างพื้นฐาน (Infrastructure) แทนการนั่งไล่กดทีละเมนูในหน้าเว็บ

แนวคิดของมันง่ายมากครับ
เราแค่เขียนไฟล์คอนฟิกขึ้นมาว่าอยากได้อะไรบ้าง เช่น มี VM กี่เครื่อง ใช้ Network แบบไหน มี Database อะไรบ้าง แล้วปล่อยให้ Terraform จัดการสร้าง แก้ไข หรืออัปเดต resource เหล่านั้นบน Cloud ให้เราแบบอัตโนมัติ

ถ้าไม่มี Terraform ชีวิตเราจะเป็นยังไง?

ลองจินตนาการดูครับว่า ถ้าคุณต้องทำระบบที่มี Environment เหมือนกันเป๊ะ ๆ ถึง 3 ชุด — Dev, Staging และ Production — แถมยังต้องทำซ้ำบ่อย ๆ ด้วย ชีวิตในโลกที่ไม่มี Terraform น่าจะเจออะไรประมาณนี้ครับ

😵 Human Error กลายเป็นเรื่องปกติ

การกดสร้างหรือตั้งค่าด้วยมือซ้ำ ๆ เป็นร้อยครั้ง ยังไงก็ต้องมีสักครั้งที่พลาด ไม่ว่าจะเป็นลืมเปิด Firewall บาง port, เลือก spec เครื่องผิดขนาด หรือตั้งชื่อ resource ผิด

พอระบบเริ่มใหญ่ขึ้น ความผิดพลาดเล็ก ๆ เหล่านี้จะตามหายากมาก และกว่าจะรู้ต้นตอ ก็เสียเวลาไปไม่น้อยเลยครับ

📄 Documentation มักจะล้าหลังความจริง

หลายครั้งเราสร้างระบบเสร็จแล้วก็คิดว่า “เดี๋ยวค่อยมาเขียน doc ทีหลัง”
สุดท้าย…ไม่ได้เขียน 😅

ผ่านไปสัก 2–3 เดือน พอกลับมาแก้ไขระบบ ก็เริ่มงงว่า

ตอนนั้นตั้งค่าแบบนี้ไปทำไม?

สุดท้ายก็ต้องเปิดหน้า Console ไล่ดูทีละจุดอยู่ดี

🐢 Scaling ช้า และเหนื่อย

ถ้าวันหนึ่งต้องขยายระบบไปอีกหลาย Region
หรืออยาก duplicate Production environment ขึ้นมาใหม่เพื่อทำ Disaster Recovery

การมานั่งกดสร้าง resource ทีละหน้าจอ คงไม่ใช่เรื่องสนุกแน่ ๆ
แถมบางทียังกินเวลาเป็นวัน ๆ อีกด้วย

❌ ไม่มี Rollback และ Audit ที่ชัดเจน

ถ้าเผลอกดลบ resource อะไรบางอย่างบนหน้า Console แบบไม่ได้ตั้งใจ
โอกาสจะกู้กลับมาได้แทบไม่มีเลย

แถมยังไม่มีประวัติบันทึกไว้ชัด ๆ ด้วยว่า

ใครทำอะไรไป ตอนไหน และทำไม

ซึ่งตรงนี้อันตรายมาก โดยเฉพาะกับระบบที่มีหลายคนดูแลครับ

Key Features: เอามาใช้ทำอะไรได้บ้าง?

Terraform ไม่ได้เป็นแค่เครื่องมือสร้าง Server แต่เป็น "พิมพ์เขียว" ของระบบไอทีทั้งระบบ:

• Multi-Cloud Management: เขียนโค้ดชุดเดียว (แยกตาม Provider) เพื่อคุมทั้ง Google Cloud, AWS และ Azure ในที่เดียว ไม่ต้องสลับหน้าจอไปมา
• Version Control Infrastructure: เมื่อโครงสร้างระบบเป็นโค้ด เราจึงเก็บไว้ใน Git ได้ ทำให้รู้ว่า "ใคร" แก้ไขระบบตอนไหน และย้อนกลับ (Rollback) ได้ง่ายหากเกิดปัญหา
• Automated Provisioning: ใช้ร่วมกับ CI/CD เพื่อให้ระบบสร้าง Infrastructure ใหม่โดยอัตโนมัติเมื่อมีการ Deploy โค้ด
• Dependency Management: Terraform ฉลาดพอที่จะรู้ว่าต้องสร้าง Network ก่อน ถึงจะสร้าง VM ได้ มันจัดการลำดับก่อน-หลังให้เราเองอัตโนมัติ

วิธีการติดตั้งเบื้องต้น (Installation)

Terraform เป็นไฟล์ Binary เดียวที่รันได้ทุก OS คุณสามารถดูคู่มือฉบับเต็มได้ที่ Terraform Install Docs หรือรันคำสั่งลัดตามนี้:

Windows: ติดตั้งผ่าน Chocolatey

choco install terraform

macOS: ติดตั้งผ่าน Homebrew

brew tap hashicorp/tap
brew install hashicorp/tap/terraform

Linux (Ubuntu/Debian):

sudo apt-get update && sudo apt-get install -y gnupg software-properties-common
# (เพิ่ม Repo และติดตั้งตามขั้นตอนใน Official Docs)

เช็กความพร้อม: พิมพ์ terraform -v ถ้าขึ้นเลขเวอร์ชันแสดงว่าพร้อมลุย!

Basic การใช้งาน: 4 คำสั่งที่ต้องจำ และโค้ดตัวอย่าง

การทำงานของ Terraform จะวนเวียนอยู่กับไฟล์นามสกุล .tf (เขียนด้วยภาษา HCL) โดยมีขั้นตอนหลักคือ:

ตัวอย่างโค้ดสร้าง VM บน GCP (main.tf)

# 1. ระบุ Provider
provider "google" {
  project = "your-project-id"
  region  = "asia-southeast1"
}

# 2. นิยาม Resource (สร้าง VM เครื่องแรก)
resource "google_compute_instance" "demo_vm" {
  name         = "blog-sample-vm"
  machine_type = "e2-medium"
  zone         = "asia-southeast1-a"

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  network_interface {
    network = "default"
  }
}

วิธีการรันและผลลัพธ์ที่จะได้

1. terraform init: รันเพื่อโหลด Plugin ของ Google Cloud มาไว้ในเครื่อง
2. terraform plan: Terraform จะสแกนโค้ดและบอกว่า "Plan: 1 to add" (กำลังจะสร้าง VM 1 เครื่องนะ)
3. terraform apply: พิมพ์ yes เพื่อเริ่มสร้างจริง ผลที่ได้: VM จะโผล่ขึ้นมาบน Cloud Console ของคุณทันที!
4. terraform destroy: ใช้เมื่อต้องการลบ Resource ทุกอย่างที่สร้างทิ้งทั้งหมดเพื่อประหยัดเงิน

สรุป

เอาละครับ ในบทความนี้ผมได้พูดถึง Terraform ซึ่งจะใช้แก้ปัญหา การตั้งค่า Infrastructure ด้วยมือที่ยุ่งยากและเสี่ยงต่อความผิดพลาด (Manual Configuration) เพื่อที่เราจะได้ ระบบที่จัดการได้ด้วยโค้ด (Infrastructure as Code) ที่แม่นยำ รวดเร็ว และทำงานร่วมกันในทีมได้อย่างมีประสิทธิภาพ

เอาละครับ หวังว่าบทความนี้จะได้ประโยชน์ไม่มากก็น้อย ขอให้สนุกกับการ dev ครับ!