Conecte-se a dispositivos Junos usando Ansible
RESUMO Os módulos Ansible da Juniper Networks permitem que você se conecte a dispositivos Junos usando conexões SSH, telnet ou console serial.
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. Os módulos podem se conectar a dispositivos Junos usando diferentes protocolos e conexões Ansible, que são descritas neste documento.
Visão geral dos métodos de conexão
Os juniper.device
módulos de coleta permitem que você se conecte a um dispositivo Junos usando SSH, telnet ou uma conexão de console serial. Você deve usar uma conexão de console serial quando seu terminal ou laptop estiver fisicamente conectado à porta CONSOLE em um dispositivo Junos. Você pode usar SSH ou telnet para se conectar à interface de gerenciamento do dispositivo ou a um servidor de console que está diretamente conectado à porta CONSOLE do dispositivo.
Dispositivos novos ou zeroizados que tenham configurações padrão de fábrica exigem acesso por meio de uma conexão de console. Assim, você pode usar o Ansible para configurar inicialmente um dispositivo que ainda não está configurado para acesso remoto usando uma conexão de console serial quando você está diretamente conectado ao dispositivo ou usando telnet ou SSH através de um servidor de console que está diretamente conectado ao dispositivo.
Por padrão, os juniper.device
módulos usam SSH para se conectar a um dispositivo. Para usar a telnet ou uma conexão de console serial, defina o mode
parâmetro para o valor apropriado. Para telenet em um dispositivo, definir o mode
argumento igual a "telnet"
. Para usar uma conexão de console serial, definir o mode
argumento igual a "serial"
. A Tabela 1 resume os modos de conexão, seus valores padrão para determinados parâmetros e qualquer configuração necessária do Junos OS. Os juniper.device
módulos oferecem suporte a todos os modos de conexão desde a versão inicial.
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 em série |
|
/dev/ttyUSB0 |
– |
SSH por meio de um servidor de console |
– |
22 |
– |
Dispositivo Telnet para Junos |
|
23 |
[edit system services] telnet; |
Telnet através de um servidor de console |
|
23 |
– |
Antes de poder acessar a interface de gerenciamento usando telnet ou NETCONF sobre SSH, você deve primeiro habilitar o serviço apropriado no nível hierárquico [edit system services]
. Como a telnet usa senhas de texto claro (portanto, criando uma vulnerabilidade de segurança em potencial), recomendamos que você use SSH.
Quando você executa os juniper.device
módulos para gerenciar um dispositivo Junos, o dispositivo remoto deve ser capaz de autenticar o usuário Ansible usando credenciais apropriadas para o protocolo determinado. Para obter mais informações, veja Authenticate Users Executing Ansible Modules on Junos Devices.
Os juniper.device
módulos oferecem suporte a diferentes conexões Ansible ao se conectar a dispositivos Junos, incluindo conexões locais (por tarefa) e conexões persistentes (por jogo). A conexão Ansible determina se a Ansible estabelece uma conexão separada com o host para cada tarefa na peça ou se ela estabelece uma única conexão com um host que persiste em todas as tarefas da peça. Para obter informações sobre como especificar a conexão Ansible, consulte Entendendo conexões ansíveis locais e persistentes.
Entendendo conexões locais e persistentes de ansible
Os módulos Ansible da Juniper Networks não exigem Python em dispositivos Junos porque eles usam o Junos PyEZ e a API Junos XML sobre NETCONF para interface com o dispositivo. Portanto, para realizar operações em dispositivos Junos, você deve executar módulos localmente no nó de controle Ansible, onde o Python está instalado. Você pode executar os módulos localmente, incluindo connection: local
no playbook. Quando você usa connection: local
, o Ansible estabelece uma conexão separada com o host para cada tarefa na peça que realiza operações no host.
Os juniper.device
módulos de coleta também oferecem suporte connection: juniper.device.pyez
para estabelecer uma conexão persistente com um host. Quando você usa uma conexão persistente, a Ansible ainda executa os módulos localmente no nó de controle, mas ele só estabelece e mantém uma única conexão com cada host, que persiste sobre a execução de todas as tarefas em jogo. Estabelecer uma conexão persistente com um host pode ser mais eficiente para executar várias tarefas do que estabelecer uma conexão separada com o host para cada tarefa na peça.
A Tabela 2 resume as conexões Ansible e os conjuntos de conteúdo que as suportam.
Conexão ansível |
Descrição |
Suporte para o conjunto de conteúdo |
---|---|---|
|
Execute os módulos localmente no nó de controle Ansible, mas estabeleça uma conexão separada com um host para cada tarefa na peça que realiza operações no host. |
|
|
Execute os módulos localmente no nó de controle Ansible, mas estabeleça uma conexão persistente com um host que persiste sobre a execução de todas as tarefas em jogo. |
|
Quando você usa connection: local
, o Ansible estabelece uma conexão separada com um host para cada módulo, o que significa que você pode definir parâmetros de conexão e autenticação específicos do módulo na lista de argumentos do módulo. Por outro lado, quando você usa connection: juniper.device.pyez
, a conexão persiste em todas as tarefas em jogo e, portanto, você deve definir os parâmetros de conexão e autenticação globalmente para todos os módulos. Você pode definir os parâmetros na vars:
seção de um jogo, além de fornecê-los por outros meios, por exemplo, em um arquivo de configuração SSH ou no arquivo de inventário Ansible. Para obter mais detalhes, veja Authenticate Users Executing Ansible Modules on Junos Devices.
O manual a seguir estabelece uma conexão persistente com cada host que é usada para todas as tarefas da peça. As credenciais do usuário, armazenadas em um arquivo de cofre Ansible, são definidas na seção da vars:
jogada.
--- - name: Get Device Information hosts: dc1 connection: juniper.device.pyez gather_facts: no vars: host: "{{ inventory_hostname }}" 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 }}"
Conecte-se a um dispositivo usando SSH
Os módulos Ansible da Juniper Networks suportam o uso de SSH para se conectar a um dispositivo Junos. Você pode estabelecer uma sessão netconf sobre SSH na interface de gerenciamento do dispositivo ou estabelecer uma conexão SSH com um servidor de console que está diretamente conectado à porta CONSOLE do dispositivo. O servidor SSH deve ser capaz de autenticar o usuário usando mecanismos padrão de autenticação de SSH, conforme descrito no Authenticate Users Executing Ansible Modules on Junos Devices. Para estabelecer uma sessão de NETCONF sobre SSH, você também deve satisfazer os requisitos descritos na Configuração de Nós gerenciados do Junos OS para o Junos.
Os módulos da Juniper Networks consultam automaticamente o arquivo de configuração SSH padrão em ~/.ssh/config, se houver um. Você também pode incluir o ssh_config
parâmetro para especificar um arquivo de configuração diferente.
Ao usar o SSH para se conectar a um dispositivo Junos ou a um servidor de console conectado ao dispositivo, os módulos primeiro tentam a autenticação pública baseada em chave SSH e depois tentam a autenticação baseada em senha. Quando a autenticação baseada em senha é usada, a senha fornecida é usada como senha do dispositivo. Quando as chaves SSH estão em uso, a senha fornecida é usada como senha para desbloquear a chave privada. Se a chave privada SSH tiver uma senha vazia, uma senha não será necessária. No entanto, não recomendamos usar chaves privadas SSH com senhas vazias.
O manual a seguir estabelece uma sessão netconf sobre SSH com um dispositivo Junos e recupera os fatos do dispositivo. A cartilha usa chaves SSH no local padrão.
--- - name: Get Device Facts hosts: dc1 connection: local gather_facts: no tasks: - name: Retrieve facts from Junos devices juniper.device.facts: savedir: "{{ playbook_dir }}" - name: Print version ansible.builtin.debug: var: junos.version
Os módulos Ansible da Juniper Networks também permitem que você se conecte a um dispositivo Junos através de uma conexão SSH com um servidor de console. Neste caso, você deve especificar as credenciais de login tanto para o dispositivo Junos quanto para o servidor do console. Você usa o e passwd
os user
parâmetros para especificar as credenciais de login do Junos OS, e usa os cs_user
parâmetros e especifique cs_passwd
as credenciais do servidor do console. Quando as chaves SSH estão em uso, cs_passwd
é a senha para a chave privada.
O manual a seguir solicita as credenciais do usuário para o servidor do console e o dispositivo Junos. O módulo autentica com o servidor do console e depois com o dispositivo Junos. Se a autenticação for bem sucedida, o manual de jogadas então recupera os fatos do dispositivo a partir do nó gerenciado e imprime a versão do Junos OS.
--- - name: Get Device Facts hosts: dc1_con connection: local gather_facts: no vars_prompt: - name: "CS_USER" prompt: "Console server username" private: no - name: "CS_PASSWORD" prompt: "Console server password" private: yes - name: "JUNOS_USER" prompt: "Junos OS username" private: no - name: "JUNOS_PASSWORD" prompt: "Junos OS password" private: yes vars: cs_user: "{{ CS_USER }}" cs_passwd: "{{ CS_PASSWORD }}" user: "{{ JUNOS_USER }}" passwd: "{{ JUNOS_PASSWORD }}" tasks: - name: "Retrieve facts from Junos devices" juniper.device.facts: savedir: "{{ playbook_dir }}" - name: Print version ansible.builtin.debug: var: junos.version
Os módulos da Juniper Networks consultam automaticamente o arquivo de configuração padrão do cliente SSH em ~/.ssh/config, se ele existir. Você pode usar um arquivo de configuração SSH diferente, incluindo o ssh_config
parâmetro e especificando a localização do arquivo de configuração. Por exemplo:
--- - name: Get Device Facts hosts: dc1 connection: local gather_facts: no vars: ssh_config: "/home/admin/.ssh/config_dc" tasks: - name: "Retrieve facts from Junos devices" juniper.device.facts: savedir: "{{ playbook_dir }}" - name: Print version ansible.builtin.debug: var: junos.version
Conecte-se a um dispositivo usando a Telnet
Os módulos da Juniper Networks permitem que você se conecte a um dispositivo Junos usando a telnet, que fornece acesso não criptografado ao dispositivo de rede. Você pode telenet para a interface de gerenciamento do dispositivo ou para um servidor de console que está diretamente conectado à porta CONSOLE do dispositivo. O acesso ao dispositivo por meio de um servidor de console permite que você configure inicialmente um dispositivo novo ou zeroizado que ainda não esteja configurado para acesso remoto. Para colocar a telnet na interface de gerenciamento, você deve configurar o serviço Telnet no nível de [edit system services]
hierarquia em todos os dispositivos que exigem acesso à interface.
Para colocar a telnet no dispositivo remoto, defina o mode
parâmetro "telnet"
e inclua opcionalmente o port
parâmetro para especificar uma porta. Quando você define mode
, "telnet"
mas omite o port
parâmetro, o valor para port
padrões é de 23. Para conexões persistentes, definir mode
e port
embaixo da vars:
seção. Para conexões locais, você pode definir os parâmetros sob a seção ou como argumentos do vars:
módulo.
O manual a seguir é exibido em um dispositivo Junos usando a porta 7016, recupera os fatos do dispositivo e os salva em um arquivo. O manual solicita o nome do usuário e a senha.
--- - name: Get Device Facts hosts: dc1 connection: local gather_facts: no vars_prompt: - name: "DEVICE_USERNAME" prompt: "Device username" private: no - name: "DEVICE_PASSWORD" prompt: "Device password" private: yes vars: user: "{{ DEVICE_USERNAME }}" passwd: "{{ DEVICE_PASSWORD }}" mode: "telnet" port: "7016" tasks: - name: Retrieve facts from Junos devices juniper.device.facts: savedir: "{{ playbook_dir }}" - name: Print version ansible.builtin.debug: var: junos.version
Conecte-se a um dispositivo usando uma conexão de console serial
Os módulos da Juniper Networks permitem que você se conecte a um dispositivo Junos usando uma conexão de console serial, que é útil quando você deve configurar inicialmente um dispositivo novo ou zeroizado que ainda não está configurado para acesso remoto. Para usar esse método de conexão, seu terminal ou laptop deve estar fisicamente conectado ao dispositivo Junos por meio da porta CONSOLE . Para obter instruções detalhadas sobre a conexão à porta CONSOLE em um dispositivo Junos, veja a documentação de hardware do seu dispositivo específico.
Para se conectar a um dispositivo Junos por uma conexão de console serial, defina o parâmetro "serial"
do mode
módulo e inclua opcionalmente o port
parâmetro para especificar uma porta. Quando você definemode
, "serial"
mas omite o port
parâmetro, o valor para port
padrões é /dev/ttyUSB0
. Para conexões persistentes, definir mode
e port
embaixo da vars:
seção. Para conexões locais, você pode definir os parâmetros sob a seção ou como argumentos do vars:
módulo.
O manual a seguir se conecta a um dispositivo Junos pela porta CONSOLE e depois carrega e confirma uma configuração inicial. O manual solicita o nome do usuário e a senha.
--- - name: Load Initial Configuration hosts: dc1 connection: local gather_facts: no vars_prompt: - name: "DEVICE_USERNAME" prompt: "Device username" private: no - name: "DEVICE_PASSWORD" prompt: "Device password" private: yes tasks: - name: Load initial configuration and commit juniper.device.config: user: "{{ DEVICE_USERNAME }}" passwd: "{{ DEVICE_PASSWORD }}" mode: "serial" load: "merge" src: "configs/junos.conf" register: response - name: Print the response ansible.builtin.debug: var: response