Terraform Infrastructure as Code เบื้องต้น

Terraform Infrastructure as Code เบื้องต้น: ปูพื้นฐานสู่ระบบอัตโนมัติ

พื้นฐานความรู้เกี่ยวกับ Terraform

Infrastructure as Code (IaC) คืออะไร?

Terraform คืออะไร และทำงานอย่างไร?

ความแตกต่างระหว่าง Terraform กับเครื่องมือ IaC อื่น ๆ

🎬 YouTube @icafefx

วิธีติดตั้งและใช้งาน Terraform เบื้องต้น

ขั้นตอนการติดตั้ง Terraform

terraform version
    Terraform v1.1.7
    on darwin_amd64
    

การใช้งาน Terraform เบื้องต้น

terraform {
      required_providers {
        aws = {
          source  = "hashicorp/aws"
          version = "~> 3.0"
        }
      }
    }

    provider "aws" {
      region = "us-west-2"
    }

    resource "aws_s3_bucket" "example" {
      bucket = "my-tf-test-bucket-1996"
      acl    = "private"

      tags = {
        Name        = "My bucket"
        Environment = "Dev"
      }
    }
    

terraform init

    Initializing the backend...

    Initializing provider plugins...
    - Finding hashicorp/aws versions matching "~> 3.0"...
    - Installing hashicorp/aws v3.74.0...
    - Installed hashicorp/aws v3.74.0 (signed by HashiCorp)

    Terraform has been successfully initialized!

    You may now begin working with Terraform. Try running "terraform plan" to see
    any changes that are required for your infrastructure. All Terraform commands
    should now work.

    If you ever set or change modules or backend configuration for Terraform,
    rerun this command to reinitialize your working directory. If you forget, other
    commands will detect it and remind you to do so if necessary.
    

terraform plan

    Terraform will perform the following actions:

      # aws_s3_bucket.example will be created
      + resource "aws_s3_bucket" "example" {
          + acceleration_status         = (known after apply)
          + acl                         = "private"
          + arn                         = (known after apply)
          + bucket                      = "my-tf-test-bucket-1996"
          + bucket_domain_name          = (known after apply)
          + bucket_regional_domain_name = (known after apply)
          + cors_rule                   = (known after apply)
          + force_destroy               = false
          + hosted_zone_id              = (known after apply)
          + id                          = (known after apply)
          + lifecycle_rule              = (known after apply)
          + logging                     = (known after apply)
          + object_lock_configuration   = (known after apply)
          + policy                      = (known after apply)
          + region                      = (known after apply)
          + replication_configuration   = (known after apply)
          + request_payer               = (known after apply)
          + server_side_encryption_configuration = (known after apply)
          + tags                        = {
              + "Environment" = "Dev"
              + "Name"        = "My bucket"
            }
          + tags_all                    = {
              + "Environment" = "Dev"
              + "Name"        = "My bucket"
            }
          + versioning                  = (known after apply)
          + website                     = (known after apply)
          + website_domain              = (known after apply)
          + website_endpoint            = (known after apply)
        }

    Plan: 1 to add, 0 to change, 0 to destroy.

    

terraform apply

    Terraform will perform the following actions:

      # aws_s3_bucket.example will be created
      + resource "aws_s3_bucket" "example" {
          + acceleration_status         = (known after apply)
          + acl                         = "private"
          + arn                         = (known after apply)
          + bucket                      = "my-tf-test-bucket-1996"
          + bucket_domain_name          = (known after apply)
          + bucket_regional_domain_name = (known after apply)
          + cors_rule                   = (known after apply)
          + force_destroy               = false
          + hosted_zone_id              = (known after apply)
          + id                          = (known after apply)
          + lifecycle_rule              = (known after apply)
          + logging                     = (known after apply)
          + object_lock_configuration   = (known after apply)
          + policy                      = (known after apply)
          + region                      = (known after apply)
          + replication_configuration   = (known after apply)
          + request_payer               = (known after apply)
          + server_side_encryption_configuration = (known after apply)
          + tags                        = {
              + "Environment" = "Dev"
              + "Name"        = "My bucket"
            }
          + tags_all                    = {
              + "Environment" = "Dev"
              + "Name"        = "My bucket"
            }
          + versioning                  = (known after apply)
          + website                     = (known after apply)
          + website_domain              = (known after apply)
          + website_endpoint            = (known after apply)
        }

    Plan: 1 to add, 0 to change, 0 to destroy.

    Do you want to perform these actions?
      Terraform will perform the actions described above.
      Only 'yes' will be accepted to approve.

      Enter a value: yes

    aws_s3_bucket.example: Creating...
    aws_s3_bucket.example: Creation complete after 1s [id=my-tf-test-bucket-1996]

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

terraform destroy

    Terraform will perform the following actions:

      # aws_s3_bucket.example will be destroyed
      - resource "aws_s3_bucket" "example" {
          - acceleration_status         = null -> null
          - acl                         = "private" -> null
          - arn                         = "arn:aws:s3:::my-tf-test-bucket-1996" -> null
          - bucket                      = "my-tf-test-bucket-1996" -> null
          - bucket_domain_name          = "my-tf-test-bucket-1996.s3.amazonaws.com" -> null
          - bucket_regional_domain_name = "my-tf-test-bucket-1996.s3.us-west-2.amazonaws.com" -> null
          - cors_rule                   = [] -> null
          - force_destroy               = false -> null
          - hosted_zone_id              = "Z3AQBSTGFUMQ6" -> null
          - id                          = "my-tf-test-bucket-1996" -> null
          - lifecycle_rule              = [] -> null
          - logging                     = [] -> null
          - object_lock_configuration   = [] -> null
          - policy                      = null -> null
          - region                      = "us-west-2" -> null
          - replication_configuration   = [] -> null
          - request_payer               = "BucketOwner" -> null
          - server_side_encryption_configuration = [] -> null
          - tags                        = {
              - "Environment" = "Dev" -> null
              - "Name"        = "My bucket" -> null
            }
          - tags_all                    = {
              - "Environment" = "Dev" -> null
              - "Name"        = "My bucket" -> null
            }
          - versioning                  = [] -> null
          - website                     = [] -> null
          - website_domain              = null -> null
          - website_endpoint            = null -> null
        }

    Plan: 0 to add, 0 to change, 1 to destroy.

    Do you want to perform these actions?
      Terraform will perform the actions described above.
      Only 'yes' will be accepted to approve.

      Enter a value: yes

    aws_s3_bucket.example: Destroying...
    aws_s3_bucket.example: Destruction complete after 0s

    Destroy complete! Resources: 1 destroyed.
    

ตารางสรุปคำสั่ง Terraform ที่ใช้บ่อย

เทคนิคขั้นสูงในการปรับแต่ง Terraform Configuration

หลังจากที่เราได้เรียนรู้พื้นฐานการใช้งาน Terraform ไปแล้ว ในส่วนนี้เราจะมาเจาะลึกเทคนิคขั้นสูงที่จะช่วยให้การจัดการ Infrastructure as Code (IaC) ของเรามีประสิทธิภาพมากยิ่งขึ้นครับ เทคนิคเหล่านี้จะช่วยให้เราสามารถปรับแต่งการทำงานของ Terraform ให้เข้ากับความต้องการเฉพาะของเราได้อย่างละเอียด ไม่ว่าจะเป็นการจัดการ State file อย่างมีประสิทธิภาพ การใช้ Modules เพื่อสร้าง Infrastructure ที่ซับซ้อน หรือการใช้ Data Sources เพื่อดึงข้อมูลจากภายนอกมาใช้ในการ Configuration

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

การจัดการ Terraform State File อย่างมีประสิทธิภาพ

Terraform State file เป็นหัวใจสำคัญของการทำงานของ Terraform เลยก็ว่าได้ มันเก็บข้อมูลเกี่ยวกับสถานะของ Infrastructure ที่เราได้สร้างขึ้น ทำให้ Terraform สามารถเปรียบเทียบสถานะปัจจุบันกับ Configuration file ของเรา และทำการเปลี่ยนแปลงที่จำเป็นได้ แต่ปัญหาคือ State file นี้สามารถใหญ่ขึ้นเรื่อยๆ เมื่อ Infrastructure ของเราซับซ้อนขึ้น ซึ่งอาจทำให้การทำงานของ Terraform ช้าลงได้ นอกจากนี้ การเก็บ State file ไว้ในเครื่อง Local ยังมีความเสี่ยงที่จะสูญหายหรือเสียหายได้อีกด้วย

ดังนั้น การจัดการ State file อย่างมีประสิทธิภาพจึงเป็นสิ่งสำคัญมาก วิธีการหนึ่งที่นิยมใช้กันคือการเก็บ State file ไว้ใน Remote Backend เช่น AWS S3 หรือ Azure Blob Storage ซึ่งจะช่วยให้ State file ของเราปลอดภัยและสามารถเข้าถึงได้จากหลายๆ ที่ นอกจากนี้ Remote Backend ยังรองรับการทำ State Locking ซึ่งจะช่วยป้องกันไม่ให้มีการเปลี่ยนแปลง Infrastructure พร้อมกันจากหลายๆ คน ซึ่งอาจทำให้เกิด Conflict ได้

terraform {
  backend "s3" {
    bucket = "my-terraform-state-bucket"
    key    = "terraform/state"
    region = "ap-southeast-1"
    encrypt = true
  }
}

Configuration นี้จะบอกให้ Terraform เก็บ State file ไว้ใน S3 bucket ที่ชื่อ my-terraform-state-bucket ใน Region ap-southeast-1 และทำการ Encrypt ข้อมูลด้วย ซึ่งจะช่วยเพิ่มความปลอดภัยให้กับ State file ของเรา

การสร้าง Infrastructure ที่ซับซ้อนด้วย Terraform Modules

Terraform Modules คือส่วนประกอบที่สามารถนำกลับมาใช้ใหม่ได้ ซึ่งช่วยให้เราสามารถสร้าง Infrastructure ที่ซับซ้อนได้อย่างง่ายดาย โดยการแบ่ง Infrastructure ออกเป็นส่วนย่อยๆ ที่มีความรับผิดชอบเฉพาะ และนำ Modules เหล่านั้นมาประกอบกันเป็น Infrastructure ที่สมบูรณ์ ตัวอย่างเช่น เราสามารถสร้าง Module สำหรับสร้าง Virtual Machine (VM) ที่มี Configuration พื้นฐานที่เหมือนกัน และนำ Module นี้ไปใช้ซ้ำๆ เพื่อสร้าง VM หลายๆ ตัวได้อย่างรวดเร็ว

การใช้ Modules ช่วยลดความซ้ำซ้อนของ Configuration file ของเรา และทำให้ง่ายต่อการดูแลรักษา นอกจากนี้ Modules ยังสามารถแชร์ให้กับคนอื่นๆ ในทีมหรือใน Community ได้ ซึ่งจะช่วยประหยัดเวลาและแรงงานในการสร้าง Infrastructure ใหม่ๆ ลองดูตัวอย่าง Module สำหรับสร้าง VM กันครับ

# modules/vm/main.tf

resource "aws_instance" "example" {
  ami           = var.ami
  instance_type = var.instance_type
  tags = {
    Name = var.vm_name
  }
}

output "public_ip" {
  value = aws_instance.example.public_ip
}

# modules/vm/variables.tf

variable "ami" {
  type = string
  description = "The AMI to use for the instance"
}

variable "instance_type" {
  type = string
  description = "The type of instance to start"
}

variable "vm_name" {
  type = string
  description = "The name of the VM"
}

Module นี้รับ Input variables 3 ตัว คือ ami, instance_type, และ vm_name และสร้าง AWS Instance โดยใช้ Input เหล่านั้น เราสามารถนำ Module นี้ไปใช้ได้ดังนี้

module "my_vm" {
  source  = "./modules/vm"
  ami           = "ami-0c55b9d9212a84f3c"
  instance_type = "t2.micro"
  vm_name = "MyVM"
}

output "vm_ip" {
  value = module.my_vm.public_ip
}

จะเห็นได้ว่าการใช้ Modules ช่วยให้ Configuration file ของเราสั้นลงและอ่านง่ายขึ้นมากครับ

การดึงข้อมูลจากภายนอกด้วย Data Sources

Data Sources ช่วยให้เราสามารถดึงข้อมูลจากภายนอกมาใช้ในการ Configuration file ของเราได้ ตัวอย่างเช่น เราสามารถดึงข้อมูล AMI (Amazon Machine Image) ที่เป็น Version ล่าสุดของ Ubuntu ได้ โดยไม่ต้อง Hardcode AMI ID ไว้ใน Configuration file ของเรา Data Sources มีประโยชน์มากในการจัดการ Infrastructure ที่มีการเปลี่ยนแปลงบ่อยๆ หรือ Infrastructure ที่ต้องทำงานร่วมกับ Services อื่นๆ ที่มีการเปลี่ยนแปลงอยู่เสมอ

ลองดูตัวอย่างการใช้ Data Source เพื่อดึงข้อมูล AMI กันครับ

data "aws_ami" "ubuntu" {
  most_recent = true

  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*"]
  }

  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }

  owners = ["099720109477"] # Canonical
}

resource "aws_instance" "example" {
  ami           = data.aws_ami.ubuntu.id
  instance_type = "t2.micro"
}

Configuration นี้จะดึงข้อมูล AMI ที่เป็น Version ล่าสุดของ Ubuntu 20.04 และนำ AMI ID นั้นมาใช้ในการสร้าง AWS Instance โดยที่เราไม่ต้อง Hardcode AMI ID ไว้ใน Configuration file เลย

เปรียบเทียบ Terraform กับเครื่องมือ IaC อื่นๆ

ในตลาดของเครื่องมือ Infrastructure as Code (IaC) นั้น Terraform ไม่ได้เป็นเพียงตัวเลือกเดียว ยังมีเครื่องมืออื่นๆ ที่น่าสนใจและมีจุดเด่นที่แตกต่างกันไป การเปรียบเทียบ Terraform กับเครื่องมือเหล่านี้จะช่วยให้เราสามารถเลือกเครื่องมือที่เหมาะสมกับความต้องการและสภาพแวดล้อมของเราได้มากที่สุดครับ

เครื่องมือ IaC ที่ได้รับความนิยมและมักถูกนำมาเปรียบเทียบกับ Terraform ได้แก่ Ansible, Chef, Puppet และ CloudFormation แต่ละเครื่องมือมี Architecture, Features และ Use Cases ที่แตกต่างกัน การทำความเข้าใจความแตกต่างเหล่านี้จะช่วยให้เราตัดสินใจได้อย่างชาญฉลาดว่าเครื่องมือใดเหมาะสมกับ Project ของเราที่สุด

ตารางเปรียบเทียบ Features หลัก

จากตารางนี้ เราจะเห็นได้ว่า Terraform มีจุดเด่นในเรื่องของ Infrastructure Support ที่รองรับ Multi-Cloud และ State Management ที่ Built-in มาพร้อมกับเครื่องมือ ในขณะที่ Ansible มีจุดเด่นในเรื่องของ Learning Curve ที่ง่ายกว่า และเหมาะสำหรับการ Configuration Management

ตารางเปรียบเทียบ Benchmark ด้าน Performance

นอกจาก Features แล้ว Performance ก็เป็นอีกปัจจัยที่สำคัญในการเลือกเครื่องมือ IaC การ Benchmark Performance ของแต่ละเครื่องมืออาจเป็นเรื่องที่ซับซ้อน เนื่องจาก Performance ขึ้นอยู่กับหลายปัจจัย เช่น ขนาดของ Infrastructure, ความซับซ้อนของ Configuration, และ Hardware ที่ใช้ แต่เราสามารถเปรียบเทียบ Performance ของแต่ละเครื่องมือในภาพรวมได้ดังนี้

จากตารางนี้ เราจะเห็นได้ว่า Terraform มี Provisioning Speed ที่รวดเร็ว และ Scalability ที่ดีเยี่ยม ซึ่งเหมาะสำหรับการสร้าง Infrastructure ขนาดใหญ่ ในขณะที่ Ansible มี Configuration Speed ที่รวดเร็ว ซึ่งเหมาะสำหรับการจัดการ Configuration ของ Server จำนวนมาก

ข้อควรระวังและ Troubleshooting ในการใช้งาน Terraform

การใช้งาน Terraform อาจไม่ได้ราบรื่นเสมอไป เราอาจเจอปัญหาต่างๆ ที่ทำให้การ Provisioning Infrastructure ไม่เป็นไปตามที่คาดหวัง การทำความเข้าใจข้อควรระวังและวิธีการ Troubleshooting จะช่วยให้เราสามารถแก้ไขปัญหาได้อย่างรวดเร็ว และป้องกันไม่ให้เกิดปัญหาซ้ำๆ ในอนาคตครับ

คำเตือน: การเปลี่ยนแปลง Infrastructure โดยไม่ระมัดระวังอาจทำให้เกิด Downtime หรือความเสียหายต่อข้อมูลได้ ดังนั้น ควรทำการ Backup ข้อมูลและทดสอบการเปลี่ยนแปลงใน Environment ที่ไม่ใช่ Production ก่อนเสมอ

รายการข้อควรระวังและ Troubleshooting

• การจัดการ State File: State File เป็นสิ่งสำคัญมาก หาก State File เสียหายหรือสูญหาย จะทำให้ Terraform ไม่สามารถจัดการ Infrastructure ได้อย่างถูกต้อง ดังนั้น ควร Backup State File อย่างสม่ำเสมอ และเก็บไว้ใน Remote Backend ที่ปลอดภัย
• Version Control: Configuration File ควรถูกเก็บไว้ใน Version Control System เช่น Git เพื่อให้สามารถ Track การเปลี่ยนแปลง และ Rollback ไปยัง Version ก่อนหน้าได้ หากเกิดปัญหา
• การใช้ Variables: ควรใช้ Variables แทนการ Hardcode ค่าต่างๆ ใน Configuration File เพื่อให้ Configuration File สามารถนำกลับมาใช้ใหม่ได้ง่าย และลดความผิดพลาด
• การใช้ Modules: ควรแบ่ง Infrastructure ออกเป็น Modules เพื่อลดความซับซ้อนของ Configuration File และทำให้ง่ายต่อการดูแลรักษา
• การตรวจสอบ Error Messages: เมื่อเกิด Error ควรตรวจสอบ Error Messages อย่างละเอียด เพื่อหาสาเหตุของปัญหา และแก้ไขได้อย่างถูกต้อง
• การใช้ Terraform Plan: ก่อนที่จะ Apply การเปลี่ยนแปลงใดๆ ควรใช้ Terraform Plan เพื่อดูว่า Terraform จะทำการเปลี่ยนแปลงอะไรบ้าง เพื่อป้องกันไม่ให้เกิดผลกระทบที่ไม่คาดคิด
• การใช้ Terraform Import: หากมี Infrastructure ที่สร้างขึ้นมาก่อนที่จะใช้ Terraform สามารถใช้ Terraform Import เพื่อนำ Infrastructure นั้นมาจัดการด้วย Terraform ได้
• การอัพเดท Providers: ควรอัพเดท Providers ให้เป็น Version ล่าสุดอยู่เสมอ เพื่อให้ Terraform สามารถทำงานร่วมกับ Cloud Providers ได้อย่างถูกต้อง และได้รับ Features ใหม่ๆ

ตัวอย่างจากประสบการณ์ 20 ปีในการใช้ Terraform

จากการที่ผมได้คลุกคลีกับ IT มากว่า 20 ปี ผมได้มีโอกาสใช้ Terraform ใน Project ที่หลากหลาย ตั้งแต่ Infrastructure ขนาดเล็กๆ ไปจนถึง Infrastructure ขนาดใหญ่ที่รองรับ Traffic จำนวนมหาศาล ผมอยากจะแชร์ประสบการณ์บางส่วนที่ผมได้เรียนรู้จากการใช้ Terraform ในสถานการณ์จริงครับ

ผมเคยเจอปัญหา State File เสียหายใน Production Environment ซึ่งทำให้ Terraform ไม่สามารถจัดการ Infrastructure ได้อย่างถูกต้อง โชคดีที่ผมได้ Backup State File ไว้ ทำให้ผมสามารถ Restore State File และแก้ไขปัญหาได้อย่างรวดเร็ว จากเหตุการณ์นั้น ผมได้เรียนรู้ว่าการ Backup State File เป็นสิ่งสำคัญมาก และควรทำอย่างสม่ำเสมอ

นอกจากนี้ ผมยังเคยเจอปัญหา Configuration File ซับซ้อนจนยากต่อการดูแลรักษา ผมจึงตัดสินใจแบ่ง Infrastructure ออกเป็น Modules และใช้ Variables แทนการ Hardcode ค่าต่างๆ ซึ่งช่วยลดความซับซ้อนของ Configuration File และทำให้ง่ายต่อการดูแลรักษาอย่างมาก การใช้ Modules ทำให้ทีมงานสามารถทำงานร่วมกันได้ง่ายขึ้น และลดความผิดพลาดในการ Configuration ได้อีกด้วย

อีกสถานการณ์หนึ่งที่ผมเจอคือการ Integrate Terraform กับ CI/CD Pipeline เพื่อให้การ Provisioning Infrastructure เป็นไปโดยอัตโนมัติ ผมได้ใช้ Terraform Plan และ Terraform Apply ใน CI/CD Pipeline เพื่อตรวจสอบและ Apply การเปลี่ยนแปลง Infrastructure โดยอัตโนมัติ ซึ่งช่วยลดเวลาและแรงงานในการ Provisioning Infrastructure อย่างมาก

สุดท้ายนี้ ผมอยากจะแนะนำว่าการเรียนรู้ Terraform ไม่ได้จบแค่การอ่าน Documentation หรือ Tutorial แต่ต้องลงมือปฏิบัติจริงและเจอปัญหาต่างๆ ด้วยตัวเอง ประสบการณ์ที่ได้จากการแก้ไขปัญหาจริง จะเป็นสิ่งที่ช่วยให้เราเข้าใจ Terraform อย่างลึกซึ้ง และสามารถนำไปประยุกต์ใช้ใน Project ของเราได้อย่างมีประสิทธิภาพครับ

เครื่องมือแนะนำ

เครื่องมือจัดการ State: Terraform Cloud/Enterprise

เครื่องมือ Linting และ Validation: TFLint และ Checkov

tflint

checkov -d .

เครื่องมือ Visualization: Terraform Graph

terraform graph | dot -Tsvg > graph.svg

Case Study ประสบการณ์จริง

FAQ คำถามที่พบบ่อย

Terraform เหมาะกับ Infrastructure แบบไหน?

Terraform ต่างจาก Configuration Management tools (เช่น Ansible, Chef, Puppet) อย่างไร?

Terraform สามารถใช้จัดการ Kubernetes ได้หรือไม่?

Terraform free หรือเสียเงิน?

ถ้า state ไฟล์หาย จะเกิดอะไรขึ้น?

Terraform รองรับ Multi-Cloud ไหม?

สรุป