Hogar › Internet › Cómo utilizar el programa de velocidad del ventilador. Cómo configurar el programa SpeedFan. Opción de velocidad automática

Cómo utilizar el programa de velocidad del ventilador. Cómo configurar el programa SpeedFan. Opción de velocidad automática

No hace mucho, en las páginas de la revista, analizamos el sistema de gestión de configuración remota Cfengine para máquinas UNIX, que simplifica enormemente la vida de un administrador de sistemas al automatizar los pasos para configurar muchos nodos de red. Pero, por muy conveniente que sea Cfengine, tiene muchas desventajas que no tiene un sistema llamado Puppet.

Imagínese como un administrador de sistemas, responsable de mantener la funcionalidad de cientos de máquinas que ejecutan sistemas operativos tipo UNIX. Cada uno de ellos requiere configuración, actualización periódica y seguimiento, y se supone que muchos de ellos realizan funciones similares.

Dos tercios son estaciones de trabajo, algunos más son enrutadores y el resto son varios servidores web y almacenamiento de datos. Pregunta: ¿cómo gestionar todo este negocio? La respuesta más simple es simplemente conectarse a cada uno de ellos con usando SSH y contribuir cambios necesarios. Sin embargo, este método tiene dos problemas. En primer lugar, requiere mucha mano de obra. En segundo lugar, el administrador tendrá que realizar constantemente muchas acciones monótonas (por ejemplo, para actualizar OpenOffice.org en todas las estaciones de trabajo, deberá ejecutar los mismos comandos varias docenas de veces). Puede intentar evitar este problema escribiendo varios scripts que se conectarán a cada máquina y ejecutarán comandos preescritos. Pero aquí también te esperan problemas.

Los guiones habrá que modificarlos constantemente para adaptarlos a cada tarea; Los scripts deberán tener en cuenta las diferencias en los sistemas operativos y las versiones, y deberán depurarse durante mucho tiempo antes de aplicarse a las máquinas en ejecución. En general, no comme il faut. La respuesta correcta es utilizar los llamados sistemas de gestión de configuración remota, cuyos representantes más famosos son sistemas abiertos Cfengine y títere. Dichos sistemas asumen todas las responsabilidades para llevar la configuración de la máquina a el tipo correcto, requiriendo sólo una descripción del administrador estado final sistema en un lenguaje especial (por ejemplo, una descripción de qué paquetes deben instalarse en el sistema operativo, qué líneas deben agregarse a los archivos de configuración, qué comandos deben ejecutarse, etc.). Después de esto, todos los nodos recibirán información sobre el estado requerido del servidor y configurarán automáticamente el sistema. Gracias a este mecanismo, las máquinas nuevas se pueden configurar completamente sin intervención humana y las existentes se pueden reconfigurar agregando solo unas pocas líneas a la descripción del estado.

¿Marioneta?

Ya hemos dedicado un artículo completo al sistema Cfengine, por lo que hoy nos centraremos en el sistema Puppet, al que bien se puede llamar su seguidor ideológico. Puppet fue desarrollado por Luke Kanies, quien se cansó de las limitaciones de Cfengine y decidió crear una versión mejor desde cero. Si ya ha utilizado Cfenfine, probablemente encontrará Puppet más conveniente y sistema poderoso. El lenguaje de estado de Puppet es más flexible y de alto nivel, por lo que los administradores no tienen que preocuparse por cosas como escribir reglas separadas para cada tipo de sistema operativo o detallar cómo realizar acciones triviales. Puppet permite que su maestro se concentre en lo que quiere hacer, en lugar de en cómo hacerlo (por ejemplo, para instalar un paquete específico en cualquiera de los sistemas operativos compatibles, solo necesita escribir literalmente unas pocas líneas que digan "Instalar este programa " en lugar de describir los comandos necesarios para su instalación). Puppet está escrito en un lenguaje Ruby simple, lo que facilita adaptarlo a una tarea específica y ampliar su funcionalidad (se proporciona un sistema flexible de complementos).

Además, a diferencia del modelo de desarrollo de Cfengine, que esencialmente gira en torno a una persona, Puppet tiene una gran comunidad de entusiastas que realizan mejoras en el código, comparten ejemplos de configuración y escriben documentación.

En general, Puppet parece ser un sistema más moderno y sofisticado con buen diseño. Al igual que Cfengine, es compatible con casi todos los sistemas operativos modernos tipo UNIX (incluido MacOS X) y también puede ejecutarse en el entorno Cygwin sobre Windows. Su lista de dependencias solo incluye el intérprete Ruby y la herramienta Factor, por lo que no debería haber problemas con la instalación (para ser justos, la lista de dependencias de Cfengine es aún más corta).

Instalación

Al igual que Cfengne, Puppet es un sistema cliente-servidor que consta de un servidor de control y nodos esclavos. El servidor almacena una descripción de los estados finales de los nodos (que en términos de Puppet se llama manifiesto) y espera a que se conecten. Cada media hora (por defecto), el cliente se conecta al servidor, recibe de él una descripción del estado final, lo compara con el actual y, si éste y/o el estado descrito ha cambiado, reconfigura el sistema y luego se va a dormir. La comunicación se realiza a través de un canal cifrado, por lo que los ataques basados en la sustitución de la descripción del estado están excluidos (pero si un atacante toma el control del servidor, todos los nodos estarán bajo su control).

Puppet está incluido en los repositorios de todas las distribuciones populares, por lo que instalarlo no debería ser difícil. Por ejemplo, en Debian/Ubuntu el cliente Puppet se puede instalar así:

$ sudo apt-get instalar marioneta

Y el servidor es así:

$ sudo apt-get instalar Puppet Puppetmaster

Los archivos de configuración del cliente y del servidor se almacenan en el directorio /etc/puppet. El más importante de ellos es el archivo /etc/puppet/manifests/site.pp, que contiene el manifiesto.

Almacena una descripción de los estados y solo debe existir en el servidor. Para facilitar la depuración, agreguemos una configuración simple:

contraseña de clase (
archivo("/etc/contraseña":
propietario => raíz,
grupo => raíz,
modo => 644,
}
}
valor predeterminado del nodo (
incluir contraseña
}

Estas líneas describen el estado en el que el propietario del archivo /etc/passwd debe ser root y sus permisos deben estar establecidos en 644. Examinaremos más de cerca el formato del archivo de manifiesto en la siguiente sección. El segundo archivo más importante es /etc/puppet/puppet.conf. Establece la configuración del servidor y de los clientes, por lo que debe estar presente en todas las máquinas organizadas en la red Puppet. En Ubuntu, este archivo contiene la configuración mínima necesaria y, en la mayoría de los casos, suficiente. A continuación se dan con comentarios:

# vi /etc/puppet/puppet.conf
# Caminos estándar a catálogos
logdir=/var/log/títere
vardir=/var/lib/títere
ssldir=/var/lib/puppet/ssl
rundir=/var/run/títere
# Ubicación de la herramienta Factor,
# utilizado para obtener información sobre el sistema operativo
factpath=$vardir/lib/facter
# Sincronizar complementos
# (complementos instalados en el servidor; se copian a los clientes)
complementosync=verdadero
# Catálogo con plantillas (lea sobre ellas a continuación)
templatedir=$confdir/plantillas
# Sincronización con etckeeper
# (quién sabe, lo entenderá, otros no lo necesitan)
prerun_command=/etc/puppet/etckeeper-commitpre
postrun_command=/etc/puppet/etckeeper-commitpost

El archivo de configuración puede contener una gran cantidad de varias opciones, información sobre la cual se puede obtener generando una configuración predeterminada:

$ sudo Puppetmasterd -genconfig > /etc/puppet/
Puppetd.conf.default

La configuración del cliente predeterminada se genera usando otro comando:

$ sudo Puppet -genconfig > /etc/puppet/puppetd.conf.default

Los archivos fileserver.conf y auth.conf se utilizan para configurar el servidor de archivos (lea sobre esto en la sección "Servidor de archivos") y la autenticación. No tiene sentido tocarlos todavía. Una vez completada la configuración, se debe reiniciar el servidor Puppet:

$ sudo /etc/init.d/puppetmaster reiniciar

Después de lo cual estará listo para aceptar las solicitudes de los clientes. Sin embargo, sin un certificado firmado, ningún cliente podrá recibir el manifiesto del servidor y configurar la máquina.

Por lo tanto, debemos ejecutar los clientes Puppet en modo de prueba para que puedan enviar sus certificados al servidor para su firma (por cierto, esto se puede hacer en todas las máquinas al mismo tiempo usando la herramienta shmux):

$ sudo Puppetd -servidor Puppet-server.com -verbose -test

Regresamos al servidor y recibimos una lista de certificados listos para firmar:

$ sudo puppetca --lista

Seleccione un host de la lista y firme su certificado:

$ sudo puppetca --sign nomad.grinder.com

O firmamos todo a la vez:

$ sudo puppetca --signo --todos

Ahora puedes iniciar clientes en modo combate. Pero primero debe ingresar el nombre del servidor Puppet en el archivo de configuración (por defecto su nombre es simplemente Puppet):

$sudo su
# eco "" >> /etc/puppet/puppet.conf
# echo "servidor=puppet-server.com" >> /etc/puppet/puppet.conf
# salida

Clientes de lanzamiento:

$ sudo /etc/init.d/puppet inicio

Lenguaje de descripción del estado

Como se mencionó anteriormente, Puppet utiliza su propio lenguaje para describir el estado final del sistema operativo, con la ayuda del cual el administrador del sistema especifica en qué forma deben adoptarse los componentes del sistema operativo para que alcance el estado deseado. Se trata de un lenguaje bastante complejo que, sin embargo, es mucho más sencillo que cualquier lenguaje de programación. Si está al menos superficialmente familiarizado con el lenguaje de scripting bash, comprenderá fácilmente el lenguaje Puppet. Elemento clave El lenguaje son recursos con cuya ayuda se describe la forma a la que se debe convertir uno de los componentes del sistema operativo. Por ejemplo, el siguiente recurso simple describe el estado deseado del archivo /etc/passwd:

# vi /etc/puppet/manifests/site.pp
archivo("/etc/contraseña":
propietario => "raíz"
}

Aquí el archivo es el tipo de recurso. Hay varias docenas de ellos en total, desde recursos que administran archivos, como en este ejemplo, hasta paquetes y servicios. La línea /etc/passwd es el nombre del recurso.

En el caso del tipo de archivo, el nombre es el mismo que la ruta al archivo, pero en algunos otros tipos el nombre puede ser arbitrario. La línea propietario => "root" describe establecer el atributo propietario en raíz, es decir, dice que el propietario archivo especificado debe haber un administrador.

Cada tipo de recurso tiene su propio conjunto de atributos disponibles para modificación, además hay metaatributos especiales que se pueden usar en cualquier recurso. Una de las cualidades importantes de los recursos es la capacidad de vincularse a ellos. Esto se puede utilizar para formar cadenas de dependencia. Próxima entrada crea un recurso /etc/group que depende del recurso /etc/passwd (las dependencias se especifican utilizando el metaatributo require):

# vi /etc/puppet/manifests/site.pp
archivo("/etc/grupo":
requerir => Archivo["/etc/passwd"],
propietario => "raíz",
}

Esto significa que el recurso /etc/group se puede configurar (llevar al formulario descrito) solo cuando el recurso /etc/passwd está configurado. Los recursos se pueden agrupar en colecciones de recursos llamadas clases. Esto es necesario para combinar recursos similares en significado y tipo de tarea realizada en un recurso abstracto. Por ejemplo, por conveniencia podríamos combinar instalación y lanzamiento. servidor web nginx en un recurso abstracto del mismo nombre:

# vi /etc/puppet/manifests/site.pp
clase nginx(
paquete("nginx":
asegurar => instalado
}
servicio("nginx":
asegurar => corriendo,
requerir => Paquete["nginx"],
}
}

Aquí, el tipo de recurso del paquete se usa para instalar el paquete nginx en el sistema y el servicio se usa para iniciar el servicio del mismo nombre. Con require forzamos al sistema a iniciar el servicio sólo si el paquete se ha instalado correctamente. La conveniencia de las clases es que también se pueden incluir dependiendo de:

# vi /etc/puppet/manifests/site.pp
servicio("calamar":
asegurar => corriendo,
requerir => Clase["nginx"],
}

Como en los lenguajes OOP reales, las clases pueden heredar entre sí y anular atributos:

# vi /etc/puppet/manifests/site.pp
contraseña de clase (
archivo("/etc/contraseña":
propietario => "raíz",
grupo => "raíz",
}
}
la clase passwd-bsd hereda passwd (
Archivo["/etc/passwd"] (grupo => "rueda")
}

Aquí la clase passwd-bsd hereda de passwd para anular el atributo de grupo del recurso /etc/passwd (en sistemas BSD /etc/passwd pertenece al grupo wheel, por lo que creamos una clase separada para dichos sistemas). Más adelante veremos una forma más correcta y obvia de seleccionar valores de atributos alternativos mediante condiciones.

Las variables son uno de los componentes esenciales de cualquier lenguaje de programación y Puppet también las tiene. Las variables comienzan con el signo $ y pueden contener cualquier número, cadena o valor booleano (verdadero, falso):

$quiero_apache = verdadero
$apache_version = "2.2.14"

Una de las características más poderosas de Puppet relacionadas con variables es su integración con la herramienta de información de la máquina facter. Esta utilidad devuelve toda la información específica de la máquina en forma de pares clave-valor, que se convierten en variables del mismo nombre en Puppet. Junto con las instrucciones condicionales en el lenguaje Puppet, se pueden utilizar para alterar los atributos de los recursos según las propiedades de la máquina.

Por ejemplo, la clase passwd descrita anteriormente se puede reescribir fácilmente en selección automática atributo según el tipo de sistema operativo (en este caso, la clase en sí ya no es necesaria):

# vi /etc/puppet/manifests/site.pp
archivo("/etc/contraseña":
propietario => "raíz",
grupo => $núcleo? (
Linux => "raíz",
FreeBSD => "rueda",
},
}

Dependiendo del sistema operativo en el que se analizará este fragmento del manifiesto, el valor del atributo del grupo será root o wheel. Además del operador condicional, Puppet también admite el operador selección de casos, que se puede utilizar para crear un recurso particular dependiendo del valor de la variable:

# vi /etc/puppet/manifests/site.pp
caso $sistema operativo (
redhat: (servicio("httpd": asegurar => ejecutando))
debian: (servicio("apache": asegurar => en ejecución))
predeterminado: ( servicio ( "apache2": asegurar =>
correr))
}

Este código define varias opciones recurso de tipo de servicio según el sistema operativo (nombres de servicio en diferentes Distribuciones de Linux pueden diferir, por lo que el servicio que Puppet debe ejecutar debe especificarse individualmente para cada uno de ellos).

La opción predeterminada se utiliza si el valor de la variable no coincide con ninguna de las opciones anteriores. Además de los tipos de recursos de archivos, paquetes y servicios mencionados anteriormente, Puppet admite una gran cantidad de otros tipos de recursos, incluidos los creados por desarrolladores externos. Su descripción detallada, incluidos ejemplos, atributos y características admitidos, se puede encontrar en la documentación oficial: http://docs.puppetlabs.com/references/stable/type.html. A continuación se muestra una lista y breve descripción de los más utilizados:

Tipos de recursos populares de Marionetas

cron - gestionar trabajos cron
ejecutivo: ejecuta scripts y comandos
archivo - gestión de archivos
filebucket - copia de seguridad de archivos
grupo - gestión de grupo
host: gestiona las entradas en el archivo /etc/hosts
interfaz - configuración de interfaces de red
mount - montar sistemas de archivos
notificar: envía un mensaje al archivo de registro de Puppet
paquete - gestión de paquetes
servicio - gestión de servicios
sshkey - administrar claves SSH
ordenado: eliminar archivos según las condiciones
usuario - gestión de usuarios
zonas - Gestión de zonas Solaris

El segundo elemento más importante del lenguaje Puppet después de los recursos son los nodos. Con su ayuda, el administrador puede describir a qué máquinas se deben aplicar determinados recursos y clases. En otras palabras, es una forma de especificar una configuración individual para cada una de las máquinas que participan en la red Puppet. El ejemplo más simple de un nodo se da al principio del artículo en la sección "Instalación":

# vi /etc/puppet/manifests/site.pp
valor predeterminado del nodo (
incluir contraseña
}

Esta es la definición del nodo predeterminado, que incluye el recurso/clase passwd. El nombre predeterminado significa "todos los demás nodos", por lo que el recurso/clase de contraseña definido en algún lugar arriba se configurará en cada uno de ellos. La palabra clave include se utiliza aquí por conveniencia; de hecho, todas las clases y recursos se pueden describir directamente en la descripción del nodo, pero esto no se recomienda. Además del valor predeterminado, puede especificar en el nombre del nodo nombre de la red máquina (entonces todos los recursos descritos en el nodo se configurarán solo en esta máquina), o un nombre arbitrario (entonces este nodo puede ser heredado por otro nodo). Para comprender cómo funciona todo esto junto con las clases y los recursos, veamos un ejemplo de un manifiesto Puppet listo para usar que se utiliza para configurar dos máquinas de red (un servidor web y un servidor NTP):

# vi /etc/puppet/manifests/site.pp
# Instalar y ejecutar un servidor SSH
clase sshd (
paquete (openssh-server: asegurar => instalado)
servicio(sshd:
nombre => $sistema operativo? (
fedora => "sshd",
debian => "ssh",
predeterminado => "sshd",
},
habilitar => verdadero,
asegurar => corriendo,
}
}
# Instalar y ejecutar Apache
clase httpd(
paquete (httpd: asegurar => instalado)
servicio(httpd:
habilitar => verdadero,
asegurar => corriendo,
}
}
# Instalar e iniciar un servidor NTP
clase ntpd(
paquete (servidor ntp: asegurar => instalado)
servicio (
servidor ntp:
habilitar => verdadero,
asegurar => corriendo,
}
}
# El nodo base, usado sólo como padre de todos los demás.
base del nodo (
incluir sshd
}
# El nodo donde se ubicará el servidor web
El nodo web.server.com hereda la base (
incluir httpd
}
# Nodo del servidor NTP
El nodo ntp.server.com hereda la base (
incluir ntpd
}

Esta configuración aparentemente simple hace mucho: instala y iniciando apache en una máquina con la dirección web.server.com e instalar y ejecutar un servidor NTP en la máquina ntp.servidor.com. Además, ambas máquinas instalan un servidor SSH. Es poco probable que esta configuración sea adecuada ni siquiera para un administrador; Tendrá que mejorarse seriamente para enseñar cómo configurar servidores correctamente, recibir configuraciones nuevas y otros archivos del servidor principal de Puppet.

Sin embargo, muestra claramente el poder de Puppet. Usando una configuración simple, hicimos que las máquinas instalaran y ejecutaran el software necesario por sí mismas y lo mantuvieran en funcionamiento (si el servidor falla, Puppet se reconfigurará para llevar los sistemas al estado requerido).

Servidor de archivos

Muchas tareas administración remota No se puede resolver sin copiar archivos adicionales a las máquinas. Estas podrían ser configuraciones preparadas previamente, páginas web para Apache, paquetes no disponibles en repositorio oficial y mucho más. Para facilitar el proceso de transferencia de estos archivos a hosts remotos, Puppet incluye un servidor de archivos.

La configuración del servidor de archivos se almacena en el archivo /etc/puppet/fileserver.conf. Para obligar a Puppet a entregar el contenido de un directorio específico a los clientes, debe escribir algunas líneas en él:

# vi /etc/puppet/fileserver.conf
ruta = /var/títere/archivos
permitir *.server.com

Estas dos líneas indican que el directorio /var/puppet/files debe ser accesible para todos los hosts en el dominio server.com. Además, podemos indicar el completo nombre de dominio máquina permitida o su dirección IP, así como cortar las no deseadas usando la directiva denegar. Cualquier archivo en ese directorio se puede mover al cliente utilizando el recurso de archivo. Por ejemplo:

# vi /etc/puppet/manifests/site.pp
archivo("/etc/httpd/conf/httpd.conf":
fuente => "títere://httpd/httpd.conf",
modo => 644,
}

El archivo httpd.conf, ubicado en el servidor en el directorio /var/puppet/files/httpd, se copiará a la máquina de destino a lo largo de la ruta especificada en el nombre del recurso.

Conclusiones

En este artículo, hemos cubierto una porción muy pequeña de las capacidades de Puppet. De hecho, se trata de un sistema complejo que sólo puede describirse en detalle en las páginas de un libro. Al mismo tiempo, Puppet es muy fácil de configurar y mantener, sobre todo porque puedes encontrar muchos ejemplos de su configuración en la Web.

Información

Usos de marionetas protocolo HTTP, por lo que para aumentar el rendimiento se puede ejecutar bajo el control de un servidor web.
Puppet se puede utilizar para configurar automáticamente y mantener una única máquina local.
Al combinar Puppet, instalación de red SO (pxe-install) y autoensamblado Imágenes de instalación, puede crear una red de máquinas completamente autoconfigurable que se puede implementar con un solo comando.
Muchas grandes empresas utilizan Puppet en su trabajo, como Google, Fedora Project, la Universidad de Stanford, Red Hat, Siemens IT Solution y SugarCRM.

Campo de golf

http://docs.puppetlabs.com - Documentación de marionetas
http://docs.puppetlabs.com/guides/language_tutorial.html - Descripción completa del lenguaje Puppet
http://docs.puppetlabs.com/references/stable/type.html - Tipos de recursos

Para más uso efectivo Puppet necesita comprender cómo se crean los módulos y manifiestos. este manual Le explica cómo funcionan estos componentes de Puppet utilizando un ejemplo de configuración de una pila LAMP en un servidor Ubuntu 14.04.

Requisitos

Instalando Puppet (maestro y agente). Más sobre esto -.
La capacidad de crear al menos un servidor virtual Ubuntu 14.04 para atender el nodo del agente Puppet.

Conceptos básicos del código títere

Recursos

El código títere se compone principalmente de recursos. Un recurso es un fragmento de código que describe el estado del sistema y determina los cambios que necesita. Por ejemplo:

usuario("mitchell":
asegurar => presente,
uid => "1000",
gid => "1000",
cáscara => "/bin/bash",
casa => "/casa/mitchell"
}

La declaración de recursos tiene el siguiente formato:

tipo_recurso("nombre_recurso"
atributo => valor
...
}

Para ver todos los tipos de recursos de Puppet, emita el comando:

recurso de marionetas --tipos

Aprenderá más sobre los tipos de recursos en esta guía.

Manifiestos

Un manifiesto es un guión de orquestación. Los programas títeres con extensión .pp se denominan manifiestos. El manifiesto de Puppet predeterminado es /etc/puppet/manifests/site.pp.

Clases

Como en cualquier lenguaje de programación normal, las clases son responsables de organizar y reutilizar partes de la orquestación.

Dentro de una definición de clase hay un bloque de código que describe cómo funciona la clase. Una vez que define una clase, puede usarla en manifiestos.

La definición de clase tiene el siguiente formato:

clase ejemplo_clase(
...
código
...
}

Este código define la clase example_class. El código Puppet estará entre llaves.

Una declaración de clase es el lugar del código donde se llama a una clase particular. Con una declaración de clase, Puppet procesa su código.

La declaración de clase puede ser ordinaria y por tipo de recurso.

Se agrega una declaración de clase regular al código usando la palabra clave include.

incluir clase_ejemplo

Cuando se declara como tipo de recurso, la clase se declara en formato de recurso:

clase("ejemplo_clase":)

Esta declaración le permite agregar parámetros de clase a su código que anulan los valores predeterminados de los atributos de clase. Por ejemplo:

nodo "host2" (
clase ("apache": ) # usar el módulo apache
apache::vhost ( "ejemplo.com": # define el recurso vhost
puerto => "80",
docroot => "/var/www/html"
}
}

Módulos

Un módulo es un grupo de manifiestos y otros archivos organizados de una manera predefinida para facilitar el intercambio y la reutilización. partes individuales orquestación. Los módulos ayudan a organizar el código Puppet porque se pueden usar para separar el código en múltiples manifiestos.

Los módulos Puppet se almacenan en el directorio /etc/puppet/modules.

Escribiendo un manifiesto

Puede practicar la escritura de manifiestos, módulos y clases de Puppet usando el ejemplo de instalación de una pila LAMP en un servidor Ubuntu (el resultado será).

Entonces, para organizar un servidor Ubuntu 14.04 e instalar una pila LAMP en él, necesita recursos para las siguientes acciones:

instalando el paquete apache2.
iniciando el servicio apache2.
instalación del paquete servidor mysql, servidor mysql.
iniciando el servicio mysql.
instalando el paquete php5
creando una prueba secuencia de comandos PHP, info.php.
actualizando el índice apt antes de instalar cada paquete.

A continuación encontrará tres ejemplos de código Puppet que se pueden utilizar para lograr dicha configuración de pila LAMP.

El primer ejemplo le enseñará cómo escribir manifiestos básicos en un archivo. El segundo ejemplo le ayudará a ensamblar y utilizar una clase y un módulo basados en manifiestos escritos previamente. El tercer ejemplo le mostrará cómo utilizar módulos públicos prediseñados para instalar una pila LAMP.

Nota: Para realizar pruebas, es mejor utilizar un servidor virtual nuevo.

Ejemplo 1: instalación de LAMP con un manifiesto

El manifiesto de Puppet se puede escribir en el nodo del agente y luego ejecutarse usando el comando de aplicación de Puppet (no es necesario tener una configuración maestra y de agente para hacer esto).

En esta sección, aprenderá a escribir manifiestos que utilizarán estos tipos de declaraciones de recursos:

exec: Ejecuta comandos.
paquete: instalar paquetes.
servicio: gestión de servicios.
archivo: gestión de archivos.

Creando un manifiesto

Crea un nuevo manifiesto:

sudo vi /etc/puppet/manifests/lamp.pp

Agregue el siguiente código para declarar los recursos necesarios.

# ejecutar el comando "apt-get update"
ejecutivo("apt-update": # recurso ejecutivo "apt-update"
comando => "/usr/bin/apt-get update" # comando que ejecutará este recurso
}
# instalar el paquete apache2
paquete("apache2":
require => Exec["apt-update"], # solicita "apt-update" antes de instalar el paquete
asegurar => instalado,
}
# iniciar el servicio apache2
servicio("apache2":
asegurar => corriendo,
}
# instalar el servidor mysql
paquete("servidor-mysql":
require => Exec["apt-update"], # solicita "apt-update" reinstalando
asegurar => instalado,
}
# iniciar el servicio mysql
servicio("mysql":
asegurar => corriendo,
}
# instalar el paquete php5
paquete("php5":
require => Exec["apt-update"], # solicita "apt-update" antes de la instalación
asegurar => instalado,
}
# iniciar el servicio info.php
archivo("/var/www/html/info.php":
asegurar => archivo,
contenido => "", # código phpinfo
require => Paquete["apache2"], # solicitud del paquete "apache2"
}

Aplicando un manifiesto

Para usar el nuevo manifiesto, ingrese el comando:

aplicar sudo Puppet --prueba

Mostrará un resultado voluminoso que muestra todos los cambios en el estado del medio ambiente. Si no hay errores en el resultado, debería poder abrir su dirección IP externa o nombre de dominio en su navegador. Aparecerá una prueba de prueba en la pantalla. pagina PHP con información sobre la pila. Esto significa que Apache y PHP están funcionando.

Ahora la pila LAMP está instalada en el servidor usando Puppet.

Este es un manifiesto bastante simple ya que se puede ejecutar en un agente. Si no tiene un Puppet master, otros nodos de agente no podrán usar este manifiesto.

El servidor Puppet Master comprueba los cambios de estado del servidor cada 30 minutos.

Ejemplo 2: instalación de una pila LAMP utilizando un módulo

Ahora intenta crear un módulo simple basado en el manifiesto LAMP que escribiste en la sección anterior.

Para crear un módulo, cree un nuevo directorio en el directorio de módulos (su nombre debe coincidir con el nombre del módulo). Este directorio debe contener un directorio de manifiestos y un archivo init.pp. El archivo init.pp especifica la clase Puppet (su nombre también debe coincidir con el nombre del módulo).

Creando un módulo

Vaya al servidor Puppet master y cree una estructura de directorio para el módulo:

cd /etc/títere/módulos
sudo mkdir -p lámpara/manifiestos

Cree y abra el archivo init.pp en el editor:

lámpara sudo vi/manifests/init.pp

Inserte la clase de lámpara en el archivo:

lámpara de clase (
}

Copie el contenido del manifiesto de la sección 1 y péguelo en el bloque de clase de lámpara. Ahora tiene una definición de clase de lámpara. Otros manifiestos podrán utilizar esta clase como módulo.

Guarde y cierre el archivo.

Usando un módulo en el manifiesto principal

Ahora puede configurar el manifiesto principal y usar el módulo de lámpara para instalar la pila LAMP en el servidor.

En el servidor Puppet master, edite el siguiente archivo:

sudo vi /etc/puppet/manifests/site.pp

Lo más probable es que en en este momento el archivo está vacío. Agregue las siguientes líneas:

valor predeterminado del nodo ( )
nodo "lámpara-1" (
}

Nota: Reemplace lamp-1 con el nombre de host de su agente Puppet en el que instalará la pila.

El bloque de nodos le permite especificar el código Puppet que solo se aplicará a algunos nodos.

El bloque predeterminado se aplica a todos los nodos del agente que no tienen un bloque individual (déjelo vacío). El bloque lámpara-1 se aplicará al nodo del agente lámpara-1.

Añadir a este bloque siguiente línea, que utiliza el módulo de lámpara:

Guarde y cierre el archivo.

Ahora el nodo del agente Puppet podrá descargar la configuración del servidor maestro e instalar la pila LAMP. Si desea realizar cambios ahora mismo, ejecute el comando en el agente:

agente títere sudo --prueba

Los módulos son la forma más conveniente reutilizar Código de marionetas. Además, los módulos le ayudan a organizar lógicamente su código.

Ejemplo 3: instalación de LAMP utilizando módulos públicos

El módulo MySQL se utiliza de forma similar. Agregue las siguientes líneas al bloque de nodos:

clase("mysql::servidor":
root_password => "contraseña",
}

También puede pasar los parámetros del módulo MySQL.

Agregue un recurso que copie info.php a lugar correcto. Utilice el parámetro de origen. Agregue las siguientes líneas al bloque de nodos:

file("info.php": # nombre del archivo de recursos
ruta => "/var/www/html/info.php", # ruta de destino
asegurar => archivo,
require => Clase["apache"], # clase de apache a usar
source => "puppet:///modules/apache/info.php", # ubicación para copiar el archivo
}

Esta declaración de clase utiliza el parámetro fuente en lugar del contenido. Esta opción no sólo utiliza el contenido del archivo, sino que también lo copia.

Puppet copiará el archivo puppet:///modules/apache/info.php a /etc/puppet/modules/apache/files/info.php.

Guarde y cierre el archivo.

Crea un archivo info.php.

sudo sh -c "eco""> /etc/puppet/modules/apache/files/info.php"

Ahora el nodo del agente Puppet podrá descargar la configuración del servidor maestro e instalar la pila LAMP. Si desea realizar cambios en el entorno del agente ahora mismo, ejecute el comando en este nodo:

agente títere sudo --prueba

Este comando descargará todas las actualizaciones para el nodo actual e instalará la pila en él. Para asegurarse de que Apache y PHP estén funcionando, abra la dirección IP o el dominio del nodo en un navegador:

http://lámpara_1_public_IP/info.php

Conclusión

Ahora tiene conocimientos básicos sobre cómo trabajar con módulos y manifiestos de Puppet. Intente crear usted mismo un manifiesto y un módulo sencillos.

Puppet es excelente para administrar archivos de configuración de aplicaciones.

Etiquetas: ,

Rubí

Tutorial

Hola.

Este tema abre una serie de artículos sobre el uso del sistema de gestión de configuración Puppet.

¿Qué es un sistema de gestión de configuración?

Supongamos que tiene una flota de servidores que realizan diversas tareas. Si bien hay pocos servidores y no estás creciendo, puedes configurar fácilmente cada servidor manualmente. Instale el sistema operativo (tal vez automáticamente), agregue usuarios, instale software ingresando comandos en la consola, configure servicios, edite las configuraciones de sus editores de texto favoritos (nanorc, vimrc), establezca las mismas configuraciones del servidor DNS en ellos, instale el sistema de monitoreo agente, configurar syslog para la recopilación centralizada de registros... En resumen, hay bastante trabajo y no es particularmente interesante.

Realmente creo que un buen administrador es un administrador vago. No le gusta hacer algo varias veces. La primera idea es escribir un par de guiones en los que habrá algo como:

Servidores.sh
servidores="servidor00 servidor01 servidor02 servidor03 servidor04" para el servidor en $servidores; hacer scp /ruta/al/trabajo/archivo/job.sh $servidor:/tmp/job.sh ssh $servidor sh /tmp/job.sh hecho

Trabajo.sh
#!/bin/bash apt-get update apt-get install nginx service nginx start

Todo parecía fácil y bueno. Necesitamos hacer algo - escribir nuevo guión, lancemos. Los cambios llegan a todos los servidores de forma secuencial. Si el script está bien depurado, todo irá bien. Por ahora.

Ahora imagina que hay más servidores. Por ejemplo, cien. Y el cambio lleva mucho tiempo; por ejemplo, ensamblar algo grande y aterrador (por ejemplo, un kernel) a partir del código fuente. El guión tardará cien años en ejecutarse, pero no está tan mal.

Imagine que sólo necesita hacer esto en un grupo específico de esos cien servidores. Y dos días después, debes realizar otra gran tarea en una sección diferente de servidores. Tendrá que reescribir los scripts cada vez y comprobar muchas veces si contienen errores o si esto causará algún problema al iniciar.

Lo peor es que en guiones como este describe comportamiento, que debe realizarse para llevar el sistema a un determinado estado, y no a este estado en sí. Esto significa que si el sistema inicialmente no estaba en el estado esperado, definitivamente todo saldrá mal. Los manifiestos títeres describen de forma declarativa el estado requerido del sistema, y calcular cómo llegar a él desde el estado actual es tarea del propio sistema de gestión de configuración.

A modo de comparación: un manifiesto de marionetas que hace el mismo trabajo que un par de guiones del principio del tema:

Nginx.pp
clase nginx ( paquete ( "nginx": asegurar => último ) servicio ( "nginx": asegurar => en ejecución, habilitar => verdadero, requerir => Paquete["nginx"] ) ) nodo /^servidor(\d+)$ / (incluye nginx)
Si utilizas los servidores correctamente y dedicas algo de tiempo a configuración inicial sistema de gestión de configuración, puede lograr un estado tal de la flota de servidores que no necesite iniciar sesión en ellos para realizar el trabajo. Todos los cambios necesarios se les enviarán automáticamente.

¿Qué es la marioneta?

Puppet es un sistema de gestión de configuración. La arquitectura es cliente-servidor, las configuraciones se almacenan en el servidor (en términos de títeres se llaman manifiestos), los clientes contactan con el servidor, los reciben y los aplican. Puppet está escrito en lenguaje Ruby, los manifiestos en sí están escritos en un DSL especial, muy similar al propio Ruby.

Pinitos

Olvidémonos de los clientes, servidores, sus interacciones, etc. Supongamos que solo tenemos un servidor en el que está instalado un sistema operativo básico (en adelante, estoy trabajando en Ubuntu 12.04, para otros sistemas las acciones serán ligeramente diferentes).

Primero, instalemos la última versión de Puppet.

Wget http://apt.puppetlabs.com/puppetlabs-release-precise.deb dpkg -i puppetlabs-release-precise.deb apt-get actualizar apt-get instalar Puppet Puppetmaster

Asombroso. Ahora tenemos Puppet instalado en nuestro sistema y podemos jugar con él.

¡Hola Mundo!

Creemos el primer manifiesto:

/tmp/holamundo.pp
archivo ( "/tmp/helloworld": asegurar => presente, contenido => "¡Hola, mundo!", modo => 0644, propietario => "raíz", grupo => "raíz")
Y aplicarlo:

$ Puppet aplicar helloworld.pp /Stage//File/ensure: creado Catálogo terminado ejecutado en 0,06 segundos

Un poco sobre el lanzamiento.

Los manifiestos proporcionados en este tema se pueden aplicar manualmente mediante la aplicación de títeres. Sin embargo, en temas posteriores se utilizará para el trabajo la configuración maestro-esclavo (estándar para Puppet).

Ahora mire el contenido del archivo /tmp/helloworld. Contendrá (¡sorprendentemente!) la línea “¡Hola, mundo!”, que especificamos en el manifiesto.

Se podría decir que podría hacer echo "¡Hola, mundo!" > /tmp/helloworld , sería más rápido, más simple, no tendrías que pensar, escribir algunos manifiestos terribles y, en general, nadie necesita esto, de alguna manera es demasiado complicado, pero piénsalo más seriamente. De hecho, necesitarías escribir touch /tmp/helloworld && echo "¡Hola, mundo!" > /tmp/helloworld && chmod 644 /tmp/helloworld && chown root /tmp/helloworld && chgrp root /tmp/helloworld para garantizar el mismo resultado.

Veamos línea por línea qué contiene exactamente nuestro manifiesto:

/tmp/holamundo.pp
file ( "/tmp/helloworld": asegurar => presente, # el archivo debe existir contenido => "¡Hola, mundo!", # el contenido del archivo debe ser la cadena "¡Hola, mundo!" modo => 0644, # permisos de archivo - 0644 propietario => "raíz", # propietario de archivo - grupo raíz => "raíz" # grupo de archivos - raíz)

Descrito aquí en términos de títeres. recurso tipo archivo con titulo /tmp/holamundo.

Recursos

Un recurso es la unidad de abstracción más pequeña en Puppet. Los recursos pueden ser:

archivos;
paquetes (Puppet soporta los sistemas de paquetes de muchas distribuciones);
servicios;
usuarios;
grupos;
tareas cron;
etc.

Puede echar un vistazo a la sintaxis del recurso sin restricciones.

Puppet te permite agregar tus propios recursos. Por lo tanto, si te confundes mucho, puedes terminar con manifiestos como:

Servidor web.pp
incluir servidor web; servidor web::vhost ( "ejemplo.com": asegurar => presente, tamaño => "1G", php => falso, https => verdadero)
Puppet creará un volumen lógico de 1 GiB de tamaño en el servidor, lo montará donde debería estar (por ejemplo, en /var/www/example.com), agregará las entradas necesarias a fstab, creará los hosts virtuales necesarios en nginx y apache, reinicie ambos demonios, agregue el usuario example.com a ftp y sftp con la contraseña mySuperSecretPassWord con acceso de escritura a este host virtual.

¿Sabroso? ¡Palabra equivocada!

Además, lo más delicioso, en mi opinión, no es la automatización de la rutina. Si, por ejemplo, es un idiota y reinstala constantemente sus servidores en producción, Puppet le permitirá retomar el antiguo conjunto de paquetes y configuraciones creado con amor desde cero en un modo completamente automático. Simplemente instala el agente Puppet, lo conecta a su Puppet master y espera. Todo vendrá por sí solo. Los paquetes aparecerán mágicamente (¡no, realmente mágicamente!) en el servidor, sus claves ssh se distribuirán, se instalará un firewall y vendrán. ajustes individuales bash, redes, se instalará y configurará todo el software que prudentemente instalaste usando Puppet.
Además, Puppet, con diligencia, permite conseguir un sistema autodocumentado, porque la propia configuración (manifiestos) es la columna vertebral de la documentación. Están siempre actualizados (ya funcionan), no tienen errores (compruebas tu configuración antes de lanzar), están mínimamente detallados (funciona).

Un poco más de magia

Un poco sobre distribución cruzada

Puppet tiene la capacidad de utilizar manifiestos de distribución cruzada, este es uno de los propósitos para los que fue creado. Nunca he usado esto intencionalmente y no te lo recomiendo. El parque de servidores debe ser lo más homogéneo posible en términos de software del sistema, esto le permitirá no pensar en los momentos críticos: “Ayblin, toma;
rc.d, no init.d” (un guiño a ArchLinux) y generalmente le permite pensar menos en las tareas rutinarias.

Muchos recursos dependen de otros recursos. Por ejemplo, para el recurso "servicio sshd" necesita el recurso "paquete sshd" y opcionalmente "configuración sshd"
Veamos cómo se implementa esto: archivo ( "sshd_config": ruta => "/etc/ssh/sshd_config", asegurar => archivo, contenido => "Puerto 22 Protocolo 2 HostKey /etc/ssh/ssh_host_rsa_key HostKey /etc/ssh / ssh_host_dsa_key HostKey /etc/ssh/ssh_host_ecdsa_key UsePrivilegeSeparation sí KeyRegeneraciónInterval 3600 ServerKeyBits 768 SyslogFacility AUTH LogLevel INFO LoginGraceTime 120 PermitRootLogin sí StrictModes sí RSAAuthentication sí PubkeyAuthentication sí IgnoreRhosts sí autenticación no HostbasedAuthentication no PermitEmptyPasswords no ChallengeResponseAuthentication no X11Forwarding sí X11DisplayOffset 10 PrintMotd no PrintLastLog sí TCPKeepAlive sí AcceptEnv LANG LC_* Subsistema sftp /usr/lib/openssh/sftp-server UsePAM sí", modo => 0644, propietario => raíz, grupo => raíz, requiere => Paquete["sshd"]) paquete ( "sshd" : asegurar => último, nombre => "openssh-server" ) servicio ( "sshd": asegurar => ejecutando, habilitar => verdadero, nombre => "ssh" suscribirse => Archivo["sshd_config"], requerir => Paquete[ "sshd"])

Esto utiliza una configuración en línea, lo que hace que el manifiesto sea feo. En realidad, esto casi nunca se hace, existe un motor de plantillas basado en ERB y la capacidad de utilizar únicamente archivos externos. Pero eso no es lo que nos interesa.

Las líneas más deliciosas aquí son las líneas de dependencia: solicitar y suscribirse.

Puppet admite muchas opciones para describir dependencias. Como siempre, puedes leer detalladamente en

Imagínese en el rol de administrador de sistemas, responsable de mantener la funcionalidad de cientos de máquinas que ejecutan sistemas operativos tipo UNIX. Cada uno requiere configuración y actualización y monitoreo periódicos, pero se espera que muchos realicen funciones similares. Dos tercios son estaciones de trabajo, algunos más son enrutadores y el resto son varios servidores web y almacenamiento de datos. Pregunta: ¿cómo gestionar todo este negocio?

La respuesta más sencilla es simplemente conectarse a cada uno de ellos mediante SSH y realizar los cambios necesarios. Sin embargo, este método tiene dos problemas. En primer lugar, requiere mucha mano de obra. En segundo lugar, el administrador tendrá que realizar constantemente muchas acciones monótonas (por ejemplo, para actualizar OpenOffice.org en todas las estaciones de trabajo, deberá ejecutar los mismos comandos varias docenas de veces). Puede intentar evitar este problema escribiendo varios scripts que se conectarán a cada máquina y ejecutarán comandos preescritos. Pero aquí también nos esperan problemas. Los scripts deberán modificarse constantemente para adaptarse a cada tarea, los scripts deberán tener en cuenta las diferencias en los sistemas operativos y las versiones, y deberán depurarse durante mucho tiempo antes de aplicarse a las máquinas en ejecución. En general, no un camilleaux.

La respuesta correcta es utilizar los llamados sistemas de gestión de configuración remota, cuyos representantes más conocidos son los sistemas de código abierto Cfengine y Puppet. Dichos sistemas asumen todas las responsabilidades para llevar la configuración de la máquina a la forma deseada, requiriendo que el administrador solo describa el estado final del sistema en un lenguaje especial (por ejemplo, una descripción de qué paquetes deben instalarse en el sistema operativo, qué líneas deben agregarse a los archivos de configuración, qué comandos deben ejecutarse, etc.). Después de esto, todos los nodos recibirán información sobre el estado requerido del servidor y configurarán automáticamente el sistema. Gracias a este mecanismo, las máquinas nuevas se pueden configurar completamente sin intervención humana y las existentes se pueden reconfigurar agregando solo unas pocas líneas a la descripción del estado.

¿Marioneta?

Puppet fue desarrollado por Luke Kanies, quien se cansó de las limitaciones de Cfengine y decidió crear una versión mejor desde cero. Si ya ha utilizado Cfenfine, probablemente encontrará que Puppet es un sistema más conveniente y potente. El lenguaje de estado de Puppet es más flexible y de alto nivel, por lo que los administradores no tienen que preocuparse por cosas como escribir reglas separadas para cada tipo de sistema operativo o detallar cómo realizar acciones triviales. Puppet te permite concentrarte en lo que Qué quiere hacer, en lugar de cómo hacerlo (por ejemplo, para instalar un determinado paquete en cualquiera de los sistemas operativos soportados por el sistema, basta con escribir literalmente unas pocas líneas que digan “Instalar este programa”, en lugar de describir los comandos necesarios para instalarlo). Puppet está escrito en un lenguaje Ruby simple, lo que facilita adaptarlo a una tarea específica y ampliar su funcionalidad (se proporciona un sistema flexible de complementos). Además, a diferencia del modelo de desarrollo de Cfengine, que esencialmente gira en torno a una persona, Puppet tiene una gran comunidad de entusiastas que realizan mejoras en el código, comparten ejemplos de configuración y escriben documentación.

En general, Puppet parece un sistema más moderno y mejor diseñado. Al igual que Cfengine, es compatible con casi todos los sistemas operativos modernos tipo UNIX (incluido MacOS X) y también puede ejecutarse en el entorno Cygwin sobre Windows. Su lista de dependencias solo incluye el intérprete Ruby y la herramienta Factor, por lo que no debería haber problemas con la instalación (para ser justos, la lista de dependencias de Cfengine es aún más corta).

Servidor de archivos

Muchas tareas de administración remota no se pueden resolver sin copiar archivos adicionales a las máquinas. Pueden ser configuraciones preparadas previamente, páginas web para Apache, paquetes que no están en el repositorio oficial y mucho más. Para facilitar el proceso de transferencia de estos archivos a nodos remotos, Puppet incluye un servidor de archivos.

Ruta = /var/puppet/files permitir *.server.com

Estas dos líneas indican que el directorio /var/puppet/files debe ser accesible para todos los hosts en el dominio server.com. También podemos especificar el nombre de dominio completo de una máquina permitida o su dirección IP, y también eliminar los no deseados usando la directiva denegar. Cualquier archivo en ese directorio se puede mover al cliente utilizando el recurso de archivo. Por ejemplo:

Archivo ("/etc/httpd/conf/httpd.conf": fuente => "puppet://httpd/httpd.conf", modo => 644,)

El archivo httpd.conf ubicado en el servidor en el directorio /var/puppet/files/httpd se copiará a la máquina de destino a lo largo de la ruta especificada en el nombre del recurso.

Conclusiones

En este artículo, hemos cubierto una porción muy pequeña de las capacidades de Puppet. De hecho, se trata de un sistema muy complejo que sólo puede describirse en su totalidad en las páginas de un libro. Al mismo tiempo, Puppet es muy fácil de configurar y mantener, sobre todo porque puedes encontrar muchos ejemplos de su configuración en Internet.

Autor: Luke Kanies
Fecha de publicación: 2 de mayo de 2012
Traducción: A. Panin
Fecha de traducción: 27 de agosto de 2013

18.1. Introducción

Puppet es una herramienta de gestión de infraestructura de TI desarrollada utilizando el lenguaje de programación Ruby y utilizada para automatizar el mantenimiento del centro de datos y la gestión de servidores. empresas de google, Twitter, Bolsa de Valores de Nueva York y muchas otras organizaciones. El desarrollo del proyecto cuenta principalmente con el apoyo de la organización Puppet Labs, que sentó las bases para su desarrollo. Puppet puede gestionar entre 2 y 50.000 servidores y ser mantenido por un equipo de uno o cientos de administradores de sistemas.

Puppet es una herramienta diseñada para configurar y mantener sus computadoras; Usando su lenguaje de configuración simple, puede decirle a Puppet cómo desea configurar sus máquinas y las reconfigurará según sea necesario para cumplir con sus especificaciones. A medida que cambie esta especificación con el tiempo debido a circunstancias como actualizaciones de paquetes, adición de nuevos usuarios o actualizaciones de configuración, Puppet actualizará automáticamente la configuración de sus máquinas para que coincida con la especificación. En caso de que ya estén configurados correctamente, Puppet no realizará ningún trabajo.

En general, Puppet realiza todas las acciones posibles encaminadas a utilizar funciones. sistema existente hacer tu trabajo; es decir, en distribuciones basadas en tecnologías RedHat, usará la utilidad yum para administrar paquetes e init.d para administrar servicios, mientras que en OS X usará la utilidad dmg para administrar paquetes y launchd para administrar servicios. Uno de los objetivos fundamentales de Puppet Project es producir trabajo útil, ya sea utilizando el código de Puppet Project o el sistema mismo, por lo que los siguientes estándares del sistema son fundamentales.

El proyecto Puppet se construyó sobre la base de la experiencia con muchas otras herramientas. En un mundo de aplicaciones de código abierto código fuente la mayor influencia en su desarrollo fue el proyecto CFEngine, que fue la primera herramienta de configuración propósito general código abierto, así como el proyecto ISconf, que utilizó hacer utilidad para completar todo el trabajo, lo que a su vez llevó a prestar especial atención a las dependencias descritas explícitamente en el sistema. En el mundo del software comercial, Puppet puede verse como un competidor de los proyectos BladeLogic y Opsware (que luego fueron adquiridos por empresas más grandes), cada uno de los cuales tuvo ventas exitosas cuando se introdujo Puppet, pero cada una de estas herramientas se vendió a los jefes. de las grandes empresas, en lugar de desarrollarse en consecuencia con requisitos directos de herramientas de calidad para los administradores de sistemas. El objetivo del proyecto Puppet era resolver problemas similares a los que resuelven estas herramientas, aunque estaba destinado a usuarios completamente diferentes.

Como ejemplo simple de cómo usar Puppet, a continuación se muestra un fragmento de código que le permite estar seguro de que instalación correcta y configuraciones del servicio de shell seguro (SSH): clase ssh ( paquete ( ssh: asegurar => instalado ) archivo ( "/etc/ssh/sshd_config": fuente => "puppet:///modules/ssh/sshd_config", asegurar = > presente, requiere => Paquete) servicio (sshd: asegurar => en ejecución, requiere =>, Paquete]))

Este código le permite estar seguro de que el paquete se instalará, el archivo se colocará en la ubicación requerida y se iniciará el servicio. Cabe señalar que hemos descrito las dependencias entre recursos, por lo que siempre realizaremos cualquier trabajo en la secuencia correcta. Esta clase se puede asociar con cualquier nodo para aplicar una configuración determinada dentro de ese nodo. Tenga en cuenta que los componentes básicos de la configuración de Puppet son objetos estructurados, en este caso el paquete, el archivo y los objetos de servicio. En la terminología de Puppet, llamamos a estos objetos recursos ( recursos) y cualquier especificación de configuración de Puppet consta de estos recursos y las dependencias entre ellos.

Normal instalación de marionetas contendrá decenas o incluso cientos de estos fragmentos de código, que llamamos clases ( clases); Almacenamos estas clases en el disco en archivos llamados manifiestos y también agrupamos clases relacionadas lógicamente en grupos llamados módulos ( módulos). Por ejemplo, es posible que tenga un módulo ssh con esta clase ssh y cualquier otra clase relacionada lógicamente, junto con los módulos mysql, apache y sudo.

Mayoría Las interacciones con Puppet se llevan a cabo utilizando caparazón o siempre ejecutando servicios HTTP, pero también hay interfaces gráficas para realizar tareas como procesar informes. Puppet Labs también ofrece productos comerciales de software Puppet que utilizan GUI web.

El primer prototipo de Puppet se desarrolló en el verano de 2004 y el desarrollo completo del proyecto comenzó en febrero de 2005. Fue diseñado y desarrollado originalmente por Luke Kanies, un administrador de sistemas con amplia experiencia en el desarrollo de pequeñas herramientas pero sin experiencia en el desarrollo de proyectos que contengan más de 10.000 líneas de código. Básicamente, Luke Kanies aprendió habilidades de programación durante el desarrollo del proyecto Puppet, lo que afectó la arquitectura del proyecto tanto positiva como negativamente.

Puppet se desarrolló inicialmente y principalmente como una herramienta para que los administradores de sistemas les hicieran la vida más fácil, permitiéndoles hacer su trabajo de manera más rápida, más eficiente y con menos errores. La primera innovación clave para implementar este principio fueron los recursos descritos anteriormente, que son primitivos Puppet; se pueden transferir entre sistemas operativos y al mismo tiempo representar detalles de implementación de manera abstracta, lo que permite al usuario pensar en los resultados del trabajo en lugar de cómo lograrlos. Este conjunto de primitivas se implementó en la capa de abstracción de recursos de Puppet.

Los recursos de títeres deben ser exclusivos de nodo dado. Sólo puede tener un paquete llamado "ssh", un servicio llamado "sshd" y un archivo llamado "/etc/ssh/sshd_config". Esta restricción evita conflictos mutuos entre varias partes sus configuraciones y aprenderá sobre estos conflictos en etapa temprana proceso de configuración. Nos referimos a estos recursos por sus tipos y nombres, es decir, Paquete y Servicio. Puedes utilizar un paquete y un servicio con el mismo nombre, ya que están relacionados varios tipos, pero no dos paquetes o servicios con el mismo nombre.

La segunda innovación clave en Puppet es la capacidad de especificar directamente dependencias entre recursos. Herramientas utilizadas anteriormente destinadas a realizar tareas individuales sin considerar las relaciones entre estas tareas; Puppet fue la primera herramienta que declaró explícitamente que las dependencias son una parte fundamental de sus configuraciones, que a su vez deben modelarse en consecuencia. Creó un gráfico de recursos y sus dependencias como uno de los principales tipos de datos, y casi todas las acciones de Puppet dependían de este gráfico (llamado Catálogo), sus vértices y aristas.

Último un componente importante Puppet es un lenguaje de configuración. Este lenguaje es declarativo y está destinado más a describir la configuración que a la programación completa; repite casi por completo el formato de configuración de Nagios, pero también fue creado bajo una influencia significativa de los lenguajes de CFEngine y Ruby.

Los componentes funcionales de Puppet se basan en dos principios rectores: debe ser lo más fácil de usar posible, priorizando la usabilidad sobre las funciones; y debe desarrollarse primero como un marco y segundo como una aplicación, de modo que los desarrolladores externos puedan crear sus aplicaciones basadas en componentes de software Puppet si así lo desean. Estaba claro que además del marco, también se necesitaba una aplicación ampliamente utilizada y de alta calidad, pero la primera prioridad de los desarrolladores seguía siendo el marco, no la aplicación. Mucha gente todavía cree que Puppet es la aplicación en sí y no el marco en el que se implementa.

Después de construir su primer prototipo de Puppet, Luke se convirtió en un buen desarrollador de Perl en general, con cierta experiencia en programación de scripts de shell y algo de experiencia en C, obtenida principalmente trabajando con el sistema CFEngine. Además, tenía experiencia en la creación de sistemas de análisis para lenguajes simples, había desarrollado dos sistemas de este tipo para ejecutarse con herramientas pequeñas y había vuelto a desarrollar el sistema de análisis CFEngine desde cero para que fuera más fácil de mantener (este código no se transfirió al proyecto). por incompatibilidades menores).

decisión de uso lenguaje dinámico La implementación de Puppet se adoptó con bastante rapidez debido a la productividad significativamente mayor del desarrollador y la difusión de este tipo de lenguaje, pero la elección en sí resultó bastante difícil. Los prototipos iniciales en Perl fueron rechazados, por lo que se realizaron experimentos para encontrar otros lenguajes. Se intentó utilizar lenguaje pitón, pero Lucas consideró que este lenguaje contradecía significativamente su visión del mundo. Después de escuchar a un amigo hablar sobre los beneficios del nuevo lenguaje, Luke intentó usar Ruby y creó un prototipo funcional en cuatro horas. Cuando comenzó el desarrollo a gran escala de Puppet, el lenguaje Ruby era prácticamente desconocido, por lo que la decisión de utilizarlo supuso un gran riesgo, pero en este caso la productividad del desarrollador volvió a jugar un papel decisivo en la elección del lenguaje. Hogar característica distintiva lenguaje rubí, al menos desde Perl, existía la facilidad de crear relaciones de clases no jerárquicas sin que el lenguaje chocara con el pensamiento del desarrollador Luke, lo cual era fundamental.

Popular en la categoría: