Puppet este un tool pentru gestiunea configuratiei unui sistem. Pentru descrierea configuratiilor foloseste un limbaj declarativ. Puppet poate gestiona atat sisteme Linux, cat si Windows.

Puppet abstractizeaza majoritatea entitatilor din sistem prin resurse. De exemplu, fiecare serviciu, fie ca este pornit sau oprit, este vazut ca o resursa.

Folositi comanda puppet resource service pentru a inspecta serviciile de sistem din perspectiva Puppet:

[root@learn ~]# puppet resource service
service { 'abrt-ccpp':
  ensure => 'running',
  enable => 'true',
}
service { 'abrt-oops':
  ensure => 'stopped',
  enable => 'false',
}
service { 'abrtd':
  ensure => 'running',
  enable => 'true',
}
service { 'acpid':
  ensure => 'running',
  enable => 'true',
}
...

Semnificatia comenzii puppet resource service este urmatoarea:

• comanda puppet este folosita pentru accesarea majoritatii functiilor oferite de Puppet;
• subcomanda resource interactioneaza cu resursele “vazute” de Puppet;
• parametrul service reprezinta tipul resurselor ce vor fi inspectate.

In afara de servicii, si alte entitati din sistem sunt abstractizate prin resurse. Spre exemplu:

• utilizatori
• fisiere sau directoare
• pachete (software)

Afisati resursa ce descrie contul utilizatorului root, folosind comanda puppet resource user root.

[root@learn ~]# puppet resource user root
user { 'root':
  ensure           => 'present',
  comment          => 'root',
  gid              => '0',
  home             => '/root',
  password         => '$1$jrm5tnjw$h8JJ9mCZLmJvIxvDLjw1M/',
  password_max_age => '99999',
  password_min_age => '0',
  shell            => '/bin/bash',
  uid              => '0',

Structura resursei este data de urmatoarele elemente:

• Tipul resursei: in cazul nostru, user;
• Numele resursei: 'root';
• Atributele resursei: ensure, comment, gid, home etc.;
• Fiecare atribut are o valoare.

Sintaxa de mai sus constituie “declararea unei resurse”.

In afara de servicii si utilizatori, Puppet implementeaza multe alte tipuri de resurse. Pentru a le lista, folositi comanda puppet describe –list:

[root@learn ~]# puppet describe --list
These are the types known to puppet:
anchor          -  A simple resource type intended to be used a ...
augeas          -  Apply a change or an array of changes to the ...
computer        - Computer object management using DirectorySer ...
cron            -  Installs and manages cron jobs
exec            - Executes external commands
file            - Manages files, including their content, owner ...
file_line       -  Ensures that a given line is contained withi ...
filebucket      -  A repository for storing and retrieving file ...
firewall        -  This type provides the capability to manage  ...
firewallchain   -  This type provides the capability to manage  ...
group           - Manage groups
...

Folosind comanda puppet resource putem crea si resurse noi. Sintaxa generala este:

puppet resource type name attr1=val1 attr2=val2 …

Dorim sa cream utilizatorul gigel astfel incat:

• sa aiba directorul home in /home/gigel;
• sa aiba ca shell default /bin/sh.

Comanda Puppet corespunzatoare este:

[root@learn ~]# puppet resource user gigel ensure=present shell="/bin/sh" home="/home/gigel"
Notice: /User[gigel]/ensure: created
user { 'gigel':
  ensure => 'present',
  home   => '/home/gigel',
  shell  => '/bin/sh',
}

Inspectati fisierul /etc/passwd si verificati ca utilizatorul a fost creat.

Pentru a sterge o resursa, atributul ensure al acesteia trebuie setat la valoarea absent.

De exemplu, pentru a sterge utilizatorul gigel creat anterior:

[root@learn ~]# puppet resource user gigel ensure=absent
Notice: /User[gigel]/ensure: removed
user { 'gigel':
  ensure => 'absent',
}

Verificati, din nou, in /etc/passwd faptul ca utilizatorul a fost sters.

Cu toate ca putem crea, modifica sau sterge resurse folosind comenzi de tip puppet resource, aceasta nu este o solutie potrivita pentru situatii complexe.

O solutie mai buna consta in:

• declararea resurselor in fisiere (text);
• efectuarea modificarilor descrise in fisiere folosind Puppet.

Fisierele ce contin declarari de resurse Puppet se numesc manifeste si au, de obicei, extensia .pp.

Vom scrie un manifest care sa descrie o resursa de tip fisier. Fisierul va avea urmatoarele proprietati:

• nume si cale: /tmp/my_file;
• drepturi de acces: 0640;
• continut: “File created using Puppet”;

Declararea resursei va arata astfel:

file {'my_file':
  path    => '/tmp/my_file',
  ensure  => present,
  mode    => 0640,
  content => "File created using Puppet.",
}

Salvati codul de mai sus intr-un fisier manifest numit my_file_manif.pp.

Aplicarea unui manifest se executa folosind comanda puppet apply:

[root@learn ~]# puppet apply my_file_manif.pp
Notice: Compiled catalog for learn.localdomain in environment production in 0.18 seconds                             
Notice: /Stage[main]//File[my_file]/ensure: created                                                                  
Notice: Finished catalog run in 0.38 seconds                                                                         

Verificati ca fisierul a fost creat, iar continutul si drepturile de acces sunt corecte.

Incercati sa aplicati din nou manifestul:

[root@learn ~]# puppet apply my_file_manif.pp
Notice: Compiled catalog for learn.localdomain in environment production in 0.16 seconds
Notice: Finished catalog run in 0.38 seconds

Observati ca daca resursa este deja in starea descrisa de manifest, Puppet nu mai executa nici o actiune.

Modificati drepturile de acces ale fisierului la 755, apoi aplicati din nou manifestul:

[root@learn ~]# chmod 755 /tmp/my_file 
[root@learn ~]# puppet apply my_file_manif.pp
Notice: Compiled catalog for learn.localdomain in environment production in 0.18 seconds
Notice: /Stage[main]//File[my_file]/mode: mode changed '0755' to '0640'
Notice: Finished catalog run in 0.38 seconds

Modificati continutul fisierului, apoi aplicati din nou manifestul:

[root@learn ~]# echo "This is not my file" > /tmp/my_file 
[root@learn ~]# puppet apply my_file_manif.pp
Notice: Compiled catalog for learn.localdomain in environment production in 0.18 seconds
Notice: /Stage[main]//File[my_file]/content: content changed '{md5}7225302b0d15d4a2562c2ab55e45d4cc' to '{md5}b4fdf30d694de5a5d7fe7a50cda27851'
Notice: Finished catalog run in 0.41 seconds

Observati ca daca atributele resursei difera de cele descrise in manifest, aplicarea manifestului readuce resursa in starea dorita.

Atributul ensure specifica de cele mai multe ori daca resursa:

• trebuie sa existe (ensure ⇒ present);
• trebuie sa NU existe (ensure ⇒ absent).

Unele tipuri de resurse definesc stari aditionale pentru acest atribut. Resursele de tip file pot avea, in plus, urmatoarele valori pentru ensure:

• directory
• link
• file

Definiti un manifest care sa creeze un link simbolic la fisierul /tmp/my_file.

Intr-un manifest, definiti o resursa de tip “cheie autorizata SSH”.

Resursa trebuie sa permita autentificarea utilizatorului student de pe masina fizica, in contul utilizatorului root de pe masina virtuala, fara parola.

Un manifest Puppet poate contine declarari pentru mai multe resurse, insa ordinea in care sunt aplicate nu este bine definita.

Sunt cazuri in care trebuie sa ne asiguram ca o resursa este aplicata inaintea alteia (de exemplu, un pachet este instalat inaintea pornirii serviciului).

In aceste situatii, trebuie sa definim dependente intre resurse.

Modificam manifestul creat anterior astfel:

file {'my_file':
  path    => '/tmp/my_file',
  ensure  => present,
  mode    => 0640,
  content => "File created using Puppet.",
}

notify {'my_notify':
  message => "File /tmp/my_file has been synced",
  require => File['my_file'],
}

• Resursa de tip notify defineste un mesaj ce va fi afisat in momentul cand declaratia sa este evaluata;
• Dependenta intre resurse este definita prin atributul require. In cazul de fata, resursa my_file este evaluata inaintea resursei my_notify.

Modificati fisierul /tmp/my_file, apoi aplicati manifestul de mai sus. Observati ordinea in care resursele sunt evaluate.

O sintaxa echivalenta ar fi folosirea parametrului before in resursa my_file:

file {'my_file':
  path    => '/tmp/my_file',
  ensure  => present,
  mode    => 0640,
  content => "File created using Puppet.",
  before  => Notify['my_notify'],
}

notify {'my_notify':
  message => "File /tmp/my_file has been synced",
}

Pentru unele resurse are sens actiunea de “refresh” (de exemplu, un serviciu care trebuie repornit).

Daca dorim ca, in plus fata de dependenta intre resurse, sa facem “refresh” pentru a doua resursa, cand prima resursa este modificata, trebuie:

• sa folosim notify in loc de before, sau
• sa folosim subscribe in loc de require.

Un exemplu ar fi repornirea serviciului SSH atunci cand fisierul sau de configurare este modificat:

file { '/etc/ssh/sshd_config':
  ensure => file,
  mode   => 600,
  source => '/root/examples/sshd_config',
}
service { 'sshd':
  ensure    => running,
  enable    => true,
  subscribe => File['/etc/ssh/sshd_config'],
}

Creati un manifest cu codul de mai sus, apoi modificati fisierul /etc/ssh/sshd_config si aplicati manifestul.

In locul atributelor before / require sau notify / subscribe putem folosi operatorul →, respectiv ~>.

Exemplu:

file {'my_file':
  path    => '/tmp/my_file',
  ensure  => present,
  mode    => 0640,
  content => "File created using Puppet.",
}
->
notify {'my_notify':
  message => "File /tmp/my_file has been synced",
}

In multe situatii, Puppet este folosit pentru a ne asigura ca un anumit serviciu de sistem este instalat, pornit si are configuratia corecta.

Implementarea se poate realiza folosind trei resurse:

• package
• file
• service

Intre primele doua avem o relatie de tip “before / require”, iar intre ultimele doua o relatie de tip “notify / subscribe”.

Creati urmatorul manifest care implementeaza acest design pattern pentru serviciul SSH, apoi aplicati manifestul.

package { 'openssh-server':
  ensure => present,
}
->
file { '/etc/ssh/sshd_config':
  ensure => file,
  mode   => 600,
  source => '/root/examples/sshd_config',
}
~>
service { 'sshd':
  ensure     => running,
  enable     => true, 
}

Modificati diverse stari ale tripletului “package / file / service”, apoi reaplicati manifestul. De exemplu:

• dezinstalati pachetul;
• modificati fisierul de configurare;
• opriti serviciul.

Creati un manifest de tip “package / file / service” pentru serviciul Apache.

Pentru a defini variabile in Puppet, folosim sintaxa $variabila, atat pentru atribuire, cat si pentru referentiere.

Rescriem manifestul pentru fisierul my_file, definind continutul fisierului intr-o variabila:

$my_content = "File created using Puppet."

file {'my_file':
  path    => '/tmp/my_file',
  ensure  => present,
  mode    => 0640,
  content => $my_content,
}

In afara de variabilele definite de utilizator, Puppet defineste si anumite variabile de sistem. Acestea se numesc facts.

Pentru a vizualiza toate aceste variabile, folosim comanda facter:

[root@learn ~]# facter 
architecture => i386
augeasversion => 1.1.0
bios_release_date => 12/01/2006
bios_vendor => innotek GmbH
bios_version => VirtualBox
blockdevice_sda_model => VBOX HARDDISK
blockdevice_sda_size => 8589934592
blockdevice_sda_vendor => ATA
blockdevices => sda
...

Un exemplu de folosire a variabilelor de sistem este luarea anumitor decizii in functie de valoarea acestora.

Urmatorul manifest se asigura ca serviciul NTP:

• este pornit daca masina este fizica;
• este oprit daca masina este virtuala.

Decizia se ia in functie de valoarea variabile de sistem $is_virtual.

if str2bool("$is_virtual") {
  service {'ntpd':
    ensure => stopped,
    enable => false,
  }
}
else {
  service { 'ntpd':
    name       => 'ntpd',
    ensure     => running,
    enable     => true,
    hasrestart => true,
    require => Package['ntp'],
  }
}

Aplicati manifestul si observati starea serviciului NTP.

Mai intai, dezinstalati serverul de NTP din masina virtuala.

Apoi, scrieti un manifest care:

• sa instaleze pachetul pentru serverul NTP;
• sa se asigure ca serviciul NTP este pornit (numele serviciului difera, in functie de distributia de Linux);
• sa se asigure ca fisierul de configurare este cel corect (in functie de distributie).

Folositi structura conditionala case.

Resursele Puppet se pot declara si intr-un fisier manifest special, numit “site manifest”: /etc/puppetlabs/puppet/manifests/site.pp.

Acesta are semnificatia de manifest global si este folosit de agentul Puppet pentru a gestiona configuratia unui sistem in mod unitar.

Adaugati continutul manifestului pentru seriviciul SSH creat la task-ul 03 in “site manifest”.

Apoi:

• dezactivati, din /etc/ssh/sshd_config login-ul pentru root;
• restartati serviciul SSH;
• deconectati-va de la masina virtuala;
• verificati ca nu va mai puteti conecta prin SSH.

Conectati-va la consola web a Puppet: https://10.0.0.2/ (folositi user-ul puppet@example.com si parola learningpuppet).

Apoi, fortati agentul Puppet sa re-ruleze pentru a reaplica site manifest-ul.

Verificati ca va puteti conecta din nou prin SSH.