Il me reste du temps, mais depuis que j'ai construit l'environnement et acquis les informations JUNOS par la dernière fois, je vais essayer de changer les paramètres JUNOS cette fois. ..
En utilisant le module jnpr.junos.utils.config.Config de PyEz, vous pouvez lire le texte ASCII, Junos XML ou Junos OS set des fichiers de commande et modifier les paramètres, ou utiliser les objets Jinja2 Template pour les paramètres basés sur des modèles. Peut être changé.
Lors de la modification des paramètres, le processus est le suivant: lire les paramètres et les refléter par Commit, tout comme la CLI JUNOS.
Configuration Process
Spécifiez [Option] lors de la validation (https://www.juniper.net/techpubs/en_US/junos-pyez1.2/topics/task/program/junos-pyez-program-configuration-committing.html) Vous pouvez également laisser un commentaire ou synchroniser lorsque RE est redondant.
En ce qui concerne la lecture des paramètres, comme le remplacement de charge, la fusion de charge ou l'écrasement de charge de JUNOS CLI, spécifiez l'écrasement ou l'ajout et modifiez les paramètres. C'est pendant l'opération de chargement, spécifiez les paramètres de fusion et d'écrasement (https://www.juniper.net/techpubs/en_US/junos-pyez1.2/topics/reference/general/junos-pyez-configuration- Peut être sélectionné par (process-and-data-formats.html).
Cette fois, j'essaierai la méthode de lecture d'un fichier texte ASCII et l'ajout de paramètres, et la méthode d'ajout de paramètres basés sur un modèle à l'aide de Jinja2.
Extension pour le fichier de chargement (https://www.juniper.net/techpubs/en_US/junos-pyez1.2/topics/task/program/junos-pyez-program-configuration-data-loading.html) Spécifiez le texte ASCII (.conf, .text, .txt), la commande Junos set (.set), XML (.xml) comme enfants.
Au moment de la lecture, le fichier est lu en spécifiant le chemin du fichier avec le paramètre path. Par exemple
conf_file = "configs/junos-config-add-syslog-ntp.conf"
cu.load(path=conf_file, format="text", merge=True)
À titre d'exemple, le cas où l'ajout du paramètre de notification ntp de syslog est effectué par PyEz est illustré. Préparez un fichier de configuration à lire en plus du fichier python.
junos-config-add-syslog-ntp.conf
system {
syslog {
file messages {
ntp notice;
}
}
}
Voici un exemple Python.
ch-config-ntp.py
from jnpr.junos import Device
from jnpr.junos.utils.config import Config
conf_file = 'configs/junos-config-add-syslog-ntp.conf'
# open a connection with the device and start a NETCONF session
dev = Device(host='10.0.0.243', user='xxx', password='xxx', port='22', gather_facts=False)
dev.open()
dev.bind(cu=Config)
# Lock the configuration, load configuration changes, and commit as load merge
print "Locking the configuration"
dev.cu.lock()
print "Loading configuration changes"
dev.cu.load(path=conf_file, merge=True)
print "Committing the configuration"
dev.cu.commit(comment='Loaded by example.')
print "Unlocking the configuration"
dev.cu.unlock()
# End the NETCONF session and close the connection
dev.close()
Une exception est également disponible dans le module jnpr.junos.exception. Par conséquent, afin de vérifier l'erreur lorsqu'elle n'a pas pu être exécutée, si vous l'excluez dans chaque processus, ce sera comme suit.
ch-config-ntp-exception.py
from jnpr.junos import Device
from jnpr.junos.utils.config import Config
from jnpr.junos.exception import ConnectError
from jnpr.junos.exception import LockError
from jnpr.junos.exception import UnlockError
from jnpr.junos.exception import ConfigLoadError
from jnpr.junos.exception import CommitError
conf_file = 'configs/junos-config-add-syslog-ntp.conf'
def main():
# open a connection with the device and start a NETCONF session
try:
dev = Device(host='10.0.0.243', user='xxxx', password='xxxx', port='22
', gather_facts=False)
dev.open()
except ConnectError as err:
print "Cannot connect to device: {0}".format(err)
return
dev.bind(cu=Config)
# Lock the configuration, load configuration changes, and commit
print "Locking the configuration"
try:
dev.cu.lock()
except LockError as err:
print "Unable to lock configuration: {0}".format(err)
dev.close()
return
print "Loading configuration changes"
try:
dev.cu.load(path=conf_file, merge=True)
except (ConfigLoadError, Exception) as err:
print "Unable to load configuration changes: {0}".format(err)
print "Unlocking the configuration"
try:
dev.cu.unlock()
except UnlockError:
print "Unable to unlock configuration: {0}".format(err)
dev.close()
return
print "Committing the configuration"
try:
dev.cu.commit(comment='Loaded by example.')
except CommitError as err:
print "Unable to commit configuration: {0}".format(err)
print "Unlocking the configuration"
try:
dev.cu.unlock()
except UnlockError as err:
print "Unable to unlock configuration: {0}".format(err)
dev.close()
return
print "Unlocking the configuration"
try:
dev.cu.unlock()
except UnlockError as err:
print "Unable to unlock configuration: {0}".format(err)
# End the NETCONF session and close the connection
dev.close()
if __name__ == "__main__":
main()
En utilisant Jinja2, vous pouvez facilement créer des configurations similaires à l'aide de modèles. Jinja2 est un moteur de modèle Python, et Origine du nom semble être le modèle ⇒ temple ⇒ sanctuaire. Les modèles Jinja2 utilisent du texte ASCII, des éléments XML Junos et des commandes Junos OS set dans des formats pris en charge, tout comme la lecture de fichiers. Dans le Format du modèle Jinja, {% ...%} et {{...}} sont des parties variables. Et toutes les autres parties sont des phrases fixes. {% ...%} exécute la déclaration / l'affectation de variable, le traitement en boucle, etc. {{...}} est l'affichage du résultat Voir ici pour les structures de contrôle utilisées pour {%.
Pour utiliser le modèle, utilisez la méthode load () [Options](https://www.juniper.net/techpubs/en_US/junos-pyez1.2/topics/task/program/junos-pyez-program-configuration- Spécifiez le modèle dans data-loading.html). Spécifiez le fichier de modèle avec template_path et spécifiez les paramètres avec template_vars.
cu.load(template_path=conf_file, template_vars=config, merge=True)
Cette fois, utilisez un modèle qui ajoute les paramètres mpls et rsvp à chaque interface, et lisez les noms d'interface de paramètres, etc. dans un fichier yaml. Le modèle est également du texte ASCII.
Cliquez ici pour le fichier de modèle
junos-config-interfaces-mpls.conf
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 %}
}
}
Cliquez ici pour le fichier de paramètres
mpls_interface.yml
---
interfaces:
- ge-0/0/0
- ge-0/0/1
description: 'MPLS interface'
family: mpls
Fondamentalement, sur la base du même script (ch-config-ntp-exception.py) que lors de la lecture du fichier, seuls le modèle et les paramètres sont spécifiés par load (), donc seules les différentes parties sont extraites.
add-config-mpls-template.extrait py
import yaml
conf_file = 'configs/junos-config-interfaces-mpls.conf'
yml_config = yaml.load(open('configs/mpls_interface.yml'))
dev.cu.load(template_path=conf_file, template_vars=yml_config, merge=Tru
e)
Avec cela, les paramètres de mpls et rsvp pour l'interface spécifiée peuvent être ajoutés.
J'ai beaucoup écrit cette fois, mais j'ai pu confirmer que les paramètres JUNOS peuvent être modifiés à l'aide de PyEz. Dans PyEz, en plus de l'acquisition d'informations et du changement de paramètres, la comparaison de configuration, la mise à niveau du système d'exploitation, le transfert de fichiers par scp, etc. sont également possibles.
Il peut être difficile de toucher sans comprendre à la fois JUNOS et PyEz, mais même les ingénieurs qui ne sont pas familiers avec Python peuvent facilement vérifier les paramètres nécessaires et modifier les paramètres. Si vous créez un mécanisme qui vous permet d'accéder au Web en les utilisant, même les ingénieurs réseau non experts peuvent vérifier et modifier, et en établissant des liens avec d'autres systèmes, vous pouvez modifier dynamiquement les paramètres en fonction de la situation. Les méthodes d'utilisation sont susceptibles de se développer en fonction d'idées telles que la création d'infrastructures.
À l'avenir, je prévois d'essayer d'autres Automation Stacks de manière irrégulière.
Recommended Posts