En este tutorial, explicaré los recursos, manifiestos, módulos y clases de Puppet con ejemplos. Además, asumo que ya tiene instalados los nodos maestro/agente de Puppet y listos para usar. Para usar Puppet, debe comprender cómo maneja los recursos Puppet y cómo se crean el manifiesto y los módulos.
Requisitos previos:
Como dije anteriormente, debe tener instalados y configurados los nodos Puppet Master y Agent.
Lenguaje específico de dominio declarativo (DSL) de Puppet
- Puppet tiene su propio lenguaje específico de dominio declarativo que define ESTADOS de un sistema.
- El código de marionetas está escrito en un archivo llamado MANIFESTS y guardado con extensión .pp (por ejemplo, sitio.pp es un archivo de manifiesto principal)
- El código de marioneta contiene RECURSOS que afectan elementos del sistema (como archivo, paquete, servicio, usuario, host, interfaz, exec, etc.). Los recursos son la unidad fundamental de las configuraciones del sistema y cada recurso describe un aspecto del sistema.
- Los recursos se agrupan en CLASES ( bloque con nombre de códigos Puppet) que se almacenan (organizan) en MÓDULOS y no se usan hasta que se invocan.
- Puppet Master crea un CATALOGO (generado en base al código y los datos de Puppet) y los clientes los aplican.
Veamos los términos de Puppet en detalle.
Recursos
Un recurso describe algo sobre el estado del sistema. Por ejemplo, si existe un determinado usuario o archivo, si un servicio debe estar ejecutándose o habilitado, o si debe instalarse un paquete.
Formato del recurso:
resource_type { 'name_of_the_resource':
argument => value,
other_arg => value,
}
Ejemplo 1:
file { 'test':
path => '/tmp/test',
content => 'An example content',
} Ejemplo 2:
package { 'ntp':
ensure => present,
} Ejemplo 3:
service { 'ntpd':
ensure => running,
enable => true,
} Aquí hay un comando para enumerar los tipos de recursos en 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
Manifiestos
Como se dijo anteriormente, el código de Puppet está escrito en un archivo de Manifiesto con extensión .pp . El archivo de manifiesto principal predeterminado se encuentra en:
# vim /etc/puppetlabs/code/environments/production/manifests/site.pp
Se pueden crear más archivos de manifiesto en /etc/puppetlabs/code/environments/production/manifests/
Clases
Las clases contienen bloques de código que se pueden invocar desde cualquier parte del código. Las clases proporcionan la facilidad de reutilización de código. Si conoce lenguajes de programación como Java o C++, entonces definir la clase en Puppet es lo mismo.
class class_name {
::::::::::Puppet code goes here:::::::::
} Ahora, la clase anterior se puede incluir en un código Puppet como se muestra a continuación:
include class_name
Módulos
Los módulos ayudan a organizar un conjunto de manifiestos. Se puede agregar un módulo en /etc/puppetlabs/code/environments/production/modules. Un gran código de Puppet puede distribuirse en múltiples manifiestos y organizarse mediante módulos (en la parte inferior de esta publicación, aprenderá cómo instalar, configurar e iniciar el servicio Apache, donde cada una de estas tareas se divide en diferentes clases).
Bueno, intente crear un manifiesto para realizar una operación simple.
Mi primer manifiesto en Puppet
Ejemplo 1:Creación de un archivo nuevo (en site.pp)
Paso 3: Editar sitio.pp – archivo de manifiesto principal. Si no encuentra uno, créelo.
# vim site.pp
file { "/tmp/myFile":
ensure => "present",
owner => "root",
group => "root",
mode => "644",
content => "This is my first manifest to create a file in temp directory",
} En el código anterior, hemos utilizado archivo tipo de recurso, con argumentos como garantizar , propietario , grupo , modo y contenido . El archivo se creará en /tmp .
Paso 5 :Ahora el archivo de manifiesto está listo. Pase al nodo Puppet Agent y ejecute el siguiente comando.
[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 El resultado anterior dice que se ha aplicado el catálogo.
Nota :Los agentes de Puppet se pondrán en contacto automáticamente con el servidor de Puppet para recibir un catálogo para configurarse ellos mismos. Pero si no desea esperar la sincronización automática, puede ejecutar el comando anterior.
Paso 6 :compruebe si el archivo se ha creado con los contenidos necesarios.
# ls /tmp/myFile /tmp/myFile
# more /tmp/myFile This is my first manifest to create a file in temp directory
Creando tu primer Módulo
Creemos un módulo que instalará el servidor web Apache en los nodos del agente.
# cd /etc/puppetlabs/code/environments/production/modules
Paso 2 :Vamos a crear un módulo llamado httpd . Para hacer eso, usaremos PuppetForge – lo que requiere que se siga una convención de nomenclatura. Por ejemplo,
organizationName-moduleName
Como estamos instalando el servidor web Apache, el paquete a instalar es httpd y mi convención de nomenclatura será la que se muestra a continuación:
mypuppetorg-httpd
Paso 3 :Ejecute el siguiente comando
# /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 Paso 4 :Se creará un módulo. Por ejemplo, httpd y su estructura es la siguiente:
# ls httpd/ examples Gemfile manifests metadata.json Rakefile README.md spec
Paso 5 :Personaliza el módulo
El paso 4 creará una estructura de directorio de módulos y un archivo de manifiesto principal (para el módulo) llamado init.pp . Simplemente abriremos el archivo para ver cómo se ve y al final del archivo, encontrará un httpd vacío. clase.
class httpd {
} Paso 6 :Vamos a crear una clase separada para instalar (install.pp), configurar (configure.pp) e iniciar (start.pp) el servicio Apache.
Creando una subclase para instalar Apache: Crearemos un nuevo archivo de manifiesto llamado install.pp (nombre de módulo de clase::instalar)
# pwd /etc/puppetlabs/code/environments/production/modules/httpd
# vim manifests/install.pp
Copie y pegue el siguiente código:
# == Class: httpd::install
class httpd::install inherits httpd {
package { 'httpd':
ensure => installed,
}
} Aquí, la subclase 'instalar ‘ heredará la clase principal httpd . Además, busque la sintaxis paquete , lo que significa el tipo de marioneta y garantizar atributo asegura que dicho paquete está instalado.
Creación de una subclase para configurar httpd (configure.pp – class modulename::configure)
# pwd /etc/puppetlabs/code/environments/production/modules/httpd
# vim manifests/configure.pp
Copie y pegue el siguiente código para asegurarse de que httpd.conf el archivo está debidamente protegido.
class httpd::configure inherits httpd{
file { '/etc/httpd/conf/httpd.conf':
ensure => file,
owner => 'root',
group => 'root',
mode => '0644',
}
} Creando una subclase para iniciar httpd servicio (start.pp – class modulename::start):
# pwd /etc/puppetlabs/code/environments/production/modules/httpd
# vim manifests/start.pp
Copie y pegue el siguiente código:
class httpd::start inherits httpd{
service { 'httpd':
ensure => running,
enable => true,
hasstatus => true,
hasrestart => true,
require => Package['httpd'],
}
} Ahora, tienes las subclases creadas.
- instalar.pp – para instalar httpd paquete
- configure.pp – para configurar los permisos adecuados para httpd.conf archivo
- inicio.pp – para habilitar e iniciar el httpd servicio.
Paso 7: Ahora deberíamos dejar que la clase principal httpd saber acerca de las subclases (instalar , configurar y empezar ). Para hacerlo, simplemente abra la clase principal del módulo e incluya las subclases.
# vim manifests/init.pp
La declaración de inclusión es la siguiente:
class httpd {
include httpd::install
include httpd::configure
include httpd::start
} Paso 8: Ya hemos terminado con las clases. Pero debe decirle a Puppet en qué nodos se debe implementar el catálogo. Así es como puedes hacerlo.
Vaya al archivo de manifiesto principal (en /etc/puppetlabs/code/environments/production/manifests )
# vim site.pp
Copie y pegue el siguiente código. Aquí httpd es la clase principal creada para administrar el servidor web Apache.
node default {
include httpd
} ¡Eso es todo! Puede esperar hasta que los nodos de Puppet Agent descarguen el catálogo automáticamente o puede activarlo manualmente. Vaya al nodo Puppet Agent y ejecute el siguiente comando.
Paso 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
Dado que este es su primer módulo, es posible que desee verificar si el paquete está instalado y si el servicio se inició correctamente.
[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
Conclusión
¡Eso es todo! Ahora ya sabe cómo escribir sus propios módulos de Puppet para instalar, configurar y habilitar el servicio. Sin embargo, este tutorial es solo un punto de partida para hacer maravillas con Puppet. ¡Felices marionetas!