10 ขั้นตอนสู่ YAML Zen

เราทุกคนรัก Ansible แต่ Ansible คือ YAML ไฟล์การกำหนดค่ามีหลายรูปแบบ: รายการค่า, คู่พารามิเตอร์-ค่า, ไฟล์ INI, YAML, JSON, XML และอื่นๆ อีกมากมาย อย่างไรก็ตาม ด้วยเหตุผลหลายประการ YAML มักถูกมองว่ายากเป็นพิเศษ โดยเฉพาะอย่างยิ่ง แม้จะมีความเรียบง่ายที่สดชื่นและความสามารถที่น่าประทับใจในการทำงานกับค่าลำดับชั้น ไวยากรณ์ YAML อาจสร้างความรำคาญได้ด้วยวิธีเยื้องแบบ Python

หาก YAML ทำให้คุณไม่พอใจ คุณก็ทำได้—และควรทำ! – ทำตามขั้นตอน 10 ขั้นตอนต่อไปนี้เพื่อลดความหงุดหงิดให้อยู่ในระดับที่ยอมรับได้และตกหลุมรัก YAML เพื่อให้เหมาะกับรายการนี้ เคล็ดลับสิบประการของเราจะถูกนับตั้งแต่เริ่มต้น เราจะเพิ่มการทำสมาธิและการปฏิบัติทางจิตวิญญาณตามต้องการ 😉

0. ทำให้บรรณาธิการของคุณใช้งานได้

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

ตัวอย่างเช่น บรรณาธิการ อะตอม รองรับ YAML เป็นค่าเริ่มต้น แต่สำหรับ GNU Emacs คุณจะต้องติดตั้งแพ็คเกจเพิ่มเติม เช่น โหมด yaml.

Emacs ในโหมด YAML และแสดงช่องว่าง

หากโปรแกรมแก้ไขที่คุณชื่นชอบไม่มีโหมด YAML ปัญหาบางอย่างสามารถแก้ไขได้ด้วยการทำงานกับการตั้งค่า ตัวอย่างเช่น โปรแกรมแก้ไขข้อความ GNOME มาตรฐาน Gedit ไม่มีโหมด YAML แต่ตามค่าเริ่มต้นจะเน้นไวยากรณ์ YAML และอนุญาตให้คุณกำหนดค่าการทำงานด้วยการเยื้อง:

การตั้งค่าการเยื้องใน Gedit

ปลั๊กอิน ช่องว่าง สำหรับ Gedit แสดงช่องว่างเป็นจุด ขจัดความคลุมเครือด้วยระดับการเยื้อง

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

1. ใช้ผ้าสำลี

ตามหลักการแล้ว ภาษาโปรแกรมและภาษามาร์กอัปจะใช้ไวยากรณ์ที่คาดเดาได้ คอมพิวเตอร์สามารถคาดเดาได้ดี ซึ่งเป็นเหตุผลว่าทำไมแนวคิดนี้จึงเป็นเช่นนั้น ลินเทรา. หากผ่านไป 40 ปีของการดำรงอยู่และคุณยังไม่ได้ใช้ YAML linter ก็ถึงเวลาลองใช้ yamllint

เพื่อทำการติดตั้ง แยมลินท์ คุณสามารถใช้ตัวจัดการแพ็คเกจ Linux มาตรฐานได้ ตัวอย่างเช่นใน Red Hat Enterprise Linux 8 หรือ Fedora มันทำได้ดังนี้:

$ sudo dnf install yamllint

จากนั้นคุณเพียงเรียกใช้ yamllint โดยส่งไฟล์ YAML เพื่อตรวจสอบ นี่คือลักษณะที่จะเกิดขึ้นหากคุณส่งไฟล์ที่มีข้อผิดพลาดไปยัง linter:

$ yamllint errorprone.yaml
errorprone.yaml
23:10     error    syntax error: mapping values are not allowed here
23:11     error    trailing spaces  (trailing-spaces)

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

เมื่อ yamllint ไม่พบข้อผิดพลาดในไฟล์ จะไม่มีสิ่งใดถูกพิมพ์ลงบนหน้าจอ หากความเงียบดังกล่าวทำให้คุณกลัวและคุณต้องการความคิดเห็นเพิ่มเติมอีกเล็กน้อย คุณสามารถรัน linter ด้วยคำสั่ง echo แบบมีเงื่อนไขผ่านเครื่องหมายแอมเพอร์แซนด์คู่ (&&) เช่นนี้:

$ yamllint perfect.yaml && echo "OK"
OK

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

2. เขียนใน Python ไม่ใช่ YAML

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

การแปลงตนเอง

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

#!/usr/bin/python3	
import yaml 

d={
"glossary": {
  "title": "example glossary",
  "GlossDiv": {
	"title": "S",
	"GlossList": {
	  "GlossEntry": {
		"ID": "SGML",
		"SortAs": "SGML",
		"GlossTerm": "Standard Generalized Markup Language",
		"Acronym": "SGML",
		"Abbrev": "ISO 8879:1986",
		"GlossDef": {
		  "para": "A meta-markup language, used to create markup languages such as DocBook.",
		  "GlossSeeAlso": ["GML", "XML"]
		  },
		"GlossSee": "markup"
		}
	  }
	}
  }
}

f=open('output.yaml','w')
f.write(yaml.dump(d))
f.close

ตอนนี้เรารันไฟล์นี้ใน Python และรับไฟล์ output.yaml:

$ python3 ./example.json
$ cat output.yaml
glossary:
  GlossDiv:
	GlossList:
	  GlossEntry:
		Abbrev: ISO 8879:1986
		Acronym: SGML
		GlossDef:
		  GlossSeeAlso: [GML, XML]
		  para: A meta-markup language, used to create markup languages such as DocBook.
		GlossSee: markup
		GlossTerm: Standard Generalized Markup Language
		ID: SGML
		SortAs: SGML
	title: S
  title: example glossary

นี่เป็น YAML ที่ถูกต้องสมบูรณ์ แต่ yamllint จะเตือนคุณว่าไม่ได้ขึ้นต้นด้วย - สิ่งนี้สามารถแก้ไขได้อย่างง่ายดายด้วยตนเองหรือแก้ไขเล็กน้อยในสคริปต์ Python

การแปลงผ่านสคริปต์

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

ขั้นแรก เรามาสร้างไฟล์ JSON example.json กันก่อน ตัวอย่างเช่น คุณสามารถนำมาจากไฟล์ดังกล่าวได้ json.org:

{
	"glossary": {
	  "title": "example glossary",
	  "GlossDiv": {
		"title": "S",
		"GlossList": {
		  "GlossEntry": {
			"ID": "SGML",
			"SortAs": "SGML",
			"GlossTerm": "Standard Generalized Markup Language",
			"Acronym": "SGML",
			"Abbrev": "ISO 8879:1986",
			"GlossDef": {
			  "para": "A meta-markup language, used to create markup languages such as DocBook.",
			  "GlossSeeAlso": ["GML", "XML"]
			  },
			"GlossSee": "markup"
			}
		  }
		}
	  }
	}

จากนั้นเราจะสร้างสคริปต์ตัวแปลงอย่างง่ายและบันทึกไว้ในชื่อ json2yaml.py สคริปต์นี้จะนำเข้าทั้งโมดูล YAML และ JSON Python และโหลดไฟล์ JSON ที่ผู้ใช้ระบุ ทำการแปลง และเขียนข้อมูลลงในไฟล์ output.yaml

#!/usr/bin/python3
import yaml
import sys
import json

OUT=open('output.yaml','w')
IN=open(sys.argv[1], 'r')

JSON = json.load(IN)
IN.close()
yaml.dump(JSON, OUT)
OUT.close()

บันทึกสคริปต์นี้ในพาธของระบบและรันตามต้องการ:

$ ~/bin/json2yaml.py example.json

3. แยกวิเคราะห์บ่อยๆ

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

ตัวอย่างเช่น หากคุณพอใจกับการทำงานกับรายการพจนานุกรมหรือ JSON คุณสามารถแปลง YAML เป็น JSON ได้โดยใช้คำสั่งเพียง XNUMX คำสั่งใน Python Shell แบบโต้ตอบ สมมติว่าคุณมีไฟล์ YAML mydata.yaml หน้าตาจะเป็นดังนี้:

$ python3
>>> f=open('mydata.yaml','r')
>>> yaml.load(f)
{'document': 34843, 'date': datetime.date(2019, 5, 23), 'bill-to': {'given': 'Seth', 'family': 'Kenlon', 'address': {'street': '51b Mornington Roadn', 'city': 'Brooklyn', 'state': 'Wellington', 'postal': 6021, 'country': 'NZ'}}, 'words': 938, 'comments': 'Good article. Could be better.'}

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

4. อ่านรายละเอียด

กลับมาที่ YAML หลังจากหยุดพักไปนานก็มีประโยชน์ในการเยี่ยมชม yaml.org และอ่านข้อกำหนด (ข้อมูลจำเพาะ) อีกครั้ง หากคุณประสบปัญหากับ YAML แต่ยังไม่เข้าใจข้อกำหนด ถึงเวลาแก้ไขสถานการณ์นี้แล้ว ข้อมูลจำเพาะเขียนได้ง่ายอย่างน่าประหลาดใจ และข้อกำหนดด้านไวยากรณ์มีภาพประกอบพร้อมตัวอย่างจำนวนมากใน บทที่ 6.

5. การตั้งค่าหลอก

เมื่อเขียนหนังสือหรือบทความ การร่างโครงร่างเบื้องต้นก่อนจะเป็นประโยชน์เสมอ อย่างน้อยก็ในรูปแบบของสารบัญ มันเหมือนกันกับ YAML เป็นไปได้มากว่าคุณมีความคิดว่าข้อมูลใดที่ต้องเขียนลงในไฟล์ YAML แต่คุณไม่เข้าใจวิธีเชื่อมต่อข้อมูลเข้าด้วยกัน ดังนั้น ก่อนที่จะสร้าง YAML ให้วาด pseudo-config

Pseudo-config คล้ายกับรหัสเทียม โดยที่คุณไม่ต้องกังวลเกี่ยวกับโครงสร้างหรือการเยื้อง ความสัมพันธ์ระหว่างพ่อแม่และลูก การสืบทอด และการซ้อน มันก็เหมือนกันที่นี่: คุณวาดการวนซ้ำของข้อมูลที่เกิดขึ้นในหัวของคุณ

โปรแกรมเมอร์แสดงรายการ Pseudo-config (Martin และ Tabitha) และทักษะของพวกเขา (ภาษาการเขียนโปรแกรม: Python, Perl, Pascal และ Lisp, Fortran, Erlang ตามลำดับ)

หลังจากวาด pseudo-config บนกระดาษแล้ว ให้วิเคราะห์อย่างระมัดระวัง และหากทุกอย่างเป็นไปตามลำดับ ให้จัดรูปแบบเป็นไฟล์ YAML ที่ถูกต้อง

6. ภาวะที่กลืนไม่เข้าคายไม่ออกระหว่างแท็บกับช่องว่าง

คุณจะต้องแก้ปัญหาที่กลืนไม่เข้าคายไม่ออก “แท็บหรือช่องว่าง?”. ไม่ใช่ในระดับโลก แต่เฉพาะในระดับองค์กรของคุณหรืออย่างน้อยก็ในโครงการ ไม่สำคัญว่าสิ่งนี้จะเกี่ยวข้องกับการใช้การประมวลผลภายหลังด้วยสคริปต์ sed การตั้งค่าโปรแกรมแก้ไขข้อความบนเครื่องของโปรแกรมเมอร์ หรือการตอบรับการปฏิบัติตามคำสั่งของ linter อย่างเข้มงวดในระดับสากลภายใต้การขู่ว่าจะถูกไล่ออก แต่สมาชิกทุกคนในทีมของคุณที่ ไม่ทางใดก็ทางหนึ่งที่เกี่ยวข้องกับ YAML ต้องใช้ช่องว่างเท่านั้น (ตามที่กำหนดโดยข้อกำหนด YAML)

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

ตามที่ผู้เกลียดชัง YAML ทุกคนรู้ดี คุณจะไม่เห็นความแตกต่างระหว่างแท็บและช่องว่างบนหน้าจอ และเมื่อบางสิ่งไม่สามารถมองเห็นได้ มันก็มักจะเป็นสิ่งสุดท้ายที่ผู้คนจดจำ หลังจากที่พวกเขาได้จัดการ ตรวจสอบ และขจัดปัญหาอื่นๆ ที่เป็นไปได้ทั้งหมดแล้ว ใช้เวลาหนึ่งชั่วโมงในการค้นหาเส้นโค้งของตารางหรือบล็อกช่องว่างเพียงแค่กรีดร้องว่าคุณจำเป็นต้องสร้างนโยบายสำหรับการใช้งานอย่างใดอย่างหนึ่งอย่างเร่งด่วนจากนั้นใช้การตรวจสอบคอนกรีตเสริมเหล็กเพื่อให้สอดคล้องกับมัน (เช่นผ่าน Git hook เพื่อบังคับผ่าน linter)

7. น้อยแต่มาก (หรือมากกว่านั้นน้อย)

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

นี่คือตัวอย่างโครงสร้างดังกล่าวจาก เอกสารที่สามารถอ่านได้:

# Employee records
-  martin:
        name: Martin D'vloper
        job: Developer
        skills:
            - python
            - perl
            - pascal
-  tabitha:
        name: Tabitha Bitumen
        job: Developer
        skills:
            - lisp
            - fortran
            - erlang

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

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

---
- martin:
   name: Martin D'vloper
   job: Developer
   skills:
   - python
   - perl
   - pascal
- tabitha:
   name: Tabitha Bitumen
   job: Developer
   skills:
   - lisp
   - fortran
   - erlang

8. ใช้ช่องว่าง

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

---
# - <common name>:
#   name: Given Surname
#   job: JOB
#   skills:
#   - LANG
- martin:
  name: Martin D'vloper
  job: Developer
  skills:
  - python
  - perl
  - pascal
- tabitha:
  name: Tabitha Bitumen
  job: Developer
  skills:
  - lisp
  - fortran
  - erlang

9. ใช้สิ่งที่แตกต่างออกไป

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

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

หากคุณทำไม่ได้หากไม่มี YAML ลองใช้เคล็ดลับ 10 ข้อเหล่านี้และเอาชนะความไม่ชอบ YAML ของคุณทันที!

ที่มา: will.com