YANG Data Modeling Language

YANG Data Modeling Language: Complete Guide for CCNP ENCOR Exam

Understanding YANG Data Modeling Language

YANG (Yet Another Next Generation) is a data modeling language used to define the structure of data sent over the NETCONF (Network Configuration Protocol) and RESTCONF (RESTful Configuration Protocol) protocols. It provides a standardized way to describe network device configuration and operational data.

Why YANG Data Modeling is Important

1. Standardization: YANG provides a vendor-neutral way to define network device configurations, ensuring consistency across different manufacturers and platforms.

2. Automation Enablement: YANG enables network automation by providing a clear contract between network devices and management systems about what data can be configured or retrieved.

3. Validation: YANG models include built-in validation rules (constraints, types, ranges) that ensure data integrity before it reaches the device.

4. Documentation: YANG files serve as living documentation of network device capabilities and configuration options.

5. Multi-Protocol Support: The same YANG model can be used with multiple transport protocols (NETCONF, RESTCONF, gRPC), reducing implementation complexity.

6. Device Interoperability: Standardized YANG models allow tools and orchestration platforms to work with multiple vendor devices without custom adaptation for each one.

What is YANG Data Modeling?

YANG Fundamentals: YANG is a text-based data modeling language with a syntax similar to SMIv2 (used in SNMP). It defines the structure, type, and organization of configuration and operational data on network devices.

Key Characteristics:

• Text-based format that is human-readable and machine-parseable
• Hierarchical tree structure mirroring the actual data organization
• Type system with built-in and extensible data types
• Support for constraints, default values, and status indicators
• Container-based organization with leaf nodes for actual data
• RPC (Remote Procedure Call) definitions for operations beyond simple get/set
• Notification definitions for asynchronous data delivery

YANG Module Structure: A YANG module contains:

• Module Declaration: Header information including namespace, prefix, and version
• Imports/Includes: References to other YANG modules for reusability
• Data Definitions: The core containers, leaves, and leaf-lists that define the data model
• RPC Definitions: Operations that can be executed on the device
• Notifications: Asynchronous events the device can send
• Augmentations: Extensions to existing models from other modules

How YANG Data Modeling Works

Core Concepts:

1. Containers: Logical grouping of related configuration or operational data. Containers do not hold values themselves but organize child nodes. Think of them as folders in a directory structure.

Example: An interface container might hold multiple interface-specific configurations.

2. Leaves: Terminal nodes that actually hold data values (strings, integers, boolean, etc.). A leaf is the lowest level in the hierarchy and cannot contain child nodes.

Example: A leaf might be the IP address assigned to an interface.

3. Leaf-lists: Similar to leaves but can contain multiple values of the same type, like an array or list in programming.

Example: A list of DNS servers that a device uses.

4. Lists: Collections of entries where each entry is identified by one or more key leaves, similar to database records with primary keys.

Example: A list of interfaces, with each interface identified by its name as the key.

5. Data Types: YANG supports various data types including:

• Built-in types: string, int8, int16, int32, int64, uint8, uint16, uint32, uint64, decimal64, boolean, binary, bits, enumeration
• Derived types: Custom types created using typedef for reusability
• Constrained types: Applying restrictions like length, range, or pattern to base types

6. Constraints and Validation Rules:

• Type constraints: Enforce specific data types
• Range constraints: Limit numeric values to specific ranges
• Length constraints: Restrict string or binary lengths
• Pattern constraints: Use regular expressions to validate format
• Mandatory constraints: Specify required versus optional nodes
• Presence containers: Containers that exist in configuration to enable/disable functionality

7. RPC Definitions: Remote Procedure Calls allow management systems to invoke operations beyond simple get/set operations.

Example: A reboot RPC might be defined to allow remote device restart with specific parameters.

8. Notifications: Asynchronous messages sent by devices to report events or state changes.

Example: An interface-up notification triggered when a port comes online.

9. Augmentation: The ability to extend existing YANG models by adding new nodes, allowing vendor-specific extensions while maintaining compatibility with standard models.

YANG Processing Workflow:

1. Model Definition: A vendor creates a YANG model defining their device's data structure and operations
2. Compilation: YANG models are typically compiled into intermediate representations for protocol use
3. Protocol Binding: The compiled model is bound to NETCONF or RESTCONF for transport
4. Client Request: A management system requests data using the protocol, referencing the YANG model structure
5. Server Validation: The device validates incoming requests against the YANG model constraints
6. Data Exchange: Configuration or operational data flows between client and device following the model structure
7. Response: Data is returned in a structured format (XML for NETCONF, JSON for RESTCONF) matching the YANG hierarchy

YANG Model Examples and Concepts

Basic YANG Module Structure:

A typical YANG module begins with declarations and then defines the data hierarchy. For example, an interface module might look like:

module: ietf-interfaces
  +--rw interfaces
     +--rw interface* [name]
        +--rw name                string
        +--rw type                identityref
        +--rw enabled?            boolean
        +--rw speed?              string
        +--rw mtu?                uint16
        +--rw statistics
           +--ro in-octets         uint64
           +--ro in-errors         uint64
           +--ro out-octets        uint64
           +--ro out-errors        uint64

Key Symbols in YANG Tree Output:

• +--rw = Read-Write node (configuration)
• +--ro = Read-Only node (operational/state data)
• * = List node
• ? = Optional leaf
• [name] = List key for uniquely identifying list entries

Understanding Augmentation: A vendor might augment the standard ietf-interfaces model with proprietary features:

augment "/ietf-interfaces:interfaces/ietf-interfaces:interface" {
  leaf vendor-specific-feature {
    type string;
  }
}

YANG's Relationship with NETCONF and RESTCONF

NETCONF Integration: YANG models define the structure of data exchanged via NETCONF. NETCONF uses XML for data encoding and RPC for operations, with the YANG model providing the schema.

RESTCONF Integration: RESTCONF is a REST API for network device management that uses YANG models to define API endpoints and data structures. RESTCONF typically uses JSON encoding.

pyang Tool: The pyang tool is used to validate and convert YANG modules, check syntax, and generate tree-style visualizations of the data model.

Common YANG Models in Network Automation

IETF Standard Models: The Internet Engineering Task Force publishes standard YANG models that vendors implement:

• ietf-interfaces: Standard interface configuration and statistics
• ietf-ip: IP address and routing configuration
• ietf-system: System-level configuration like hostname and NTP
• ietf-netconf: NETCONF protocol operations

Vendor-Specific Models: Cisco publishes Cisco IOS XE YANG models, Juniper has Junos OS models, and other vendors maintain their proprietary model sets.

Practical Applications of YANG in Network Automation

Configuration Management: Ansible, Terraform, and other tools use YANG models to understand device capabilities and validate configurations before deployment.

Intent-Based Networking: High-level network intent is translated into device-specific configurations using YANG models as the translation guide.

Multi-Vendor Management: A single orchestration platform can manage devices from multiple vendors by understanding their respective YANG models.

API Generation: RESTCONF automatically generates REST APIs directly from YANG models, reducing custom code development.

Configuration Validation: YANG constraints catch configuration errors before they're sent to devices, improving network reliability.

Exam Tips: Answering Questions on YANG Data Modeling Language

Tip 1: Know the Purpose and Problem YANG Solves

Exam questions often ask "Why use YANG?" or "What problem does YANG address?" Remember that YANG provides standardization for defining network data models, enables vendor-neutral automation, and serves as a contract between management systems and devices. If you see a question about interoperability between devices from different vendors or consistent data definitions, YANG is likely the answer.

Tip 2: Understand the Core Components

Be ready to identify and explain:

• Containers: Grouping mechanisms (answer questions about organization)
• Leaves: Actual data values (answer questions about where values are stored)
• Leaf-lists: Multiple values of same type (answer questions about arrays or collections)
• Lists: Collections with keys (answer questions about indexed data)

If asked "Where would you store multiple IP addresses?" the answer involves leaf-lists or lists depending on context.

Tip 3: Recognize rw vs ro Notation

In tree-formatted YANG output:

• rw (read-write): Configuration data that can be changed
• ro (read-only): Operational/state data that cannot be modified

Exam questions might ask which nodes are operational state versus configuration. The +--rw and +--ro indicators tell you immediately.

Tip 4: Know YANG's Relationship with Protocols

Understand that:

• YANG defines the data model structure
• NETCONF transports configuration using YANG models with XML encoding
• RESTCONF transports configuration using YANG models with JSON encoding (typically)
• The same YANG model can support multiple protocols

If asked how a management system knows what data a device supports, the answer involves YANG models being provided/retrieved by the device.

Tip 5: Master the Concept of Augmentation

Augmentation allows extending existing YANG models with new nodes. Exam questions might present a scenario where a vendor needs to add proprietary features to a standard model without breaking compatibility. The answer is augmentation.

Tip 6: Understand Constraints and Validation

YANG supports various constraints:

• Type constraints (string, int, boolean)
• Range constraints (e.g., 1-65535 for port numbers)
• Length constraints (e.g., max 255 characters)
• Pattern constraints (regex matching)
• Mandatory/presence constraints

Questions about validation or error prevention before data reaches a device should reference YANG constraints.

Tip 7: Know the Difference Between Data Models and Protocols

YANG is a data model language, not a protocol itself. It works with protocols like NETCONF and RESTCONF. If an exam question conflates YANG as a transport protocol, you can eliminate that answer.

Tip 8: Recognize Practical Scenario Questions

Exam questions often present scenarios like:

• "You need to configure multiple DNS servers on a device through an API. What YANG construct would you use?" Answer: leaf-list (multiple values)
• "You want to store interface configurations where each interface is uniquely identified by name. What construct?" Answer: list with name as key
• "You need to add vendor-specific parameters to a standard interface model without modifying the standard. How?" Answer: augment
• "A device reports its current uptime. Can this be modified through NETCONF?" Answer: No, operational data is read-only (ro)

Tip 9: Understand RPC and Notification Definitions

YANG models don't just define data; they can also define:

• RPCs: Operations with input parameters and output responses (e.g., reboot, reset-counters)
• Notifications: Asynchronous events sent from device to management system

Questions about invoking operations or receiving unsolicited updates from devices might reference these concepts.

Tip 10: Practice Reading YANG Tree Output

Get comfortable with tree-formatted YANG output. You should quickly identify:

• The hierarchy and nesting of nodes
• Which nodes are configuration vs operational
• Key leaves in lists
• Optional vs mandatory nodes (presence/absence of ?)

Exam questions often show tree format and ask you to identify what data can be configured or retrieved.

Tip 11: Connect YANG to Real-World Automation Tools

YANG is used by:

• Ansible: Uses YANG to understand device capabilities
• Terraform: Provider plugins use YANG models to know valid configurations
• NETCONF/RESTCONF clients: Understand device APIs through YANG
• Network management platforms: Use YANG to auto-generate user interfaces

Contextual questions about automation might require you to explain YANG's role in these tools.

Tip 12: Remember pyang for Model Validation

The pyang tool is important for:

• Validating YANG module syntax
• Converting between YANG formats
• Generating tree output for visualization
• Checking for semantic errors

If a question asks about tools for working with YANG models, pyang is a key answer.

Tip 13: Focus on Standardization and Vendor Neutrality

A common exam theme is how YANG promotes vendor independence. Standard IETF YANG models allow tools and platforms to work with multiple vendors' devices without custom code for each vendor. If you see questions about interoperability, reducing vendor lock-in, or consistent APIs across platforms, YANG is likely relevant.

Tip 14: Understand Presence Containers

Presence containers are special—their existence in configuration enables a feature. Unlike regular containers that just organize data, a presence container's presence or absence determines if a feature is active.

Example: An OSPF process container might be a presence container—if it exists, OSPF is enabled; if it doesn't exist, OSPF is disabled.

Tip 15: Test Your Understanding

Before the exam, ensure you can answer:

• What is YANG and why is it important?
• What are the main building blocks of a YANG model?
• How does YANG relate to NETCONF and RESTCONF?
• How would you model specific configuration scenarios using YANG concepts?
• What constraints can YANG enforce?
• How does YANG enable vendor-neutral automation?

Key Terminology to Know:

• Container
• Leaf
• Leaf-list
• List
• RPC
• Notification
• Augmentation
• Typedef
• Constraint
• Schema
• Operational data vs Configuration data
• Data model
• pyang

Final Exam Strategy:

When approaching YANG-related exam questions:

1. Identify the core question: Is it about model structure, protocol integration, validation, or practical application?
2. Eliminate obviously wrong answers: YANG is not a protocol, not a transport mechanism, and not a vendor-specific technology.
3. Look for keywords: Standardization, vendor-neutral, automation, interoperability, configuration, validation, data structure.
4. Think practically: Consider real-world scenarios—how would this YANG concept be used in network automation?
5. Trust the hierarchical thinking: YANG is fundamentally about organizing data hierarchically, so think about containment and relationships.