introduction
Après avoir configuré Puppet dans une configuration agent / maître, vous aurez peut-être besoin d'aide pour la rédaction des manifestes et des modules de Puppet. Pour utiliser efficacement Puppet, vous devez comprendre comment les manifestes et les modules sont construits. Ce tutoriel couvre les bases du code de Puppet et vous montrera comment construire des manifestes et des modules qui vous aideront à commencer à utiliser Puppet pour gérer votre environnement de serveur. Nous montrerons trois manières différentes d’utiliser Puppet pour configurer une pile LAMP sur un Ubuntu 14.04 VPS.
Conditions préalables
Avant de commencer ce didacticiel, vous devez avoir une configuration agent / maître de marionnettes en état de marche. Si vous ne l'avez pas déjà, suivez ce tutoriel:How To Install Puppet To Manage Your Server Infrastructure.
Vous devez également pouvoir créer au moins un nouveau VPS qui servira de nœud d'agent de marionnette que le maître de marionnettes va gérer.
Créer un nouveau nœud d'agent
Créez un nouveau VPS Ubuntu 14.04 appelé «lamp-1»,add it as a Puppet agent node, et signez sa demande de certificat sur le maître Puppet.
Principes de base du code de marionnettes
Avant de commencer à écrire le code Puppet qui configurera nos systèmes, revenons en arrière et passons en revue certains termes et concepts pertinents de Puppet.
Ressources
Le code de marionnette est composé principalement deresource declarations. Une ressource décrit quelque chose sur l'état du système, tel qu'un utilisateur ou un fichier donné doit exister ou qu'un package doit être installé. Voici un exemple de déclaration de ressource utilisateur:
user { 'mitchell':
ensure => present,
uid => '1000',
gid => '1000',
shell => '/bin/bash',
home => '/home/mitchell'
}Les déclarations de ressources sont formatées comme suit:
resource_type { 'resource_name'
attribute => value
...
}Par conséquent, la déclaration de ressource précédente décrit une ressource utilisateur nommée "mitchell", avec les attributs spécifiés.
Pour répertorier tous les types de ressources par défaut disponibles pour Puppet, entrez la commande suivante:
puppet resource --typesNous allons couvrir quelques types de ressources supplémentaires tout au long de ce tutoriel.
Manifestes
Les programmes de marionnettes sont appelés manifestes. Les manifestes sont composés de code marionnette et leurs noms de fichiers utilisent l'extension.pp. Le manifeste principal par défaut dans Puppet installé via apt est/etc/puppet/manifests/site.pp.
Si vous avez suivi le didacticiel préalable de Puppet, vous avez déjà écrit un manifeste qui crée un fichier et installe Apache. Nous écrirons également quelques autres dans ce tutoriel.
Des classes
Dans Puppet, les classes sont des blocs de code pouvant être appelés ailleurs dans un code. L'utilisation de classes vous permet de réutiliser le code de Puppet et facilite la lecture des manifestes.
Définition de classe
Une définition de classe est l'endroit où réside le code qui compose une classe. La définition d'une classe rend la classe disponible pour être utilisée dans les manifestes, mais n'évalue en réalité rien.
Voici comment une classedefinition est formatée:
class example_class {
...
code
...
}Ce qui précède définit une classe nommée exemple_class, et le code de la marionnette serait placé entre les accolades.
Déclaration de classe
Une déclaration de classe se produit lorsqu'une classe est appelée dans un manifeste. Une déclaration de classe indique à Puppet d'évaluer le code dans la classe. Les déclarations de classe sont de deux types différents: normal et type ressource.
Unnormal class declaration se produit lorsque le mot-cléinclude est utilisé dans le code Puppet, comme ceci:
include example_classCela obligera Puppet à évaluer le code enexample_class.
Unresource-like class declaration se produit lorsqu'une classe est déclarée comme une ressource, comme ceci:
class { 'example_class': }L'utilisation de déclarations de classe de type ressource vous permet de spécifierclass parameters, qui remplace les valeurs par défaut des attributs de classe. Si vous avez suivi le didacticiel des prérequis, vous avez déjà utilisé une déclaration de classe de type ressource (classe «apache») lorsque vous avez utilisé le module Apache PuppetLabs pour installer Apache surhost2:
node 'host2' {
class { 'apache': } # use apache module
apache::vhost { 'example.com': # define vhost resource
port => '80',
docroot => '/var/www/html'
}
}Maintenant que vous connaissez les ressources, les manifestes et les classes, vous souhaitez en savoir plus sur les modules.
Modules
Un module est un ensemble de manifestes et de données (tels que des faits, des fichiers et des modèles), dotés d'une structure de répertoires spécifique. Les modules sont utiles pour organiser votre code Puppet, car ils vous permettent de scinder votre code en plusieurs manifestes. Il est recommandé d'utiliser des modules pour organiser la quasi-totalité de vos manifestes de marionnettes.
Pour ajouter un module à Puppet, placez-le dans le répertoire/etc/puppet/modules.
Nous couvrirons les détails nécessaires pour écrire votre propre module de base. Si vous souhaitez en savoir plus, consultez le guide de référence dePuppetLabs Module Fundamentals.
Développer un manifeste
Pour montrer comment écrire des manifestes, des classes et des modules Puppet, nous utiliserons Puppet pour configurer la pile LAMP sur Ubuntu (similaire à la configuration dansthis tutorial). Si vous n'avez jamais configuré de pile LAMP auparavant, vous souhaiterez parcourir le didacticiel lié pour vous familiariser avec la procédure de configuration manuelle.
D'après le didacticiel de la pile LAMP, nous savons que nous voulons un serveur Ubuntu 14.04 avec lesresources suivants:
-
Paquet Apache (apache2) installé
-
Service Apache (apache2) en cours d'exécution
-
Paquet MySQL Server (mysql-server) installé
-
Service serveur MySQL (mysql) en cours d'exécution
-
Paquet PHP5 (php5) installé
-
Un fichier de script de test PHP (info.php)
-
Mettre à jour apt avant d'installer des paquets
Les trois sections suivantes montrent différentes manières d’utiliser Puppet pour obtenir des résultats similaires, un serveur LAMP en état de fonctionnement. Le premier exemple montrera comment écrire un manifeste de base qui se trouve dans un seul fichier. Le deuxième exemple montrera comment construire et utiliser une classe et un module, en se basant sur le manifeste développé dans le premier exemple. Enfin, le troisième exemple montrera comment utiliser des modules préexistants disponibles au public pour configurer rapidement et facilement une pile LAMP similaire. Si vous voulez essayer les trois exemples, à des fins d'apprentissage, nous vous recommandons de commencer avec un nouveau VPS (comme décrit dans lesprerequisites) à chaque fois.
Exemple 1: Installation de LAMP avec un manifeste unique
Si vous n'avez jamais écrit de manifeste de marionnettes auparavant, cet exemple est un bon point de départ. Le manifeste sera développé sur un nœud d'agent Puppet et exécuté viapuppet apply, de sorte qu'une configuration agent / maître n'est pas requise.
Vous apprendrez à écrire un manifeste qui utilisera les types suivants de déclarations de ressources:
-
exec: pour exécuter des commandes, telles que
apt-get -
package: pour installer des packages via apt
-
service: pour s'assurer qu'un service est en cours d'exécution
-
file: pour s'assurer que certains fichiers existent
Créer un manifeste
Sur un VPSlamp-1 frais, créez un nouveau manifeste:
sudo vi /etc/puppet/manifests/lamp.ppAjoutez les lignes suivantes pour déclarer les ressources que nous venons de déterminer que nous voulions. Les commentaires en ligne détaillent chaque déclaration de ressource:
# execute 'apt-get update'
exec { 'apt-update': # exec resource named 'apt-update'
command => '/usr/bin/apt-get update' # command this resource will run
}
# install apache2 package
package { 'apache2':
require => Exec['apt-update'], # require 'apt-update' before installing
ensure => installed,
}
# ensure apache2 service is running
service { 'apache2':
ensure => running,
}
# install mysql-server package
package { 'mysql-server':
require => Exec['apt-update'], # require 'apt-update' before installing
ensure => installed,
}
# ensure mysql service is running
service { 'mysql':
ensure => running,
}
# install php5 package
package { 'php5':
require => Exec['apt-update'], # require 'apt-update' before installing
ensure => installed,
}
# ensure info.php file exists
file { '/var/www/html/info.php':
ensure => file,
content => '', # phpinfo code
require => Package['apache2'], # require 'apache2' package before creating
}Sauvegarder et quitter.
Appliquer le manifeste
Vous voudrez maintenant utiliser la commandepuppet apply pour exécuter le manifeste. Surlamp-1, exécutez ceci:
sudo puppet apply --testVous verrez de nombreuses lignes de sortie indiquant comment l’état de votre serveur change, afin de correspondre aux déclarations de ressources de votre manifeste. S'il n'y a pas d'erreur, vous devriez pouvoir visiter l'adresse IP publique (ou le nom de domaine, si vous l'avez configuré) et voir la page d'informations PHP qui indique qu'Apache et PHP fonctionnent. Vous pouvez également vérifier que MySQL a été installé sur votre serveur (cela n’a pas été sécurisé, mais nous n’allons pas nous en inquiéter pour le moment). Félicitations! Vous configurez une pile LAMP avec Puppet.
Cette configuration particulière n’est pas très excitante, car nous n’avons pas tiré parti de notre configuration agent / maître. Le manifeste n'est actuellement pas disponible pour les autres nœuds d'agent et Puppet ne vérifie pas en permanence (toutes les 30 minutes) que notre serveur est dans l'état décrit par le manifeste.
Maintenant, nous voulons convertir le manifeste que nous venons de développer en un module, de sorte qu'il puisse être utilisé par vos autres nœuds Puppet.
Exemple 2: Installer LAMP en créant un nouveau module
Créons maintenant un module de base, basé sur le manifeste LAMP développé dans l’exemple 1. Nous allons le faire sur le nœud Puppetmaster cette fois. Pour créer un module, vous devez créer un répertoire (dont le nom correspond à votre nom de module) dans le répertoiremodules de Puppet, et il doit contenir un répertoire appelémanifests, et ce répertoire doit contenir uninit.pp fichier. Le fichierinit.pp ne doit contenir qu'une classe Puppet correspondant au nom du module.
Créer un module
Sur Puppetmaster, créez la structure de répertoires pour un module nommélamp:
cd /etc/puppet/modules
sudo mkdir -p lamp/manifestsMaintenant, créez et modifiez le fichierinit.pp de votre module:
sudo vi lamp/manifests/init.ppDans ce fichier, ajoutez un bloc pour une classe appelée «lampe», en ajoutant les lignes suivantes:
class lamp {
}Copiez le contenu du manifeste LAMP que vous avez créé précédemment (ou copiez-le de l'exemple 1 ci-dessus) et collez-le dans le bloc de classelamp. Dans ce fichier, vous avez créé une définition de classe pour une classe «lampe». Le code dans la classe est ne sera pas évalué pour le moment, mais il est disponible pour être déclaré. De plus, comme elle est conforme aux conventions de Puppet pour la définition d'un module, cette classe est accessible en tant que module par d'autres manifestes.
Sauvegarder et quitter.
Utiliser le module dans le manifeste principal
Maintenant que nous avons un module de lampe de base configuré, configurons notre manifeste principal pour l'utiliser pour installer une pile LAMP surlamp-1.
Sur le Puppetmaster, modifiez le manifeste principal:
sudo vi /etc/puppet/manifests/site.ppEn supposant que le fichier est vide, ajoutez les blocsnode suivants (remplacez «lamp-1» par le nom d'hôte de l'agent Puppet sur lequel vous souhaitez installer LAMP):
node default { }
node 'lamp-1' {
}Un bloc de nœud vous permet de spécifier un code de marionnette qui ne s'appliquera qu'à certains nœuds d'agent. Le nœuddefault s'applique à chaque nœud d'agent qui n'a pas de bloc de nœud spécifié - nous le laisserons vide. Le bloc de nœudslamp-1 s'appliquera à votre nœud d'agent Puppetlamp-1.
Dans le bloc de nœudslamp-1, ajoutez le code suivant pour utiliser le module «lampe» que nous venons de créer:
include lampMaintenant, enregistrez et quittez.
La prochaine fois que votre nœud d'agent Puppetlamp-1 extrait sa configuration du maître, il évaluera le manifeste principal et appliquera le module qui spécifie une configuration de pile LAMP. Si vous souhaitez l'essayer immédiatement, exécutez la commande suivante sur le nœud d'agentlamp-1:
sudo puppet agent --testUne fois terminé, vous verrez qu'une pile LAMP de base est configurée, exactement comme dans l'exemple 1. Pour vérifier qu'Apache et PHP fonctionnent, accédez à l'adresse IP publique delamp-1 dans un navigateur Web:
http://lamp_1_public_IP/info.phpVous devriez voir la page d'information pour votre installation de PHP.
Notez que vous pouvez réutiliser le module «lampe» que vous avez créé en le déclarant dans d'autres blocs de nœud. L'utilisation de modules est le meilleur moyen de promouvoir la réutilisation du code Puppet. Elle est également utile pour organiser votre code de manière logique.
Nous allons maintenant vous montrer comment utiliser des modules préexistants pour réaliser une configuration similaire.
Exemple 3: Installation de LAMP avec des modules préexistants
Il existe un référentiel de modules disponibles publiquement, àthe Puppet Forge, qui peuvent être utiles lorsque vous essayez de développer votre propre infrastructure. Les modules Puppet Forge peuvent être installés rapidement avec la commandepuppet module intégrée. Il se trouve que les modules d’installation et de maintenance d’Apache et de MySQL sont disponibles ici. Nous montrerons comment ils peuvent être utilisés pour nous aider à configurer notre pile LAMP.
Installer les modules Apache et MySQL
Sur votre Puppetmaster, installez le modulepuppetlabs-apache:
sudo puppet module install puppetlabs-apacheVous verrez la sortie suivante, qui indique les modules installés correctement:
Notice: Preparing to install into /etc/puppetlabs/puppet/modules ...
Notice: Downloading from https://forgeapi.puppetlabs.com ...
Notice: Installing -- do not interrupt ...
/etc/puppet/modules
└─┬ puppetlabs-apache (v1.0.1)
├── puppetlabs-concat (v1.0.0) [/etc/puppet/modules]
└── puppetlabs-stdlib (v3.2.0) [/etc/puppet/modules]Installez également le modulepuppetlabs-mysql:
sudo puppet module install puppetlabs-mysqlLes modulesapache etmysql sont désormais disponibles!
Modifier le manifeste principal
Modifions maintenant notre manifeste principal afin qu’il utilise les nouveaux modules pour installer notre pile LAMP.
Sur le Puppetmaster, modifiez le manifeste principal:
sudo vi /etc/puppet/manifests/site.ppEn supposant que le fichier est vide, ajoutez les blocs de nœuds suivants (si vous avez suivi l'exemple 2, supprimez simplement le contenu du bloc de nœudslamp-1):
node default { }
node 'lamp-1' {
}Dans le bloc de nœudslamp-1, utilisez une déclaration de classe de type ressource pour utiliser le moduleapache (les commentaires en ligne expliquent chaque ligne):
class { 'apache': # use the "apache" module
default_vhost => false, # don't use the default vhost
default_mods => false, # don't load default mods
mpm_module => 'prefork', # use the "prefork" mpm_module
}
include apache::mod::php # include mod php
apache::vhost { 'example.com': # create a vhost called "example.com"
port => '80', # use port 80
docroot => '/var/www/html', # set the docroot to the /var/www/html
}Le moduleapache peut recevoir des paramètres qui remplacent le comportement par défaut du module. Nous transmettons certains paramètres de base qui désactivent l'hôte virtuel par défaut créé par le module et nous veillons à créer un hôte virtuel pouvant utiliser PHP. Pour une documentation complète du module PuppetLabs-Apache, consultez sesreadme.
L'utilisation du module MySQL est similaire à l'utilisation du module Apache. Nous allons garder les choses simples car nous n'utilisons pas réellement la base de données à ce stade. Ajoutez les lignes suivantes dans le bloc de noeud:
class { 'mysql::server':
root_password => 'password',
}Comme le module Apache, le module MySQL peut être configuré en passant des paramètres (full documentation here.
Ajoutons maintenant la ressource de fichier qui garantit que info.php sera copié au bon emplacement. Cette fois, nous utiliserons le paramètresource pour spécifier un fichier à copier. Ajoutez les lignes suivantes dans le bloc de noeud:
file { 'info.php': # file resource name
path => '/var/www/html/info.php', # destination path
ensure => file,
require => Class['apache'], # require apache class be used
source => 'puppet:///modules/apache/info.php', # specify location of file to be copied
}Cette déclaration de ressource de fichier est légèrement différente d'avant. La principale différence est que nous spécifions le paramètresource au lieu du paramètrecontent. Source dit à puppet de copier un fichier, au lieu de simplement spécifier le contenu du fichier. La source spécifiée,puppet:///modules/apache/info.php est interprétée par Puppet en/etc/puppet/modules/apache/files/info.php, nous devons donc créer le fichier source pour que cette déclaration de ressource fonctionne correctement.
Enregistrez et quittezsite.pp.
Créez le fichierinfo.php avec la commande suivante:
sudo sh -c 'echo "" > /etc/puppet/modules/apache/files/info.php'La prochaine fois que votre nœud d'agent Puppetlamp-1 extrait sa configuration du maître, il évaluera le manifeste principal et appliquera le module qui spécifie une configuration de pile LAMP. Si vous souhaitez l'essayer immédiatement, exécutez la commande suivante sur le nœud d'agentlamp-1:
sudo puppet agent --testUne fois terminé, vous verrez qu'une pile LAMP de base est configurée, exactement comme dans l'exemple 1. Pour vérifier qu'Apache et PHP fonctionnent, accédez à l'adresse IP publique delamp-1 dans un navigateur Web:
http://lamp_1_public_IP/info.phpVous devriez voir la page d'information pour votre installation de PHP.
Conclusion
Toutes nos félicitations! Vous avez utilisé Puppet pour configurer une pile Ubuntu 14.04 LAMP.
Maintenant que vous êtes familiarisé avec les bases du code de Puppet et que vous êtes capable d’écrire des manifestes et des modules de base, essayez d’utiliser Puppet pour configurer d’autres aspects de votre environnement.
Un bon point de départ est d'utiliser Puppet pour gérer les utilisateurs de votre système et les fichiers de configuration de vos applications. N'oubliez pas que si vous utilisez Puppet pour gérer les ressources, vous devez modifier ces ressources sur votre serveur maître Puppet, sinon elles seront écrasées la prochaine fois que vos nœuds agents effectueront leur demande d'extraction de catalogue périodique.
Bonne chance!