Arista Switches: Programmable APIs & Event-Driven Automation

Arista switches offer several powerful APIs that enable seamless programmability and automation. These APIs allow network engineers and developers to manage configurations, retrieve telemetry, and integrate switches with third-party tools using modern programming paradigms.

• Arista eAPI (Extensible API): A JSON-RPC 2.0 API that provides programmatic access to Arista EOS command-line interface (CLI) commands and structured JSON output. It supports HTTP/HTTPS transport and is language-agnostic, allowing easy integration with scripting languages like Python, Go, and Ruby.
• OpenConfig: A vendor-neutral, model-driven API using gRPC and YANG models for streaming telemetry and configuration management. Arista EOS supports OpenConfig telemetry, enabling high-frequency, real-time network data collection.
• EOS SDK (Software Development Kit): Provides developers deep programmability into EOS via Python or C++ interfaces that can run on the switch itself. This enables advanced integrations, custom daemons, and on-box automation.
• NETCONF & RESTCONF: Standardized network management protocols supported by Arista for configuration and state retrieval. NETCONF uses XML over SSH, while RESTCONF provides RESTful access to configuration data.
• Linux Shell & APIs: EOS switches run a Linux-based OS that supports scripting and automation using native Linux tools and APIs. This allows leveraging familiar Unix/Linux commands and scripts to automate switch operations.

Arista switches provide robust event-driven automation capabilities that allow network engineers to create responsive and intelligent network workflows. These features enable automatic actions based on network or system events, improving operational efficiency and reducing manual intervention.

• Advanced Event Management (AEM): AEM allows users to define event handlers that trigger scripts or commands in response to specific system or network events. It supports a wide range of event types such as interface status changes, configuration modifications, or hardware faults, enabling real-time automation.
• Event Manager: The core component that monitors EOS events and associates them with user-defined triggers. Event Manager facilitates mapping incoming events to customized actions, ensuring timely and precise network responses.
• Event Monitor: Continuously observes system states or logs for specific conditions and helps initiate event-driven workflows, providing enhanced network visibility and proactivity.
• Integration with Native Linux Tools: Since EOS is based on a Linux kernel, users can leverage standard Linux scripting and automation utilities (such as bash scripts, Python, cron jobs) to extend and customize event-driven automation capabilities within Arista switches.
• Use Cases for Event-Driven Automation:
  • Automatically backing up switch configurations upon any change.
  • Triggering alerts or remediation scripts when interfaces go down or flap.
  • Proactive fault detection and automated troubleshooting workflows.
  • Dynamic updating of monitoring or logging policies based on network conditions.

Arista switches support a variety of automation and integration tools that help network engineers streamline operations, automate workflows, and integrate with third-party systems effectively.

This step-by-step guide demonstrates how to enable and use Arista's Extensible API (eAPI) for programmatic management of Arista EOS switches. eAPI uses JSON-RPC over HTTP or HTTPS, providing easy integration for automation workflows.

1. Access the Switch CLI
   Connect to your Arista switch via SSH or console cable.
2. Enter Privileged EXEC Mode
   enable
3. Enter Global Configuration Mode
   configure terminal
4. Enable Management API for eAPI

   management api http-commands
      protocol https
      no shutdown
       

   For additional options, you can also enable HTTP or restrict access by IP as required.

5. Save the Configuration
   write memory
6. Verify eAPI Status
   show management api http-commands
   Confirm that the API server is enabled and running on the intended protocols.
7. Access API Documentation
   Open a browser and navigate to https://<switch-ip>/eapi/overview or /eapi/spec for interactive documentation.
8. Send API Requests
   • Use tools like curl, Postman, or Python libraries to send HTTP POST requests to https://<switch-ip>/command-api with JSON payloads.
   • Python example using jsonrpclib:

     from jsonrpclib import Server
     switch = Server("https://username:password@<switch-ip>/command-api")
     response = switch.runCmds(1, ["show version"])
     print(response)
             

Tip: Always use HTTPS for secure communication. Restrict access to trusted hosts where possible.

This section provides step-by-step troubleshooting strategies and tips specific to programmable APIs and event-driven automation on Arista EOS switches. Use these steps to quickly identify and resolve common issues when automating or integrating with Arista switches.

1. Verify API and Feature Enablement
   
   • Ensure management api http-commands or the relevant API service is enabled and not administratively shut down.
   • Run show management api http-commands to verify which protocols (HTTP, HTTPS) are enabled and that state is up.
2. Check User Credentials and Access Rights
   
   • Make sure the API user has appropriate privileges (e.g., network-admin role).
   • Test login via SSH or API using the same credentials to confirm access.
3. Review Error Responses from eAPI
   • API calls that fail will return a JSON error object; inspect code and message fields for cause.
   • Use the on-box eAPI documentation for up-to-date command syntax and supported features:
     https://<switch-ip>/eapi/overview or .../eapi/spec
   • Check for required arguments or syntax errors in command payloads.
4. Network Connectivity
   • Confirm that the client system can reach the switch on the appropriate interface and protocol (check VRF if used).
   • Test using ping or curl to the API endpoint to verify basic connectivity.
   • Ensure no firewall or ACLs are blocking management traffic.
5. Automation Tool Integration Issues
   • Double-check inventory, variables, and configuration files for external automation tools (e.g., Ansible, Python scripts).
   • Use verbose or debug logging (-vvv in Ansible) to display detailed error messages.
   • If using Ansible, ensure ansible_network_os: eos or equivalent is properly set, and recommended modules are installed.
6. Event-Driven Automation Debugging
   • Validate that event handlers or scripts are present and executable from the switch shell.
   • Check event logs for trigger and handler execution (show event-history if available).
   • Test automation logic with controlled test cases to ensure event triggers work as expected.
7. Example: Diagnosing a Failed API Call
   • The eAPI response includes either a result or an error JSON field.

     {
       "jsonrpc": "2.0",
       "error": {
         "code": 1002,
         "message": "invalid command",
         "data": "Error message details"
       },
       "id": "cli-1"
     }
             

     Review the code and message for troubleshooting clues (such as typo, unsupported operation, or permissions issue).
8. When All Else Fails
   • Consult Arista’s official product documentation and whitepapers for error codes and troubleshooting tips.
   • Leverage Arista’s support forums and community spaces for peer-to-peer help.
   • Contact Arista TAC for advanced troubleshooting assistance.

Tip: Use change-control best practices (such as config backups and version control) before making major automation adjustments. Always test in a lab or staging environment when possible.