Conecte-se a dispositivos Junos usando o Junos PyEZ
Conecte-se a um dispositivo Junos ou a um servidor de console conectado usando diferentes métodos e protocolos de conexão em um aplicativo Junos PyEZ.
O Junos PyEZ é um microframework para Python que permite gerenciar dispositivos Junos. O Junos PyEZ modela cada dispositivo como uma instância da classe jnpr.junos.device.Device . A Device classe permite que você se conecte a um dispositivo Junos usando uma conexão de console serial, Telnet ou uma sessão NETCONF sobre SSH. O Junos PyEZ também oferece suporte à conexão ao dispositivo por meio de uma conexão telnet ou SSH com um servidor de console. Um servidor de console, também conhecido como servidor de terminal, é um dispositivo especializado que fornece uma conexão de rede para a porta de console de gerenciamento fora de banda de um dispositivo. Além disso, você pode usar o Junos PyEZ para se conectar a um dispositivo Junos por meio de um dispositivo intermediário, como um bastion ou host de salto.
Este tópico fornece uma visão geral dos métodos de conexão suportados pelo Junos PyEZ e explica como usar os diferentes métodos para se conectar a um dispositivo Junos. Os exemplos do Junos PyEZ usam vários métodos de autenticação, mas para informações detalhadas sobre como autenticar um usuário, consulte Autenticar usuários do Junos PyEZ.
Visão geral dos métodos de conexão
O Junos PyEZ permite que você se conecte a um dispositivo Junos usando uma conexão de console serial, telnet ou uma sessão NETCONF sobre SSH. Você deve usar uma conexão de console serial quando estiver fisicamente conectado à porta CONSOLE em um dispositivo. Você pode usar telnet ou SSH para se conectar à interface de gerenciamento do dispositivo ou a um servidor de console conectado à porta CONSOLE do dispositivo. O Junos PyEZ também oferece suporte a conexões SSH com um dispositivo por meio de um bastião ou host de salto. Além disso, o Junos PyEZ oferece suporte a conexões SSH de saída, nas quais o dispositivo Junos inicia a conexão com o aplicativo de gerenciamento de clientes.
Dispositivos novos ou zerados que têm configurações padrão de fábrica exigem acesso por meio de uma conexão de console. Você pode usar o Junos PyEZ para configurar inicialmente um dispositivo que ainda não está configurado para acesso remoto. Você pode usar uma conexão de console serial quando estiver conectado diretamente ao dispositivo ou pode usar telnet ou SSH por meio de um servidor de console conectado ao dispositivo.
Por padrão, o Junos PyEZ usa SSH para se conectar a um dispositivo. Para especificar um tipo de conexão diferente, você deve incluir o mode parâmetro na lista de Device argumentos. Para fazer telnet para um dispositivo, inclua o mode='telnet' argumento. Para se conectar a um dispositivo usando uma conexão de console serial, inclua o mode='serial' argumento. A Tabela 1 resume os métodos de conexão do Junos PyEZ, seus valores padrão para determinados parâmetros e qualquer configuração necessária do Junos OS.
|
Modo de conexão |
Valor do |
Porta padrão |
Configuração necessária do Junos OS |
|---|---|---|---|
|
NETCONF sobre SSH (padrão) |
– |
830 |
[edit system services]
netconf {
ssh;
}
|
|
Conexão de console serial |
serial |
/dev/ttyUSB0 |
– |
|
Telnet para dispositivo Junos |
Telnet |
23 |
[edit system services] telnet; |
|
Telnet através de um servidor de console |
Telnet |
23 |
– |
|
SSH por meio de um servidor de console |
– |
22 |
– |
|
SSH por meio de um host de salto |
– |
22 |
[edit system services]
netconf {
ssh;
}
|
|
SSH de saída |
– |
– |
[edit system services]
outbound-ssh {
...
}
|
Antes de acessar a interface de gerenciamento de um dispositivo usando Telnet ou NETCONF sobre SSH, você deve primeiro habilitar o serviço apropriado no nível da [edit system services] hierarquia. Para obter mais informações, consulte Configurar nós gerenciados do Junos PyEZ. Como o Telnet usa senhas de texto não criptografado (criando assim uma possível vulnerabilidade de segurança), recomendamos que você use SSH.
Obtenha credenciais de maneira segura e apropriada para o seu ambiente. Como prática recomendada, solicite credenciais sempre que executar o script em vez de armazená-las em um formato não criptografado.
O Junos PyEZ suporta o uso de gerenciadores de contexto (with ... as sintaxe) para todos os métodos de conexão. Quando você usa um gerenciador de contexto, o Junos PyEZ chama automaticamente os open() métodos and close() para se conectar e desconectar do dispositivo. Se você não usar um gerenciador de contexto, deverá chamar explicitamente os open() métodos and close() em seu aplicativo. Recomendamos que você use um gerenciador de contexto para conexões de console. O gerenciador de contexto lida automaticamente com o fechamento da conexão e a falha ao fechar a conexão pode levar a resultados imprevisíveis.
Entendendo as propriedades de conexão do Junos PyEZ
Quando você se conecta a um dispositivo Junos, o Junos PyEZ armazena informações sobre a conexão atual como propriedades da Device instância. A Tabela 2 descreve as propriedades de conexão disponíveis.
|
Propriedade |
Digite |
Descrição |
|---|---|---|
|
|
Booleano |
Estado atual da conexão. Retorna |
|
|
Sequência |
Nome do host do dispositivo ao qual o aplicativo está conectado. |
|
|
Booleano |
Retorna |
|
|
Inteiro ou cadeia de caracteres |
Porta usada para a conexão. |
|
|
Sequência |
Nome do Mecanismo de Roteamento ao qual o aplicativo está conectado. |
|
|
Inteiro |
Valor de tempo limite de RPC em segundos. |
|
|
Inteiro |
Número de segundos desde que o Mecanismo de Roteamento atual foi inicializado. |
|
|
Sequência |
Usuário acessando o dispositivo Junos. |
Por exemplo, depois de se conectar a um dispositivo, você pode consultar a connected propriedade para retornar o estado atual da conexão. A SessionListener monitora a sessão e responde a erros de transporte gerando uma TransportError exceção e definindo a Device.connected propriedade como False.
O código de exemplo a seguir imprime o valor da propriedade após a conexão com um dispositivo Junos e novamente após o fechamento da connected sessão.
from jnpr.junos import Device dev = Device(host='router.example.net') dev.open() print (dev.connected) dev.close() print (dev.connected)
Quando você executa o programa, a connected propriedade retorna True enquanto o aplicativo está conectado ao dispositivo e retorna False depois que a conexão é fechada.
user@host:~$ python connect.py True False
Conectar-se a um dispositivo usando SSH
A classe PyEZ Device do Junos suporta o uso de SSH para se conectar a um dispositivo Junos. O Junos PyEZ suporta as seguintes conexões:
-
Conecte-se diretamente à interface de gerenciamento do dispositivo
-
Conecte-se por meio de um servidor de console conectado diretamente à porta CONSOLE do dispositivo
-
Conectar-se por meio de um bastião ou host de salto
O servidor SSH deve ser capaz de autenticar o usuário usando mecanismos de autenticação SSH padrão, conforme descrito em Autenticar usuários do Junos PyEZ. Para estabelecer uma sessão NETCONF sobre SSH, você também deve atender aos requisitos descritos em Configurar nós gerenciados do Junos PyEZ.
Ao usar o SSH para se conectar a um dispositivo, o Junos PyEZ primeiro tenta a autenticação baseada em chave pública SSH e, em seguida, tenta a autenticação baseada em senha. Quando a autenticação baseada em senha é usada, a senha fornecida é usada como a senha do dispositivo. Quando as chaves SSH estão em uso, a senha fornecida é a senha para desbloquear a chave privada. Você não precisará fornecer uma senha se carregar a chave em um agente de chave SSH ou se a chave privada SSH tiver uma senha vazia. No entanto, não recomendamos o uso de chaves privadas SSH com senhas vazias.
O Junos PyEZ consulta automaticamente o arquivo de configuração SSH padrão em ~/.ssh/config, se houver. O Junos PyEZ usa todas as configurações relevantes no arquivo de configuração SSH que não são substituídas pelos Device argumentos, como o usuário ou o arquivo de identidade. Para usar um arquivo de configuração SSH diferente, defina ssh_config como o caminho do arquivo ao definir Device. Por exemplo:
ssh_config_file = "~/.ssh/config_dc"
dev = Device(host='router1.example.com', ssh_config=ssh_config_file)
A partir do Junos PyEZ Release 2.7.2, um cliente Junos PyEZ pode habilitar a verificação de chave de host SSH quando se conecta a um dispositivo Junos. O cliente verifica a identidade do dispositivo remoto validando se a impressão digital da chave de host do dispositivo corresponde a uma chave confiável no arquivo known_hosts do cliente. Se a chave de host apresentada não corresponder a uma chave confiável, a conexão será rejeitada. Use a verificação de chave de host, quando aplicável, para evitar ataques man-in-the-middle.
Por padrão, o Junos PyEZ desabilita a verificação da chave do host SSH e permite que a conexão prossiga sem exigir que a chave pública do servidor seja registrada no arquivo known_hosts do cliente. Para habilitar a verificação de chave de host, inclua hostkey_verify=True ao definir Device. Se você habilitar a verificação de chave de host, deverá carregar a chave de host do dispositivo no arquivo known_hosts antes de se conectar ao dispositivo. Caso contrário, a conexão falhará.
dev = Device(host='router1.example.com', hostkey_verify=True)
As seções a seguir discutem os diferentes métodos para se conectar a um dispositivo usando SSH.
- Conecte-se diretamente a um dispositivo
- Conectar-se a um dispositivo por meio de um servidor de console
- Conectar-se a um dispositivo por meio de um bastião ou host de salto
Conecte-se diretamente a um dispositivo
O Junos PyEZ permite que você se conecte diretamente a um dispositivo com o Junos OS ou um dispositivo com o Junos OS Evolved. Ao instanciar o Device objeto, forneça o nome do host ou o endereço IP do dispositivo de destino e as credenciais de usuário necessárias.
Se o cliente Junos PyEZ precisar estabelecer a conexão usando um endereço IP de origem local específico no servidor de gerenciamento de configuração (CMS), você poderá incluir o bind_addr argumento para especificar o endereço. Definir o endereço de origem local para uma conexão pode ser necessário, por exemplo, se o CMS usar várias interfaces de rede e endereços IP e apenas um subconjunto de endereços puder ser acessado a partir do dispositivo de rede.
Para criar um aplicativo Junos PyEZ que estabelece uma sessão NETCONF sobre SSH com um dispositivo Junos e imprime os fatos do dispositivo:
-
Importe a
Deviceclasse e quaisquer outros módulos ou objetos necessários para suas tarefas.import sys from getpass import getpass from jnpr.junos import Device from jnpr.junos.exception import ConnectError
-
Crie a instância do dispositivo e forneça o nome do host, todos os parâmetros necessários para autenticação e todos os parâmetros opcionais.
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) Se o dispositivo Junos configurar o NETCONF em uma porta diferente da padrão (830), inclua o
portargumento e especifique a porta.dev = Device(host=hostname, user=junos_username, passwd=junos_password, port=50001)
-
(Opcional) Se você precisar especificar o endereço de origem local que deve ser usado para estabelecer a conexão, inclua o
bind_addrargumento e especifique o endereço IP a ser usado.dev = Device(host=hostname, user=junos_username, passwd=junos_password, bind_addr=10.10.10.1)
-
Conecte-se ao dispositivo chamando o
open()método, por exemplo: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 os fatos do dispositivo.
print (dev.facts)
-
Depois de executar todas as tarefas necessárias, feche a conexão com o dispositivo.
dev.close()
O programa de exemplo em sua totalidade (parâmetros opcionais omitidos) é apresentado aqui:
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, você pode usar um gerenciador de contexto ao se conectar ao dispositivo. O gerenciador de contexto chama automaticamente os open() métodos e close() . Por exemplo:
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)
Conectar-se a um dispositivo por meio de um servidor de console
Um cliente Junos PyEZ pode se conectar a um dispositivo Junos por meio de uma conexão SSH com um servidor de console. Nesse caso, você deve especificar as credenciais de login para o servidor de console e o dispositivo Junos. Na lista de Device argumentos, inclua as credenciais do servidor de console nos cs_user argumentos e cs_passwd . Quando as chaves SSH estiverem em uso, defina o cs_passwd argumento como a variável que contém a senha da chave privada. Além disso, defina o port argumento como a porta TCP que mapeia para o dispositivo TTY, se aplicável.
O servidor de console se conecta ao dispositivo Junos por meio de uma conexão serial, que pode ser lenta. As conexões do Junos PyEZ por meio de um servidor de console têm um valor de tempo limite de conexão padrão de 0,5 segundos. Para permitir tempo suficiente para que o aplicativo cliente estabeleça a conexão, talvez seja necessário aumentar o intervalo de tempo limite da conexão incluindo o timeout=seconds argumento.
O exemplo do Junos PyEZ a seguir é autenticado com o servidor de console e, em seguida, com o dispositivo Junos. O tempo limite da conexão é definido como seis segundos para que o cliente tenha tempo suficiente para estabelecer a conexão.
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)
Conectar-se a um dispositivo por meio de um bastião ou host de salto
O Junos PyEZ permite que você acesse um dispositivo de destino por meio de um host intermediário (bastion ou jump host). Talvez seja necessário usar um bastião ou host de salto quando não for possível fazer login diretamente no dispositivo de destino. Por exemplo, o dispositivo pode estar atrás de um firewall.
Para usar o SSH para se conectar por meio de um dispositivo intermediário, você pode usar uma das seguintes opções:
-
No arquivo de configuração SSH, adicione uma entrada para o dispositivo de destino e especifique a opção ProxyCommand.
-
Em sua
Devicelista de argumentos, inclua oproxy_commandparâmetro.
O Device proxy_command argumento tem precedência sobre a opção ProxyCommand no arquivo de configuração SSH. Se você configurar as duas opções, o Junos PyEZ usará apenas o proxy_command argumento. As seções a seguir fornecem detalhes sobre como usar cada opção.
- Exemplo: usar ProxyCommand no arquivo de configuração SSH
- Exemplo: usar o
Deviceproxy_commandargumento
Exemplo: usar ProxyCommand no arquivo de configuração SSH
Para configurar um bastion ou jump host em seu arquivo de configuração SSH, adicione uma entrada para o host Junos e inclua a opção ProxyCommand. A cadeia de caracteres ProxyCommand define a conexão com o dispositivo intermediário. Por exemplo, a configuração a seguir se conecta por meio de um host intermediário que oferece suporte a 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
Da mesma forma, a configuração a seguir se conecta por meio do dispositivo intermediário ao host e à porta de destino no modo silencioso, que suprime os avisos.
user1@server:~$ cat ~/.ssh/config Host 198.51.100.1 User user1 ProxyCommand ssh -W %h:%p -q jumphost.example.com
Exemplo: usar o argumento Device proxy_command
Ao definir Device, você pode incluir o proxy_command argumento para se conectar por meio de um dispositivo intermediário. A proxy_command cadeia de caracteres define a conexão com o bastião ou host de salto. Se necessário, o Junos PyEZ solicita a senha do host de salto ou sua senha de chave privada SSH.
O exemplo a seguir se conecta a um dispositivo Junos por meio de um host de salto. Neste exemplo, o Junos PyEZ é autenticado com cada dispositivo usando chaves SSH protegidas por senha carregadas no agente de chave 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)
Se você carregar as chaves SSH para o host de salto e o dispositivo de rede em seu agente de chave SSH, não precisará fornecer os caminhos de chave privada ou senhas no aplicativo Junos PyEZ. No entanto, se você não carregar as chaves necessárias no agente de chave SSH, deverá fornecer o caminho e a senha para todas as chaves protegidas por senha em locais não padrão. Os ssh_private_key_file argumentos and password especificam o caminho e a senha da chave privada usada para autenticar com o dispositivo Junos. proxy_command No argumento, use a -i path opção para especificar o caminho da chave privada usada para autenticar com o host de salto. Quando você executa o script, o Junos PyEZ solicita a senha da chave privada correspondente. Por exemplo:
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()
Quando você executa o script, ele solicita as senhas das chaves 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...]
Conectar-se a um dispositivo usando SSH de saída
Você pode configurar um dispositivo Junos para iniciar uma conexão TCP/IP com um aplicativo de gerenciamento de clientes que seria bloqueado se o cliente tentasse iniciar a conexão (por exemplo, se o dispositivo estiver atrás de um firewall). A outbound-ssh configuração instrui o dispositivo a criar uma conexão TCP/IP com o aplicativo de gerenciamento do cliente e a encaminhar a identidade do dispositivo. Uma vez estabelecida a conexão, o aplicativo de gerenciamento atua como o cliente e inicia a sequência SSH, e o dispositivo Junos atua como o servidor e autentica o cliente.
Depois de configurar e confirmar o SSH de saída no dispositivo Junos, o dispositivo começa a iniciar uma conexão SSH de saída com base na configuração confirmada. O dispositivo tenta criar essa conexão repetidamente até ser bem-sucedido. Se a conexão entre o dispositivo e o aplicativo de gerenciamento do cliente for descartada, o dispositivo tentará novamente criar uma nova conexão SSH de saída até ser bem-sucedida. Essa conexão é mantida até que a configuração SSH de saída seja excluída ou desativada.
Para configurar o dispositivo Junos para conexões SSH de saída, inclua a outbound-ssh declaração no nível da [edit system services] hierarquia. No exemplo a seguir, o dispositivo Junos tenta iniciar uma conexão com o host em 198.51.100.101 na porta 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 estabelecer uma conexão com o dispositivo Junos usando SSH de saída, o aplicativo Junos PyEZ define o sock_fd Device argumento no construtor igual ao descritor de arquivo de um soquete existente e omite o host argumento ou o define como None.
O exemplo de PyEZ do Junos a seguir escuta na porta TCP configurada para sessões SSH de entrada de dispositivos Junos. O aplicativo aceita uma conexão de entrada e recupera o descritor de arquivo do soquete para essa conexão, que é usado para o valor do sock_fd argumento. O aplicativo cliente estabelece a conexão SSH com o dispositivo, coleta e imprime os fatos do dispositivo, desconecta-se do dispositivo e aguarda mais conexões.
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 obter informações detalhadas sobre como configurar o SSH de saída em dispositivos Junos, consulte Configurar o serviço SSH de saída.
Conectar-se a um dispositivo usando Telnet
A classe PyEZ Device do Junos oferece suporte à conexão com um dispositivo Junos usando Telnet, que fornece acesso não criptografado ao dispositivo de rede. Você pode fazer telnet para a interface de gerenciamento do dispositivo ou para um servidor de console que esteja diretamente conectado à porta CONSOLE do dispositivo. Você deve configurar a telnet declaração no nível da [edit system services] hierarquia em todos os dispositivos que exigem acesso à interface de gerenciamento. Acessar o dispositivo por meio de um servidor de console permite que você configure inicialmente um dispositivo novo ou zerado que ainda não está configurado para acesso remoto.
Para usar o Device Junos PyEZ para fazer telnet para um dispositivo Junos, você deve incluir mode='telnet' na lista de argumentos e, opcionalmente, incluir o port parâmetro para especificar uma porta. Quando você especificamode='telnet', mas omite o port parâmetro, o valor port para o padrão é 23. Quando o aplicativo se conecta por meio de um servidor de console, especifique a porta pela qual o servidor de console se conecta ao dispositivo Junos.
Para usar o Junos PyEZ para fazer telnet para um dispositivo Junos e imprimir os fatos do dispositivo:
O programa de exemplo em sua totalidade é apresentado aqui:
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, você pode usar um gerenciador de contexto ao se conectar ao dispositivo, que lida com a abertura e o fechamento da conexão. Por exemplo:
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)
Em alguns casos, quando você se conecta a um servidor de console que emite uma mensagem de faixa, pode ser necessário pressionar Enter após a mensagem para acessar o prompt de login. Nesse caso, o aplicativo pode falhar ao receber o prompt de login, o que pode fazer com que a conexão seja interrompida.
A partir do Junos PyEZ Release 2.6.2, o Junos PyEZ lida automaticamente com o banner do servidor de console. No Junos PyEZ versões 2.1.0 a 2.6.1, um aplicativo Junos PyEZ pode ser incluído console_has_banner=True na Device lista de argumentos para lidar com um servidor de console que emite uma mensagem de banner.
dev = Device(host=hostname, user=username, passwd=password, mode='telnet', port=port, console_has_banner=True)
Quando você inclui o console_has_banner=True argumento, se o aplicativo não receber um prompt de logon na conexão inicial, o aplicativo aguardará 5 segundos. Em seguida, o aplicativo emite um caractere de nova linha (\n) para que o servidor do console emita o prompt de login. Se você omitir o argumento e a conexão travar, o aplicativo emitirá o <close-session/> RPC para encerrar a conexão.
Conecte-se a um dispositivo usando uma conexão de console serial
A classe PyEZ Device do Junos permite que você se conecte a um dispositivo Junos usando uma conexão de console serial. Uma conexão de console serial é útil quando você deve configurar inicialmente um dispositivo novo ou zerado que ainda não está configurado para acesso remoto. Para usar este método de conexão, você deve estar fisicamente conectado ao dispositivo através da porta CONSOLE . Para obter instruções detalhadas sobre como se conectar à porta CONSOLE do seu dispositivo, consulte a documentação de hardware do seu dispositivo específico.
O Junos PyEZ oferece suporte ao uso de gerenciadores de contexto para conexões de console serial. Recomendamos que você use um gerenciador de contexto para conexões de console, pois o gerenciador de contexto lida automaticamente com a abertura e o fechamento da conexão. O não fechamento da conexão pode levar a resultados imprevisíveis.
Para usar o Device Junos PyEZ para se conectar a um dispositivo Junos por meio de uma conexão de console serial, você deve incluir mode='serial' na lista de argumentos. Opcionalmente, é possível incluir o port parâmetro para especificar uma porta. Quando você especificamode='serial', mas omite o port parâmetro, o valor port padrão é /dev/ttyUSB0.
Para usar o Junos PyEZ para se conectar a um dispositivo Junos usando uma conexão de console serial e carregar e confirmar uma configuração:
O programa de exemplo em sua totalidade é apresentado aqui:
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)