Comprendre Ansible pour les collections et modules Junos OS

Comprendre les collections Ansible et les modules de gestion des appareils Junos

Ansible est un framework d’automatisation informatique que vous pouvez utiliser pour gérer la configuration de l’infrastructure. Vous utilisez des modules Ansible, qui sont des unités de code discrètes, pour exécuter des fonctions spécifiques sur un nœud géré. Vous pouvez exécuter des modules individuels sur des hôtes distants pour effectuer des tâches ad hoc. Vous pouvez également exécuter des modules via des playbooks.

Juniper Networks fournit des modules Ansible que vous pouvez utiliser pour gérer les équipements Junos. Les modules Ansible sont regroupés et distribués via Ansible Content Collections, qui sont hébergés dans le référentiel Ansible Galaxy . Les collections Ansible sont un format permettant de distribuer du contenu Ansible qui n’est pas inclus dans l’installation principale d’Ansible. Les collections peuvent inclure un large éventail de contenus, notamment des modules, des playbooks, des plug-ins et des rôles. Les collections ont également leurs propres dépôts, de sorte qu’elles peuvent être développées et publiées indépendamment de l’installation principale d’Ansible.

Le Tableau 1 présente les ensembles de contenus disponibles pour la gestion des équipements Junos. Juniper Networks fournit la juniper.device collecte. juniper.device À partir de la version 2.0.0, nous avons consolidé la collection Juniper Networks juniper.device et la collection Red Hat Ansible junipernetworks.junos en une seule collection contenant les deux ensembles de modules.

Tableau 1 : ensembles de contenus Ansible pour la gestion des équipements Junos
Collecte	Ensemble de modules	Descriptif
`juniper.device`	`juniper.device`	Modules de gestion des équipements Junos. Juniper Networks fournit et gère cette collection en tant que projet open source.
`juniper.device`	`junipernetworks.junos` (`juniper.device.junos_*`)	Modules de gestion des équipements Junos. À l’origine, l’équipe réseau Red Hat Ansible s’occupait de cette collection. Dans `juniper.device` la version 2.0.0, nous avons fusionné les modules dans la `juniper.device` collection. Juniper Networks maintient ces modules à l’avenir. Vous pouvez identifier ces modules par le nom du module, qui commence par `junos_`.

Comprendre la `juniper.device` collection fusionnée

Présentation de la fusion
Comparaison des ensembles de modules

Présentation de la fusion

Avant la juniper.device version 2.0.0, la collection Juniper Networks juniper.device et la collection Red Hat Ansible junipernetworks.junos étaient des collections distinctes distinctes. Chaque propriétaire de collection a maintenu sa collection respective. À partir de juniper.device la version 2.0.0, nous avons fusionné la junipernetworks.junos collection dans la juniper.device collection. Juniper Networks conserve la collection fusionnée à l’avenir.

Nous nous référerons à la juniper.device collection pour indiquer l’ensemble combiné des modules. Pour distinguer les ensembles de modules de la collection, nous nous référerons aux modules comme suit :

juniper.device modules ou juniper.device modules d’origine
junipernetworks.junos Modules ou juniper.device.junos_* modules

Lorsque vous installez la juniper.device collection, vous pouvez l’utiliser juniper.device.module_name pour exécuter des modules à partir de l’un ou l’autre ensemble de modules. Pour continuer à utiliser les playbooks existants qui font référence junipernetworks.junos.module_nameà , vous devez également installer la junipernetworks.junos collection. Pour exécuter les modules en utilisant l’un junipernetworks.junos ou l’autre des espaces de noms, vous devez définir ansible_network_os sur juniper.device.junos. Sinon, tout le reste reste reste le même en utilisant l’un ou l’autre ensemble de modules.

Bien que la juniper.device collection comprenne les deux ensembles de modules, chaque ensemble de modules utilise des valeurs de connexion Ansible et des valeurs de système d’exploitation réseau différentes. Par conséquent, les deux ensembles de modules ne peuvent pas utiliser le même fichier de stock et vous ne pouvez pas mélanger les ensembles de modules dans le même playbook. Ainsi, nous vous recommandons de sélectionner un ensemble de modules à utiliser pour vos playbooks et tâches. L’ensemble que vous sélectionnez est une question de préférence. Pour vous aider à déterminer quel ensemble de modules convient le mieux à votre environnement, nous avons fourni une vue d’ensemble et une comparaison de haut niveau des deux ensembles.

Comparaison des ensembles de modules

La juniper.device collection et la junipernetworks.junos collection ont été construites à l’origine pour des objectifs et des cas d’utilisation différents. Juniper Networks a conçu les juniper.device modules de manière à fournir aux utilisateurs un accès direct à l’ensemble des fonctionnalités de Junos OS. Red Hat a développé les junipernetworks.junos modules en utilisant une approche cohérente appliquée à toutes les collections réseau gérées par Red Hat. Cette approche a permis d’utiliser des modèles de configuration pour une gestion rationalisée et reproductible des configurations.

Hormis quelques différences notables, les juniper.device modules et les junipernetworks.junos modules offrent des fonctions similaires pour la gestion des équipements Junos. Les deux ensembles de modules vous permettent de :

Obtenir des informations sur les appareils
Exécuter des commandes et des RPC sur un appareil
Installer des packages logiciels
Exécuter des opérations ping à partir d’un appareil
Configurer un appareil

Les deux ensembles de modules offrent des options similaires pour configurer les appareils. Par exemple, vous pouvez :

Charger les données de configuration dans l’un des formats acceptés à partir d’un fichier
Chargez les données de configuration sous forme de set commandes fournies dans les arguments du module
Annuler la configuration
Remplacement de l’ensemble de la configuration
Spécifier le format et l’opération de chargement pour le chargement des données de configuration
Validez la configuration et incluez les options de commit courantes

Les ensembles de modules présentent également quelques différences en ce qui concerne les opérations de configuration. Les junipernetworks.junos modules fournissent de nombreux modèles de configuration qui vous permettent de configurer facilement des instructions communes pour des zones spécifiques de la hiérarchie de configuration. Par exemple, vous pouvez configurer des options communes pour OSPF ou des routes statiques.

De même, les juniper.device modules offrent des capacités de configuration supplémentaires. Vous pouvez comparer les configurations, charger la configuration de secours et charger les données de configuration à l’aide d’un modèle Jinja2. Vous pouvez également sélectionner le mode de configuration. Par exemple, vous pouvez utiliser le mode batch ; configurer une copie privée de la configuration candidate ; ou configurer la base de données dynamique ou éphémère. Les juniper.device modules fournissent également des options de validation supplémentaires pour synchroniser la configuration, valider les modifications vides et ignorer les avertissements de validation.

Une autre différence clé entre les ensembles de modules est qu’ils s’intègrent juniper.device à plusieurs autres produits Juniper Networks. Par exemple, vos playbooks Ansible peuvent référencer les tables opérationnelles de Junos PyEZ pour récupérer les données d’état opérationnel d’un équipement. Les playbooks Ansible peuvent également effectuer des opérations Junos Snapshot Administrator in Python (JSNAPy). JSNAPy vous permet de capturer et d’auditer des instantanés de l’environnement d’exécution de vos équipements Junos. Ainsi, vous pouvez utiliser vos tables Junos PyEZ existantes et vos fichiers de configuration et de test JSNAPy dans vos playbooks Ansible.

Exécuter des modules sur des équipements Junos

Pour utiliser des collections hébergées dans le référentiel Ansible Galaxy, vous devez d’abord installer Ansible sur le nœud de contrôle, puis installer la collection. Pour plus d’informations sur l’installation de la collection, reportez-vous à la section Configuration requise d’Ansiblejuniper.device pour le serveur Junos OS.

Les modules Ansible peuvent effectuer des opérations sur un nœud géré. En règle générale, le nœud de contrôle Ansible envoie un module au nœud géré pour effectuer l’opération. Le nœud exécute le module puis le supprime. Dans ce scénario, le nœud géré doit avoir la capacité d’exécuter le module. Étant donné que la plupart des modules Ansible sont écrits en Python, Ansible nécessite généralement Python sur le nœud géré.

Les modules de la juniper.device collection, cependant, ne nécessitent pas Python sur les nœuds gérés. Contrairement à l’opération typique, le nœud de contrôle Ansible exécute les modules localement. Les modules utilisent l’API XML de Junos et NETCONF pour s’interfacer avec le nœud géré. Cette méthode d’exécution vous permet d’utiliser Ansible pour gérer n’importe quel équipement Junos pris en charge. La figure 1 illustre la communication entre le nœud de contrôle Ansible et un équipement Junos géré.

Figure 1 : Communication Ansible avec un équipement Ansible Communication with a Junos Device

Junos

Pour utiliser les juniper.device modules ou les junipernetworks.junos modules, votre playbook ou commande Ansible doit :

Spécifier la collection ou FQCN : pour spécifier la collection, incluez la collections clé dans la lecture. Vous pouvez également omettre la clé et référencer le collections contenu de la collection par son nom de collection complet (FQCN), qui est la méthode recommandée.

Exécuter les modules localement sur le nœud de contrôle : pour exécuter les modules Ansible localement, vous devez définir les paramètres de connexion appropriés dans votre playbook, votre fichier d’inventaire ou vos options de commande. Définissez le connection paramètre dans le playbook ou définissez le ansible_connection paramètre dans le fichier d’inventaire ou les fichiers de variables hôtes ou de groupe. Pour les junipernetworks.junos modules, vous devez également spécifier le ansible_network_os paramètre. Vous définissez généralement ce paramètre dans le fichier d’inventaire. Le Tableau 2 présente les valeurs prises en charge.

Tableau 2 : Paramètres de connexion
Ensemble de modules	Guide de jeu	Fichier de stock
`juniper.device` (modules d’origine)	`connection: (local \| juniper.device.pyez)`	`ansible_connection=(local \| juniper.device.pyez)`
`junipernetworks.junos` (tous les `junos_*` modules sauf `junos_netconf` et `junos_ping`)	`connection: netconf`	`ansible_connection=netconf` `ansible_network_os=juniper.device.junos`
`junipernetworks.junos` `junos_netconf`( et `junos_ping`)	`connection: network_cli`	`ansible_connection=network_cli` `ansible_network_os=juniper.device.junos`

Fournissez les informations de connexion et d’authentification appropriées pour vous connecter à l’équipement géré.

Vous pouvez exécuter des modules Ansible à l’aide de n’importe quel compte utilisateur ayant accès à l’équipement Junos géré. Lorsque vous exécutez des modules Ansible, les privilèges d’accès au compte utilisateur Junos OS sont appliqués. La classe configurée pour le compte d’utilisateur Junos OS détermine les autorisations. Ainsi, si un utilisateur exécute un module qui charge des modifications de configuration sur un appareil, l’utilisateur doit disposer des autorisations nécessaires pour modifier les parties pertinentes de la configuration.

Les sections suivantes fournissent des exemples de playbooks et de fichiers d’inventaire pour les différents ensembles de modules.

Exemple de guide pour juniper.device les modules
Exemple de fichier d’inventaire et de guide pour junipernetworks.junos les modules

Exemple de playbook pour les modules juniper.device

Le playbook suivant exécute le juniper.device.facts module pour récupérer les informations sur l’appareil et les enregistrer dans un fichier. Dans cet exemple, nous définissons le type de connexion dans le playbook au lieu du fichier d’inventaire. L’utilisateur s’authentifie auprès de l’appareil à l’aide de clés SSH chargées dans un agent de clé SSH.

Vous pouvez également effectuer des opérations ad hoc sur la ligne de commande. La commande suivante exécute le module et récupère les informations sur les juniper.device.facts équipements à partir des hôtes du groupe junosd’inventaire.

Exemple de fichier d’inventaire et de guide pour les modules junipernetworks.junos

Si vous utilisez l’ensemble de junipernetworks.junos modules, vous pouvez définir les variables et ansible_network_os dans votre fichier d’inventaire ansible_connection ou vos fichiers de variables hôte ou de groupe. L’exemple de fichier d’inventaire suivant définit les paramètres de connexion pour le groupe dc1 sous dc1:vars.

Le playbook suivant exécute le junipernetworks.junos.junos_facts module sous l’espace de juniper.device noms. Le playbook fait référence au dc1 groupe, qui définit les valeurs de connexion et de système d’exploitation réseau appropriées dans le fichier d’inventaire.

Modules juniper.device

Le tableau 3 présente les modules originaux juniper.device de la juniper.device collection. Pour obtenir la liste des modules actuels, la documentation et des exemples d’utilisation des modules, voir https://ansible-juniper-collection.readthedocs.io.

Tableau 3 : `juniper.device` Modules
Nom du module	Descriptif	Connexions Ansible prises en charge
`command`	Exécutez des commandes en mode opérationnel sur le périphérique Junos et enregistrez la sortie localement.	`local` `juniper.device.pyez`
`config`	Gérez la configuration des équipements Junos.	`local` `juniper.device.pyez`
`facts`	Récupérez des informations spécifiques à l’équipement sur l’hôte distant, notamment la version de Junos OS, le numéro de série et le numéro de modèle du matériel.	`local` `juniper.device.pyez`
`file_copy`	Transférez un fichier entre le nœud de contrôle Ansible local et l’équipement Junos.	`local` `juniper.device.pyez`
`jsnapy`	Exécutez des tests Junos Snapshot Administrator in Python (JSNAPy) via Ansible.	`local` `juniper.device.pyez`
`ping`	Exécutez la `ping` commande à partir d’un équipement Junos.	`local` `juniper.device.pyez`
`pmtud`	Effectuez une détection de chemin MTU (PMTUD) sur les équipements Junos.	`local` `juniper.device.pyez`
`rpc`	Exécutez des RPC Junos OS.	`local` `juniper.device.pyez`
`software`	Installez un progiciel et redémarrez un équipement Junos.	`local` `juniper.device.pyez`
`srx_cluster`	Créez un cluster de châssis SRX Series pour les pare-feu SRX Series compatibles avec les clusters.	`local` `juniper.device.pyez`
`system`	Effectuez des opérations système sur les équipements Junos, y compris la réinitialisation, le redémarrage ou l’arrêt de l’équipement.	`local` `juniper.device.pyez`
`table`	Utilisez les tables et les vues opérationnelles de Junos PyEZ pour récupérer des informations opérationnelles à partir des équipements Junos.	`local` `juniper.device.pyez`

`junipernetworks.junos` Modules

À partir de juniper.device la version 2.0.0, la juniper.device collection comprend les junipernetworks.junos modules. Le tableau 4 présente les junipernetworks.junos modules de la juniper.device collection. L’ensemble des modules vous permet d’effectuer des tâches opérationnelles. Il comprend également de nombreux modules de modèles de configuration qui permettent de configurer des paramètres communs pour diverses fonctionnalités, protocoles et services sur les équipements Junos.

Tableau 4 : `junipernetworks.junos` Modules
Nom du module	Descriptif	Connexions Ansible prises en charge
Modules opérationnels
`junos_command`	Exécutez des commandes en mode opérationnel sur l’équipement Junos.	`ansible.netcommon.netconf` `ansible.netcommon.network_cli`
`junos_facts`	Récupérez les informations spécifiques à l’équipement à partir de l’hôte distant.	`ansible.netcommon.netconf`
`junos_package`	Installez un progiciel et redémarrez un équipement Junos.	`ansible.netcommon.netconf`
`junos_ping`	Exécutez la `ping` commande à partir d’un équipement Junos.	`ansible.netcommon.network_cli`
`junos_rpc`	Exécutez des RPC Junos OS via NETCONF sur un équipement Junos.	`ansible.netcommon.netconf`
Configuration Modules
`junos_acl_interfaces`	Appliquez des filtres de pare-feu sur une interface.	`ansible.netcommon.netconf`
`junos_acls`	Configurez les filtres de pare-feu, parfois appelés listes de contrôle d’accès (ACL).	`ansible.netcommon.netconf`
`junos_banner`	Configurez les bannières.	`ansible.netcommon.netconf`
`junos_bgp_address_family`	Gérez les attributs de la famille d’adresses BGP des interfaces.	`ansible.netcommon.netconf`
`junos_bgp_global`	Configurez les propriétés globales de BGP.	`ansible.netcommon.netconf`
`junos_config`	Gérez la configuration des équipements Junos.	`ansible.netcommon.netconf`
`junos_hostname`	Configurez le nom d’hôte de l’appareil.	`ansible.netcommon.netconf`
`junos_interfaces`	Configurez les propriétés physiques et logiques de base de l’interface.	`ansible.netcommon.netconf`
`junos_l2_interfaces`	Configurer les interfaces L2.	`ansible.netcommon.netconf`
`junos_l3_interfaces`	Configurez les interfaces L3.	`ansible.netcommon.netconf`
`junos_lacp`	Configurez les propriétés globales LACP (Link Aggregation Control Protocol) pour les interfaces Ethernet agrégées.	`ansible.netcommon.netconf`
`junos_lacp_interfaces`	Gérer les attributs LACP d’une interface.	`ansible.netcommon.netconf`
`junos_lag_interfaces`	Configurez les LAG (Link Aggregation Groups).	`ansible.netcommon.netconf`
`junos_lldp_global`	Configurez les paramètres globaux du protocole LLDP (Link Layer Discovery Protocol).	`ansible.netcommon.netconf`
`junos_lldp_interfaces`	Gérez les attributs LLDP d’une interface.	`ansible.netcommon.netconf`
`junos_logging_global`	Configurez la journalisation du système.	`ansible.netcommon.netconf`
`junos_netconf`	Configurez le service système NETCONF.	`ansible.netcommon.network_cli`
`junos_ntp_global`	Configurez le protocole NTP (Network Time Protocol).	`ansible.netcommon.netconf`
`junos_ospf_interfaces`	Gérez la configuration OSPF des interfaces.	`ansible.netcommon.netconf`
`junos_ospfv2`	Configurez OSPFv2.	`ansible.netcommon.netconf`
`junos_ospfv3`	Configurez OSPFv3.	`ansible.netcommon.netconf`
`junos_prefix_lists`	Configurez les listes de préfixes de la politique de routage.	`ansible.netcommon.netconf`
`junos_routing_instances`	Configurez les instances de routage.	`ansible.netcommon.netconf`
`junos_routing_options`	Configurez les options de routage.	`ansible.netcommon.netconf`
`junos_security_policies`	Configurer et gérer les politiques de sécurité.	`ansible.netcommon.netconf`
`junos_security_policies_global`	Configurez les paramètres de stratégie de sécurité globale.	`ansible.netcommon.netconf`
`junos_security_zones`	Configurez les zones de sécurité.	`ansible.netcommon.netconf`
`junos_snmp_server`	Gérez la configuration du serveur SNMP.	`ansible.netcommon.netconf`
`junos_static_routes`	Configurez des routes statiques.	`ansible.netcommon.netconf`
`junos_system`	Gérez le nom d’hôte et la configuration DNS.	`ansible.netcommon.netconf`
`junos_user`	Configurez les comptes d’utilisateurs locaux.	`ansible.netcommon.netconf`
`junos_vlans`	Configurez les VLAN.	`ansible.netcommon.netconf`
`junos_vrf`	Gérez les définitions VRF sur l’appareil.	`ansible.netcommon.netconf`

SUR CETTE PAGE