LAB 1 — Network Device Automation with SSH and Netmiko

# Test SSH to R1
ssh netadmin@10.10.20.10

# Enter password: NetAuto123!
# You should reach R1 CLI prompt: R1>

pip install netmiko

python -c "import netmiko; print(netmiko.__version__)"

# device_inventory.py
# Device connection parameters for SSH automation

# Dictionary of devices with connection details
devices = {
    'R1': {
        'device_type': 'cisco_ios',       # Netmiko device type
        'host': '10.10.20.10',             # Management IP address
        'username': 'netadmin',            # SSH username
        'password': 'NetAuto123!',         # SSH password
        'secret': 'NetAuto123!',           # Enable password (if different)
        'port': 22,                        # SSH port
    },
    'R2': {
        'device_type': 'cisco_ios',
        'host': '10.10.20.20',
        'username': 'netadmin',
        'password': 'NetAuto123!',
        'secret': 'NetAuto123!',
        'port': 22,
    },
    'SW1': {
        'device_type': 'cisco_ios',
        'host': '10.10.20.30',
        'username': 'netadmin',
        'password': 'NetAuto123!',
        'secret': 'NetAuto123!',
        'port': 22,
    },
    'SW2': {
        'device_type': 'cisco_ios',
        'host': '10.10.20.40',
        'username': 'netadmin',
        'password': 'NetAuto123!',
        'secret': 'NetAuto123!',
        'port': 22,
    }
}

# Convenience lists for iteration
routers = ['R1', 'R2']
switches = ['SW1', 'SW2']
all_devices = ['R1', 'R2', 'SW1', 'SW2']

# test_netmiko_connection.py
# Test Netmiko SSH connection to R1

from netmiko import ConnectHandler
from device_inventory import devices

# Select device to test
device = devices['R1']

# Connect to device via SSH
print(f"Connecting to {device['host']}...")
try:
    # ConnectHandler establishes SSH connection
    connection = ConnectHandler(**device)

    print("Connected successfully!")

    # Get the device prompt (hostname)
    prompt = connection.find_prompt()
    print(f"Device prompt: {prompt}")

    # Send a simple show command
    output = connection.send_command("show version | include Software")
    print(f"\nDevice Software Version:")
    print(output)

    # Disconnect
    connection.disconnect()
    print("\nDisconnected")

except Exception as e:
    print(f"Connection failed: {e}")

python test_netmiko_connection.py

Connecting to 10.10.20.10...
Connected successfully!
Device prompt: R1#

Device Software Version:
Cisco IOS Software, ISR Software (X86_64_LINUX_IOSD-UNIVERSALK9-M), Version 17.3.4...

Disconnected

# show_interface_status.py
# Retrieve interface status from R1

from netmiko import ConnectHandler
from device_inventory import devices

# Connect to R1
device = devices['R1']
connection = ConnectHandler(**device)

print(f"Connected to {connection.find_prompt()}\n")

# Send show command and capture output
output = connection.send_command("show ip interface brief")

# Print the output
print("Interface Status:")
print("=" * 80)
print(output)
print("=" * 80)

# Disconnect
connection.disconnect()

python show_interface_status.py

Connected to R1#

Interface Status:
================================================================================
Interface              IP-Address      OK? Method Status                Protocol
GigabitEthernet0/0/0   unassigned      YES unset  administratively down down
GigabitEthernet0/0/1   10.10.20.10     YES manual up                    up
GigabitEthernet0/1/0   unassigned      YES unset  administratively down down
...
================================================================================

# collect_device_info.py
# Collect multiple pieces of information from R1

from netmiko import ConnectHandler
from device_inventory import devices
from datetime import datetime

# Connect to device
device = devices['R1']
connection = ConnectHandler(**device)

print(f"Device Information Report: {connection.find_prompt()}")
print(f"Collected: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print("=" * 80)

# List of show commands to run
commands = [
    "show version | include Software",
    "show ip interface brief",
    "show ip route | include Gateway",
    "show running-config | include hostname"
]

# Execute each command and display results
for command in commands:
    print(f"\n### Command: {command}")
    print("-" * 80)
    output = connection.send_command(command)
    print(output)
    print("-" * 80)

# Disconnect
connection.disconnect()
print("\nReport complete")

# save_show_output.py
# Save show command output to a file for later analysis

from netmiko import ConnectHandler
from device_inventory import devices
from datetime import datetime

device = devices['R1']
connection = ConnectHandler(**device)

# Get running configuration
print("Retrieving running configuration...")
config_output = connection.send_command("show running-config")

# Create filename with timestamp
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
filename = f"R1_running_config_{timestamp}.txt"

# Save to file
with open(filename, 'w') as file:
    file.write(f"Configuration Backup for R1\n")
    file.write(f"Collected: {datetime.now()}\n")
    file.write("=" * 80 + "\n\n")
    file.write(config_output)

print(f"Configuration saved to: {filename}")

connection.disconnect()

# collect_from_all_devices.py
# Collect interface status from all devices

from netmiko import ConnectHandler
from device_inventory import devices, all_devices

print("Collecting interface status from all devices...")
print("=" * 80)

# Loop through each device
for device_name in all_devices:
    print(f"\n### {device_name} ###")

    # Get device connection parameters
    device = devices[device_name]

    try:
        # Connect to device
        connection = ConnectHandler(**device)

        # Get interface status
        output = connection.send_command("show ip interface brief")
        print(output)

        # Disconnect
        connection.disconnect()

    except Exception as e:
        print(f"Error connecting to {device_name}: {e}")
        continue  # Continue to next device even if one fails

print("\n" + "=" * 80)
print("Collection complete")

# configure_description.py
# Add description to an interface on R1

from netmiko import ConnectHandler
from device_inventory import devices

# Connect to R1
device = devices['R1']
connection = ConnectHandler(**device)

print(f"Connected to {connection.find_prompt()}")

# Configuration commands as a list
config_commands = [
    'interface GigabitEthernet0/0/0',
    'description Configured by Python Script',
    'exit'
]

print(f"\nSending configuration commands...")
print(f"Commands: {config_commands}")

# send_config_set() enters config mode, sends commands, exits config mode
output = connection.send_config_set(config_commands)
print("\nDevice Response:")
print(output)

# Verify the change
print("\nVerifying configuration...")
verify_output = connection.send_command("show running-config interface GigabitEthernet0/0/0")
print(verify_output)

# Save configuration
print("\nSaving configuration...")
save_output = connection.send_command("write memory")
print(save_output)

connection.disconnect()
print("\n Configuration complete")

python configure_description.py

R1# show running-config interface GigabitEthernet0/0/0
Building configuration...

Current configuration : 123 bytes
!
interface GigabitEthernet0/0/0
 description Configured by Python Script
 no ip address
 shutdown
end

# configure_loopback.py
# Create loopback interface with IP address on R1

from netmiko import ConnectHandler
from device_inventory import devices

device = devices['R1']
connection = ConnectHandler(**device)

print("Creating Loopback99 on R1...")

# Commands to create loopback and assign IP
config_commands = [
    'interface Loopback99',
    'description Created via Netmiko Python',
    'ip address 192.0.2.99 255.255.255.0',
    'no shutdown',
    'exit'
]

# Send configuration
output = connection.send_config_set(config_commands)
print("Configuration applied:")
print(output)

# Verify interface was created
print("\nVerifying interface...")
verify = connection.send_command("show ip interface brief | include Loopback99")
print(verify)

# Save config
connection.send_command("write memory")
connection.disconnect()

print("\nLoopback99 created successfully")

Creating Loopback99 on R1...
Configuration applied:
configure terminal
Enter configuration commands, one per line.  End with CNTL/Z.
R1(config)#interface Loopback99
R1(config-if)#description Created via Netmiko Python
R1(config-if)#ip address 192.0.2.99 255.255.255.0
R1(config-if)#no shutdown
R1(config-if)#exit
R1(config)#end
R1#

Verifying interface...
Loopback99             192.0.2.99      YES manual up                    up

Loopback99 created successfully

# configure_all_devices.py
# Apply consistent configuration to all devices

from netmiko import ConnectHandler
from device_inventory import devices, all_devices

# Configuration to apply to ALL devices
# These commands work on both routers and switches
common_config = [
    'banner login # Authorized Access Only - Managed by Automation #',
    'service timestamps debug datetime msec',
    'service timestamps log datetime msec',
    'no ip domain-lookup'
]

print("Applying common configuration to all devices...")
print(f"Configuration commands: {common_config}\n")
print("=" * 80)

# Track success/failure
results = {'success': [], 'failed': []}

# Loop through all devices
for device_name in all_devices:
    print(f"\n### Configuring {device_name} ###")

    device = devices[device_name]

    try:
        # Connect
        connection = ConnectHandler(**device)
        print(f"Connected to {connection.find_prompt()}")

        # Send configuration
        output = connection.send_config_set(common_config)
        print("Configuration applied")

        # Save configuration
        connection.send_command("write memory")
        print("Configuration saved")

        # Disconnect
        connection.disconnect()

        # Track success
        results['success'].append(device_name)

    except Exception as e:
        print(f"Error: {e}")
        results['failed'].append(device_name)

# Print summary
print("\n" + "=" * 80)
print("Summary:")
print(f"  Successful: {len(results['success'])} devices - {results['success']}")
print(f"  Failed: {len(results['failed'])} devices - {results['failed']}")
print("=" * 80)

# configure_from_template.py
# Read configuration commands from file and apply to device

from netmiko import ConnectHandler
from device_inventory import devices

# Create a template file first
template_content = """interface Loopback100
 description Template-Generated Interface
 ip address 10.100.100.1 255.255.255.0
 no shutdown
!
interface Loopback101
 description Another Template Interface
 ip address 10.101.101.1 255.255.255.0
 no shutdown
!
"""

# Save template to file
with open('interface_template.txt', 'w') as f:
    f.write(template_content)

# Now apply template to R1
device = devices['R1']
connection = ConnectHandler(**device)

print("Applying configuration from template file...")

# send_config_from_file() reads file and sends commands
output = connection.send_config_from_file('interface_template.txt')
print("Configuration output:")
print(output)

# Verify interfaces created
print("\nVerifying interfaces...")
verify = connection.send_command("show ip interface brief | include Loopback10")
print(verify)

# Save
connection.send_command("write memory")
connection.disconnect()

print("\nTemplate applied successfully")

# error_handling_example.py
# Demonstrate error handling in network automation

from netmiko import ConnectHandler, NetmikoTimeoutException, NetmikoAuthenticationException
from device_inventory import devices

device = devices['R1']

try:
    print("Attempting connection...")
    connection = ConnectHandler(**device)
    print("Connected successfully")

    # Try to send an invalid command
    try:
        output = connection.send_command("show invalid-command")
        print(output)
    except Exception as cmd_error:
        print(f"Command error: {cmd_error}")

    connection.disconnect()

except NetmikoTimeoutException:
    print("Connection timeout - device not reachable")
    print("  Check: IP address, network connectivity, firewall rules")

except NetmikoAuthenticationException:
    print("Authentication failed - wrong username or password")
    print("  Check: credentials in device_inventory.py")

except Exception as e:
    print(f"Unexpected error: {e}")

# configure_with_verification.py
# Configure interface and verify change was applied correctly

from netmiko import ConnectHandler
from device_inventory import devices

device = devices['R1']
connection = ConnectHandler(**device)

# Define what we want to configure
interface_name = "Loopback200"
desired_ip = "10.200.200.1"
desired_mask = "255.255.255.0"

print(f"Configuring {interface_name} with IP {desired_ip}/{desired_mask}")

# Step 1: Apply configuration
config_commands = [
    f'interface {interface_name}',
    f'description Configured with Verification',
    f'ip address {desired_ip} {desired_mask}',
    'no shutdown'
]

print("\n[1/4] Applying configuration...")
connection.send_config_set(config_commands)
print("Configuration commands sent")

# Step 2: Verify interface exists
print("\n[2/4] Verifying interface exists...")
verify_output = connection.send_command(f"show ip interface brief | include {interface_name}")

if interface_name in verify_output:
    print(f"Interface {interface_name} found")
    print(f"  Status: {verify_output.strip()}")
else:
    print(f"Interface {interface_name} not found!")
    connection.disconnect()
    exit(1)

# Step 3: Verify IP address is correct
print("\n[3/4] Verifying IP address...")
ip_check = connection.send_command(f"show running-config interface {interface_name} | include ip address")

if desired_ip in ip_check and desired_mask in ip_check:
    print(f"IP address configured correctly")
    print(f"  Config: {ip_check.strip()}")
else:
    print(f"IP address mismatch!")
    print(f"  Expected: {desired_ip} {desired_mask}")
    print(f"  Found: {ip_check.strip()}")

# Step 4: Save configuration
print("\n[4/4] Saving configuration...")
save_output = connection.send_command("write memory")
if "OK" in save_output or "[OK]" in save_output:
    print("Configuration saved successfully")
else:
    print("Save may have failed - check device")

connection.disconnect()
print("\nConfiguration and verification complete")

# check_device_status.py
# Check which devices are reachable before attempting configuration

from netmiko import ConnectHandler
from device_inventory import devices, all_devices
import socket

def check_port_open(host, port=22, timeout=3):
    """Check if TCP port is open on host"""
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.settimeout(timeout)
    try:
        result = sock.connect_ex((host, port))
        sock.close()
        return result == 0  # 0 means port is open
    except:
        return False

print("Checking device reachability...")
print("=" * 80)

reachable = []
unreachable = []

for device_name in all_devices:
    device = devices[device_name]
    host = device['host']

    print(f"\nChecking {device_name} ({host})...", end=" ")

    # Check if SSH port is open
    if check_port_open(host):
        print("Reachable")

        # Try to connect via SSH
        try:
            connection = ConnectHandler(**device)
            prompt = connection.find_prompt()
            connection.disconnect()
            print(f"  SSH authentication successful ({prompt})")
            reachable.append(device_name)
        except Exception as e:
            print(f"  SSH failed: {e}")
            unreachable.append(device_name)
    else:
        print("Unreachable (port 22 closed or filtered)")
        unreachable.append(device_name)

# Summary
print("\n" + "=" * 80)
print("Device Status Summary:")
print(f"  Reachable: {len(reachable)} devices - {reachable}")
print(f"  Unreachable: {len(unreachable)} devices - {unreachable}")

if unreachable:
    print("\nSome devices are unreachable. Check:")
    print("  - Network connectivity (ping)")
    print("  - SSH service enabled on device")
    print("  - Credentials correct")
    print("  - Firewall rules")

# backup_all_configs.py
# Backup running configurations from all devices

from netmiko import ConnectHandler
from device_inventory import devices, all_devices
from datetime import datetime
import os

# Create backup directory with timestamp
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
backup_dir = f"config_backups_{timestamp}"
os.makedirs(backup_dir, exist_ok=True)

print(f"Backing up configurations to: {backup_dir}/")
print("=" * 80)

backup_count = 0

for device_name in all_devices:
    print(f"\nBacking up {device_name}...", end=" ")

    device = devices[device_name]

    try:
        # Connect to device
        connection = ConnectHandler(**device)

        # Get running configuration
        config = connection.send_command("show running-config")

        # Save to file
        filename = f"{backup_dir}/{device_name}_config_{timestamp}.txt"
        with open(filename, 'w') as f:
            f.write(f"! Configuration backup for {device_name}\n")
            f.write(f"! Backup date: {datetime.now()}\n")
            f.write(f"! Device: {device['host']}\n\n")
            f.write(config)

        # Get file size
        file_size = os.path.getsize(filename)

        print(f"Saved ({file_size} bytes)")
        backup_count += 1

        connection.disconnect()

    except Exception as e:
        print(f"Failed: {e}")

print("\n" + "=" * 80)
print(f"Backup Summary: {backup_count}/{len(all_devices)} devices backed up successfully")
print(f"Backup location: {backup_dir}/")

# deploy_security_config.py
# Apply security best practices to all devices

from netmiko import ConnectHandler
from device_inventory import devices, all_devices

# Security configuration commands
security_config = [
    # Disable unused services
    'no ip http server',
    'no ip http secure-server',
    'no ip bootp server',
    'no service finger',
    'no service pad',

    # Enable security features
    'service password-encryption',
    'service tcp-keepalives-in',
    'service tcp-keepalives-out',
    'no service dhcp',

    # Login security
    'login block-for 300 attempts 3 within 120',
    'login on-failure log',
    'login on-success log',

    # VTY security
    'line vty 0 15',
    ' exec-timeout 10 0',
    ' transport input ssh',
    ' logging synchronous',
    ' exit',

    # Console security
    'line console 0',
    ' exec-timeout 10 0',
    ' logging synchronous',
    ' exit',

    # Enable secret
    'enable algorithm-type scrypt secret SecureEnable123!',

    # Logging
    'logging buffered 51200 warnings',
]

print("Deploying security configuration to all devices...")
print("=" * 80)

for device_name in all_devices:
    print(f"\n### {device_name} ###")
    print(f"Connecting...", end=" ")

    device = devices[device_name]

    try:
        connection = ConnectHandler(**device)
        print(" DONE")

        print("Applying security configuration...", end=" ")
        output = connection.send_config_set(security_config)
        print(" DONE")

        print("Saving configuration...", end=" ")
        connection.send_command("write memory")
        print(" DONE")

        connection.disconnect()
        print(f"{device_name} security configuration complete")

    except Exception as e:
        print(f"\nError on {device_name}: {e}")

print("\n" + "=" * 80)
print("Security deployment complete")