Conéctese a dispositivos de Junos con Junos PyEZ
Conéctese a un dispositivo Junos o a un servidor de consola conectado utilizando diferentes métodos y protocolos de conexión en una aplicación Junos PyEZ.
Junos PyEZ es un micromarco para Python que le permite administrar dispositivos de Junos. Junos PyEZ modela cada dispositivo como una instancia de la clase jnpr.junos.device.Device. La Device clase le permite conectarse a un dispositivo Junos mediante una conexión de consola serie, Telnet o una sesión NETCONF a través de SSH. Junos PyEZ también admite la conexión al dispositivo a través de una conexión Telnet o SSH a un servidor de consola. Un servidor de consola, también conocido como servidor de terminales, es un dispositivo especializado que proporciona una conexión de red al puerto de la consola de administración fuera de banda de un dispositivo. Además, puede usar Junos PyEZ para conectarse a un dispositivo Junos a través de un dispositivo intermedio como un bastión o un host de salto.
En este tema, se proporciona una descripción general de los métodos de conexión admitidos por Junos PyEZ y se explica cómo usar los distintos métodos para conectarse a un dispositivo Junos. Los ejemplos de Junos PyEZ usan varios métodos de autenticación, pero para obtener información detallada sobre cómo autenticar a un usuario, consulte Autenticar usuarios de Junos PyEZ.
Descripción general de los métodos de conexión
Junos PyEZ le permite conectarse a un dispositivo Junos mediante una conexión de consola serie, Telnet o una sesión de NETCONF a través de SSH. Debe utilizar una conexión de consola serie cuando esté físicamente conectado al puerto CONSOLE de un dispositivo. Puede usar telnet o SSH para conectarse a la interfaz de administración del dispositivo o a un servidor de consola que esté conectado al puerto CONSOLE del dispositivo. Junos PyEZ también admite conexiones SSH a un dispositivo a través de un bastión o un host de salto. Además, Junos PyEZ admite conexiones SSH salientes, en las que el dispositivo Junos inicia la conexión con la aplicación de administración del cliente.
Los dispositivos nuevos o ceroizados que tienen configuraciones predeterminadas de fábrica requieren acceso a través de una conexión de consola. Puede usar Junos PyEZ para configurar inicialmente un dispositivo que aún no está configurado para el acceso remoto. Puede usar una conexión de consola serie cuando esté conectado directamente al dispositivo, o puede usar Telnet o SSH a través de un servidor de consola que esté conectado al dispositivo.
De forma predeterminada, Junos PyEZ usa SSH para conectarse a un dispositivo. Para especificar un tipo de conexión diferente, debe incluir el mode parámetro en la lista de Device argumentos. Para telnet a un dispositivo, incluya el mode='telnet' argumento. Para conectarse a un dispositivo mediante una conexión de consola serie, incluya el mode='serial' argumento. La tabla 1 resume los métodos de conexión de Junos PyEZ, sus valores predeterminados para ciertos parámetros y cualquier configuración de Junos OS requerida.
|
Modo de conexión |
Valor del |
Puerto predeterminado |
Configuración necesaria de Junos OS |
|---|---|---|---|
|
NETCONF a través de SSH (predeterminado) |
– |
830 |
[edit system services]
netconf {
ssh;
}
|
|
Conexión de consola serie |
serie |
/dev/ttyUSB0 |
– |
|
Telnet a dispositivo de Junos |
telnet |
23 |
[edit system services] telnet; |
|
Telnet a través de un servidor de consola |
telnet |
23 |
– |
|
SSH a través de un servidor de consola |
– |
22 |
– |
|
SSH a través de un host de salto |
– |
22 |
[edit system services]
netconf {
ssh;
}
|
|
SSH saliente |
– |
– |
[edit system services]
outbound-ssh {
...
}
|
Antes de poder acceder a la interfaz de administración de un dispositivo mediante Telnet o NETCONF a través de SSH, primero debe habilitar el servicio adecuado en el nivel jerárquico [edit system services] . Para obtener más información, consulte Configurar nodos administrados de Junos PyEZ. Dado que Telnet utiliza contraseñas de texto sin cifrar (lo que crea una posible vulnerabilidad de seguridad), le recomendamos que utilice SSH.
Obtenga credenciales de una manera segura y adecuada para su entorno. Como práctica recomendada, solicite credenciales cada vez que ejecute el script en lugar de almacenarlas en un formato sin cifrar.
Junos PyEZ admite el uso de administradores de contexto (with ... as sintaxis) para todos los métodos de conexión. Cuando usa un administrador de contexto, Junos PyEZ llama automáticamente a los open() métodos y close() para conectarse y desconectarse del dispositivo. Si no utiliza un administrador de contexto, debe llamar explícitamente a los métodos y close() en la open() aplicación. Recomendamos que utilice un administrador de contexto para las conexiones de consola. El administrador de contexto controla automáticamente el cierre de la conexión y, si no se cierra la conexión, pueden producirse resultados impredecibles.
Descripción de las propiedades de conexión de Junos PyEZ
Cuando se conecta a un dispositivo Junos, Junos PyEZ almacena información sobre la conexión actual como propiedades de la Device instancia. En la tabla 2 se describen las propiedades de conexión disponibles.
|
Propiedad |
Tipo |
Descripción |
|---|---|---|
|
|
Booleano |
Estado actual de la conexión. Regresa cuando está |
|
|
Cadena |
Nombre de host del dispositivo al que está conectada la aplicación. |
|
|
Booleano |
Devuelve |
|
|
Entero o cadena |
Puerto utilizado para la conexión. |
|
|
Cadena |
Nombre del motor de enrutamiento al que está conectada la aplicación. |
|
|
Entero |
Valor de tiempo de espera de RPC en segundos. |
|
|
Entero |
Número de segundos desde que se inició el motor de enrutamiento actual. |
|
|
Cadena |
Un usuario accede al dispositivo de Junos. |
Por ejemplo, después de conectarse a un dispositivo, puede consultar la connected propiedad para devolver el estado actual de la conexión. A SessionListener supervisa la sesión y responde a los errores de transporte generando una TransportError excepción y estableciendo la Device.connected propiedad en False.
El siguiente código de ejemplo imprime el valor de la connected propiedad después de conectarse a un dispositivo Junos y nuevamente después de cerrar la sesión.
from jnpr.junos import Device dev = Device(host='router.example.net') dev.open() print (dev.connected) dev.close() print (dev.connected)
Cuando ejecuta el programa, la connected propiedad regresa True mientras la aplicación está conectada al dispositivo y regresa False después de que se cierra la conexión.
user@host:~$ python connect.py True False
Conectarse a un dispositivo mediante SSH
La clase PyEZ Device de Junos admite el uso de SSH para conectarse a un dispositivo Junos. Junos PyEZ admite las siguientes conexiones:
-
Conectarse directamente a la interfaz de administración del dispositivo
-
Conéctese a través de un servidor de consola que esté conectado directamente al puerto CONSOLE del dispositivo
-
Conéctese a través de un bastión o un host de salto
El servidor SSH debe ser capaz de autenticar al usuario mediante mecanismos de autenticación SSH estándar, como se describe en Autenticación de usuarios de Junos PyEZ. Para establecer una sesión NETCONF a través de SSH, también debe cumplir los requisitos descritos en Configuración de nodos administrados de Junos PyEZ.
Cuando usa SSH para conectarse a un dispositivo, Junos PyEZ primero prueba la autenticación basada en clave pública SSH y, luego, prueba la autenticación basada en contraseña. Cuando se utiliza la autenticación basada en contraseña, la contraseña proporcionada se utiliza como contraseña del dispositivo. Cuando se utilizan claves SSH, la contraseña proporcionada es la frase de contraseña para desbloquear la clave privada. No es necesario proporcionar una contraseña si carga la clave en un agente de claves SSH o si la clave privada SSH tiene una frase de contraseña vacía. Sin embargo, no recomendamos usar claves privadas SSH con frases de contraseña vacías.
Junos PyEZ consulta automáticamente el archivo de configuración SSH predeterminado en ~/.ssh/config, si existe. Junos PyEZ utiliza cualquier configuración relevante en el archivo de configuración SSH que no sea anulada por los Device argumentos, como el usuario o el archivo de identidad. Para utilizar un archivo de configuración SSH diferente, establezca ssh_config en la ruta de acceso del archivo cuando defina Device. Por ejemplo:
ssh_config_file = "~/.ssh/config_dc"
dev = Device(host='router1.example.com', ssh_config=ssh_config_file)
A partir de la versión 2.7.2 de Junos PyEZ, un cliente de Junos PyEZ puede habilitar la verificación de clave de host SSH cuando se conecta a un dispositivo Junos. El cliente verifica la identidad del dispositivo remoto validando que la huella digital de la clave de host del dispositivo coincida con una clave de confianza en el archivo de known_hosts del cliente. Si la clave de host presentada no coincide con una clave de confianza, se rechaza la conexión. Utilice la verificación de clave de host, cuando corresponda, para evitar ataques de intermediarios.
De forma predeterminada, Junos PyEZ deshabilita la verificación de la clave de host SSH y permite que la conexión continúe sin necesidad de que la clave pública del servidor se registre en el archivo known_hosts del cliente. Para habilitar la comprobación de clave de host, incluya hostkey_verify=True cuando defina Device. Si habilita la verificación de clave de host, debe cargar la clave de host del dispositivo en el archivo known_hosts antes de conectarse al dispositivo. De lo contrario, se producirá un error en la conexión.
dev = Device(host='router1.example.com', hostkey_verify=True)
En las siguientes secciones, se describen los diferentes métodos para conectarse a un dispositivo mediante SSH.
- Conectarse directamente a un dispositivo
- Conectarse a un dispositivo a través de un servidor de consola
- Conectarse a un dispositivo a través de un bastión o un host de salto
Conectarse directamente a un dispositivo
Junos PyEZ le permite conectarse directamente a un dispositivo que ejecute Junos OS o a un dispositivo que ejecute Junos OS evolucionado. Cuando cree una instancia del Device objeto, proporcione el nombre de host o la dirección IP del dispositivo de destino y las credenciales de usuario necesarias.
Si el cliente PyEZ de Junos debe establecer la conexión utilizando una dirección IP de origen local específica en el servidor de administración de configuración (CMS), puede incluir el bind_addr argumento para especificar la dirección. Puede ser necesario establecer la dirección de origen local para una conexión, por ejemplo, si el CMS utiliza varias interfaces de red y direcciones IP y solo se puede acceder a un subconjunto de direcciones desde el dispositivo de red.
Para crear una aplicación PyEZ de Junos que establezca una sesión NETCONF a través de SSH con un dispositivo Junos e imprima los datos del dispositivo:
-
Importe la
Deviceclase y cualquier otro módulo u objeto necesario para sus tareas.import sys from getpass import getpass from jnpr.junos import Device from jnpr.junos.exception import ConnectError
-
Cree la instancia del dispositivo y proporcione el nombre de host, los parámetros necesarios para la autenticación y los parámetros opcionales.
hostname = input("Device hostname: ") junos_username = input("Junos OS username: ") junos_password = getpass("Junos OS or SSH key password: ") dev = Device(host=hostname, user=junos_username, passwd=junos_password)
-
(Opcional) Si el dispositivo Junos configura NETCONF en un puerto distinto al predeterminado (830), incluya el
portargumento y especifique el puerto.dev = Device(host=hostname, user=junos_username, passwd=junos_password, port=50001)
-
(Opcional) Si necesita especificar la dirección de origen local que se debe usar para establecer la conexión, incluya el
bind_addrargumento y especifique la dirección IP que se va a usar.dev = Device(host=hostname, user=junos_username, passwd=junos_password, bind_addr=10.10.10.1)
-
Para conectarse al dispositivo, llame al
open()método, por ejemplo:try: dev.open() except ConnectError as err: print ("Cannot connect to device: {0}".format(err)) sys.exit(1) except Exception as err: print (err) sys.exit(1)
-
Imprima los datos del dispositivo.
print (dev.facts)
-
Después de realizar las tareas necesarias, cierre la conexión con el dispositivo.
dev.close()
El programa de ejemplo en su totalidad (se omiten los parámetros opcionales) se presenta aquí:
import sys from getpass import getpass from jnpr.junos import Device from jnpr.junos.exception import ConnectError hostname = input("Device hostname: ") junos_username = input("Junos OS username: ") junos_password = getpass("Junos OS or SSH key password: ") dev = Device(host=hostname, user=junos_username, passwd=junos_password) try: dev.open() except ConnectError as err: print ("Cannot connect to device: {0}".format(err)) sys.exit(1) except Exception as err: print (err) sys.exit(1) print (dev.facts) dev.close()
Alternativamente, puede usar un administrador de contexto cuando se conecte al dispositivo. El administrador de contexto llama automáticamente a los open() métodos y close() . Por ejemplo:
import sys from getpass import getpass from jnpr.junos import Device from jnpr.junos.exception import ConnectError hostname = input("Device hostname: ") junos_username = input("Junos OS username: ") junos_password = getpass("Junos OS or SSH key password: ") try: with Device(host=hostname, user=junos_username, passwd=junos_password) as dev: print (dev.facts) except ConnectError as err: print ("Cannot connect to device: {0}".format(err)) sys.exit(1) except Exception as err: print (err) sys.exit(1)
Conectarse a un dispositivo a través de un servidor de consola
Un cliente Junos PyEZ puede conectarse a un dispositivo Junos a través de una conexión SSH a un servidor de consola. En este caso, debe especificar las credenciales de inicio de sesión tanto para el servidor de la consola como para el dispositivo de Junos. En la lista de Device argumentos, incluya las credenciales del servidor de la consola en los cs_user argumentos y cs_passwd . Cuando se usen claves SSH, establezca el cs_passwd argumento en la variable que contiene la frase de contraseña para la clave privada. Además, establezca el port argumento en el puerto TCP que se asigna al dispositivo TTY, si corresponde.
El servidor de la consola se conecta al dispositivo Junos a través de una conexión en serie, que puede ser lenta. Las conexiones de Junos PyEZ a través de un servidor de consola tienen un valor de tiempo de espera de conexión predeterminado de 0,5 segundos. Para permitir suficiente tiempo para que la aplicación cliente establezca la conexión, es posible que tenga que aumentar el intervalo de tiempo de espera de conexión incluyendo el timeout=seconds argumento.
El siguiente ejemplo de Junos PyEZ se autentica con el servidor de consola y, luego, con el dispositivo de Junos. El tiempo de espera de conexión se establece en seis segundos para que el cliente tenga tiempo suficiente para establecer la conexión.
import sys from getpass import getpass from jnpr.junos import Device from jnpr.junos.exception import ConnectError hostname = input("Console server hostname: ") cs_username = input("Console server username: ") cs_password = getpass("Console server or SSH key password: ") junos_username = input("Junos OS username: ") junos_password = getpass("Junos OS password: ") port = input("Port number: ") try: with Device(host=hostname, user=junos_username, passwd=junos_password, cs_user=cs_username, cs_passwd=cs_password, port=port, timeout=6) as dev: print (dev.facts) except ConnectError as err: print ("Cannot connect to device: {0}".format(err)) sys.exit(1) except Exception as err: print (err) sys.exit(1)
Conectarse a un dispositivo a través de un bastión o un host de salto
Junos PyEZ le permite acceder a un dispositivo de destino a través de un host intermediario (host bastión o host de salto). Es posible que tenga que usar un host de bastión o de salto cuando no pueda iniciar sesión directamente en el dispositivo de destino. Por ejemplo, el dispositivo puede estar detrás de un firewall.
Para usar SSH para conectarse a través de un dispositivo intermedio, puede usar una de las siguientes opciones:
-
En el archivo de configuración SSH, agregue una entrada para el dispositivo de destino y especifique la opción ProxyCommand.
-
En su
Devicelista de argumentos, incluya elproxy_commandparámetro.
El Device proxy_command argumento tiene prioridad sobre la opción ProxyCommand en el archivo de configuración SSH. Si configura ambas opciones, Junos PyEZ solo usará el proxy_command argumento. En las secciones siguientes se proporcionan detalles sobre cómo usar cada opción.
- Ejemplo: Uso de ProxyCommand en el archivo de configuración SSH
- Ejemplo: Usar el
Deviceproxy_commandargumento
Ejemplo: Uso de ProxyCommand en el archivo de configuración SSH
Para configurar un bastión o un host de salto en el archivo de configuración SSH, agregue una entrada para el host de Junos e incluya la opción ProxyCommand. La cadena ProxyCommand define la conexión con el dispositivo intermedio. Por ejemplo, la siguiente configuración se conecta a través de un host intermedio que admite netcat.
user1@server:~$ cat ~/.ssh/config Host 198.51.100.1 User user1 ProxyCommand ssh -l user1 192.168.1.1 nc %h 22 2>/dev/null
De manera similar, la siguiente configuración se conecta a través del dispositivo intermedio al host y puerto de destino en modo silencioso, lo que suprime las advertencias.
user1@server:~$ cat ~/.ssh/config Host 198.51.100.1 User user1 ProxyCommand ssh -W %h:%p -q jumphost.example.com
Ejemplo: Usar el argumento del dispositivo proxy_command
Cuando defina Device, puede incluir el proxy_command argumento para conectarse a través de un dispositivo intermedio. La proxy_command cadena define la conexión con el bastión o el host de salto. Si es necesario, Junos PyEZ solicita la contraseña del host de salto o su frase de contraseña de clave privada SSH.
El siguiente ejemplo se conecta a un dispositivo Junos a través de un host de salto. En este ejemplo, Junos PyEZ se autentica con cada dispositivo mediante claves SSH protegidas por frase de contraseña cargadas en el agente de claves SSH.
from jnpr.junos import Device junos_host = "198.51.100.1" with Device(host=junos_host, proxy_command="ssh -W %h:%p -q user1@192.168.1.1") as dev: print(dev.facts)
Si carga las claves SSH para el host de salto y el dispositivo de red en su agente de clave SSH, no necesita proporcionar las rutas de clave privada ni las frases de contraseña en la aplicación Junos PyEZ. Sin embargo, si no carga las claves necesarias en el agente de claves SSH, debe proporcionar la ruta y la frase de contraseña de cualquier clave protegida por frase de contraseña en ubicaciones no predeterminadas. Los ssh_private_key_file argumentos y password especifican la ruta y la frase de contraseña de la clave privada utilizada para autenticarse con el dispositivo Junos. En el proxy_command argumento, use la -i path opción para especificar la ruta de la clave privada utilizada para autenticarse con el host de salto. Cuando ejecuta la secuencia de comandos, Junos PyEZ solicita la frase de contraseña de clave privada correspondiente. Por ejemplo:
from jnpr.junos import Device from getpass import getpass junos_host = "198.51.100.1" passwd = getpass("SSH key passphrase for network device: ") dev = Device( host=junos_host, passwd=passwd, ssh_private_key_file="/home/user1/.ssh/id_rsa_junos", proxy_command="ssh -i /home/user1/.ssh/id_rsa_jump -W %h:%p -q 192.168.1.1" ) dev.open() print(dev.facts) dev.close()
Cuando ejecute el script, el script solicitará las frases de contraseña de las claves privadas.
user1@server:~$ python junos-pyez-proxy-command.py
Network device SSH key password:
Enter passphrase for key '/home/user1/.ssh/keys/id_rsa_jump':
{'2RE': True, 'HOME': '/var/home/user1', 'RE0': {'mastership_state': 'Master', 'status': 'OK', 'model': 'RE VIRTUAL', 'last_reboot_reason': 'Unknown', 'up_time': '29 days, 23 hours, 11 minutes, 42 seconds'}, 'RE1': {'mastership_state': 'Backup', 'status': 'OK', 'model': 'RE VIRTUAL', 'last_reboot_reason': 'Unknown', 'up_time': '29 days, 23 hours, 9 minutes'},
[...output omitted...]
Conectarse a un dispositivo mediante SSH saliente
Puede configurar un dispositivo Junos para iniciar una conexión TCP/IP con una aplicación de administración de cliente que se bloquearía si el cliente intentara iniciar la conexión (por ejemplo, si el dispositivo está detrás de un firewall). La outbound-ssh configuración indica al dispositivo que cree una conexión TCP/IP con la aplicación de administración del cliente y que reenvíe la identidad del dispositivo. Una vez establecida la conexión, la aplicación de administración actúa como cliente e inicia la secuencia SSH, y el dispositivo Junos actúa como servidor y autentica al cliente.
Una vez que configure y confirme SSH de salida en el dispositivo de Junos, el dispositivo comenzará a iniciar una conexión SSH de salida en función de la configuración confirmada. El dispositivo intenta repetidamente crear esta conexión hasta que se realiza correctamente. Si se interrumpe la conexión entre el dispositivo y la aplicación de administración del cliente, el dispositivo vuelve a intentar crear una nueva conexión SSH saliente hasta que se realice correctamente. Esta conexión se mantiene hasta que se elimina o desactiva la configuración de SSH de salida.
Para configurar el dispositivo Junos para conexiones SSH salientes, incluya la outbound-ssh instrucción en el nivel de [edit system services] jerarquía. En el siguiente ejemplo, el dispositivo Junos intenta iniciar una conexión con el host en 198.51.100.101 en el puerto 2200:
user@router1> show configuration system services outbound-ssh
client nms1 {
device-id router1;
secret "$9abc123"; ## SECRET-DATA
services netconf;
198.51.100.101 port 2200;
}
Para establecer una conexión con el dispositivo Junos mediante SSH saliente, la aplicación PyEZ de Junos establece el sock_fd argumento en el Device constructor igual al descriptor de archivo de un socket existente y omite el host argumento o lo establece en None.
El siguiente ejemplo de Junos PyEZ escucha en el puerto TCP configurado las sesiones SSH entrantes desde dispositivos Junos. La aplicación acepta una conexión entrante y recupera el descriptor de archivo del socket para esa conexión, que se usa para el valor del sock_fd argumento. La aplicación cliente establece la conexión SSH con el dispositivo, recopila e imprime los datos del dispositivo, se desconecta del dispositivo y espera más conexiones.
import socket from jnpr.junos import Device from jnpr.junos.exception import ConnectError from getpass import getpass from pprint import pprint """ Listen on TCP port 2200 for incoming SSH session from a Junos device. After the device connects, collect and print the devices facts. Then disconnect from that device and wait for more connections. """ def launch_junos_proxy(client, addr): val = { 'MSG-ID': None, 'MSG-VER': None, 'DEVICE-ID': None, 'HOST-KEY': None, 'HMAC': None } msg = '' count = 0 while count < 5: c = client.recv(1) c = c.decode("utf-8") msg += str(c) if c == '\n': count += 1 for line in msg.splitlines(): (key, value) = line.split(': ') val[key] = value print("{}: {}".format(key, val[key])) return client.fileno() def main(): PORT = 2200 junos_username = input('Junos OS username: ') junos_password = getpass('Junos OS password: ') s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind(('', PORT)) s.listen(5) print('\nListening on port %d for incoming sessions ...' % (PORT)) sock_fd = 0 while True: client, addr = s.accept() print('\nGot a connection from %s:%d' % (addr[0], addr[1])) sock_fd = launch_junos_proxy(client, addr) print('Logging in ...') try: with Device(host=None, sock_fd=sock_fd, user=junos_username, passwd=junos_password) as dev: pprint(dev.facts) except ConnectError as err: print ("Cannot connect to device: {0}".format(err)) if __name__ == "__main__": main()
user@nms1:~$ python junos-pyez-outbound-ssh.py
Junos OS username: user
Junos OS password:
Listening on port 2200 for incoming sessions ...
Got a connection from 10.10.0.5:57881
MSG-ID : DEVICE-CONN-INFO
MSG-VER : V1
DEVICE-ID : router1
HOST-KEY : ssh-rsa AAAAB...0aF4Mk=
HMAC : 4e61201ec27a8312104f63bfaf77a4478a892c82
Logging in ...
{'2RE': True,
'HOME': '/var/home/user',
'RE0': {'last_reboot_reason': 'Router rebooted after a normal shutdown.',
'mastership_state': 'master',
'model': 'RE-MX-104',
'status': 'OK',
'up_time': '2 days, 6 hours, 22 minutes, 22 seconds'},
'RE1': {'last_reboot_reason': 'Router rebooted after a normal shutdown.',
'mastership_state': 'backup',
'model': 'RE-MX-104',
'status': 'OK',
'up_time': '2 days, 6 hours, 22 minutes, 12 seconds'},
'RE_hw_mi': False,
'current_re': ['re0', 'master', 'node', 'fwdd', 'member', 'pfem'],
'domain': 'example.com',
'fqdn': 'router1.example.com',
'hostname': 'router1',
...
Para obtener información detallada sobre cómo configurar SSH de salida en dispositivos Junos, consulte Configurar servicio de SSH de salida.
Conectarse a un dispositivo mediante Telnet
La clase PyEZ Device de Junos admite la conexión a un dispositivo Junos mediante Telnet, que proporciona acceso sin cifrar al dispositivo de red. Puede hacer telnet a la interfaz de administración del dispositivo o a un servidor de consola que esté conectado directamente al puerto CONSOLE del dispositivo. Debe configurar la telnet instrucción en el nivel de [edit system services] jerarquía en todos los dispositivos que requieran acceso a la interfaz de administración. El acceso al dispositivo a través de un servidor de consola le permite configurar inicialmente un dispositivo nuevo o ceroizado que aún no está configurado para el acceso remoto.
Para usar Junos PyEZ to telnet a un dispositivo Junos, debe incluirlo mode='telnet' en la lista de Device argumentos y, opcionalmente, incluir el parámetro para especificar un port puerto. Cuando se especifica mode='telnet' pero se omite el port parámetro, el valor port predeterminado es 23. Cuando la aplicación se conecte a través de un servidor de consola, especifique el puerto a través del cual el servidor de consola se conecta al dispositivo de Junos.
Para usar Junos PyEZ para telnet a un dispositivo Junos e imprimir los datos del dispositivo:
El programa de ejemplo en su totalidad se presenta aquí:
import sys from getpass import getpass from jnpr.junos import Device hostname = input("Device hostname: ") junos_username = input("Junos OS username: ") junos_password = getpass("Junos OS password: ") dev = Device(host=hostname, user=junos_username, passwd=junos_password, mode='telnet', port=23) try: dev.open() except Exception as err: print (err) sys.exit(1) print (dev.facts) dev.close()
Como alternativa, puede usar un administrador de contexto al conectarse al dispositivo, que controla la apertura y el cierre de la conexión. Por ejemplo:
import sys from getpass import getpass from jnpr.junos import Device hostname = input("Device hostname: ") junos_username = input("Junos OS username: ") junos_password = getpass("Junos OS password: ") try: with Device(host=hostname, user=junos_username, passwd=junos_password, mode='telnet', port=23) as dev: print (dev.facts) except Exception as err: print (err) sys.exit(1)
En algunos casos, cuando se conecta a un servidor de consola que emite un mensaje de banner, es posible que deba pulsar Intro después del mensaje para acceder al indicador de inicio de sesión. En este caso, es posible que la aplicación no reciba el mensaje de inicio de sesión, lo que puede hacer que la conexión se bloquee.
A partir de la versión 2.6.2 de Junos PyEZ, Junos PyEZ gestiona automáticamente el banner del servidor de la consola. En las versiones de Junos PyEZ 2.1.0 a 2.6.1, una aplicación de Junos PyEZ puede incluirse console_has_banner=True en la lista de Device argumentos para manejar un servidor de consola que emite un mensaje de banner.
dev = Device(host=hostname, user=username, passwd=password, mode='telnet', port=port, console_has_banner=True)
Cuando se incluye el console_has_banner=True argumento, si la aplicación no recibe un mensaje de inicio de sesión en la conexión inicial, la aplicación espera 5 segundos. A continuación, la aplicación emite un carácter de nueva línea (\n) para que el servidor de la consola emita el mensaje de inicio de sesión. Si omite el argumento y la conexión se bloquea, la aplicación emite la <close-session/> RPC para finalizar la conexión.
Conectarse a un dispositivo mediante una conexión de consola serie
La clase PyEZ Device de Junos le permite conectarse a un dispositivo Junos mediante una conexión de consola serie. Una conexión de consola serie es útil cuando inicialmente debe configurar un dispositivo nuevo o ceroizado que aún no está configurado para el acceso remoto. Para utilizar este método de conexión, debe estar conectado físicamente al dispositivo a través del puerto CONSOLE . Para obtener instrucciones detalladas sobre cómo conectarse al puerto CONSOLE de su dispositivo, consulte la documentación del hardware de su dispositivo específico.
Junos PyEZ admite el uso de administradores de contexto para conexiones de consola en serie. Recomendamos que utilice un administrador de contexto para las conexiones de la consola, ya que el administrador de contexto controla automáticamente la apertura y el cierre de la conexión. Si no se cierra la conexión, pueden producirse resultados impredecibles.
Para usar Junos PyEZ para conectarse a un dispositivo Junos a través de una conexión de consola serie, debe incluirlo mode='serial' en la lista de Device argumentos. Opcionalmente, puede incluir el port parámetro para especificar un puerto. Cuando se especifica mode='serial' pero se omite el port parámetro, el valor port predeterminado de ./dev/ttyUSB0
Para usar Junos PyEZ para conectarse a un dispositivo Junos mediante una conexión de consola serie y cargar y confirmar una configuración:
El programa de ejemplo en su totalidad se presenta aquí:
import sys from getpass import getpass from jnpr.junos import Device from jnpr.junos.utils.config import Config junos_username = input("Junos OS username: ") junos_password = getpass("Junos OS password: ") try: with Device(mode='serial', port='port', user=junos_username, passwd=junos_password) as dev: print (dev.facts) cu = Config(dev) cu.lock() cu.load(path='/tmp/config_mx.conf') cu.commit() cu.unlock() except Exception as err: print (err) sys.exit(1)