10 ნაბიჯი YAML Zen-მდე

ჩვენ ყველას გვიყვარს Ansible, მაგრამ Ansible არის YAML. არსებობს მრავალი ფორმატი კონფიგურაციის ფაილებისთვის: მნიშვნელობების სიები, პარამეტრ-მნიშვნელობის წყვილები, INI ფაილები, YAML, JSON, XML და მრავალი სხვა. თუმცა, ყველა მათგანიდან რამდენიმე მიზეზის გამო, YAML ხშირად განიხილება განსაკუთრებით რთულად. კერძოდ, მიუხედავად მისი გამაგრილებელი მინიმალიზმისა და იერარქიულ მნიშვნელობებთან მუშაობის შთამბეჭდავი შესაძლებლობებისა, YAML სინტაქსი შეიძლება იყოს გამაღიზიანებელი პითონის მსგავსი მიდგომით ჩაღრმავებასთან დაკავშირებით.

თუ YAML გაღიზიანებთ, შეგიძლიათ - და უნდა! – გადადგით შემდეგი 10 ნაბიჯი, რათა შეამციროთ თქვენი იმედგაცრუება მისაღებ დონეზე და შეიყვაროთ YAML. როგორც ამ სიას შეეფერება, ჩვენი ათი რჩევა დანომრილი იქნება ნულიდან, ჩვენ სურვილისამებრ დავამატებთ მედიტაციას და სულიერ პრაქტიკას 😉

0. გააკეთე შენი რედაქტორი იმუშაოს

არ აქვს მნიშვნელობა რა ტექსტური რედაქტორი გაქვთ, ალბათ არის მინიმუმ ერთი მოდული YAML-თან მუშაობისთვის. თუ არ გაქვთ, დაუყოვნებლივ იპოვეთ და დააინსტალირეთ. ძიებასა და დაყენებაში დახარჯული დრო ბევრჯერ ანაზღაურდება ყოველ ჯერზე, როცა YAML-ის რედაქტირება მოგიწევთ.

მაგალითად, რედაქტორი Atom სტანდარტულად მხარს უჭერს YAML-ს, მაგრამ GNU Emacs-ისთვის მოგიწევთ დამატებითი პაკეტების დაყენება, მაგალითად, yaml- რეჟიმი.

Emacs YAML რეჟიმში და აჩვენებს სივრცეებს.

თუ თქვენს საყვარელ რედაქტორს არ აქვს YAML რეჟიმი, მაშინ ზოგიერთი პრობლემის მოგვარება შესაძლებელია პარამეტრებთან მუშაობით. მაგალითად, GNOME-ის სტანდარტულ ტექსტურ რედაქტორს Gedit-ს არ აქვს YAML რეჟიმი, მაგრამ ნაგულისხმევად ის ხაზს უსვამს YAML სინტაქსს და საშუალებას გაძლევთ დააკონფიგურიროთ მუშაობა ჩაღრმავებებით:

შეწევის დაყენება Gedit-ში.

მოდული გათამაშების ადგილები Gedit-ისთვის აჩვენებს სივრცეებს ​​წერტილების სახით, აღმოფხვრის გაურკვევლობას ჩაღრმავების დონეებით.

სხვა სიტყვებით რომ ვთქვათ, დაუთმეთ დრო თქვენი საყვარელი რედაქტორის შესწავლას. გაარკვიეთ, რას სთავაზობს მას ან მის განვითარების საზოგადოებას YAML-თან მუშაობისთვის და გამოიყენეთ ეს ფუნქციები. აუცილებლად არ ინანებთ.

1. გამოიყენეთ ლინტერი

იდეალურ შემთხვევაში, პროგრამირების ენები და მარკირების ენები იყენებენ პროგნოზირებად სინტაქსს. კომპიუტერები კარგად არიან პროგნოზირებადობაში, რის გამოც კონცეფცია ლინტერა. თუ მისი არსებობის 40 წლის განმავლობაში მან გაგიარა და ჯერ კიდევ არ იყენებთ YAML ლინტერს, მაშინ დროა სცადოთ yamllint.

ინსტალაცია იამლინტი შეგიძლიათ გამოიყენოთ სტანდარტული Linux პაკეტის მენეჯერი. მაგალითად, in Red Hat Enterprise Linux 8 ან Fedora ეს გაკეთდა ასე:

$ sudo dnf install yamllint

შემდეგ უბრალოდ გაუშვით yamllint, გადასცემთ მას YAML ფაილს შესამოწმებლად. ასე გამოიყურება, თუ ფაილს შეცდომით გადასცემთ ლინტერს:

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

მარცხნივ რიცხვები არ არის დრო, არამედ შეცდომის კოორდინატები: მწკრივის და სვეტის ნომერი. შეცდომის აღწერამ შეიძლება ვერაფერი გითხრათ, მაგრამ ზუსტად იცით სად არის. უბრალოდ შეხედეთ ამ ადგილს კოდში და, სავარაუდოდ, ყველაფერი ნათელი გახდება.

როდესაც yamllint არ აღმოაჩენს შეცდომებს ფაილში, არაფერი იბეჭდება ეკრანზე. თუ ასეთი სიჩუმე შეგაშინებთ და გსურთ ცოტა მეტი გამოხმაურება, მაშინ შეგიძლიათ აწარმოოთ ლინტერი პირობითი ექო ბრძანებით ორმაგი ამპერსანდის (&&) მეშვეობით, ასე:

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

POSIX-ში ორმაგი ამპერსანტი ირთვება, თუ და მხოლოდ იმ შემთხვევაში, თუ წინა ბრძანება დააბრუნებს 0-ს. და yamllint უბრალოდ აბრუნებს ნაპოვნი შეცდომების რაოდენობას, რის გამოც მთელი ეს პირობითი კონსტრუქცია მუშაობს.

2. დაწერეთ პითონში და არა YAML-ში

თუ YAML ნამდვილად გაღიზიანებთ, უბრალოდ არ დაწეროთ მასში, სიტყვასიტყვით. ეს ხდება, რომ YAML არის ერთადერთი ფორმატი, რომელსაც აპლიკაცია ესმის. მაგრამ ამ შემთხვევაშიც არ არის აუცილებელი YAML ფაილის შექმნა. დაწერე რაც მოგწონს და მერე გადააკეთე. მაგალითად, არსებობს პითონის შესანიშნავი ბიბლიოთეკა პიამლი და კონვერტაციის ორი მეთოდი: თვითკონვერტაცია და კონვერტაცია სკრიპტების საშუალებით.

თვითგადაქცევა

ამ შემთხვევაში, მონაცემთა ფაილი ასევე არის პითონის სკრიპტი, რომელიც ქმნის 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 გაფრთხილებთ, რომ ის არ იწყება --ით. კარგად, ეს შეიძლება ადვილად გამოსწორდეს ხელით ან ოდნავ შეცვლილი პითონის სკრიპტში.

კონვერტაცია სკრიპტების საშუალებით

ამ შემთხვევაში, ჩვენ ჯერ ვწერთ JSON-ში და შემდეგ ვაწარმოებთ კონვერტერს, როგორც ცალკე პითონის სკრიპტს, რომელიც აწარმოებს 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-ად მხოლოდ ორი ბრძანებით ინტერაქტიული პითონის გარსში. ვთქვათ, თქვენ გაქვთ 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-ის ძერწვამდე, დახაზეთ ფსევდო-კონფიგურაცია.

ფსევდო-კონფიგურაცია მსგავსია ფსევდო კოდის, სადაც არ უნდა ინერვიულოთ სტრუქტურაზე ან ჩაღრმავებაზე, მშობელ-შვილის ურთიერთობებზე, მემკვიდრეობაზე და ბუდეზე. აქაც იგივეა: თქვენ ხაზავთ მონაცემების გამეორებას, როგორც ისინი წარმოიქმნება თქვენს თავში.

ფსევდო-კონფიგურაციის ჩამონათვალის პროგრამისტები (მარტინი და ტაბიტა) და მათი უნარები (პროგრამირების ენები: Python, Perl, Pascal და Lisp, Fortran, Erlang, შესაბამისად).

ფურცელზე ფსევდოკონფიგურაციის დახატვის შემდეგ, გულდასმით გააანალიზეთ იგი და, თუ ყველაფერი რიგზეა, დააფორმატეთ იგი მოქმედი YAML ფაილის სახით.

6. Tabs vs. Spaces დილემა

თქვენ მოგიწევთ დილემის გადაჭრა "ჩანართები თუ სივრცეები?". არა გლობალური გაგებით, არამედ მხოლოდ თქვენი ორგანიზაციის, ან თუნდაც პროექტის დონეზე. არ აქვს მნიშვნელობა ეს გულისხმობს sed სკრიპტის შემდგომ დამუშავებას, პროგრამისტების მანქანებზე ტექსტური რედაქტორების დაყენებას, თუ საყოველთაოდ მიღებულ ქვითრების მიღებას ლინტერის ინსტრუქციების მკაცრი დაცვის საფრთხის ქვეშ, მაგრამ თქვენი გუნდის ყველა წევრი, რომელიც ამა თუ იმ გზით, რომელიც ეხება YAML-ს, უნდა გამოიყენოს მხოლოდ სივრცეები (როგორც ამას მოითხოვს YAML სპეციფიკაცია).

ნებისმიერ ნორმალურ ტექსტურ რედაქტორში შეგიძლიათ დააკონფიგურიროთ ავტომატური შესწორება ჩანართების მითითებულ რაოდენობაზე, ასე რომ გასაღების მიმდევრები აჯანყდებიან. Tab არ უნდა გეშინოდეს.

როგორც ყველა YAML-ის მოძულე იცის, თქვენ ვერ ხედავთ განსხვავებას ჩანართებსა და სივრცეებს ​​შორის ეკრანზე. და როდესაც რაღაც არ ჩანს, ეს ჩვეულებრივ ბოლოა, რაც ხალხს ახსოვს, მას შემდეგ რაც დალაგდება, შეამოწმებს და აღმოფხვრის ყველა სხვა შესაძლო პრობლემას. ტაბულური მრუდის ან სივრცეების ბლოკის ძიებაში დახარჯული დროის ერთი საათი უბრალოდ ყვირის, რომ სასწრაფოდ უნდა შექმნათ პოლიტიკა ერთის ან მეორეს გამოყენებისთვის და შემდეგ განახორციელოთ რკინაბეტონის შემოწმება მასთან შესაბამისობისთვის (მაგალითად, Git Hook, რომ ძალით გაიაროს იგი ლინტერში).

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-ის მიმართ ერთხელ და სამუდამოდ!

წყარო: www.habr.com