JN0-223 NETCONF/XML API

NETCONF/XML API Detailed Explanation

NETCONF Overview

NETCONF (Network Configuration Protocol) is a protocol designed specifically for managing network devices. It enables automation by allowing programmatic interaction with devices to configure, monitor, and retrieve information securely and efficiently.

Key Features of NETCONF:

1. Protocol Type:

   • NETCONF is an RPC-based protocol (Remote Procedure Call). This means it works by sending requests (like "get configuration") and receiving responses from the device.

2. Transport Layer:

   • NETCONF uses SSH (Secure Shell) to securely transmit data between the client and the network device. This ensures that the data is encrypted and safe from unauthorized access.

3. Data Model:

   • The core data format in NETCONF is XML (Extensible Markup Language). XML is structured and hierarchical, making it easy to organize and exchange data.

4. Applications:
   NETCONF is used in:

   • Configuration Management: Modify and save configurations on network devices.
   • State Retrieval: Query devices to get operational information like interface statuses or routing tables.
   • Event Notifications: Receive alerts or updates about changes in the network.

Core NETCONF Operations

NETCONF operations are defined as specific actions or procedures that a client can perform on a network device. Below are the most important ones:

1. Session Management

Before performing any action, a NETCONF session must be established between the client (e.g., a script or automation tool) and the device. This session is initiated over an SSH connection.

• How to Start a Session:

  • Use the following command to connect:

    ssh -s netconf [email protected]
    

  • The -s netconf flag specifies that the SSH connection should be used for NETCONF.

• Session Lifecycle:

  • Open: Establish a session.
  • Perform Operations: Execute RPC calls.
  • Close: End the session gracefully.

2. RPC Calls (Remote Procedure Calls)

NETCONF operations are carried out through RPCs, which are requests sent by the client to the device. The device processes the request and sends back a response.

• Common RPC Calls:

  1. <get>: Retrieve operational state information (e.g., interface status, routing tables).
  2. <get-config>: Fetch the current configuration from the device.
  3. <edit-config>: Modify the device’s configuration.

• Example RPC Request and Response:

Request (XML format):

<rpc>
  <get-config>
    <source>
      <candidate/>
    </source>
  </get-config>
</rpc>

Response (from the device):

<rpc-reply>
  <data>
    <configuration>
      <system>
        <host-name>my-device</host-name>
      </system>
    </configuration>
  </data>
</rpc-reply>

• Explanation:
  • The client requested the candidate configuration (a temporary configuration before committing changes).
  • The device replied with the system hostname configuration.

3. Configuration Locking and Unlocking

• Why Locking is Needed:
  When multiple clients or administrators interact with the same device, configuration conflicts can arise. Locking ensures only one client has access to modify configurations at a time.

• NETCONF Locking Workflow:

  1. Lock Configuration:

     • Issue a lock command before making changes.

     • Example RPC for locking:

       <rpc>
        <lock>
          <target>
            <candidate/>
          </target>
        </lock>
       </rpc>
       

  2. Make Changes: Perform your configuration edits.

  3. Unlock Configuration: Release the lock to allow others to access the configuration.

• Benefits:

  • Prevents simultaneous edits that could overwrite each other.
  • Ensures consistency and avoids configuration corruption.

XML’s Role in NETCONF

XML is a key component of NETCONF, serving as the data format for all communications between the client and the device.

Features of XML:

1. Structured Data:

   • XML uses a hierarchical format with nested tags, making it easy to organize and understand. For example:

     <configuration>
      <system>
        <host-name>my-device</host-name>
      </system>
     </configuration>
     

   • This structure clearly shows that "host-name" is part of the "system" configuration.

2. Extensibility:

   • XML can be extended using schemas, allowing it to support custom functionality.

3. Human-Readable and Machine-Readable:

   • XML is easy for both humans and machines to parse, making it ideal for configuration management.

Use Cases for NETCONF

1. Automating Device State Retrieval

Scripts can use NETCONF to automatically fetch the operational state of a device, such as:

• Interface status (e.g., is an interface up or down?).
• CPU usage or memory statistics.
• Routing tables or firewall rules.

Python Example:

from ncclient import manager

with manager.connect(host="192.168.1.1", port=830, username="admin", password="admin123", hostkey_verify=False) as m:
    rpc_reply = m.get(filter=('subtree', '<interfaces></interfaces>'))
    print(rpc_reply.xml)

• Explanation:
  • The script connects to the device using the ncclient library.
  • It retrieves information about all interfaces on the device.

2. Performing Configuration Rollbacks

NETCONF allows you to revert to a previous configuration if something goes wrong.

• Workflow:
  1. Fetch the current configuration using <get-config>.
  2. Save a backup of the configuration.
  3. Apply new changes using <edit-config>.
  4. If an error occurs, reapply the saved configuration using <edit-config>.

Summary

NETCONF, combined with XML, is a powerful protocol for managing and automating network devices. It allows you to:

• Securely communicate with devices over SSH.
• Retrieve device state and configuration data.
• Modify configurations programmatically.
• Avoid conflicts through configuration locking.

By learning NETCONF, you gain the ability to interact with network devices in a standardized and efficient way, enabling you to automate repetitive tasks and build robust network automation solutions.