Examkin

All practice questions

229 questions

All types1,987Multiple choice1,020Multiple select452Numeric18Matching229Ordering203Fill in the blank22Short answer43
Question 61Question →

Match each HTTP verb commonly used in REST-based network automation APIs to its corresponding CRUD operation.

Click a left item, then click its matching right item

Items

GET
POST
PUT
DELETE

Matches

Show answer & explanation

Answer

GET maps to Read, POST maps to Create, PUT maps to Update / Replace, and DELETE maps to Delete.
In REST-based APIs, standard HTTP verbs correspond directly to CRUD operations: GET retrieves information (Read), POST creates new resources (Create), PUT updates or overwrites existing resources (Update), and DELETE removes resources (Delete).

Step-by-Step Solution

1
Identify the primary function of each HTTP request method in RESTful web services.
GET retrieves data; POST creates data; PUT updates/replaces data; DELETE removes data.
REST architecture standardizes data operations by mapping HTTP methods directly to database operations.
2
Match each HTTP verb to its corresponding acronym component in CRUD (Create, Read, Update, Delete).
POST = Create, GET = Read, PUT = Update, DELETE = Delete.
This 1-to-1 mapping is a fundamental characteristic of REST-based API design.

Key Concept

Mapping HTTP Verbs to CRUD Operations in RESTful APIs
Question 62Question →

A network automation engineer is building Python scripts to manage network infrastructure via Cisco DNA Center and RESTCONF API endpoints. Match each HTTP request component or operation to its correct RESTful behavior.

Click a left item, then click its matching right item

Items

HTTP POST request targeting a collection URI
HTTP PUT request targeting a specific interface resource
HTTP PATCH request targeting a specific interface resource
Accept header set to application/yang-data+json

Matches

Show answer & explanation

Answer

HTTP POST maps to creating a resource or triggering an async task. HTTP PUT maps to replacing the complete representation of a target resource. HTTP PATCH maps to applying partial modifications to a resource. The Accept header specifies the client's expected response format.
Each item matches its fundamental REST API operational characteristic: HTTP POST creates resources/tasks, HTTP PUT replaces the full representation, HTTP PATCH applies partial updates, and the Accept header defines the expected format of response data.

Step-by-Step Solution

1
Identify the operation performed by HTTP POST in REST APIs.
POST creates child resources or invokes task processing, returning HTTP status codes such as 201 Created or 202 Accepted.
Demonstrate knowledge of HTTP verb to CRUD mapping.
2
Differentiate between HTTP PUT and HTTP PATCH operations.
PUT replaces the complete resource state (omitted fields revert to defaults), whereas PATCH modifies only specified fields (omitted fields remain unchanged).
Distinguish full resource replacement from partial modification in RESTful APIs.
3
Determine the role of the HTTP Accept header.
The Accept header negotiates response encoding (e.g., application/yang-data+json) sent from the server back to the client.
Understand HTTP headers used in RESTCONF and RESTful communications.

Key Concept

Characteristics of REST-Based APIs (CRUD, HTTP Verbs, Data Formats)
Question 63Question →

Match each HTTP request method used in REST-based network management APIs to its primary function and corresponding CRUD operation.

Click a left item, then click its matching right item

Items

GET
POST
PUT
PATCH

Matches

Show answer & explanation

Answer

GET maps to Read (retrieves data), POST maps to Create (creates a new resource), PUT maps to Update/Replace (completely replaces a resource), and PATCH maps to Update/Modify (partially updates specific fields).
In RESTful architecture, standard HTTP request verbs correspond directly to basic CRUD database operations: GET reads resource state, POST creates new resources, PUT completely replaces existing resources, and PATCH performs partial modifications to existing resources.

Step-by-Step Solution

1
Identify the CRUD mapping for retrieving information from a network REST API.
GET corresponds to the Read operation.
GET is a safe and idempotent method used solely to request data from an endpoint.
2
Identify the CRUD mapping for creating new resources.
POST corresponds to the Create operation.
POST submits a payload to an API endpoint to generate a new object or resource.
3
Distinguish between full replacement and partial update HTTP methods.
PUT replaces the resource entirely, while PATCH modifies only specified fields.
PUT requires a full payload representation of the resource, whereas PATCH accepts partial payloads.

Key Concept

HTTP Verbs and CRUD Operations in REST-Based APIs
Estimated Time:45s
Question 64Question →

An enterprise network engineering team is modernizing its operations infrastructure. Match each operational transition on the left with its corresponding primary benefit to network management on the right.

Click a left item, then click its matching right item

Items

Transitioning from SNMP periodic polling to model-driven streaming telemetry
Transitioning from imperative CLI scripts to declarative configuration management
Transitioning from direct device login to API-driven controller orchestration
Transitioning from manual change windows to version-controlled automated pipeline testing

Matches

Show answer & explanation

Answer

Matching operational transitions to network management benefits: (1) SNMP to streaming telemetry correlates to continuous push data replacing CPU-intensive polling; (2) Imperative CLI to declarative management correlates to defining desired state to eliminate configuration drift; (3) Direct device login to controller APIs correlates to abstracting hardware syntax via unified programmatic interfaces; (4) Manual change windows to automated pipeline testing correlates to pre-deployment syntax validation and rollback capabilities.
Each item accurately pairs a key transition in network management automation with its primary operational shift: streaming telemetry replaces SNMP polling overhead with real-time push streams; declarative configuration enforces intended state to reduce drift; controller APIs abstract per-device CLI complexity; and automated pipelines validate changes prior to production deployment.

Step-by-Step Solution

1
Analyze the transition from SNMP polling to streaming telemetry
Identify telemetry push-based operational advantages
SNMP relies on pull-based periodic polling which strains CPU and lacks real-time precision. Streaming telemetry uses subscription-based push models for instant, efficient performance data.
2
Analyze imperative versus declarative configuration models
Identify drift mitigation as the primary benefit of declarative state management
Imperative scripts execute fixed command sequences regardless of baseline state, whereas declarative systems enforce the intended state, detecting and remediating unauthorized drift.
3
Analyze direct device CLI vs API-driven controller management
Identify abstraction of hardware-specific syntax via controller APIs
Controller-based automation abstracts individual box CLI syntaxes, presenting northbound APIs for intent-based fabric orchestration.
4
Analyze version control and automated CI/CD pipeline deployment
Identify automated pre-deployment testing and rollback enforcement
Pipeline automation subjects network changes to linting, dry-runs, and automated testing before applying changes live, facilitating rapid automated rollback if issues arise.

Key Concept

Core shifts in modern network management automation: push telemetry, declarative intent models, controller API abstraction, and CI/CD change validation pipelines.
Question 65Question →

Match each network device operation or architectural component to its corresponding plane of operation or processing path in a modern router or switch architecture.

Click a left item, then click its matching right item

Items

Building the Routing Information Base (RIB) and calculating OSPF Shortest Path First (SPF) metrics via the central processor
Performing hardware-accelerated Forwarding Information Base (FIB) lookups and MAC header rewriting on ASIC line cards
Authenticating SSH administrative sessions and processing NETCONF/RESTCONF RPC requests to update YANG datastores
Generating ICMP Time Exceeded control messages for transit IP packets whose Time-to-Live (TTL) field decrements to zero

Matches

Show answer & explanation

Answer

Building the RIB and calculating OSPF metrics maps to the Control Plane; performing FIB lookups and MAC header rewriting maps to the Data Plane; processing SSH and RESTCONF sessions maps to the Management Plane; and generating ICMP Time Exceeded messages for TTL-expired packets maps to the Exception Path (Punt to Control Plane).
The pairs accurately distinguish between topology computation (Control Plane), line-rate hardware forwarding (Data Plane), administrative system management (Management Plane), and hardware exception redirection (Punt Path).

Step-by-Step Solution

1
Analyze routing protocol logic and topology computation
Mapped to Control Plane
Protocol logic like OSPF calculations and RIB maintenance requires general CPU processing to maintain global network state.
2
Analyze line-rate packet forwarding and hardware frame modification
Mapped to Data Plane
High-speed transit switching relies on compiled FIB/Adjacency tables programmed into hardware TCAM and ASICs.
3
Analyze network administrator management and API transactions
Mapped to Management Plane
Administrative connectivity and configuration state management are isolated within the Management Plane.
4
Analyze hardware forwarding exceptions such as TTL expiration
Mapped to Exception Path (Punt to Control Plane)
When ASIC forwarding hardware encounters conditions requiring ICMP generation, it punts the packet to the CPU process queue.

Key Concept

Separation of Control, Data, and Management Planes with Exception Handling
Question 66Question →

A network automation engineer issues an HTTP GET request to a Cisco IOS-XE RESTCONF API endpoint to retrieve BGP neighbor status details. The router returns the following JSON-encoded response:

{
"Cisco-IOS-XE-bgp:bgp-state-data": {
"bgp-neighbors": [
{
"neighbor-id": "192.168.10.1",
"remote-as": 65001,
"state": "Established",
"address-family": [
{
"af-name": "ipv4-unicast",
"prefixes": {
"accepted": 42,
"sent": 15
}
},
{
"af-name": "vpnv4-unicast",
"prefixes": {
"accepted": 120,
"sent": 88
}
}
]
},
{
"neighbor-id": "192.168.20.2",
"remote-as": 65002,
"state": "Active",
"address-family": [
{
"af-name": "ipv4-unicast",
"prefixes": {
"accepted": 0,
"sent": 0
}
}
]
}
]
}
}

Match each Python dictionary lookup / data extraction expression on the left to its corresponding value or evaluated data type on the right based on the JSON response payload.

Click a left item, then click its matching right item

Items

data["Cisco-IOS-XE-bgp:bgp-state-data"]["bgp-neighbors"][0]["address-family"][1]["prefixes"]["accepted"]
data["Cisco-IOS-XE-bgp:bgp-state-data"]["bgp-neighbors"][1]["remote-as"]
type(data["Cisco-IOS-XE-bgp:bgp-state-data"]["bgp-neighbors"][0]["neighbor-id"])
data["Cisco-IOS-XE-bgp:bgp-state-data"]["bgp-neighbors"][0]["address-family"][0]["af-name"]

Matches

Show answer & explanation

Answer

Each Python expression correctly matches its evaluated output: the nested lookup for the second address family accepted prefixes of neighbor 0 evaluates to 120; the remote-as of neighbor 1 evaluates to integer 65002; the data type of the quoted neighbor-id string evaluates to str; and the first address family name of neighbor 0 evaluates to "ipv4-unicast".
Each expression matches its exact JSON path evaluation according to zero-based array indexing rules and standard JSON data type mapping into Python data structures (objects to dictionaries, lists to arrays, quoted values to strings, unquoted numbers to integers).

Step-by-Step Solution

1
Parse the top-level JSON structure and array indices using zero-based index rules.
Neighbor array index [0] corresponds to neighbor '192.168.10.1'. Neighbor array index [1] corresponds to neighbor '192.168.20.2'.
JSON arrays listed under brackets [] in Python parsing are zero-indexed.
2
Trace nested path queries down into key-value pairs and inner arrays.
Path 1 selects neighbor [0] ('192.168.10.1'), address-family array index [1] ('vpnv4-unicast'), and extracts key 'accepted' with value 120. Path 2 selects neighbor [1] ('192.168.20.2') and extracts key 'remote-as' with value 65002.
Proper path traversal requires following object keys ({}) and array indices ([]) sequentially.
3
Distinguish between JSON primitive types (string vs number/integer).
'neighbor-id' value "192.168.10.1" is enclosed in quotes (string), whereas 'remote-as' value 65002 is unquoted (integer).
JSON represents strings in double quotes and numbers without quotes.

Key Concept

JSON data structure traversal and type interpretation (arrays, objects, strings, integers)
Question 67Question →

A network automation engineer is building Python scripts to interact with Cisco DNA Center and RESTCONF API interfaces. Match each HTTP request configuration on the left to its corresponding RESTful API operational behavior on the right.

Click a left item, then click its matching right item

Items

HTTP PUT to a specific resource URI with a Content-Type payload
HTTP PATCH to a specific resource URI with a Content-Type payload
HTTP POST to a collection URI with an Accept header specified
HTTP GET to a specific resource URI with an If-None-Match header

Matches

Show answer & explanation

Answer

HTTP PUT maps to complete resource replacement (Idempotent); HTTP PATCH maps to partial modification of specified attributes; HTTP POST with an Accept header maps to creating a subordinate resource while specifying expected response encoding; HTTP GET with an If-None-Match header maps to conditional resource retrieval based on ETag validation.
Matching each HTTP request operation to its behavior requires analyzing HTTP verb semantics, idempotency, and header roles in REST APIs. PUT performs complete resource replacement (idempotent), PATCH performs partial attribute modification, POST creates new subordinate resources with Accept defining expected response formatting, and GET with If-None-Match enables conditional retrieval using ETags.

Step-by-Step Solution

1
Analyze HTTP PUT verb characteristics and CRUD mapping
PUT represents a full update/replace operation. It is idempotent and requires transmitting the complete payload structure to overwrite the existing target resource.
Differentiating PUT from PATCH requires recognizing full resource overwrite versus selective attribute modification.
2
Analyze HTTP PATCH verb characteristics and CRUD mapping
PATCH applies delta or partial updates, modifying only the fields included in the request body while leaving all unmentioned parameters intact.
PATCH minimizes payload bandwidth when altering isolated parameters within an existing configuration.
3
Analyze HTTP POST verb behavior and header roles
POST creates new child entities under a target collection endpoint. The Accept header indicates the media type (e.g., application/json) requested for the server's response.
Content-Type describes the request payload format sent to the server, while Accept specifies the desired response format returned by the server.
4
Analyze HTTP GET conditional request headers
GET retrieves resource state without side effects. Including If-None-Match allows the client to perform conditional validation against the server's ETag, saving bandwidth if un-modified.
Conditional headers optimize RESTful network automation workflows by preventing unnecessary data transmission.

Key Concept

Characteristics of REST-Based APIs (CRUD, HTTP Verbs, Data Formats)
Estimated Time:2m 0s
Question 68Question →

Match each architectural concept or communication interface to its corresponding functional role in traditional vs. controller-based networking environments.

Click a left item, then click its matching right item

Items

Northbound API Communication
Centralized Control Plane
Distributed Control Plane
Southbound API Communication

Matches

Show answer & explanation

Answer

Northbound APIs connect the controller with high-level applications; Centralized Control Planes aggregate network intelligence onto a central software controller; Distributed Control Planes require each network device to make independent control decisions locally; Southbound APIs allow the controller to communicate down to physical network infrastructure elements.
In controller-based networking, the control plane is decoupled from physical hardware and centralized on an SDN controller. Northbound APIs enable communication between software applications and the controller, while Southbound APIs allow the controller to configure and program underlying network elements. Traditional networks rely on a distributed control plane where each node executes control protocol algorithms locally.

Step-by-Step Solution

1
Analyze Northbound API functions
Identify that Northbound APIs face 'upward' toward applications and management platforms (REST/JSON).
Northbound APIs connect business applications to the centralized controller.
2
Analyze Centralized Control Plane functions
Recognize that control plane logic is removed from individual devices and relocated to a central software-defined controller.
The controller uses a global network view to compute paths centrally.
3
Analyze Distributed Control Plane functions
Recall traditional networking mechanics where every router and switch independently exchanges control messages to build forwarding databases.
In traditional deployments, control decisions are distributed per device.
4
Analyze Southbound API functions
Identify that Southbound APIs face 'downward' toward infrastructure nodes (NETCONF, RESTCONF, OpenFlow).
Southbound APIs push instructions from the SDN controller down to network devices.

Key Concept

Structural and functional distinctions between traditional distributed networks and controller-based SDN architectures.
Question 69Question →

A network engineer is implementing automated API calls against a Cisco Catalyst Center controller. Match each HTTP request verb to its corresponding CRUD operation and database handling behavior.

Click a left item, then click its matching right item

Items

HTTP POST
HTTP PUT
HTTP PATCH
HTTP DELETE

Matches

Show answer & explanation

Answer

HTTP POST matches creating a new collection resource (CRUD: Create); HTTP PUT matches full resource replacement (CRUD: Update/Replace); HTTP PATCH matches partial attribute updates (CRUD: Update/Modify); HTTP DELETE matches target resource removal (CRUD: Delete).
In REST-based automation, HTTP verbs map directly to specific CRUD operations: POST instantiates new entries, PUT performs a full resource replacement, PATCH updates partial attributes, and DELETE removes resources.

Step-by-Step Solution

1
Map the resource creation and deletion verbs to their primary CRUD definitions.
POST creates new sub-resources under a endpoint collection, while DELETE removes existing resources.
RESTful conventions define POST for creation operations and DELETE for resource removal.
2
Differentiate between full and partial resource update operations.
PUT executes a complete replacement of the entity, whereas PATCH updates only designated fields.
Sending a PUT request replaces the entire target state, while PATCH modifies specific attributes without wiping omitted parameters.

Key Concept

RESTful API HTTP Verbs and CRUD Mapping
Question 70Question →

A network automation engineer is selecting configuration management tools for an enterprise infrastructure overhaul. Match each configuration management mechanism or artifact on the left with its corresponding operational model, transport mechanism, and configuration language characteristics on the right.

Click a left item, then click its matching right item

Items

Ansible
Puppet
Chef
Ansible Playbook

Matches

Show answer & explanation

Answer

Ansible matches with the agentless push model using SSH/NETCONF and YAML; Puppet matches with the agent-based pull model communicating over TCP 8140 using Puppet DSL manifests; Chef matches with the agent-based pull model communicating over TCP 443 using Ruby DSL recipes; Ansible Playbook matches with the YAML-encoded file mapping host inventory groups to task executions.
Each automation mechanism exhibits specific architectural and transport signatures. Ansible uses an agentless push architecture over SSH/NETCONF with YAML files (Playbooks). Puppet uses an agent-based pull model communicating over TCP port 8140 with Puppet DSL manifests. Chef uses an agent-based pull model communicating over TCP port 443 (HTTPS) with Ruby DSL recipes.

Step-by-Step Solution

1
Analyze Ansible's core architecture and communication method.
Ansible is agentless, uses an active push model, relies on SSH/NETCONF for network devices, and uses YAML formatting.
Eliminates the requirement to install local daemon agents on network switches and routers.
2
Analyze Puppet's operational model, transport ports, and configuration structure.
Puppet defaults to an agent-based pull model, communicates with a central master over TCP port 8140, and uses Puppet DSL manifests.
Agents periodically poll the Puppet Master to pull catalog updates and maintain state enforcement.
3
Analyze Chef's operational model, transport ports, and configuration structure.
Chef uses an agent-based pull model, communicates with the Chef server over TCP port 443 (HTTPS), and utilizes Ruby DSL recipes/cookbooks.
Chef Client runs periodically on target nodes to pull recipes from the server.
4
Identify the role and structure of an Ansible Playbook.
An Ansible Playbook is the YAML document containing plays, host specifications, and task lists executed by Ansible.
Distinguishes the tool framework (Ansible) from its execution file artifact (Playbook).

Key Concept

Capabilities and Architectural Differences of Network Configuration Management Tools (Ansible, Puppet, Chef)
Question 71Question →

Match each Cisco Software-Defined Architecture component or protocol on the left with its corresponding architectural role or operational function on the right.

Click a left item, then click its matching right item

Items

Physical Routed Underlay
VXLAN Overlay Data Plane
LISP Fabric Control Plane
Fabric Edge Node

Matches

Show answer & explanation

Answer

The Physical Routed Underlay provides transport IP reachability via traditional routing protocols; the VXLAN Overlay Data Plane encapsulates data frames into UDP packets; the LISP Fabric Control Plane manages the mapping database between Endpoint Identifiers (EIDs) and Routing Locators (RLOCs); and the Fabric Edge Node authenticates endpoints and initiates overlay encapsulation.
In software-defined fabric architectures, responsibilities are strictly divided: the physical routed underlay provides IP transport for fabric nodes using standard IGPs; VXLAN handles data plane encapsulation of user traffic into UDP tunnels; LISP acts as the control plane to map host identities (EIDs) to switch locations (RLOCs); and Fabric Edge nodes interface directly with endpoints to perform authentication and overlay encapsulation.

Step-by-Step Solution

1
Identify the primary role of the Physical Routed Underlay.
Determined that the underlay strictly provides underlying IP reachability between switch loopback interfaces using standard IGPs.
The underlay infrastructure provides basic packet transport between fabric switches and operates independently of overlay endpoints.
2
Identify the function of the VXLAN Overlay Data Plane.
Matched VXLAN to data plane encapsulation of Layer 2 frames within UDP port 4789 headers.
VXLAN is the data plane encapsulation standard used in modern software-defined fabrics to tunnel endpoint traffic over an IP underlay.
3
Identify the function of the LISP Fabric Control Plane.
Matched LISP to the control plane tracking mechanism that maps EID host addresses to RLOC switch addresses.
LISP eliminates the need for broadcast-based flood-and-learn mechanisms by maintaining an explicit mapping database of host locations.
4
Identify the operational responsibilities of the Fabric Edge Node.
Matched the Fabric Edge Node to connecting, authenticating, and encapsulating endpoint traffic into the fabric overlay.
Fabric Edge nodes act as first-hop access switches where endpoints connect and where overlay tunnel encapsulation originates.

Key Concept

Software-Defined Fabric Architecture: Separation of Underlay, Overlay Data Plane, Control Plane, and Edge Roles
Estimated Time:2m 0s
Question 72Question →

A network automation engineer sends an HTTP GET request to a Cisco IOS XE RESTCONF endpoint to check IP SLA operation status. The API returns the following JSON payload:

{
"Cisco-IOS-XE-sla:sla": {
"ip-sla": [
{
"oper-id": 101,
"type": "icmp-echo",
"destination": "192.168.50.1",
"stats": {
"rtt-ms": 14,
"state": "active",
"history": [
{"sample-id": 1, "rtt": 12, "success": true},
{"sample-id": 2, "rtt": 16, "success": true}
]
}
},
{
"oper-id": 102,
"type": "udp-jitter",
"destination": "10.10.20.5",
"stats": {
"rtt-ms": 4,
"state": "inactive",
"history": [
{"sample-id": 1, "rtt": 4, "success": false}
]
}
}
]
}
}

Based on the JSON payload provided above, match each data extraction path on the left to its correct extracted value and data type on the right.

Click a left item, then click its matching right item

Items

`Cisco-IOS-XE-sla:sla` → `ip-sla[0]` → `stats` → `state`
`Cisco-IOS-XE-sla:sla` → `ip-sla[1]` → `destination`
`Cisco-IOS-XE-sla:sla` → `ip-sla[0]` → `stats` → `history[1]` → `rtt`
`Cisco-IOS-XE-sla:sla` → `ip-sla[1]` → `stats` → `history[0]` → `success`

Matches

Show answer & explanation

Answer

The correct matches map each zero-indexed JSON array path to its corresponding value and type: `ip-sla[0]->stats->state` maps to `"active" (String)`, `ip-sla[1]->destination` maps to `"10.10.20.5" (String)`, `ip-sla[0]->stats->history[1]->rtt` maps to `16 (Number)`, and `ip-sla[1]->stats->history[0]->success` maps to `false (Boolean)`.
All four extraction paths correctly evaluate zero-based array indices (`[0]` for first element, `[1]` for second element) and trace object key structures to their exact primitive values and data types.

Step-by-Step Solution

1
Locate top-level keys and array indices
The top-level key `Cisco-IOS-XE-sla:sla` contains an array named `ip-sla`. Index `[0]` refers to the first object (`oper-id` 101), and index `[1]` refers to the second object (`oper-id` 102).
JSON arrays use zero-based indexing, where the first element is at index 0.
2
Extract direct keys from array elements
For `ip-sla[0] -> stats -> state`, the value is `"active"`. For `ip-sla[1] -> destination`, the value is `"10.10.20.5"`.
Navigating directly through key-value maps yields the string values bound to those keys.
3
Traverse nested array elements and primitives
For `ip-sla[0] -> stats -> history[1] -> rtt`, index `[1]` of `history` points to sample-id 2, returning `16`. For `ip-sla[1] -> stats -> history[0] -> success`, index `[0]` points to sample-id 1, returning `false`.
Properly indexing sub-arrays prevents off-by-one errors and identifies data types such as numbers vs. booleans.

Key Concept

Traversing nested JSON objects and zero-indexed arrays returned by Cisco REST APIs.
Question 73Question →

An enterprise network architect is creating documentation to clarify plane responsibilities and interfaces in traditional versus software-defined controller-based architectures. Match each operational task or network behavior on the left to the corresponding architectural component or interface model on the right.

Click a left item, then click its matching right item

Items

Independent, hop-by-hop calculation of routing topology and state maintenance on each individual device
Exposure of RESTful APIs allowing external management applications and scripts to communicate intent to the controller
Provisioning and device configuration management via protocols like NETCONF and RESTCONF from the central controller to nodes
Line-rate frame switching and packet forwarding performed locally in ASIC hardware based on FIB tables

Matches

Show answer & explanation

Answer

Independent hop-by-hop topology calculation pairs with Traditional Distributed Control Plane; RESTful API exposure to management applications pairs with Controller Northbound Interface (NBI); Device provisioning via NETCONF/RESTCONF pairs with Controller Southbound Interface (SBI); Line-rate ASIC forwarding pairs with Controller-Based Data Plane (SDN Data Plane).
Independent routing calculations define traditional distributed control planes where every node operates autonomously. Northbound interfaces expose REST APIs for applications to automate network policies through the controller. Southbound interfaces enable the controller to program and monitor network elements using protocols such as NETCONF or RESTCONF. Localized ASIC-based forwarding represents the data plane, which continues to reside on physical network hardware in both traditional and controller-based models.

Step-by-Step Solution

1
Analyze the operational task of independent local routing topology calculation.
Corresponds to the Traditional Distributed Control Plane.
Traditional devices run distributed control algorithms (like OSPF or EIGRP) on each node independently.
2
Analyze the role of RESTful APIs communicating intent from applications to the controller.
Corresponds to the Controller Northbound Interface (NBI).
Northbound interfaces face upward toward orchestrators, business logic, and applications.
3
Analyze the role of protocols pushing configuration down from controller to network nodes.
Corresponds to the Controller Southbound Interface (SBI).
Southbound interfaces face downward from the controller to manage physical or virtual infrastructure switches and routers.
4
Analyze line-rate hardware forwarding in ASIC hardware.
Corresponds to the Controller-Based Data Plane.
Data plane packet forwarding remains local to network hardware to handle traffic without sending every packet to the central controller.

Key Concept

Distinction between control plane, data plane, Northbound APIs, and Southbound APIs in traditional vs controller-based architectures.
Estimated Time:1m 30s
Question 74Question →

A network automation engineer is building a Python script to interact with a Cisco REST-based API. Match each HTTP request verb on the left to its corresponding operational characteristic or CRUD function on the right.

Click a left item, then click its matching right item

Items

POST
GET
PUT
PATCH

Matches

Show answer & explanation

Answer

POST matches with creating a new resource under a target URI, GET matches with retrieving resource representation without making modifications, PUT matches with replacing the entire target resource with the provided payload, and PATCH matches with applying partial modifications to specific fields of an existing resource.
Each HTTP verb directly aligns with specific REST CRUD semantics: POST creates new resources under an endpoint; GET retrieves existing resource states safely; PUT overwrites and completely replaces the target resource entity; and PATCH modifies select attributes of an existing resource without disturbing unreferenced attributes.

Step-by-Step Solution

1
Identify the primary CRUD operations for retrieve and create actions in REST APIs.
POST corresponds to resource creation (Create), while GET corresponds to retrieving data (Read).
GET is an idempotent and safe read-only operation, whereas POST sends data to create a new resource entry.
2
Distinguish between full replacement (PUT) and partial update (PATCH) behaviors.
PUT completely overwrites the existing target resource, while PATCH modifies only specified resource fields.
PUT requires a complete resource representation in the request payload, whereas PATCH updates targeted attributes without modifying omitted fields.

Key Concept

REST HTTP Verbs to CRUD Operations Mapping
Question 75Question →

In a modern enterprise network transitioning from traditional routing to a software-defined fabric architecture, different operational tasks are assigned to distinct functional planes. Match each specific network task or protocol operation to the corresponding architectural plane responsible for executing it.

Click a left item, then click its matching right item

Items

Processing gNMI streaming telemetry and executing REST API configuration calls from an administrative platform
Building the local Routing Information Base (RIB) and processing incoming OSPF Hello packets on the switch CPU
Performing wire-speed ASIC TCAM table lookups and handling VXLAN header encapsulation for ingress data frames
Maintaining fabric-wide LISP endpoint mapping databases and dynamically pushing control policies to edge nodes

Matches

Show answer & explanation

Answer

Processing gNMI/REST APIs matches Management Plane; Building local RIB and OSPF Hellos matches Distributed (Local) Control Plane; ASIC TCAM lookups and VXLAN encapsulation matches Data Plane (Forwarding Plane); Maintaining LISP mapping database matches Centralized Controller Control Plane.
Administrative monitoring and programmatic configuration interfaces (gNMI/REST APIs) reside in the Management Plane. Local routing engine tasks like OSPF neighbor maintenance and RIB construction execute within the Distributed (Local) Control Plane on the device CPU. Hardware-accelerated packet switching, TCAM lookups, and VXLAN header manipulations take place purely in the Data Plane. Centralized fabric-wide mapping databases (LISP) and policy distribution are functions of the Centralized Controller Control Plane.

Step-by-Step Solution

1
Identify administrative and monitoring functions
Handling REST API calls and gNMI telemetry fall under system administration and device monitoring tasks.
Administrative access, configuration interfaces, and external telemetry generation operate within the management plane.
2
Analyze local routing daemon operations
OSPF Hello packet processing and RIB compilation require local CPU compute resources on the network device.
Local routing protocols run in software as part of the distributed control plane on individual network nodes.
3
Examine line-rate packet forwarding and encapsulation
TCAM lookups and VXLAN encapsulation take place in specialized hardware ASICs without invoking the main CPU.
The data plane is dedicated to high-speed, hardware-based packet handling and forwarding along the path of user traffic.
4
Analyze centralized SDN fabric mapping operations
Managing fabric endpoint location maps via LISP across multiple nodes is handled by the central controller software.
In software-defined architectures, control plane intelligence and endpoint mapping databases are offloaded from edge switches to a centralized controller control plane.

Key Concept

Separation of Management, Local Control, Centralized Control, and Data Planes in Enterprise SDN Architectures
Question 76Question →

Match each architectural concept to its corresponding description within traditional and controller-based networking environments.

Click a left item, then click its matching right item

Items

Southbound Interface (SBI)
Northbound Interface (NBI)
Distributed Control Plane
Centralized Control Plane

Matches

Show answer & explanation

Answer

Southbound Interface pairs with communication between controller and forwarding elements via protocols like NETCONF/OpenFlow. Northbound Interface pairs with RESTful API communication between controller and applications. Distributed Control Plane pairs with autonomous per-device processing. Centralized Control Plane pairs with consolidated global topology control.
The correct pairings accurately map interface directions and control plane locations: Southbound Interfaces interact downwards with physical or virtual network devices via protocols such as NETCONF, RESTCONF, or OpenFlow; Northbound Interfaces interact upwards with applications and management suites using REST APIs; Distributed Control Planes compute logic independently per device; and Centralized Control Planes aggregate network intelligence into a controller to manage policies centrally.

Step-by-Step Solution

1
Identify controller communication directionality (Northbound vs. Southbound).
Northbound interfaces point up toward applications/REST APIs; Southbound interfaces point down toward network switches/routers using protocols like NETCONF, RESTCONF, or OpenFlow.
Establishing API directional planes differentiates controller-based interface functions.
2
Differentiate control plane placement (Distributed vs. Centralized).
Traditional distributed control planes compute routing tables locally on every switch/router, whereas controller-based centralized control planes consolidate network logic within a central controller.
Locating control plane logic is the fundamental structural distinction between traditional and SDN-based network architectures.

Key Concept

Architectural Plane and Interface Separation in Traditional vs. Controller-Based Networks
Question 77Question →

Match each configuration management tool on the left with its corresponding operational traits, communication protocols, and file terminology on the right.

Click a left item, then click its matching right item

Items

Ansible
Puppet
Chef

Matches

Show answer & explanation

Answer

Ansible matches with the agentless push architecture using YAML Playbooks over SSH/NETCONF. Puppet matches with the pull model using Puppet DSL Manifests over TCP port 8140. Chef matches with the pull model using Ruby-based Recipes and Cookbooks over TCP port 443.
Ansible is distinct for its agentless push model using SSH and YAML Playbooks. Puppet operates via an agent pull model requesting Manifests over TCP 8140. Chef operates via an agent pull model fetching Ruby-based Recipes and Cookbooks over HTTPS (TCP 443).

Step-by-Step Solution

1
Identify the agent requirement and transport protocol for each tool.
Ansible is agentless (SSH/NETCONF), while Puppet (TCP 8140) and Chef (TCP 443) require client agent software.
Agentless operation is a unique distinguishing operational characteristic of Ansible.
2
Determine the data encoding format or domain-specific language (DSL) used by each tool.
Ansible uses YAML, Puppet uses Puppet DSL, and Chef uses Ruby-based DSL.
File formats directly map to tool-specific terminology and structures.
3
Associate file names and operational direction with each tool.
Ansible uses Playbooks (Push), Puppet uses Manifests (Pull), and Chef uses Recipes/Cookbooks (Pull).
Matching push vs pull and configuration artifact naming establishes complete tool identification.

Key Concept

Capabilities and Architectural Traits of Configuration Management Tools (Ansible, Puppet, Chef)
Question 78Question →

When interacting with RESTful network APIs, network engineers use specific HTTP request verbs to execute CRUD (Create, Read, Update, Delete) operations against management endpoints. Match each HTTP request verb on the left to its corresponding operational behavior on the right.

Click a left item, then click its matching right item

Items

HTTP POST
HTTP GET
HTTP PUT
HTTP PATCH
HTTP DELETE

Matches

Show answer & explanation

Answer

HTTP POST matches creating a new subordinate resource; HTTP GET matches retrieving data safely; HTTP PUT matches full resource replacement; HTTP PATCH matches partial field modification; HTTP DELETE matches resource removal.
Each HTTP verb corresponds directly to a standard CRUD action in RESTful architectures. POST creates new entries, GET reads existing data, PUT overwrites/replaces entire resources, PATCH updates specific fields partially, and DELETE erases targeted resources.

Step-by-Step Solution

1
Identify the mapping between HTTP POST and CRUD operations.
HTTP POST performs the Create operation by instantiating new data resources under a collection URI.
POST is used for creating new entries when the client does not specify the exact final resource URI.
2
Identify the mapping between HTTP GET and CRUD operations.
HTTP GET performs the Read operation by retrieving data without making changes.
GET requests are read-only, safe, and idempotent.
3
Distinguish between HTTP PUT and HTTP PATCH for Update operations.
HTTP PUT performs a full update (replacement), whereas HTTP PATCH performs a partial update.
PUT overwrites the entire target resource with the provided payload, whereas PATCH only modifies specified key-value pairs.
4
Identify the mapping between HTTP DELETE and CRUD operations.
HTTP DELETE performs the Delete operation.
DELETE instructs the API endpoint to erase the target resource.

Key Concept

RESTful API HTTP verbs map directly to basic database CRUD operations (POST=Create, GET=Read, PUT/PATCH=Update, DELETE=Delete).
Question 79Question →

Match each software-defined architecture component or protocol on the left with its corresponding operational role within a Cisco enterprise fabric on the right.

Click a left item, then click its matching right item

Items

VXLAN
LISP
Underlay Network
Cisco DNA Center

Matches

Show answer & explanation

Answer

VXLAN pairs with data plane frame encapsulation via UDP tunnels; LISP pairs with control plane mapping of EIDs to RLOCs; Underlay Network pairs with physical connectivity and Layer 3 IP routing reachability; Cisco DNA Center pairs with centralized management plane orchestration and policy automation.
VXLAN handles data plane encapsulation by tunneling Layer 2 Ethernet frames over Layer 3 UDP headers. LISP functions as the fabric control plane mapping protocol connecting EIDs to RLOCs. The underlay network consists of the physical devices and IP routing protocols that provide base reachability across switches. Cisco DNA Center serves as the centralized management controller responsible for network automation, provisioning, and policy management.

Step-by-Step Solution

1
Identify the data plane overlay tunneling mechanism.
VXLAN uses MAC-in-UDP encapsulation to build overlay tunnels across Layer 3 boundaries.
Overlay data planes require encapsulating original host frames so they can cross intermediate routed infrastructure transparently.
2
Identify the control plane protocol responsible for host mapping.
LISP maintains the mapping database connecting host IP/MAC addresses (EIDs) to their switch location (RLOCs).
Separating host location from identity minimizes flooding and enables endpoint mobility.
3
Identify the infrastructure base supporting overlay communication.
The underlay network provides basic IP routing connectivity between physical switch interfaces.
Fabric nodes must establish IP reachability via IGP routing protocols prior to forming overlay tunnels.
4
Identify the centralized management platform.
Cisco DNA Center manages policy, orchestration, and provisioning across the fabric.
Management plane platforms aggregate controller operations into a single interface for intent-based network management.

Key Concept

Software-Defined Architectures: Overlay, Underlay, and Fabric plane separation
Question 80Question →

Match each HTTP request method used in network automation REST APIs to its corresponding CRUD operation and operational behavior.

Click a left item, then click its matching right item

Items

HTTP GET
HTTP POST
HTTP PUT
HTTP PATCH
HTTP DELETE

Matches

Show answer & explanation

Answer

HTTP GET matches Read (safe/idempotent data retrieval); HTTP POST matches Create (non-idempotent resource creation); HTTP PUT matches Update (idempotent full replacement); HTTP PATCH matches Update (partial field modification); HTTP DELETE matches Delete (resource removal).
In RESTful web services, HTTP verbs map directly to CRUD operations: GET to Read (retrieves resources without side effects), POST to Create (adds a new sub-resource), PUT to Update (replaces an entire resource), PATCH to Update (modifies selected fields), and DELETE to Delete (removes a resource).

Step-by-Step Solution

1
Identify the basic CRUD operations for retrieving and removing data.
HTTP GET performs the Read operation without altering server state, while HTTP DELETE performs the Delete operation to remove a resource.
GET and DELETE are standard operations for viewing and removing targeted API resources.
2
Determine the resource creation method.
HTTP POST maps to Create and is non-idempotent because executing it multiple times creates multiple distinct items.
POST submits data to be processed by a parent resource.
3
Distinguish between the two update methods (PUT vs. PATCH).
HTTP PUT performs a full resource replacement, while HTTP PATCH performs a partial update.
PUT replaces the complete payload representation at the target URI, whereas PATCH modifies only the specified parameters inside the existing resource.

Key Concept

RESTful HTTP Verbs and CRUD Mapping
Estimated Time:1m 30s
PreviousPage 4 / 12Next
All practice questions — Cisco CCNA | Examkin