Marionnette - Aperçu

Puppet est un outil de gestion de configuration développé par Puppet Labs afin d'automatiser la gestion et la configuration de l'infrastructure. Puppet est un outil très puissant qui aide dans le concept d'infrastructure en tant que code. Cet outil est écrit en langage Ruby DSL qui aide à convertir une infrastructure complète au format code, qui peut être facilement gérée et configurée.

Puppet suit le modèle client-serveur, où une machine dans n'importe quel cluster agit en tant que serveur, connu sous le nom de Puppet Master et l'autre agit en tant que client connu sous le nom d'esclave sur les nœuds. Puppet a la capacité de gérer n'importe quel système à partir de zéro, de la configuration initiale à la fin de vie d'une machine particulière.

Caractéristiques du système de marionnettes

Voici les caractéristiques les plus importantes de Puppet.

Idempotence

Puppet prend en charge l'Idempotency, ce qui le rend unique. Semblable à Chef, dans Puppet, on peut exécuter en toute sécurité le même ensemble de configuration plusieurs fois sur la même machine. Dans ce flux, Puppet vérifie l'état actuel de la machine cible et n'apportera des modifications qu'en cas de modification spécifique de la configuration.

L'idempotence aide à gérer une machine particulière tout au long de son cycle de vie à partir de la création de la machine, des changements de configuration de la machine, jusqu'à la fin de vie. La fonction Puppet Idempotency est très utile pour maintenir la machine à jour pendant des années plutôt que de reconstruire la même machine plusieurs fois, en cas de changement de configuration.

Multiplateforme

Dans Puppet, avec l'aide de Resource Abstraction Layer (RAL) qui utilise les ressources Puppet, on peut cibler la configuration spécifiée du système sans se soucier des détails d'implémentation et du fonctionnement de la commande de configuration à l'intérieur du système, qui sont définis dans la configuration sous-jacente fichier.

Marionnette - Flux de travail

Puppet utilise le flux de travail suivant pour appliquer la configuration sur le système.

• Dans Puppet, la première chose que fait le maître Puppet est de collecter les détails de la machine cible. En utilisant le facteur présent sur tous les nœuds Puppet (similaire à Ohai dans Chef), il obtient tous les détails de configuration au niveau de la machine. Ces détails sont collectés et renvoyés au maître des marionnettes.

• Ensuite, le maître de marionnettes compare la configuration récupérée avec les détails de configuration définis, et avec la configuration définie, il crée un catalogue et l'envoie aux agents Puppet ciblés.

• L'agent Puppet applique ensuite ces configurations pour amener le système dans un état souhaité.

• Enfin, une fois que le nœud cible est dans un état souhaité, il renvoie un rapport au maître Puppet, ce qui aide le maître Puppet à comprendre où se trouve l'état actuel du système, tel que défini dans le catalogue.

Puppet - Composants clés

Voici les composants clés de Puppet.

Ressources de marionnettes

Les ressources Puppet sont les composants clés pour modéliser une machine particulière. Ces ressources ont leur propre modèle d'implémentation. Puppet utilise le même modèle pour obtenir une ressource particulière dans l'état souhaité.

Fournisseurs

Les fournisseurs sont essentiellement des fournisseurs de toute ressource particulière utilisée dans Puppet. Par exemple, le type de package 'apt-get' et 'yum' sont tous deux valides pour la gestion des packages. Parfois, plus d'un fournisseur serait disponible sur une plate-forme particulière. Bien que chaque plate-forme ait toujours un fournisseur par défaut.

Manifeste

Manifest est une collection de ressources qui sont couplées à l'intérieur de la fonction ou des classes pour configurer n'importe quel système cible. Ils contiennent un ensemble de code Ruby afin de configurer un système.

Modules

Le module est le bloc de construction clé de Puppet, qui peut être défini comme une collection de ressources, fichiers, modèles, etc. Ils peuvent être facilement répartis entre différents types d'OS étant définis qu'ils sont de la même saveur. Comme ils peuvent être facilement distribués, un module peut être utilisé plusieurs fois avec la même configuration.

Modèles

Les modèles utilisent des expressions Ruby pour définir le contenu personnalisé et l'entrée de variable. Ils sont utilisés pour développer du contenu personnalisé. Les modèles sont définis dans les manifestes et sont copiés vers un emplacement du système. Par exemple, si l'on veut définir httpd avec un port personnalisable, alors cela peut être fait en utilisant l'expression suivante.

Listen <% = @httpd_port %>

La variable httpd_port dans ce cas est définie dans le manifeste qui fait référence à ce modèle.

Fichiers statiques

Les fichiers statiques peuvent être définis comme un fichier général qui sont parfois nécessaires pour effectuer des tâches spécifiques. Ils peuvent être simplement copiés d'un endroit à un autre à l'aide de Puppet. Tous les fichiers statiques se trouvent dans le répertoire des fichiers de n'importe quel module. Toute manipulation du fichier dans un manifeste est effectuée à l'aide de la ressource fichier.