SUR CETTE PAGE
-
Comment spécifier le format des données de configuration à charger
-
Comment charger des données de configuration sous forme de chaînes
-
Comment charger des données de configuration à partir d’un fichier local ou distant
-
Comment charger des données de configuration à l’aide d’un modèle Jinja2
-
Comment ignorer les avertissements lors de la configuration des appareils
-
Exemple : Utilisation d’Ansible pour configurer des appareils Junos
Utilisation du juniper.device.config module Ansible pour gérer la configuration de Junos OS
Vous pouvez utiliser le juniper.device.config module Ansible pour gérer la configuration des équipements exécutant Junos OS et des équipements exécutant Junos OS Evolved.
Juniper Networks fournit des modules Ansible qui vous permettent de configurer des équipements Junos. Le Tableau 1 présente les modules disponibles. Si vous utilisez déjà un ensemble donné de modules de la juniper.device collection, utilisez le module pour cet ensemble.
|
Collecte |
Ensemble de modules |
Nom du module |
|---|---|---|
|
|
||
|
|
juniper.device.junos_config |
Les sections suivantes expliquent comment utiliser le juniper.device.config module pour modifier et valider la configuration sur les équipements Junos. Pour plus d’informations sur le juniper.device.junos_config module, consultez Utiliser le module juniper.device.junos_config Ansible pour configurer Junos appareils.
Présentation du module
Le juniper.device.config module vous permet d’effectuer les opérations suivantes sur les équipements Junos :
-
Charger les données de configuration
-
Valider la configuration
-
Annuler la configuration
-
Charger la configuration de sauvetage
Le processus de base pour apporter des modifications de configuration consiste à verrouiller la configuration, à charger les modifications de configuration, à valider la configuration pour la rendre active, puis à déverrouiller la configuration. Le compte d’utilisateur utilisé pour apporter des modifications à la configuration doit disposer des autorisations nécessaires pour modifier les parties pertinentes de la configuration sur chaque appareil. Pour modifier la configuration, la liste d’arguments du module doit inclure l’un des paramètres suivants :
-
load: charge de nouvelles données de configuration. -
rollback: revenez à la configuration de sauvetage ou à une configuration validée précédemment.
Par défaut, le juniper.device.config module apporte des modifications à la base de données de configuration candidate à l’aide du configure exclusive mode, qui verrouille et déverrouille automatiquement la configuration globale candidate. Vous pouvez également spécifier un mode de configuration différent. Par exemple, vous pouvez apporter des modifications à une copie privée de la configuration candidate ou à la base de données de configuration éphémère. Pour plus d’informations sur la spécification du mode de configuration, consultez la rubrique Spécification du mode de configuration.
Lors du chargement de nouvelles données de configuration, en plus de spécifier le mode de configuration, vous pouvez également spécifier l’opération de chargement ainsi que la source et le format des modifications.
-
Opération de chargement : l’opération de chargement détermine la façon dont les données de configuration sont chargées dans la base de données de configuration sélectionnée. Vous pouvez choisir parmi les mêmes opérations de chargement que celles disponibles dans la CLI de Junos OS. Pour plus d’informations, voir Comment spécifier l’action de chargement.
-
Format : vous pouvez configurer les équipements Junos à l’aide de l’un des formats standard pris en charge. Vous pouvez fournir des données de configuration ou des modèles Jinja2 sous forme de texte, d’éléments XML Junos, de commandes Junos OS
setou de JSON. Pour plus d’informations sur la spécification du format des données de configuration, voir Spécification du format des données de configuration à charger. -
Source de données de configuration : vous pouvez charger des données de configuration à partir d’une liste de chaînes, d’un fichier sur le nœud de contrôle Ansible local, d’un modèle Jinja2 ou d’une URL accessible depuis l’appareil client. Pour plus d’informations sur la spécification de la source des données de configuration, consultez les sections suivantes :
Le juniper.device.config module vous permet également de charger et de valider la configuration de sauvetage ou de restaurer la configuration à une configuration précédemment validée. Pour charger la configuration de secours ou une configuration précédemment validée, vous devez inclure l’argument rollback module. Pour plus d’informations, consultez les sections suivantes :
Après avoir modifié la configuration, vous devez valider la configuration pour en faire la configuration active sur l’appareil. Par défaut, le juniper.device.config module valide les modifications apportées à la configuration. Pour modifier ce comportement ou fournir des options de validation supplémentaires, consultez Comment valider la configuration.
Par défaut, lorsque le juniper.device.config module inclut les load arguments or rollback , la réponse du module renvoie automatiquement les modifications de configuration au format diff ou patch. Le module renvoie les différences dans les diff champs and diff_lines . Pour empêcher le module de calculer et de renvoyer les différences, définissez l’argument diff module sur false.
Comment spécifier le mode de configuration
Vous pouvez spécifier le mode de configuration à utiliser lors de la modification de la configuration de l’appareil. Pour spécifier le mode de configuration dans votre tâche, incluez le paramètre du config_mode module. Les modes de configuration pris en charge sont les suivants :
-
batch -
dynamic -
ephemeral -
exclusive -
private
Par défaut, le juniper.device.config module apporte des modifications à la base de données de configuration candidate à l’aide du configure exclusive mode. Le mode exclusif de configuration verrouille la configuration globale candidate (également appelée base de données de configuration partagée) aussi longtemps que le module doit apporter les modifications de configuration demandées. Le verrouillage de la base de données empêche les autres utilisateurs de modifier ou de valider les modifications de la base de données en même temps.
Les exemples suivants montrent comment configurer une copie privée de la configuration candidate et comment configurer la base de données éphémère.
Exemple : config_mode : « privé »
Le playbook suivant utilise private le mode configuration pour modifier une copie privée de la configuration candidate :
---
- name: Configure Device
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Configure op script
juniper.device.config:
config_mode: private
load: set
lines:
- "set system scripts op file bgp.slax"
register: response
- name: Print the config changes
ansible.builtin.debug:
var: response.diff_lines
user@ansible-cn:~/ansible$ ansible-playbook configure-script.yaml
PLAY [Configure Device] *******************************************************
TASK [Configure op script] ****************************************************
changed: [dc1a.example.net]
TASK [Print the config changes] ***********************************************
ok: [dc1a.example.net] => {
"response.diff_lines": [
"",
"[edit system scripts op]",
"+ file bgp.slax;"
]
}
PLAY RECAP ********************************************************************
dc1a.example.net : ok=2 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
Configurer la base de données éphémère
Vous pouvez utiliser le juniper.device.config module pour mettre à jour la base de données de configuration éphémère sur les appareils qui prennent en charge cette base de données. La base de données éphémère est une base de données de configuration alternative qui fournit une interface de programmation rapide permettant d’effectuer des mises à jour de configuration sur les équipements Junos.
Pour ouvrir et configurer l’instance par défaut de la base de données de configuration éphémère, incluez l’argument config_mode: ephemeral . Par exemple :
---
- name: Configure ephemeral database
hosts: dc1a
connection: local
gather_facts: no
tasks:
- name: Configure the default ephemeral database
juniper.device.config:
config_mode: ephemeral
load: set
lines:
- "set protocols mpls label-switched-path to-hastings to 192.0.2.1"
Pour ouvrir et configurer une instance existante définie par l’utilisateur de la base de données de configuration éphémère, incluez l’argument config_mode: ephemeral et définissez l’argument ephemeral_instance sur le nom de l’instance.
tasks:
- name: Configure a user-defined ephemeral instance
juniper.device.config:
config_mode: ephemeral
ephemeral_instance: eph1
load: set
lines:
- "set protocols mpls label-switched-path to-hastings to 192.0.2.2"
Comment spécifier l’action de chargement
Le juniper.device.config module prend en charge les modifications de configuration de chargement en utilisant la plupart des opérations de chargement prises en charge dans la CLI de Junos OS. Vous spécifiez l’opération de chargement en définissant l’argument du load module sur la valeur de l’opération de chargement correspondante. Le Tableau 2 résume les valeurs des arguments pour les différentes opérations de chargement.
|
Opération de chargement |
|
Descriptif |
|---|---|---|
|
|
|
Fusionnez la configuration chargée avec la configuration existante. |
|
|
|
Remplacez l’ensemble de la configuration par la configuration chargée. Tous les processus système analysent la configuration. |
|
|
|
Chargez les données de configuration à partir d’un fichier de correctifs. |
|
|
|
Fusionnez la configuration chargée avec la configuration existante, mais remplacez les instructions de la configuration existante par des instructions de la configuration chargée qui spécifient la |
|
|
|
Chargez les données de configuration au |
|
|
|
Chargez une configuration complète et comparez-la à la configuration existante. Remplacez uniquement les parties de la configuration candidate qui ont changé. Pendant l’opération de validation, seuls les processus système affectés analysent la nouvelle configuration. |
Comment spécifier le format des données de configuration à charger
Le juniper.device.config module vous permet de configurer des équipements Junos à l’aide de l’un des formats standard pris en charge. Vous pouvez fournir des données de configuration sous forme de chaînes ou de fichiers. Les fichiers peuvent contenir des données de configuration ou des modèles Jinja2. Lorsque vous fournissez des données de configuration dans une chaîne, un fichier ou un modèle Jinja2, les formats pris en charge incluent le texte, les éléments XML Junos, les commandes Junos OS set et JSON.
Le juniper.device.config module tente de détecter automatiquement le format des données de configuration que vous fournissez sous forme de chaînes dans l’argument lines . Toutefois, vous pouvez spécifier explicitement le format des chaînes en incluant l’argument format . Lorsque vous fournissez des données de configuration dans un fichier ou un modèle Jinja2, vous devez spécifier le format des données. Ajoutez l’extension appropriée au fichier ou incluez l’argument format .
Le Tableau 3 résume les formats pris en charge pour les données de configuration et la valeur correspondante pour l’extension de fichier et format le paramètre. Si vous incluez l’argument format , il remplace à la fois le format de détection automatique des chaînes et le format indiqué par une extension de fichier.
|
Format des données de configuration |
Extension de fichier |
|
|---|---|---|
|
Instructions de configuration de la CLI (texte) |
.conf |
|
|
JavaScript Object Notation (JSON) |
.json |
|
|
|
.set |
|
|
Éléments XML de Junos |
.xml |
|
Lorsque vous définissez l’argument du load module sur override ou update, vous ne pouvez pas utiliser le format de commande Junos OS set .
Comment charger des données de configuration sous forme de chaînes
Le juniper.device.config module vous permet de charger des données de configuration à partir d’une liste de chaînes. Pour charger les données de configuration sous forme de chaînes, incluez l’argument approprié load et l’argument lines . L’argument lines prend une liste de chaînes contenant les données de configuration à charger.
Le module tente de détecter automatiquement le lines format des données de configuration. Toutefois, vous pouvez spécifier explicitement le format en incluant l’argument format . Pour plus d’informations sur la spécification du format, voir Comment spécifier le format des données de configuration à charger. Si vous incluez l’argument format , il remplace le format détecté automatiquement.
Le playbook suivant configure et valide deux scripts op. Dans ce cas, l’argument load a de la valeur 'set' , car les données de configuration dans lines utilisent le format d’instruction Junos OS set .
---
- name: Load and commit configuration
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Load configuration data using strings and commit
juniper.device.config:
load: set
lines:
- "set system scripts op file bgp.slax"
- "set system scripts op file bgp-neighbor.slax"
register: response
- name: Print the response
ansible.builtin.debug:
var: response
Le playbook suivant configure les mêmes instructions à l’aide de lines données de configuration au format texte. Dans ce cas, l’exemple utilise load: "merge".
---
- name: Load and commit configuration
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Load configuration data using strings and commit
juniper.device.config:
load: merge
lines:
- |
system {
scripts {
op {
file bgp.slax;
file bgp-neighbor.slax;
}
}
}
register: response
- name: "Print the response"
ansible.builtin.debug:
var: response
Comment charger des données de configuration à partir d’un fichier local ou distant
Le juniper.device.config module vous permet de charger des données de configuration à partir d’un fichier. Le fichier peut résider dans l’un des emplacements suivants :
-
Nœud de contrôle Ansible
-
Appareil client
-
URL FTP ou HTTP accessible depuis l’appareil client
Lorsque vous chargez des données de configuration à partir d’un fichier, vous devez indiquer l’emplacement du fichier et le format des données de configuration dans le fichier. Les formats de données de configuration pris en charge incluent le texte, les éléments XML Junos, les commandes Junos OS set et JSON. Pour plus d’informations sur le chargement de fichiers contenant des modèles Jinja2, consultez Comment charger des données de configuration à l’aide d’un modèle Jinja2.
Pour spécifier le format, incluez le paramètre du module ou ajoutez l’extension format appropriée au fichier de données de configuration. Si vous spécifiez le format paramètre, il remplace le format indiqué par l’extension de fichier. Pour plus d’informations sur la spécification du format, voir Comment spécifier le format des données de configuration à charger. Lorsque les données de configuration utilisent le format XML Junos, vous devez les inclure dans la balise de niveau <configuration> supérieur.
Vous n’avez pas besoin de joindre les données de configuration au format texte, commandes Junos OS set ou JSON dans <configuration-text>, <configuration-set>ou <configuration-json> les balises requises lors de la configuration de l’équipement directement dans une session NETCONF.
Le Tableau 4 présente les paramètres de module que vous pouvez inclure pour spécifier l’emplacement du fichier.
|
Paramètre du module |
Descriptif |
|---|---|
|
|
|
|
|
|
Pour charger des données de configuration à partir d’un fichier local sur le nœud de contrôle Ansible, définissez l’argument src sur le chemin absolu ou relatif du fichier contenant les données de configuration. Par exemple :
---
- name: Load and commit configuration
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Load configuration from a local file and commit
juniper.device.config:
load: merge
src: "build_conf/{{ inventory_hostname }}/junos.conf"
register: response
- name: Print the response
ansible.builtin.debug:
var: response
Pour charger des données de configuration à partir d’un fichier sur le périphérique Junos ou d’une URL FTP ou HTTP, utilisez le url paramètre. Spécifiez le chemin ou l’URL du fichier à charger. Par exemple :
---
- name: Load and commit configuration
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Load configuration from a remote file and commit
juniper.device.config:
load: merge
url: "/var/tmp/junos.conf"
register: response
- name: Print the response
ansible.builtin.debug:
var: response
La valeur de url peut être un chemin d’accès absolu ou relatif à un fichier local, un emplacement FTP ou une URL HTTP.
-
Le chemin d’accès à un fichier local sur l’équipement cible se présente sous l’une des formes suivantes :
-
/path/filename : fichier sur un système de fichiers monté, soit sur le disque flash local, soit sur le disque dur.
-
R :filename ou un fichier :path/filename—sur le lecteur local. Le chemin par défaut est / (le répertoire de niveau racine). Le support amovible peut être au format MS-DOS ou UNIX (UFS).
-
-
Le chemin d’accès à un fichier sur un serveur FTP a la forme suivante :
ftp://username:password@hostname/path/filename -
Le chemin d’accès à un fichier sur un serveur HTTP a la forme suivante :
http://username:password@hostname/path/filename
Dans chaque cas, la valeur par défaut de la path variable est le répertoire personnel de l’utilisateur. Pour spécifier un chemin absolu, l’application commence le chemin avec les caractères %2F ; par exemple, ftp://username :password@hostname/ %2Fpath/filename.
Comment charger des données de configuration à l’aide d’un modèle Jinja2
Le juniper.device.config module vous permet de restituer les données de configuration à partir d’un fichier modèle Jinja2 sur le nœud de contrôle Ansible, puis de charger et de valider la configuration sur un équipement Junos. Jinja est un moteur de modèles pour Python qui vous permet de générer des documents à partir de modèles prédéfinis. Les modèles, qui sont des fichiers texte dans la langue souhaitée, offrent une flexibilité grâce à l’utilisation d’expressions et de variables. Vous pouvez créer des données de configuration Junos OS à l’aide de modèles Jinja2 dans l’un des formats de configuration pris en charge, qui inclut du texte ASCII, des éléments XML Junos, des commandes Junos OS set et JSON. Le module Ansible utilise le modèle Jinja2 et un dictionnaire de variables fourni pour afficher les données de configuration.
Pour charger et valider les données de configuration à l’aide d’un modèle Jinja2, incluez les template paramètres et dans vars la liste des arguments du module.
-
template—Chemin du fichier de modèle Jinja2 -
vars—Dictionnaire des clés et des valeurs requises pour afficher le modèle Jinja2
Vous devez également inclure le format paramètre lorsque l’extension de fichier du modèle n’indique pas le format des données. Pour plus d’informations sur la spécification du format, voir Comment spécifier le format des données de configuration à charger.
Par exemple, le fichier interfaces-mpls.j2 contient le modèle Jinja2 suivant :
interfaces {
{% for item in interfaces %}
{{ item }} {
description "{{ description }}";
unit 0 {
family {{ family }};
}
} {% endfor %}
}
protocols {
mpls {
{% for item in interfaces %}
interface {{ item }};
{% endfor %}
}
rsvp {
{% for item in interfaces %}
interface {{ item }};
{% endfor %}
}
}
Pour utiliser le juniper.device.config module pour charger le modèle Jinja2, définissez l’argument template sur le chemin du fichier modèle. Définissez les variables requises par le modèle dans le vars dictionnaire.
Le playbook suivant utilise le modèle Jinja2 et le vars dictionnaire pour afficher les données de configuration. Le format paramètre indique le format des données de configuration dans le fichier modèle. Le playbook charge et valide la configuration sur l’hôte cible.
---
- name: Load and commit configuration
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Load a configuration from a Jinja2 template and commit
juniper.device.config:
load: merge
template: "build_conf/templates/interfaces-mpls.j2"
format: text
vars:
interfaces: ["ge-1/0/1", "ge-1/0/2", "ge-1/0/3"]
description: "MPLS interface"
family: "mpls"
register: response
- name: Print the response
ansible.builtin.debug:
var: response
Le module génère les données de configuration suivantes. Le module charge les données dans la configuration candidate sur l’appareil et la valide.
interfaces {
ge-1/0/1 {
description "MPLS interface";
unit 0 {
family mpls;
}
}
ge-1/0/2 {
description "MPLS interface";
unit 0 {
family mpls;
}
}
ge-1/0/3 {
description "MPLS interface";
unit 0 {
family mpls;
}
}
}
protocols {
mpls {
interface ge-1/0/1;
interface ge-1/0/2;
interface ge-1/0/3;
}
rsvp {
interface ge-1/0/1;
interface ge-1/0/2;
interface ge-1/0/3;
}
}
Comment charger la configuration de sauvetage
Une configuration de secours vous permet de définir une configuration de travail connue ou une configuration avec un état connu que vous pouvez restaurer à tout moment. Vous utilisez la configuration de secours lorsque vous devez revenir à une configuration connue ou en dernier recours si la configuration de l’appareil et les fichiers de configuration de sauvegarde sont endommagés de manière irréparable. Lorsque vous créez une configuration de secours, l’appareil enregistre la configuration validée la plus récente en tant que configuration de secours.
Le juniper.device.config module vous permet de revenir à une configuration de sauvetage existante sur les équipements Junos. Pour charger et valider la configuration de sauvetage sur un appareil, incluez l’argument du rollback: rescue module. Par exemple :
---
- name: Revert to rescue configuration
hosts: dc1a
connection: local
gather_facts: no
tasks:
- name: Load and commit rescue configuration
juniper.device.config:
rollback: rescue
register: response
- name: Print response
ansible.builtin.debug:
var: response
Comment restaurer la configuration
Les équipements Junos stockent une copie de la configuration validée la plus récente et jusqu’à 49 configurations précédentes, selon la plate-forme. Vous pouvez revenir à n’importe quelle configuration stockée. Cette fonctionnalité est utile lorsque des modifications de configuration entraînent des résultats indésirables et que vous souhaitez revenir à une configuration de travail connue. La restauration de la configuration est similaire au processus de modification de la configuration sur l’appareil. Toutefois, au lieu de charger les données de configuration, vous effectuez une restauration, qui remplace l’ensemble de la configuration candidate par une configuration précédemment validée.
Le juniper.device.config module vous permet de revenir à une configuration précédemment validée sur les équipements Junos. Pour restaurer la configuration et la valider, incluez l’argument du module et spécifiez l’ID rollback de la configuration de restauration. Les valeurs d’ID valides sont comprises entre 0 (zéro, pour la dernière configuration validée) soit une de moins que le nombre de configurations précédentes stockées (49 au maximum).
Le playbook suivant demande d’abord l’ID de restauration de la configuration à restaurer. La première tâche restaure la configuration à la version demandée et la valide. La deuxième tâche imprime les différences de configuration en sortie standard.
---
- name: Roll back the configuration
hosts: dc1a
connection: local
gather_facts: no
vars_prompt:
- name: "ROLLBACK"
prompt: "Rollback ID of the configuration to restore"
private: no
tasks:
- name: Roll back the configuration and commit
juniper.device.config:
rollback: "{{ ROLLBACK }}"
register: response
- name: Print the configuration changes
ansible.builtin.debug:
var: response.diff_lines
user@ansible-cn:~/ansible$ ansible-playbook configuration-rollback.yaml
Rollback ID of the configuration to restore: 1
PLAY [Roll back the configuration] ********************************************
TASK [Roll back the configuration and commit] *********************************
changed: [dc1a.example.net]
TASK [Print the configuration changes] ***************************************
ok: [dc1a.example.net] => {
"response.diff_lines": [
"",
"[edit interfaces]",
"- ge-0/0/0 {",
"- unit 0 {",
"- family mpls;",
"- }",
"- }"
]
}
PLAY RECAP ********************************************************************
dc1a.example.net : ok=2 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
Comment valider la configuration
Par défaut, lorsque vous utilisez le juniper.device.config module pour modifier la configuration, le module effectue automatiquement une vérification de validation et valide les modifications. Pour empêcher le module d’effectuer une vérification de validation ou de valider les modifications, définissez l’argument check ou commit sur false, respectivement.
Vous pouvez également personnaliser l’opération de validation avec un grand nombre des options disponibles dans la CLI de Junos OS. Le Tableau 5 présente les arguments de module que vous pouvez utiliser pour spécifier différentes options de validation.
|
Module Argument |
Descriptif |
Valeur par défaut pour |
|---|---|---|
|
|
Effectuez une vérification de validation ou confirmez une opération de validation confirmée précédente. |
|
|
|
Attendez le nombre de secondes spécifié entre la vérification de la validation et l’opération de validation. |
– |
|
|
Consignez un commentaire pour cette opération de validation dans le fichier journal système et dans l’historique des validations de l’appareil. |
– |
|
|
Validez les modifications de configuration ou confirmez une opération de validation confirmée précédente. |
|
|
|
Validez la configuration même si la configuration candidate n’a pas été modifiée. |
|
|
|
Synchronisez et validez la configuration sur tous les moteurs de routage, même si l’autre moteur de routage a des sessions de configuration ouvertes ou des modifications de configuration non validées. |
|
|
|
Synchroniser et valider la configuration sur tous les moteurs de routage. |
|
|
|
Exiger qu’une opération de validation soit confirmée dans un délai spécifié après la validation initiale. Si vous ne confirmez pas la validation dans le délai spécifié, rétablissez la configuration précédemment validée. Confirmez la validation à l’aide de l’option |
– |
|
|
Attendez la fin de l’opération en utilisant la valeur spécifiée comme délai d’expiration. |
30 secondes |
Commit Commentaire
Lorsque vous validez la configuration, vous pouvez inclure un bref commentaire pour décrire l’objectif des modifications validées. Pour consigner un commentaire décrivant les modifications, incluez l’argument comment: "comment string" avec la chaîne du message.
Vérification de la validation
Par défaut, le module exécute à la fois une vérification de validation juniper.device.config et une opération de validation. L’argument check_commit_wait définit le nombre de secondes à attendre entre la vérification de validation et les opérations de validation. Incluez cet argument lorsque vous devez laisser suffisamment de temps à l’appareil pour terminer l’opération de vérification de validation et libérer le verrou de configuration avant de lancer l’opération de validation. Si le périphérique lance l’opération de validation avant que l’opération de vérification de validation ne libère son verrou sur la configuration, l’opération de validation échoue et le module émet un CommitError.
Valider les modifications vides
Par défaut, si la configuration candidate et la configuration validée ne présentent aucune différence, le module ne valide pas les modifications. Pour forcer une opération de validation même en l’absence de différences, incluez l’argument commit_empty_changes: true .
Validation, synchronisation
Si l’appareil dispose de deux moteurs de routage, vous pouvez synchroniser et valider la configuration sur les deux moteurs de routage en incluant l’argument commit_sync: true . Pour forcer la réussite de l’opération commit synchronize même si l’autre moteur de routage a des sessions de configuration ouvertes ou des modifications de configuration non validées, utilisez l’argument commit_force_sync: true . Lorsque vous incluez l’option commit_force_sync: true , l’appareil met fin à toutes les sessions de configuration sur l’autre moteur de routage avant de synchroniser et de valider la configuration.
Valider Confirmer
Pour exiger qu’une opération de validation soit confirmée dans un délai spécifié après la validation initiale, incluez l’argument confirmed: minutes . Si vous ne confirmez pas la validation dans le délai imparti, la configuration revient automatiquement à la configuration précédemment validée. La plage autorisée est de 1 à 65 535 minutes. L’opération de validation confirmée est utile pour vérifier qu’une modification de configuration fonctionne correctement et n’empêche pas l’accès de gestion à l’appareil. Si la modification empêche l’accès ou provoque d’autres erreurs, la restauration automatique de la configuration précédente permet d’accéder à l’appareil une fois la date limite de restauration écoulée. Pour confirmer l’opération de validation, appelez le module avec l’argument juniper.device.config check: true or commit: true .
Dans le playbook suivant, la première tâche modifie la configuration, attend 10 secondes entre la vérification de validation et l’opération de validation, et nécessite que l’opération de validation soit confirmée dans les 5 minutes. Il enregistre également un commentaire pour le commit. La deuxième tâche émet une commit check opération pour confirmer la validation. Dans un scénario réel, vous pouvez effectuer des tâches de validation après la validation initiale et n’exécuter la confirmation de validation que si les tâches répondent à certains critères de validation.
---
- name: Load configuration and confirm within 5 minutes
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Load configuration. Wait 10 seconds between check and commit. Confirm within 5 min.
juniper.device.config:
load: merge
format: text
src: "build_conf/{{ inventory_hostname }}/junos.conf"
check_commit_wait: 10
confirmed: 5
comment: "updated using Ansible"
register: response
- name: Print the response
ansible.builtin.debug:
var: response
- name: Confirm the commit with a commit check
juniper.device.config:
check: true
diff: false
commit: false
register: response
- name: Print the response
ansible.builtin.debug:
var: response
Comment ignorer les avertissements lors de la configuration des appareils
Le juniper.device.config module vous permet de modifier et de valider la configuration sur les équipements Junos. Dans certains cas, la réponse RPC peut contenir <rpc-error> des éléments avec un niveau de gravité d’avertissement ou supérieur qui entraînent le déclenchement d’une RpcError exception par le module. Une RpcError exception peut entraîner l’échec de l’opération de chargement ou de validation.
Dans certains cas, il peut être nécessaire ou souhaitable de supprimer les RpcError exceptions qui sont levées en réponse aux avertissements pour les opérations de chargement et de validation. Vous pouvez demander juniper.device.config au module de supprimer RpcError les exceptions déclenchées pour les avertissements en incluant le paramètre dans la ignore_warning liste d’arguments du module. L’argument ignore_warning prend un booléen, une chaîne ou une liste de chaînes.
Pour indiquer au module d’ignorer tous les avertissements pour les opérations de chargement et de validation effectuées par le module, incluez l’argument ignore_warning: true . L’exemple suivant ignore tous les avertissements pour les opérations de chargement et de validation.
---
- name: Configure Device
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Configure op script
juniper.device.config:
config_mode: private
load: set
lines:
- "set system scripts op file bgp.slax"
ignore_warning: true
register: response
- name: Print the response
ansible.builtin.debug:
var: response
Si vous incluez ignore_warning: true et que tous les <rpc-error> éléments ont un niveau de gravité d’avertissement, l’application ignore tous les avertissements et ne lève pas d’exception RpcError . Cependant, tout <rpc-error> élément avec des niveaux de gravité plus élevés soulèvera toujours des exceptions.
Pour indiquer au module d’ignorer des avertissements spécifiques, définissez l’argument ignore_warning sur une chaîne ou une liste de chaînes contenant les avertissements à ignorer. L’exemple suivant ignore deux avertissements spécifiques :
---
- name: Configure Device
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Configure Junos device and ignore warnings
juniper.device.config:
config_mode: private
load: merge
src: "build_conf/{{ inventory_hostname }}/junos.conf"
ignore_warning:
- "Advertisement-interval is less than four times"
- "Chassis configuration for network services has been changed."
register: response
- name: Print the response
ansible.builtin.debug:
var: response
Le module supprime les RpcError exceptions si tous les <rpc-error> éléments ont un niveau de gravité d’avertissement et que chaque avertissement de la réponse correspond à une ou plusieurs des chaînes spécifiées.
Exemple : Utilisation d’Ansible pour configurer des appareils Junos
Le juniper.device.config module vous permet de gérer la configuration sur les équipements Junos. Cet exemple utilise le config module pour apporter des modifications de configuration sur un équipement Junos via NETCONF sur SSH.
- Exigences
- Vue d’ensemble
- La configuration
- Exécuter le guide stratégique
- Vérification
- Résoudre les erreurs du playbook
Exigences
Cet exemple utilise les composants matériels et logiciels suivants :
-
Serveur de gestion de la configuration exécutant Ansible 2.17 ou version ultérieure avec la
juniper.devicecollection installée -
Équipement Junos sur lequel NETCONF est activé et un compte utilisateur configuré avec les autorisations appropriées
-
Paire de clés publique/privée SSH configurée pour l’utilisateur approprié sur le contrôleur Ansible et l’équipement Junos
-
Fichier d’inventaire Ansible existant avec les hôtes requis définis
Vue d’ensemble
Cet exemple présente un playbook Ansible qui utilise le juniper.device.config module pour activer un nouveau script op dans la configuration des équipements Junos cibles. Le fichier de données de configuration, junos-config.conf, contient les données de configuration pertinentes sous forme de texte.
Le playbook comprend la Check NETCONF connectivity tâche, qui utilise le ansible.builtin.wait_for module Ansible pour essayer d’établir une session NETCONF avec l’appareil cible à l’aide du port NETCONF par défaut (830). Si le nœud de contrôle ne parvient pas à établir une session NETCONF avec un périphérique cible pendant l’exécution du playbook, il ignore les tâches restantes en cours de lecture pour ce périphérique.
Le playbook utilise le juniper.device.file_copy module pour copier le nouveau script op du nœud de contrôle Ansible vers l’équipement Junos. Les arguments du module spécifient le répertoire et le nom de fichier du script sur le périphérique local et le répertoire de destination sur le périphérique distant.
La tâche de configuration du périphérique exécute le juniper.device.config module à condition que la vérification NETCONF ait réussi. L’argument load: "merge" charge les nouvelles données de configuration dans la configuration candidate à l’aide d’une load merge opération. Par défaut, le module valide les données de configuration d’un config appareil pour load et rollback les opérations. Les arguments du module incluent l’argument comment , qui enregistre un commentaire de commit dans le fichier journal système de l’appareil et l’historique des validations.
La configuration
Créer le fichier de données de configuration
Procédure étape par étape
Pour créer le fichier de données de configuration utilisé par le module :
-
Créez un fichier avec l’extension appropriée en fonction du format des données de configuration, qui dans cet exemple est du texte.
-
Incluez les modifications de configuration souhaitées dans le fichier.
user@ansible-cn:~/ansible$ cat build_conf/dc1a.example.net/junos-config.conf system { scripts { op { file bgp.slax; } } }
Créer le playbook Ansible
Procédure étape par étape
Pour créer un playbook qui utilise le config module pour apporter des modifications de configuration sur un équipement Junos :
-
Incluez le modèle de playbook, qui exécute les modules localement.
--- - name: Load and commit configuration data on a Junos device hosts: dc1 connection: local gather_facts: no
-
(Facultatif) Créez une tâche pour vérifier la connectivité NETCONF.
tasks: - name: Check NETCONF connectivity ansible.builtin.wait_for: host: "{{ inventory_hostname }}" port: 830 timeout: 5 -
Créez une tâche pour copier le nouveau script op sur l’appareil.
- name: Copy the op script to the device juniper.device.file_copy: action: put file: bgp.slax local_dir: scripts remote_dir: /var/db/scripts/op -
Créez la tâche pour charger la configuration sur l’appareil et la valider.
- name: Merge configuration data from a file and commit juniper.device.config: load: "merge" src: "build_conf/{{ inventory_hostname }}/junos-config.conf" comment: "Configuring op script with Ansible" register: response -
(Facultatif) Créez une tâche pour imprimer la réponse, qui inclut les modifications de configuration au format diff .
- name: Print the response ansible.builtin.debug: var: response
Résultats
Sur le nœud de contrôle Ansible, passez en revue le playbook terminé. Si le playbook n’affiche pas le code prévu, répétez les instructions de cet exemple pour corriger le playbook.
---
- name: Load and commit configuration data on a Junos device
hosts: dc1
connection: local
gather_facts: no
tasks:
- name: Check NETCONF connectivity
ansible.builtin.wait_for:
host: "{{ inventory_hostname }}"
port: 830
timeout: 5
- name: Copy the op script to the device
juniper.device.file_copy:
action: put
file: bgp.slax
local_dir: scripts
remote_dir: /var/db/scripts/op
- name: Merge configuration data from a file and commit
juniper.device.config:
load: "merge"
src: "build_conf/{{ inventory_hostname }}/junos-config.conf"
comment: "Configuring op script with Ansible"
register: response
- name: Print the response
ansible.builtin.debug:
var: response
Exécuter le guide stratégique
Pour exécuter le playbook :
-
Exécutez la
ansible-playbookcommande sur le nœud de contrôle et fournissez le chemin du playbook et toutes les options souhaitées.user@ansible-cn:~/ansible$ ansible-playbook ansible-pb-junos-config.yaml PLAY [Load and commit configuration data on a Junos device] *************** TASK [Check NETCONF connectivity] ***************************************** ok: [dc1a.example.net] TASK [Copy the op script to the device] *********************************** changed: [dc1a.example.net] TASK [Merge configuration data from a file and commit] ******************** changed: [dc1a.example.net] TASK [Print the response] ************************************************* ok: [dc1a.example.net] => { "response": { "changed": true, "diff": { "prepared": "\n[edit system scripts op]\n+ file bgp.slax;\n" }, "diff_lines": [ "", "[edit system scripts op]", "+ file bgp.slax;" ], "failed": false, "file": "build_conf/dc1a.example.net/junos-config.conf", "msg": "Configuration has been: opened, loaded, checked, diffed, committed, closed." } } PLAY RECAP **************************************************************** dc1a.example.net : ok=4 changed=2 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
Vérification
Vérifiez la configuration
Objet
Vérifiez que la configuration a été correctement mise à jour sur l’équipement Junos.
Mesures à prendre
Examinez la sortie du playbook Ansible pour voir si la tâche de configuration a réussi ou échoué. Vous pouvez également vous connecter à l’équipement Junos et afficher la configuration, l’historique des validations et les fichiers journaux pour vérifier la configuration et valider, par exemple :
user@dc1a> show configuration system scripts
op {
file bgp.slax;
}
user@dc1a> show system commit
0 2020-12-17 15:33:50 PST by user via netconf
Configuring op script with Ansible
user@dc1a> show log messages Dec 17 15:33:39 dc1a mgd[33444]: UI_COMMIT: User 'user' requested 'commit' operation (comment: Configuring op script with Ansible) Dec 17 15:33:57 dc1a mgd[33444]: UI_COMMIT_COMPLETED: commit complete
Résoudre les erreurs du playbook
- Résoudre les erreurs de délai d’attente
- Résoudre les erreurs de verrouillage de configuration
- Résoudre les erreurs de modification de configuration
Résoudre les erreurs de délai d’attente
Problème
Le playbook génère un TimeoutExpiredError message d’erreur et ne parvient pas à mettre à jour la configuration de l’appareil.
ncclient.operations.errors.TimeoutExpiredError: ncclient timed out while waiting for an rpc reply
Le délai d’expiration par défaut d’un RPC NETCONF est de 30 secondes. Les modifications de configuration importantes peuvent dépasser cette valeur, ce qui entraîne l’expiration de l’opération avant que la configuration puisse être téléchargée et validée.
La solution
Pour prendre en charge les modifications de configuration qui peuvent nécessiter un temps de validation plus long que l’intervalle de délai d’expiration RPC par défaut, définissez l’argument du timeout module sur une valeur appropriée et réexécutez le playbook.
Résoudre les erreurs de verrouillage de configuration
Problème
Le playbook génère un LockError message d’erreur indiquant que la configuration ne peut pas être verrouillée. Par exemple :
FAILED! => {"changed": false, "msg": "Unable to open the configuration in exclusive mode: LockError(severity: error, bad_element: None, message: configuration database modified)"}
ou
FAILED! => {"changed": false, "msg": "Unable to open the configuration in exclusive mode: LockError(severity: error, bad_element: lock-configuration, message: permission denied)"}
Une erreur de verrouillage de configuration peut se produire pour les raisons suivantes :
-
Un autre utilisateur dispose d’un verrou exclusif sur la configuration.
-
Un autre utilisateur a apporté des modifications à la base de données de configuration, mais n’a pas encore validé les modifications.
-
L’utilisateur exécutant le module Ansible n’a pas les autorisations nécessaires pour configurer l’appareil.
La solution
La LockError chaîne du message indique généralement la cause racine du problème. Si un autre utilisateur a un verrou exclusif sur la configuration ou a modifié la configuration, attendez que le verrou soit libéré ou que les modifications soient validées, puis exécutez à nouveau le playbook. Si la cause du problème est que l’utilisateur n’a pas les autorisations nécessaires pour configurer l’équipement, exécutez le playbook avec un utilisateur disposant des autorisations nécessaires ou, le cas échéant, configurez l’équipement Junos pour donner à l’utilisateur actuel les autorisations nécessaires pour apporter les modifications.
Résoudre les erreurs de modification de configuration
Problème
Le playbook génère un ConfigLoadError message d’erreur indiquant que la configuration ne peut pas être modifiée, car l’autorisation est refusée.
FAILED! => {"changed": false, "msg": "Failure loading the configuraton: ConfigLoadError(severity: error, bad_element: scripts, message: error: permission denied)"}
Ce message d’erreur est généré lorsque l’utilisateur exécutant le module Ansible est autorisé à modifier la configuration mais n’a pas l’autorisation de modifier la section demandée de la configuration.
La solution
Exécutez le playbook avec un utilisateur disposant des autorisations nécessaires ou, le cas échéant, configurez l’équipement Junos pour donner à l’utilisateur actuel les autorisations nécessaires pour effectuer les modifications.