SUR CETTE PAGE
Exemple : utilisation de Salt pour configurer les équipements exécutant Junos OS
Juniper Networks prend en charge l’utilisation de Salt pour gérer les équipements exécutant Junos OS. Cet exemple utilise Salt pour configurer plusieurs équipements exécutant Junos OS.
Exigences
Cet exemple utilise les composants matériels et logiciels suivants :
Trois routeurs MX Series exécutant Junos OS avec NETCONF activé
Salt master avec les exigences suivantes :
Salt version 3001 ou ultérieure
Ping et opérations sur les équipements exécutant Junos OS
Aperçu
Cet exemple définit un état Salt qui configure les sessions d’appairage BGP sur les équipements cibles exécutant Junos OS. Le tableau 1 présente les noms d’hôte d’équipement, les ID proxy et les fichiers spécifiques à l’équipement.
Hostname |
Proxy ID |
Fichier de configuration du proxy (/srv/pilier) |
Fichier de données BGP (/srv/pillar/bgp) |
|---|---|---|---|
r1 |
r1 |
r1-proxy.sls |
r1.sls |
R2 |
R2 |
r2-proxy.sls |
r2.sls |
r3 |
r3 |
r3-proxy.sls |
r3.sls |
L’exemple utilise les composants suivants :
Modèle de configuration Jinja2 : définit la configuration BGP comme un modèle Jinja à l’aide du
setformat de commande. Le modèle utilise l’extension de fichier .set pour indiquer le format.Fichiers de piliers : définissent les données de configuration spécifiques à l’équipement requises par le modèle Jinja2. Les données de chaque équipement sont stockées dans un fichier distinct dans le répertoire /srv/pillar/bgp du module Salt master.
Fichier top pillar : mappe chaque fichier pilier au minion proxy approprié.
Fichier d’état : définit l’état à appliquer aux équipements cibles. Dans ce cas, le fichier d’état utilise la
junos.install_configfonction pour appliquer la configuration BGP à un équipement.État top fichier : mappe le fichier d’état aux équipements sur lesquels l’état doit être appliqué.
Dans cet exemple, vous créez un modèle Jinja2 pour générer la configuration BGP chargée et validée sur l’équipement. Le modèle remplace les données de configuration spécifiques à l’équipement par des variables afin de pouvoir les réutiliser selon les besoins. Le fichier de modèle est placé dans le répertoire /srv/salt/configs du salt master.
Vous créez ensuite des fichiers de piliers distincts pour chaque équipement et définissez les données de configuration propres à chaque équipement dans le fichier. Chaque fichier de piliers définit une BGP_data clé qui contient tous les paramètres variables référencés dans le modèle de configuration. Le fichier top pilier mappe chaque fichier pilier à son minion proxy respectif. Le stockage des données dans des piliers garantit que chaque minion proxy ne peut accéder qu’aux données de cet équipement.
Le fichier d’état junos_bgp_config.sls définit un état qui utilise la junos.install_config fonction pour appliquer la configuration BGP dans le modèle. Lorsqu’elle est invoquée, la fonction verrouille la base de données de configuration, charge la configuration spécifique à l’équipement cible, valide la configuration, puis débloque la base de données. La fonction inclut les diffs_file paramètres permettant de stocker les différences de configuration dans un fichier sur le serveur minion proxy. Le nom de fichier utilise le id grain pour générer des noms de fichier spécifiques à l’équipement pour les fichiers en sortie.
Le fichier state top applique l’état junos_bgp_config à n’importe quel minion avec une BGP_data clé de pilier avec toute valeur. Lorsque vous exécutez un état élevé ou que vous appliquez cet état à un équipement, Salt utilise le modèle et les données de pilier pour générer la configuration spécifique à la cible, puis appelle la junos.install_config fonction pour charger et valider la configuration sur l’équipement. Si la configuration est déjà appliquée, la junos.install_config fonction ne réapplique pas la configuration.
Après avoir configuré les équipements, vous appliquez l’état junos_bgp_verify_peers . Cet état exécute le get-bgp-neighbor-information RPC sur chaque équipement jusqu’à ce qu’il renvoie une peer-state valeur pour Established chaque pair défini dans les données de base ou délais d’utilisation de cet équipement. Cet état suppose que BGP s’exécute sur l’équipement.
Configuration
Pour configurer les équipements à l’aide de Salt, exécutez les tâches incluses dans cette section.
Définir les données de base
Procédure étape par étape
Pour définir les données de base utilisées avec le modèle Jinja2 pour générer la configuration BGP :
Sur salt master, créez un fichier distinct nommé /srv/pillar/bgp/hostname.sls pour chaque équipement géré.
Définissez les données pour l’hôte r1 dans le fichier r1.sls .
BGP_data: 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.3Définissez les données pour l’hôte r2 dans le fichier r2.sls .
BGP_data: 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.3Définissez les données pour l’hôte r3 dans le fichier r3.sls .
BGP_data: 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.2Dans le fichier de base supérieur, mappez le fichier de piliers avec les données BGP sous l’ID de l’équipement approprié pour permettre à l’équipement d’accéder aux données.
saltuser@salt-master:~$ cat /srv/pillar/top.sls base: 'r1': - r1-proxy - bgp/r1 'r2': - r2-proxy - bgp/r2 'r3': - r3-proxy - bgp/r3Actualisez les données des piliers.
saltuser@salt-master:~$ sudo salt '*' saltutil.refresh_pillar r3: True r1: True r2: True
Définir le modèle Jinja2
Procédure étape par étape
Pour créer le modèle Jinja2 utilisé pour générer la configuration BGP :
Créez un fichier nommé /srv/salt/configs/junos-config-bgp-template.set sur salt master.
Ajoutez le modèle de configuration BGP au fichier et enregistrez-le.
saltuser@salt-master:~$ cat /srv/salt/configs/junos-config-bgp-template.set {% if pillar.BGP_data %} set interfaces lo0 unit 0 family inet address {{ pillar.BGP_data.loopback }}/32 set policy-options policy-statement bgp-ecmp then load-balance per-packet set policy-options policy-statement bgp-in then accept set policy-options policy-statement bgp-out then next-hop self set policy-options policy-statement bgp-out then accept set protocols bgp group underlay type external set protocols bgp group underlay import bgp-in set protocols bgp group underlay export bgp-out set protocols bgp group underlay local-as {{ pillar.BGP_data.local_asn }} set protocols bgp group underlay multipath multiple-as set routing-options router-id {{ pillar.BGP_data.loopback }} set routing-options forwarding-table export bgp-ecmp {% for neighbor in pillar.BGP_data.neighbors %} set interfaces {{ neighbor.interface }} unit 0 description {{ neighbor.name }} set interfaces {{ neighbor.interface }} unit 0 family inet address {{ neighbor.local_ip }}/30 set protocols bgp group underlay neighbor {{ neighbor.peer_ip }} peer-as {{ neighbor.asn }} set protocols lldp interface {{ neighbor.interface }} {% endfor %} {% endif %}
Définir les états
Définir le fichier d’état de configuration
Pour définir le fichier d’état qui applique la configuration :
Créez un fichier nommé /srv/salt/junos_bgp_config.sls sur salt master.
Définissez un état qui utilise la
junos.install_configfonction pour appliquer la configuration BGP dans le modèle.saltuser@salt-master:~$ cat /srv/salt/junos_bgp_config.sls Apply BGP configuration: junos.install_config: - name: salt://configs/junos-config-bgp-template.set - comment: Configuring BGP using Salt - diffs_file: /var/log/salt/output/{{ grains['id'] }}_junos_bgp_config_diff - template_vars: TrueNote:Si votre modèle comprend uniquement des variables internes salt comme les données de piliers, les données de grain et les fonctions, la
junos.install_configfonction peut devoir être définietemplate_vars: Truepour rendre le modèle.Dans le fichier supérieur, définissez les cibles auxquelles s’applique l’état junos_bgp_config . Les cibles incluent tous les équipements dont le
BGP_datapilier est défini.saltuser@salt-master:~$ cat /srv/salt/top.sls base: BGP_data:*: - match: pillar - junos_bgp_config
Définir le fichier d’état de vérification BGP
Pour définir l’état qui vérifie que les pairs BPG ont :peer-state Established
Créez un fichier nommé /srv/salt/junos_bgp_verify_peers.sls sur salt master.
Définissez un état qui utilise la
junos.rpcfonction pour exécuter leget-bgp-neighbor-informationRPC, puis vérifie la réponse RPC pour unepeer-stateréponse deEstablished.saltuser@salt-master:~$ cat /srv/salt/junos_bgp_verify_peers.sls {% for peer in pillar['BGP_data']['neighbors'] %} validate_bgp_session_state_with_{{ peer['peer_ip'] }}: loop.until: - name: junos.rpc - condition: m_ret['rpc_reply']['bgp-information']['bgp-peer']['peer-state'] == 'Established' - period: 5 - timeout: 20 - m_args: - get-bgp-neighbor-information - m_kwargs: neighbor-address: {{ peer['peer_ip'] }} {% endfor %}
Résultats
Lorsque vous exécutez un état élevé, les états du top.sls fichier sont appliqués aux équipements cibles appropriés.
saltuser@salt-master:~$ sudo salt '*' state.apply
r1:
----------
ID: Apply BGP configuration
Function: junos.install_config
Name: salt://configs/junos-config-bgp-template.set
Result: True
Comment:
Started: 07:07:14.449582
Duration: 3379.914 ms
Changes:
----------
message:
Successfully loaded and committed!
out:
True
Summary for r1
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
Total run time: 3.380 s
r2:
----------
ID: Apply BGP configuration
Function: junos.install_config
Name: salt://configs/junos-config-bgp-template.set
Result: True
Comment:
Started: 07:07:14.485640
Duration: 3132.677 ms
Changes:
----------
message:
Successfully loaded and committed!
out:
True
Summary for r2
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
Total run time: 3.133 s
r3:
----------
ID: Apply BGP configuration
Function: junos.install_config
Name: salt://configs/junos-config-bgp-template.set
Result: True
Comment:
Started: 07:07:14.388629
Duration: 3431.723 ms
Changes:
----------
message:
Successfully loaded and committed!
out:
True
Summary for r3
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
Total run time: 3.432 s
Vérification
Vérification de la configuration BGP
But
Vérifiez que la session BGP est établie pour chaque adresse de voisinage.
Action
Appliquez l’état junos_bgp_verify_peers aux équipements cibles et examinez le résultat.
saltuser@salt-master:~$ sudo salt '*' state.apply junos_bgp_verify_peers
r1:
----------
ID: validate_bgp_session_state_with_198.51.100.2
Function: loop.until
Name: junos.rpc
Result: True
Comment: Condition m_ret['rpc_reply']['bgp-information']['bgp-peer']['peer-state'] == 'Established' was met
Started: 07:17:01.825414
Duration: 125.241 ms
Changes:
----------
ID: validate_bgp_session_state_with_198.51.100.6
Function: loop.until
Name: junos.rpc
Result: True
Comment: Condition m_ret['rpc_reply']['bgp-information']['bgp-peer']['peer-state'] == 'Established' was met
Started: 07:17:01.950786
Duration: 148.944 ms
Changes:
Summary for r1
------------
Succeeded: 2
Failed: 0
------------
Total states run: 2
Total run time: 274.185 ms
r3:
----------
ID: validate_bgp_session_state_with_198.51.100.5
Function: loop.until
Name: junos.rpc
Result: True
Comment: Condition m_ret['rpc_reply']['bgp-information']['bgp-peer']['peer-state'] == 'Established' was met
Started: 07:17:02.849612
Duration: 99.527 ms
Changes:
----------
ID: validate_bgp_session_state_with_198.51.100.9
Function: loop.until
Name: junos.rpc
Result: True
Comment: Condition m_ret['rpc_reply']['bgp-information']['bgp-peer']['peer-state'] == 'Established' was met
Started: 07:17:02.949265
Duration: 165.041 ms
Changes:
Summary for r3
------------
Succeeded: 2
Failed: 0
------------
Total states run: 2
Total run time: 264.568 ms
r2:
----------
ID: validate_bgp_session_state_with_198.51.100.1
Function: loop.until
Name: junos.rpc
Result: True
Comment: Condition m_ret['rpc_reply']['bgp-information']['bgp-peer']['peer-state'] == 'Established' was met
Started: 07:17:02.811094
Duration: 143.335 ms
Changes:
----------
ID: validate_bgp_session_state_with_198.51.100.10
Function: loop.until
Name: junos.rpc
Result: True
Comment: Condition m_ret['rpc_reply']['bgp-information']['bgp-peer']['peer-state'] == 'Established' was met
Started: 07:17:02.954551
Duration: 170.651 ms
Changes:
Summary for r2
------------
Succeeded: 2
Failed: 0
------------
Total states run: 2
Total run time: 313.986 ms
Sens
Le fichier d’état nécessite que ce peer-state soit égal à Established pour chaque pair. La sortie indique que cette condition est remplie pour tous les pairs sur chaque équipement. Vous pouvez également utiliser la junos.cli fonction pour exécuter la show bgp summary commande sur les équipements et examiner la sortie pour vérifier que la session BGP est établie pour chaque adresse de voisinage.
Dépannage
Dépannage des erreurs de charge de configuration
Problème
Le maître Salt génère une ConfigLoadError erreur indiquant qu’il n’a pas chargé la configuration sur l’équipement en raison d’une erreur de syntaxe.
message:
Could not load configuration due to : "ConfigLoadError(severity: error, bad_element: interface1, message: error: syntax error)"
Solution
Salt rend la configuration de Junos OS à l’aide du modèle Jinja2 et des données de base définies pour cet équipement. Salt 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é du message d’erreur.