Oliver Bennet

Posted on Nov 23 • Originally published at graphpe.Medium

Automating Network Devices with Python and Netmiko: A Comprehensive Guide

#rpa #python #automation #networking

Introduction: The Real-World Impact of Network Automation

In a 2023 report by Gartner, organizations that implemented network automation saw operational costs decrease by up to 40% and configuration errors reduce by over 70%.

Cisco further highlights that manual configuration accounts for over 75% of network downtime, costing enterprises an average of $5,600 per minute of downtime. These figures underline the critical role automation plays in modern network management.

Automation not only saves money but also reduces human error, accelerates deployment, and ensures consistent configurations across devices.

For network engineers and administrators, the demand for automation is no longer optional but a necessity in large-scale IT environments.

Among the numerous tools available for automating network devices, Python paired with Netmiko stands out for its simplicity, flexibility, and vendor-agnostic approach.

In this article, we'll explore how you can use Python and Netmiko to automate real-world network tasks, starting with basic use cases and progressing to advanced and complex scenarios.

Understanding Netmiko and Its Benefits

Netmiko is an open-source Python library built on top of Paramiko, designed specifically for managing network devices. Its abstraction layer simplifies SSH interactions and supports multiple vendors, making it an essential tool for network automation.

Key Features of Netmiko

Multi-Vendor Support: Includes Cisco, Juniper, Arista, HP, Dell, and more.
Ease of Use: Simplifies SSH-based interactions and configuration tasks.
Scalability: Automates tasks for hundreds of devices in parallel.
Customizability: Tailors scripts to specific network requirements.

Use Cases for Automating Network Devices

Let’s dive into real-world use cases that demonstrate the power of Python and Netmiko in network automation.

1. Bulk Configuration Changes

In large organizations, updating configurations across hundreds or thousands of devices is a frequent but tedious task. For example:

Updating VLANs across all switches.
Applying QoS policies to prioritize traffic.
Enabling or disabling specific protocols.

Example: Configuring VLANs Across Multiple Switches

from netmiko import ConnectHandler

# List of devices
devices = [
    {"device_type": "cisco_ios", "ip": "192.168.1.1", "username": "admin", "password": "password"},
    {"device_type": "cisco_ios", "ip": "192.168.1.2", "username": "admin", "password": "password"},
]

# VLAN configuration commands
commands = [
    "vlan 10",
    "name Sales_VLAN",
    "vlan 20",
    "name HR_VLAN",
]

# Automating the changes
for device in devices:
    connection = ConnectHandler(**device)
    connection.send_config_set(commands)
    connection.save_config()
    connection.disconnect()

Impact: Automating such tasks reduces manual effort from hours to minutes while ensuring consistency across the network.

2. Backup Configurations

Configuration backups are crucial for disaster recovery. Manual backups are time-consuming and prone to being overlooked.

Example: Automating Backup of Running Configurations

from netmiko import ConnectHandler

# Device details
device = {
    "device_type": "cisco_ios",
    "ip": "192.168.1.1",
    "username": "admin",
    "password": "password",
}

# Connect and fetch configuration
connection = ConnectHandler(**device)
config = connection.send_command("show running-config")

# Save configuration to a file
with open(f"{device['ip']}_backup.txt", "w") as file:
    file.write(config)

connection.disconnect()

Impact: Automating backups ensures that the latest configurations are always available, reducing downtime in case of failures.

3. Compliance Auditing

Compliance with organizational policies or industry regulations requires regular auditing of device configurations. For example:

Ensuring SSH and SNMP are securely configured.
Verifying firewall rules.
Detecting unauthorized changes.

Example: Auditing SNMP Configuration

from netmiko import ConnectHandler

device = {
    "device_type": "cisco_ios",
    "ip": "192.168.1.1",
    "username": "admin",
    "password": "password",
}

connection = ConnectHandler(**device)
output = connection.send_command("show running-config | include snmp")

# Verify SNMP settings
if "snmp-server community public RO" not in output:
    print(f"{device['ip']} is non-compliant!")

connection.disconnect()

Impact: Detects non-compliant devices in real-time, ensuring that configurations adhere to security policies.

4. Real-Time Device Monitoring

Network devices often require real-time monitoring to track their health and performance. This includes:

Monitoring CPU, memory, and interface utilization.
Detecting high latency or dropped packets.

Example: Checking Interface Status

from netmiko import ConnectHandler

device = {
    "device_type": "cisco_ios",
    "ip": "192.168.1.1",
    "username": "admin",
    "password": "password",
}

connection = ConnectHandler(**device)
output = connection.send_command("show ip interface brief")

# Parse the output to detect interfaces that are down
for line in output.splitlines():
    if "administratively down" in line:
        print(f"Interface issue found: {line}")

connection.disconnect()

Impact: Alerts administrators about potential issues before they escalate into outages.

Advanced and Complex Use Cases

5. Multi-Vendor Network Orchestration

Large enterprises often have multi-vendor environments with Cisco, Juniper, and Arista devices. Writing automation scripts for each vendor is cumbersome, but Netmiko simplifies this with vendor-specific device types.

Example: Retrieving Version Information Across Vendors

devices = [
    {"device_type": "cisco_ios", "ip": "192.168.1.1", "username": "admin", "password": "password"},
    {"device_type": "juniper", "ip": "192.168.1.2", "username": "admin", "password": "password"},
    {"device_type": "arista_eos", "ip": "192.168.1.3", "username": "admin", "password": "password"},
]

for device in devices:
    connection = ConnectHandler(**device)
    output = connection.send_command("show version")
    print(f"Version information for {device['ip']}:\n{output}")
    connection.disconnect()

6. Firmware Upgrades

Firmware upgrades are critical but disruptive tasks that require careful orchestration. Automating the process minimizes downtime and human error.

Example: Automating Firmware Uploads

from netmiko import ConnectHandler

device = {
    "device_type": "cisco_ios",
    "ip": "192.168.1.1",
    "username": "admin",
    "password": "password",
}

connection = ConnectHandler(**device)

# Upload firmware
connection.send_command("copy tftp://192.168.1.100/new_firmware.bin flash:")

# Reload device
connection.send_command("reload")

connection.disconnect()

Impact: Enables efficient and error-free firmware management for hundreds of devices.

7. Zero-Touch Provisioning

When new devices are added to the network, manually provisioning them can delay deployment. Automating the initial setup reduces time-to-service.

Example: Configuring a New Router

from netmiko import ConnectHandler

new_device = {
    "device_type": "cisco_ios",
    "ip": "192.168.1.50",
    "username": "admin",
    "password": "password",
}

# Initial configuration
commands = [
    "hostname NewRouter",
    "interface GigabitEthernet0/1",
    "ip address 192.168.1.1 255.255.255.0",
    "no shutdown",
    "ip route 0.0.0.0 0.0.0.0 192.168.1.254",
]

connection = ConnectHandler(**new_device)
connection.send_config_set(commands)
connection.save_config()
connection.disconnect()

Impact: Speeds up deployment while ensuring consistency in configurations.

Optimizing Automation with Advanced Techniques

1. Parallel Execution

For large-scale networks, automating sequentially can be slow. Use Python’s concurrent.futures to execute tasks in parallel.

from concurrent.futures import ThreadPoolExecutor
from netmiko import ConnectHandler

def execute_command(device):
    connection = ConnectHandler(**device)
    output = connection.send_command("show ip route")
    connection.disconnect()
    return output

devices = [
    {"device_type": "cisco_ios", "ip": "192.168.1.1", "username": "admin", "password": "password"},
    {"device_type": "cisco_ios", "ip": "192.168.1.2", "username": "admin", "password": "password"},
]

with ThreadPoolExecutor(max_workers=5) as executor:
    results = executor.map(execute_command, devices)

for result in results:
    print(result)

2. Centralized Logging

Integrate logging to track script execution and errors.

import logging

logging.basicConfig(level=logging.INFO)
logging.info("Starting network automation script")

Summary

Network automation with Python and Netmiko is transforming how organizations manage their IT infrastructure. From reducing operational costs and human errors to accelerating deployments, the benefits are undeniable. By starting with basic use cases and progressing to complex scenarios like multi-vendor orchestration and firmware upgrades, Netmiko empowers engineers to build scalable and efficient solutions.

Automation isn't just about efficiency—it’s about enabling innovation, improving reliability, and future-proofing your network in an ever-evolving landscape.

Oliver | GraphPe | Medium | Youtube

DEV Community