SUR CETTE PAGE
Exemple : Utiliser Salt pour configurer des périphériques 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 périphériques 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é
Maître de sel avec les exigences suivantes :
Salt version 3001 ou ultérieure
Peut envoyer une requête ping et effectuer des opérations sur les périphériques 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 des périphériques, les ID de proxy et les fichiers spécifiques aux périphériques.
Nom d’hôte |
Proxy ID |
Fichier de configuration du proxy (/srv/pilier) |
Fichier de données BGP (/srv/pilier/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 en tant que modèle Jinja à l’aide
setdu format de commande. Le modèle utilise l’extension de fichier .set pour indiquer le format.Pillar files : définissez les données de configuration spécifiques à l’équipement requises par le modèle Jinja2. Les données de chaque périphérique sont stockées dans un fichier séparé dans le répertoire /srv/pillar/bgp du maître Salt.
Fichier supérieur du pilier : mappe chaque fichier de 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 périphérique.Fichier supérieur d’état : mappe le fichier d’état aux périphériques sur lesquels l’état doit être appliqué.
Dans cet exemple, vous allez créer un modèle Jinja2 pour générer la configuration BGP qui est chargée et validée sur l’appareil. Le modèle substitue des variables aux données de configuration spécifiques à l’appareil afin qu’elles puissent être réutilisées selon les besoins. Le fichier de modèle est placé dans le répertoire /srv/salt/configs du maître Salt.
Vous créez ensuite des fichiers piliers distincts pour chaque appareil et définissez les données de configuration spécifiques à chaque appareil dans le fichier. Chaque fichier de pilier 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 supérieur du pilier mappe chaque fichier de pilier à son serviteur proxy respectif. Le stockage des données dans des piliers garantit que chaque serviteur proxy ne peut accéder qu’aux données de cet appareil.
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 appelée, la fonction verrouille la base de données de configuration, charge la configuration spécifique à l’équipement cible, valide la configuration, puis déverrouille la base de données. La fonction inclut le diffs_file paramètre 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 fichiers spécifiques à l’unité pour les fichiers de sortie.
Le fichier d’état supérieur applique l’état junos_bgp_config à n’importe quel minion avec une clé de pilier avec n’importe BGP_data quelle valeur. Lorsque vous exécutez un highstate ou que vous appliquez cet état à un périphérique, Salt utilise les données du modèle et du 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 le périphérique. Si la configuration est déjà appliquée, la junos.install_config fonction ne réapplique pas la configuration.
Une fois que vous avez configuré les périphériques, vous appliquez l’état junos_bgp_verify_peers . Cet état exécute le get-bgp-neighbor-information RPC sur chaque périphérique jusqu’à ce qu’il renvoie une peer-state valeur de Established pour chaque homologue défini dans les données de pilier de cet appareil. Cet état suppose que BGP est en cours d’exécution sur l’équipement.
Configuration
Pour configurer les appareils à l’aide de Salt, effectuez les tâches incluses dans cette section.
Définir les données du pilier
Procédure étape par étape
Pour définir les données de pilier utilisées avec le modèle Jinja2 pour générer la configuration BGP :
Sur le maître Salt, créez un fichier distinct nommé /srv/pillar/bgp/hostname.sls pour chaque périphérique géré.
Définissez les données de 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 de 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 de 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 du pilier supérieur, mappez le fichier du pilier avec les données BGP sous l’ID d’appareil approprié pour permettre à l’appareil 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 du pilier.
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 le maître Salt.
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éfinition des états
Définition du fichier d’état de configuration
Pour définir le fichier d’état qui applique la configuration, procédez comme suit :
Créez un fichier nommé /srv/salt/junos_bgp_config.sls sur le maître Salt.
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 n’inclut que des variables internes à Salt telles que les données de piliers, les données de grain et les fonctions, la
junos.install_configfonction devra peut-être être définietemplate_vars: Truepour afficher le modèle.Dans le fichier supérieur, définissez les cibles auxquelles s’applique l’état junos_bgp_config . Les cibles comprennent tous les appareils pour lesquels un
BGP_dataélément de pilier est défini.saltuser@salt-master:~$ cat /srv/salt/top.sls base: BGP_data:*: - match: pillar - junos_bgp_config
Définition du fichier d’état de vérification BGP
Pour définir l’état qui vérifie que les homologues BPG ont un peer-state de Established:
Créez un fichier nommé /srv/salt/junos_bgp_verify_peers.sls sur le maître Salt.
Définissez un état qui utilise la
junos.rpcfonction pour exécuter leget-bgp-neighbor-informationRPC, puis vérifiez la réponse du RPC pour unpeer-statedeEstablished.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 highstate, 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 voisine.
Action
Appliquez l’état junos_bgp_verify_peers aux équipements cibles et examinez la sortie.
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
Signification
Le fichier d’état exige que le peer-state soit égal à Established pour chaque homologue. La sortie indique que cette condition est remplie pour tous les homologues de chaque appareil. Vous pouvez également utiliser la junos.cli fonction pour exécuter la show bgp summary commande sur les périphériques et examiner la sortie pour vérifier que la session BGP est établie pour chaque adresse voisine.
Dépannage
Dépannage des erreurs de chargement de configuration
Problème
Le maître Salt génère une ConfigLoadError erreur indiquant qu’il n’a pas pu charger la configuration sur l’appareil 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 restitue la configuration de Junos OS à l’aide du modèle Jinja2 et des données de pilier 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 afin de corriger l’élément identifié par la bad_element clé dans le message d’erreur.