Gain insights into automating network reconnaissance, orchestrating repetitive changes, and transforming network configuration management. Discover CI/CD pipeline migration for full network automation.

ansibleFinal1.tar.gz

gitjob

CIPhosts

CIPhosts-copy

gather_info

gather_important_facts

facts_to_md

facts_to_csv_html

tools

frr01

frr02

first_gather_important_facts

​​Network automation begins with automating network reconnaissance. This is accomplished by gathering important information from network devices while building a library of dynamic on-demand utilities and generating living documentation. Starting small, the course exhibits the simplicity and elegance of network automation.

Next, you will learn how to automate larger changes that require a high number of repetitive steps. These changes will be executed serially in a specific orchestrated order, making them perfect for an automated solution. After gaining comfort with the new tools, you can fully transform network configuration management to an automated, intent-based, self-documenting system.

The final step is learning how to migrate to a continuous integration/continuous delivery (CI/CD) pipeline, thereby fully automating the network.

Automate Your Network

Network reconnaissance is a massive challenge to tackle on an enterprise
network, even with powerful network management systems in place. Many
commands must be executed at the CLI to capture the information required
to troubleshoot a problem, or to design a new solution. 

It can be tedious to hop from device to device and collect
information that may be stale or obsolete by the time the
change is drafted. It especially does not scale well for larger changes.
Now that the inventory file `hosts` is ready, Ansible can
execute playbooks against the devices.



Some advantages to this approach
are as follows:

-   Excellent starting point to network automation

-   Improves software development skills

-   Non-disruptive and non-intrusive, with little chance of anything going wrong

-   Simple and easy to get going


To achieve this approach, converts the commands normally run on a device to a simple script Next, dry run the processes. From here, start building a centralized library of customized network utilities available for engineers or operators to run on-demand, or scheduled for execution daily or weekly. One important utility is comprehensive dynamic network documentation.

Automation should be done for a well-understood environment. Understand the network with respect to the following before we start automating anything:

    -   Layer 1 topology

    -   Layer 2 topology

    -   Layer 3 topology

    -   Cisco Discovery Protocol (CDP) neighbors
         - Use Ansible to gather and capture the CDP neighbors to build a topology of the network first

    -   Open Shortest Path First (OSPF)/Enhanced Interior Gateway
        Routing Protocol (EIGRP)/Border Gateway Protocol (BGP)
        neighbors

    -   Routing tables

    -   VLANs

    -   Interface availability/usage  


Using Ansible offers many ways to gather information from the network.
This course focuses on the Cisco `ios_facts` and `ios_command` modules
that are natively included with Ansible by default.

## Ansible module: `ios_facts`

Ansible has the built-in `ios_facts` module used to
gather facts from the Cisco IOS devices on the network. The `ios_facts` module is a great place to start because it is simple to use. Basic information
about the hardware, configuration, and interfaces is returned from
`ios_facts`. The default setting includes all available facts about a
device. However, it is possible to limit the scope of what `ios_facts`
includes or excludes from the playbook. 

Examples of `ios_facts` usage
are included in the chapter [Network Reconnaissance](https://www.educative.io/collection/page/10370001/6498292152664064/5771046924320768). It should be noted that other similar fact-gathering modules exist, such as `nxos_facts`.

A mix of limiting to specific subsets of facts, or every fact but
specific subsets, can be used to adjust the scope. 

Some basic examples from the Ansible `ios_facts` module documentation are:

```yaml
#Collect all facts from the device
- ios_facts:
    gather_subset: all

#Collect only the config and default facts
- ios_facts:
    gather_subset:
      - config

#Do not collect hardware facts
- ios_facts:
    gather_subset:
      - "!hardware"
```

>More information about the [`ios_facts` module](https://docs.ansible.com/ansible/latest/modules/ios_facts_module.html).
>
>More on [Cisco and Ansible](https://www.ansible.com/integrations/networks/cisco).


## Ansible module: `ios_command `

Another way of gathering information from the network is using the
simple and easy-to-use `ios_command` module. This module can be used
to gather the output of IOS `show` commands. Become comfortable with
`ios_command`. Build on the ability to gather information from the
network and use the module to change the network. 

Here are some ideas of
the `show` commands that can be performed using `ios_command` module
to gather network reconnaissance:

-   `show cdp neighbors`

-   `show spanning-tree`

-   `show spanning-tree blockedports`

-   `show ip ospf neighbors`

-   `show ip route`



Though it might seem impossible, any or all the above commands can be
performed on any or all the network devices on-demand, or at scheduled
times using Ansible playbooks. If the output of the commands is kept in
the master branch, when changed, TFS will show the change history for
these output files. This makes it easier to detect state changes in the
network. This could help keep track of topology changes or hint at
potential problems or unreported outages. Manipulate the output of the
commands and store them in the centralized repository for version and
change control.

# Tactical changes 
The automated network reconnaissance has led to some discoveries on the network that need to be addressed, such as:

-   Large-scale feature deployments

-   Large-scale corrections

-   Single, one-time changes

-   Configuration management

## Ansible module: `ios_config` 

Building on the `ios_command` module, the `ios_config` Ansible module is used to perform changes on Cisco Catalyst devices
running IOS. Think of the `ios_command` module as a tool used in **EXEC**
mode on a device. This is able to perform standard `show` commands or
`copy running-configuration startup-configuration` commands
at the user **EXEC** level of IOS.

In contrast, the `ios_config` module can perform privileged **EXEC** level
commands used for device configuration. The `ios_config` module is
used to execute commands that make changes on the network.
 


Let's learn how to tackle the challenges of network reconnaissance.

Introduction

What Is Network Automation?

Why Automate the Network?

How to Automate the Network

Where to Start with Network Automation

Repository Structure

Network Reconnaissance

Tactical Playbooks

Data Models and Dynamic Templates

Dynamic Intent-Based Documentation

Configuration Management

Continuous Integration/Continuous Delivery

Conclusion

Network Reconnaissance

Gather information