Comment installer Puppet pour gérer votre infrastructure de serveur

[.note] #Note: Une version plus récente de ce didacticiel, qui utilise Puppet Server au lieu de Puppet with Passenger, peut être trouvée ici:How To Install Puppet 4 in a Master-Agent Setup on Ubuntu 14.04.
#

introduction

Puppet, de Puppet Labs, est un outil de gestion de la configuration qui aide les administrateurs système à automatiser l’approvisionnement, la configuration et la gestion d’une infrastructure de serveur. En planifiant à l'avance et en utilisant des outils de gestion de la configuration tels que Puppet, vous réduirez le temps consacré à la répétition des tâches de base et garantissez la cohérence et la précision de vos configurations sur l'ensemble de votre infrastructure. Une fois que vous maîtriserez la gestion de vos serveurs avec Puppet et d’autres outils d’automatisation, vous gagnerez du temps, qui vous permettra d’améliorer d’autres aspects de votre configuration globale.

Il existe deux types de marionnettes: Puppet Enterprise et Open Source Puppet. Il fonctionne sur la plupart des distributions Linux, diverses plates-formes UNIX et Windows.

Dans ce didacticiel, nous expliquerons comment installer Puppet Open Source dans une configuration Agent / Master. Cette configuration se compose d'un serveurPuppet Master central, à partir duquel toutes vos données de configuration seront gérées et distribuées, et tous vos serveurs restants seront des nœudsPuppet Agent, qui peuvent être configurés par le serveur maître marionnette.

Conditions préalables

Pour suivre ce didacticiel, vous devez avoir un accès root à tous les serveurs avec lesquels vous souhaitez configurer Puppet. Vous devrez également créer un nouveau VPS Ubuntu 14.04 qui agira en tant que serveur maître de Puppet. Si vous n'avez pas d'infrastructure existante, n'hésitez pas à recréer l'exemple d'infrastructure (décrit ci-dessous) en suivant le didacticiel d'installation DNS requis.

Avant de commencer à installer Puppet, assurez-vous que les conditions préalables suivantes sont remplies:

  • Private Network DNS: Les DNS directs et inversés doivent être configurés et chaque serveur doit avoir un nom d'hôte unique. Voici un tutoriel surconfigure your own private network DNS server. Si vous n'avez pas configuré DNS, vous devez utiliser votre fichierhosts pour la résolution de noms. Nous supposerons que vous utiliserez votre réseau privé pour la communication au sein de votre infrastructure.

  • Firewall Open Ports: Le maître Puppet doit être accessible sur le port 8140. Si votre pare-feu est trop restrictif, consultez ceUFW Tutorial pour savoir comment autoriser les requêtes entrantes sur le port 8140.

Exemple d'infrastructure

Nous utiliserons l’infrastructure suivante pour montrer comment configurer Puppet:

Nom d'hôte Role FQDN privé

hôte1

Générique Ubuntu 14.04 VPS

host1.nyc2.example.com

host2

Générique Ubuntu 14.04 VPS

host2.nyc2.example.com

ns1

Serveur de noms principal

ns1.nyc2.example.com

ns2

Serveur de noms secondaire

ns2.nyc2.example.com

L'agent de marionnettes sera installé sur tous ces hôtes. Ces hôtes seront référencés par leurs interfaces réseau privées, mappées sur le sous-domaine «.nyc2.example.com» dans le système DNS. Il s'agit de la même infrastructure que celle décrite dans le didacticiel des prérequis:How To Configure BIND as a Private Network DNS Server on Ubuntu 14.04
.

Une fois toutes les conditions préalables remplies, passons à la création du serveur maître Puppet!

Créer un serveur maître de marionnettes

Créez un nouveau VPS x64Ubuntu 14.04, en utilisant «puppet» comme nom d'hôte. Ajoutez son réseau privé à votre DNS avec les détails suivants:

Nom d'hôte Role FQDN privé

fantoche

Maître de la marionnette

puppet.nyc2.example.com

Si vous venez de configurer votre DNS et que vous ne savez pas comment ajouter votre hôte au DNS, reportez-vous à la sectionMaintaining DNS Records du didacticiel DNS. Pour l'essentiel, vous devez ajouter un enregistrement "A" et "PTR" et permettre au nouvel hôte d'effectuer des requêtes récursives. Assurez-vous également de configurer votre domaine de recherche de sorte que vos serveurs puissent utiliser des noms d’hôte abrégés pour se rechercher.

L’utilisation de «marionnette» comme nom d’hôte du maître de marionnettes simplifie légèrement la configuration de l’agent, car c’est le nom par défaut que les agents utiliseront lorsqu’ils tenteront de se connecter au maître.

Nous devons maintenant configurer NTP.

Installer NTP

Parce qu’il agit en tant qu’autorité de certification pour les nœuds d’agent, le serveur maître de marionnettes doit conserver une heure système précise pour éviter tout problème éventuel lorsqu’il émet des certificats d’agent. Les certificats peuvent sembler expirés s’il existe des écarts de temps. Nous allons utiliser le protocole NTP (Network Time Protocol) à cette fin.

Tout d'abord, effectuez une synchronisation ponctuelle à l'aide de la commandentpdate:

sudo ntpdate pool.ntp.org

Votre heure système sera mise à jour, mais vous devez installer le démon NTP pour mettre à jour automatiquement l'heure afin de minimiser la dérive temporelle. Installez-le avec la commande apt suivante:

sudo apt-get update && sudo apt-get -y install ntp

Il est courant de mettre à jour la configuration NTP pour utiliser des «zones de pools» géographiquement plus proches de votre serveur NTP. Dans un navigateur Web, accédez auxNTP Pool Project et recherchez unpool zone qui ferme géographiquement le centre de données que vous utilisez. Nous irons avec le pool États-Unis (http://www.pool.ntp.org/zone/us) dans notre exemple, car les serveurs sont situés dans un datacenter de New York.

Ouvrezntp.conf pour l'édition:

sudo vi /etc/ntp.conf

Ajoutez les serveurs de temps de la page Projet de pool NTP en haut du fichier:

server 0.us.pool.ntp.org
server 1.us.pool.ntp.org
server 2.us.pool.ntp.org
server 3.us.pool.ntp.org

Sauvegarder et quitter. Redémarrez NTP pour ajouter les nouveaux serveurs de temps.

sudo service ntp restart

Maintenant que notre serveur garde l'heure exacte, installons le logiciel Puppet Master.

Installer le maître de marionnettes

Il y a plusieurs façons d'installer Puppet Open Source. Nous utiliserons le paquet debian appelépuppetmaster-passenger, qui est fourni par Puppet Labs. Le packagepuppetmaster-passenger inclut le Puppet Master plus un serveur Web prêt pour la production (Passenger avec Apache), ce qui élimine quelques étapes de configuration par rapport à l'utilisation du package de basepuppetmaster.

Téléchargez le package Puppet Labs:

cd ~; wget https://apt.puppetlabs.com/puppetlabs-release-trusty.deb

Installez le paquet:

sudo dpkg -i puppetlabs-release-trusty.deb

Mettre à jour la liste des paquets disponibles d'apt:

sudo apt-get update

Installez le packagepuppetmaster-passenger:

sudo apt-get install puppetmaster-passenger

Les packages Puppet master, Passenger, Apache et autres requis sont maintenant installés. Parce que nous utilisons Passenger avec Apache, le processus maître de Puppet est contrôlé par Apache, c.-à-d. il fonctionne quand Apache est en cours d'exécution.

Avant de continuer, arrêtez le maître Puppet en arrêtant le serviceapache2:

sudo service apache2 stop

Ensuite, nous voulons verrouiller la version de Puppet.

Verrouiller la version

Les changements de version en version peuvent parfois empêcher votre environnement Puppet de fonctionner correctement. Pour cette raison, vous souhaiterez conserver une version cohérente de Puppet sur l’ensemble de votre infrastructure. Si vous décidez de mettre à niveau vers une version plus récente, assurez-vous de mettre à niveau vosmaster avant tout nœud d'agent, car le maître ne peut pas gérer les agents qui ont un numéro de version plus élevé.

Regardons la version de notre installation de Puppet avec la commande suivante:

puppet help | tail -n 1

Au moment de l'écriture, la sortie de la commande précédente estPuppet v3.6.2. Nous pouvons utiliser la fonction de broche d'apt pour verrouiller notre installation Puppet sur3.6.*, ce qui empêchera apt de mettre à niveau Puppet vers une version majeure supérieure. Créez un nouveau fichier appelé dans le répertoire des préférences d’apt:

sudo vi /etc/apt/preferences.d/00-puppet.pref

Ajoutez les lignes suivantes pour verrouiller les packagespuppet,puppet-common etpuppetmaster-passenger aux3.6.* (modifiez ceci pour correspondre à votre version installée):

# /etc/apt/preferences.d/00-puppet.pref
Package: puppet puppet-common puppetmaster-passenger
Pin: version 3.6*
Pin-Priority: 501

Sauvegarder et quitter. Votre version de marionnette est maintenant verrouillée.

La prochaine étape consiste à configurer vos noms et certificats de maître Puppet.

Configurer les noms et les certificats

Puppet utilise des certificats SSL pour authentifier la communication entre les nœuds maître et agent. Le maître de marionnettes agit en tant qu'autorité de certification et doit générer ses propres certificats, utilisés pour signer les demandes de certificat d'agent. Nous allons installer les certificats du maître maintenant.

Supprimer les certificats existants

Supprimez tous les certificats SSL existants créés lors de l'installation du package. L’emplacement par défaut des certificats SSL de Puppet est/var/lib/puppet/ssl:

sudo rm -rf /var/lib/puppet/ssl

Configurer le certificat

Lors de la création du certificat du maître de marionnettes, incluez chaque nom DNS sur lequel les nœuds d’agent peuvent contacter le maître. Dans le cas de notre exemple, nous utiliserons “puppet” et “puppet.nyc2.example.com”, le nom d'hôte abrégé et le nom de domaine complet, respectivement.

Editez le fichier puppet.conf du maître:

sudo vi /etc/puppet/puppet.conf

Cela ressemblera à ceci:

[main]
logdir=/var/log/puppet
vardir=/var/lib/puppet
ssldir=/var/lib/puppet/ssl
rundir=/var/run/puppet
factpath=$vardir/lib/facter
templatedir=$confdir/templates

[master]
# These are needed when the puppetmaster is run by passenger
# and can safely be removed if webrick is used.
ssl_client_header = SSL_CLIENT_S_DN
ssl_client_verify_header = SSL_CLIENT_VERIFY

Supprimez la ligne avec l'optiontemplatedir, car cette option est obsolète.

Ajoutez les deux lignes suivantes à la fin de la section[main] (remplacez le texte en surbrillance par le FQDN privé):

certname = puppet
dns_alt_names = puppet,puppet.nyc2.example.com

Il est important d'utiliser assigncertname à «puppet» car la configuration Apache / Passenger s'attend à ce que le certificat soit nommé «puppet». Si vous décidez que vous souhaitez un paramètrecertname différent, veillez à modifier le fichier de configuration Apache (/etc/apache2/sites-available/puppetmaster.conf) pour changer le nom du chemin du certificat SSL.

Sauvegarder et quitter.

Générer un nouveau certificat

Créez maintenant de nouveaux certificats CA en exécutant la commande suivante:

sudo puppet master --verbose --no-daemonize

Vous verrez plusieurs lignes de sortie indiquant que des clés et des certificats SSL sont en cours de création. Une fois que vous voyezNotice: Starting Puppet master version 3.6.2, la configuration du certificat est terminée. Appuyez surCTRL-C pour revenir au shell.

Exemple de sortie:

Info: Creating a new SSL key for ca
Info: Creating a new SSL certificate request for ca
Info: Certificate Request fingerprint (SHA256): EC:7D:ED:15:DE:E3:F1:49:1A:1B:9C:D8:04:F5:46:EF:B4:33:91:91:B6:5D:19:AC:21:D6:40:46:4A:50:5A:29
Notice: Signed certificate request for ca
...
Notice: Signed certificate request for puppet
Notice: Removing file Puppet::SSL::CertificateRequest puppet at '/var/lib/puppet/ssl/ca/requests/puppet.pem'
Notice: Removing file Puppet::SSL::CertificateRequest puppet at '/var/lib/puppet/ssl/certificate_requests/puppet.pem'
Notice: Starting Puppet master version 3.6.2

Si vous souhaitez consulter les informations de certification du certificat qui vient d'être créé, tapez ce qui suit:

sudo puppet cert list -all

La commande précédente répertorie en fait tous les certificats signés et les demandes de certificats non signés. Actuellement, seul le certificat principal sera affiché, car aucun autre certificat n'a encore été ajouté:

+ "puppet" (SHA256) 05:22:F7:65:64:CF:46:0E:09:2C:5D:FD:8C:AC:9B:31:17:2B:7B:05:93:D5:D1:01:52:72:E6:DF:84:A0:07:37 (alt names: "DNS:puppet", "DNS:puppet.nyc2.example.com")

Notre service de maître de marionnettes est presque prêt à démarrer. Voyons d’abord la configuration principale.

Configurer le maître de marionnettes

Le fichier de configuration de marionnette principal,puppet.conf, se compose de trois sections:[main],[master] et[agent]. Comme vous l'avez peut-être deviné, la section «main» contient la configuration globale, la section «master» est spécifique au maître de marionnettes et «l'agent» est utilisé pour configurer l'agent de marionnette. Mis à part les modifications apportées plus tôt, les valeurs par défaut fonctionneront correctement pour une configuration de base.

Le fichier de configuration a beaucoup d'options qui pourraient être pertinentes pour votre propre configuration. Une description complète du fichier est disponible sur Puppet Labs:Main Config File (puppet.conf).

Si vous voulez l'éditer, lancez cette commande:

sudo vi /etc/puppet/puppet.conf

Jetons un coup d’œil au fichier manifeste principal.

Fichier manifeste principal

Puppet utilise un langage spécifique au domaine pour décrire les configurations système, et ces descriptions sont enregistrées dans des fichiers appelés «manifestes», qui ont une extension de fichier.pp. Le fichier manifeste principal par défaut se trouve dans/etc/puppet/manifests/site.pp. Nous couvrirons quelques manifestes de base plus tard, mais nous allons créer un fichier d’espace réservé pour le moment:

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

Démarrer le maître des marionnettes

Nous sommes maintenant prêts à démarrer le maître de marionnettes. Démarrez-le en exécutant le serviceapache2:

sudo service apache2 start

Votre maître de marionnettes est en cours d'exécution, mais il ne gère encore aucun nœud d'agent. Apprenons comment installer et ajouter des agents Puppet!

Installer l'agent de marionnettes

L'agent Puppet doit être installé sur tout serveur géré par le maître Puppet. Dans la plupart des cas, cela inclut tous les serveurs de votre infrastructure. Comme indiqué dans l'introduction, l'agent Puppet peut s'exécuter sur toutes les principales distributions Linux, certaines plates-formes UNIX et Windows. Comme l'installation varie légèrement d'un système d'exploitation à l'autre, nous ne couvrirons que l'installation sur les serveurs Ubuntu et Debian.

Les instructions pour installer Puppet sur d'autres plates-formes se trouvent dans lePuppet Labs Docs - assurez-vous de suivre la section «Installer Puppet sur les nœuds d'agent» pour le système d'exploitation de votre choix.

Note: On suppose que tous vos nœuds Puppet, y compris les nœuds d'agent, sont configurés pour utiliser votre DNS. Si vous créez un tout nouveau serveur, assurez-vous d'avoiradd it to your DNS avant d'installer l'agent Puppet.

Nœud Agent Ubuntu / Debian

Note: tous nos exemples de nœuds d'agent,host1,host2,ns1 etns2, sont Ubuntu 14.04 VPS. Nous allons répéter cette étape pour chaque serveur, afin que chacun puisse être géré par le maître de marionnettes.

Sur votre nœud d’agent Puppet, téléchargez le package Puppet Labs:

cd ~; wget https://apt.puppetlabs.com/puppetlabs-release-trusty.deb

Installez le paquet:

sudo dpkg -i puppetlabs-release-trusty.deb

Mettre à jour la liste des paquets disponibles d'apt:

sudo apt-get update

Installez le package de l'agent Puppet (puppet):

sudo apt-get install puppet

L'agent de marionnettes est désactivé par défaut. Pour changer cela, mettez à jour son fichier par défaut:

sudo vi /etc/default/puppet

Et changez la valeur deSTART en «oui»:

START=yes

Enregistrez et quittez/etc/default/puppet.

Verrouiller la version

Comme avec le maître de marionnettes, nous voudrons utiliser la fonctionnalité pin d'apt pour verrouiller la version de l'agent de marionnettes:

sudo vi /etc/apt/preferences.d/00-puppet.pref

Ajoutez les lignes suivantes pour verrouiller les packagespuppet etpuppet-common aux3.6.* (modifiez ceci pour correspondre à votre version installée):

# /etc/apt/preferences.d/00-puppet.pref
Package: puppet puppet-common
Pin: version 3.6*
Pin-Priority: 501

Sauvegarder et quitter. Votre version de marionnette est maintenant verrouillée.

Configurer l'agent

Avant d'exécuter l'agent, nous devons apporter quelques modifications à la configuration.

Modifiez lespuppet.conf de l'agent:

sudo vi /etc/puppet/puppet.conf

Cela ressemblera exactement au fichier de configuration initial du maître de marionnettes.

Encore une fois, supprimez la lignetemplatedir. Supprimez ensuite la section[master] et toutes les lignes en dessous.

En supposant que le maître de marionnettes soit accessible à «marionnette», l'agent devrait pouvoir se connecter au maître. Si le maître n’est pas disponible sur «marionnette», vous devrez ajouter le nom de domaine complet du marionnettiste. Nous vous recommandons de configurer cela indépendamment (remplacez le nom de domaine complet par le vôtre):

[agent]
server = puppet.nyc2.example.com

Sauvegarder et quitter.

L'agent de marionnettes est prêt à fonctionner. Faites-le en exécutant la commande suivante:

sudo service puppet start

Si tout est configuré correctement, vous ne devriez voir aucune sortie. La première fois que vous exécutez l'agent Puppet, il génère un certificat SSL et envoie une demande de signature au maître Puppet. Une fois que le maître de marionnettes a signé le certificat de l'agent, il pourra communiquer avec le nœud de l'agent.

Note: s'il s'agit de votre premier agent Puppet, il est recommandé d'essayer de signer le certificat sur le maître Puppet avant d'ajouter vos autres agents. Une fois que vous avez vérifié que tout fonctionne correctement, vous pouvez revenir en arrière et ajouter les nœuds d'agent restants en toute confiance.

Demande de signature sur le maître

La première fois que Puppet s'exécute sur un nœud d'agent, il envoie une demande de signature de certificat au maître Puppet. Avant que le maître puisse communiquer et contrôler le noeud de l’agent, il doit signer le certificat de ce noeud d’agent particulier. Nous allons décrire comment signer et vérifier les demandes de signature.

Liste des demandes de certificats en cours

Sur le maître de marionnettes, exécutez la commande suivante pour répertorier toutes les demandes de certificat non signé:

sudo puppet cert list

Si vous venez de configurer votre premier noeud d'agent, vous verrez une demande. Cela ressemblera à ce qui suit, avec le nom de domaine complet du noeud de l’agent comme nom d’hôte:

"host1.nyc2.example.com" (SHA256) B1:96:ED:1F:F7:1E:40:53:C1:D4:1B:3C:75:F4:7C:0B:A9:4C:1B:5D:95:2B:79:C0:08:DD:2B:F4:4A:36:EE:E3

Notez qu'il n'y a pas de+ devant lui. Cela indique qu'il n'a pas encore été signé.

Signer une demande

Pour signer une demande de certificat, utilisez la commandepuppet cert sign, avec le nom d'hôte du certificat que vous souhaitez signer. Par exemple, pour signerhost1.nyc2.example.com, vous utiliseriez la commande suivante:

sudo puppet cert sign host1.nyc2.example.com

Vous verrez la sortie suivante, qui indique que la demande de certificat a été signée:

Notice: Signed certificate request for host1.nyc2.example.com
Notice: Removing file Puppet::SSL::CertificateRequest host1.nyc2.example.com at '/var/lib/puppet/ssl/ca/requests/host1.nyc2.example.com.pem'

Le maître de marionnettes peut maintenant communiquer et contrôler le nœud auquel appartient le certificat signé.

Si vous souhaitez signer toutes les requêtes en cours, utilisez l'option-all, comme ceci:

sudo puppet cert sign --all

Révoquer des certificats

Vous voudrez peut-être supprimer un hôte de Puppet ou reconstruire un hôte puis le rajouter à Puppet. Dans ce cas, vous souhaiterez révoquer le certificat de l’hôte du maître des marionnettes. Pour ce faire, vous voudrez utiliser l'actionclean:

sudo puppet cert clean hostname

Les certificats associés à l’hôte spécifié seront supprimés de Puppet.

Afficher toutes les demandes signées

Si vous souhaitez afficher toutes les demandes, signées et non signées, exécutez la commande suivante:

sudo puppet cert list --all

Vous verrez une liste de toutes les demandes. Les demandes signées sont précédées d'un` and unsigned requests do not have the `.

  "ns2.nyc2.example.com"   (SHA256) E4:F5:26:EB:B1:99:1F:9D:6C:B5:4B:BF:86:14:40:23:E0:50:3F:C1:45:D0:B5:F0:68:6E:B2:0F:41:C7:BA:76
+ "host1.nyc2.example.com" (SHA256) 71:A2:D3:82:15:0D:80:20:D4:7E:E3:42:C2:35:87:83:79:2B:57:1D:D5:5A:EC:F6:8B:EE:51:69:53:EB:6B:A1
+ "host2.nyc2.example.com" (SHA256) F4:79:A6:7C:27:0C:EA:8E:BC:31:66:FF:F2:01:AB:B1:35:7B:9F:5E:C8:C9:CE:82:EE:E8:2F:23:9F:0C:2B:ED
+ "puppet"                 (SHA256) 05:22:F7:65:64:CF:46:0E:09:2C:5D:FD:8C:AC:9B:31:17:2B:7B:05:93:D5:D1:01:52:72:E6:DF:84:A0:07:37 (alt names: "DNS:puppet", "DNS:puppet.nyc2.example.com")

Félicitations! Votre infrastructure est maintenant prête à être gérée par Puppet!

Débuter avec Puppet

Maintenant que votre infrastructure est configurée pour être gérée avec Puppet, nous allons vous montrer comment effectuer quelques tâches de base pour vous aider à démarrer.

Comment sont rassemblés les faits

Puppet rassemble des faits sur chacun de ses nœuds avec un outil appeléfacter. Facter, par défaut, rassemble des informations utiles pour la configuration du système (par exemple, Noms de système d'exploitation, noms d'hôte, adresses IP, clés SSH, etc.). Il est possible d’ajouter des faits personnalisés si vous avez besoin d’autres faits pour effectuer vos configurations.

Les faits rassemblés peuvent être utiles dans de nombreuses situations. Par exemple, vous pouvez créer un modèle de configuration de serveur Web et renseigner automatiquement les adresses IP appropriées pour un hôte virtuel particulier. Ou vous pouvez déterminer que le système d'exploitation de votre serveur est «Ubuntu», vous devez donc exécuter le serviceapache2 au lieu dehttpd. Ce sont des exemples basiques, mais ils devraient vous donner une idée de la manière dont les faits peuvent être utilisés.

Pour afficher une liste des faits collectés automatiquement sur votre noeud d'agent, exécutez la commande suivante:

facter

Comment le manifeste principal est-il exécuté?

L'agent de marionnettes s'enquiert périodiquement auprès du maître des marionnettes (généralement toutes les 30 minutes). Pendant ce temps, il enverra des informations sur lui-même au maître et extraira un catalogue en cours, une liste compilée des ressources et de leurs états souhaités qui sont pertinents pour l'agent, déterminées par le manifeste principal. Le nœud d'agent tentera ensuite d'apporter les modifications appropriées pour atteindre l'état souhaité. Ce cycle se poursuivra tant que le maître de marionnettes est en cours d'exécution et communique avec les nœuds d'agent.

Exécution immédiate sur un nœud d'agent particulier

Il est également possible de lancer manuellement la vérification d'un noeud d'agent particulier en exécutant la commande suivante (sur le noeud d'agent en question):

puppet agent --test

Cette opération appliquera le manifeste principal à l'agent exécutant le test. Vous pouvez voir une sortie comme celle-ci:

Info: Retrieving pluginfacts
Info: Retrieving plugin
Info: Loading facts in /var/lib/puppet/lib/facter/pe_version.rb
Info: Loading facts in /var/lib/puppet/lib/facter/puppet_vardir.rb
Info: Loading facts in /var/lib/puppet/lib/facter/root_home.rb
Info: Loading facts in /var/lib/puppet/lib/facter/facter_dot_d.rb
Info: Caching catalog for host1.nyc2.example.com
Info: Applying configuration version '1407966707'

Cette commande est utile pour voir comment le manifeste principal affectera immédiatement un seul serveur.

Manifestes ponctuels

La commandepuppet apply vous permet d'exécuter des manifestes qui ne sont pas liés au manifeste principal, à la demande. Il applique uniquement le manifeste au nœud à partir duquel vous exécutez le programme apply. Voici un exemple:

sudo puppet apply /etc/puppet/modules/test/init.pp

L'exécution de manifestes de cette manière est utile si vous souhaitez tester un nouveau manifeste sur un nœud d'agent ou si vous souhaitez simplement exécuter un manifeste une fois (par exemple, pour initialiser un noeud d’agent à l’état souhaité).

Un simple manifeste

Comme vous vous en souvenez peut-être, le fichier manifeste principal sur le maître Puppet se trouve à/etc/puppet/manifests/site.pp.

Sur lemaster, modifiez-le maintenant:

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

Ajoutez maintenant les lignes suivantes pour décrire une ressource de fichier:

file {'/tmp/example-ip':                                            # resource type file and filename
  ensure  => present,                                               # make sure it exists
  mode    => 0644,                                                  # file permissions
  content => "Here is my Public IP Address: ${ipaddress_eth0}.\n",  # note the ipaddress_eth0 fact
}

Maintenant, enregistrez et quittez. Les commentaires en ligne doivent expliquer la ressource que nous définissons. En clair, cela feraensure que tous les nœuds d'agent auront un fichier à/tmp/example-ip, avec les autorisations-rw-r--r--, et du texte contenant l'adresse IP publique du nœud.

Vous pouvez soit attendre que l'agent s'enregistre automatiquement auprès du maître, soit exécuter la commandepuppet agent --test (à partir de l'un de vos nœuds d'agent). Puis exécutez la commande suivante pour imprimer le fichier:

cat /tmp/example-ip

Vous devriez voir un résultat ressemblant à ce qui suit (avec l’adresse IP de ce nœud):

Here is my Public IP Address: 128.131.192.11.

Spécifier un nœud

Si vous souhaitez définir une ressource pour des nœuds spécifiques, définissez unnode dans le manifeste.

Sur le maître, éditezsite.pp:

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

Maintenant, ajoutez les lignes suivantes:

node 'ns1', 'ns2' {    # applies to ns1 and ns2 nodes
  file {'/tmp/dns':    # resource type file and filename
    ensure => present, # make sure it exists
    mode => 0644,
    content => "Only DNS servers get this file.\n",
  }
}

node default {}       # applies to nodes that aren't explicitly defined

Sauvegarder et quitter.

Désormais, Puppet s'assurera qu'un fichier à/tmp/dns existera surns1 etns2. Vous pouvez exécuter la commandepuppet agent --test (à partir de ns1 ou ns2), si vous ne souhaitez pas attendre l'extraction programmée de l'agent Puppet.

Notez que si vous ne définissez pas de ressource, Puppet fera de son mieux pour ne pas y toucher. Ainsi, si vous supprimez ces ressources du manifeste, Puppet ne supprimera pas les fichiers créés. Si vous voulez qu'il supprime les fichiers, remplacezensure parabsent.

Ces exemples ne servent à rien, mais ils prouvent que Puppet fonctionne correctement.

Utiliser un module

Maintenant, utilisons un module. Les modules sont utiles pour regrouper des tâches. De nombreux modules sont disponibles dans la communauté Puppet et vous pouvez même écrire les vôtres.

Sur le maître Puppet, installez le modulepuppetlabs-apache de forgeapi:

sudo puppet module install puppetlabs-apache

Warning: n'utilisez pas ce module sur une configuration Apache existante. Il purgera toutes les configurations Apache qui ne sont pas gérées par Puppet.

Maintenant, éditezsite.pp:

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

Ajoutez maintenant les lignes suivantes pour installer Apache surhost2:

node 'host2' {
  class { 'apache': }             # use apache module
  apache::vhost { 'example.com':  # define vhost resource
    port    => '80',
    docroot => '/var/www/html'
  }
}

Sauvegarder et quitter. Désormais, la prochaine fois que Puppet mettra à jour host2, il installera le package Apache et configurera un hôte virtuel appelé «example.com», à l'écoute sur le port 80, et avec une racine de document/var/www/html.

Surhost2, exécutez la commande suivante:

sudo puppet agent --test

Vous devriez voir un tas de résultats indiquant qu'Apache est en cours d'installation. Une fois l'opération terminée, accédez à l'adresse IP publique dehost2. Vous devriez voir la page d'accueil par défaut d'Apache.

Félicitations! Vous avez utilisé votre premier module de marionnettes!

Conclusion

Maintenant que vous disposez d'une installation de base de puppet agent / maître, vous êtes maintenant prêt à en apprendre davantage sur l'utilisation de Puppet pour gérer votre infrastructure de serveur. Consultez le didacticiel suivant:Getting Started With Puppet Code: Manifests and Modules.

Related