Comprendre le sel pour les composants Junos OS

Vue d’ensemble des composants

Vous pouvez utiliser Salt pour gérer les périphériques exécutant Junos OS. Le Tableau 1 donne une vue d’ensemble des différents composants Salt. Chaque composant est décrit plus en détail dans les sections suivantes.

Tableau 1 : Composants du sel
Composant	Description
Maître du sel	Serveur de contrôle principal qui gère un ou plusieurs serviteurs.
Serviteur de sel	Noeud géré avec Salt.
Proxy de sel	Processus qui s’exécute sur le maître Salt ou sur un serveur séparé et qui permet au maître Salt de gérer les périphériques qui n’exécutent pas un processus salt-minion standard directement sur l’appareil. Le proxy Junos (pour Salt) permet au maître Salt de gérer les périphériques exécutant Junos OS.
Céréales	Informations statiques ou faits sur un serviteur de sel. Salt récupère les informations d’un périphérique exécutant Junos OS lors de la première connexion au périphérique. Les informations sur Junos OS sont stockées dans des grains de sel et sont accessibles de la même manière que les autres céréales.
Piliers	Données définies par l’utilisateur associées à un minion et accessibles par celui-ci.
Fichiers d’état	Définissez les structures de données qui sont utilisées par le système Salt et qui peuvent ê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 minions à partir de la ligne de commande principale de Salt. 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 serviteur. 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 périphériques exécutant Junos OS.
Moteur syslog Junos	Surveille les messages du journal système envoyés par les périphériques exécutant Junos OS, extrait les informations sur les événements 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, qui sont intégrés au logiciel Salt, sont utilisés pour gérer les périphériques exécutant Junos OS :

Maître de sel, serviteurs et serviteurs par procuration

Le maître Salt est le serveur de contrôle principal qui gère un ou plusieurs nœuds ou serviteurs Salt. Salt utilise généralement une architecture basée sur un agent dans laquelle le nœud géré exécute le processus Salt Minion. 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 le périphérique. Dans ces cas, Salt prend en charge l’utilisation d’un minion proxy pour gérer un appareil qui ne peut pas exécuter directement un minion Salt, mais qui peut être géré via un autre protocole, par exemple, NETCONF. Un minion (proxy ou normal) n’est qu’un processus logiciel utilisé pour gérer un périphérique, et vous pouvez exécuter plusieurs processus sur le même serveur. Un processus de minion proxy peut s’exécuter soit sur le maître Salt, soit sur un serveur distinct, et par défaut, il est toujours connecté au nœud géré.

L’installation standard de Salt comprend le module proxy Junos , qui permet à un maître Salt de gérer les périphériques exécutant Junos OS via un minion proxy Salt. Le processus du minion proxy Junos peut s’exécuter sur le serveur 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 périphérique 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 et Python doivent être installés sur le serveur minion proxy Junos. Junos PyEZ est un microframework pour Python qui vous permet de gérer et d’automatiser les équipements exécutant Junos OS. Le minion 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 sur SSH avec le périphérique 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 données statiques que le maître du sel collecte sur un serviteur. Les données sur les grains comprennent des propriétés relatives au système, par exemple le modèle ou le numéro de série de l’appareil. Lorsque le maître Salt exécute des commandes ou applique des états, il peut utiliser des grains pour cibler certains groupes de serviteurs. Par exemple, il peut appliquer un état à tous les serviteurs exécutant un système d’exploitation ou une version particulière.

Lorsque le minion proxy Junos établit une connexion avec un périphérique exécutant Junos OS, il recueille les informations relatives à Junos OS et les stocke dans les grains. Les faits sur 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 l’élément junos_facts de 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 sur l’appareil sont récupérées et mises en cache lorsque le minion proxy Junos se connecte au périphérique 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 serviteurs sur lesquels effectuer des tâches. Par exemple, la commande suivante s’exécute show chassis routing-engine uniquement sur les périphériques exécutant Junos OS et dotés de deux moteurs de routage :

Piliers

Le système de piliers Salt vous permet de définir des données qui peuvent être distribuées aux serviteurs. Les piliers de sel sont des structures arborescentes de données définies par l’utilisateur qui sont définies sur le maître de sel et sont accessibles par les serviteurs. Les données de pilier peuvent définir des données de configuration, des variables définies par l’utilisateur ou des informations sensibles associées au minion. 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 Pillar peuvent être définies dans de simples fichiers YAML, 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 de pilier sont stockés dans le répertoire /srv/pillar du maître Salt. Pour modifier l’emplacement des données de piliers, définissez le pillar_roots paramètre dans le fichier de configuration principal Salt sur le répertoire souhaité.

Lors de la gestion des é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 périphérique donné exécutant Junos OS. L’exemple de fichier de pilier suivant contient la configuration du proxy Junos pour un périphérique exécutant Junos OS :

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

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

Fichiers d’état Salt (SLS)

Les fichiers d’état SaLt (SLS) définissent les structures de données qui sont 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 en utilisant la syntaxe Jinja pour plus de flexibilité.

Salt vous permet de travailler avec les configurations des systèmes gérés de manière déclarative. Le module d’état Junos (pour Salt), salt.states.junosfournit des fonctions que vous pouvez utiliser dans les fichiers d’état pour déclarer et appliquer certains états sur les périphériques exécutant Junos OS. Par exemple, vous voudrez peut-être vous assurer que la configuration de l’appareil inclut un ensemble spécifique d’instructions ou que l’appareil reflète un état de fonctionnement spécifique.

La structure générale d’un fichier SLS qui définit l’état d’un équipement 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 junos.install_config fonction pour appliquer la 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 supérieur Salt peut être utilisé pour appliquer un ou plusieurs états à un minion lors de 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, reportez-vous à la section Présentation des modules d’exécution et de sel d’état Junos.

Fichier supérieur

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

Par défaut, le fichier top utilisé pour les états se trouve dans /srv/salt/top.sls. Il utilise la syntaxe suivante pour mapper les équipements 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 minions de l’environnement de base dont l’ID commence par « routeur » :

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

De même, le fichier Pillar top, qui se trouve généralement dans /srv/pillar/top.sls, mappe un fichier pillar aux minions qui sont autorisés à accéder aux données de ce fichier. Lors de la gestion des périphériques exécutant Junos OS, le fichier supérieur Pillar mappe un ID de minion proxy Junos au fichier d’état contenant les données Pillar du périphérique correspondant exécutant Junos OS, comme décrit dans la section Pillars .

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 équipements gérés. Les modules d’exécution Salt sont des modules Python qui s’exécutent sur un minion Salt. Ils définissent les fonctions qui vous permettent d’effectuer des tâches sur le minion. Vous pouvez exécuter des commandes ad hoc sur le maître Salt qui demandent aux serviteurs 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 minion.

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

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 d’états sur les périphériques exécutant Junos OS. Pour plus d’informations sur l’utilisation des modules d’exécution et d’état Junos, reportez-vous à la section Présentation des modules Salt d’exécution et d’état Junos.

Moteur Syslog Junos, bus d’événements de sel et réacteurs de 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 serviteurs. Les composants communiquent en envoyant des messages via le bus, et des événements externes peuvent être injectés sur le bus. Le maître du sel et chaque serviteur du sel ont leur propre bus d’événement.

Le système d’événements utilise un modèle publish-subscribe (publish-subscribe). 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 minion, le maître Salt publie un événement de travail, et le serviteur correspondant exécute le travail et déclenche un événement de retour, qui contient les résultats du travail, 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 (syslog) de Junos OS qui sont 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 des équipements gérés exécutant Junos OS. Lorsque le moteur syslog Junos reçoit un événement, il extrait les informations sur l’événement, les traduit au format Salt et les publie sur le bus d’événements Salt.

La sortie suivante est un exemple UI_COMMIT_COMPLETED d’événement qui a été 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, en conjonction avec les réacteurs Salt, pour la gestion de l’état basée sur les événements des périphériques exécutant Junos OS. 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 des règles configurées. Pour activer le système Salt Reactor, vous devez configurer l’option reactor dans le fichier de configuration maître Salt et associer des balises d’événement à un ou plusieurs fichiers SLS du réacteur. 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, consultez :

SUR CETTE PAGE