Tutoriel de marionnettes pour débutants : Bases et DSL
David Carter
⚡ Résumé intelligent
Puppet est une plateforme de gestion de configuration open source qui automatise le provisionnement, la configuration et la maintenance des serveurs. Elle utilise l'infrastructure en tant que code via un langage déclaratif dédié au domaine, remplaçant ainsi les tâches d'administration manuelles répétitives sur de vastes parcs de serveurs.
Puppet est un outil de gestion de configuration open source qui permet de définir l'infrastructure sous forme de code et de maintenir de vastes parcs de serveurs dans un état cohérent et reproductible. Avant d'apprendre Puppet, commençons par comprendre la gestion de configuration.
Qu'est-ce que la gestion des configurations ?
La gestion de la configuration est le processus de maintien des logiciels et des systèmes informatiques (serveurs, stockage, réseaux, etc.) dans un état connu, souhaité et cohérent. Elle permet également d'accéder à un historique précis de l'état du système à des fins de gestion de projet et d'audit.
Les administrateurs système effectuent principalement des tâches répétitives, comme l'installation et la configuration des serveurs. Ces professionnels peuvent automatiser ce travail en écrivant des scripts.
Cependant, cette tâche se complexifie lorsqu'il s'agit d'infrastructures de grande envergure. Des outils de gestion de configuration tels que Puppet ont été mis en place pour résoudre ces problèmes.
C'est quoi Marionnette ?
Fantoche Puppet est un outil de gestion de systèmes permettant de centraliser et d'automatiser le processus de gestion de la configuration. Il est également utilisé comme outil de déploiement logiciel.
Il s'agit d'un logiciel de gestion de configuration open source, largement utilisé pour la configuration, la gestion, le déploiement et l'orchestration de diverses applications et services au sein de l'infrastructure d'une organisation.
Puppet est spécialement conçu pour gérer la configuration de Linux et Windows systèmes. Il est écrit en Ruby et utilise son unique Domain Sspécifique Llangage (DSL) pour décrire la configuration du système.
Quelles sont les versions Puppet ?
Puppet est disponible en deux versions :
- Marionnette Open SourceIl s'agit d'une version de base de l'outil de gestion de configuration Puppet, également connu sous le nom de Puppet Open Source. Elle est disponible directement sur le site web de Puppet et est distribuée sous licence Apache 2.0.
- Puppet EnterpriseUne version commerciale offrant des fonctionnalités telles que la génération de rapports de conformité, l'orchestration, le contrôle d'accès basé sur les rôles, une interface graphique, une API et des outils en ligne de commande pour une gestion efficace des nœuds.
Que peut faire Puppet ?
Par exemple, supposons que vous ayez une infrastructure composée d'une centaine de serveurs. En tant qu'administrateur système, votre rôle est de veiller à ce que tous ces serveurs soient toujours à jour et fonctionnent parfaitement.
Pour ce faire, vous pouvez utiliser Puppet, qui vous permet d'écrire du code simple déployable automatiquement sur ces serveurs. Cela réduit l'intervention humaine et rend le processus de développement rapide et efficace.
Puppet remplit les fonctions suivantes :
- Puppet vous permet de définir des configurations distinctes pour chaque hôte.
- Cet outil permet de surveiller en continu les serveurs afin de vérifier que la configuration requise existe et n'a pas été modifiée. En cas de modification de la configuration, Puppet rétablit la configuration prédéfinie sur l'hôte.
- Il permet également de contrôler chaque système configuré, de sorte qu'une modification centralisée est automatiquement appliquée partout.
- Il est également utilisé comme outil de déploiement, car il déploie automatiquement des logiciels sur le système. Il implémente L'infrastructure sous forme de code, car les politiques et les configurations sont écrites sous forme de code.
Puppet DSL et paradigmes de programmation
Avant d'apprendre le langage Puppet DSL, comprenons les paradigmes de programmation. Un paradigme de programmation est un style de programmation informatique.
Quatre types de paradigmes sont :
- Impératif.
- Déclaratif.
- Fonctionnel (qui est considéré comme un sous-ensemble du paradigme déclaratif).
- Orienté objet.
Nous nous concentrerons sur les paradigmes impératif et déclaratif.
Paradigmes impératifs
Ce paradigme de programmation exprime la logique d'un calcul (ce qu'il faut faire) et décrit également son flux de contrôle (comment le faire).
Exemple :
Imaginez que vous vous rendez à votre bureau. Vous réservez un taxi et commencez à donner des instructions précises au chauffeur, étape par étape, jusqu'à votre arrivée. Indiquer quoi faire et comment le faire correspond à un style impératif.
Paradigmes déclaratifs
Ce paradigme de programmation exprime la logique d'un calcul (ce qu'il faut faire) sans décrire son flux de contrôle (comment le faire).
Exemple :
Supposons que vous vous rendiez à votre bureau. Vous réservez un Uber et précisez uniquement la destination finale (le bureau). Indiquer ce qu'il faut faire, sans préciser comment, correspond à un style déclaratif.
| Paradigme | Que faire | Comment faire |
|---|---|---|
| Impératif | Oui | Oui |
| Déclaratif | Oui | Non |
Puppet utilise un paradigme de programmation déclarative
Puppet utilise une approche de programmation déclarative.
Exemple : Créez un utilisateur sur le système.
Cela peut se faire en utilisant un modèle de programmation impératif avec un script shell. Ici, nous spécifions comment créer l'utilisateur et quelles commandes utiliser sur le système. le système d'exploitation.
Cependant, il est également possible d'obtenir le même résultat en utilisant un modèle de programmation déclaratif avec seulement quelques lignes de code Puppet et le langage spécifique au domaine (DSL) de Puppet.
Modèles de déploiement d'outils de gestion de configuration
Il existe deux modèles de déploiement pour outils de gestion de configuration:
- Modèle de déploiement basé sur le push : initié par un nœud maître.
- Modèle de déploiement basé sur le pull : initié par les agents.
Modèle de déploiement basé sur le push
Dans ce modèle de déploiement, le serveur maître envoie les configurations et les logiciels aux agents individuels. Après avoir vérifié une connexion sécurisée, le maître exécute des commandes à distance sur les agents. Par exemple, Ansible et pile de sel.
Modèle de déploiement basé sur le principe du pull
Dans ce modèle de déploiement, chaque serveur contacte un serveur maître, vérifie et établit une connexion sécurisée, télécharge sa configuration et ses logiciels, puis se configure en conséquence — par exemple, Puppet et Chef.
Comment fonctionne Puppet ?
Puppet repose sur un modèle de déploiement par extraction, où les nœuds agents se connectent régulièrement, après chaque 1800 En quelques secondes, l'agent communique avec le nœud maître pour vérifier si des mises à jour sont nécessaires. Si c'est le cas, il récupère le code Puppet requis auprès du maître et effectue les actions nécessaires.
Prenons l'exemple d'une configuration maître-agent pour illustrer cela.
Le Maître
Il s'agit d'une machine Linux sur laquelle est installé le logiciel maître Puppet. Ce dernier est chargé de gérer les configurations sous forme de code Puppet. Le nœud maître doit impérativement être sous Linux.
Les agents
Ce sont les machines cibles gérées par Puppet, sur lesquelles le logiciel agent Puppet est installé.
L'agent peut être configuré sur n'importe quel système d'exploitation pris en charge, tel que Linux, Windows, Solarisou Mac OS.
La communication entre le maître et l'agent est établie via des certificats sécurisés.
Communication entre le maître et l'agent
Étape 1) Une fois la connexion établie entre l'agent et le serveur maître, l'agent Puppet envoie au serveur maître des données relatives à son état. Ces données, appelées « faits », comprennent notamment le nom d'hôte, les détails du noyau, l'adresse IP et les noms de fichiers.
Étape 2) Le serveur Puppet utilise ces données et compile une liste de la configuration à appliquer à l'agent. Cette liste de configuration à exécuter sur un agent est appelée une configuration de sécurité. catalogueCela peut inclure l'installation, la mise à niveau ou la suppression de paquets, la création de systèmes de fichiers, la création ou la suppression d'utilisateurs, le redémarrage du serveur, les modifications de la configuration IP, etc.
Étape 3) L'agent utilise cette liste de configuration pour appliquer toutes les modifications de configuration requises sur le nœud.
S'il n'y a pas de dérive dans la configuration, l'agent n'effectue aucune modification de configuration et laisse le nœud fonctionner avec la même configuration.
Étape 4) Une fois l'opération terminée, le nœud renvoie un rapport au serveur Puppet maître, indiquant que la configuration a été appliquée et finalisée.
Blocs de marionnettes
Puppet offre la possibilité d'intégrer des rapports avec des outils tiers grâce aux API Puppet.
Les quatre types de blocs de construction pour marionnettes sont :
- Ressources
- Cours
- Manifeste
- Modules
Ressources sur les marionnettes
Les ressources Puppet sont les éléments constitutifs de Puppet.
Les ressources sont les fonctions intégrées qui s'exécutent en arrière-plan pour effectuer les opérations requises dans Puppet.
Cours de marionnettes
Différentes ressources peuvent être regroupées en une seule unité appelée classe.
Manifeste de marionnettes
Un manifeste est un répertoire contenant des fichiers DSL Puppet. Ces fichiers ont l'extension .pp, qui signifie « programme Puppet ». Le code Puppet est constitué de définitions ou de déclarations de classes Puppet.
Modules de marionnettes
Les modules sont un ensemble de fichiers et de répertoires, tels que des manifestes et des définitions de classes. Ce sont les unités réutilisables et partageables de Puppet.
Par exemple, MySQL le module installe et configure MySQLainsi que, Jenkins le module gère Jenkins.
Types de ressources Puppet
De manière générale, un système se compose de fichiers, d'utilisateurs, de services, de processus, de paquets, etc. Dans Puppet, ces éléments sont appelés ressources et constituent les composants fondamentaux de Puppet.
Toutes les opérations sur les agents Puppet sont réalisées à l'aide des ressources Puppet.
Les ressources Puppet sont des outils prêts à l'emploi permettant d'effectuer diverses tâches et opérations sur toute plateforme prise en charge. On peut utiliser une seule ressource Puppet pour réaliser une tâche spécifique, ou en utiliser plusieurs conjointement pour déployer des configurations d'applications complexes.
Les ressources peuvent avoir différents types. Utilisations des marionnettes Ressources et types de ressources afin de décrire la configuration d'un système.
Il existe trois types de ressources :
- Noyau de marionnette ou types de ressources intégrés.
- Types de ressources définis par Puppet.
- Types de ressources personnalisées Puppet.
Noyau de marionnette ou types de ressources intégrées
Les types de ressources de base ou intégrés sont les types de ressources Puppet préconfigurés et fournis avec le logiciel Puppet. Tous ces types de ressources sont développés et maintenus par l'équipe Puppet.
Types de ressources définis par Puppet
Les types de ressources définis sont des types de ressources légers écrits dans le langage déclaratif Puppet en utilisant une combinaison de types de ressources existants.
Types de ressources personnalisées Puppet
Les types de ressources personnalisés sont des types de ressources entièrement personnalisés écrits en Ruby.
Explorons plus en détail les types de ressources Puppet.
Dans le terminal, saisissez la commande suivante pour afficher la liste des sous-commandes liées à Puppet :
Puppet --help
Dans notre cas, nous nous intéressons à la sous-commande «ressource« », que nous utiliserons pour trouver des informations sur les types de ressources Puppet intégrés.
Dans le terminal, tapez l'une des commandes suivantes pour afficher une liste de actes associé à la sous-commande Puppet «ressource"
Puppet help resource Puppet resource --help
Dans ce cas, nous avons ressource comme sous-commande et -les types comme l'action.
Puppet dispose de 49 types de ressources de base intégrés.
Dans le terminal, saisissez la commande suivante pour afficher la liste des types de ressources Puppet intégrés disponibles :
puppet resource –types
Chaque type prend en charge une liste de attributs. Ces attributs fournissent une description détaillée que Puppet utilise pour gérer la ressource.
Pour connaître tous les attributs associés à un type de ressource Puppet, utilisez la commande suivante :
puppet describe <resource type name>
Les paramètres listeront tous les attributs disponibles pour ce type de ressource.
paquet de description de marionnette
Il est difficile pour une nouvelle personne de comprendre et de s'approprier de nombreux fichiers de code Puppet non gérés. C'est là que nous avons besoin d'un groupe.ping L'objectif est de coordonner les opérations entre elles, afin de résoudre un problème unique, comme par exemple la configuration complète du protocole SSH sur un serveur, d'un service NTP, ou encore d'un serveur web ou d'un serveur de base de données.
Que sont les cours de marionnettes ?
Les classes Puppet sont des ensembles de ressources Puppet regroupées en une seule unité.
Puppet a introduit des cours pour rendre la structure réutilisable et organisée.
Tout d'abord, il faut définir une classe en utilisant la syntaxe de définition de classe. Les classes doivent être uniques et ne peuvent être déclarées qu'une seule fois avec le même nom :
class <class-name> {
<Resource declarations>
}
Exemple :
class ntpconfig {
file {
"/etc/ntp.conf":
ensure=> "present", content=> "server 0.centos.pool.ntp.org iburst\n",
}
}
Jusqu'à présent, nous avons seulement défini la classe ; nous ne l'avons utilisée nulle part. Cela signifie que le code que nous avons écrit ne sera jamais exécuté à moins que nous ne déclarions cette classe ailleurs.
Déclaration de classe
Pour utiliser une classe définie dans votre code, utilisez la comprennent mot-clé.
class ntpconfig {
file {
"/etc/ntp.conf":
ensure=> "present",
content=> "server 0.centos.pool.ntp.org iburst\n",
}
}
include ntpconfig
Essayons de comprendre cela à travers un scénario concret.
Démo installer NTP
Vérifiez d'abord que le paquet NTP n'est pas déjà installé sur le serveur. La commande suivante ne renverra rien si le paquet NTP est absent :
rpm -qa | grep -i ntp
Comme on peut le constater, le paquet NTP est déjà présent sur le serveur. Supprimons le paquet NTP existant :
yum remove ntp
Après avoir supprimé le paquet, assurez-vous que le fichier ntp.conf n'existe plus :
ls -lrt /etc/ntp.conf
Vérifiez que le service ntp n'existe pas en exécutant la commande suivante :
systemctl status ntp
Créez un nouveau fichier .pp pour enregistrer le code. Depuis la ligne de commande :
vi demontp.pp
Passez en mode insertion en appuyant sur la touche i du clavier.
Tapez le code suivant pour créer un nouveau fichier :
# Class Definition
class ntpconfig {
# Installing NTP Package
package {"ntp":
ensure=> "present",
}
# Configuring NTP configuration file
file {"/etc/ntp.conf":
ensure=> "present",
content=> "server 0.centos.pool.ntp.org iburst\n",
}
# Starting NTP services
service {"ntpd":
ensure=> "running",
}
}
Une fois la modification terminée, appuyez sur Échap.
Pour enregistrer le fichier, appuyez sur :wq!
L'étape suivante consiste à choisissez si le code contient des erreurs de syntaxe. Exécutez la commande suivante :
puppet parser validate demontp.pp
Assurez-vous d'avoir basculé sur le racine l'utilisateur doit pouvoir terminer le test sans aucune erreur, en exécutant la commande :
su root
Test est la prochaine étape du processus de création de code. Exécutez la commande suivante pour effectuer un test de fumée :
Puppet applies demontp.pp --noop
La dernière étape consiste à courir Puppet en mode réel et vérifiez le résultat.
puppet apply demontp.pp
Puppet n'a rien fait car la classe de démonstration était simplement défini mais pas a déclaré.
Donc, tant que vous n'aurez pas déclaré la classe Puppet, le code ne sera pas appliqué.
Laissez-nous déclarer la classe de démonstration dans le même code en utilisant inclure le nom de la classe à la fin du code :
# Class Definition
class ntpconfig {
# Installing NTP Package
package {"ntp":
ensure=> "present",
}
# Configuring NTP configuration file
file {"/etc/ntp.conf":
ensure=> "present",
content=> "server 0.centos.pool.ntp.org iburst\n",
}
# Starting NTP services
service {"ntpd":
ensure=> "running",
}
}
# Class Declaration
include ntpconfig
Le prix de choisissez si le code contient des erreurs de syntaxe. Exécutez la commande suivante :
puppet parser validate demontp.pp
Assurez-vous d'avoir basculé sur le racine l'utilisateur doit pouvoir terminer le test sans aucune erreur, en exécutant la commande :
su root
Tests est la prochaine étape du processus de création de code. Exécutez la commande suivante pour effectuer un test de fumée :
Puppet apply demontp.pp --noop
La dernière étape consiste à courir Puppet en mode réel et vérifiez le résultat.
puppet apply demontp.pp
Cette fois-ci, le code est appliqué car la classe a été définie puis déclarée.
Vérifiez que le fichier ntp.conf existe bien :
ls -lrt /etc/ntp.conf
Vérifiez que le service ntp a bien été démarré en exécutant la commande suivante :
systemctl status ntpd
