JNCIA-DevOps Practice Exam 2 — 20 Questions

Question 1

Which TWO characteristics distinguish the Junos REST API from NETCONF when interacting with Junos devices? (Choose two)

Accepted Answer

The REST API uses standard HTTP methods (GET, POST, PUT, DELETE) over HTTP/HTTPS ports.. Option C is correct because the Junos REST API is an HTTP-based interface that uses standard HTTP verbs (GET to retrieve, POST to create/execute RPCs, PUT to replace, DELETE to remove) and listens on HTTP/HTTPS ports (typically 80/443 or the configured web-management ports), unlike NETCONF which runs over SSH. Option D is correct because the Junos REST API can return responses in JSON (as well as XML), which is a native capability of the REST interface, whereas NETCONF returns XML-encoded data. Option A is incorrect because TCP port 830 is the default NETCONF-over-SSH port, not a REST API port. Option B is incorrect because NETCONF does not require explicit SSH key pairs (password or key-based SSH both work), and the REST API does support encryption via HTTPS. Option E is incorrect because NETCONF over SSH maintains a persistent session, while REST is inherently stateless per HTTP request.

Answer

The REST API communicates directly over TCP port 830.

Answer

NETCONF requires explicit SSH key pairs for transport security, whereas REST API cannot use encryption.

Answer

NETCONF is stateless, whereas REST API maintains persistent interactive sessions by default.

Question 2

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 3

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 4

What is the primary benefit of using PyEZ Table and View abstractions over raw RPC XML parsing in Python scripts?

Accepted Answer

They automatically convert XML into structured Python data structures like dictionaries and lists. PyEZ Table and View abstractions map Junos XML output to Python dictionaries and lists, eliminating the need for manual XML parsing. Tables define the structure and XPath, while Views map XML elements to Python attributes. This provides a clean, programmatic interface to operational data, making scripts more readable and maintainable.

Answer

They eliminate the need to establish a Device connection object

Answer

They allow direct execution of Junos CLI operational commands without NETCONF

Answer

They automatically commit configurations to the active database

Question 5

Which character is used to indicate a mapping key-value pair in YAML syntax?

Accepted Answer

Colon (:). In YAML, a key-value mapping is represented by a colon followed by a space (: ).

Answer

Semicolon (;)

Answer

Arrow (->)

Answer

Equals sign (=)

Question 6

Which TWO Python standard library modules are commonly combined when a script needs to fetch web content (such as Junos REST API data) and parse the resulting payload? (Choose two)

Accepted Answer

json. Option D, urllib.request, is correct because it is the standard library module used to open URLs and perform HTTP requests, so it can fetch web content such as Junos REST API data. Option A, json, is correct because REST API payloads are typically returned in JSON format, and the json module parses that response text into Python dictionaries and lists. Together, urllib.request retrieves the raw response and json.loads() converts it into usable Python objects. Option B, yaml, is not needed here since the scenario specifies web content/REST payloads, which are JSON rather than YAML. Option C, socket, is a lower-level networking module and does not provide convenient HTTP fetching or payload parsing. Option E, pickle, is for serializing/deserializing Python objects and is not used to parse JSON API responses.

Answer

yaml

Answer

socket

Answer

pickle

Question 7

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 8

Which tool or library is commonly used in Python to simplify interacting with Junos NETCONF APIs by abstracting low-level XML handling?

Accepted Answer

Junos PyEZ (juniper-eznc). PyEZ is Juniper's official Python library designed specifically for interacting with Junos devices via NETCONF.

Answer

Netmiko

Answer

Paramiko

Answer

Requests

Question 9

You need to lock the candidate configuration datastore in your NETCONF script to prevent concurrent modifications by other administrators. Which XML element accomplishes this?

Accepted Answer

. The RPC takes a target element specifying which datastore to lock, such as the candidate datastore.

Answer

<lock-config>

Answer

<acquire-lock>

Answer

<exclusive-edit>

Question 10

An automation script needs to compare pre- and post-change states on a Junos device using JSNAPy (Junos Snapshot Administrator). Which configuration file format is used by JSNAPy to define snapshot checks and test assertions?

Accepted Answer

YAML. JSNAPy uses YAML files to define snapshots and test assertions. Snapshot files (for example, `snapshot.yaml`) list the commands or RPCs to capture, and test files (for example, `test.yaml`) define assertions using operators like `is-equal`, `is-greater-than`, and `contains`. YAML's human-readable structure makes it the standard format for JSNAPy configuration.

Answer

XML

Answer

JSON

Answer

INI

Question 11

An administrator configures the Junos REST API service. By default, which TCP port does the device listen on for secure HTTPS REST requests?

Accepted Answer

3443. The default TCP port for secure HTTPS requests in the Junos REST API daemon (jpagent) is port 3443.

Answer

443

Answer

8080

Answer

830

Question 12

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 13

An automation engineer is writing a Python script that takes a complex nested Python dictionary containing Junos telemetry parameters and converts it into a YAML string. Which PyYAML function should be used?

Accepted Answer

yaml.safe_dump(). yaml.safe_dump() converts a Python object into a YAML-formatted string safely, avoiding the security risks associated with the base yaml.dump().

Answer

yaml.export()

Answer

yaml.serialize_string()

Answer

yaml.to_yaml()

Question 14

When establishing a NETCONF session over SSH, which standard capability announcement is exchanged during the initial hello message phase?

Accepted Answer

urn:ietf:params:netconf:base:1.0. NETCONF capabilities are exchanged in <hello> messages at session startup, referencing URIs like urn:ietf:params:netconf:base:1.0.

Answer

http://xml.juniper.net/junos/rpc/v1

Answer

netconf:params:xml:ns:netconf:base:2.0

Answer

urn:juniper:params:netconf:ssh:1.0

Question 15

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 16

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 17

An engineer is applying a candidate configuration using PyEZ and needs to load it from an external text file named 'interfaces.conf'. Which Config method should be used?

Accepted Answer

cu.load(path='interfaces.conf', format='text'). The Config object's load() method is the standard PyEZ API for loading configuration data into a candidate configuration, and it accepts a path argument pointing to an external file plus a format argument specifying the data format. Since the file is a plain text Junos configuration file, format='text' is the correct specification. This combination loads the file contents into the candidate config so it can later be committed.

Answer

dev.load_configuration(file='interfaces.conf')

Answer

cu.load_file('interfaces.conf')

Answer

cu.read_config('interfaces.conf')

Question 18

When executing an RPC call in PyEZ, what format is typically returned by default if you do not parse it into another structure?

Accepted Answer

An XML Element (lxml.etree). PyEZ RPC calls return an ElementTree object (XML Element) representing the response from the Junos device.

Answer

A JSON dictionary

Answer

A raw plain text string

Answer

A Python list of strings

Question 19

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 20

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.