JNCIA-DevOps Practice Test 2 — 25 Questions

Question 1

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 2

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 3

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 4

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 5

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 6

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 7

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 8

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 9

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 10

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 11

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 12

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 13

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 14

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 15

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 16

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 17

A network automation engineer is using a Python script with the PyYAML library to load a YAML file that defines a Junos device's configuration. The script needs to ensure that the loaded data is a Python dictionary and that no arbitrary Python objects are instantiated during parsing. Which function should the engineer use to safely load the YAML content?

Accepted Answer

yaml.safe_load(stream). Using yaml.safe_load ensures that only standard Python data types are constructed from the YAML input. It prevents the instantiation of arbitrary objects and mitigates security risks such as code execution. This is the recommended approach for parsing configuration files in automation scripts.

Answer

yaml.load(stream, Loader=yaml.FullLoader)

Answer

yaml.load(stream, Loader=yaml.BaseLoader)

Answer

yaml.load(stream, Loader=yaml.UnsafeLoader)

Question 18

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.

Question 19

An automation engineer writes a Python script that reads a Junos configuration file serialized in JSON. The file opens successfully, but parsing fails with a JSONDecodeError due to trailing commas at the end of object lists. How does standard JSON handle trailing commas compared to YAML?

Accepted Answer

JSON strictly forbids trailing commas, whereas YAML permits them in collections.. Standard JSON strictly prohibits trailing commas in objects and arrays, whereas YAML is much more lenient and allows trailing commas in sequences and mappings.

Answer

Both formats handle trailing commas identically by ignoring them.

Answer

JSON allows trailing commas, but YAML strictly forbids them.

Answer

Both JSON and YAML strictly require trailing commas for every key.

Question 20

Which THREE tasks are typical responsibilities of a network DevOps engineer managing a Junos infrastructure? (Choose three)

Accepted Answer

Writing and maintaining Python automation scripts and Jinja2 templates. Option B is correct because a network DevOps engineer on Junos infrastructure typically writes Python automation scripts using libraries such as PyEZ and ncclient, and generates configuration from Jinja2 templates to push via NETCONF or Junos CLI, which is core to infrastructure-as-code. Option C is correct because managing Git repositories, branch policies, and pull request workflows is essential for version-controlling Junos configurations and enabling peer review and rollback. Option D is correct because configuring and maintaining CI/CD pipeline tools like GitLab CI or GitHub Actions automates validation, testing, and deployment of Junos configuration changes. Option A is not a DevOps responsibility since crimping CAT6 cables is a physical layer cabling task performed by cabling technicians, not automation engineers. Option E is not a DevOps responsibility because manually rebooting every switch daily is an operational anti-pattern that automation and proper monitoring would replace.

Answer

Manually crimping CAT6 Ethernet cables in the wiring closet

Answer

Manually rebooting every switch in the data center daily