JNCIA-DevOps Hard Questions — 25 Difficult Questions

Question 1

An automation engineer is troubleshooting a Junos REST API script that intermittently fails with HTTP 401 Unauthorized errors when retrieving operational data. The script uses HTTP Basic Authentication with a valid username and password. The engineer confirms that the credentials are correct and that the REST API is enabled. What is the most likely cause of the intermittent failures?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

The device is configured to use RADIUS authentication, and the RADIUS server is occasionally unreachable.. Intermittent 401 Unauthorized errors with valid credentials often stem from external authentication server issues. When a Junos device is configured to use RADIUS or TACACS+ for user authentication, temporary server unreachability can cause authentication failures. The REST API uses the device's configured authentication methods, so an unreachable RADIUS server would result in 401 responses.

Answer

The script is exceeding the maximum number of concurrent REST API sessions, causing new requests to be rejected with 401.

Answer

The device's clock is out of sync with the authentication server, causing token-based authentication to fail.

Answer

The REST API requires the use of a session cookie instead of Basic Authentication for operational requests.

Question 2

A Python automation script parses a Junos telemetry stream in JSON. The JSON payload uses integer keys in a dictionary (e.g., {443: 'HTTPS'}). When loaded into Python using json.loads(), what data type do the dictionary keys become?

Accepted Answer

They are converted to Python string objects.. JSON specification dictates that object keys must be strings. When json.loads() parses an object, any keys (even if numeric-looking) are converted to Python strings.

Answer

They are converted to floating-point numbers.

Answer

They remain integer objects.

Answer

The parser raises a KeyError because JSON keys must be alphabetic.

Question 3

A Python script using PyEZ loads a configuration from a file and commits it on a Junos device. The commit fails with a `CommitError` exception. You need to retrieve the specific error message returned by the device. Which method or attribute should you use to obtain the detailed error text?

Accepted Answer

`exception.errs`. When a commit fails, PyEZ raises `CommitError` with an `errs` attribute containing a list of error details from the device. Iterating over `exception.errs` provides the specific commit error messages. Other attributes like `message`, `detail`, or `response` are not the correct way to retrieve these details.

Answer

`exception.detail`

Answer

`exception.message`

Answer

`exception.response`

Question 4

You are writing a Python script that converts a Junos operational state output from XML (via NETCONF) into JSON. The XML structure contains sibling elements with the same tag name. When converted naively, how do standard XML-to-JSON conversion libraries (like xmltodict) typically represent these repeated sibling elements in the resulting JSON dictionary?

Accepted Answer

As a JSON array containing multiple objects.. Conversion libraries like xmltodict represent repeated sibling XML elements as a JSON array (list) to preserve all instances under a single key.

Answer

By appending numeric indexes to every key name automatically.

Answer

By raising a DuplicateElementException.

Answer

By overwriting previous elements so only the last element is retained.

Question 5

An automation script needs to convert a JSON string containing Juniper interface statistics into a YAML format to maintain consistency with existing Ansible variable files. When performing this conversion, which structural capability does YAML support that standard JSON does not?

Accepted Answer

Support for comments. YAML natively supports complex keys (such as using objects or tuples as keys) and comments, whereas standard JSON requires all keys to be strings and does not support comments.

Answer

Support for numeric floating-point values

Answer

Support for boolean data types

Answer

Support for nested arrays

Question 6

When configuring the Junos REST API, an administrator restricts access to a specific port and enables SSL. Which configuration statement sets the secure HTTPS port to 8443?

Accepted Answer

set system services jpagent https port 8443. To customize the HTTPS port for the jpagent service in Junos, the administrator uses the 'set system services jpagent https port 8443' command.

Answer

set protocols rest-api https port 8443

Answer

set system services rest port 8443 secure

Answer

set system services netconf https-port 8443

Question 7

An engineer is designing an automated failover script that needs to discard candidate configuration changes made via the Junos REST API. How should this discard action be performed?

Accepted Answer

Send a request to the configuration discard/rollback endpoint or invoke the discard-changes RPC via the REST API.. To discard candidate configuration changes via the Junos REST API, you must send a request to the configuration discard/rollback endpoint or invoke the discard-changes RPC. The REST API provides a specific endpoint for this action, typically a POST to /api/configuration/discard or using the 'discard-changes' RPC. This is the correct way to revert uncommitted changes.

Answer

Send an HTTP GET request with ?action=reset.

Answer

Issue an HTTP DELETE request to the root /api/configuration path.

Answer

Restart the routing engine process (RE switchover).

Question 8

An engineer needs to retrieve the entire candidate configuration in JSON format from a Junos device using the Junos REST API. Which HTTP header must be included in the GET request to ensure the response is returned in JSON format?

Accepted Answer

Accept: application/json. The Accept header with 'application/json' specifies that the client expects the response to be formatted in JSON.

Answer

Transfer-Encoding: chunked

Answer

Content-Type: text/xml

Answer

X-Junos-Data-Format: json

Question 9

When writing an automation script that converts data formats between YAML and JSON for Junos configuration pipelines, which THREE potential pitfalls should an engineer account for? (Choose three)

Accepted Answer

JSON integer keys are automatically converted to strings in Python dictionaries.. Option C is correct because JSON object keys are always strings, so when Python's json module loads a JSON document, any key that appears numeric (e.g., 1) becomes the string '1', which can break lookups or round-trips if the script expects an integer key. Option D is correct because JSON has no comment syntax, so any YAML comments (# ...) are discarded by the YAML parser and cannot be represented in the resulting JSON output. Option E is correct because YAML 1.1 parsers interpret unquoted scalars such as 'yes'/'no' as booleans and leading-zero values like 012 as octal integers, silently changing the data type unless the scalars are explicitly quoted. Option A is wrong because YAML does not guarantee lossless round-trip conversion for arbitrary Python objects (custom types, tuples, sets, etc. require tags or custom representers). Option B is wrong because JSON has no native support for YAML anchors and aliases; those are YAML-specific features that must be resolved before JSON serialization.

Answer

YAML automatically guarantees lossless round-trip conversion for all Python objects.

Answer

JSON files natively support YAML anchors and aliases.

Question 10

You want to run a JSNAPy verification test via Python code. Which Python class should you import and instantiate to execute the snapshot comparison programmatically?

Accepted Answer

from jnpr.jsnapy import SnapAdmin. The SnapAdmin class from the jnpr.jsnapy module is the main entry point for programmatically running JSNAPy operations, including taking snapshots and comparing them. You import it with 'from jnpr.jsnapy import SnapAdmin' and instantiate it to call methods like snap() and check(). This is the documented Python API for JSNAPy.

Answer

from jnpr.jsnapy.verify import VerifyEngine

Answer

from jnpr.junos.utils.jsnapy import JSNAPy

Answer

from jnpr.jsnapy.runner import JSNAPyRunner

Question 11

When developing Python scripts that utilize PyEZ and Jinja2, which THREE best practices ensure robust and maintainable automation code? (Choose three)

Accepted Answer

Using the PyEZ Config context manager to ensure locks are released and rollbacks occur on error. Option A is correct because the PyEZ Config context manager (with Config(dev) as cu:) automatically acquires the configuration lock, and on an exception it discards the candidate configuration and releases the lock, preventing stale locks and partial commits. Option C is correct because catching specific PyEZ exceptions such as ConnectError, ConfigError, LockError, and CommitError lets scripts handle connection and configuration failures precisely rather than masking all errors with a bare except. Option E is correct because keeping Jinja2 templates in separate .j2 files (loaded via Environment with FileSystemLoader) separates presentation from logic, improving readability, reuse, and maintainability. Option B is wrong because hardcoding administrative passwords in template files exposes credentials and violates secure secret-handling practices. Option D is wrong because omitting device.close() leaks NETCONF/SSH sessions and consumes device and client resources; sessions should be closed when work is complete.

Answer

Hardcoding administrative passwords inside template files for easy rendering

Answer

Avoiding device.close() calls to keep network sessions open permanently

Question 12

When using PyEZ to push a configuration, you want to log out all NETCONF XML traffic exchanged between the script and the Junos device for debugging purposes. How do you enable this logging in Python?

Accepted Answer

Configuring Python logging for the 'jnpr.junos' logger with DEBUG level. PyEZ uses Python's standard `logging` module and emits all NETCONF XML traffic under the `jnpr.junos` logger hierarchy. Setting that logger to DEBUG level (via `logging.getLogger('jnpr.junos').setLevel(logging.DEBUG)` plus a handler) causes the full request/response XML to be logged. There is no PyEZ-specific debug flag or `dev.debug` attribute that performs this function.

Answer

import jnpr.junos.debug; jnpr.junos.debug.enable()

Answer

dev.rpc.trace(enabled=True)

Answer

dev.debug = True

Question 13

Which TWO components are essential parts of a model-driven network automation architecture on Junos devices? (Choose two)

Accepted Answer

YANG data models defining the structure and constraints of configuration and state data. Option A is correct because YANG data models are the foundational schema in a model-driven architecture, formally defining the structure, hierarchy, types, and constraints of both configuration and state data on Junos devices, enabling programmatic and vendor-neutral interaction. Option B is correct because model-driven automation requires standardized, model-aware management protocols — NETCONF (typically over SSH on port 830) and gRPC/gNMI — to transport YANG-modeled data and support operations like get-config, edit-config, and telemetry, rather than relying on human-readable CLI output. Options C, D, and E are not part of a model-driven architecture: Telnet terminal emulation, screen-scraping PERL scripts that parse raw CLI text, and physical serial port multiplexers all represent legacy, CLI-centric or hardware-centric approaches that lack structured data models and standardized programmatic interfaces.

Answer

Manual terminal emulation sessions using Telnet

Answer

Proprietary screen-scraping PERL scripts parsing raw CLI text

Answer

Physical serial port multiplexers

Question 14

An automation engineer is designing a deployment strategy for Junos devices using Git branches. Which branching strategy model aligns best with continuous delivery where feature branches are merged frequently into a shared integration branch that automatically triggers staging tests?

Accepted Answer

Trunk-based development where developers merge small, frequent changes into a central main branch that drives automated pipelines.. Trunk-based development aligns best with continuous delivery because developers merge small, frequent changes into a central main branch, which automatically triggers staging tests via CI/CD pipelines. This reduces merge conflicts, shortens feedback loops, and keeps the main branch always deployable.

Answer

Creating a separate permanent branch for every physical router in the network and never merging them.

Answer

Locking the master branch for 12 months while developing a single monolithic configuration update offline.

Answer

Using tag-based releases exclusively without utilizing any version control branches.

Question 15

An engineer compares NETCONF and Junos REST API when fetching operational state via RPCs. How does the REST API transmit an RPC request compared to a NETCONF <rpc> wrapper?

Accepted Answer

REST API uses HTTP POST/GET requests targeting specific RPC URI paths, translating JSON/XML parameters, whereas NETCONF sends raw XML RPC elements over a dedicated SSH subsystem.. NETCONF wraps queries in an XML <rpc> element over a persistent SSH channel. The Junos REST API maps RPCs to HTTP methods (such as GET or POST) targeting specific URI endpoints under /api/operational/ or /api/rpc/, translating the payload to JSON or XML without needing a raw NETCONF XML envelope.

Answer

There is no functional difference; REST API is simply an alias for NETCONF over port 830.

Answer

NETCONF uses HTTP status codes for error reporting, while REST API uses standard syslog messages.

Answer

REST API requires a persistent WebSocket connection that tunnels NETCONF XML streams.

Question 16

An automation engineer is designing a Python script that converts Junos device configuration data between JSON and YAML formats. The script must correctly handle data types to avoid misconfiguration. Which TWO statements about JSON and YAML data type handling are correct? (Choose two.)

Accepted Answer

YAML represents a null value with the tilde (~) character.. YAML's tilde represents null, and YAML supports anchors and aliases for reuse. These features are absent in JSON, which lacks comments, disallows trailing commas, and requires escaped newlines for multi-line strings. Understanding these differences is essential when converting between formats in automation scripts.

Answer

JSON allows trailing commas in arrays and objects.

Answer

JSON natively supports multi-line strings without escaping newlines.

Answer

JSON supports comments, which can be used to annotate configuration sections.

Question 17

A Python script reads a Junos configuration snippet stored in YAML. The configuration uses YAML anchors and aliases to duplicate common routing policy definitions across multiple VRFs. When the script parses the file using yaml.safe_load(), what happens to the anchors and aliases?

Accepted Answer

The parser resolves the anchors and populates the resulting Python dictionary with the referenced data.. When yaml.safe_load() parses a YAML file containing anchors and aliases, it resolves the aliases by inserting the referenced data into the resulting Python dictionary. The anchors and aliases are a YAML feature for reusing nodes, and safe_load() fully supports them, producing a dictionary with the duplicated data expanded.

Answer

The parser raises a ScannerError because anchors are prohibited in safe mode.

Answer

The aliases are ignored, resulting in empty values for those configuration blocks.

Answer

The parser treats the anchor syntax as literal string data.

Question 18

A network automation engineer is writing a Python script using the Junos PyEZ library to retrieve operational state from a QFX Series switch. The script needs to retrieve interface statistics using an RPC instead of raw CLI text parsing. Which PyEZ method should the engineer execute to invoke the 'get-interface-information' RPC and receive the structured XML response?

Accepted Answer

dev.rpc.get_interface_information(). In Junos PyEZ, the dev.rpc() method is used to execute native Junos XML RPCs directly against the device and return the results as an ElementTree XML object.

Answer

dev.get_config(format='xml')

Answer

dev.load(action='set', format='xml')

Answer

dev.execute_cli('show interfaces')

Question 19

You are writing a Python script to convert a complex Juniper device inventory from YAML format into JSON format using PyYAML and the built-in json module. Which THREE considerations must you keep in mind regarding differences between YAML and JSON during this conversion? (Choose three)

Accepted Answer

YAML allows unquoted strings for most values, whereas JSON strictly requires double quotes for all string literals.. Option A is correct because YAML's flexible scalar syntax permits unquoted strings (e.g., hostname: router1), while JSON mandates double quotes around every string literal, so the conversion must emit properly quoted strings. Option B is correct because JSON has no comment syntax, so any # comments in the YAML source are dropped by the parser and cannot appear in the JSON output. Option D is correct because JSON object keys must be strings, so YAML keys that PyYAML resolves as integers or booleans (e.g., 8080: or true:) become string keys like "8080" and "true" in JSON. Option C is wrong because anchors and aliases are a YAML-only feature; PyYAML resolves them into duplicated values during parsing, so JSON has no native reference mechanism to preserve them. Option E is wrong because JSON does not support multi-document streams; only YAML's --- document separators allow multiple documents in one file, and json.loads expects a single JSON value.

Answer

YAML anchors and aliases will be automatically preserved as native references in the resulting JSON output.

Answer

JSON supports multi-document streams natively in a single file just like YAML.

Question 20

You are writing a Python script using PyEZ to retrieve and process operational data from a Junos device. Which TWO statements correctly describe the use of PyEZ Table and View for parsing operational data? (Choose two.)

Accepted Answer

A View defines how to extract specific fields from the XML response of an RPC.. A View defines the extraction of fields from XML, and a Table uses that View to parse RPC output into a list of dictionaries. The other statements are incorrect: Tables do not auto-convert to JSON, Views can be in Python, and Tables are for operational data.

Answer

Views must be defined in a separate YAML file and cannot be coded in Python.

Answer

Tables automatically convert all XML responses into JSON format.

Answer

Tables can only retrieve configuration data, not operational data.