Comprendre les composants de Salt pour Junos OS

Présentation des composants

Vous pouvez utiliser Salt pour gérer les équipements exécutant Junos OS. Le tableau 1 fournit une vue d’ensemble générale des différents composants de Salt. Chaque composante est décrite plus en détail dans les sections qui suivent.

Tableau 1 : Composants du sel
Composant	Description
Maître du sel	Serveur de contrôle principal qui gère un ou plusieurs sbires.
Minion de sel	Nœud géré avec Salt.
Proxy de sel	Processus qui s’exécute sur le maître Salt ou sur un serveur distinct et qui permet au maître Salt de gérer les périphériques qui n’exécutent pas de processus salt-minion standard directement sur le périphérique. Le proxy Junos (pour Salt) permet au maître Salt de gérer les équipements exécutant Junos OS.
Céréales	Informations statiques ou faits sur un serviteur de sel. Salt récupère les faits d’un équipement exécutant Junos OS lors de la première connexion à l’équipement. Les faits relatifs au système d’exploitation Junos sont stockés dans des grains de sel et sont accessibles de la même manière que les autres grains.
Piliers	Données définies par l’utilisateur qui sont associées à un serviteur et auxquelles il a accès.
Fichiers d’état	Définissez les structures de données utilisées par le système Salt et pouvant être appliquées à des cibles spécifiques. Par exemple, ils peuvent être utilisés pour définir des données piliers ou l’état d’un système.
Fichier supérieur	Mappe des groupes de périphériques aux fichiers d’état Salt qui doivent leur être appliqués dans un environnement donné.
Module d’exécution	Définit les fonctions d’exécution qui vous permettent d’effectuer des tâches ad hoc sur les sbires à partir de la ligne de commande Salt master. Le module d’exécution Junos (pour Salt) vous permet d’exécuter des tâches opérationnelles et de configuration sur des équipements exécutant Junos OS.
Module d’état	Définit les fonctions d’état qui vous permettent de déclarer et d’appliquer l’état souhaité d’un sbire. Le module d’état Junos (pour Salt) fournit des fonctions que vous pouvez utiliser dans les fichiers d’état Salt pour déclarer et appliquer un état spécifique sur les équipements exécutant Junos OS.
Moteur syslog Junos	Surveille les messages du journal système envoyés par les équipements exécutant Junos OS, extrait les informations d’événement et les publie au format Salt sur le bus d’événements Salt.
Réacteur	Permet de définir les actions à effectuer pour certains événements reçus sur le bus d’événements Salt.

Les composants Salt suivants, intégrés au logiciel Salt, sont utilisés pour gérer les équipements exécutant Junos OS :

Salt Master, Minions et Minions par procuration

Le maître Salt est le serveur de contrôle principal qui gère un ou plusieurs nœuds ou sbires de sel. Salt utilise généralement une architecture basée sur des agents dans laquelle le nœud géré exécute le processus Minion Salt. Certains périphériques, par exemple les périphériques réseau, peuvent ne pas prendre en charge l’installation et l’exécution du processus Salt minion directement sur l’appareil. Dans ces cas, Salt prend en charge l’utilisation d’un minion proxy pour gérer un périphérique qui ne peut pas exécuter directement un minion Salt mais peut être géré via un autre protocole, par exemple, NETCONF. Un minion (proxy ou régulier) est juste un processus logiciel utilisé pour gérer un appareil, et vous pouvez exécuter plusieurs processus sur le même serveur. Un processus de minion proxy peut s’exécuter sur le maître Salt ou sur un serveur séparé, et par défaut, il est toujours connecté au nœud géré.

L’installation standard de Salt inclut le module proxy Junos, qui permet à un maître Salt de gérer les équipements exécutant Junos OS via un serviteur proxy Salt. Le processus de minion proxy Junos peut s’exécuter sur le maître Salt ou sur un serveur distinct et nécessite environ 40 à 100 Mo de RAM par processus. Vous devez disposer d’un processus de minion proxy pour chaque équipement géré exécutant Junos OS. Le proxy Junos fournit des modules d’exécution et d’état qui vous permettent d’effectuer des tâches opérationnelles et de configuration sur les équipements exécutant Junos OS.

La bibliothèque Junos PyEZ et les jxmlease yamlordereddictloader modules Python doivent être installés sur le serveur proxy Junos. Junos PyEZ est un microframework pour Python qui vous permet de gérer et d’automatiser les appareils exécutant Junos OS. Le serviteur proxy Junos se connecte au maître Salt à l’aide du bus d’événements ZeroMQ et utilise Junos PyEZ pour établir une session NETCONF via SSH avec l’équipement exécutant Junos OS. Le jxmlease module convertit XML en structures de données Python et les structures de données Python en XML.

Céréales

Les grains sont des éléments de données statiques que le maître du sel recueille sur un sbire. Les données relatives au grain incluent des propriétés relatives au système, par exemple le modèle ou le numéro de série du périphérique. Lorsque le maître Salt exécute des commandes ou applique des états, il peut utiliser des grains pour cibler certains groupes de sbires. Par exemple, il peut appliquer un état à tous les sbires exécutant un système d’exploitation ou une version particulière.

Lorsque le serviteur proxy Junos établit une connexion avec un équipement exécutant Junos OS, il rassemble les informations relatives à Junos OS et les stocke dans des grains. Les informations relatives à Junos OS sont accessibles de la même manière que les autres grains.

Pour afficher les grains d’un périphérique exécutant Junos OS, qui inclut le junos_facts grain, exécutez la grains.items fonction.

Si vous souhaitez afficher uniquement les informations relatives à Junos OS, vous pouvez demander uniquement le junos_facts grain.

Vous pouvez également exécuter la facts fonction à partir du module d’exécution junos . La junos.facts fonction renvoie les mêmes données que la commande précédente.

Les informations relatives au périphérique sont récupérées et mises en cache lorsque le serviteur proxy Junos se connecte à l’équipement exécutant Junos OS. Lorsque vous affichez les faits, ils sont servis à partir du cache. Par conséquent, si la valeur d’un fait déjà mis en cache change, il n’est pas automatiquement mis à jour dans le système Salt. Pour recharger les faits à partir de l’appareil et les afficher, appelez la junos.facts_refresh fonction.

Vous pouvez utiliser des grains pour affiner l’ensemble des sbires sur lesquels effectuer des tâches. Par exemple, la commande suivante exécute uniquement la commande sur les show chassis routing-engine équipements exécutant Junos OS qui disposent de deux moteurs de routage :

Piliers

Le système de pilier Salt vous permet de définir des données qui peuvent être distribuées aux sbires. Les piliers de sel sont des structures arborescentes de données définies par l’utilisateur qui sont définies sur le maître Salt et sont accessibles par les sbires. Les données piliers peuvent définir des données de configuration, des variables définies par l’utilisateur ou des informations sensibles associées au sbire. Vous pouvez restreindre les données de pilier auxquelles un serviteur peut accéder en mappant le pilier aux cibles appropriées dans le fichier supérieur du pilier.

Les données piliers peuvent être définies dans des fichiers YAML simples, mais peuvent également être stockées et récupérées à partir d’une base de données telle que SQL. Par défaut, les fichiers de données des piliers sont stockés dans le répertoire / srv/pillar du maître Salt. Pour modifier l’emplacement des données du pilier, définissez le paramètre dans le fichier de configuration principal Salt sur le pillar_roots répertoire souhaité.

Lors de la gestion d’équipements exécutant Junos OS, des piliers sont utilisés pour définir les données du proxy Junos, y compris le nom d’hôte et les informations d’authentification d’un équipement donné exécutant Junos OS. L’exemple de fichier pilier suivant contient la configuration du proxy Junos pour un périphérique exécutant Junos OS :

Le fichier top du pilier Salt, qui réside généralement dans / srv/pillar/top.sls, définit les données de pilier auxquelles un serviteur peut accéder. Lors de la gestion d’équipements exécutant Junos OS, le fichier pilier supérieur mappe l’ID du minion proxy Junos au fichier pilier contenant les données proxy du périphérique Junos OS correspondant. Dans l’exemple suivant, le fichier supérieur mappe l’ID proxy minion router1 au fichier pilier router1-proxy.sls dans l’environnement de base :

Vous pouvez afficher les données piliers d’un serviteur en exécutant la pillar.items fonction.

Fichiers SLS (Salt State)

Les fichiers SLS (SaLt State) définissent les structures de données utilisées par le système Salt à diverses fins. Par exemple, ils peuvent être utilisés pour définir des données piliers ou l’état d’un système. Par défaut, les fichiers d’état Salt sont écrits au format YAML et utilisent l’extension de fichier . sls. Prise en charge des fichiers d’état à l’aide de la syntaxe Jinja pour plus de flexibilité.

Salt vous permet d’utiliser les configurations des systèmes gérés de manière déclarative. Le module d’état Junos (pour Salt), salt.states.junos, fournit des fonctions que vous pouvez utiliser dans les fichiers d’état pour déclarer et appliquer certains états sur les équipements exécutant Junos OS. Par exemple, vous pouvez vous assurer que la configuration de l’appareil inclut un ensemble spécifique d’instructions ou qu’il reflète un état opérationnel spécifique.

La structure générale d’un fichier SLS qui définit l’état d’un périphérique géré est la suivante, bien que cela puisse varier en fonction du module et de la fonction :

Par exemple, le fichier d’état suivant utilise la fonction pour appliquer la junos.install_config configuration du modèle donné aux équipements cibles exécutant Junos OS :

Vous pouvez appliquer un état individuel à un ou plusieurs équipements cibles. Par exemple :

Alternativement, le fichier Salt top peut être utilisé pour appliquer un ou plusieurs états à un minion pendant l’exécution d’un état élevé.

Lorsque vous exécutez un highstate sur une cible donnée, le système Salt applique tous les états configurés dans le top.sls fichier pour cette cible.

Pour plus d’informations sur le module d’état Junos, voir Présentation des modules Junos Execution et State Salt.

Fichier haut de page

Lorsque vous utilisez Salt pour gérer des appareils, vous pouvez regrouper les sbires en différentes catégories ou environnements. Par défaut, tous les sbires sont dans l’environnement de base, mais vous pouvez placer d’autres sbires dans un environnement de développement ou de production. Un fichier Salt top mappe un périphérique ou un groupe de périphériques aux fichiers d’état qui doivent leur être appliqués et aux données piliers auxquelles ils peuvent accéder dans l’environnement donné. Les fichiers supérieurs sont nommés top.sls par défaut et se trouvent au sommet de la hiérarchie de répertoires qui contient les fichiers d’état Salt.

Par défaut, le fichier supérieur utilisé pour les états réside dans / srv/salt/top.sls. Il utilise la syntaxe suivante pour mapper les machines cibles à leurs fichiers d’état correspondants dans l’environnement donné. Le fichier doit toujours définir l’environnement base .

Par exemple, le fichier supérieur suivant applique les fichiers d’état core.sls et common_config.sls à tous les sbires de l’environnement de base dont l’ID commence par « router » :

Pour appliquer les états, exécutez un highstate et spécifiez les équipements cibles.

De même, le fichier Pillar top, qui réside généralement dans / srv/pillar/top.sls, mappe un fichier pilier aux sbires autorisés à accéder aux données de ce fichier. Lors de la gestion d’équipements exécutant Junos OS, le fichier supérieur du pilier mappe un ID de minion proxy Junos au fichier d’état contenant les données piliers de l’équipement correspondant exécutant Junos OS, comme décrit dans la section Piiers .

Modules d’exécution et d’état

Salt est un outil de gestion de la configuration et d’exécution à distance qui vous permet de déclarer et d’appliquer l’état d’un système et d’effectuer des tâches opérationnelles et de configuration sur les appareils gérés. Les modules d’exécution Salt sont des modules Python qui s’exécutent sur un minion Salt. Ils définissent des fonctions qui vous permettent d’effectuer des tâches sur le sbire. Vous pouvez exécuter des commandes ad hoc sur le maître Salt qui demandent aux sbires cibles d’exécuter la fonction donnée et de renvoyer le résultat. De même, les modules d’état Salt définissent des fonctions qui gèrent l’application d’un état à un sbire.

Par exemple, pour tester la connectivité à tous les sbires, vous pouvez exécuter la fonction du ping module et spécifier la test cible pour '*' indiquer tous les sbires.

L’installation de Salt comprend les modules d’exécution et d’état Junos, qui définissent les fonctions qui vous permettent d’effectuer des tâches opérationnelles et de configuration et de gérer l’application des états sur les équipements exécutant Junos OS. Pour plus d’informations sur l’utilisation des modules d’exécution et d’état Junos, voir Présentation des modules Junos Execution et State Salt.

Moteur Junos Syslog, bus d’événements Salt et réacteurs au sel

L’architecture Salt est centrée autour d’un bus d’événements hautes performances, qui utilise ZeroMQ comme mécanisme de transport de messages et d’événements par défaut pour la communication entre le maître Salt et les sbires. Les composants communiquent en envoyant des messages via le bus et des événements externes peuvent être injectés sur le bus. Le Salt Master et chaque Salt Minion ont leur propre bus événementiel.

Le système d’événements utilise un modèle de publication-abonnement (pub/sub). Les événements sont publiés sur le bus d’événements, et les abonnés écoutent les événements publiés et réagissent comme indiqué. Par exemple, lorsque vous exécutez une fonction sur un sbire, le maître Salt publie un événement de tâche, et le sbire correspondant exécute la tâche et déclenche un événement de retour, qui contient les résultats de la tâche, sur le bus. Salt fournit des méthodes pour publier des événements externes sur le bus et pour réagir aux événements, ce qui vous permet d’utiliser Salt pour surveiller et répondre aux événements en temps réel.

Les moteurs Salt sont des processus système externes qui vous permettent d’exporter ou d’importer des événements sur le bus d’événements Salt. L’installation de Salt inclut le moteur syslog Junos (pour Salt), qui peut surveiller les messages du journal système Junos OS (syslog) envoyés au serveur Salt et les publier sur le bus d’événements Salt. Lorsqu’il est activé, le moteur syslog Junos écoute sur le port spécifié les événements syslog provenant des équipements gérés exécutant Junos OS. Lorsque le moteur syslog Junos reçoit un événement, il extrait les informations de l’événement, les traduit au format Salt et les publie sur le bus d’événements Sel.

La sortie suivante est un exemple UI_COMMIT_COMPLETED d’événement envoyé à partir d’un périphérique exécutant Junos OS et publié sur le bus d’événements Salt par le moteur syslog Junos :

Vous pouvez utiliser le moteur syslog Junos, conjointement avec les réacteurs Salt, pour la gestion de l’état des équipements exécutant Junos OS en fonction des événements. Les réacteurs à sel vous permettent d’agir en réponse à des événements sur le bus d’événements Salt. Lorsque vous activez le système Salt Reactor, il surveille le bus d’événements Salt et déclenche des actions pour faire correspondre les événements en fonction de vos règles configurées. Pour activer le système Salt Reactor, configurez l’option reactor dans le fichier de configuration principal Salt et associez des balises d’événement à un ou plusieurs fichiers SLS reactor. Les fichiers du réacteur définissent les actions à entreprendre lorsque cet événement se produit.

Pour plus d’informations sur le moteur syslog Junos et la création de réacteurs pour les événements Junos OS, voir :

SUR CETTE PAGE