Autenticar usuários do Junos PyEZ
RESUMO Os aplicativos Junos PyEZ podem autenticar usuários usando mecanismos padrão de autenticação de SSH, incluindo senhas e chaves SSH.
Visão geral da autenticação de usuário do Junos PyEZ
O Junos PyEZ permite que você se conecte e gerencie diretamente os dispositivos Junos usando uma conexão de console serial, telnet ou uma sessão NETCONF sobre SSH. Além disso, o Junos PyEZ também oferece suporte à conexão ao dispositivo por meio de uma conexão telnet ou SSH a um servidor de console conectado à porta do CONSOLE dispositivo. O dispositivo deve ser capaz de autenticar o usuário usando uma senha ou outros mecanismos de autenticação SSH padrão, dependendo do método de conexão. Quando você gerencia os dispositivos Junos por meio de uma conexão SSH, a maneira mais conveniente e segura de acessar um dispositivo é configurar as chaves SSH. As chaves SSH permitem que o dispositivo remoto identifique usuários confiáveis.
Você pode realizar operações de dispositivo usando qualquer conta de usuário que tenha acesso ao dispositivo Junos gerenciado. Você pode definir explicitamente o usuário ao criar uma nova instância da jnpr.junos.device.Device classe ou, se não especificar um usuário na lista de parâmetros $USER, o usuário não poderá .
Para conexões SSH, o Junos PyEZ consulta automaticamente o arquivo de configuração SSH padrão em ~/.ssh/config, se um existir, a menos que a Device lista de argumentos inclua o ssh_config argumento para especificar um arquivo de configuração diferente. O Junos PyEZ usa quaisquer configurações relevantes no arquivo de configuração SSH para uma determinada conexão que não seja anulada pelos argumentos da Device lista de argumentos, como o usuário ou o arquivo de identidade.
Quando o cliente Junos PyEZ usa o SSH para se conectar ao dispositivo Junos ou a um servidor de console conectado ao dispositivo, o Junos PyEZ primeiro tenta a autenticação pública baseada em chave SSH e depois tenta autenticação baseada em senha. Quando as chaves SSH estão em uso, a senha fornecida é usada como senha para desbloquear a chave privada. Quando a autenticação baseada em senha é usada, a senha fornecida é usada como senha do dispositivo. Se a autenticação baseada em chave pública SSH estiver sendo usada e a chave privada SSH tiver uma senha vazia, então uma senha não será necessária. No entanto, as chaves privadas SSH com senhas vazias não são recomendadas.
É responsabilidade do usuário obter as credenciais de autenticação de nome de usuário e senha de maneira segura e apropriada para o ambiente. É a melhor prática solicitar essas credenciais de autenticação durante cada invocação do script em vez de armazenar as credenciais em um formato não criptografado.
Autenticar usuários do Junos PyEZ usando uma senha
Para autenticar um usuário do Junos PyEZ usando uma senha:
Autenticar usuários do Junos PyEZ usando chaves SSH
Para usar chaves SSH em um aplicativo Junos PyEZ, você deve primeiro gerar as chaves no servidor de gerenciamento de configuração e configurar a chave pública em cada dispositivo ao qual o cliente Junos PyEZ se conectará. Para se conectar diretamente ao dispositivo Junos, configure a chave nesse dispositivo. Para se conectar a um dispositivo Junos por meio de um servidor de console, configure a chave no servidor do console. Para usar as chaves, você deve incluir os argumentos apropriados na Device lista de argumentos.
O Junos PyEZ pode usar chaves SSH que são ativamente carregadas em um agente-chave SSH, chaves que são geradas no local padrão ou em um local definido pelo usuário, e chaves que usam ou deixam de usar a proteção de senha. Ao se conectar diretamente a um dispositivo Junos, se os Device argumentos não especificarem uma senha ou arquivo chave SSH, o Junos PyEZ verifica primeiro as chaves SSH que estão ativamente carregadas no agente chave SSH e depois verifica se há chaves SSH no local padrão. Ao se conectar a um servidor de console, apenas as chaves protegidas por senha são suportadas.
As seções a seguir descrevem as etapas para gerar as chaves SSH, configurar as chaves nos dispositivos Junos e usar as chaves para se conectar ao dispositivo gerenciado:
Gerar e configurar chaves SSH
Para gerar chaves SSH no servidor de gerenciamento de configuração e configurar a chave pública em dispositivos Junos:
Chaves SSH de referência em aplicativos Junos PyEZ
Após gerar o par de chaves SSH e configurar a chave pública no dispositivo remoto, você pode usar a chave para se conectar ao dispositivo, incluindo os argumentos apropriados no código do Device construtor. Os Device argumentos são determinados pela localização da chave, se a chave está protegida por senha, se a chave é carregada ativamente em um agente-chave SSH, como ssh-agent, e se o arquivo de configuração SSH do usuário já define configurações para esse host. As seções a seguir descrevem os vários cenários:
- Autenticar o usuário usando um agente-chave SSH com chaves carregadas ativamente
- Autenticar o usuário usando chaves SSH sem proteção de senha
- Autenticar o usuário usando arquivos chave SSH protegidos por senha
Autenticar o usuário usando um agente-chave SSH com chaves carregadas ativamente
Você pode usar um agente-chave SSH para armazenar chaves privadas com segurança e evitar reinstalar repetidamente a senha para chaves protegidas por senha. O Junos PyEZ permite que um cliente se conecte diretamente a um dispositivo Junos usando chaves SSH que são ativamente carregadas em um agente-chave SSH. Ao se conectar a um dispositivo Junos, se os Device argumentos não especificarem uma senha ou arquivo chave SSH, o Junos PyEZ verifica primeiro as chaves SSH que estão ativamente carregadas no agente chave SSH e depois verifica se há chaves SSH no local padrão.
Para usar as chaves SSH que são ativamente carregadas no agente-chave SSH nativo para se conectar diretamente a um dispositivo Junos:
Na lista de
Deviceargumentos, você só precisa fornecer o nome de host necessário e quaisquer variáveis desejadas.dev = Device(host='router.example.com')
Autenticar o usuário usando chaves SSH sem proteção de senha
O Junos PyEZ permite que um cliente se conecte diretamente a um dispositivo Junos usando chaves privadas SSH que não tenham proteção de senha, embora não recomendemos usar chaves privadas SSH com uma senha vazia. O Junos PyEZ não suporta a conexão a um servidor de console usando chaves privadas SSH com uma senha vazia.
Para se conectar a um dispositivo Junos usando chaves SSH que estão no local padrão e não têm proteção de senha:
Na lista de
Deviceargumentos, você só precisa fornecer o nome de host necessário e quaisquer variáveis desejadas.dev = Device(host='router.example.com')
O Junos PyEZ verifica primeiro as chaves SSH que estão carregadas em qualquer agente-chave SSH ativo e depois verifica as chaves SSH no local padrão.
Para se conectar a um dispositivo Junos usando chaves SSH que não estão no local padrão e não têm proteção de senha:
Na lista de
Deviceargumentos, definir ossh_private_key_fileargumento para o caminho da chave privada SSH.dev = Device(host='router.example.com', ssh_private_key_file='/home/user/.ssh/id_rsa_dc')
Nota:Se o arquivo de configuração SSH do usuário já especificar o caminho de arquivo de chave privada SSH local para um determinado host, você pode omitir o
ssh_private_key_fileargumento naDevicelista de argumentos. Incluir ossh_private_key_fileargumento substitui qualquer valor existenteIdentityFiledefinido para um host no arquivo de configuração SSH do usuário.
Autenticar o usuário usando arquivos chave SSH protegidos por senha
Os clientes Junos PyEZ podem usar arquivos chave SSH protegidos por senha para se conectar diretamente a um dispositivo Junos ou se conectar a um servidor de console conectado ao dispositivo.
Para se conectar diretamente a um dispositivo Junos usando um arquivo chave SSH protegido por senha:
Para se conectar a um dispositivo Junos por meio de um servidor de console usando um arquivo chave SSH protegido por senha:
-
Inclua código que solicita as credenciais de login para o dispositivo Junos e armazena cada valor em uma variável.
from jnpr.junos import Device from getpass import getpass junos_username = input('Junos OS username: ') junos_password = getpass('Junos OS password: ')
Inclua código que solicita o nome de usuário do servidor do console e a senha da chave privada SSH e armazena cada valor em uma variável.
from jnpr.junos import Device from getpass import getpass junos_username = input('Junos OS username: ') junos_password = getpass('Junos OS password: ') cs_username = input('Console server username: ') key_password = getpass('Password for SSH private key file: ')
Na lista de argumentos do
Deviceconstrutor:Definir o
hostargumento para o nome de host do servidor do console ou endereço IPDefinir os
userargumentos epasswdas variáveis que contêm as credenciais de login do Junos OSDefinir o
cs_userargumento para a variável que contém o nome de usuário do servidor do consoleDefinir o
cs_passwdargumento para a variável que contém a senha de arquivo chave SSHDefina o
ssh_private_key_fileargumento para o caminho da chave privada, se a chave não estiver no local padrão e o caminho do arquivo ainda não estiver definido no arquivo de configuração SSH do usuário
from jnpr.junos import Device from getpass import getpass junos_username = input('Junos OS username: ') junos_password = getpass('Junos OS password: ') cs_username = input('Console server username: ') key_password = getpass('Password for SSH private key file: ') with Device(host='router.example.com', user=junos_username, passwd=junos_password, cs_user=cs_username, cs_passwd=key_password, ssh_private_key_file='/home/user/.ssh/id_rsa_dc') as dev: print (dev.facts) # ...