YAML คืออะไร? ทำความเข้าใจพื้นฐาน ไวยากรณ์ และกรณีการใช้งาน

ตลอดหลายปีที่ผ่านมา ทำงานกับไฟล์คอนฟิกมานับไม่ถ้วน และ YAML โดดเด่นขึ้นมาด้วยความเรียบง่ายและอ่านง่าย ไม่ว่าจะตั้งค่าเวิร์กโฟลว์ใน Kubernetes กำหนดบริการใน Docker หรือจัดโครงสร้างคำขอ API YAML ทำให้คอนฟิกที่ซับซ้อนจัดการได้ง่ายขึ้น โครงสร้างที่อาศัยการย่อหน้าที่ยุ่งน้อยลงช่วยตัดความรกของฟอร์แมตอย่าง XML ขณะเดียวกันก็ยังยืดหยุ่น

ในคู่มือนี้ จะพาไปทำความเข้าใจไวยากรณ์ โครงสร้าง ฟีเจอร์ขั้นสูง และแนวทางปฏิบัติที่ดีของ YAML เพื่อให้ใช้งานได้อย่างมั่นใจ

YAML คืออะไร?

YAML (Yet Another Markup Language / YAML Ain’t Markup Language) เป็นฟอร์แมตสำหรับทำซีเรียลไลซ์ข้อมูลที่ให้ความสำคัญกับความอ่านง่ายและใช้งานสะดวก ในขณะที่ XML ใช้แท็กซ้อนคล้าย HTML และ JSON ใช้วงเล็บปีกกาและอัญประกาศคล้ายพจนานุกรมของ Python YAML กระชับกว่า และใช้การย่อหน้าเพื่อกำหนดโครงสร้าง จึงเป็นมิตรกับผู้อ่านมากกว่า

YAML รองรับชนิดข้อมูลหลากหลาย รวมถึงสเกลาร์ (สตริง ตัวเลข บูลีน) ลำดับ (ลิสต์) และแมปปิง (คู่คีย์-ค่า) นิยมใช้อย่างแพร่หลายในไฟล์คอนฟิก ระบบอัตโนมัติโครงสร้างพื้นฐาน และการแลกเปลี่ยนข้อมูล โดยเฉพาะในเครื่องมืออย่าง Kubernetes, Docker และ Ansible

นอกจากนี้ YAML ยังเป็น superset ของ JSON ซึ่งหมายความว่าไฟล์ JSON ที่ถูกต้องสามารถถูกพาร์สเป็น YAML ได้ โดยไฟล์ YAML มักใช้ส่วนขยาย .yaml หรือ .yml

สามารถเรียนรู้เพิ่มเติมเกี่ยวกับ YAML ได้ที่เว็บไซต์ด้วยเช่นกัน

ไวยากรณ์และโครงสร้างของ YAML

ส่วนนี้จะอธิบัติหลักการพื้นฐานของไวยากรณ์ YAML รวมถึงคู่คีย์-ค่า ลิสต์ ข้อมูลซ้อน และคอมเมนต์

กฎไวยากรณ์พื้นฐาน

กฎพื้นฐานของ YAML มีไม่กี่ข้อ:

• ใช้ช่องว่างในการย่อหน้าเพื่อบอกโครงสร้าง ดังนั้นหลีกเลี่ยงการใช้แท็บ
• คู่คีย์-ค่ามีโครงสร้างเป็น key: value คล้ายกับภาษาอื่น
• ใช้ยัติภังค์ที่ต้นบรรทัดเพื่อระบุลิสต์
• ใช้ # เพื่อสร้างบรรทัดคอมเมนต์

# Here is an example of YAML
name: John Doe
age: 30
skills:
  - Python
  - YAML

คู่คีย์-ค่า

YAML แทนข้อมูลในรูปคู่คีย์-ค่า คล้ายพจนานุกรมใน Python ซึ่งมักใช้ระบุข้อมูลที่ส่งให้ไฟล์คอนฟิกและการตั้งค่าต่าง ๆ ไม่จำเป็นต้องใส่อัญประกาศให้สตริงหรือคีย์ เพียงเขียนคีย์และค่าที่ต้องการ:

location: New York
country: USA
security-level: user

ลิสต์ใน YAML

ลิสต์ระบุด้วยยัติภังค์ (-) ช่วยให้สามารถลิสต์วัตถุหลายรายการภายใต้คีย์เดียวได้ มักแสดงผลเป็นสัญลักษณ์หัวข้อย่อยเมื่ออ่านด้วยตัวแก้ไขมาร์กอัป

fruits:
  - Apple
  - Banana
  - Cherry

ข้อมูลซ้อน

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

person:
  name: Alice
  details:
    age: 25
    city: London

คอมเมนต์

คอมเมนต์ขึ้นต้นด้วย # และตัวพาร์ส YAML จะละเว้น คอมเมนต์เป็นแบบบรรทัดเดียว

# This is a comment
username: admin
password: secret

ฟีเจอร์ขั้นสูงของ YAML

YAML มีฟีเจอร์ที่ทรงพลังอย่างสตริงหลายบรรทัด ชนิดข้อมูล และ anchor ที่ทำให้เอกสารถูกจัดโครงสร้างและมีประสิทธิภาพมากขึ้น ในส่วนนี้จะสำรวจความสามารถเหล่านี้พร้อมตัวอย่างใช้งานจริง

สตริงหลายบรรทัด

YAML รองรับสตริงหลายบรรทัดด้วย | (literal block) หรือ > (folded block)

• | literal block จะสร้างบรรทัดใหม่ \n สำหรับการขึ้นบรรทัดแต่ละครั้ง
• > folded block จะขึ้นบรรทัดใหม่เฉพาะเมื่อมีการขึ้นบรรทัดติดกัน

literal: |
  This is a
  multi-line string.

folded: >
  This is another
  multi-line string.

จะเข้าใจได้ชัดเจนขึ้นเมื่อดูเอาต์พุต

• สำหรับ | (literal block):

This is a
multi-line string.

• สำหรับ > (folded block):

This is another multi-line string.

ชนิดข้อมูลใน YAML

YAML รองรับชนิดข้อมูลหลากหลาย รวมถึงสตริง ตัวเลข บูลีน และค่า null โดยตรวจจับชนิดข้อมูลอัตโนมัติตามรูปแบบ และยังอนุญาตให้ระบุชนิดแบบชัดเจนได้

ตัวอย่างต่อไปนี้แสดงการใช้ชนิดข้อมูลพื้นฐานใน YAML:

string_implicit: Hello, YAML!  # No quotes needed unless necessary
string_double_quoted: "Supports escape sequences like \n and \t"
string_single_quoted: 'Raw text, no escape sequences'

integer: 42  # Whole numbers
float: 3.14  # Numbers with decimals

boolean_true: true
boolean_false: false

null_value: null  # Null value
null_tilde: ~  # Another way to represent null

YAML อนุญาตให้ประกาศชนิดแบบชัดเจนด้วย !!type เมื่อจำเป็น:

explicit_string: !!str 123  # Forces 123 to be a string
explicit_integer: !!int "42"  # Forces "42" to be an integer
explicit_float: !!float "3.14"  # Forces "3.14" to be a float

เนื่องจาก YAML มักใช้กับข้อมูลที่มีโครงสร้าง จึงรองรับ:

• ลิสต์ (sequence):

fruits:
  - Apple
  - Banana
  - Cherry

• ดิกชันนารี (mapping):

person:
  name: Alice
  age: 30
  is_student: false

แองเคอร์และอัลยายส์

YAML อนุญาตให้กำหนดค่าเพื่อใช้งานซ้ำด้วยแองเคอร์ (&) และอ้างอิงภายหลังด้วยอัลยายส์ (*) ช่วยลดความซ้ำซ้อนในไฟล์คอนฟิก ทำให้ไฟล์สะอาดและดูแลง่ายขึ้น

defaults: &default_settings
  retries: 3
  timeout: 30

server1:
  host: example.com
  retries: *default_settings  # Reuses the retries value from defaults

ไวยากรณ์ <<: อนุญาตให้ผสานคู่คีย์-ค่าจากแองเคอร์เข้ากับแมปปิงอื่น หากคีย์มีอยู่ทั้งสองที่ ค่าที่ใหม่จะเขียนทับค่าเดิม

defaults: &default_settings
  retries: 3
  timeout: 30

server1:
  <<: *default_settings  # Merges all key-value pairs from default_settings
  host: example.com  # This key is added to the merged data

โครงสร้างที่แก้ไขรวมสุดท้ายเป็นดังนี้:

server1:
  retries: 3
  timeout: 30
  host: example.com

แองเคอร์และอัลยายส์มีประโยชน์อย่างยิ่งในไฟล์คอนฟิกขนาดใหญ่ที่การทำซ้ำค่าเดิมด้วยมือไม่มีประสิทธิภาพ ช่วยให้ไฟล์ YAML ยึดหลัก DRY (Don’t Repeat Yourself) และอัปเดตได้ง่าย

กรณีการใช้งานทั่วไปของ YAML

YAML ใช้อย่างแพร่หลายในงานพัฒนาซอฟต์แวร์ ระบบอัตโนมัติโครงสร้างพื้นฐาน และการจัดการ API ไวยากรณ์ที่อ่านง่ายทำให้เป็นฟอร์แมตที่นิยมสำหรับไฟล์คอนฟิก การทำซีเรียลไลซ์ข้อมูล และ Infrastructure as Code (IaC) มาดูการใช้งานที่พบบ่อยที่สุด

ไฟล์คอนฟิก

YAML ใช้กันอย่างกว้างขวางสำหรับคอนฟิกในแอปพลิเคชันต่าง ๆ อย่าง Docker Compose, Kubernetes และไปป์ไลน์ CI/CD ความเข้าใจง่ายทำให้ใคร ๆ ก็หยิบไฟล์ตั้งค่า YAML ของ Docker มาดูและเข้าใจสิ่งที่เกิดขึ้นได้ไม่ยาก

version: '3'
services:
  web:
    image: nginx
    ports:
      - "80:80"
    environment:
      - NGINX_HOST=localhost
      - NGINX_PORT=80

ความอ่านง่ายของ YAML และการรองรับแองเคอร์กับอัลยายส์ช่วยลดความซ้ำซ้อน ทำให้ดูแลง่ายกว่า JSON หรือ XML

เรียนรู้เพิ่มเติมเกี่ยวกับ YAML และการใช้งานใน Docker ในคอร์สระดับกลาง Docker นี้

การซีเรียลไลซ์และถ่ายโอนข้อมูล

YAML ใช้ซีเรียลไลซ์ข้อมูลสำหรับ API และเครื่องมือจัดการคอนฟิก โดยแปลงโครงสร้างข้อมูลที่ซับซ้อนให้อยู่ในรูปแบบที่มนุษย์อ่านง่ายและเครื่องพาร์สได้สะดวก

ตัวอย่างเช่น เนื้อหาคำขอของ API ที่ฟอร์แมตเป็น YAML:

user:
  id: 123
  name: "John Doe"
  email: "johndoe@example.com"
  active: true

โครงสร้างแบบย่อหน้าของ YAML ลดไวยากรณ์ที่ไม่จำเป็น ทำให้มีน้ำหนักเบา อ่านง่าย และแก้ไขสะดวกกว่า JSON

Infrastructure as Code (IaC)

เครื่องมือจัดการคอนฟิกอย่าง Ansible และ Kubernetes ใช้ YAML เพื่อกำหนดสถานะระบบ ทำงานอัตโนมัติ และรับประกันความสอดคล้องระหว่างสภาพแวดล้อม

• ใน Ansible ใช้ YAML เขียนเพลย์บุ๊กเพื่อกำหนดสถานะระบบ งาน และการพึ่งพา เพื่อให้ส่วนประกอบของโครงสร้างพื้นฐานถูกคอนฟิกอย่างสม่ำเสมอ
• Kubernetes ใช้แมนิฟेस्ट YAML เพื่อกำหนดทรัพยากร เช่น พ็อด บริการ และดีพลอยเมนต์ ทำให้จัดการประสานงานคอนเทนเนอร์ได้โดยอัตโนมัติ

ตัวอย่างคอนฟิกพ็อดของ Kubernetes:

apiVersion: v1
kind: Pod
metadata:
  name: my-app
spec:
  containers:
    - name: app-container
      image: my-app:latest
      ports:
        - containerPort: 8080

เรียนรู้เพิ่มเติมเกี่ยวกับการใช้ YAML ใน Kubernetes ได้ในคอร์ส Introduction to Kubernetes

เอกสารประกอบ API

สเปค API อย่าง OpenAPI และ Swagger ใช้ YAML เพื่อกำหนดเอนด์พอยต์และโครงสร้างข้อมูลในรูปแบบที่อ่านง่าย YAML ใช้สำหรับร่างเมธอดของ API พารามิเตอร์คำขอ รูปแบบการตอบกลับ และวิธีการยืนยันตัวตน

ตัวอย่างสเปค OpenAPI ใน YAML:

openapi: 3.0.0
info:
  title: User API
  version: "1.0"
paths:
  /users:
    get:
      summary: Retrieve a list of users
      responses:
        "200":
          description: Successful response

ตัวอย่างเช่น สเปค OpenAPI ใช้ YAML เพื่อจัดทำเอกสาร RESTful API ทำให้สามารถจัดทำพิมพ์เขียวที่ชัดเจนสำหรับการสร้าง SDK ฝั่งลูกค้า เอกสาร API แบบอินเทอร์แอกทีฟ และการทดสอบอัตโนมัติ ฟอร์แมตที่มีโครงสร้างนี้ช่วยให้การนำไปใช้กับ API มีความสอดคล้องกัน

การทำงานกับไฟล์ YAML

YAML ใช้อย่างแพร่หลายสำหรับไฟล์คอนฟิก ระบบอัตโนมัติ และการซีเรียลไลซ์ข้อมูล แต่เนื่องจากพึ่งพาการย่อหน้า การจัดรูปแบบที่ถูกต้องจึงสำคัญมาก ต่อไปนี้คือวิธีอ่าน เขียน ตรวจสอบความถูกต้อง และแก้ไข YAML อย่างมีประสิทธิภาพ

การอ่านและเขียน YAML ใน Python

ไลบรารี PyYAML ของ Python สามารถพาร์สและสร้าง YAML ได้

ลองนึกภาพว่ามีไฟล์คอนฟิก YAML ดังนี้:

database:
  host: localhost
  port: 5432
  user: admin
  password: secret

ต่อไปนี้คือวิธีทำงานกับไฟล์คอนฟิกใน Python:

import yaml

# Load YAML data
with open("config.yaml", "r") as file:
    data = yaml.safe_load(file)  # safe_load prevents arbitrary code execution

# Modify data (optional)
data["database"]["user"] = "new_user"

# Write YAML data
with open("output.yaml", "w") as file:
    yaml.dump(data, file, default_flow_style=False)

หากสนใจทำงานกับข้อมูล JSON ใน Python ลองดูบทความสรุปครบถ้วน Python JSON

การตรวจสอบความถูกต้องของไฟล์ YAML

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

ตัวตรวจสอบ YAML ที่นิยม:

• เครื่องมือ CLI: yamllint (ตัวลินต์ที่พัฒนาด้วย Python)
• ตัวตรวจสอบออนไลน์: YAML Lint, ตัวตรวจสอบ YAML ของ JSON Formatter

การแก้ไข YAML

สามารถเขียนและแก้ไข YAML ได้ด้วยตัวแก้ไขข้อความใดก็ได้ แต่การใช้เครื่องมือลินต์และการไฮไลต์ไวยากรณ์จะช่วยให้อ่านง่ายขึ้น

ตัวแก้ไขที่ชื่นชอบ:

• VS Code (พร้อมปลั๊กอิน YAML)
• PyCharm (รองรับในตัว)
• Sublime Text (พร้อมไฮไลต์ไวยากรณ์ YAML)

ข้อผิดพลาดที่พบบ่อยที่ควรหลีกเลี่ยงใน YAML

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

ผสมแท็บกับช่องว่าง

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

การย่อหน้าที่ไม่ถูกต้อง

รักษาการย่อหน้าให้สม่ำเสมอเพื่อหลีกเลี่ยงข้อผิดพลาดในการพาร์ส เนื่องจากการย่อหน้าเป็นวิธีเดียวของ YAML ในการบอกลำดับชั้น การพาร์สไม่ถูกต้องอาจทำให้โค้ดมีปัญหา ได้ง่ายที่จะใส่คู่ key: value ไว้ผิดตำแหน่ง จึงควรระวังการย่อหน้าให้ดี

ลืมใส่อัญประกาศให้กับอักขระพิเศษ

ใช้อัญประกาศกับสตริงที่มีอักขระพิเศษหรือช่องว่าง สิ่งต่าง ๆ อย่างแบ็กสแลช คอมมา เครื่องหมายอัศเจรีย์ เป็นต้น ต้องใช้อัญประกาศเพื่อให้ถูกอ่านเป็นสตริง

path: "/home/user/documents"
message: "Hello, World!"

ด้วยการตรวจสอบความถูกต้องอย่างเหมาะสม การแก้ไขอย่างมีโครงสร้าง และการใช้ PyYAML ของ Python จะสามารถทำงานกับไฟล์ YAML ได้อย่างมีประสิทธิภาพและหลีกเลี่ยงหลุมพรางที่พบบ่อย

สรุป

YAML เป็นฟอร์แมตที่ทรงพลังแต่เรียบง่าย ซึ่งใช้กันอย่างแพร่หลายในงานคอนฟิก การซีเรียลไลซ์ข้อมูล และระบบอัตโนมัติโครงสร้างพื้นฐาน ด้วยความเข้าใจไวยากรณ์ โครงสร้าง และแนวทางปฏิบัติที่ดี จะสามารถทำงานกับ YAML ได้อย่างมีประสิทธิภาพในแอปพลิเคชันหลากหลาย

หากสนใจนำ YAML ไปใช้ในสถานการณ์จริง:

• เรียนรู้การใช้ YAML ในเวิร์กโฟลว์ CI/CD ได้ใน คอร์ส CI/CD for Machine Learning
• สำรวจว่า API ใช้ YAML ในสเปคอย่างไรได้ใน คอร์ส Introduction to APIs in Python
• ลงลึกเรื่องคอนเทนเนอร์และระบบอัตโนมัติโครงสร้างพื้นฐานใน เส้นทาง Containerization and Virtualization