ネットワークデバイス向けREST API

Welcome! In this lesson, we'll dive into how to control network devices using REST APIs. This is a powerful way to automate tasks beyond traditional command-line interfaces (CLIs).

Instead of typing commands, you can send structured messages to devices, making automation much more scalable and efficient.

REST stands for Representational State Transfer. It's an architectural style for designing networked applications. It's not a protocol, but a set of guidelines for how an API should behave.

• Client-Server: Separation of concerns.
• Stateless: Each request from a client to a server must contain all the information needed to understand the request.
• Cacheable: Responses can be cached to improve performance.
• Uniform Interface: A consistent way to interact with resources.

In REST, everything is a resource, identified by a URL (Uniform Resource Locator). For example, /interfaces or /vlans/100.

You interact with these resources using standard HTTP methods (verbs):

• GET: Retrieve data from a resource.
• POST: Create a new resource.
• PUT: Update an existing resource (or create if it doesn't exist).
• DELETE: Remove a resource.

When interacting with REST APIs, data is typically exchanged in a structured format. The most common formats are JSON (JavaScript Object Notation) and XML (Extensible Markup Language).

JSON is widely preferred today due to its simplicity and readability. Here's a tiny JSON example:

This tells us the interface name and its current status.

Many modern network devices, from vendors like Cisco, Juniper, Arista, and others, expose REST APIs. These APIs allow you to programmatically query their status, retrieve configurations, and even make configuration changes.

Each vendor's API will have its own specific structure and endpoints, so always refer to the official documentation!

For Python, the requests library is the go-to tool for making HTTP requests to web services and REST APIs. It simplifies sending requests and handling responses.

You'll typically install it using pip:

Then, you can import it into your Python scripts.

Let's see how to make a simple GET request to retrieve data from a public API. We'll use a dummy API to fetch a 'todo' item. This simulates getting information from a network device.

Try running this example:

While GET retrieves data, POST and PUT are used to send data to the API to create or update resources. For example, you might use POST to create a new VLAN or PUT to modify an interface's speed.

When sending data, you typically pass it as a JSON payload in the request body, often using the json parameter in the requests library.

Most real-world network device APIs require authentication to ensure only authorized users can access or modify configurations. Common methods include:

• Basic Authentication: Sending username and password with each request.
• API Keys: A unique key provided by the service.
• Token-based: Obtaining a temporary token after login, then using it for subsequent requests (e.g., OAuth).

Always secure your credentials!

After making an API call, the server sends back an HTTP status code indicating the request's outcome. Understanding these is crucial for debugging:

• 200 OK: Request successful.
• 201 Created: Resource created successfully (for POST).
• 400 Bad Request: Client sent invalid data.
• 401 Unauthorized: Authentication failed.
• 404 Not Found: Resource not found.
• 500 Internal Server Error: Server-side issue.

The requests library's response.status_code gives you this value.

Great job! You've learned the fundamentals of interacting with REST APIs for network automation. We covered what REST is, key HTTP methods, data formats like JSON, and how to use Python's requests library.

By leveraging REST APIs, you can build powerful scripts to automate configuration, monitoring, and troubleshooting of modern network infrastructures!