TOC

Comment configurer un environnement de marionnettes sans maître sur Ubuntu 14.04

introduction

Dans le monde moderne du cloud computing, la gestion de la configuration est une étape cruciale. Les outils de gestion de la configuration vous permettent de déployer de manière fiable des configurations sur vos serveurs. L’un des outils de gestion de la configuration les plus avancés dans cet espace est Puppet.

Dans un environnement Puppet typique, un utilisateur écrit des modules de Puppet sur son poste de travail et les envoie sur un serveur de contrôle de version (par exemple, Git), puis tire ces modules vers un maître de marionnettes. Un serveur exécutant le client Puppet se connecte périodiquement au maître Puppet pour vérifier si quelque chose a changé et applique les modifications le cas échéant.

Ce scénario fonctionne parfaitement jusqu’à ce que vous deviez commencer à augmenter le nombre de serveurs en cours d’enregistrement ou la complexité des modules. À ce stade, vous avez deux options: regrouper votre maître de marionnettes pour gérer la charge (ce qui nécessitera probablement l’achat de la version commerciale de Puppet) ou simplement supprimer le maître de marionnettes. Cet article examinera la deuxième option.

Une configuration Puppet sans maître nécessite la copie de tous les modules de Puppet sur chaque nœud via Git, puis de faire appliquer les modifications localement par Puppet. L’inconvénient de cette méthode est que chaque serveur télécharge tous les modules, puis applique ce qui est pertinent, ce n’est donc pas le meilleur choix, par exemple. configurations avec des informations sensibles. Cependant, fonctionner sans maître de marionnettes vous donne beaucoup de flexibilité et fonctionne très bien sans avoir à redimensionner votre infrastructure.

Conditions préalables

Si vous êtes nouveau dans Puppet, vous pouvez vous arrêter ici pour lire cet article sur Puppet d’abord, car ce didacticiel suppose une connaissance pratique de l’outil. Si vous êtes nouveau dans Git, vous pouvez également consulter cette introduction à la série Git.

Dans ce didacticiel, nous allons utiliser deux droplets: l’un fonctionnant en tant que serveur Git et l’autre auquel nous appliquerons les modifications via Puppet. Nous nous référerons aux adresses IP de ces Droplets avec + your_git_server_ip + et + your_puppet_server_ip + respectivement.

Donc, pour suivre ce tutoriel, vous aurez besoin de:

Le moyen le plus simple de configurer Git Labs consiste à utiliser l’image d’un clic: sur la page de création de gouttelettes sous * Sélectionner une image *, cliquez sur l’onglet * Applications *, puis sur * GitLab 7.10.0 CE le 14.04 *. Vous pouvez également suivre ce tutoriel pour configurer Git Labs. manuellement.

Étape 1 - Création d’un référentiel Git

La première étape consiste à créer un référentiel dans lequel tous les modules et les manifestes de Puppet seront stockés.

Tout d’abord, ouvrez l’interface utilisateur de Git Labs en accédant à «+ http: // +» dans votre navigateur préféré. Créez un compte en renseignant les détails à droite sous * Nouvel utilisateur? Créez un compte * et appuyez sur le bouton vert * Inscription *. Vous recevrez un e-mail d’activation de compte et, après l’activation de votre compte, vous pourrez vous connecter sur la page principale.

Cliquez sur le bouton vert * + Nouveau projet * sur la page principale. Entrez «marionnette» pour le * chemin du projet *, puis cliquez sur * Créer un projet *. Entrez «marionnette» dans le champ * Chemin du projet * et choisissez * Public * pour le * Niveau de visibilité *, puis cliquez sur le bouton vert * Créer un projet *.

Assurez-vous de copier l’URL SSH, que vous verrez en haut de l’écran de projet, car nous en aurons besoin ultérieurement. Cela ressemblera à quelque chose comme + git @: / puppet.git +.

Étape 2 - Ajout d’une clé SSH à Git Labs

Dans cette étape, nous allons créer une clé SSH sur le serveur Puppet, puis ajouter cette clé au serveur Git Labs.

Connectez-vous au serveur Puppet en tant que * racine *. (Les fichiers de Puppet étant la propriété de root, nous devons disposer des droits nécessaires pour configurer le référentiel Git initial dans le dossier Puppet.)

Créez une clé SSH pour l’utilisateur root. Veillez à ne pas entrer de phrase secrète car cette clé sera utilisée par les scripts et non par l’utilisateur.

ssh-keygen -t rsa

Ensuite, affichez votre clé publique avec la commande suivante.

cat ~/.ssh/id_rsa.pub

Copiez cette clé. Cela ressemblera à quelque chose comme + ssh-rsa long_alphanumeric_string root @ +.

Maintenant, sur votre page Tableau de bord Git Labs, cliquez sur l’icône * Paramètres du profil * dans la barre du haut, la deuxième à partir de la droite. Dans le menu de gauche, cliquez sur * SSH Keys *, puis sur le bouton vert * Ajouter une clé SSH *. Dans le champ * Title *, ajoutez une description de la clé (par exemple, «Root Puppet Key») et collez votre clé publique dans le champ * Key *. Enfin, cliquez sur * Ajouter une clé *.

Étape 3 - Installer Puppet et Git

Dans cette étape, nous allons installer Puppet et Git.

Sur le serveur Puppet, commencez par télécharger le paquet Puppet pour Ubuntu 14.04.

wget http://apt.puppetlabs.com/puppetlabs-release-trusty.deb

Installez le paquet.

dpkg -i /tmp/puppetlabs-release-trusty.deb

Mettez à jour la liste de paquets de votre système.

apt-get update

Enfin, installez Puppet et git.

apt-get install puppet git-core

À ce stade, vous devez configurer votre environnement Git en suivant les instructions fournies à l’adresse https://www.digitalocean.com/community/tutorials/how-to-install-git-on-ubuntu-14-04#how-to-set. -up-git [ce tutoriel].

Étape 4 - Modification de la configuration initiale de la marionnette

Avec Puppet et Git installés, nous sommes prêts à effectuer notre premier travail dans notre référentiel Puppet.

Tout d’abord, déplacez-vous dans le répertoire + / etc / puppet +, où résident les fichiers de configuration.

cd /etc/puppet

Initialisez un dépôt git ici.

git init

Ajouter tout dans le répertoire en cours.

git add .

Commettez ces modifications avec un commentaire descriptif.

git commit -m ""

Ajoutez le projet Git que nous avons créé précédemment comme origine à l’aide de l’URL SSH que vous avez copiée à l’étape 1.

git remote add origin git@:/puppet.git

Et enfin, appuyez sur les modifications.

git push -u origin master

Étape 5 - Nettoyage de la configuration de la marionnette

Maintenant que Puppet est installé, nous pouvons tout mettre en place. À ce stade, vous pouvez vous déconnecter en tant que root et vous connecter à la place en tant qu’utilisateur sudo non root que vous avez créé au cours des conditions préalables. Ce n’est pas une bonne pratique de fonctionner en tant qu’utilisateur root à moins que cela ne soit absolument nécessaire.

Pour que la fondation soit en place, nous devons apporter quelques changements. Premièrement, nous allons nettoyer le fichier + / etc / puppet / puppet.conf. En utilisant votre éditeur favori (vim, nano, etc.), éditez + / etc / puppet / puppet.conf + avec les modifications suivantes.

Commençons par apporter quelques modifications au fichier + / etc / puppet / puppet.conf pour votre configuration spécifique. Ouvrez le fichier en utilisant nano ou votre éditeur de texte préféré.

sudo nano /etc/puppet/puppet.conf

Le fichier ressemblera à ceci:

/Etc/puppet/puppet.conf d’origine

[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

Tout d’abord, supprimez tous les éléments de la ligne + [master] +, car nous n’exécutons pas de maître de marionnettes. Supprimez également la dernière ligne de la section + [main] + qui commence par + templatedir +, car elle est obsolète. Enfin, changez la ligne qui se lit + factpath = $ vardir / lib / facter + à + ​​factpath = $ confdir / facter + à la place. + $ confdir + est équivalent à + ​​/ etc / puppet / +, i.e. notre référentiel de marionnettes.

Voici à quoi votre + puppet.conf devrait ressembler une fois que vous avez terminé les modifications ci-dessus.

/Etc/puppet/puppet.conf modifié

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

Étape 6 - Ajout d’un module de marionnettes

Maintenant, Puppet est installé, mais il ne fait aucun travail. La façon dont fonctionne Puppet consiste à examiner les fichiers appelés manifestes qui définissent ce qu’elle doit faire. Nous allons donc, dans cette étape, créer un module utile à l’exécution de Puppet.

Notre premier module, que nous appellerons cron-puppet, déploiera Puppet via Git. Il installera un hook Git qui exécutera Puppet après une fusion réussie (par exemple, git pull), et il installera un travail cron pour effectuer un + git pull + toutes les 30 minutes.

Tout d’abord, accédez au répertoire des modules de Puppet.

cd /etc/puppet/modules

Ensuite, créez un répertoire + cron-puppet + contenant les répertoires + manifestests + et + + fichiers +.

sudo mkdir -p cron-puppet/manifests cron-puppet/files

Créez et ouvrez un fichier nommé + init.pp + dans le répertoire + manifestests +.

sudo nano cron-puppet/manifests/init.pp

Copiez le code suivant dans + init.pp +. C’est ce qui dit à Puppet de retirer Git toutes les demi-heures.

init.pp

class cron-puppet {
   file { 'post-hook':
       ensure  => file,
       path    => '/etc/puppet/.git/hooks/post-merge',
       source  => 'puppet:///modules/cron-puppet/post-merge',
       mode    => 0755,
       owner   => root,
       group   => root,
   }
   cron { 'puppet-apply':
       ensure  => present,
       command => "cd /etc/puppet ; /usr/bin/git pull",
       user    => root,
       minute  => '*/30',
       require => File['post-hook'],
   }
}

Enregistrez et fermez le fichier, puis ouvrez un autre fichier nommé + post-merger dans le répertoire` + fichiers dans`.

sudo nano cron-puppet/files/post-merge

Copiez le script bash suivant dans + post-merge +. Ce script bash sera exécuté après une fusion réussie de Git et enregistrera le résultat de l’exécution.

post-fusion

#!/bin/bash -e
## Run Puppet locally using puppet apply
/usr/bin/puppet apply /etc/puppet/manifests/site.pp

## Log status of the Puppet run
if [ $? -eq 0 ]
then
   /usr/bin/logger -i "Puppet has run successfully" -t "puppet-run"
   exit 0
else
   /usr/bin/logger -i "Puppet has ran into an error, please run Puppet manually" -t "puppet-run"
   exit 1
fi

Sauvegarder et fermer ce fichier

Enfin, nous devons dire à Puppet d’exécuter ce module en créant un manifeste global, que l’on trouve canoniquement dans + / etc / puppet / manifestests / site.pp +.

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

Collez le texte suivant dans + site.pp +. Cela crée une classification de nœud appelée ‘default’. Tout ce qui est inclus dans le nœud "par défaut" sera exécuté sur chaque serveur. Ici, nous lui disons de lancer notre module + cron-puppet +.

site.pp

node default {
   include cron-puppet
}

Enregistrez et fermez le fichier. Maintenant, assurons-nous que notre module fonctionne en l’exécutant.

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

Après une exécution réussie, vous devriez voir une sortie se terminant par une ligne comme celle-ci.

...

Notice: Finished catalog run in 0.18 seconds

Enfin, engageons nos modifications dans le référentiel Git. Commencez par vous connecter en tant qu’utilisateur root, car il s’agit d’un utilisateur disposant d’un accès clé SSH au référentiel.

Ensuite, accédez au répertoire + / etc / puppet +.

cd /etc/puppet

Ajoutez tout ce qui se trouve dans ce répertoire au commit.

git add .

Commettez les modifications avec un message descriptif.

git commit -m ""

Enfin, appuyez sur les modifications.

git push -u origin master

Conclusion

Pour ajouter plus de serveurs, suivez simplement l’étape 3 ci-dessus pour installer Puppet et Git sur le nouveau serveur, puis clonez le référentiel Git dans + / etc / puppet + et appliquez le manifeste + site.pp +.

Vous pouvez même automatiser cette installation en utilisant user data lorsque vous créez un Droplet. Veillez à utiliser une clé SSH lors de la création du droplet et à l’ajouter à votre serveur GitLab. Ensuite, cochez la case * Activer les données utilisateur * sur l’écran de création de Droplet et entrez le script bash suivant, en remplaçant les variables surlignées en rouge par les vôtres.

#!/bin/bash -e

## Install Git and Puppet
wget -O /tmp/puppetlabs.deb http://apt.puppetlabs.com/puppetlabs-release-`lsb_release -cs`.deb
dpkg -i /tmp/puppetlabs.deb
apt-get update
apt-get -y install git-core puppet

# Clone the 'puppet' repo
cd /etc
mv puppet/ puppet-bak
git clone http:////puppet.git /etc/puppet

# Run Puppet initially to set up the auto-deploy mechanism
puppet apply /etc/puppet/manifests/site.pp

C’est tout! Vous avez maintenant un système Puppet sans maître et pouvez activer un nombre quelconque de serveurs supplémentaires sans même avoir à vous connecter.

Related