Tutorial marionetă pentru începători: ce este marioneta și cum se folosește?

Înainte de a învăța Puppet, să înțelegem:

Ce este Managementul configurației?

Managementul configurației este procesul de menținere a software-ului și a sistemelor informatice (de exemplu, servere, stocare, rețele) într-o stare cunoscută, dorită și consecventă. De asemenea, permite accesul la o înregistrare istorică precisă a stării sistemului în scopuri de management de proiect și audit.

Administratorii de sistem efectuează în mare parte sarcini repetitive, cum ar fi instalarea serverelor, configurarea acelor servere etc. Acești profesioniști pot automatiza această sarcină prin scrierea de scripturi.

Cu toate acestea, este o muncă dificilă atunci când lucrează la o infrastructură masivă. Instrumentul de gestionare a configurației, cum ar fi o marionetă, a fost introdus pentru a rezolva astfel de probleme.

Ce este Puppet?

Marionetă este un instrument de management al sistemului pentru centralizarea și automatizarea procesului de management al configurației. Puppet este, de asemenea, folosit ca instrument de implementare a software-ului. Este un software de gestionare a configurației open-source utilizat pe scară largă pentru configurarea serverului, managementul, implementarea și orchestrarea diferitelor aplicații și servicii în întreaga infrastructură a unei organizații.

Puppet este special conceput pentru a gestiona configurația Linux și Windows sisteme. Este scris în Ruby și își folosește unicul Dprincipal Specific Llimba (DSL) pentru a descrie configurația sistemului.

Care sunt versiunile Puppet?

Puppet vine în două versiuni:

• Păpușă cu sursă deschisă: Este o versiune de bază a instrumentului de gestionare a configurației Puppet, care este cunoscut și sub numele de Open Source Puppet. Este disponibil direct de pe site-ul Puppet și este licențiat sub sistemul Apache 2.0.

• Întreprindere de păpuși: versiune comercială care oferă funcții precum raportarea conformității, orchestrarea, controlul accesului bazat pe roluri, GUI, API și instrumente de linie de comandă pentru gestionarea eficientă a nodurilor.

Ce poate face Puppet?

De exemplu, ai o infrastructură cu aproximativ 100 de servere. În calitate de administrator de sistem, este rolul tău să te asiguri că toate aceste servere sunt mereu actualizate și funcționează cu funcționalitate completă.

Pentru a face acest lucru, puteți folosi Puppet, care vă permite să scrieți un cod simplu care poate fi implementat automat pe aceste servere. Acest lucru reduce efortul uman și face ca procesul de dezvoltare să fie rapid și eficient.

Marioneta îndeplinește următoarele funcții:

• Puppet vă permite să definiți configurații distincte pentru fiecare gazdă.
• Instrumentul vă permite să monitorizați în mod continuu serverele pentru a confirma dacă configurația necesară există sau nu și nu este modificată. Dacă configurația este modificată, instrumentul Puppet va reveni la configurația predefinită pe gazdă.
• De asemenea, oferă control asupra întregului sistem configurat, astfel încât o schimbare centralizată este efectuată automat.
• Este, de asemenea, folosit ca instrument de implementare, deoarece implementează automat software-ul în sistem. Acesta implementează infrastructura ca cod, deoarece politicile și configurațiile sunt scrise ca cod.

Puppet DSL și paradigme de programare

Înainte de a învăța Puppet DSL, să înțelegem paradigmele de programare:

O paradigmă de programare este un stil pe care îl utilizați în programarea computerelor.

Patru tipuri de paradigme sunt:

• Imperativ.
• Declarativ.
• Funcțională (care este considerată un subset al acelei paradigme declarative)
• Orientat pe obiecte.

Ne vom concentra pe imperativ și declarativ.

Paradigme imperative

Această paradigmă de programare exprimă logica unui calcul (Ce trebuie făcut) și descrie fluxul său de control (Cum se face)

Exemplu:

Să presupunem că mergi la birou, rezervi un taxi și începi să dai șoferului instrucțiuni pas cu pas până ajungi la birou. Specificarea ce să faci și cum să faci este un stil imperativ.

Paradigme declarative

Această paradigmă de programare exprimă logica unui calcul (Ce să faceți) fără a descrie fluxul său de control (Cum se face)

Exemplu:

Să presupunem că mergeți la biroul dvs., rezervați taxiul Uber și specificați destinația finală (Office). Specificarea a ceea ce se face nu cum se face este un stil declarativ.

Paradigmă	Ce sa fac	Cum să faci
imperativ	Da	Da
Declarativ	Da	Nu

Puppet folosește o paradigmă de programare declarativă

Puppet folosește o abordare de programare declarativă.

Exemplu: Creați un utilizator pe sistem:

Se poate face folosind modelul de programare imperativ printr-un script shell: Aici specificăm cum să creați utilizatorul și ce comenzi să folosiți pe sistem de operare.

Cu toate acestea, se poate face folosind modelul de programare declarativ cu doar câteva linii de cod marionetă, limbajul specific domeniului (DSL) Puppet și totuși obține același rezultat.

Modele de implementare a instrumentelor de management al configurației

Există două modele de implementare pentru instrumente de management al configurației :

• Model de implementare bazat pe push: inițiat de un nod principal.
• Model de implementare bazat pe tragere: inițiat de agenți.

Model de implementare bazat pe push

În acest model de implementare, serverul principal împinge configurațiile și software-ul către agenții individuali. După verificarea unei conexiuni securizate, comandantul execută comenzi de la distanță pe agenți. De exemplu, ansiblu și Stiva de sare.

Model de implementare bazat pe tragere.

În acest model de implementare, serverele individuale contactează un server principal, verifică și stabilesc o conexiune sigură, își descarcă configurațiile și software-ul și apoi se configurează în consecință - de exemplu, Puppet și Chef.

Cum funcționează Puppet?

Puppet se bazează pe un model de implementare Pull, în care nodurile de agent se înregistrează în mod regulat după fiecare 1800 secunde cu nodul master pentru a vedea dacă ceva trebuie actualizat în agent. Dacă ceva trebuie actualizat, agentul extrage codurile păpușilor necesare de la master și efectuează acțiunile necesare.

Să explicăm printr-un exemplu:

Exemplu: Configurare Master – Agent:

Master

O mașină bazată pe Linux cu software Puppet master instalat pe ea. Este responsabil pentru menținerea configurațiilor sub formă de coduri de păpuși. Nodul principal poate fi doar Linux.

Agenții

Mașinile țintă gestionate de o marionetă cu software-ul agent de marionetă instalat pe ele.

Agentul poate fi configurat pe orice sistem de operare acceptat, cum ar fi Linux sau Windows or Solaris sau Mac OS.

Comunicarea dintre master și agent se stabilește prin certificate securizate.

Comunicarea dintre Master și Agent

Pas 1) Odată ce conectivitatea este stabilită între agent și master, agentul Puppet trimite datele despre starea acestuia către serverul Puppet master. Acestea se numesc Fapte: Aceste informații includ numele de gazdă, detaliile kernelului, adresa IP, detaliile numelui fișierului etc...

Pas 2) Puppet Master folosește aceste date și alcătuiește o listă cu configurația care urmează să fie aplicată agentului. Această listă de configurare care trebuie efectuată pe un agent este cunoscută sub numele de a catalog. Acest lucru poate fi modificat, cum ar fi instalarea pachetului, upgrade-urile sau eliminările, crearea sistemului de fișiere, crearea sau ștergerea utilizatorilor, repornirea serverului, modificările configurației IP etc.

Pas 3) Agentul folosește această listă de configurații pentru a aplica orice modificări de configurare necesare pe nod.

În cazul în care nu există derive în configurație, Agent nu efectuează nicio modificare de configurare și lasă nodul să ruleze cu aceeași configurație.

Pas 4) Odată ce este finalizat, nodul raportează înapoi la puppet master indicând că configurația a fost aplicată și finalizată.

Blocuri de păpuși

Puppet oferă flexibilitatea de a integra Rapoarte cu instrumente terță parte folosind API-urile Puppet.

Sunt patru tipuri de blocuri de construcție Puppet

1. Resurse
2. Clase
3. Manifesta
4. Panouri

Resurse pentru păpuși

Puppet Resources sunt elementele de bază ale Puppet.

Resursele sunt funcții încorporate care rulează la capătul din spate pentru a efectua operațiunile necesare în marionetă.

Cursuri de păpuși

O combinație de resurse diferite poate fi grupată într-o singură unitate numită clasă.

Manifestul păpușilor

Manifest este un director care conține fișiere DSL marionete. Aceste fișiere au extensia .pp. Extensia .pp înseamnă program puppet. Codul păpușilor este format din definiții sau declarații ale claselor de păpuși.

Module de păpuși

Modulele sunt o colecție de fișiere și directoare, cum ar fi manifeste, definiții de clasă. Sunt unitățile reutilizabile și partajabile din Puppet.

De exemplu, MySQL modul de instalare și configurare MySQL sau modulul Jenkins pentru a gestiona Jenkins etc..

Tipuri de resurse Puppet

În general, un sistem este format din fișiere, utilizatori, servicii, procese, pachete etc. În Puppet, acestea se numesc resurse. Resursele sunt piatra de bază fundamentală în

Marionetă. Toate operațiunile asupra agenților păpuși sunt efectuate cu ajutorul resurselor păpușilor.

Resursele marionete sunt instrumentele gata făcute care sunt utilizate pentru a efectua diverse sarcini și operațiuni pe orice platformă acceptată. Putem folosi o singură resursă marionetă pentru a efectua o anumită sarcină sau putem folosi mai multe resurse marionete împreună pentru a realiza implementări de configurații complexe ale aplicațiilor.

Resursele pot avea diferite tipuri. Utilizări de păpuși resurse si tipuri de resurse pentru a descrie configurația unui sistem.

Există trei tipuri de resurse:

1. Miez marionetă sau tipuri de resurse încorporate.
2. Tipuri de resurse definite de marionete.
3. Tipuri de resurse personalizate pentru marionete.

Miez marionetă sau tipuri de resurse încorporate

Tipurile de resurse de bază sau încorporate sunt tipurile de resurse de păpuși prefabricate livrate cu software-ul pentru marionete. Toate tipurile de resurse de bază sau încorporate Puppet sunt scrise și întreținute de echipa Puppet.

Tipuri de resurse definite de marionete

Tipurile de resurse definite sunt tipuri de resurse ușoare scrise în limbajul declarativ Puppet folosind o combinație de tipuri de resurse existente.

Tipuri de resurse personalizate pentru marionete

Tipurile de resurse personalizate sunt tipuri de resurse complet personalizate scrise în Ruby.

Să explorăm tipurile de resurse pentru păpuși...

În terminal, tastați următoarea comandă pentru a afișa o listă de subcomenzi relevante pentru Puppet:

Puppet --help

În cazul nostru, ne interesează subcomanda „resursă” pe care îl vom folosi pentru a găsi informații despre tipurile de resurse de păpuși încorporate.

În terminal, tastați oricare dintre următoarele comenzi pentru a afișa o listă acțiuni asociat cu subcomanda păpuși „resursă„:

Puppet help resource		
Puppet resource --help		

În acest caz, avem resursă ca subcomanda si -tipuri ca acţiune.

Puppet are 49 de tipuri de resurse de bază încorporate.

În terminal, tastați următoarea comandă pentru a afișa o listă de tipuri de resurse de păpuși încorporate disponibile:

puppet resource –types

Fiecare tip acceptă o listă de atribute. Aceste atribute oferă o descriere detaliată pe care Puppet o folosește pentru a gestiona resursa.

Pentru a afla toate atributele asociate tipului de resursă păpușă, utilizați următoarea comandă:

puppet describe <resource type name>	

Parametrii vor lista toate atributele disponibile pentru acel tip de resursă.

păpușă descrie pachet

Este greu pentru o persoană nouă să înțeleagă și să relaționeze multe fișiere de cod de marionetă neadministrate. Aici avem nevoie de o grupare pentru a lega operațiunile. Scopul este de a rezolva o singură problemă, cum ar fi toate operațiunile necesare pentru a configura ssh pe un server sau serviciu ntp sau un server web complet sau un server de baze de date de la zero.

Ce sunt clasele de păpuși?

Clasele de păpuși sunt o colecție de resurse pentru păpuși grupate ca o singură unitate.

Puppet a introdus clase pentru a face structura reutilizabilă și organizată.

În primul rând, trebuie să definim o clasă folosind sintaxa definiției clasei; clasele trebuie să fie unice și pot fi declarate o singură dată cu același nume:

class <class-name> {
<Resource declarations>
}

Exemplu:

class ntpconfig {
    file {
        "/etc/ntp.conf": 
     ensure=> "present", content=> "server 0.centos.pool.ntp.org iburst\n",
    }
}

Până acum am definit doar clasa, dar nu am folosit-o nicăieri. Înseamnă că acest cod pe care l-am scris nu va fi niciodată executat decât dacă declarăm această clasă în altă parte.

Declarație de clasă

Pentru a utiliza o clasă definită în cod, utilizați include cuvinte cheie.

class ntpconfig {
    file {
        "/etc/ntp.conf": 
      ensure=> "present", 
      content=> "server 0.centos.pool.ntp.org iburst\n",
    }
}
include ntpconfig

Să înțelegem acest lucru cu un scenariu de caz real.

Instalare demonstrativă NTP

În primul rând, asigurați-vă că pachetul NTP nu este deja prezent pe server, următoarea comandă nu va returna nimic dacă telnetul nu este prezent pe server:

rpm -qa | grep -i ntp

După cum putem vedea, pachetul NTP este deja prezent pe server. Să eliminăm pachetul NTP existent:

yum remove ntp

După eliminarea pachetului, asigurați-vă că fișierul ntp.conf nu există:

ls -lrt /etc/ntp.conf

Verificați că serviciul ntp nu există, rulând următoarea comandă:

systemctl status ntp

Creați un nou fișier .pp pentru a salva codul. Din linia de comandă:

vi demontp.pp

Treceți în modul de inserare apăsând i de la tastatură.

Tastați următorul cod pentru a crea un fișier nou:

# Class Definition 
class ntpconfig {
    # Installing NTP Package 
  package {"ntp": 
    ensure=> "present",
    }
    # Configuring NTP configuration file 
  file {"/etc/ntp.conf": 
    ensure=> "present", 
    content=> "server 0.centos.pool.ntp.org iburst\n",
    }
    # Starting NTP services 
  service {"ntpd": 
    ensure=> "running",
    }
}

După terminarea editării: apăsați esc

Pentru a salva fișierul, apăsați :wq!

Următorul pas este să verifica dacă codul are erori de sintaxă. Executați următoarea comandă:

puppet parser validate demontp.pp

Asigurați-vă că ați trecut la rădăcină pentru a putea finaliza testul fără nicio eroare, executând comanda:

su root

Testare este următorul pas în procesul de creare a codului. Executați următoarea comandă pentru a efectua un test de fum:

Puppet applies demontp.pp --noop

Ultimul pas este să alerga marioneta în modul real și verificați rezultatul.

puppet apply demontp.pp

Puppet nu a interpretat nimic pentru că clasa demonstrativă a fost doar definit dar nu declarat.

Deci, până când nu declarați clasa de păpuși, codul nu va fi aplicat.

hai declara clasa demo în interiorul aceluiași cod folosind include numele clasei la sfarsitul codului:

# Class Definition 
class ntpconfig {
    # Installing NTP Package 
  package {"ntp": 
    ensure=> "present",
    }
    # Configuring NTP configuration file 
  file {"/etc/ntp.conf": 
    ensure=> "present", 
    content=> "server 0.centos.pool.ntp.org iburst\n",
    }
    # Starting NTP services 
  service {"ntpd": 
    ensure=> "running",
    }
}

# Class Declaration 
include ntpconfig

Din nou verifica dacă codul are erori de sintaxă. Executați următoarea comandă:

puppet parser validate demontp.pp

Asigurați-vă că ați trecut la rădăcină pentru a putea finaliza testul fără nicio eroare, executând comanda:

su root

Testarea este următorul pas în procesul de creare a codului. Executați următoarea comandă pentru a efectua un test de fum:

Puppet apply demontp.pp --noop

Ultimul pas este să alerga marioneta în modul real și verificați rezultatul.

puppet apply demontp.pp

De data aceasta, codul este aplicat deoarece clasa a fost definită și apoi declarată.

Asigurați-vă că ntp.conf există acum:

ls -lrt /etc/ntp.conf

Verificați că serviciul ntp a fost pornit rulând următoarea comandă:

systemctl status ntpd