Utiliser Junos Snapshot Administrator en Python (JSNAPy) dans Ansible Playbooks
RÉSUMÉ Exécutez des tests JSNAPy dans le cadre d’un playbook Ansible pour capturer et auditer les instantanés d’environnement d’exécution des équipements Junos.
Junos Snapshot Administrator in Python (JSNAPy) vous permet de capturer et d’auditer des instantanés de l’environnement d’exécution de vos périphériques Junos® réseau. Vous pouvez capturer et vérifier la configuration et l’état opérationnel d’un appareil, ainsi que vérifier les modifications apportées à un appareil. Juniper Networks fournit des modules Ansible qui vous permettent d’exécuter des tests JSNAPy sur des équipements Junos dans le cadre d’un playbook Ansible. Le tableau 1 présente les modules disponibles.
Ensemble de contenu |
Nom du module |
---|---|
|
|
|
Vous devez installer Junos Snapshot Administrator en Python sur le nœud de contrôle Ansible pour utiliser les modules. Pour obtenir des instructions d’installation et des informations sur la création de fichiers de configuration et de test JSNAPy, reportez-vous à Junos Snapshot Administrator dans la documentation Python.
À partir de la Juniper.junos
version 2.0.0, le juniper_junos_jsnapy
module remplace les fonctionnalités du junos_jsnapy
module.
Les sections suivantes expliquent comment utiliser les modules dans les playbooks Ansible.
Présentation du module
Les jsnapy
modules et juniper_junos_jsnapy
vous permettent d’exécuter bon nombre des mêmes fonctions JSNAPy à partir d’un playbook Ansible que vous pouvez exécuter à l’aide de JSNAPy sur la ligne de commande, notamment :
-
Capture et enregistrement d’un instantané de l’environnement d’exécution
-
Comparaison de deux instantanés
-
capturer un instantané et l’évaluer immédiatement
Les modules nécessitent de spécifier l’argument et l’argument action
ou config_file
test_files
. L’argument action
spécifie l’action JSNAPy à exécuter. Le tableau 2 présente les valeurs valides action
et les commandes JSNAPy équivalentes.
Valeur de l’action |
Description |
Commande JSNAPy équivalente |
---|---|---|
|
Comparez deux instantanés existants en fonction des cas de test donnés ou, si aucun cas de test n’est fourni, comparez les instantanés nœud par nœud. |
|
|
Prenez des instantanés pour les commandes ou les RPC spécifiés dans les fichiers de test après avoir apporté des modifications sur les périphériques donnés. |
|
|
Prenez des instantanés pour les commandes ou les RPC spécifiés dans les fichiers de test avant d’apporter des modifications sur les périphériques donnés. |
|
|
Prenez des instantanés des commandes ou des RPC spécifiés dans les fichiers de test et évaluez-les immédiatement par rapport à des critères prédéfinis dans les cas de test. |
|
Lorsque vous exécutez JSNAPy sur la ligne de commande, JSNAPy effectue l’action demandée sur les hôtes spécifiés dans la hosts
section du fichier de configuration. En revanche, les modules Ansible exécutent l’action demandée sur les hôtes du groupe d’inventaire Ansible défini dans le playbook. Par conséquent, le module peut soit référencer un fichier de configuration, en ignorant la hosts
section, soit référencer directement un ou plusieurs fichiers de test.
Ainsi, en plus de l’argument, les modules et nécessitent également l’argument ou l’argument pour spécifier le fichier de configuration JSNAPy ou les fichiers de test JSNAPy à utiliser pour l’action action
config_file
test_files
donnée. Le tableau 3 présente les config_file
jsnapy
arguments et.juniper_junos_jsnapy
test_files
Module argument |
Valeur |
Informations supplémentaires |
---|---|---|
|
Chemin d’accès absolu ou relatif à un fichier de configuration JSNAPy. |
Si le chemin est relatif, le module recherche le fichier de configuration aux emplacements suivants et dans l’ordre indiqué :
Si le fichier de configuration référence les fichiers de test à l’aide d’un chemin d’accès relatif, le module recherche d’abord les fichiers de test dans le répertoire playbook, puis recherche les fichiers de test dans le répertoire par défaut |
|
Chemin d’accès absolu ou relatif à un fichier test JSNAPy. Il peut s’agir d’un chemin d’accès à un seul fichier ou d’une liste de chemins d’accès. |
Pour chaque fichier de test qui spécifie un chemin relatif, le module recherche le fichier aux emplacements suivants et dans l’ordre indiqué :
|
Les config_file
arguments et test_files
peuvent prendre un chemin d’accès absolu ou relatif. Lorsque vous utilisez un chemin d’accès relatif, vous pouvez éventuellement inclure l’argument dir
module pour spécifier le répertoire dans lequel résident les fichiers. Si un argument ou test_files
utilise un config_file
chemin d’accès relatif au fichier, le module vérifie d’abord le fichier dans le répertoire du playbook Ansible, même si l’argument dir
est présent. Si le fichier n’existe pas sous le répertoire playbook, le module vérifie sous le répertoire des arguments, s’il est spécifié, ou sous le dir
répertoire /etc/jsnapy/testfiles, si l’argument dir
est omis. Le playbook génère un message d’erreur si le fichier est introuvable.
L’exemple de playbook suivant exécute l’action à l’aide snap_pre
du fichier de configuration configuration_interface_status.yaml. Si le fichier de configuration n’existe pas dans le répertoire playbook, le module recherche le fichier dans le répertoire personnel de l’utilisateur sous le sous-répertoire jsnapy/testfiles .
--- - name: Junos Snapshot Administrator tests hosts: dc1a connection: local gather_facts: no tasks: - name: Take a pre-maintenance snapshot of the interfaces juniper.device.jsnapy: action: "snap_pre" dir: "~/jsnapy/testfiles" config_file: "configuration_interface_status.yaml"
À partir de Junos Snapshot Administrator dans Python version 1.3.0, l’emplacement par défaut des fichiers de configuration et de test est ~/jsnapy/testfiles. Cependant, l’emplacement par défaut dans un environnement virtuel ou pour les versions antérieures est / etc/jsnapy/testfiles.
Le module effectue l’action demandée sur les hôtes spécifiés dans le playbook Ansible, même s’il fait référence à un fichier de configuration qui inclut une hosts
section. Le module signale un échec s’il rencontre une erreur et ne parvient pas à exécuter les tests JSNAPy. Il ne signale pas d’échec si un ou plusieurs des tests JSNAPy échouent. Pour vérifier les résultats du test JSNAPy, enregistrez la réponse du module et utilisez le module pour vérifier le assert
résultat attendu dans la réponse.
Junos Snapshot Administrator en Python consigne par défaut les informations relatives à ses opérations dans le fichier / var/log/jsnapy/jsnapy.log . Les jsnapy
modules et juniper_junos_jsnapy
peuvent éventuellement inclure l’argument, qui spécifie le chemin d’accès logfile
à un fichier accessible en écriture sur le nœud de contrôle Ansible où les informations relatives à la tâche particulière sont consignées. Le niveau d’informations enregistrées dans le fichier est déterminé par le niveau de détail et les options de débogage d’Ansible. Par défaut, seuls les messages de niveau de gravité AVERTISSEMENT ou supérieur sont enregistrés. Pour consigner des messages égaux ou supérieurs au niveau de gravité INFO ou au niveau de gravité DEBUG, exécutez le playbook avec l’option de ligne de -v
commande ou -vv
, respectivement.
Lorsque vous exécutez des tests JSNAPy dans un playbook Ansible, vous pouvez activer le plug-in de rappel pour capturer et résumer les jsnapy
informations relatives aux tests JSNAPy ayant échoué. Pour activer le plug-in de rappel, ajoutez l’instruction callback_whitelist = jsnapy
au fichier de configuration Ansible. Pour plus d’informations, consultez Activer le plug-in de rappel jsnapy.
Prendre et comparer des instantanés
JSNAPy vous permet de capturer des instantanés de l’environnement d’exécution de vos périphériques Junos réseau avant et après une modification, puis de comparer les instantanés pour vérifier les modifications attendues ou identifier les problèmes inattendus. Les jsnapy
modules et juniper_junos_jsnapy
Ansible vous permettent de prendre et de comparer des instantanés JSNAPy dans le cadre d’un playbook Ansible. Les modules enregistrent chaque snapshot pour chaque hôte dans un fichier séparé du répertoire de snapshots JSNAPy par défaut à l’aide d’un nom de fichier prédéterminé. Pour plus d’informations sur les fichiers de sortie, consultez Présentation de la sortie du module jsnapy et juniper_junos_jsnapy.
Pour prendre des instantanés de base d’un ou de plusieurs périphériques avant d’apporter des modifications, définissez l’argument du action
module sur snap_pre
, puis spécifiez un fichier de configuration ou un ou plusieurs fichiers de test.
Le playbook suivant enregistre les instantanés PRE pour chaque périphérique du groupe d’inventaire Ansible. La tâche référence le fichier de configuration configuration_interface_status.yaml dans le répertoire ~/jsnapy/testfiles et consigne les messages dans le fichier jsnapy_tests.log dans le répertoire playbook.
--- - name: Junos Snapshot Administrator tests hosts: dc1 connection: local gather_facts: no tasks: - name: Take a pre-maintenance snapshot of the interfaces juniper.device.jsnapy: action: "snap_pre" dir: "~/jsnapy/testfiles" config_file: "configuration_interface_status.yaml" logfile: "jsnapy_tests.log"
Pour prendre un instantané d’un ou de plusieurs périphériques après avoir effectué des modifications, définissez l’argument du action
module sur snap_post
, puis spécifiez un fichier de configuration ou un ou plusieurs fichiers de test.
Le playbook suivant enregistre les instantanés POST pour chaque périphérique du groupe d’inventaire Ansible. La tâche fait référence au même fichier de configuration configuration_interface_status.yaml dans le répertoire ~/jsnapy/testfiles et consigne les messages dans le fichier jsnapy_tests.log du répertoire playbook.
--- - name: Junos Snapshot Administrator tests hosts: dc1 connection: local gather_facts: no tasks: - name: Take a post-maintenance snapshot of the interfaces juniper.device.jsnapy: action: "snap_post" dir: "~/jsnapy/testfiles" config_file: "configuration_interface_status.yaml" logfile: "jsnapy_tests.log"
Lorsque le jsnapy
module ou effectue une action ou une action, il enregistre chaque instantané pour chaque hôte dans un fichier distinct à l'aide de noms de fichiers générés automatiquement qui contiennent respectivement une snap_pre
snap_post
balise 'PRE' ou juniper_junos_jsnapy
'POST'. Pour comparer les instantanés et POST
afin de vérifier rapidement les mises à jour ou d’identifier les problèmes susceptibles d’avoir pu résulter des modifications, définissez l’argument du action
module sur check
, et spécifiez le ou les mêmes fichiers de test que ceux utilisés pour prendre les PRE
instantanés.
Lorsque le module effectue une check
action, les instantanés PRE et POST préexistants pour chaque test sur chaque appareil sont comparés et évalués par rapport aux critères définis dans la tests:
section des fichiers de test. Si les fichiers de test ne définissent aucun cas de test, JSNAPy compare les snapshots nœud par nœud. Pour vérifier les résultats du test, enregistrez la réponse du module et utilisez le module pour vérifier le assert
résultat attendu dans la réponse.
Le playbook suivant compare les instantanés pris pour les exécutions snap_pre
précédentes et snap_post
les actions pour chaque appareil du groupe d’inventaire Ansible. Les résultats sont évalués à l’aide des critères des fichiers de test référencés dans le fichier de configuration. Le playbook enregistre la réponse du module comme '' et utilise le assert
module pour vérifier que tous les tests ont réussi sur l'test_result
appareil donné.
--- - name: Junos Snapshot Administrator tests hosts: dc1 connection: local gather_facts: no tasks: - name: Compare PRE and POST snapshots juniper.device.jsnapy: action: "check" dir: "~/jsnapy/testfiles" config_file: "configuration_interface_status.yaml" logfile: "jsnapy_tests.log" register: test_result - name: Verify JSNAPy tests passed assert: that: - "test_result.passPercentage == 100"
Lorsque vous exécutez le playbook, les assertions identifient rapidement les appareils qui ont échoué aux tests.
user@host:~$ ansible-playbook jsnapy-interface-check.yaml PLAY [Junos Snapshot Administrator tests] ************************************* TASK [Compare PRE and POST snapshots] ***************************************** ok: [dc1a.example.net] ok: [dc1b.example.net] TASK [Verify JSNAPy tests passed] ********************************************* ok: [dc1b.example.net] => { "changed": false, "msg": "All assertions passed" } fatal: [dc1a.example.net]: FAILED! => { "assertion": "test_result.passPercentage == 100", "changed": false, "evaluated_to": false, "msg": "Assertion failed" } to retry, use: --limit @/home/user/jsnapy-interface-check.retry PLAY RECAP ******************************************************************** dc1b.example.net : ok=2 changed=0 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0 dc1a.example.net : ok=1 changed=0 unreachable=0 failed=1 skipped=0 rescued=0 ignored=0
Effectuer des opérations Snapcheck
JSNAPy vous permet de prendre des instantanés pour les commandes ou les RPC spécifiés dans les fichiers de test JSNAPy et d’évaluer immédiatement les instantanés par rapport à des critères prédéfinis dans les cas de test. Les jsnapy
modules et juniper_junos_jsnapy
Ansible vous permettent d’effectuer une opération snapcheck JSNAPy dans le cadre d’un playbook Ansible.
Pour prendre un instantané et l’évaluer immédiatement en fonction de l’ensemble de critères prédéfinis dans la tests:
section des fichiers de test, définissez l’argument du action
module sur snapcheck
, puis spécifiez un fichier de configuration ou un ou plusieurs fichiers de test. Pour vérifier les résultats du test, enregistrez la réponse du module et utilisez le module pour vérifier le assert
résultat attendu dans la réponse.
Par exemple, pour chaque périphérique du groupe d’inventaire Ansible, le playbook suivant enregistre un instantané distinct pour chaque commande ou RPC dans les fichiers de test, enregistre la réponse du module et utilise le module assert pour vérifier que tous les tests définis dans les fichiers de test ont réussi sur cet appareil.
--- - name: Junos Snapshot Administrator tests hosts: dc1 connection: local gather_facts: no tasks: - name: Take a snapshot and immediately evaluate it juniper.device.jsnapy: action: "snapcheck" dir: "~/jsnapy/testfiles/" test_files: - "test_interface_status.yaml" - "test_bgp_neighbor.yaml" logfile: "jsnapy_tests.log" register: test_result - name: Verify JSNAPy tests passed assert: that: - "test_result.passPercentage == 100"
Comprendre la sortie du module jsnapy et juniper_junos_jsnapy
Lorsque le module ou exécute une snap_pre
action , snap_post
ou snapcheck
juniper_junos_jsnapy
, il enregistre automatiquement les snapshots dans le jsnapy
répertoire des snapshots JSNAPy. Les modules utilisent les répertoires JSNAPy par défaut, sauf si vous modifiez le fichier de configuration JSNAPy pour spécifier un emplacement différent. Le module crée un fichier distinct pour chaque commande ou RPC exécuté sur chaque périphérique du groupe d’inventaire Ansible. Le tableau 4 indique les noms des fichiers de capture instantanée pour chaque valeur de l’argumentaction
.
À partir de Junos Snapshot Administrator dans Python version 1.3.0, les répertoires par défaut des fichiers de test et des snapshots JSNAPy sont respectivement ~/jsnapy/testfiles et ~/jsnapy/snapshots. Cependant, les répertoires par défaut dans un environnement virtuel ou pour les versions antérieures sont /etc/jsnapy/testfiles et /etc/jsnapy/snapshots.
|
Fichiers de sortie |
---|---|
|
hostname_PRÉ__hashcommand.format |
|
hostname_POSTE__hash.commandformat |
|
hostname_snap_temp_hash_command.format |
Où:
-
hostname: nom d’hôte de l’équipement sur lequel la commande ou le RPC est exécuté.
-
(PRE | POSTE | snap_temp) : balise identifiant l’action. L’opération
snapcheck
utilise la balise dans les versions actuelles ; dans les versions antérieures, l’opération utilise laPRE
snap_temp
balise. -
hash—Hachage généré à partir de pour les fichiers de
kwargs
test qui incluent lesrpc
clés etkwargs
.Si les fichiers de test utilisent le même RPC mais incluent des arguments différents, et que les RPC sont exécutés sur le même hôte, le hachage garantit des noms de fichiers de sortie uniques dans ces cas. Si un fichier de test définit la clé ou si un fichier de test définit la clé mais n’inclut pas la
command
rpc
kwargs
clé, le hachage est omis. -
command: commande ou RPC exécutée sur l’équipement géré. Le module remplace les espaces et les caractères spéciaux dans la commande ou le nom RPC par des traits de soulignement ( _ ).
-
format: format de la sortie, par exemple, xml.
Les jsnapy
modules et différencient uniquement les noms de fichiers instantanés pour une action donnée en fonction du nom d’hôte et juniper_junos_jsnapy
de la commande ou RPC. Par conséquent, si le module prend des instantanés sur le même appareil pour la même action à l’aide de fichiers de test qui définissent la même commande ou RPC, le module générera des instantanés avec le même nom de fichier et le nouveau fichier écrasera l’ancien fichier.
Par exemple, si le module inclut action: "snap_pre"
et référence des fichiers de test qui exécutent les show chassis fpc
commandes et sur les périphériques dc1a.example.net et show interfaces terse
dc1b.example.net, les fichiers résultants sont les suivants :
user@ansible-cn:~$ ls jsnapy/snapshots dc1a.example.net_PRE_show_chassis_fpc.xml dc1a.example.net_PRE_show_interfaces_terse.xml dc1b.example.net_PRE_show_chassis_fpc.xml dc1b.example.net_PRE_show_interfaces_terse.xml
Si le module inclut action: "snap_post"
et référence un fichier de test qui exécute le RPC avec kwargs
l’élément interface_name: lo0
sur le périphérique dc1a.example.net, le get-interface-information
fichier résultant est :
dc1a.example.net_POST_r1w59I99HXxC3u0VXXshbw==_get_interface_information.xml
En plus de générer les fichiers de capture instantanée, les modules et juniper_junos_jsnapy
peuvent également renvoyer les jsnapy
clés suivantes dans la réponse du module :
-
action
—JSNAPy action effectuée par le module. -
changed
: indique si l’état du périphérique a changé. Étant donné que JSNAPy ne fait rapport que sur l’état, la valeur est toujoursfalse
. -
failed
: indique si la tâche playbook a échoué. -
msg
—Résultats du test JSNAPy.
Activer le plug-in jsnapy Callback
Lorsque vous exécutez des tests JSNAPy sur des périphériques Junos et qu’un ou plusieurs tests échouent, il peut être difficile d’identifier et d’extraire les tests échoués si le résultat est étendu. Le jsnapy
plug-in de rappel vous permet d’extraire et de résumer facilement les informations relatives aux tests JSNAPy qui ont échoué. Lorsque vous activez le plug-in de rappel et exécutez un playbook qui inclut des tests JSNAPy, le plug-in résume les informations pour les tests JSNAPy ayant échoué après le jsnapy
playbook PLAY RECAP
.
Le jsnapy
plug-in de rappel n’est pas activé par défaut. Pour activer le plug-in de rappel, ajoutez l’instruction callback_whitelist = jsnapy
au fichier de jsnapy
configuration Ansible.
[defaults] callback_whitelist = jsnapy
Lorsque vous activez le plug-in de rappel et exécutez un playbook, le jsnapy
plug-in résume les tests JSNAPy échoués dans un format lisible par l’homme. Par exemple :
... PLAY RECAP **************************************************************** qfx10002-01 : ok=3 changed=0 unreachable=0 failed=1 qfx10002-02 : ok=3 changed=0 unreachable=0 failed=1 qfx5100-01 : ok=1 changed=0 unreachable=0 failed=1 JSNAPy Results for: qfx10002-01 ******************************************* Value of 'peer-state' not 'is-equal' at '//bgp-information/bgp-peer' with {"peer-as": "64502", "peer-state": "Active", "peer-address": "198.51.100.21"} Value of 'peer-state' not 'is-equal' at '//bgp-information/bgp-peer' with {"peer-as": "64510", "peer-state": "Idle", "peer-address": "192.168.0.1"} Value of 'oper-status' not 'is-equal' at '//interface-information/physical-interface[normalize-space(admin-status)='up' and logical-interface/address-family/address-family-name ]' with {"oper-status": "down", "name": "et-0/0/18"} JSNAPy Results for: qfx10002-02 ******************************************* Value of 'peer-state' not 'is-equal' at '//bgp-information/bgp-peer' with {"peer-as": "64502", "peer-state": "Active", "peer-address": "198.51.100.21"}
Exemple : utiliser Ansible pour effectuer une opération JSNAPy Snapcheck
Le jsnapy
module vous permet d’exécuter des tests JSNAPy sur des équipements Junos dans le cadre d’un playbook Ansible. Cet exemple utilise le jsnapy
module pour effectuer une snapcheck
action visant à vérifier l’état de fonctionnement des équipements Junos après l’application de modifications de configuration spécifiques.
- Exigences
- Aperçu
- Configuration
- Exécuter le playbook
- Vérification
- Résoudre les erreurs Ansible Playbook
Exigences
Cet exemple utilise les composants matériels et logiciels suivants :
-
Nœud de contrôle Ansible en cours d’exécution :
-
Python 3.7 ou version ultérieure
-
Ansible 2.10 ou version ultérieure avec la
juniper.device
collection installée -
Junos PyEZ version 2.6.0 ou ultérieure
-
Junos Snapshot Administrator dans Python version 1.3.6 ou ultérieure
-
Avant d’exécuter le playbook Ansible, assurez-vous d’avoir :
-
Équipements Junos avec NETCONF over SSH activé et compte utilisateur configuré avec les autorisations appropriées
-
Paire de clés publique/privée SSH configurée pour l’utilisateur approprié sur le nœud de contrôle Ansible et l’équipement Junos
-
Fichier d’inventaire Ansible existant avec les hôtes requis définis
Aperçu
Dans cet exemple, le playbook Ansible configure les sessions d’appairage BGP sur trois équipements Junos et utilise le jsnapy
module pour vérifier que la session BGP est établie pour chaque adresse voisine. Si le playbook vérifie que les sessions sont établies sur un appareil, il confirme la validation de la nouvelle configuration. Si le playbook ne confirme pas la validation, le périphérique Junos revient automatiquement à la configuration précédemment validée. Le projet Ansible définit les variables groupe et hôte pour le playbook sous les group_vars
répertoires et host_vars
, respectivement.
Le playbook comporte deux pièces. La première lecture, , génère et assemble la configuration, Load and commit BGP configuration
charge la configuration sur l’équipement et la valide à l’aide d’une opération de validation confirmée. Si la configuration est mise à jour, un gestionnaire est averti. Le jeu exécute les tâches suivantes :
Remove build directory |
Supprime le répertoire de build existant pour le périphérique donné, le cas échéant. |
Create build directory |
Crée un répertoire de build vide pour le périphérique donné. |
Build BGP configuration |
Utilise le module avec le modèle Jinja2 et les variables hôtes pour restituer la configuration BGP pour le |
Assemble configuration parts |
Utilise le module pour assembler le Dans cet exemple, seul le fichier de configuration BGP sera présent, et donc le fichier de configuration résultant est identique au fichier de configuration BGP rendu dans la tâche précédente. Si vous ajoutez ultérieurement de nouvelles tâches pour générer des fichiers de configuration supplémentaires à partir d’autres modèles, le |
Load and commit config, require confirmation |
Charge la configuration sur le périphérique Junos et valide la configuration à l’aide d’une opération qui nécessite une Si la configuration demandée est déjà présente sur l’appareil, le |
Le second play, , effectue une opération JSNAPy sur chaque périphérique en utilisant les tests des fichiers de test JSNAPy snapcheck
et confirme le commit, Verify BGP
à condition que tous les tests réussissent. Le jeu exécute les tâches suivantes :
Execute snapcheck |
Effectue une opération JSNAPy Dans cet exemple, le playbook référence directement les fichiers de test JSNAPy en définissant l’argument |
Confirm commit |
Exécute une opération de vérification de validation, qui confirme l’opération de validation précédente, à condition que le premier playbook ait mis à jour la configuration et que tous les tests JSNAPy aient réussi. Si le playbook met à jour la configuration mais ne confirme pas la validation, le périphérique Junos restaure automatiquement la configuration à la configuration précédemment validée.
Note:
Vous pouvez confirmer l’opération de validation précédente avec une |
Verify BGP configuration |
(Facultatif) Indique explicitement si les tests JSNAPy ont réussi ou échoué sur le périphérique donné. Cette tâche n’est pas spécifiquement requise, mais elle identifie plus facilement quand les tests JSNAPy échouent et sur quels équipements. |
Configuration
- Définition des variables de groupe
- Définir le modèle Jinja2 et les variables hôtes
- Créer les fichiers de test JSNAPy
- Créer le playbook Ansible
- Résultats
Définition des variables de groupe
Procédure étape par étape
Pour définir les variables de groupe :
-
Dans le fichier group_vars/all , définissez des variables pour le répertoire de génération et pour les noms de fichiers des fichiers journaux et de configuration.
build_dir: "{{ playbook_dir }}/build_conf/{{ inventory_hostname }}" junos_conf: "{{ build_dir }}/junos.conf" logfile: "junos.log"
Définir le modèle Jinja2 et les variables hôtes
Définir le modèle Jinja2
Pour créer le modèle Jinja2 utilisé pour générer la configuration BGP :
Créez un fichier nommé bgp-template.j2 dans le répertoire playbook du projet.
Ajoutez le modèle de configuration BGP au fichier.
interfaces { {% for neighbor in neighbors %} {{ neighbor.interface }} { unit 0 { description "{{ neighbor.name }}"; family inet { address {{ neighbor.local_ip }}/30; } } } {% endfor %} lo0 { unit 0 { family inet { address {{ loopback }}/32; } } } } protocols { bgp { group underlay { import bgp-in; export bgp-out; type external; local-as {{ local_asn }}; multipath multiple-as; {% for neighbor in neighbors %} neighbor {{ neighbor.peer_ip }} { peer-as {{ neighbor.asn }}; } {% endfor %} } } lldp { {% for neighbor in neighbors %} interface "{{ neighbor.interface }}"; {% endfor %} } } routing-options { router-id {{ loopback }}; forwarding-table { export bgp-ecmp; } } policy-options { policy-statement bgp-ecmp { then { load-balance per-packet; } } policy-statement bgp-in { then accept; } policy-statement bgp-out { then { next-hop self; accept; } } }
Définition des variables hôtes
Pour définir les variables hôtes utilisées avec le modèle Jinja2 afin de générer la configuration BGP :
Dans le répertoire host_vars du projet, créez un fichier distinct nommé hostname.yaml pour chaque hôte.
Définissez les variables pour l’hôte r1 dans le fichier r1.yaml.
--- loopback: 192.168.0.1 local_asn: 64521 neighbors: - interface: ge-0/0/0 name: to-r2 asn: 64522 peer_ip: 198.51.100.2 local_ip: 198.51.100.1 peer_loopback: 192.168.0.2 - interface: ge-0/0/1 name: to-r3 asn: 64523 peer_ip: 198.51.100.6 local_ip: 198.51.100.5 peer_loopback: 192.168.0.3
Définissez les variables de l’hôte r2 dans le fichier r2.yaml.
--- loopback: 192.168.0.2 local_asn: 64522 neighbors: - interface: ge-0/0/0 name: to-r1 asn: 64521 peer_ip: 198.51.100.1 local_ip: 198.51.100.2 peer_loopback: 192.168.0.1 - interface: ge-0/0/1 name: to-r3 asn: 64523 peer_ip: 198.51.100.10 local_ip: 198.51.100.9 peer_loopback: 192.168.0.3
Définissez les variables pour l’hôte r3 dans le fichier r3.yaml.
--- loopback: 192.168.0.3 local_asn: 64523 neighbors: - interface: ge-0/0/0 name: to-r1 asn: 64521 peer_ip: 198.51.100.5 local_ip: 198.51.100.6 peer_loopback: 192.168.0.1 - interface: ge-0/0/1 name: to-r2 asn: 64522 peer_ip: 198.51.100.9 local_ip: 198.51.100.10 peer_loopback: 192.168.0.2
Créer les fichiers de test JSNAPy
Procédure étape par étape
Le jsnapy
module référence les fichiers de test JSNAPy dans le répertoire ~/jsnapy/testfiles . Pour créer les fichiers de test JSNAPy :
Créez le fichier jsnapy_test_file_bgp_states.yaml , qui exécute la
show bgp neighbor
commande et vérifie que l’état homologue BGP est établi.bgp_neighbor: - command: show bgp neighbor - ignore-null: True - iterate: xpath: '//bgp-peer' id: './peer-address' tests: # Check if peers are in the established state - is-equal: peer-state, Established err: "Test Failed!! peer <{{post['peer-address']}}> state is not Established, it is <{{post['peer-states']}}>" info: "Test succeeded!! peer <{{post['peer-address']}}> state is <{{post['peer-state']}}>"
Créez le fichier jsnapy_test_file_bgp_summary.yaml , qui exécute la
show bgp summary
commande et affirme que le nombre d’homologues BGP descendants doit être égal à 0.bgp_summary: - command: show bgp summary - item: xpath: '/bgp-information' tests: - is-equal: down-peer-count, 0 err: "Test Failed!! down-peer-count is not equal to 0. It is equal to <{{post['down-peer-count']}}>" info: "Test succeeded!! down-peer-count is equal to <{{post['down-peer-count']}}>"
Créer le playbook Ansible
- Définir le premier jeu pour configurer l’appareil
- Définir la deuxième lecture pour effectuer des opérations JSNAPy
Définir le premier jeu pour configurer l’appareil
Pour créer le premier jeu, qui restitue la configuration, la charge sur l’équipement et valide la configuration en tant qu’opération de validation confirmée :
Incluez le passe-partout pour le playbook et le premier play, qui exécute les modules localement.
--- - name: Load and commit BGP configuration hosts: bgp_routers connection: local gather_facts: no
Créez les tâches qui remplacent le répertoire de build existant par un répertoire vide, qui stockera les nouveaux fichiers de configuration.
tasks: - name: Remove build directory file: path: "{{ build_dir }}" state: absent - name: Create build directory file: path: "{{ build_dir }}" state: directory
Créez la tâche qui restitue la configuration BGP à partir du fichier de modèle Jinja2 et des variables hôtes et stockez-la dans le fichier bgp.conf du répertoire de build de cet hôte.
- name: Build BGP configuration template: src: "{{ playbook_dir }}/bgp-template.j2" dest: "{{ build_dir }}/bgp.conf"
Créez une tâche pour assembler les fichiers de configuration du répertoire de build dans le fichier de configuration junos.conf final.
- name: Assemble configuration parts assemble: src: "{{ build_dir }}" dest: "{{ junos_conf }}"
Créez la tâche qui charge la configuration sur l’appareil, effectue une opération de validation qui nécessite une confirmation et avertit le gestionnaire concerné, à condition que la configuration ait été modifiée.
- name: Load and commit config, require confirmation juniper.device.config: load: "merge" format: "text" src: "{{ junos_conf }}" confirm: 5 comment: "config by Ansible" logfile: "{{ logfile }}" register: config_result # Notify handler, only if configuration changes. notify: - Waiting for BGP peers to establish connections
Créez un gestionnaire qui suspend l’exécution du playbook si la configuration de l’appareil est mise à jour et définissez la durée de pause sur une valeur appropriée pour votre environnement.
handlers: - name: Waiting for BGP peers to establish connections pause: seconds=60
Définir la deuxième lecture pour effectuer des opérations JSNAPy
Pour créer le second play, qui effectue une opération JSNAPy snapcheck et confirme la configuration validée, à condition que la configuration ait changé et que les tests JSNAPy aient réussi :
Incluez le passe-partout pour la deuxième lecture, qui exécute les modules localement.
- name: Verify BGP hosts: bgp_routers connection: local gather_facts: no
Créez une tâche pour effectuer une opération JSNAPy snapcheck basée sur les tests des fichiers de test JSNAPy donnés et enregistrez la réponse du module.
tasks: - name: Execute snapcheck juniper.device.jsnapy: action: "snapcheck" dir: "~/jsnapy/testfiles" test_files: - "jsnapy_test_file_bgp_states.yaml" - "jsnapy_test_file_bgp_summary.yaml" logfile: "{{ logfile }}" register: snapcheck_result
Créez la tâche pour confirmer la validation si les conditions données sont remplies.
# Confirm commit only if configuration changed and JSNAPy tests pass - name: Confirm commit juniper.device.config: check: true commit: false diff: false logfile: "{{ logfile }}" when: - config_result.changed - "snapcheck_result.passPercentage == 100"
(Facultatif) Créez une tâche qui utilise le
assert
module pour affirmer que les tests JSNAPy ont réussi.- name: Verify BGP configuration assert: that: - "snapcheck_result.passPercentage == 100" msg: "JSNAPy test on {{ inventory_hostname }} failed"
Résultats
Sur le nœud de contrôle Ansible, consultez le playbook terminé. Si le playbook n’affiche pas le code voulu, répétez les instructions de cette section pour corriger le playbook.
--- - name: Load and commit BGP configuration hosts: bgp_routers connection: local gather_facts: no tasks: - name: Remove build directory file: path: "{{ build_dir }}" state: absent - name: Create build directory file: path: "{{ build_dir }}" state: directory - name: Build BGP configuration template: src: "{{ playbook_dir }}/bgp-template.j2" dest: "{{ build_dir }}/bgp.conf" - name: Assemble configuration parts assemble: src: "{{ build_dir }}" dest: "{{ junos_conf }}" - name: Load and commit config, require confirmation juniper.device.config: load: "merge" format: "text" src: "{{ junos_conf }}" confirm: 5 comment: "config by Ansible" logfile: "{{ logfile }}" register: config_result # Notify handler, only if configuration changes. notify: - Waiting for BGP peers to establish connections handlers: - name: Waiting for BGP peers to establish connections pause: seconds=60 - name: Verify BGP hosts: bgp_routers connection: local gather_facts: no tasks: - name: Execute snapcheck juniper.device.jsnapy: action: "snapcheck" dir: "~/jsnapy/testfiles" test_files: - "jsnapy_test_file_bgp_states.yaml" - "jsnapy_test_file_bgp_summary.yaml" logfile: "{{ logfile }}" register: snapcheck_result # Confirm commit only if configuration changed and JSNAPy tests pass - name: Confirm commit juniper.device.config: check: true commit: false diff: false logfile: "{{ logfile }}" when: - config_result.changed - "snapcheck_result.passPercentage == 100" - name: Verify BGP configuration assert: that: - "snapcheck_result.passPercentage == 100" msg: "JSNAPy test on {{ inventory_hostname }} failed"
Exécuter le playbook
Pour exécuter le playbook :
-
Exécutez la
ansible-playbook
commande sur le nœud de contrôle et indiquez le chemin du playbook et toutes les options souhaitées.user@ansible-cn:~/ansible$ ansible-playbook ansible-pb-bgp-configuration.yaml PLAY [Load and commit BGP configuration] ************************************* TASK [Remove build directory] ************************************************ changed: [r1] changed: [r2] changed: [r3] TASK [Create build directory] ************************************************ changed: [r1] changed: [r2] changed: [r3] TASK [Build BGP configuration] *********************************************** changed: [r2] changed: [r1] changed: [r3] TASK [Assemble configuration parts] ****************************************** changed: [r3] changed: [r2] changed: [r1] TASK [Load and commit config, require confirmation] ************************** changed: [r2] changed: [r1] changed: [r3] RUNNING HANDLER [Waiting for BGP peers to establish connections] ************* Pausing for 60 seconds (ctrl+C then 'C' = continue early, ctrl+C then 'A' = abort) ok: [r3]
PLAY [Verify BGP] ************************************************************ TASK [Execute snapcheck] ***************************************************** ok: [r2] ok: [r1] ok: [r3] TASK [Confirm commit] ******************************************************** ok: [r2] ok: [r1] ok: [r3] TASK [Verify BGP configuration] ********************************************** ok: [r1] => { "changed": false, "msg": "All assertions passed" } ok: [r2] => { "changed": false, "msg": "All assertions passed" } ok: [r3] => { "changed": false, "msg": "All assertions passed" } PLAY RECAP ******************************************************************* r1 : ok=8 changed=5 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0 r2 : ok=8 changed=5 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0 r3 : ok=9 changed=5 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
Vérification
Vérifier les voisins BGP
But
Vérifiez que la session BGP est établie pour chaque adresse voisine.
Les fichiers de test JSNAPy testent que la session BGP est établie pour chaque adresse voisine et qu’il n’y a pas d’homologues descendants. La Verify BGP configuration
sortie de la tâche vous permet de vérifier rapidement que le périphérique donné a réussi tous les tests JSNAPy. Si le JSNAPy passPercentage
est égal à 100 %, la tâche est incluse "msg": "All assertions passed"
dans la sortie de la tâche.
Action
Examinez la sortie de la Verify BGP configuration
tâche et vérifiez que chaque périphérique renvoie le All assertions passed
message.
TASK [Verify BGP configuration] ********************************************** ok: [r1] => { "changed": false, "msg": "All assertions passed" } ok: [r2] => { "changed": false, "msg": "All assertions passed" } ok: [r3] => { "changed": false, "msg": "All assertions passed" }
Sens
Le All assertions passed
message indique que les sessions BGP sont établies avec succès sur les périphériques.
Résoudre les erreurs Ansible Playbook
- Résoudre les erreurs de chargement de configuration
- Dépannage des tests JSNAPy ayant échoué
- Dépannage des échecs de validation
Résoudre les erreurs de chargement de configuration
Problème
Le playbook Ansible génère une erreur indiquant qu’il n’a pas pu charger la configuration sur l’appareil en raison d’une ConfigLoadError
erreur de syntaxe.
fatal: [r1]: FAILED! => {"changed": false, "msg": "Failure loading the configuraton: ConfigLoadError(severity: error, bad_element: protocol, message: error: syntax error\nerror: error recovery ignores input until this point)"}
Solution
Le playbook affiche la configuration de Junos OS à l’aide du modèle Jinja2 et des variables hôtes définies pour cet équipement dans le répertoire host_vars . Le playbook génère une erreur de syntaxe lorsque le modèle Jinja2 produit une configuration non valide. Pour corriger cette erreur, mettez à jour le modèle Jinja2 pour corriger l’élément identifié par la bad_element
clé dans le message d’erreur.
Dépannage des tests JSNAPy ayant échoué
Problème
La Verify BGP configuration
sortie de la tâche indique que l’assertion a échoué, car le JSNAPy passPercentage
n’était pas égal à 100 pour cent.
TASK [Verify BGP configuration] ************************************************************* fatal: [r1]: FAILED! => { "assertion": "snapcheck_result.passPercentage == 100", "changed": false, "evaluated_to": false, "msg": "JSNAPy test on r1 failed" }
L’affirmation échoue lorsque l’appareil n’a pas établi la session BGP avec son voisin ou que la session tombe en panne. Si l’assertion échoue et que la configuration de cet équipement a été mise à jour lors de la première lecture, le playbook ne confirme pas la validation de la nouvelle configuration sur l’équipement et l’équipement restaure la configuration précédemment validée.
Solution
Les tests JSNAPy peuvent échouer si l’opération snapcheck
est effectuée avant que les homologues puissent établir la session ou parce que les voisins BGP ne sont pas configurés correctement. Si la sortie du playbook indique que la configuration a été chargée et validée avec succès sur l’appareil, essayez d’augmenter l’intervalle de pause du gestionnaire à une valeur adaptée à votre environnement et réexécutez le playbook.
handlers: - name: Waiting for BGP peers to establish connections pause: seconds=75
Si les tests échouent toujours, vérifiez que le modèle Jinja2 et les variables hôtes de chaque périphérique contiennent les données correctes et que la configuration résultante pour chaque périphérique est correcte.
Dépannage des échecs de validation
Problème
La configuration n’a pas été confirmée sur un ou plusieurs appareils.
TASK [Confirm commit] *********************************************************************** skipping: [r2] skipping: [r2] skipping: [r3]
Solution
Le playbook ne confirme la configuration que si elle a changé et que les tests JSNAPy réussissent. Si la sortie de la tâche indique que la configuration n’a pas changé, le playbook n’exécute pas la tâche pour confirmer la Load and commit config, require confirmation
validation. Si la configuration a changé mais n’a pas été confirmée, les tests JSNAPy ont échoué. Les tests JSNAPy peuvent échouer si les voisins BGP ne sont pas configurés correctement ou si le playbook ne fournit pas suffisamment de temps entre les lectures pour que les périphériques établissent la session BGP. Pour plus d’informations, consultez Dépannage des tests JSNAPy ayant échoué.
Juniper.junos
version 2.0.0, le
juniper_junos_jsnapy
module remplace les fonctionnalités du
junos_jsnapy
module.