NESTA PÁGINA
Entendendo os valores padrão dos módulos da Juniper Networks
Como definir parâmetros de autenticação nos vars: Seção para conexões locais e persistentes
Como definir o parâmetro do provedor nos módulos Juniper.junos
Como autenticar o usuário usando um guia de jogadas ou solicitação de senha de linha de comando
Como autenticar o usuário usando um arquivo criptografado por cofres ansible
Autenticar usuários executando módulos ansíveis em dispositivos Junos
Visão geral da autenticação
A Juniper Networks fornece módulos Ansible que você pode usar para gerenciar dispositivos Junos. Os módulos da Juniper Networks são distribuídos por meio da juniper.device
coleção e do Juniper.junos
papel, que são hospedados na Ansible Galaxy.
Os módulos da Juniper Networks permitem que você se conecte diretamente e gerencie dispositivos Junos usando SSH, telnet ou uma conexão de console serial. Os módulos também suportam a conexão ao dispositivo por meio de uma conexão SSH ou telnet a um servidor de console que está conectado à porta do CONSOLE
dispositivo. O dispositivo remoto deve ser capaz de autenticar o usuário usando uma senha ou outros mecanismos de autenticação SSH padrão, dependendo do protocolo de conexão.
Quando você usa o Ansible para gerenciar dispositivos Junos, a maneira mais conveniente de acessar o dispositivo é configurar as chaves SSH. As chaves SSH permitem que o dispositivo remoto identifique usuários confiáveis. Alternativamente, você pode fornecer um nome de usuário e senha quando você executa módulos e playbooks.
Para conexões SSH, os módulos da Juniper Networks primeiro tentam a autenticação pública baseada em chave SSH e depois tentam a autenticação baseada em senha. Quando as chaves SSH estão em uso, a senha fornecida é usada como senha para desbloquear a chave SSH 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. Para recuperar uma senha para autenticação baseada em senha ou chaves SSH protegidas por senha, você pode solicitar a senha do manual ou linha de comando, ou criar um arquivo de dados criptografado com cofre que armazena com segurança a senha.
Você pode especificar parâmetros de conexão e autenticação para os módulos da Juniper Networks das seguintes maneiras. Se você não definir explicitamente os valores, os valores padrão serão usados em alguns casos, conforme descrito na compreensão dos valores padrão dos módulos da Juniper Networks. Se você definir o valor de um parâmetro em vários lugares, a Ansible seleciona o valor com base na precedência variável, conforme descrito no Entendimento da precedência variável nos documentos oficiais ansíveis.
-
Variáveis ansíveis — Você pode especificar os valores dos parâmetros de conexão e autenticação usando variáveis Ansible normais, por exemplo, variáveis definidas em arquivos de inventário ou cofre, em variáveis de host ou grupo, ou usando opções de linha de comando.
-
Arquivo de configuração do cliente SSH — Para conexões SSH, os módulos da Juniper Networks consultam automaticamente o arquivo de configuração SSH padrão em ~/.ssh/config, se houver, a menos que você defina a opção
ssh_config
de especificar um arquivo de configuração diferente. Os módulos usam quaisquer configurações relevantes no arquivo de configuração SSH para a determinada conexão, a menos que você defina explicitamente variáveis que sobrepõem a configuração. -
Argumentos do módulo — o
juniper.device
suporte para módulos eJuniper.junos
especificar opções relacionadas à conexão e autenticação para conexões locais (connection: local
) como argumentos de módulo de alto nível. Além disso,Juniper.junos
os módulos suportam o uso de um provedor nos argumentos do módulo, conforme descrito em Como definir o parâmetro do provedor nos módulos Juniper.junos. -
vars:
seção — Osjuniper.device
módulos suportam especificar opções relacionadas à conexão e autenticação para conexões locais e persistentes na seção devars:
uma peça, que é descrita em Como definir parâmetros de autenticação nos vars: Seção para conexões locais e persistentes.
Este documento discute os diferentes aspectos da autenticação ao usar os módulos da Juniper Networks para gerenciar dispositivos Junos.
Entendendo os valores padrão dos módulos da Juniper Networks
Você pode definir explicitamente os parâmetros de conexão e autenticação para módulos que gerenciam dispositivos Junos. Se você não definir um parâmetro, o módulo usa um valor padrão em alguns casos. A Tabela 1 descreve os valores padrão e a precedência variável para parâmetros de conexão comuns para módulos na juniper.device
coleta e Juniper.junos
função. Para obter informações sobre os argumentos aceitos para os módulos individuais, consulte a documentação de referência da API para esse módulo.
Nome do parâmetro |
Aliases de parâmetros |
Descrição |
Valor padrão e precedência variável |
---|---|---|---|
|
|
Nome de host ou endereço IP do dispositivo remoto com o qual a conexão deve ser estabelecida. |
|
|
|
A senha do usuário ou senha de chave SSH usada para autenticar com o dispositivo gerenciado. |
|
|
– |
Caminho para um arquivo de configuração de cliente SSH. Se você omitir esse parâmetro, os módulos usam o arquivo de configuração SSH no local padrão, se houver um. |
~/.ssh/configuração |
|
|
Caminho para o arquivo de chave privada SSH usado para autenticar com o dispositivo remoto. Se você não especificar explicitamente o caminho e nenhum valor padrão for encontrado, o módulo usará o arquivo de chave privada SSH especificado na configuração SSH do usuário ou no padrão específico do sistema operacional. |
|
|
|
Nome de usuário usado para autenticar com o nó gerenciado. |
|
Ao executar módulos da Juniper Networks, o host
argumento é sempre necessário para uma conexão. No entanto, você não precisa especificar explicitamente o host, porque ele não precisa {{ inventory_hostname }}
.
Você pode executar módulos da Juniper Networks usando qualquer conta de usuário que tenha acesso ao dispositivo Junos gerenciado. Quando você executa os módulos, os privilégios de acesso à conta de usuário do Junos OS são aplicados, e a classe configurada para a conta de usuário do Junos OS determina as permissões. Se você não especificar um usuário, o usuário será definido de acordo com o algoritmo descrito user
na Tabela 1. Consulte a documentação ansível para a precedência usada para definir remote_user
, que pode ser definida de várias maneiras, incluindo:
-
-u
ou--user
opção de linha de comando -
ANSIBLE_REMOTE_USER
variável de ambiente -
remote_user
configuração de configuração
Como definir parâmetros de autenticação nos vars: Seção para conexões locais e persistentes
Você pode definir parâmetros de conexão e autenticação para os juniper.device
módulos na seção do vars:
jogo, além de defini-los como normalmente faria por meio de outras variáveis, por exemplo, no arquivo de configuração SSH, no arquivo de inventário Ansible, como argumentos de linha de comando ou como argumentos de módulo. A vars:
seção permite que você defina parâmetros de conexão comuns em um único local que todos os módulos da peça podem usar para se conectar a um host. Além disso, certas conexões Ansible exigem usar a vars:
seção quando você define os parâmetros dentro do jogo, conforme descrito aqui.
Os juniper.device
módulos oferecem suporte aos seguintes tipos de conexões Ansible:
-
conexões locais, que são definidas usando
connection: local
-
conexões persistentes, que são definidas usando
connection: juniper.device.pyez
Para conexões locais e persistentes, a Ansible executa módulos localmente no nó de controle. Quando você usa connection: local
, o Ansible estabelece uma conexão separada com o host para cada tarefa na peça que requer uma conexão. Por outro lado, quando você usa connection: juniper.device.pyez
, Ansible estabelece uma conexão única e persistente com um host, que persiste sobre a execução de todas as tarefas na peça.
Você usa os mesmos parâmetros de conexão e autenticação para conexões persistentes que você faz para conexões locais, e os valores padrão de parâmetro discutidos na compreensão dos valores padrão para módulos da Juniper Networks se aplicam a ambos os tipos de conexões. No entanto, quando você define parâmetros de conexão e autenticação dentro de um jogo para conexões persistentes, você deve definir os parâmetros na seção em vars:
vez de definir os parâmetros como argumentos de módulo de alto nível em cada tarefa porque há apenas uma única conexão, e assim os parâmetros devem ser aplicados a todas as tarefas nesse jogo. Para conexões locais, você pode definir os parâmetros na seção ou como argumentos do vars:
módulo. Se você definir os parâmetros em ambos os lugares, os argumentos do módulo têm precedência.
O manual a seguir executa dois juniper.device
módulos em cada host do grupo de inventário. A peça define a conexão Ansible como juniper.device.pyez
, que estabelece uma conexão com cada host que persiste sobre a execução de todas as tarefas na peça. Os parâmetros de autenticação para a conexão persistente são definidos na seção do vars:
jogo. As user
variáveis de referência e passwd
valores definidas no arquivo do vault-vars.yaml
cofre.
--- - name: Get Device Facts hosts: dc1 connection: juniper.device.pyez gather_facts: no vars: user: "{{ admin_username }}" passwd: "{{ admin_password }}" vars_files: - vault-vars.yaml tasks: - name: Retrieve facts from Junos devices juniper.device.facts: savedir: "{{ playbook_dir }}" - name: Get hardware inventory juniper.device.command: commands: "show chassis hardware" dest_dir: "{{ playbook_dir }}"
Como definir o parâmetro do provedor nos módulos Juniper.junos
Juniper.junos
A partir da versão 2.0.0, os Juniper.junos
módulos oferecem suporte ao provider
parâmetro, além de oferecer suporte a argumentos individuais de módulos de alto nível para cada um dos parâmetros relacionados à conexão e à autenticação. O provider
parâmetro permite que você defina os parâmetros de conexão e autenticação para vários módulos em um só lugar e passe facilmente esses valores para os módulos que os usam. Além disso, se você precisar atualizar os parâmetros mais tarde, você só precisa fazer a atualização em um único local.
Os juniper.device
módulos de coleta não suportam o uso do provider
parâmetro.
O provider
argumento aceita um náutico que contém os detalhes de conexão necessários para se conectar e autenticar com um dispositivo. O host
argumento é sempre necessário para uma conexão, mas você não precisa especificar explicitamente um valor se o módulo usa o valor padrão para host
. O recurso pode definir opcionalmente parâmetros adicionais necessários para a conexão, incluindo user
, passwd
e ssh_private_key_file
, entre outros. Para obter informações sobre os argumentos aceitos para os módulos individuais, consulte a documentação de referência da API para esse módulo.
No exemplo a seguir, a credentials
variável é um insípede que define os parâmetros e passwd
os host
user
parâmetros:
vars: credentials: host: "{{ inventory_hostname }}" user: "{{ ansible_user }}" passwd: "{{ ansible_password }}"
O manual de amostra a seguir usa o argumento único provider
para passar os detalhes da conexão para o juniper_junos_facts
módulo em vez de definir argumentos individuais do módulo. À medida que você adiciona tarefas adicionais que usam os Juniper.junos
módulos, você pode então fazer referência ao mesmo nítor para cada módulo.
--- - name: Get Device Facts hosts: dc1 connection: local gather_facts: no roles: - Juniper.junos vars: credentials: host: "{{ inventory_hostname }}" user: "{{ ansible_user }}" passwd: "{{ ansible_password }}" tasks: - name: Retrieve facts from Junos devices juniper_junos_facts: provider: "{{ credentials }}" savedir: "{{ playbook_dir }}" - name: Print version debug: var: junos.version
Como autenticar o usuário usando chaves SSH
A Juniper Networks juniper.device
e Juniper.junos
os módulos permitem que você use chaves SSH para se conectar a um dispositivo Junos ou a um servidor de console que está conectado ao dispositivo. Para autenticar um usuário usando chaves SSH, primeiro gere as chaves no nó de controle Ansible e depois configure as chaves no dispositivo ao qual o módulo se conectará, seja o dispositivo Junos gerenciado ou o servidor do console conectado ao dispositivo Junos.
Gerar e configurar as chaves SSH
Para gerar chaves SSH no nó de controle Ansible e configurar a chave pública no dispositivo remoto:
Use as chaves SSH em ansible Playbooks
Depois de gerar o par de chave SSH e configurar a chave pública no dispositivo remoto, você pode usar a chave para se conectar ao dispositivo. Os módulos da Juniper Networks consultam automaticamente o arquivo de configuração SSH padrão em ~/.ssh/config, se um existir, a menos que você defina a opção ssh_config
de especificar um arquivo de configuração diferente. Os módulos usam quaisquer configurações relevantes no arquivo de configuração SSH para a determinada conexão, a menos que você defina explicitamente variáveis que sobrepõem a configuração. Além disso, os módulos procuram automaticamente as chaves no local padrão e nas chaves que são carregadas ativamente em um agente chave SSH.
Para definir configurações específicas para chaves SSH, você pode incluir os argumentos apropriados em sua cartilha Ansible. Defina os argumentos no local apropriado para o seu conjunto de módulos e conexão Ansible, por exemplo, na vars:
seção para jogadas que usam os juniper.device
módulos com uma conexão persistente. Os argumentos a incluir são determinados pela localização da chave, se a chave está ativamente carregada em um agente-chave SSH, se a chave é protegida por senha e se o arquivo de configuração SSH do usuário já define as configurações para esse host.
-
Para se conectar a um dispositivo Junos usando chaves SSH que são ativamente carregadas no agente-chave SSH nativo ou que estão no local padrão e não têm proteção de senha, você não precisa definir nenhuma conexão ou argumentos relacionados à autenticação, a menos que eles diferem do padrão.
juniper.device.facts: savedir: "{{ playbook_dir }}"
-
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, defina o
ssh_private_key_file
argumento para o caminho do arquivo chave privado SSH. Por exemplo:juniper.device.facts: ssh_private_key_file: "/home/user/.ssh/id_rsa_alternate" savedir: "{{ playbook_dir }}"
Como alternativa, você pode especificar o caminho da chave privada SSH definindo-a no arquivo de configuração SSH; configurando a variável do
ANSIBLE_NET_SSH_KEYFILE
ambiente; ou definindo a opção--private-key
de linha de comando quando--key-file
você executa o manual. -
Para se conectar a um dispositivo Junos usando um arquivo chave SSH protegido por senha, que é o método recomendado, você pode consultar a senha de arquivo chave SSH no
passwd
argumento ou fornecer a senha usando variáveis Ansible normais ou opções de linha de comando.É responsabilidade do usuário obter a senha de arquivo chave SSH de forma segura e apropriada para o ambiente. É a melhor prática solicitar isso durante cada invocação do manual ou armazenar as variáveis usando um cofre criptografado em vez de armazenar as credenciais em um formato não criptografado. Por exemplo, você pode executar o manual com a opção
--ask-pass
de linha de comando e fornecer a senha de arquivo chave SSH quando solicitado, conforme mostrado aqui:juniper.device.facts: ssh_private_key_file: "/home/user/.ssh/id_rsa_dc" savedir: "{{ playbook_dir }}"
[user@localhost]$ ansible-playbook playbook.yaml --ask-pass SSH password:
Para obter mais informações sobre o uso de um arquivo de cofre pronto ou criptografado para a senha da chave SSH, veja como autenticar o usuário usando um prompt de playbook ou senha de linha de comando e como autenticar o usuário usando um arquivo criptografado com cofre ansível.
Para obter instruções sobre como usar as chaves SSH para se conectar a um servidor de console, veja Como autenticar através de um servidor de console.
Como autenticar o usuário usando um guia de jogadas ou solicitação de senha de linha de comando
Para autenticar um usuário que executa módulos Ansible, você pode solicitar as credenciais do usuário ao executar o manual. Por exemplo, você pode definir um prompt interativo no manual, ou pode executar o manual com a opção -k
ou --ask-pass
linha de comando para solicitar a senha. Quando as chaves SSH estão em uso, a senha fornecida é usada como senha para desbloquear a chave SSH privada. Quando a autenticação baseada em senha é usada, a senha fornecida é usada como senha do dispositivo.
Para definir um prompt interativo no manual de jogadas para obter a senha do usuário ou senha chave SSH:
Como alternativa, você pode executar uma cartilha com a opção -k
de linha de comando ou --ask-pass
solicitação de senha ou senha. Considere o manual a seguir, que usa o nome de usuário padrão:
--- - name: Get Device Facts hosts: all connection: local gather_facts: no tasks: - name: Retrieve facts from Junos devices juniper.device.facts: savedir: "{{ playbook_dir }}" - name: Print facts debug: var: junos.version
Execute o manual e inclua a opção -k
de linha de --ask-pass
comando, que solicita a senha e não ecoa a senha na linha de comando.
[user@localhost]$ ansible-playbook playbook.yaml --ask-pass SSH password: PLAY [Get Device Facts] *********************************************** ...
Como autenticar o usuário usando um arquivo criptografado por cofres ansible
Você pode criar um cofre Ansible que armazena com segurança senhas salvas e outros valores sensíveis de conexão e autenticação em um arquivo de dados criptografado com cofre. Seu manual de jogadas pode então fazer referência a essas variáveis no local apropriado para o seu conjunto de módulos e tipo de conexão Ansible, por exemplo, na seção da peça ou como argumentos de vars:
módulo.
Para criar e usar um arquivo de cofre Ansible contendo variáveis necessárias, incluindo senhas:
Como autenticar através de um servidor de console
Os módulos Ansible da Juniper Networks podem se conectar aos dispositivos Junos por meio de um servidor de console. Para conexões SSH por meio de um servidor de console, você precisa fornecer as credenciais de autenticação tanto para o servidor do console quanto para o dispositivo Junos. Você pode fornecer uma senha de dispositivo ou um arquivo chave SSH protegido por senha para a autenticação do servidor do console.
Para se conectar a um dispositivo Junos por meio de um servidor de console, você deve fornecer os seguintes parâmetros em sua cartilha, se não houver valor padrão ou o valor padrão não for apropriado:
-
host
— Nome de host do servidor do console ou endereço IP -
user
epasswd
— credenciais de login do Junos OS -
cs_user
— Nome de usuário do servidor de console -
cs_passwd
— Senha do dispositivo ou senha de arquivo chave SSH necessária para autenticar com o servidor do console
No exemplo a seguir, as credenciais para o usuário do Junos OS e o usuário do servidor do console são definidas em um arquivo de cofre Ansible. As variáveis do cofre são então mencionadas no manual de jogadas. Neste caso, o cs_passwd
argumento é a senha para a chave SSH especificada no ssh_private_key_file
argumento.
--- - name: Get Device Facts hosts: dc1_con connection: local gather_facts: no vars_files: - vault-vars.yaml vars: host: "{{ inventory_hostname }}" user: "{{ junos_username }}" passwd: "{{ junos_password }}" cs_user: "{{ cs_username }}" cs_passwd: "{{ cs_key_password }}" ssh_private_key_file: "/home/user/.ssh/id_rsa_dc" tasks: - name: Retrieve facts from Junos devices juniper.device.facts: savedir: "{{ playbook_dir }}"