Entender o Ansible para coleções e módulos do Junos OS

Entender as coleções e os módulos do Ansible para o gerenciamento de dispositivos Junos

O Ansible é uma estrutura de automação de TI que você pode usar para o gerenciamento de configuração de infraestrutura. Você usa módulos do Ansible, que são unidades discretas de código, para executar funções específicas em um nó gerenciado. Você pode executar módulos individuais em hosts remotos para executar tarefas ad hoc. Você também pode executar módulos por meio de playbooks.

A Juniper Networks oferece módulos Ansible que você pode usar para gerenciar dispositivos Junos. Os módulos do Ansible são agrupados e distribuídos por meio do Ansible Content Collections, que são hospedados no repositório do Ansible Galaxy . As coleções do Ansible são um formato para distribuir conteúdo do Ansible que não está incluído como parte da instalação principal do Ansible. As coleções podem incluir uma ampla variedade de conteúdo, incluindo módulos, manuais, plug-ins e funções. As coleções também têm seus próprios repositórios, para que possam ser desenvolvidas e lançadas independentemente da instalação principal do Ansible.

A Tabela 1 descreve os conjuntos de conteúdo disponíveis para gerenciar dispositivos Junos. A Juniper Networks fornece a juniper.device coleção. A partir da juniper.device versão 2.0.0, consolidamos a coleção da Juniper Networks juniper.device e a coleção do Red Hat Ansible junipernetworks.junos em uma única coleção contendo os dois conjuntos de módulos.

Tabela 1: Conjuntos de conteúdo do Ansible para gerenciamento de dispositivos Junos
Coleção de Emoji	Conjunto de módulos	Descrição
`juniper.device`	`juniper.device`	Módulos para gerenciamento de dispositivos Junos. A Juniper Networks oferece e gerencia essa coleção como um projeto de código aberto.
`juniper.device`	`junipernetworks.junos` (`juniper.device.junos_*`)	Módulos para gerenciamento de dispositivos Junos. A equipe do Red Hat Ansible Networking originalmente mantinha essa coleção. Na `juniper.device` versão 2.0.0, mesclamos os módulos na `juniper.device` coleção. A Juniper Networks mantém esses módulos daqui para frente. Você pode identificar esses módulos pelo nome do módulo, que começa com `junos_`.

Noções básicas sobre a coleção mesclada `juniper.device`

Visão geral da mesclagem
Comparação do conjunto de módulos

Visão geral da mesclagem

Antes da juniper.device versão 2.0.0, a coleção da Juniper Networks juniper.device e a coleção do Red Hat Ansible junipernetworks.junos eram coleções distintas e separadas. Cada proprietário de coleção manteve sua respectiva coleção. A partir da juniper.device versão 2.0.0, mesclamos a junipernetworks.junos juniper.device coleção na coleção. A Juniper Networks mantém a coleção resultante da fusão daqui para frente.

Vamos nos referir à juniper.device coleção para indicar o conjunto combinado de módulos. Para distinguir entre os conjuntos de módulos dentro da coleção, vamos nos referir aos módulos da seguinte maneira:

juniper.device módulos ou juniper.device módulos originais
junipernetworks.junos módulos ou juniper.device.junos_* módulos

Ao instalar a juniper.device coleção, você pode usá-la juniper.device.module_name para executar módulos de qualquer conjunto de módulos. Para continuar usando os manuais existentes que fazem referência ao junipernetworks.junos.module_name, você também deve instalar a junipernetworks.junos coleção. Para executar os módulos usando qualquer um dos junipernetworks.junos namespaces, você deve definir ansible_network_os como juniper.device.junos. Caso contrário, todo o resto permanece o mesmo ao usar qualquer um dos conjuntos de módulos.

Embora a juniper.device coleção inclua os dois conjuntos de módulos, cada conjunto de módulos usa diferentes valores de conexão do Ansible e valores de sistema operacional de rede. Como resultado, os dois conjuntos de módulos não podem usar o mesmo arquivo de inventário e você não pode misturar os conjuntos de módulos no mesmo manual. Portanto, recomendamos que você selecione um conjunto de módulos para usar em seus manuais estratégicos e tarefas. O conjunto que você seleciona é uma questão de preferência. Para ajudá-lo a determinar qual conjunto de módulos funciona melhor para o seu ambiente, fornecemos uma visão geral de alto nível e uma comparação dos dois conjuntos.

Comparação do conjunto de módulos

A juniper.device coleção e a junipernetworks.junos coleção foram originalmente construídas para diferentes propósitos e casos de uso. A Juniper Networks projetou os módulos para fornecer aos juniper.device usuários acesso direto a toda a gama de recursos do Junos OS. A Red Hat desenvolveu os junipernetworks.junos módulos usando uma abordagem consistente aplicada a todas as coleções de redes mantidas pela Red Hat. Essa abordagem forneceu configurações modeladas para gerenciamento de configuração simplificado e repetível.

Além de algumas diferenças distintas, tanto os módulos quanto os juniper.device junipernetworks.junos módulos oferecem funções semelhantes para o gerenciamento de dispositivos Junos. Ambos os conjuntos de módulos permitem:

Obtenha informações sobre o dispositivo
Executar comandos e RPCs em um dispositivo
Instalar pacotes de software
Executar operações de ping de um dispositivo
Configurar um dispositivo

Ambos os conjuntos de módulos fornecem opções semelhantes para configurar dispositivos. Por exemplo, você pode:

Carregar dados de configuração em um dos formatos aceitos de um arquivo
Carregue os dados de configuração como set comandos fornecidos nos argumentos do módulo
Reverta a configuração
Substitua toda a configuração
Especificar o formato e a operação de carregamento para carregar dados de configuração
Confirme a configuração e inclua opções de confirmação comuns

Os conjuntos de módulos também têm algumas diferenças em relação às operações de configuração. Os junipernetworks.junos módulos fornecem vários modelos de configuração que permitem configurar facilmente declarações comuns para áreas específicas da hierarquia de configuração. Por exemplo, você pode configurar opções comuns para OSPF ou rotas estáticas.

Da mesma forma, os juniper.device módulos fornecem alguns recursos de configuração adicionais. Você pode comparar configurações, carregar a configuração de resgate e carregar dados de configuração usando um modelo Jinja2. Você também pode selecionar o modo de configuração. Por exemplo, você pode usar o modo de lote; configurar uma cópia privada da configuração do candidato; ou configurar o banco de dados dinâmico ou efêmero. Os juniper.device módulos também fornecem opções de confirmação adicionais para sincronizar a configuração, confirmar alterações vazias e ignorar avisos de confirmação.

Outra diferença importante entre os conjuntos de módulos é que eles se integram juniper.device a vários outros produtos da Juniper Networks. Por exemplo, seus playbooks do Ansible podem fazer referência a tabelas operacionais do Junos PyEZ para recuperar dados de estado operacional de um dispositivo. Os playbooks do Ansible também podem realizar operações do Junos Snapshot Administrator em Python (JSNAPy). O JSNAPy permite que você capture e audite instantâneos do ambiente de tempo de execução de seus dispositivos Junos. Assim, você pode usar suas tabelas do Junos PyEZ existentes e arquivos de configuração e teste JSNAPy em seus playbooks do Ansible.

Como executar módulos em dispositivos Junos

Para usar coleções hospedadas no repositório do Ansible Galaxy, você deve primeiro instalar o Ansible no nó de controle e, em seguida, instalar a coleção. Para obter mais informações sobre como instalar a juniper.device coleção, consulte Requisitos do servidor Ansible for Junos OS.

Os módulos do Ansible podem realizar operações em um nó gerenciado. Normalmente, o nó de controle do Ansible envia um módulo para o nó gerenciado para executar a operação. O nó executa o módulo e o remove. Nesse cenário, o nó gerenciado deve ter a capacidade de executar o módulo. Como a maioria dos módulos do Ansible são escritos em Python, o Ansible normalmente requer Python no nó gerenciado.

Os módulos na juniper.device coleção, no entanto, não exigem Python nos nós gerenciados. Em contraste com a operação típica, o nó de controle do Ansible executa os módulos localmente. Os módulos usam a API XML do Junos e o NETCONF para fazer interface com o nó gerenciado. Esse método de execução permite que você use o Ansible para gerenciar qualquer dispositivo Junos compatível. A Figura 1 ilustra a comunicação entre o nó de controle do Ansible e um dispositivo Junos gerenciado.

Figura 1: Comunicação do Ansible com um dispositivo Ansible Communication with a Junos Device

Junos

Para usar os juniper.device módulos ou os junipernetworks.junos módulos, seu playbook ou comando do Ansible deve:

Especificar a coleção ou FQCN — Para especificar a coleção, inclua a collections chave na reprodução. Como alternativa, você pode omitir a chave e, em vez disso, referenciar o conteúdo da collections coleção por seu nome de coleção totalmente qualificado (FQCN), que é o método recomendado.

Execute os módulos localmente no nó de controle — Para executar módulos do Ansible localmente, defina os parâmetros de conexão apropriados em seu playbook, arquivo de inventário ou opções de comando. Defina o connection parâmetro no manual ou defina o ansible_connection parâmetro no arquivo de inventário ou nos arquivos de variável de host ou grupo. Para os junipernetworks.junos módulos, você também deve especificar o ansible_network_os parâmetro. Geralmente, esse parâmetro é definido no file de inventário. A Tabela 2 descreve os valores suportados.

Tabela 2: Parâmetros de conexão
Conjunto de módulos	Manual	Arquivo de inventário
`juniper.device` (módulos originais)	`connection: (local \| juniper.device.pyez)`	`ansible_connection=(local \| juniper.device.pyez)`
`junipernetworks.junos` (todos os `junos_*` módulos, exceto `junos_netconf` e `junos_ping`)	`connection: netconf`	`ansible_connection=netconf` `ansible_network_os=juniper.device.junos`
`junipernetworks.junos` `junos_netconf`( e `junos_ping`)	`connection: network_cli`	`ansible_connection=network_cli` `ansible_network_os=juniper.device.junos`

Forneça informações de conexão e autenticação apropriadas para se conectar ao dispositivo gerenciado.

Você pode executar módulos do Ansible usando qualquer conta de usuário que tenha acesso ao dispositivo Junos gerenciado. Quando você executa módulos do Ansible, os privilégios de acesso à conta de usuário do Junos OS são aplicados. A classe configurada para a conta de usuário do Junos OS determina as permissões. Assim, se um usuário executar um módulo que carrega alterações de configuração em um dispositivo, o usuário deverá ter permissões para alterar as partes relevantes da configuração.

As seções a seguir fornecem alguns manuais de exemplo e arquivos de inventário para os diferentes conjuntos de módulos.

Exemplo de manual para juniper.device módulos
Exemplo de arquivo de inventário e manual para junipernetworks.junos módulos

Exemplo de manual de estratégia para módulos juniper.device

O guia estratégico a seguir executa o juniper.device.facts módulo para recuperar os fatos do dispositivo e salvá-los em um arquivo. Neste exemplo, definimos o tipo de conexão no manual em vez do arquivo de inventário. O usuário é autenticado com o dispositivo usando chaves SSH carregadas em um agente de chave SSH.

Você também pode executar operações ad hoc na linha de comando. O comando a seguir executa o juniper.device.facts módulo e recupera os fatos do dispositivo dos hosts no grupo junosde inventário.

Exemplo de arquivo de inventário e manual para módulos junipernetworks.junos

Se você estiver usando o junipernetworks.junos conjunto de módulos, poderá definir as ansible_connection variáveis e ansible_network_os em seu arquivo de inventário ou em seus arquivos de variáveis de host ou grupo. O arquivo de inventário de exemplo a seguir define os parâmetros de conexão para o grupo dc1 em dc1:vars.

O guia estratégico a juniper.device seguir executa o junipernetworks.junos.junos_facts módulo no namespace. O playbook faz referência ao dc1 grupo, que define os valores apropriados de conexão e sistema operacional de rede no arquivo de inventário.

Módulos juniper.device

A Tabela 3 descreve os módulos originais juniper.device da juniper.device coleção. Para obter a lista de módulos atual, a documentação e os exemplos de uso dos módulos, consulte https://ansible-juniper-collection.readthedocs.io.

Tabela 3: `juniper.device` Módulos
Nome do módulo	Descrição	Conexões Ansible compatíveis
`command`	Execute comandos de modo operacional no dispositivo Junos e salve a saída localmente.	`local` `juniper.device.pyez`
`config`	Gerencie a configuração de dispositivos Junos.	`local` `juniper.device.pyez`
`facts`	Recupere informações específicas do dispositivo do host remoto, incluindo a versão do Junos OS, o número de série e o número do modelo do hardware.	`local` `juniper.device.pyez`
`file_copy`	Transfira um arquivo entre o nó de controle local do Ansible e o dispositivo Junos.	`local` `juniper.device.pyez`
`jsnapy`	Execute o Junos Snapshot Administrator em testes Python (JSNAPy) através do Ansible.	`local` `juniper.device.pyez`
`ping`	Execute o `ping` comando a partir de um dispositivo Junos.	`local` `juniper.device.pyez`
`pmtud`	Execute a descoberta de MTU de caminho (PMTUD) em dispositivos Junos.	`local` `juniper.device.pyez`
`rpc`	Execute RPCs do Junos OS.	`local` `juniper.device.pyez`
`software`	Instale um pacote de software e reinicie um dispositivo Junos.	`local` `juniper.device.pyez`
`srx_cluster`	Crie um cluster de chassi da Série SRX para firewalls da Série SRX com capacidade de cluster.	`local` `juniper.device.pyez`
`system`	Realizar operações do sistema em dispositivos Junos, incluindo redefinir, reiniciar ou desligar o dispositivo.	`local` `juniper.device.pyez`
`table`	Use as tabelas e visualizações operacionais do Junos PyEZ para recuperar informações operacionais dos dispositivos Junos.	`local` `juniper.device.pyez`

`junipernetworks.junos` Módulos

A partir da juniper.device versão 2.0.0, a juniper.device coleção inclui os junipernetworks.junos módulos. A Tabela 4 descreve os junipernetworks.junos módulos da juniper.device coleção. O conjunto de módulos permite que você execute tarefas operacionais. Ele também inclui muitos módulos de modelo de configuração que definem configurações comuns para vários recursos, protocolos e serviços em dispositivos Junos.

Tabela 4: `junipernetworks.junos` Módulos
Nome do módulo	Descrição	Conexões Ansible compatíveis
Módulos operacionais
`junos_command`	Execute comandos do modo operacional no dispositivo Junos.	`ansible.netcommon.netconf` `ansible.netcommon.network_cli`
`junos_facts`	Recupere informações específicas do dispositivo do host remoto.	`ansible.netcommon.netconf`
`junos_package`	Instale um pacote de software e reinicie um dispositivo Junos.	`ansible.netcommon.netconf`
`junos_ping`	Execute o `ping` comando a partir de um dispositivo Junos.	`ansible.netcommon.network_cli`
`junos_rpc`	Execute RPCs do Junos OS sobre NETCONF em um dispositivo Junos.	`ansible.netcommon.netconf`
Módulos de configuração
`junos_acl_interfaces`	Aplicar filtros de firewall em uma interface.	`ansible.netcommon.netconf`
`junos_acls`	Configure filtros de firewall, às vezes chamados de listas de controle de acesso (ACLs).	`ansible.netcommon.netconf`
`junos_banner`	Configure banners.	`ansible.netcommon.netconf`
`junos_bgp_address_family`	Gerencie os atributos da família de endereços BGP das interfaces.	`ansible.netcommon.netconf`
`junos_bgp_global`	Configure as propriedades globais do BGP.	`ansible.netcommon.netconf`
`junos_config`	Gerencie a configuração de dispositivos Junos.	`ansible.netcommon.netconf`
`junos_hostname`	Configure o nome do host do dispositivo.	`ansible.netcommon.netconf`
`junos_interfaces`	Configure as propriedades básicas da interface física e lógica.	`ansible.netcommon.netconf`
`junos_l2_interfaces`	Configure interfaces L2.	`ansible.netcommon.netconf`
`junos_l3_interfaces`	Configure interfaces L3.	`ansible.netcommon.netconf`
`junos_lacp`	Configure as propriedades globais do Link Aggregation Control Protocol (LACP) para interfaces Ethernet agregadas.	`ansible.netcommon.netconf`
`junos_lacp_interfaces`	Gerencie os atributos LACP de uma interface.	`ansible.netcommon.netconf`
`junos_lag_interfaces`	Configure grupos de agregação de enlaces (LAGs).	`ansible.netcommon.netconf`
`junos_lldp_global`	Defina as configurações globais para o LLDP (Link Layer Discovery Protocol).	`ansible.netcommon.netconf`
`junos_lldp_interfaces`	Gerencie os atributos LLDP de uma interface.	`ansible.netcommon.netconf`
`junos_logging_global`	Configure o log do sistema.	`ansible.netcommon.netconf`
`junos_netconf`	Configure o serviço do sistema NETCONF.	`ansible.netcommon.network_cli`
`junos_ntp_global`	Configure o Network Time Protocol (NTP).	`ansible.netcommon.netconf`
`junos_ospf_interfaces`	Gerencie a configuração OSPF de interfaces.	`ansible.netcommon.netconf`
`junos_ospfv2`	Configure OSPFv2.	`ansible.netcommon.netconf`
`junos_ospfv3`	Configure OSPFv3.	`ansible.netcommon.netconf`
`junos_prefix_lists`	Configure listas de prefixos de política de roteamento.	`ansible.netcommon.netconf`
`junos_routing_instances`	Configure instâncias de roteamento.	`ansible.netcommon.netconf`
`junos_routing_options`	Configure as opções de roteamento.	`ansible.netcommon.netconf`
`junos_security_policies`	Configurar e gerenciar políticas de segurança.	`ansible.netcommon.netconf`
`junos_security_policies_global`	Defina as configurações da política de segurança global.	`ansible.netcommon.netconf`
`junos_security_zones`	Configure zonas de segurança.	`ansible.netcommon.netconf`
`junos_snmp_server`	Gerencie a configuração do servidor SNMP.	`ansible.netcommon.netconf`
`junos_static_routes`	Configure rotas estáticas.	`ansible.netcommon.netconf`
`junos_system`	Gerencie o nome do host e a configuração de DNS.	`ansible.netcommon.netconf`
`junos_user`	Configure contas de usuário locais.	`ansible.netcommon.netconf`
`junos_vlans`	Configurar VLANs.	`ansible.netcommon.netconf`
`junos_vrf`	Gerencie as definições de VRF no dispositivo.	`ansible.netcommon.netconf`

NESTA PÁGINA