Facciu assai recensioni di u codice Ansible di l'altri è scrive assai per mè stessu. In u cursu di l'analisi di l'errori (sia di l'altri è di i mei), è ancu di parechje interviste, aghju realizatu l'errore principale chì l'utilizatori di Ansible facenu - si mettenu in cose cumplesse senza maestru di i basi.

Per corriggerà sta inghjustizia universale, aghju decisu di scrive una introduzione à Ansible per quelli chì a cunnosci digià. Vi avvistu, questu ùn hè micca un raccontu di l'omi, questu hè una longa lettura cù assai lettere è senza ritratti.

U livellu previstu di u lettore hè chì parechji millai di linee di yamla sò digià scritte, qualcosa hè digià in pruduzzione, ma "di qualchì manera tuttu hè stortu".

Nomi

L'errore principale chì face un utilizatore Ansible hè di ùn sapè cumu si chjama qualcosa. Se ùn cunnosci micca i nomi, ùn pudete micca capisce ciò chì dice a documentazione. Un esempiu vivu: durante una entrevista, una persona chì pareva dì chì hà scrittu assai in Ansible ùn pudia micca risponde à a quistione "di chì elementi hè custituitu un playbook?" È quandu aghju suggeritu chì "a risposta era prevista chì u playbook hè custituitu da u ghjocu", u cumentu dannante "ùn avemu micca usatu questu" seguitatu. A ghjente scrive Ansible per soldi è ùn usa micca u ghjocu. In realtà l'utilizanu, ma ùn sanu micca ciò chì hè.

Allora cuminciamu cù qualcosa simplice: cumu si chjama? Forsi sapete questu, o forse ùn avete micca, perchè ùn avete micca attentu quandu avete lettu a documentazione.

ansible-playbook esegue u playbook. Un playbook hè un schedariu cù l'estensione yml/yaml, in u quale ci hè qualcosa cum'è questu:

---
- hosts: group1
  roles:
    - role1

- hosts: group2,group3
  tasks:
    - debug:

Avemu digià capitu chì tuttu stu schedariu hè un playbook. Pudemu dimustrà induve sò i roli è induve sò i travaglii. Ma induve hè u ghjocu? E quale hè a diffarenza trà u ghjocu è u rolu o u playbook?

Hè tuttu in a documentazione. È li mancanu. Principianti - perchè ci hè troppu è ùn vi ricurdate micca tuttu in una volta. Esperienza - perchè "cose ​​triviali". Sè vo site espertu, rileghjite queste pagine almenu una volta ogni sei mesi, è u vostru codice diventerà a prima volta.

Allora, ricordate: Playbook hè una lista custituita da ghjucà è import_playbook.
Questu hè un ghjocu:

- hosts: group1
  roles:
    - role1

è questu hè ancu un altru ghjocu:

- hosts: group2,group3
  tasks:
    - debug:

Chì ghjè u ghjocu? Perchè ella hè ?

U ghjocu hè un elementu chjave per un libru di ghjocu, perchè u ghjocu è solu ghjucà associa una lista di roli è / o tarei cù una lista d'ospiti nantu à quale deve esse eseguitu. In a prufundità prufonda di a documentazione pudete truvà menzione delegate_to, plugins di ricerca locale, paràmetri specifichi di a rete di cli, ospiti di salto, etc. Permettenu di cambià ligeramente u locu induve i travaglii sò realizati. Ma, scurdate di questu. Ciascuna di queste opzioni intelligenti hà usi assai specifichi, è ùn sò definitivamente micca universali. È parlemu di e cose basi chì ognunu deve cunnosce è aduprà.

Sè vo vulete fà "qualcosa" "in qualchì locu", scrive play. Ùn un rolu. Ùn hè micca un rolu cù moduli è delegati. Pigliate è scrive u ghjocu. In quale, in u campu di l'ospiti elencu induve eseguisce, è in roli / compiti - ciò chì eseguisce.

Semplice, nò? Cumu puderia esse altrimenti?

Unu di i mumenti caratteristici quandu a ghjente hà u desideriu di fà questu micca per via di u ghjocu hè u "role chì mette tuttu in ordine". Mi piacerebbe avè un rolu chì cunfigura i dui servitori di u primu tipu è i servitori di u sicondu tipu.

Un esempiu archetipicu hè u monitoraghju. Mi piacerebbe avè un rolu di surviglianza chì cunfigurà u monitoraghju. U rolu di surviglianza hè assignatu à l'ospiti di monitoraghju (sicondu u ghjocu). Ma risulta chì per u monitoraghju avemu bisognu di furnisce pacchetti à l'ospiti chì monitoremu. Perchè ùn aduprà delegatu? Avete ancu bisognu di cunfigurà iptables. delegatu? Avete ancu bisognu di scrive / curregge una cunfigurazione per u DBMS per attivà u monitoraghju. delegatu! È se a creatività manca, pudete fà una delegazione include_role in un ciclu nidificatu utilizendu un filtru complicatu nantu à una lista di gruppi, è dentru include_role pudete fà più delegate_to di novu. È andemu via...

Un bonu desideriu - avè un unicu rolu di surviglianza, chì "fa tuttu" - ci porta à l'infernu cumpletu da quale a maiò parte di spessu ci hè solu una manera di esce: per riscrive tuttu da zero.

Induve hè accadutu l'errore quì? U mumentu chì avete scupertu chì per fà u compitu "x" nantu à l'ospiti X avete da andà à l'ospiti Y è fà "y" quì, avete da fà un esercitu simplice: andate è scrive u ghjocu, chì nantu à l'ospite Y faci y. Ùn aghjunghje micca qualcosa à "x", ma scrivite da zero. Ancu cù variabili hardcoded.

Sembra chì tuttu in i paragrafi sopra hè dettu bè. Ma questu ùn hè micca u vostru casu! Perchè vo vulete scrive un codice reusable chì hè SECU è biblioteca-like, è avete bisognu di circà un metudu nantu à cumu fà.

Questu hè induve un altru sbagliu seriu lurks. Un errore chì hà trasfurmatu assai prughjetti da scritti tolerabilmente (puderia esse megliu, ma tuttu funziona è hè faciule da finisce) in un horrore cumpletu chì ancu l'autore ùn pò micca capisce. Funziona, ma Diu ùn ti impedisce di cambià qualcosa.

L'errore hè: u rolu hè una funzione di biblioteca. Questa analogia hà arruvinatu tanti boni principii chì hè simplicemente tristu di fighjà. U rolu ùn hè micca una funzione di biblioteca. Ùn pò micca fà calculi è ùn pò micca piglià decisioni à livellu di ghjocu. Ricordatemi chì decisioni piglia u ghjocu?

Grazie, avete ragione. U ghjocu face una decisione (più precisamente, cuntene infurmazioni) nantu à quali compiti è roli da fà nantu à quale ospiti.

Se delegate sta decisione à un rolu, è ancu cù i calculi, vi cundannate (è quellu chì pruvarà à analizà u vostru codice) à una esistenza miserable. U rolu ùn decide micca induve hè realizatu. Sta decisione hè fatta da u ghjocu. U rolu face ciò chì hè dettu, induve hè dettu.

Perchè hè periculosu per programà in Ansible è perchè COBOL hè megliu cà Ansible, parlemu in u capitulu di variabili è jinja. Per avà, dicemu una cosa - ognunu di i vostri calculi lascia una traccia indelebile di cambiamenti in e variabili globali, è ùn pudete micca fà nunda. Appena i dui "tracce" intersectate, tuttu hè andatu.

Nota per u squeamish: u rolu pò certamenti influenzà u flussu di cuntrollu. Manghja delegate_to è hà usi ragiunate. Manghja meta: end host/play. Ma! Ricurdativi chì insegnimu i principii? Scurdate di delegate_to. Parlemu di u codice Ansible più simplice è bellu. Chì hè faciule da leghje, faciule da scrive, faciule da debug, faciule da pruvà è faciule da compie. Allora, una volta di più:

ghjucà è solu u ghjocu decide nantu à quale ospiti ciò chì hè eseguitu.

In questa sezione, avemu trattatu l'opposizione trà u ghjocu è u rolu. Avà parlemu di a relazione di u travagliu versus u rolu.

Compiti è Roli

Cunsiderate u ghjocu:

- hosts: somegroup
  pre_tasks:
    - some_tasks1:
  roles:
     - role1
     - role2
  post_tasks:
     - some_task2:
     - some_task3:

Diciamu chì avete bisognu di fà foo. È pare foo: name=foobar state=present. Induve duverebbe scrive questu? in pre? postu? Crià un rolu?

...E induva sò andati i travaglii ?

Avemu principiatu cù i principii di novu - u dispusitivu di ghjocu. Sè vo float nant'à sta questione, ùn pudete micca aduprà u ghjocu cum'è una basa per tuttu u restu, è u vostru risultatu serà "tremulu".

Dispositivu di ghjocu: direttiva di l'ospiti, paràmetri per u ghjocu stessu è pre_tasks, tasks, roles, post_tasks sections. I paràmetri rimanenti per u ghjocu ùn sò micca impurtanti per noi avà.

L'ordine di e so rùbbriche cù funzioni è roli: pre_tasks, roles, tasks, post_tasks. Siccomu semanticamente l'ordine di esicuzzioni hè trà tasks и roles ùn hè micca chjaru, allora e megliu pratiche dicenu chì aghjustemu una sezione tasks, solu s'ellu ùn roles... S'ellu ci hè roles, allura tutti i travaglii attaccati sò posti in sezioni pre_tasks/post_tasks.

Tuttu ciò chì resta hè chì tuttu hè semanticamente chjaru: prima pre_tasksdopu rolesdopu post_tasks.

Ma ùn avemu ancu rispostu à a quistione: induve hè u modulu chjamatu? foo scrive? Avemu bisognu di scrive un rolu sanu per ogni modulu? O hè megliu avè un rolu grossu per tuttu? È s'ellu ùn hè micca un rolu, allora induve scrive - in pre o post?

Se ùn ci hè micca una risposta ragiunata à queste dumande, allora questu hè un signu di mancanza di intuizione, vale à dì, quelli stessi "fundamenti tremuli". Scupritemu. Prima, una quistione di sicurità: Se u ghjocu hà pre_tasks и post_tasks (è ùn ci sò micca compiti o roli), allora qualcosa si pò rompe se eseguiu u primu compitu da post_tasks L'aghju trasladatu finu à a fine pre_tasks?

Di sicuru, a formulazione di a quistione suggerisce chì si romperà. Ma chì esattamente?

... Manipulatori. A lettura di i principii palesa un fattu impurtante: tutti i gestori sò lavati automaticamente dopu ogni sezione. Quelli. tutti i travaglii da pre_tasks, allora tutti i gestori chì sò stati notificati. Allora tutti i roli è tutti i gestori chì sò stati notificati in i roli sò eseguiti. Dopu post_tasks è i so gestori.

Cusì, s'è vo trascinate un compitu da post_tasks в pre_tasks, allora potenzialmente l'eseguirete prima chì u gestore sia eseguitu. per esempiu, se in pre_tasks u servitore web hè stallatu è cunfiguratu, è post_tasks qualcosa hè mandatu à ellu, poi trasfiriri stu compitu à a rùbbrica pre_tasks portarà à u fattu chì à l'ora di "invià" u servitore ùn sarà ancu in esecuzione è tuttu si romperà.

Avà pensemu di novu, perchè avemu bisognu pre_tasks и post_tasks? Per esempiu, per compie tuttu ciò chì hè necessariu (cumpresu i gestori) prima di cumpiendu u rolu. A post_tasks ci permetterà di travaglià cù i risultati di eseguisce roli (inclusi i manipulatori).

Un astutu espertu Ansible ci dirà ciò chì hè. meta: flush_handlers, ma perchè avemu bisognu di flush_handlers se pudemu cunfidassi nantu à l'ordine di esecuzione di e rùbbriche in ghjocu? Inoltre, l'usu di meta: flush_handlers pò dà noi cose inespettate cù manipulatori duplicati, denduci avvirtimenti strani quandu sò usati. when у block ecc. U megliu sapete l'ansible, più sfumature pudete nome per una suluzione "dilicata". È una suluzione simplice - utilizendu una divisione naturali trà pre / roles / post - ùn causa micca sfumature.

È, torna à u nostru "foo". Induve deveru mette ? In pre, post o roli? Ovviamente, questu dipende s'ellu ci hè bisognu di i risultati di u manipulatore per foo. S'ellu ùn sò micca quì, allora foo ùn hè micca bisognu di esse postu in pre o post - sti rùbbriche anu un significatu spiciale - esecutà i travaglii prima è dopu à u corpu principale di codice.

Avà a risposta à a quistione "role o compitu" vene à ciò chì hè digià in ghjocu - s'ellu ci sò compiti, allora avete bisognu di aghjunghje à i travaglii. Se ci sò roles, avete bisognu di creà un rolu (ancu da un compitu). Lasciami ricurdà chì i travaglii è i roli ùn sò micca usati à u stessu tempu.

Capisce i principii di Ansible furnisce risposte ragiunate à e dumande apparentemente di gustu.

Compiti è roli (seconda parte)

Avà discutemu a situazione quandu avete principiatu à scrive un libru di ghjocu. Avete bisognu di fà foo, bar è baz. Sò questi trè compiti, un rolu o trè roli ? Per sintetizà a quistione: à chì puntu duvete principià à scrive roli? Chì ghjè u scopu di scrive roli quandu pudete scrive i travaglii ?... Chì ghjè un rolu ?

Unu di i più grandi sbagli (aghju digià parlatu di questu) hè di pensà chì un rolu hè cum'è una funzione in a biblioteca di u prugramma. Cume hè una descrizzione di funzione generica? Accetta l'argumenti di input, interagisce cù e cause laterali, face effetti secundari, è torna un valore.

Avà, attenzione. Chì pò esse fattu da questu in u rolu? Sò sempre benvenuti à chjamà effetti latu, questu hè l'essenza di tuttu Ansible - per creà effetti latu. Avete cause laterali? Elementari. Ma cù "passà un valore è rinvià" - hè quì chì ùn funziona micca. Prima, ùn pudete micca passà un valore à un rolu. Pudete stabilisce una variabile globale cù una dimensione di vita di ghjocu in a sezione vars per u rolu. Pudete stabilisce una variabile globale cù una vita in ghjocu in u rolu. O ancu cù a vita di i libri di ghjocu (set_fact/register). Ma ùn pudete micca avè "variabili lucali". Ùn pudete micca "piglià un valore" è "riturnà".

A cosa principal segue da questu: ùn pudete micca scrive qualcosa in Ansible senza pruvucà effetti secundari. U cambiamentu di variabili glubale hè sempre un effettu secundariu per una funzione. In Rust, per esempiu, cambià una variabile globale hè unsafe. È in Ansible hè u solu metudu per influenzà i valori per un rolu. Nota e parolle aduprate: micca "passà un valore à u rolu", ma "cambià i valori chì u rolu usa". Ùn ci hè micca isolamentu trà i roli. Ùn ci hè micca isolamentu trà i travaglii è i roli.

Total: un rolu ùn hè micca una funzione.

Chì ci hè bonu di u rolu? Prima, u rolu hà valori predeterminati (/default/main.yaml), in segundu, u rolu hà cartulari supplementari per almacenà i schedari.

Chì sò i benefici di i valori predeterminati? Perchè in a piramide di Maslow, a tavola piuttostu distorta di Ansible di priorità variabili, i valori predeterminati di u rolu sò i più bassu priurità (minus Ansible paràmetri di linea di cummanda). Questu significa chì sè avete bisognu di furnisce i valori predeterminati è ùn preoccupate micca di annunzià i valori da l'inventariu o variabili di u gruppu, allora i valori predeterminati sò l'unicu locu adattatu per voi. (Sò mentitu un pocu - ci sò più |d(your_default_here), ma s'è no parlemu di lochi stazionarii, allora solu u rolu predeterminatu).

Chì altru hè grande nantu à i roli? Perchè anu u so propiu catalogu. Quessi sò cartulari per variàbili, sia custanti (vale à dì calculati per u rolu) sia dinamichi (ci hè un mudellu o un anti-pattern - include_vars inseme cù {{ ansible_distribution }}-{{ ansible_distribution_major_version }}.yml.). Quessi sò i cartulari per files/, templates/. Inoltre, vi permette di avè i vostri propri moduli è plugins (library/). Ma, in paragunà cù i travaglii in un playbook (chì pò ancu avè tuttu questu), l'unicu benefiziu quì hè chì i schedari ùn sò micca scaricati in una sola pila, ma parechji pilastri separati.

Un dettu più: pudete pruvà à creà roli chì seranu dispunibili per a reutilizazione (via galaxia). Cù l'avventu di cullezzione, a distribuzione di u rolu pò esse cunsideratu quasi scurdatu.

Cusì, i roli anu duie funzioni impurtanti: anu predeterminate (una funzione unica) è permettenu di strutturate u vostru codice.

Riturnendu à a quistione originale: quandu fà i travaglii è quandu i roli? Tasks in un playbook sò più spessu usati sia cum'è "cola" prima / dopu à i roli, o cum'è un elementu di custruzzione indipendente (tandu ùn deve esse micca rolu in u codice). Una pila di travaglii normali mischiati cù roli hè una sloppiness senza ambiguità. Duvete aderisce à un stilu specificu - o un compitu o un rolu. I roli furniscenu a separazione di l'entità è i predefiniti, i travaglii permettenu di leghje u codice più veloce. Di solitu, u codice più "stazionariu" (impurtante è cumplessu) hè messu in roli, è scripts ausiliarii sò scritti in stile di attività.

Hè pussibule di fà import_role cum'è un compitu, ma se scrivite questu, allora esse preparatu per spiegà à u vostru sensu di bellezza perchè vulete fà questu.

Un lettore astutu pò dì chì i roli ponu impurtà roli, i roli ponu avè dependenzii via galaxy.yml, è ci hè ancu un terribili è terribili. include_role - Vi ricurdamu chì migliuramu e cumpetenze in l'Ansible di basa, è micca in a ginnastica di figura.

Manipulatori è compiti

Discutemu un'altra cosa ovvia: i gestori. Sapendu cumu aduprà currettamente hè quasi un arte. Chì ghjè a diffarenza trà un handler è un drag?

Siccomu ricurdemu i principii, eccu un esempiu:

- hosts: group1
  tasks:
    - foo:
      notify: handler1
  handlers:
     - name: handler1
       bar:

I gestori di u rolu sò situati in rolename/handlers/main.yaml. I manipulatori rummaghjanu trà tutti i participanti di u ghjocu: pre / post_tasks ponu chjappà i manipulatori di rolu, è un rolu pò sguillà i manipulatori da u ghjocu. In ogni casu, e chjama "cross-role" à i gestori causanu assai più wtf cà ripetiri un gestore triviale. (Un altru elementu di e migliori pratiche hè di pruvà micca di ripetiri i nomi di i gestori).

A diferenza principale hè chì u compitu hè sempre eseguitu (idempotently) (plus / minus tags è when), è u gestore - per u cambiamentu di statu (avvisà i focu solu s'ellu hè statu cambiatu). Chì significà questu? Per esempiu, u fattu chì quandu avete riavviatu, s'ellu ùn era micca cambiatu, allora ùn ci sarà micca handler. Perchè puderia esse chì avemu bisognu di eseguisce un gestore quandu ùn ci era micca cambiamentu in u compitu di generazione? Per esempiu, perchè qualcosa s'hè rottu è cambiatu, ma l'esekzione ùn hè micca ghjunta à u manigliatore. Per esempiu, perchè a reta era temporaneamente falita. A cunfigurazione hè cambiata, u serviziu ùn hè micca riavviatu. A prossima volta chì avete principiatu, a cunfigurazione ùn cambia più, è u serviziu ferma cù a versione vechja di a cunfigurazione.

A situazione cù a cunfigurazione ùn pò esse risolta (più precisamente, pudete inventà un protokollu di riavvia speciale cù i bandieri di file, etc., ma questu ùn hè più "ansible basicu" in ogni forma). Ma ci hè una altra storia cumuna: avemu installatu l'applicazione, l'avemu arregistrata .service-file, è avà vulemu daemon_reload и state=started. È u locu naturali per questu pare chì hè u manipulatore. Ma s'è vo fate micca un gestore ma un compitu à a fine di una lista di attività o rolu, allora serà eseguitu idempotently ogni volta. Ancu s'è u playbook s'hè ruttu à mezu. Questu ùn risolve micca u prublema riavviatu in tuttu (ùn pudete micca fà un compitu cù l'attributu riavviatu, perchè l'idempotenza hè persa), ma hè definitu chì vale a pena di fà state = cuminciatu, l'stabilità generale di playbooks aumenta, perchè u numeru di cunnessione è u statu dinamicu diminuisce.

Una altra pruprietà pusitiva di u gestore hè chì ùn obstruisce micca l'output. Ùn ci era micca cambiamenti - senza saltatu extra o ok in u output - più faciule da leghje. Hè ancu una pruprietà negativa - se truvate un typo in un compitu eseguitu linearmente in a prima prima corsa, allora i gestori seranu eseguiti solu quandu cambiatu, i.e. in certi cundizioni - assai raramenti. Per esempiu, per a prima volta in a mo vita cinque anni dopu. E, sicuru, ci sarà un typo in u nome è tuttu si rompe. È s'è vo ùn li eseguite a seconda volta, ùn ci hè micca cambiatu.

Separatamente, avemu bisognu di parlà di a dispunibilità di variàbili. Per esempiu, s'è vo avvisate un compitu cù un ciclu, chì serà in e variàbili? Pudete guess analitically, ma ùn hè micca sempre trivial, soprattuttu se i variàbili venenu da diversi lochi.

... Allora i manipulatori sò assai menu utili è assai più problematiche di ciò chì parenu. Se pudete scrive qualcosa bella (senza frills) senza manichi, hè megliu per fà senza elli. Se ùn viaghja micca bè, hè megliu cun elli.

U lettore corrosive puntualmente ghjustu chì ùn avemu micca discututu listenchì un gestore pò chjamà notificà per un altru gestore, chì un gestore pò include import_tasks (chì pò fà include_role cù with_items), chì u sistema di gestore in Ansible hè Turing-complete, chì i gestori di include_role si intersecanu in una manera curiosa cù i gestori da u ghjocu, ecc .d. - tuttu questu hè chjaramente micca i "basamenti").

Ancu s'ellu ci hè un WTF specificu chì hè in realtà una funzione chì avete bisognu di mantene in mente. Se u vostru compitu hè eseguitu cù delegate_to è hà notificatu, allora u gestore currispundente hè eseguitu senza delegate_to, i.e. nantu à l'ospite induve u ghjocu hè assignatu. (Ancu se u gestore, sicuru, pò avè delegate_to Stessa).

Separatamente, vogliu dì uni pochi di parolle nantu à i roli reutilizabili. Prima chì e cullezzione apparsu, ci era una idea chì pudete fà un rolu universale chì puderia esse ansible-galaxy install è andò. Funziona su tutti i sistemi operativi di tutte le varianti in tutte le situazioni. Allora, a mo opinione: ùn funziona micca. Ogni rolu cù massa include_vars, chì sustene 100500 casi, hè cundannatu à l'abissu di i bug di casu d'angolo. Puderanu esse coperti cù teste massive, ma cum'è cù qualsiasi teste, o avete un pruduttu cartesianu di valori di input è una funzione tutale, o avete "scenarii individuali coperti". A mo opinione hè chì hè assai megliu se u rolu hè lineale (cumplessità ciclomatica 1).

U menu se (esplicito o dichjarazione - in a forma when o forma include_vars per inseme di variàbili), u megliu u rolu. Calchì volta ci vole à fà rami, ma, ripetu, menu ci sò, megliu. Allora pare un bonu rolu cù a galaxia (travaglia!) cù una mansa di when pò esse menu preferibile à u rolu "propiu" da cinque compiti. U mumentu chì u rolu cù a galaxia hè megliu hè quandu avete principiatu à scrive qualcosa. U mumentu chì s'aggrava hè quandu qualcosa si rompe è avete un suspettu chì hè per via di u "role cù a galaxia". L'apri, è ci sò cinque inclusi, ottu fogli di compiti è una pila when'ov... È avemu bisognu di capisce questu. Invece di 5 compiti, una lista lineale in quale ùn ci hè nunda di rompe.

In i seguenti parti

• Un pocu nantu à l'inventariu, variabili di gruppu, plugin host_group_vars, hostvars. Cumu attaccà un nodo gordianu cù spaghetti. Scope è variabili di precedenza, mudellu di memoria Ansible. "Allora induve guardemu u nome d'utilizatore per a basa di dati?"
• jinja: {{ jinja }} - nosql notype nosense soft plasticine. Hè in ogni locu, ancu induve ùn l'aspettate micca. Un pocu circa !!unsafe è deliziosu yaml.

Source: www.habr.com