Share
Aceasta este o parte dintr-un tutorial în două părți pe Ansible. În această parte veți afla ce este Ansible, cum să îl instalați și configurați și cum să instalați un cluster Vagrant local pentru al testa. Apoi, veți descoperi inventarul, modulele, comenzile ad-hoc, playbook-urile, strategiile de rulare, blocurile și seiful.
Ansible este un instrument de configurare și instrument de orchestrare. Funcționează în același domeniu ca Puppet, Chef și Saltstack. Acest lucru înseamnă că, cu ajutorul serviciului Ansible, puteți furniza de la distanță o întreagă parcelă de servere la distanță, instalați și implementați software pe ele și urmăriți-le de la distanță.
Ansible este un proiect open-source implementat în Python și are o arhitectură pluggable cu module care pot gestiona aproape orice sistem de operare, mediul cloud și instrumentul sau cadrul de administrare a sistemului. Puteți, de asemenea, să-l extindeți cu ușurință cu pluginurile proprii dacă doriți să faceți ceva special.
Una dintre caracteristicile unice ale lui Ansoft este că nu instalează niciun software pe mașini gestionate. Administrează mașinile de la distanță prin SSH. Pentru a gestiona o mașină la distanță, trebuie doar să vă asigurați că cheia publică SSH se află în fișierul authorized_keys al acelei mașini.
Ansible se execută pe o mașină de control și poate gestiona servere care rulează orice sistem de operare, dar mașina de control nu poate fi o mașină Windows în acest moment. Voi folosi Mac OS X în acest tutorial ca mașină de control.
Ansible necesită Python 2.6 sau 2.7. Pentru ao instala, tastați:
pip instalează
Pe Mac OS X, se recomandă mărirea numărului de mânere pentru fișiere:
sudo limita de lansare maxfiles 1024 nelimitat
Dacă vedeți o eroare precum "Prea multe fișiere deschise", probabil că trebuie să faceți acest lucru.
Pentru a verifica dacă este instalat corect, tastați posibil --versiune. Ar trebui sa vezi:
ansible 2.0.0.2 config file = calea de căutare a modulului configurate = suprascriere implicită w / o
Numărul versiunii poate fi diferit, desigur.
Ansible are un fișier de configurare care vă permite să controlați mai multe opțiuni. Ordinea de căutare este:
De asemenea, puteți să înlocuiți setările specifice utilizând variabilele de mediu individuale, care au prioritate față de fișierul de configurare.
Consultați documentația Ansible pentru a afla despre toate opțiunile.
Pentru a înțelege cu adevărat puterea lui Ansible, aveți nevoie de o mulțime de servere pentru a gestiona. În scopul acestui tutorial voi folosi un grup Vagrant de 3 VM-uri, însă, în ceea ce privește Ansoft, acestea sunt doar câteva gazde pe care trebuie să le gestioneze. Pentru a afla mai multe despre Vagrant, consultați Introducere în Vagrant.
Mai întâi, instalați VirtualBox și Vagrant. Apoi puneți următoarele într-un fișier numit "Vagrantfile" într-un director de lucru
Accentsconagua
# - * - modul: ruby - * - # vi: set ft = ruby: hosts = "larry" => "192.168.88.10" .88.12 " Vagrant.configure (" 2 ") nu | config | config.vm.box = "exact64" config.vm.box_url = "http://files.vagrantup.com/precise64.box" hosts.each face | nume, ip | config.vm.definirea numelui nu | mașină | machine.vm.network: private_network, ip: ip mașină.vm.provider "virtualbox" nu | v | v.name = nume sfârșit sfârșit sfârșit sfârșit Apoi tastați vagrant sus. Vagrantul va crea trei mașini virtuale pentru tine, disponibile ca Larry, Curly și Moe. Pentru a verifica, tastați starea vagonului. Ar trebui sa vezi:
Starea curentă a mașinii: Running larry (virtualbox) care rulează curba (virtualbox) care rulează (virtualbox) Acest mediu reprezintă VM-uri multiple. Toate VM-urile sunt enumerate mai sus cu starea lor actuală. Pentru mai multe informații despre un VM specific, executați "starea vagonului NAME".
Pentru a vă asigura că aveți SSH în gazdele dvs. de cluster, tastați: vagrantul ssh-config >> ~ / .ssh / config.
Acum aveți posibilitatea să SSH în oricare dintre servere virtuale folosind numele de gazdă. De exemplu: ssh curly. Acest lucru va permite lui Ansible să se conecteze la gazdele dvs. de cluster pe SSH fără probleme cu numele de utilizator, parolele sau cheile.
Acum că avem un grup, trebuie să-i spunem lui Ansible despre asta. Acest lucru se face folosind un fișier de inventar. Fișierul de inventar este o listă cu numele de gazde organizate în grupuri utilizând un format de fișier INI. Puneți următoarele într-un fișier numit "hosts" în directorul dvs. de lucru.
[amuzant] larry [funnier] curly moe
Am pus "larry" într-un grup numit "amuzant", iar ceilalți gazde dintr-un grup numit "funnier". Această organizație ne va permite să efectuăm acțiuni asupra acestor grupuri. De asemenea, puteți efectua acțiuni pe gazde individuale și pe toate gazdele.
Ansible are o arhitectură foarte modulară și extensibilă. Toate capacitățile sale sunt organizate în module. Există module de bază și module suplimentare. Fiecare modul reprezintă o comandă și majoritatea argumentează. Puteți utiliza modulele direct în comenzi ad-hoc sau în manuale. Puteți citi despre toate modulele din documentație.
E timpul să ne dăm mâna. Cea mai simplă modalitate de a utiliza Ansible este de a rula comenzi ad-hoc. Comenzile ad-hoc utilizează module. Formatul unei comenzi ad-hoc este:
ansiblu
De exemplu, pentru a vedea dacă toate gazdele din inventarul dvs. sunt în sus, puteți utiliza modulul ping (fără argumente):
toate găzduiri -i găzduiesc - SUCCESS => "schimbat": false, "ping": "pong" larry | SUCCESS => "schimbat": false, "ping": "pong" moe | SUCCESS => "schimbat": false, "ping": "pong"
Ansible are multe module pentru toate sarcinile comune de administrare a sistemului, cum ar fi managementul fișierelor, gestionarea utilizatorilor și gestionarea pachetelor, precum și multe sarcini neobișnuite. Dar dacă nu găsiți ceea ce aveți nevoie sau vă simțiți mai confortabil cu comenzile de shell simple, puteți utiliza modulul shell direct, inclusiv conductele. Următoarea comandă extrage adresele IP interne și externe ale tuturor gazdelor:
toate posibilitățile -i găzduiesc -m shell -a '/ sbin / ifconfig | grep inet. * Bcast '"larry | SUCCESS | rc = 0 >> inet addr: 10.0.2.15 Bcast: 10.0.2.255 Masca: 255.255.255.0 inet addr: 192.168.88.10 Bcast: 192.168.88.255 Masca: 255.255.255.0 cret | SUCCESS | rc = 0 >> inet addr: 10.0.2.15 Bcast: 10.0.2.255 Mască: 255.255.255.0 inet addr: 192.168.88.11 Bcast: 192.168.88.255 Mască: 255.255.255.0 moe | SUCCESS | rc = 0 >> inet addr : 10.0.2.15 Bcast: 10.0.2.255 Masca: 255.255.255.0 inet addr: 192.168.88.12 Bcast: 192.168.88.255 Masca: 255.255.255.0
Comenzile ad-hoc sunt plăcute atunci când doriți să faceți rapid ceva pe o mulțime de gazde, dar puterea reală a lui Ansible este în manualele sale. Manualele sunt fișiere YAML în care definiți colecții de sarcini pentru a realiza obiective precum furnizarea, configurarea, implementarea și orchestrarea infrastructurii.
Să aruncăm o privire la ceea ce arată un manual tipic înainte de a ajunge la detalii.
--- - gazdă: Funcții funnier: - nume: Instalare Nginx apt: pkg = nginx state = instalare update_cache = notificare adevărată: Start Nginx - name: name = nginx state = a început
Playbook-ul are o secțiune gazdă unde specificați gazde din fișierul inventar. În acest caz, numele grupului este "mai amuzant". Apoi, există o secțiune de sarcini cu două sarcini care instalează Nginx și Python 3. În cele din urmă, există o secțiune de handlers unde Nginx este pornit după instalare.
Puteți rula playbook-uri cu ansiblu-playbook comanda. Încă mai trebuie să furnizați un fișier de inventar și un manual de redare pe care doriți să îl executați. Salvați manualul într-un fișier numit "playbook.yml" din directorul dvs. de lucru. Hai sa incercam:
an-playbook -i găzduiește playbook.yml PLAY ******************************************** *********************************** SARCINA [configurare] *********** ************************************************** ****** ok: [moe] ok: [curat] SARCINA [Instalați Nginx] ****************************** ****************************** fatal: [moe]: FAILED! => "schimbat": false, "eșuat": true, "msg": "Nu a reușit blocarea apt pentru funcționarea exclusivă" fatal: [curly]: FAILED! => "schimbat": false, "eșuat": true, "msg": "Nu a reușit blocarea apt pentru funcționarea exclusivă" PLAY RECAP ******************* ************************************************** curat: ok = 1 schimbat = 0 nerealizabil = 0 eșuat = 1 moe: ok = 1 schimbat = 0 nerealizabil = 0 eșuat = 1
Oh nu. Ce s-a întâmplat? Anless oferă un mesaj de eroare decent: "Nu a reușit blocarea apt pentru funcționarea exclusivă". Multe playbookuri vor necesita privilegii sudo. Acest manual de joc nu este o excepție. Pentru a rula manualul cu privilegii sudo, trebuie doar să adăugați --sudo steag:
an-playbook -i găzduiește playbook.yml --sudo PLAY ***************************************** ************************************** SARCINA [configurare] ******** ************************************************** ********* ok: [buclat] ok: [moe] SARCINA [Instalați Nginx] *************************** ********************************* schimbat: [moe] schimbat: [curly] SARCINA [Instalați Python 3] * ************************************************** ***** schimbat: [moe] schimbat: [curly] RUNNING HANDLER [Start Nginx] ***************************** ********************* schimbat: [moe] schimbat: [curat] PLAY RECAP ***************** ************************************************** ** curly: ok = 4 schimbat = 3 unreachable = 0 eșuat = 0 moe: ok = 4 schimbat = 3 nerealizabil = 0 eșuat = 0
Ansible este idempotent, ceea ce înseamnă că dacă ceva este deja în starea dorită, atunci Ansible îl va lăsa singur. În ieșirea din ansiblu-playbook, puteți vedea ce sarcini au reușit sau au eșuat și ce gazde au fost modificate.
Să începem din nou același manual. Nimic nu trebuie schimbat:
an-playbook -i găzduiește playbook.yml --sudo PLAY ***************************************** ************************************** SARCINA [configurare] ******** ************************************************** ********* ok: [moe] ok: [curly] SARCINA [Instalați Nginx] *************************** ********************************* ok: [buclat] ok: [moe] SARCINA [Instalați Python 3] * ************************************************** ***** ok: [buclat] ok: [moe] PLAY RECAP ********************************* ************************************ curly: ok = 3 schimbat = 0 nerealizabil = 0 esuat = 0 moe: ok = 3 modificat = 0 nerealizabil = 0 eșuat = 0
Înainte de Ansoft 2.0, jocul este executat într-o manieră liniară, sarcină pe sarcină. Toate gazdele țintă au executat prima sarcină. Doar atunci când toate gazdele au fost terminate cu prima sarcină, ar putea să înceapă cu a doua sarcină.
Ansible 2.0 a adăugat conceptul de strategii de rulare. Există în prezent două strategii: strategia "liniară" pe care am descris-o mai sus, strategia implicită și strategia "liberă" în care gazdele sunt libere să execute sarcinile din agenda de joc încă în ordine, dar nu în bloc cu alte gazde.
Acest lucru ar putea fi util dacă sute de gazde au nevoie să descarce mai multe fișiere de pe unele servere FTP. Prima gazdă poate termina descărcarea primului fișier și trecerea la următorul, în timp ce alte gazde sunt încă ocupate să descarce primul fișier. Până când ceilalți gazde ajung să descarce următorul fișier, prima gazdă a fost deja terminată și există mai puține dispute.
Strategia gratuită pare superioară în majoritatea situațiilor. Doar adăugați a strategie: gratuit pereche cheie-valoare în manual.
- gazde: toate strategia: sarcini gratuite: ...
O altă caracteristică nouă a lui 2.0 este blocurile. Blocurile vă permit să grupați sarcinile împreună. Acest lucru este foarte util dacă aveți sarcini care trebuie executate numai într-o anumită condiție. Anterior, a trebuit să faceți acest lucru pentru fiecare activitate separat.
--- - gazdă: toate sarcinile: - debug: msg = "Task 1 here" când: ansible_distribution == 'Ubuntu' - debug: msg = "Task 2 here" când: ansible_distribution == 'Ubuntu' - debug: msg = "Task 3 here "când: ansible_distribution == 'Ubuntu'
Cu blocuri, puteți grupa toate aceste sarcini de depanare împreună și puneți condiția "când" la nivel de bloc.
- gazdă: toate sarcinile: - bloc: - debug: msg = "Task 1 here" - debug: msg = "Task 2 here - debug: msg =" Task 3 here "
Ansible comunică cu mașinile la distanță peste SSH, dar playbookurile pot conține secrete precum numele de utilizator, parolele și cheile API. Deoarece, de obicei, stocați cărți de redare în sistemele de control sursă, cum ar fi git, aceste informații vor fi vizibile pentru oricine care are acces la citire.
Ansible ajută la programul anormal care vă permite să creați, să editați și să copiați fișierele criptate. Aceste fișiere pot fi decriptate în timp ce rulează playbook-ul prin furnizarea unei parole. Dacă adăugați --bolta-cere-pass steagul la playbook-ul ansible, atunci vă va solicita parola pentru seif.
Alternativ, puteți adăuga --bolta-parolă-fișier și Ansible va citi parola din fișierul dvs. Dacă utilizați fișierul de parolă, nu îl păstrați în controlul sursei!
Acum, puteți salva în siguranță fișierele criptate în controlul sursă și nu vă faceți griji că cineva vă va găsi secrete. Trebuie să gestionați cu atenție parola pentru seif. Dacă îl pierdeți, nu veți putea să decriptați fișierele din seif.
Ansible este un instrument excelent. Este ușor. Poate fi folosit interactiv cu comenzile ad-hoc, și se calculează foarte bine sistemelor masive. De asemenea, are o mulțime de impuls și o mare comunitate. Dacă gestionați sau chiar pur și simplu lucrați cu servere de la distanță, doriți Ansible.
Rămâi acordat pentru partea a doua.
