In questo tutorial, spiegherò le risorse, i manifest, i moduli e le classi di Puppet con esempi. Inoltre, presumo che tu abbia già installato i nodi Puppet master/agent e pronti per l'uso. Per utilizzare Puppet, devi capire come il puppet gestisce le risorse e come vengono creati manifest e moduli.
Prerequisiti:
Come ho detto in precedenza, è necessario che i nodi Puppet Master e Agent siano installati e configurati.
Dichiarative Domain Specific Language (DSL) di Puppet
- Puppet ha un proprio linguaggio dichiarativo specifico del dominio che definisce gli STATI di un sistema.
- Il codice del pupazzo è scritto in un file chiamato MANIFESTS e salvato con estensione .pp (ad esempio, site.pp è un file manifest principale)
- Il codice del pupazzo contiene RISORSE che interessano elementi del sistema (come file, pacchetto, servizio, utente, host, interfaccia, exec ecc…). Le risorse sono l'unità fondamentale delle configurazioni di sistema e ogni risorsa descrive un aspetto del sistema.
- Le risorse sono raggruppate in CLASSI ( blocco denominato di codici Puppet) che sono archiviati (organizzati) in MODULI e non vengono utilizzati fino a quando non vengono invocati.
- Il burattinaio crea un CATALOGO (generato in base al codice e ai dati del pupazzo) e i client li applicano.
Vediamo in dettaglio i termini del pupazzo.
Risorse
Una risorsa descrive qualcosa sullo stato del sistema. Ad esempio, se esiste un determinato utente o file, se un servizio deve essere in esecuzione o abilitato o se deve essere installato un pacchetto.
Formato della risorsa:
resource_type { 'name_of_the_resource':
argument => value,
other_arg => value,
}
Esempio 1:
file { 'test':
path => '/tmp/test',
content => 'An example content',
} Esempio 2:
package { 'ntp':
ensure => present,
} Esempio 3:
service { 'ntpd':
ensure => running,
enable => true,
} Ecco un comando per elencare i tipi di risorse in Puppet:
# /opt/puppetlabs/puppet/bin/puppet resource --types augeas computer cron exec file filebucket group host interface k5login macauthorization mailalias maillist mcx mount nagios_command nagios_contact nagios_contactgroup nagios_host nagios_hostdependency nagios_hostescalation nagios_hostextinfo nagios_hostgroup nagios_service nagios_servicedependency nagios_serviceescalation nagios_serviceextinfo nagios_servicegroup nagios_timeperiod notify package resources router schedule scheduled_task selboolean selmodule service ssh_authorized_key sshkey stage tidy user vlan whit yumrepo zfs zone zpool
manifesti
Come detto in precedenza, il codice Puppet è scritto in un file manifest con estensione .pp . Il file manifest principale predefinito si trova in:
# vim /etc/puppetlabs/code/environments/production/manifests/site.pp
È possibile creare più file manifest in /etc/puppetlabs/code/environments/production/manifests/
Classi
Le classi contengono blocchi di codice che possono essere richiamati da qualsiasi punto del codice. Le classi forniscono la possibilità di riutilizzare il codice. Se conosci linguaggi di programmazione come Java o C++, definire la classe in Puppet è lo stesso.
class class_name {
::::::::::Puppet code goes here:::::::::
} Ora, la classe sopra può essere inclusa in un codice Puppet come di seguito:
include class_name
Moduli
I moduli aiutano a organizzare una serie di manifesti. Un modulo può essere aggiunto in /etc/puppetlabs/code/environments/production/modules. Un codice Puppet di grandi dimensioni può essere distribuito in più manifest e organizzato utilizzando i moduli (in fondo a questo post, imparerai come installare, configurare e avviare il servizio Apache, dove ciascuna di queste attività è suddivisa in classi diverse).
Bene, facci sapere prova a creare un manifest per eseguire una semplice operazione.
Il mio primo manifesto in Puppet
Esempio 1:creazione di un nuovo file (in site.pp)
Passaggio 1: Accedi a Puppet Server (Master Node) come utente privilegiato.
Passaggio 2: Vai a /etc/puppetlabs/code/environments/production/manifests
Passaggio 3: Modifica site.pp – file manifest principale. Se non ne trovi uno, crealo.
# vim site.pp
Passaggio 4: Scriviamo il codice Puppet per creare un file in /tmp/ nel nodo dell'agente burattino. Il codice è il seguente,
file { "/tmp/myFile":
ensure => "present",
owner => "root",
group => "root",
mode => "644",
content => "This is my first manifest to create a file in temp directory",
} Nel codice sopra, abbiamo usato file tipo di risorsa, con argomenti come assicura , proprietario , gruppo , modalità e contenuti . Il file verrà creato in /tmp .
Passaggio 5 :Ora il file manifest è pronto. Passa al nodo Puppet Agent ed esegui il comando seguente.
[Agent]# /opt/puppetlabs/puppet/bin/puppet agent -t
Info: Using configured environment 'production'
Info: Retrieving pluginfacts
Info: Retrieving plugin
Info: Caching catalog for puppetagent.test.in
Info: Applying configuration version '1471021726'
Notice: /Stage[main]/Main/File[/tmp/myFile]/ensure: defined content as '{md5}8eadb0a0feef0bc667702434f816d8e8'
Notice: Applied catalog in 0.09 seconds L'output sopra indica che il catalogo è stato applicato.
Nota :gli agenti Puppet contatteranno automaticamente il server Puppet per ricevere il catalogo per la configurazione autonoma. Ma se non vuoi aspettare la sincronizzazione automatica, puoi eseguire il comando precedente.
Passaggio 6 :controlla se il file è stato creato con i contenuti necessari.
# ls /tmp/myFile /tmp/myFile
# more /tmp/myFile This is my first manifest to create a file in temp directory
Creazione del tuo primo modulo
Creiamo un modulo che installerà il server web Apache sui nodi dell'agente.
Passaggio 1 :cambia la directory nella cartella dei moduli.
# cd /etc/puppetlabs/code/environments/production/modules
Passaggio 2 :Creiamo un modulo chiamato httpd . Per farlo, utilizzeremo PuppetForge – che richiede il rispetto di una convenzione di denominazione. Ad esempio,
organizationName-moduleName
Poiché stiamo installando il server web Apache, il pacchetto da installare è httpd e la mia convenzione di denominazione sarà quella mostrata di seguito:
mypuppetorg-httpd
Passaggio 3 :esegui il comando seguente
# /opt/puppetlabs/puppet/bin/puppet module generate mypuppetorg-httpd
We need to create a metadata.json file for this module. Please answer the
following questions; if the question is not applicable to this module, feel free
to leave it blank.
Puppet uses Semantic Versioning (semver.org) to version modules.
What version is this module? [0.1.0]
-->
Who wrote this module? [mypuppetorg]
-->
What license does this module code fall under? [Apache-2.0]
-->
How would you describe this module in a single sentence?
--> Installs Apache web server and configures it
Where is this module's source code repository?
-->
Where can others go to learn more about this module?
-->
Where can others go to file issues about this module?
-->
----------------------------------------
{
"name": "mypuppetorg-httpd",
"version": "0.1.0",
"author": "mypuppetorg",
"summary": "Installs Apache web server and configures it",
"license": "Apache-2.0",
"source": "",
"project_page": null,
"issues_url": null,
"dependencies": [
{"name":"puppetlabs-stdlib","version_requirement":">= 1.0.0"}
],
"data_provider": null
}
----------------------------------------
About to generate this metadata; continue? [n/Y]
--> Y
Notice: Generating module at /etc/puppetlabs/code/environments/production/modules/httpd...
Notice: Populating templates...
Finished; module generated in httpd.
httpd/Gemfile
httpd/Rakefile
httpd/examples
httpd/examples/init.pp
httpd/manifests
httpd/manifests/init.pp
httpd/spec
httpd/spec/classes
httpd/spec/classes/init_spec.rb
httpd/spec/spec_helper.rb
httpd/README.md
httpd/metadata.json Passaggio 4 :Verrà creato un modulo. Ad esempio, httpd e la sua struttura è la seguente:
# ls httpd/ examples Gemfile manifests metadata.json Rakefile README.md spec
Passaggio 5 :Personalizza il modulo
Il passaggio 4 creerà una struttura di directory del modulo e un file manifest principale (per il modulo) chiamato init.pp . Apriremo semplicemente il file per vedere come appare e alla fine del file troverai un httpd vuoto classe.
class httpd {
} Passaggio 6 :Creiamo una classe separata per l'installazione (install.pp), la configurazione (configure.pp) e l'avvio (start.pp) del servizio Apache.
Creazione di una sottoclasse per l'installazione di Apache: Creeremo un nuovo file manifest chiamato install.pp (class modulename::install)
# pwd /etc/puppetlabs/code/environments/production/modules/httpd
# vim manifests/install.pp
Copia e incolla il codice seguente:
# == Class: httpd::install
class httpd::install inherits httpd {
package { 'httpd':
ensure => installed,
}
} Qui, sottoclasse "installa ' erediterà la classe principale httpd . Inoltre, cerca la sintassi pacchetto , il che significa il tipo di pupazzo e assicura attributo garantisce che il pacchetto sia installato.
Creazione di una sottoclasse per la configurazione di httpd (configure.pp – class modulename::configure)
# pwd /etc/puppetlabs/code/environments/production/modules/httpd
# vim manifests/configure.pp
Copia e incolla il codice seguente per assicurarti che httpd.conf il file è adeguatamente protetto.
class httpd::configure inherits httpd{
file { '/etc/httpd/conf/httpd.conf':
ensure => file,
owner => 'root',
group => 'root',
mode => '0644',
}
} Creazione di una sottoclasse per avviare httpd servizio (start.pp – classe modulename::start):
# pwd /etc/puppetlabs/code/environments/production/modules/httpd
# vim manifests/start.pp
Copia e incolla il codice seguente:
class httpd::start inherits httpd{
service { 'httpd':
ensure => running,
enable => true,
hasstatus => true,
hasrestart => true,
require => Package['httpd'],
}
} Ora hai creato le sottoclassi.
- install.pp – per installare httpd pacchetto
- configura.pp – per configurare le autorizzazioni appropriate per httpd.conf file
- start.pp – per abilitare e avviare httpd servizio.
Passaggio 7: Ora dovremmo lasciare che la classe principale httpd per conoscere le sottoclassi (install , configura e inizia ). Per farlo, apri la classe principale del modulo e includi le sottoclassi.
# vim manifests/init.pp
L'istruzione Include è la seguente:
class httpd {
include httpd::install
include httpd::configure
include httpd::start
} Passaggio 8: Abbiamo finito con le classi ora. Ma devi dire a Puppet su quali nodi dovrebbe essere implementato il catalogo. Ecco come puoi farlo.
Vai al file manifest principale (sotto /etc/puppetlabs/code/environments/production/manifests )
# vim site.pp
Copia e incolla il codice sottostante. Qui httpd è la classe principale creata per la gestione del server web Apache.
node default {
include httpd
} Questo è tutto! Puoi attendere fino a quando i nodi Puppet Agent scaricano il catalogo automaticamente oppure puoi attivarlo manualmente. Vai al nodo Puppet Agent ed esegui il comando seguente.
Passaggio 9:
[Agent]# /opt/puppetlabs/puppet/bin/puppet agent -t Info: Using configured environment 'production' Info: Retrieving pluginfacts Info: Retrieving plugin Info: Caching catalog for puppetagent.test.in Info: Applying configuration version '1472036234' Notice: /Stage[main]/Httpd::Install/Package[httpd]/ensure: created Notice: /Stage[main]/Httpd::Configure/File[/etc/httpd/conf/httpd.conf]/mode: mode changed '0600' to '0644' Notice: /Stage[main]/Httpd::Start/Service[httpd]/ensure: ensure changed 'stopped' to 'running' Info: /Stage[main]/Httpd::Start/Service[httpd]: Unscheduling refresh on Service[httpd] Notice: Applied catalog in 5.88 seconds
Poiché questo è il tuo primo modulo, potresti voler verificare se il pacchetto è installato e il servizio è avviato correttamente.
[Agent]# rpm -qa|grep httpd httpd-tools-2.4.6-40.el7.centos.4.x86_64 httpd-2.4.6-40.el7.centos.4.x86_64
[Agent]# service httpd status Redirecting to /bin/systemctl status httpd.service httpd.service - The Apache HTTP Server Loaded: loaded (/usr/lib/systemd/system/httpd.service; enabled; vendor preset: disabled) Active: active (running) since Wed 2016-08-24 17:29:29 IST; 6min ago
Conclusione
Questo è tutto! Ora sai come scrivere i tuoi moduli Puppet per installare, configurare e abilitare il servizio. Tuttavia, questo tutorial è solo un punto di partenza per fare miracoli con Puppet. Buon burattino!