Network Automation with Red Hat Ansible Automation Platform

Use network resource modules by setting the module state. Resource modules support the following states:

For more details on resource modules and states, visit https://docs.ansible.com/ansible/latest/network/user_guide/network_resource_modules.html.

Network resource modules return a data structure that can be registered into a variable, or displayed in the task output.

Resource modules all support the same return values, regardless of the network OS. This makes it easy to automate consistently across network platforms.

Resource modules support the following return values:

You can use the return values to verify if and how the device configuration was changed.

You can use platform-specific *_command modules to send commands to managed network nodes that have a command-line interface, and then process the results of those commands.

If you use a separate module for each different network platform, then you would need three separate tasks to run the same type of command, as in the following example:

---
- name: Run Cisco IOS command
  cisco.ios.ios_command:
    commands: "show ip interface"
  when: ansible_network_os == 'cisco.ios.ios'

- name: Run Junos command
  junipernetworks.junos.junos_command:
    commands: "show interface terse"
  when: ansible_network_os == 'junipernetworks.junos.junos'

- name: Run Arista EOS command
  arista.eos.eos_command:
    commands: "show ip interface"
  when: ansible_network_os == 'arista.eos.eos'

You can simplify such playbooks by using the platform-independent ansible.netcommon.cli_command module, as in the following example:

---
- name: Run a command across multiple network platforms
  hosts: ios,junos,eos
  gather_facts: false
  vars:
    ansible_connection: ansible.netcommon.network_cli
  tasks:
    - name: Run command and display results
      block:
        - name: Run a command
          ansible.netcommon.cli_command:
            command: "{{ some_command }}"
          register: result

        - name: Display result
          ansible.builtin.debug:
            var: result['stdout_lines']

Store the some_command variable in files under the group_vars directory, with the actual commands to run on each network platform.

For example, the following variable file holds the some_command variable for the Arista EOS platform:

---
some_command: "show ip interface brief"

In the following example, the variable file holds the some_command variable for the Juniper Junos platform:

---
some_command: "show interface terse"

You can use the ansible.netcommon.cli_config module to configure managed network nodes, back up existing configurations, or look for configuration differences.

The following example configures NTP on Cisco IOS, Cisco Junos, and Arista EOS platforms:

---
- name: Configure IOS, Junos, and EOS platforms
  hosts: ios,junos,eos
  gather_facts: false
  vars:
    ansible_connection: ansible.netcommon.network_cli
  tasks:
    - name: Configure NTP settings
      ansible.netcommon.cli_config:
         config: "{{ config_ntp }}"
      notify:
        - Save configuration

  handlers:
    - name: Save configuration
      ansible.netcommon.cli_command:
        command: "{{ save_config }}"

You store the config_ntp and save_config variables in files under the group_vars directory, with the actual commands to run on each network platform.

For example, the following variable file holds the config_ntp and save_config variable for the Arista EOS platform:

---
config_ntp: |
  ntp server 10.10.10.10 prefer
  ntp server 10.10.10.11
save_config: "copy running-config startup-config"

In the following example, the variable file holds the config_ntp and save_config variables for the Juniper Junos platform:

---
config_ntp: |
  set system ntp server 10.10.10.10 prefer
  set system ntp server 10.10.10.11
save_config: "commit"

The ansible.netcommon.cli_config module can also back up configurations across network platforms. The following example backs up the configurations on Cisco IOS, Juniper Junos, and Arista EOS platforms:

---
- name: Backup configurations on IOS, Junos, and EOS
  hosts: ios,junos,eos
  gather_facts: false
  tasks:
    - name: Backup configurations
      vars:
        ansible_connection: ansible.netcommon.network_cli
      ansible.netcommon.cli_config:
         backup: true
         backup_options:
           filename: "{{ inventory_hostname }}.cfg"
           dir_path: ./backup

Network configurations are stored in different formats on different network platforms. You might want to store configurations from multiple network platforms in a vendor-neutral format for configuration management, migration, or troubleshooting purposes.

You can use the resource module parsed state to parse and reformat sections of configuration data. You can then store the configuration data in a version control system or import it into a configuration management system.

For example, the following playbook parses an IOS Layer 3 interface configuration stored in the l3int.cfg file, and then saves the transformed configuration data to the parsed_l3int.cfg file. The l3int.cfg file is generated by running the show running-config | section ^interface command on the IOS device and then saving the output to the file:

---
- name: Parse L3 interface configuration and save the data to a file
  hosts: ios1.example.com
  gather_facts: false
  tasks:
    - name: Parse L3 interface configuration
      cisco.ios.ios_l3_interfaces:
        running_config: "{{ lookup('file', 'l3int.cfg') }}"
        state: parsed
      register: ios_l3int

    - name: Save configuration data
      ansible.builtin.copy:
        content: >-
          "{{ ios_l3int | ansible.builtin.to_nice_yaml }}"
        dest: parsed_l3int.cfg
      delegate_to: localhost

The l3int.cfg file consists of the following content:

interface GigabitEthernet1
 ip address 172.25.250.20 255.255.255.0
 negotiation auto
interface GigabitEthernet2
 ip address 172.25.251.20 255.255.255.0
 ipv6 address 2001:db8:251:20::/64
 negotiation auto

After this playbook is run, the parsed_l3int.cfg file consists of the following content:

"changed: false
failed: false
parsed:
-   ipv4:
    -   address: 172.25.250.20/24
    name: GigabitEthernet1
-   ipv4:
    -   address: 172.25.251.20/24
    ipv6:
    -   address: 2001:db8:251:20::/64
    name: GigabitEthernet2"

You might want to use the ansible.utils.cli_parse module to parse data for the following reasons:

The ansible.utils.cli_parse module uses an architecture based on plug-ins and supports several different plug-ins. The ansible.netcommon.native plug-in is covered in this section.

To use the ansible.netcommon.native plug-in, you must create a template. The plug-in takes the output of a network device command and applies a YAML template to transform the command output into structured data. The YAML template file uses regular expressions to parse the received data into structured data.

The YAML template is structured as a list of parsers, each containing the following key-value pairs:

For example, the following play runs the show ip interface command on IOS managed nodes, and then parses and displays the output:

---
- name: Run a command and parse the output
  hosts: ios
  gather_facts: false
  tasks:
    - name: Parse interface data
      ansible.utils.cli_parse:
        command: "show ip interface"
        parser:
          name: ansible.netcommon.native
          template_path: "./templates/interfaces.yml"
        set_fact: ios_interfaces

    - name: Display structured data
      ansible.builtin.debug:
        var: ansible_facts['ios_interfaces']

The associated YAML template consists of the following content:

---
- example: "GigabitEthernet1 is up, line protocol is up"
  getval: '(?P<name>\S+)\sis\s(?P<admin_state>\S+)\,\sline\sprotocol\sis\s(?P<oper_state>\S+)'
  result:
    "{{ name }}":
      name: "{{ name }}"
      state:
        admin: "{{ admin_state }}"
        operating: "{{ oper_state }}"

When the play is run, the parsed output is displayed as follows:

...output omitted...
ok: [ios1.example.com] => {
    "ansible_facts": {
        "ios_interfaces": {
            "GigabitEthernet1": {vendor-independent
}
ok: [ios2.example.com] => {
    "ansible_facts": {
        "ios_interfaces": {
            "GigabitEthernet1": {
                "name": "GigabitEthernet1",
                "state": {
                    "admin": "up",
                    "operating": "up"
                }
            }
        }
    }
}
...output omitted...

You can then copy this data to a file and perform further actions with it, such as sending the data to an external system.