Conéctese a dispositivos Junos con Junos PyEZ
RESUMEN Conéctese a un dispositivo Junos o a un servidor de consola conectado mediante diferentes métodos y protocolos de conexión en una aplicación Junos PyEZ.
Junos PyEZ es un microframework para Python que le permite administrar dispositivos Junos. Junos PyEZ modela cada dispositivo como una instancia de la clase jnpr.junos.device.Device . La Device clase permite conectarse a un dispositivo Junos mediante una conexión de consola serie, telnet o estableciendo una sesión NETCONF a través de SSH. Además, 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 Terminal Server, 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.
En este tema se proporciona información general sobre los métodos de conexión admitidos por Junos PyEZ y se explica cómo utilizar los distintos métodos para conectarse a un dispositivo Junos. En los ejemplos de Junos PyEZ se utilizan varios métodos de autenticación, pero para obtener información detallada acerca de la autenticación de 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 NETCONF a través de SSH. Debe utilizar una conexión de consola serie cuando esté conectado físicamente al puerto CONSOLE de un dispositivo. Puede utilizar 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. 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 de clientes.
Los dispositivos nuevos o a cero que tienen configuraciones predeterminadas de fábrica requieren acceso a través de una conexión de consola. Por lo tanto, puede utilizar Junos PyEZ para configurar inicialmente un dispositivo que aún no está configurado para el acceso remoto mediante una conexión de consola serie cuando esté conectado directamente al dispositivo o mediante telnet o SSH a través de un servidor de consola que esté conectado al dispositivo.
De forma predeterminada, Junos PyEZ utiliza 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. En la tabla 1 se resumen los métodos de conexión de Junos PyEZ, sus valores predeterminados para determinados parámetros, cualquier configuración de Junos OS necesaria y la versión de Junos PyEZ en la que se introdujo por primera vez la compatibilidad con ese método de conexión.
Modo de conexión |
Valor del |
Puerto predeterminado |
Configuración requerida de Junos OS |
Primera versión compatible de Junos PyEZ |
|---|---|---|---|---|
NETCONF sobre SSH (predeterminado) |
– |
830 |
[edit system services]
netconf {
ssh;
}
|
1.0.0 |
Conexión de consola serie |
Serial |
/dev/ttyUSB0 |
– |
2.0.0 (*nix) 2.4.0 (Windows) |
Telnet a dispositivo Junos |
Telnet |
23 |
[edit system services] telnet; |
2.0.0 |
Telnet a través de un servidor de consola |
Telnet |
23 |
– |
2.0.0 |
SSH a través de un servidor de consola |
– |
22 |
– |
2.2.0 |
SSH saliente |
– |
– |
[edit system services]
outbound-ssh {
...
}
|
2.2.0 |
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 de [edit system services] jerarquía. 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), se recomienda usar SSH.
Es responsabilidad del usuario obtener las credenciales de autenticación de nombre de usuario y contraseña de una manera segura y adecuada para su entorno. Se recomienda solicitar estas credenciales de autenticación durante cada invocación de la secuencia de comandos, en lugar de almacenarlas en un formato sin cifrar.
Junos PyEZ admite el uso de gestores de contexto (with ... as sintaxis) para todos los métodos de conexión. Cuando se utiliza 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 open() métodos y close() de la aplicación. Se recomienda usar un administrador de contexto para las conexiones de consola, ya que el administrador de contexto controla automáticamente el cierre de la conexión y si no se cierra la conexión, se pueden producir 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 |
Descripción |
|---|---|
|
Booleano que especifica el estado actual de la conexión. Vuelve |
|
Cadena que especifica el nombre de host del dispositivo al que está conectada la aplicación. |
|
Booleano devuelto |
|
Entero o cadena que especifica el puerto utilizado para la conexión. |
|
Cadena que especifica el nombre del motor de enrutamiento al que está conectada la aplicación. |
|
Entero que especifica el valor de tiempo de espera de RPC en segundos. |
|
Entero que representa el número de segundos desde que se inició el motor de enrutamiento actual. Esta propiedad está disponible a partir de Junos PyEZ versión 2.1.5. |
|
Cadena que especifica el usuario que accede al dispositivo 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 de nuevo 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)
Al ejecutar el programa, la connected propiedad devuelve True mientras la aplicación está conectada al dispositivo y regresa False después de cerrar 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. Puede establecer una sesión NETCONF a través de SSH con la interfaz de administración del dispositivo o puede establecer una conexión SSH con un servidor de consola que esté conectado directamente al puerto CONSOLE del dispositivo. El servidor SSH debe ser capaz de autenticar al usuario mediante mecanismos de autenticación SSH estándar, como se describe en Autenticar usuarios de Junos PyEZ. Para establecer una sesión de NETCONF a través de SSH, también debe cumplir los requisitos descritos en Configurar nodos gestionados de Junos PyEZ.
Junos PyEZ consulta automáticamente el archivo de configuración SSH predeterminado en ~/.ssh/config, si existe. Cuando se utiliza SSH para conectarse a un dispositivo Junos o a un servidor de consola conectado al dispositivo, Junos PyEZ primero intenta la autenticación basada en clave pública SSH y, a continuación, 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 las claves SSH están en uso, la contraseña proporcionada se utiliza como frase de contraseña para desbloquear la clave privada. Si la clave privada SSH tiene una frase de contraseña vacía, no se requiere una contraseña. Sin embargo, no se recomiendan las claves privadas SSH con frases de contraseña vacías.
Para establecer una sesión NETCONF a través de SSH con un dispositivo Junos e imprimir los datos del dispositivo en una aplicación Junos PyEZ con Python 3:
El programa de muestra en su totalidad 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()
Como alternativa, puede utilizar un administrador de contexto al conectarse al dispositivo, que 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)
Junos PyEZ también permite que un cliente se conecte 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 del servidor de consola incluyendo los cs_user argumentos y cs_passwd en la lista de Device argumentos. Cuando las claves SSH estén en uso, establezca el cs_passwd argumento en la variable que contiene la frase de contraseña para la clave privada.
El servidor de la consola se conecta al dispositivo Junos a través de una conexión 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. Como resultado, es posible que deba aumentar el intervalo de tiempo de espera de conexión incluyendo el Device timeout=seconds argumento para permitir tiempo suficiente para que la aplicación cliente establezca la conexión.
El siguiente ejemplo de Python 3 se autentica con el servidor de consola y, a continuación, con el dispositivo 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: ")
try:
with Device(host=hostname, user=junos_username, passwd=junos_password,
cs_user=cs_username, cs_passwd=cs_password, 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)
Junos PyEZ consulta automáticamente el archivo de configuración SSH predeterminado en ~/.ssh/config, si existe. Sin embargo, puede especificar un archivo de configuración SSH diferente al crear la instancia de dispositivo incluyendo el ssh_config parámetro en la lista de Device argumentos. Por ejemplo:
ssh_config_file = "~/.ssh/config_dc"
dev = Device(host='198.51.100.1', ssh_config=ssh_config_file)
Junos PyEZ también proporciona compatibilidad con ProxyCommand, que le permite acceder a un dispositivo de destino a través de un host intermediario compatible con netcat. Esto es útil cuando solo puede iniciar sesión en el dispositivo de destino a través del host intermedio.
Para configurar ProxyCommand, agregue la información adecuada al archivo de configuración SSH. Por ejemplo:
[user1@server ~]$ cat ~/.ssh/config Host 198.51.100.1 User user1 ProxyCommand ssh -l user1 198.51.100.2 nc %h 22 2>/dev/null
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 clientes 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 de clientes 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 configurado y confirmado SSH saliente en el dispositivo Junos, el dispositivo comienza a iniciar una conexión SSH saliente basada en la configuración confirmada. El dispositivo intenta crear esta conexión repetidamente hasta que se realiza correctamente. Si se interrumpe la conexión entre el dispositivo y la aplicación de administración de clientes, 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 SSH saliente.
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 ejemplo siguiente, 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 "$9$h1/ceWbs4UDkGD/Cpu1I-Vb"; ## 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 Junos PyEZ 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 para 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 utiliza 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 with a Junos device.
Upon connecting, 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:~$ python3 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 acerca de cómo configurar SSH saliente en dispositivos Junos, consulte Configurar el servicio SSH saliente.
Conectarse a un dispositivo mediante Telnet
La clase Junos PyEZ Device admite la conexión a un dispositivo Junos mediante telnet, que proporciona acceso sin cifrar al dispositivo de red. Puede 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 el servicio Telnet 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 puesto a cero que aún no está configurado para el acceso remoto.
Para usar Junos PyEZ para telnet a un dispositivo Junos, debe incluir mode='telnet' en la lista de Device argumentos y, opcionalmente, incluir el port parámetro para especificar un puerto. Cuando especifique mode='telnet' pero omita el port parámetro, el valor port predeterminado de 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 Junos.
Para usar Junos PyEZ para telnet a un dispositivo Junos e imprimir los datos del dispositivo en una aplicación Junos PyEZ con Python 3:
El programa de muestra 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()
Alternativamente, puede usar un administrador de contexto cuando se conecte al dispositivo, que se encarga de abrir y cerrar 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 presionar Entrar después del mensaje para llegar al mensaje de inicio de sesión. Si una aplicación de Junos PyEZ abre una sesión de Telnet con un servidor de consola que requiere que el usuario presione Intro después de un mensaje de banner, es posible que la aplicación no reciba el mensaje de inicio de sesión, lo que puede provocar que la conexión se bloquee.
A partir de Junos PyEZ versión 2.6.2, Junos PyEZ gestiona automáticamente el banner del servidor de consola. En las versiones 2.1.0 a 2.6.1 de Junos PyEZ, una aplicación de Junos PyEZ puede incluir console_has_banner=True en la lista de Device argumentos telnet a un servidor de consola que emite un mensaje de banner.
dev = Device(host=hostname, user=username, passwd=password, mode='telnet', console_has_banner=True)
Cuando se incluye el console_has_banner=True argumento y la aplicación no recibe un mensaje de inicio de sesión en la conexión inicial, la aplicación espera 5 segundos y, a continuació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 terminar la conexión.
Conectarse a un dispositivo mediante una conexión de consola serie
La clase Junos PyEZ Device permite conectarse a un dispositivo Junos mediante una conexión de consola serie, lo cual resulta útil cuando se debe configurar inicialmente un dispositivo nuevo o a cero 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 del dispositivo, consulte la documentación del hardware de su dispositivo específico.
Junos PyEZ admite el uso de gestores de contexto para las conexiones de consola serie. Se recomienda usar un administrador de contexto para las conexiones de 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, se pueden obtener resultados impredecibles.
Para utilizar Junos PyEZ para conectarse a un dispositivo Junos a través de una conexión de consola serie, debe incluir mode='serial' en la lista de Device argumentos y, opcionalmente, incluir el port parámetro para especificar un puerto. Cuando especifique mode='serial' pero omita el port parámetro, el valor port predeterminado de ./dev/ttyUSB0
Para conectarse a un dispositivo Junos mediante una conexión de consola serie y también cargar y confirmar una configuración en el dispositivo en una aplicación Junos PyEZ con Python 3:
El programa de muestra 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)