Gustung-gusto nating lahat ang Ansible, ngunit ang Ansible ay YAML. Mayroong maraming mga format para sa mga file ng pagsasaayos: mga listahan ng mga halaga, mga pares ng parameter-value, INI file, YAML, JSON, XML at marami pang iba. Gayunpaman, para sa ilang mga kadahilanan sa lahat ng mga ito, ang YAML ay madalas na itinuturing na partikular na mahirap. Sa partikular, sa kabila ng nakakapreskong minimalism at kahanga-hangang mga kakayahan para sa pagtatrabaho sa mga hierarchical na halaga, ang YAML syntax ay maaaring nakakainis sa mala-Python nitong diskarte sa indentation.
Kung iniinis ka ng YAML, magagawa moβat dapat! β gawin ang sumusunod na 10 hakbang upang mabawasan ang iyong pagkabigo sa isang katanggap-tanggap na antas at umibig sa YAML. Bilang angkop sa listahang ito, ang aming sampung tip ay mabibilang mula sa simula, magdaragdag kami ng meditasyon at espirituwal na mga kasanayan sa kalooban π
0. Gawing gumana ang iyong editor
Hindi mahalaga kung anong text editor ang mayroon ka, malamang na mayroong kahit isang plugin para sa pagtatrabaho sa YAML. Kung wala kang isa, hanapin at i-install ito kaagad. Ang oras na ginugol sa paghahanap at pag-set up ay magbabayad nang maraming beses sa bawat oras na kailangan mong i-edit ang YAML.
Halimbawa, editor sumusuporta sa YAML bilang default, ngunit para sa GNU Emacs kakailanganin mong mag-install ng mga karagdagang pakete, halimbawa, .
Mga Emac sa YAML mode at nagpapakita ng mga puwang.
Kung ang iyong paboritong editor ay walang YAML mode, kung gayon ang ilan sa mga problema ay maaaring malutas sa pamamagitan ng pagtatrabaho sa mga setting. Halimbawa, ang karaniwang GNOME text editor na si Gedit ay walang YAML mode, ngunit bilang default ay hina-highlight nito ang YAML syntax at nagbibigay-daan sa iyong i-configure ang trabaho na may mga indentation:
Pagtatakda ng mga indent sa Gedit.
Isang plugin para sa Gedit, ipinapakita ang mga puwang bilang mga tuldok, inaalis ang mga kalabuan sa mga antas ng indentation.
Sa madaling salita, gumugol ng oras sa pag-aaral tungkol sa iyong paboritong editor. Alamin kung ano ang inaalok niya o ng kanyang development community para sa pagtatrabaho sa YAML, at gamitin ang mga feature na iyon. Siguradong hindi ka magsisisi.
1. Gumamit ng linter
Sa isip, ang mga programming language at markup language ay gumagamit ng predictable syntax. Ang mga computer ay mahusay sa predictability, kaya naman ang konsepto ng . Kung sa loob ng 40 taon ng pag-iral nito ay lumipas na ito sa iyo at hindi ka pa rin gumagamit ng YAML linter, pagkatapos ay oras na upang subukan ang yamllint.
Upang mai-install Maaari mong gamitin ang karaniwang Linux package manager. Halimbawa, sa 8 o ito ay ginawa tulad nito:
$ sudo dnf install yamllint
Pagkatapos ay patakbuhin mo lang ang yamllint, ipinapasa ito sa YAML file upang suriin. Ito ang hitsura kung nagpasa ka ng isang file na may error sa linter:
$ yamllint errorprone.yaml
errorprone.yaml
23:10 error syntax error: mapping values are not allowed here
23:11 error trailing spaces (trailing-spaces)
Ang mga numero sa kaliwa ay hindi ang oras, ngunit ang mga coordinate ng error: row at column number. Maaaring walang sabihin sa iyo ang paglalarawan ng error, ngunit alam mo kung nasaan ito. Tingnan lamang ang lugar na ito sa code, at malamang na ang lahat ay magiging malinaw.
Kapag walang nakitang error ang yamllint sa isang file, walang naka-print sa screen. Kung nakakatakot sa iyo ang gayong katahimikan at gusto mo ng kaunti pang feedback, maaari mong patakbuhin ang linter gamit ang conditional echo command sa pamamagitan ng double ampersand (&&), tulad nito:
$ yamllint perfect.yaml && echo "OK"
OK
Sa POSIX, ang isang double ampersand ay magpapaputok kung at kung ang naunang utos ay nagbabalik ng 0. At ibinabalik lamang ng yamllint ang bilang ng mga error na natagpuan, kaya naman gumagana ang buong conditional na konstruksyon.
2. Sumulat sa Python, hindi YAML
Kung talagang iniinis ka ng YAML, huwag mo lang isulat dito, literal. Ito ay nangyayari na ang YAML ay ang tanging format na naiintindihan ng application. Ngunit kahit na sa kasong ito, hindi kinakailangan na lumikha ng isang YAML file. Sumulat sa kung ano ang gusto mo at pagkatapos ay i-convert. Halimbawa, mayroong isang mahusay na library para sa Python at dalawang paraan ng conversion: self-conversion at conversion sa pamamagitan ng script.
Pagbabalik-loob sa sarili
Sa kasong ito, ang data file ay isa ring Python script na bumubuo ng YAML. Ang pamamaraang ito ay pinakaangkop para sa maliliit na set ng data. Isulat mo lang ang data ng JSON sa isang variable ng Python, paunang salita ito ng isang direktiba sa pag-import, at sa dulo ng file magdagdag ng tatlong linya upang ipatupad ang output.
#!/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
Ngayon ay pinapatakbo namin ang file na ito sa Python at makuha ang output.yaml file:
$ 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
Ito ay ganap na wastong YAML, ngunit babalaan ka ng yamllint na hindi ito nagsisimula sa -. Well, madali itong maitama nang manu-mano o bahagyang mabago sa script ng Python.
Conversion sa pamamagitan ng mga script
Sa kasong ito, sumulat muna kami sa JSON, at pagkatapos ay patakbuhin ang converter bilang isang hiwalay na script ng Python, na gumagawa ng YAML bilang output. Kung ikukumpara sa nakaraang pamamaraan, ang pamamaraang ito ay mas mahusay na sumusukat, dahil ang conversion ay hiwalay sa data.
Una, gumawa tayo ng JSON file example.json, halimbawa, maaari mo itong kunin :
{
"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"
}
}
}
}
}
Pagkatapos ay gagawa kami ng isang simpleng converter script at i-save ito sa ilalim ng pangalang json2yaml.py. Ang script na ito ay nag-i-import ng parehong YAML at JSON Python module, at naglo-load ng JSON file na tinukoy ng user, nagsasagawa ng conversion, at nagsusulat ng data sa output.yaml file.
#!/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()
I-save ang script na ito sa path ng system at patakbuhin ito kung kinakailangan:
$ ~/bin/json2yaml.py example.json
3. Mag-parse ng marami at madalas
Minsan ito ay kapaki-pakinabang upang tumingin sa isang problema mula sa ibang anggulo. Kung nagkakaproblema ka sa kumakatawan sa mga ugnayan sa pagitan ng iyong data sa YAML, maaari mo itong pansamantalang gawing mas pamilyar.
Halimbawa, kung komportable kang magtrabaho sa mga listahan ng diksyunaryo o JSON, maaari mong i-convert ang YAML sa JSON gamit lamang ang dalawang command sa interactive na shell ng Python. Sabihin nating mayroon kang YAML file na mydata.yaml, kung gayon ito ang magiging hitsura nito:
$ 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.'}
Makakakita ka ng maraming iba pang mga halimbawa sa paksang ito. Bilang karagdagan, mayroong maraming mga online converter at lokal na parser na magagamit. Kaya't huwag mag-atubiling i-reformat ang data kapag nakita mo lamang ang isang hindi maintindihang paghalu-halo dito.
4. Basahin ang specs
Pagbabalik sa YAML pagkatapos ng mahabang pahinga, kapaki-pakinabang na bisitahin at muling basahin ang mga detalye (mga detalye). Kung nahihirapan ka sa YAML, ngunit hindi pa nakakarating sa detalye, oras na para itama ang sitwasyong ito. Ang mga spec ay nakakagulat na madaling isulat, at ang mga kinakailangan sa syntax ay inilalarawan na may malaking bilang ng mga halimbawa sa .
5. Mga pseudo-config
Kapag nagsusulat ng isang libro o artikulo, palaging kapaki-pakinabang na mag-sketch muna ng isang paunang balangkas, hindi bababa sa anyo ng isang talaan ng mga nilalaman. Ito ay pareho sa YAML. Malamang, mayroon kang ideya kung anong data ang kailangang isulat sa isang YAML file, ngunit hindi mo talaga naiintindihan kung paano ikonekta ito sa isa't isa. Samakatuwid, bago i-sculpting ang YAML, gumuhit ng pseudo-config.
Ang pseudo-config ay katulad ng pseudo-code, kung saan hindi mo kailangang mag-alala tungkol sa istraktura o indentation, relasyon ng magulang-anak, mana at nesting. Ito ay pareho dito: gumuhit ka ng mga pag-ulit ng data habang lumalabas ang mga ito sa iyong ulo.
Pseudo-config listing programmers (Martin at Tabitha) at ang kanilang mga kasanayan (programming language: Python, Perl, Pascal at Lisp, Fortran, Erlang, ayon sa pagkakabanggit).
Pagkatapos gumuhit ng isang pseudo-config sa isang piraso ng papel, maingat na pag-aralan ito at, kung maayos ang lahat, i-format ito sa anyo ng isang wastong YAML file.
6. Ang Tabs vs. Spaces Dilemma
Kailangan mong lutasin ang problema . Hindi sa pandaigdigang kahulugan, ngunit sa antas lamang ng iyong organisasyon, o kahit isang proyekto. Hindi mahalaga kung kabilang dito ang paggamit ng post-processing na may sed script, pag-set up ng mga text editor sa mga programmer machine, o pangkalahatang pagkuha ng mga resibo ng mahigpit na pagsunod sa mga tagubilin ng linter sa ilalim ng banta ng pagpapaalis, ngunit lahat ng miyembro ng iyong team na nasa ang isang paraan o iba pang nauugnay sa YAML ay dapat gumamit lamang ng mga puwang (tulad ng kinakailangan ng detalye ng YAML).
Sa anumang normal na text editor, maaari mong i-configure ang mga auto-correct na tab sa isang tinukoy na bilang ng mga puwang, kaya ang pagrerebelde ng mga pangunahing adherents Tab hindi mo kailangang matakot.
Tulad ng alam ng bawat hater ng YAML, hindi mo makikita ang pagkakaiba sa pagitan ng mga tab at espasyo sa screen. At kapag ang isang bagay ay hindi nakikita, kadalasan ito ang huling natatandaan ng mga tao, pagkatapos nilang ayusin, suriin at alisin ang lahat ng iba pang posibleng problema. Ang isang oras ng oras na ginugol sa paghahanap para sa isang kurba ng tabulasyon o isang bloke ng mga puwang ay sumisigaw lamang na kailangan mong agad na lumikha ng isang patakaran para sa paggamit ng isa o iba pa, at pagkatapos ay magpatupad ng isang reinforced concrete check para sa pagsunod dito (halimbawa, sa pamamagitan ng isang Git hook upang pilitin ito sa isang linter).
7. Mas kaunti ay higit pa (o higit pa ay mas kaunti)
Ang ilang mga tao ay gustong magsulat sa YAML dahil binibigyang-diin nito ang istraktura. Kasabay nito, aktibong ginagamit nila ang indentation upang i-highlight ang mga bloke ng data. Isa itong uri ng scam para gayahin ang mga markup language na gumagamit ng tahasang mga delimiter.
Narito ang isang halimbawa ng naturang istraktura mula sa :
# Employee records
- martin:
name: Martin D'vloper
job: Developer
skills:
- python
- perl
- pascal
- tabitha:
name: Tabitha Bitumen
job: Developer
skills:
- lisp
- fortran
- erlang
Para sa ilan, ang pagpipiliang ito ay tumutulong sa kanila na ayusin ang istraktura ng YAML sa kanilang mga ulo; para sa iba, sa kabaligtaran, nakakainis ito sa kanila ng maraming hindi kailangan, sa kanilang opinyon, mga indent.
Ngunit kung ikaw ang may-ari ng dokumento ng YAML at responsable para sa pagpapanatili nito, kung gayon ikaw at ikaw lamang dapat tukuyin kung paano gamitin ang indentation. Kung naiinis ka sa malaking padding, panatilihin ito sa pinakamababang posible ayon sa detalye ng YAML. Halimbawa, ang file sa itaas mula sa dokumentasyong Ansible ay maaaring muling isulat nang tulad nito nang walang anumang pagkawala:
---
- martin:
name: Martin D'vloper
job: Developer
skills:
- python
- perl
- pascal
- tabitha:
name: Tabitha Bitumen
job: Developer
skills:
- lisp
- fortran
- erlang
8. Gumamit ng mga blangko
Kung palagi mong inuulit ang parehong mga pagkakamali kapag pinupunan ang isang YAML file, makatuwirang magpasok ng template dito bilang isang komento. Pagkatapos sa susunod na maaari mong kopyahin ang template na ito at ilagay ang totoong data doon, halimbawa:
---
# - <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. Gumamit ng ibang bagay
Kung ang application ay walang stranglehold sa iyo, maaaring sulit na baguhin ang YAML sa ibang format. Sa paglipas ng panahon, ang mga file ng pagsasaayos ay maaaring lumaki sa kanilang mga sarili at pagkatapos ay mas mahusay na i-convert ang mga ito sa mga simpleng script sa Lua o Python.
Ang YAML ay isang magandang bagay na gusto ng maraming tao para sa minimalism at pagiging simple nito, ngunit malayo ito sa tanging tool sa iyong arsenal. Kaya minsan maaari mong tanggihan ito. Ang pag-parse ng mga library ay madaling mahanap para sa YAML, kaya kung nag-aalok ka ng mga madaling opsyon sa paglipat, ang iyong mga user ay makakaligtas sa kabiguan na ito nang medyo walang sakit.
Kung hindi mo magagawa nang wala ang YAML, pagkatapos ay kunin ang 10 tip na ito at pagtagumpayan ang iyong hindi pagkagusto sa YAML minsan at para sa lahat!
Pinagmulan: www.habr.com