This section breaks down each Netmiko command execution method, its use-cases, parameters, and basic usage patterns to help you automate network tasks efficiently:

• send_command()
  • Purpose: Execute a single command (e.g., "show version") and return the device’s response as a string.
  • Common Parameters:
    • command_string: The CLI command to execute.
    • expect_string (optional): Regex to define expected CLI prompt or output.
    • delay_factor (optional): Increase wait times for slow responses.
    • use_textfsm (optional): Parse structured output with TextFSM templates.
  • Best Use: Gathering device status, running quick checks, collecting output for parsing or logging.
  • Example:

    output = net_connect.send_command("show ip int brief")

• send_config_set()
  • Purpose: Send a list or set of configuration commands to the device’s config mode.
  • Common Parameters:
    • config_commands: List of CLI configuration commands.
    • exit_config_mode (optional): Exit config mode after commands (default: True).
    • delay_factor (optional): For slow connections/devices.
  • Best Use: Applying batch network changes, interface or VLAN config, templated deployments.
  • Example:

    config = [
        "interface GigabitEthernet1",
        "description Automated by Netmiko",
        "no shutdown"
    ]
    output = net_connect.send_config_set(config)

• send_config_from_file()
  • Purpose: Read configuration commands from a local file and apply to the device.
  • Common Parameters:
    • config_file: File path containing CLI config commands.
    • exit_config_mode, delay_factor: Same options as send_config_set().
  • Best Use: Large-scale deployments, versioned configs, repeatable device setups.
  • Example:

    output = net_connect.send_config_from_file("router_config.txt")

• send_multiline()
  • Purpose: Send a block of commands or multi-line string as a single interaction.
  • Common Parameters:
    • commands: Multi-line string or list of commands.
    • strip_prompt, strip_command (optional): Remove extra CLI prompt/echo from output.
  • Best Use: When a single configuration context requires multiple commands in order (e.g., banners, access-lists).
  • Example:

    output = net_connect.send_multiline(commands="banner motd ^\nUnauthorized access prohibited\n^")

• send_command_timing()
  • Purpose: Executes a command and waits a predefined time rather than relying on prompt or pattern-matching.
  • Common Parameters:
    • command_string: The CLI command to run.
    • delay_factor: Adjust timing as needed.
  • Best Use: For devices with unreliable prompt patterns or when precise timing is crucial.
  • Example:

    output = net_connect.send_command_timing("reload")

• send_commands()
  • Purpose: Send a list of commands for sequential execution and aggregate all results.
  • Common Parameters:
    • commands: List of CLI commands.
    • use_textfsm (optional): Parse each output using TextFSM.
    • delay_factor (optional): Adjust for device/connections speed.
  • Best Use: Bulk retrieval of device state (“show” commands), audits, automations requiring multiple data points.
  • Example:

    output = net_connect.send_commands(commands=["show version", "show users", "show inventory"])

This section outlines effective strategies and best practices for working with Netmiko command outputs in production network automation:

• 1. Structured Parsing with TextFSM
  • Use the use_textfsm=True parameter with send_command() or send_commands() to transform raw command output into structured Python dictionaries or lists for easier data analysis.
  • Utilize official or custom TextFSM templates for commonly used CLI commands to streamline parsing and avoid manual text manipulation.
  • Example:

    output = net_connect.send_command("show interfaces status", use_textfsm=True)

• 2. Output Paging Considerations
  • Ensure output is not truncated due to device paging settings. Disable paging on the device (e.g., terminal length 0 on Cisco IOS) prior to sending commands to capture the entire output in one call.
  • For devices with nonstandard paging behavior, consider sending specific CLI commands to disable output paging before main operational queries.
• 3. Error Handling for Config Commands
  • Implement robust error handling using try/except blocks for common failures such as timeouts and authentication errors. Always handle exceptions like NetmikoTimeoutException and NetmikoAuthenticationException directly.
  • For send_config_set(), use the error_pattern argument to detect specific errors in config output and halt further execution if errors occur.
  • Example:

    try:
        output = net_connect.send_config_set(config_commands, error_pattern=r"% Invalid input")
    except Exception as error:
        print("Configuration change failed:", error)
    

• 4. Adjusting for Device Timing
  • Use the delay_factor parameter when working with slow or high-latency devices to avoid incomplete responses or premature timeouts. Increase the delay as needed to account for device responsiveness.
  • Tip: Set delay_factor=2 or higher for long-running commands or devices with slow processing.
• 5. Validating Output
  • Always assess the returned output for signs of errors or incomplete data, especially after configuration changes. Search for known error strings, such as % Invalid input or ERROR, in the response.
  • For outputs with sensitive or critical data, validate responses with regular expressions or through cross-checking expected patterns.
• 6. Clean Presentation and Post-Processing
  • Remove any extra CLI prompts or echoed commands from output for clarity. Use parameters like strip_prompt and strip_command when available.
  • For advanced needs, further process output into lists or dictionaries using Python's splitlines(), split(), or regular expressions.
• 7. Logging and Record-Keeping
  • Store outputs for each command execution to external files or logging systems. This approach supports auditing, troubleshooting, and change management.
  • Log both the commands sent and their corresponding responses for comprehensive traceability.

The following code samples show practical usage of Netmiko’s most common command execution methods in automation workflows:

• Connect to a Device

  from netmiko import ConnectHandler
  
  device = {
      "device_type": "cisco_ios",
      "host": "192.0.2.1",
      "username": "admin",
      "password": "password",
  }
  net_connect = ConnectHandler(**device)
  

• Execute a Single Show Command

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

• Run Multiple Show Commands and Aggregate Results

  commands = ["show version", "show inventory"]
  output = net_connect.send_commands(commands)
  for cmd, result in output.items():
      print(f"--- {cmd} ---\n{result}")
  

• Send a Set of Configuration Commands

  config_commands = [
      "interface GigabitEthernet1",
      "description Configured by Netmiko",
      "no shutdown"
  ]
  output = net_connect.send_config_set(config_commands)
  print(output)
  

• Apply Configuration from a File

  output = net_connect.send_config_from_file("config.txt")
  print(output)
  

• Send a Multi-Line Command Block

  banner = "banner motd ^\nUnauthorized Access Prohibited\n^"
  output = net_connect.send_multiline(commands=banner)
  print(output)
  

• Handle Output Parsing with TextFSM

  output = net_connect.send_command("show interfaces status", use_textfsm=True)
  for entry in output:
      print(entry)
  

• Disconnect from Device

  net_connect.disconnect()
  

This table summarizes recommended Netmiko command execution methods based on different automation scenarios. Use this as a quick guide to select the optimal method for your specific needs:

Refer to this table when selecting methods in your automation scripts to optimize reliability and maintainability.