Tutoriel Puppet pour débutants : Qu'est-ce que Puppet et comment l'utiliser ?

Avant d'apprendre Puppet, comprenons :

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 (par exemple serveurs, stockage, réseaux) dans un état connu, souhaité et cohérent. Il 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 de serveurs, la configuration de ces serveurs, etc. Ces professionnels peuvent automatiser cette tâche en écrivant des scripts.

Cependant, c'est un travail difficile lorsqu'ils travaillent sur une infrastructure massive. L'outil de gestion de configuration, tel qu'un Puppet, a été introduit pour résoudre ces problèmes.

C'est quoi Marionnette ?

Fantoche est un outil de gestion système permettant de centraliser et d'automatiser le processus de gestion de la configuration. Puppet est également utilisé comme outil de déploiement de logiciels. 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 serveurs de diverses applications et services sur l'ensemble 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 Source: Il s'agit d'une version de base de l'outil de gestion de configuration Puppet, également connu sous le nom d'Open Source Puppet. Il est disponible directement sur le site Web de Puppet et est sous licence sous le système Apache 2.0.

• Entreprise de marionnettes: version commerciale qui offre des fonctionnalités telles que les rapports de conformité, l'orchestration, le contrôle d'accès basé sur les rôles, l'interface graphique, l'API et les outils de ligne de commande pour une gestion efficace des nœuds.

Que peut faire Puppet ?

Par exemple, vous disposez d’une infrastructure avec environ 100 serveurs. En tant qu'administrateur système, il est de votre rôle de garantir que tous ces serveurs sont toujours à jour et fonctionnent avec toutes les fonctionnalités.

Pour ce faire, vous pouvez utiliser Puppet, qui permet d'écrire un code simple pouvant être déployé automatiquement sur ces serveurs. Cela réduit l’effort humain 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.
• L'outil vous permet de surveiller en permanence les serveurs pour confirmer si la configuration requise existe ou non et si elle n'est pas modifiée. Si la configuration est modifiée, l'outil Puppet reviendra à la configuration prédéfinie sur l'hôte.
• Il permet également de contrôler tout le système configuré, de sorte qu'une modification centralisée soit automatiquement effectuée.
• Il est également utilisé comme outil de déploiement car il déploie automatiquement le logiciel sur le système. Il met en œuvre le 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 Puppet DSL, comprenons les paradigmes de programmation :

Un paradigme de programmation est un style que vous utilisez en programmation informatique.

Quatre types de paradigmes sont :

• Impératif.
• Déclaratif.
• Fonctionnel (qui est considéré comme un sous-ensemble de ce paradigme déclaratif)
• Orienté objet.

Nous nous concentrerons sur l’impératif et le déclaratif.

Paradigmes impératifs

Ce paradigme de programmation exprime la logique d'un calcul (Que faire) et décrit son flux de contrôle (Comment faire)

Mise en situation :

Supposons que vous vous rendiez à votre bureau, que vous réservez un taxi et que vous commencez à donner des instructions étape par étape au chauffeur jusqu'à ce que vous atteigniez le bureau. Spécifier quoi faire et comment faire est un style impératif.

Paradigmes déclaratifs

Ce paradigme de programmation exprime la logique d'un calcul (Que faire) sans décrire son flux de contrôle (Comment faire)

Mise en situation :

Supposons que vous vous rendiez à votre bureau, que vous réservez un taxi Uber et précisez la destination finale (Bureau). Spécifier quoi faire et non comment faire est 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.

Mise en situation : Créez un utilisateur sur le système :

Cela peut être fait en utilisant un modèle de programmation impératif par un script shell : nous spécifions ici comment créer l'utilisateur et quelles commandes utiliser sur le le système d'exploitation.

Cependant, cela peut être fait en utilisant un modèle de programmation déclaratif avec seulement quelques lignes de code Puppet, un langage spécifique au domaine Puppet (DSL), et toujours obtenir le même résultat.

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 transmet 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 l'extraction.

Dans ce modèle de déploiement, les serveurs individuels contactent un serveur maître, vérifient et établissent une connexion sécurisée, téléchargent leurs configurations et leurs logiciels, puis se configurent en conséquence — par exemple, Puppet et Chef.

Comment fonctionne Puppet ?

Puppet est basé sur un modèle de déploiement Pull, dans lequel les nœuds d'agent s'enregistrent régulièrement après chaque 1800 secondes avec le nœud maître pour voir si quelque chose doit être mis à jour dans l'agent. Si quelque chose doit être mis à jour, l'agent extrait les codes marionnettes nécessaires du maître et exécute les actions requises.

Expliquons-le par un exemple :

Mise en situation : Maître – Configuration de l'agent :

Le Maître

Une machine basée sur Linux sur laquelle est installé le logiciel Puppet master. Il est chargé de maintenir les configurations sous forme de codes marionnettes. Le nœud maître ne peut être que Linux.

Les agents

Les machines cibles gérées par une marionnette sur laquelle le logiciel de l'agent marionnette est installé.

L'agent peut être configuré sur n'importe quel système d'exploitation pris en charge tel que Linux ou Windows or Solaris ou MacOS.

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 connectivité établie entre l'agent et le maître, l'agent Puppet envoie les données sur son état au serveur maître Puppet. C'est ce qu'on appelle des faits : ces informations incluent le nom d'hôte, les détails du noyau, l'adresse IP, les détails du nom de fichier, etc.…

Étape 2) Puppet Master utilise ces données et compile une liste avec la configuration à appliquer à l'agent. Cette liste de configuration à effectuer sur un agent est appelée catalogue. Cela peut être modifié comme l'installation de packages, les mises à niveau ou les suppressions, la création du système 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 aucune dérive dans la configuration, l'agent n'effectue aucune modification de configuration et laisse le nœud s'exécuter avec la même configuration.

Étape 4) Une fois cela fait, le nœud fait rapport au Puppet Master indiquant que la configuration a été appliquée et terminée.

Blocs de marionnettes

Puppet offre la flexibilité nécessaire pour intégrer des rapports à des outils tiers à l'aide des API Puppet.

Quatre types de blocs de construction de marionnettes sont

1. Ressources
2. Cours
3. Manifeste
4. formation vidéo

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

Une combinaison de différentes ressources peut être regroupée en une seule unité appelée classe.

Manifeste de marionnettes

Manifest est un répertoire contenant des fichiers DSL de marionnettes. Ces fichiers ont une extension .pp. L'extension .pp signifie programme de marionnettes. Le code Puppet se compose de définitions ou de déclarations de classes Puppet.

Modules de marionnettes

Les modules sont une collection de fichiers et de répertoires tels que des manifestes et des définitions de classe. Ce sont les unités réutilisables et partageables dans Puppet.

Par exemple, la MySQL module à installer et configurer MySQL ou le module Jenkins pour gérer Jenkins, etc.

Types de ressources Puppet

En général, un système est constitué de fichiers, d'utilisateurs, de services, de processus, de packages, etc. Dans Puppet, ceux-ci sont appelés ressources. Les ressources sont les éléments fondamentaux de

Fantoche. Toutes les opérations sur les agents fantoches sont réalisées à l’aide de ressources marionnettes.

Les ressources Puppet sont des outils prêts à l'emploi utilisés pour effectuer diverses tâches et opérations sur n'importe quelle plate-forme prise en charge. Nous pouvons utiliser une seule ressource marionnette pour effectuer une tâche spécifique, ou nous pouvons utiliser plusieurs ressources marionnettes ensemble pour effectuer certains déploiements de configurations d'application complexes.

Les ressources peuvent avoir différents types. Utilisations des marionnettes numériques et types de ressources afin de décrire la configuration d'un système.

Il existe trois types de ressources :

1. Noyau de marionnette ou types de ressources intégrés.
2. Types de ressources définis par Puppet.
3. 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ées sont les types de ressources Puppet prédéfinies fournies avec le logiciel Puppet. Tous les types de ressources Puppet de base ou intégrées sont écrits 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 en langage déclaratif Puppet 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 les types de ressources marionnettes…

Dans le terminal, tapez la commande suivante pour afficher une liste des sous-commandes pertinentes pour 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 de marionnettes intégrées.

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 le ressource comme sous-commande et -les types comme acte.

Puppet dispose de 49 types de ressources de base intégrés.

Dans le terminal, tapez la commande suivante pour afficher une liste des types de ressources de marionnettes intégrées 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 au type de ressource marionnette, utilisez la commande suivante :

puppet describe <resource type name>	

Les paramètres répertorieront 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 relier de nombreux fichiers de code de marionnettes non gérés. C’est là que nous avons besoin d’un regroupement pour relier les opérations. L'objectif est de résoudre un seul problème, comme toutes les opérations nécessaires pour configurer ssh sur un serveur ou un service ntp ou un serveur Web ou un serveur de base de données complet à partir de zéro.

Que sont les cours de marionnettes ?

Les classes de marionnettes sont un ensemble de ressources de marionnettes regroupées en une seule unité.

Puppet a introduit des cours pour rendre la structure réutilisable et organisée.

Tout d’abord, nous devons 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>
}

Mise en situation :

class ntpconfig {
    file {
        "/etc/ntp.conf": 
     ensure=> "present", content=> "server 0.centos.pool.ntp.org iburst\n",
    }
}

Jusqu’à présent, nous avons uniquement défini la classe, mais nous ne l’avons utilisée nulle part. Cela signifie que ce code que nous avons écrit ne sera jamais exécuté à moins que nous déclarions cette classe ailleurs.

Déclaration de classe

Pour utiliser une classe définie dans le code, utilisez le de Swanson comprennent mot-clé.

class ntpconfig {
    file {
        "/etc/ntp.conf": 
      ensure=> "present", 
      content=> "server 0.centos.pool.ntp.org iburst\n",
    }
}
include ntpconfig

Comprenons cela avec un scénario de cas réel.

Démo installer NTP

Tout d'abord, assurez-vous que le package NTP n'est pas déjà présent sur le serveur, la commande suivante ne retournera rien si le telnet n'est pas présent sur le serveur :

rpm -qa | grep -i ntp

Comme on peut le constater, le package NTP est déjà présent sur le serveur. Supprimons le package NTP existant :

yum remove ntp

Après avoir supprimé le package, assurez-vous que le fichier ntp.conf n'existe pas :

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 i à partir 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 l'édition terminée : appuyez sur Echap

Pour enregistrer le fichier, appuyez sur :wq!

La prochaine étape est de vérifier si le code contient des erreurs de syntaxe. Exécutez la commande suivante :

puppet parser validate demontp.pp

Assurez-vous que vous êtes passé au racine pour pouvoir réaliser 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 applies demontp.pp --noop

La dernière étape consiste à courir la marionnette en mode réel et vérifier la sortie.

puppet apply demontp.pp

Puppet n'a rien fait parce que le cours de démonstration était juste défini mais pas a déclaré.

Ainsi, jusqu'à ce que vous déclariez la classe marionnette, le code ne sera pas appliqué.

LET 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

Encore vérifier si le code contient des erreurs de syntaxe. Exécutez la commande suivante :

puppet parser validate demontp.pp

Assurez-vous que vous êtes passé au racine pour pouvoir réaliser le test sans aucune erreur, en exécutant la commande :

su root

Contrôle de qualité 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 la marionnette en mode réel et vérifier la sortie.

puppet apply demontp.pp

Cette fois, le code est appliqué car la classe a été définie puis déclarée.

Assurez-vous que ntp.conf existe désormais :

ls -lrt /etc/ntp.conf

Vérifiez que le service NTP a été démarré en exécutant la commande suivante :

systemctl status ntpd