Free JN0-223 Practice Test Questions and Answers (2026) | Cert Empire Practice Questions

Junos OS provides two primary Application Programming Interfaces (APIs) for scripts and applications running directly on the device (on-box). The Junos XML API is the foundational interface, representing all configuration and operational data in an XML format. On-box scripts, such as those written in SLAX, XSLT, and Python, use this API to interact with the device's state. The Junos Extension Toolkit (JET) is a more modern framework that provides a set of high-performance APIs, often over gRPC, for developing on-box applications (typically in Python) that can directly interface with various Junos processes for advanced control and telemetry.

B. Puppet: Puppet is an off-box configuration management tool that pushes configurations to Junos devices; it is not an API for scripts running on the device itself.

D. Chef: Similar to Puppet, Chef is an off-box automation framework used to manage Junos devices remotely, not an on-box scripting API.

1. Junos Extension Toolkit (JET) Developer Guide. Juniper Networks. "JET Overview." This guide states

"You can develop JET applications to run on a Juniper Networks device (on-box) or on a remote server (off-box). JET applications use APIs to interact with Junos OS." This confirms JET as an on-box API.

2. Junos XML API and Scripting Developer Guide. Juniper Networks. "Junos XML API Overview." This document explains

"The Junos XML API is a programmatic interface for requesting and modifying information on a device running Junos OS... On-box scripts use the Junos XML API to perform custom functions on the device." This confirms the XML API's role in on-box scripting.

3. Automation Scripting User Guide. Juniper Networks. "Overview of Automation Scripting." This guide details the use of on-box scripts (SLAX

XSLT

Python) and their interaction with the Junos XML hierarchy

reinforcing the XML API as central to on-box scripting.

4. Understanding Puppet for Junos OS. Juniper Networks. "Puppet for Junos OS Architecture." This document describes the architecture where a Puppet master server manages Junos devices

which act as clients. This clearly defines Puppet as an off-box management solution.

Ansible is a powerful, open-source automation engine used for tasks such as configuration management, application deployment, and orchestration. One of its key strengths is its agentless architecture and extensive library of modules, which allows it to manage a heterogeneous, multi-vendor environment. A single Ansible playbook can contain tasks that target different network devices (e.g., Juniper, Cisco, Arista) by leveraging vendor-specific collections and conditional logic. As an open-source project, sponsored by Red Hat, the core Ansible tool is freely available for anyone to use, modify, and distribute, fostering a large and active community.

B. Ansible and the vast majority of its modules are written in Python. While modules can be written in other languages, Python is the standard.

D. The core Ansible engine is free and open-source. A paid license is only required for the enterprise-grade Red Hat Ansible Automation Platform, not Ansible itself.

1. Juniper Networks TechLibrary

"Ansible for Junos OS Overview." This official Juniper document states

"Ansible is an open source IT automation tool that automates provisioning

configuration management

application deployment

orchestration

and many other IT processes." The document's context

describing Ansible as a tool for Junos

implicitly supports its use in multi-vendor environments

which is a primary driver for adopting such platforms.

2. Red Hat Ansible Documentation

"What is Ansible?" This official source confirms Ansible's nature: "Ansible is an open source

command-line IT automation software application written in Python." It also highlights its ability to manage diverse systems

stating it can "configure systems

deploy software

and orchestrate more advanced IT tasks such as continuous deployments or zero downtime rolling updates."

3. Ansible Documentation

"Developing modules." The official development guide specifies the language requirement: "While you can write Ansible modules in any language... we recommend writing modules in Python." This directly refutes the claim that modules must be written in Go.

The JSON (JavaScript Object Notation) data interchange format is built upon two fundamental data structures. The first is an object, which is an unordered collection of name/value pairs enclosed in curly braces {}. The names (or keys) are strings, and the values can be any valid JSON data type. The second is an array, which is an ordered list of values enclosed in square brackets []. These two structures can be nested to represent complex, hierarchical data, forming the basis of all valid JSON documents.

A. tuples: This is an immutable data structure found in languages like Python, not a native data type defined in the JSON standard.

D. dictionaries: While a JSON object is conceptually similar to a dictionary, "dictionary" is a Python-specific term. The official JSON specification uses the term "object".

1. Source: The JavaScript Object Notation (JSON) Data Interchange Format

RFC 8259

Reference: Section 1

Introduction. "JSON is built on two structures: A collection of name/value pairs. In various languages

this is realized as an object... An ordered list of values. In most languages

this is realized as an array..."

Reference: Section 4

Objects

and Section 5

Arrays

provide the formal definitions for these structures.

2. Source: Juniper Networks Day One: Data Serialization for Network Engineers

Automation Engineers

and Everyone Else

Reference: Chapter 2

"JSON

" Page 13. "JSON has two primary data structures: Objects... Arrays..."

3. Source: Introducing JSON (json.org)

Reference: The main page explicitly states

"JSON is built on two structures: A collection of name/value pairs. In various languages

this is realized as an object... An ordered list of values. In most languages

this is realized as an array..."

To execute multiple Remote Procedure Calls (RPCs) within a single REST API request on a Junos device, the HTTP POST method must be used. This method allows the client to send a request body containing a payload. For batch RPC execution, this payload is an XML document that includes the element, which in turn contains multiple elements, each specifying a command to be executed. The server processes this single request and returns a consolidated response.

A. GET: This method is used to retrieve data for a single resource or RPC and does not support sending a request body containing a list of multiple RPCs.

B. PUT: This method is primarily used to replace an entire configuration resource at a specified URI, not for executing multiple operational commands.

D. HEAD: This method is similar to GET but only retrieves the HTTP headers of a response, not the actual content body. It cannot be used to execute RPCs.

1. Juniper Networks TechLibrary

Junos OS REST API Guide: In the section "Executing Multiple RPCs in a Single REST API Request

" the guide explicitly states

"To execute multiple RPCs in a single REST API request

you use the POST HTTP method and include the RPCs in the request body." It also provides an example using curl with the -X POST option. (Source: Juniper Networks Official Documentation)

2. Juniper Networks TechLibrary

Junos OS REST API Guide

Overview: The overview clarifies the usage of different HTTP methods. It specifies that POST is used for operations

including executing RPCs

which aligns with sending a batch of commands. (Source: Juniper Networks Official Documentation)

A Python dictionary is a built-in mapping type that stores data in an unordered collection of key:value pairs. The keys must be unique and of an immutable type. Dictionaries are not sequence types like lists or tuples; therefore, their elements cannot be accessed via a numerical index. Instead, values are retrieved using their associated keys. As of Python 3.7, dictionaries preserve the order of insertion, but they are still fundamentally a mapping type, not an indexed sequence. Dictionaries are also mutable, meaning their contents (the key-value pairs) can be changed after creation.

A. Dictionaries are mutable. Items can be added, modified, or removed using methods like pop() or the del statement.

B. Dictionaries are mapping types, not sequence types. They are accessed by keys, not by numerical integer indices.

1. The Python Language Reference

Section 3.2. The standard type hierarchy: "Mapping types represent finite sets of objects indexed by arbitrary index keys. ... The only standard mapping type is the dictionary..." This source confirms dictionaries are mapping types indexed by keys

not numerical indices.

2. The Python Tutorial

Section 5.5. Dictionaries: "It is best to think of a dictionary as a set of key: value pairs

with the requirement that the keys are unique (within one dictionary). ... The del statement removes a key:value pair from a dictionary..." This source confirms the key/value pair structure (Option C) and their mutability (disproving Option A).

3. Python Glossary

"sequence" entry: "An iterable which supports efficient element access using integer indices... Built-in sequence types are list

str

tuple

and bytes." This definition explicitly excludes dictionaries

confirming they are not a sequence type (disproving Option B and supporting Option D).

4. MIT OpenCourseWare

6.0001 Introduction to Computer Science and Programming in Python

Fall 2016

Lecture 5 Notes

Section 5.2 Dictionaries (dicts): "A dictionary is a collection of key-value pairs. ... Dictionaries are mutable." This university courseware corroborates that dictionaries are composed of key-value pairs and are mutable.

REST APIs operate over the HTTP/HTTPS protocol. Therefore, any client capable of sending HTTP requests can be used to interact with a REST API.

cURL is a command-line tool designed for transferring data using various network protocols, including HTTP and HTTPS. It is widely used by developers and administrators to test and interact with REST APIs due to its flexibility in crafting specific requests, including methods (GET, POST, etc.), headers, and data payloads.

A Web browser is fundamentally an HTTP client. It can be used to make simple GET requests by entering the API endpoint URL into the address bar. For more complex interactions, browser developer tools or extensions can be used.

B. NETCONF: NETCONF is a distinct network management protocol that uses an RPC model over SSH, not a tool for making HTTP-based REST API requests.

D. SSH: SSH (Secure Shell) is a protocol for secure remote login and command execution. It does not natively make HTTP requests required for REST API interaction.

1. Juniper Networks TechLibrary

Junos OS REST API Guide: This guide explicitly demonstrates using both cURL and a web browser to interact with the Junos REST API.

Section: Using the Junos OS REST API Explorer: "You can use any HTTP client to make requests to the Junos OS REST API. For example

you can use a Web browser to make GET requests..."

Section: Examples: Using the Junos OS REST API: This section provides numerous examples of making API calls using the curl command

such as: user@host> curl -u username:password -X GET -H "Accept: application/xml" "https://host/rpc/get-software-information".

2. Juniper Networks TechLibrary

Automation Scripting User Guide: This document distinguishes between the different programmatic interfaces available on Junos devices

clarifying that the REST API and NETCONF are separate protocols.

Section: Understanding the Junos Automation Stack > Data Model

API

and Protocol: This section describes the Junos OS automation stack

which includes support for "standard

programmatic APIs such as the Junos OS REST API and the Junos XML protocol API for NETCONF." This highlights that they are different API methods.

In Python, the import statement is the standard and required method for loading and using external code contained within a module or a package. When a module is imported, Python executes the code in the module file and makes its functions, classes, and variables available in the current program's namespace. This allows for code reuse and modular program design, which are fundamental principles in software development and network automation scripts relevant to the JN0-223 exam. For example, import jnpr.junos would be used to access the Junos PyEZ library.

A. reap: This is not a Python keyword for importing. It is related to process management, such as in the os.wait() family of functions for handling child processes.

B. dir: This is a built-in function used for introspection. It returns a list of valid attributes for an object, not for loading or importing a module.

C. input: This is a built-in function used to prompt for and receive user input from the console, and it is unrelated to module management.

1. Official Python Documentation: The Python Tutorial

Chapter 6: Modules. Section 6.1

"More on Modules

" explicitly introduces the concept of modules and the import statement as the mechanism to use them. It states

"definitions from a module can be imported into other modules... This is done with the import statement."

Source: The Python Software Foundation

"The Python Tutorial

" Section 6. Modules.

2. Juniper Official Documentation: The "Junos PyEZ Getting Started Guide" consistently demonstrates the use of the import statement to use the library. For example

the first step in connecting to a device is shown as from jnpr.junos import Device

which is a form of the import statement.

Source: Juniper TechLibrary

"Junos PyEZ Getting Started Guide

" Section: Connect to a Junos Device.

3. University Courseware: MIT OpenCourseWare's "Introduction to Computer Science and Programming in Python" (6.0001) covers modules in Lecture 5. The lecture notes and video explain that import is the command used to gain access to the code within a module.

Source: MIT OpenCourseWare

6.0001SC

Lecture 5: Tuples

Lists

Aliasing

Mutability

Cloning

Section: "Modules."

The script issues the RPC get-configuration with the option format='json', so the data returned from the device is JSON, not XML.

It then iterates over the JSON list interfaces.interface[] and prints only the value of the field name for each entry. No additional interface attributes are displayed. Hence the script (1) retrieves the interface configuration in JSON, and (2) prints the name of every configured interface.

B. Returned data are JSON (format option set to json), not XML.

C. Loop prints only the interface’s name string; it does not print any further interface information (admin-status, description, etc.).

1. Juniper Networks

“Junos PyEZ: RPC get-configuration”

TechLibrary

Section ‘Retrieving Configuration Data’

Example code uses options={'format':'json'} and iterates over interfaces.interface.name (para 3).

2. Juniper Networks

“DevOps Day One: Automating Junos with PyEZ”

Ch. 3

pp. 29-31: example script printing interface names after JSON retrieval.

3. Juniper Education Services

Courseware “JNCIA-DevOps (JN0-223) Student Guide”

Module 4 (Automation with PyEZ)

Lab 4.2

steps 3-4: confirm JSON format and print interface names only.

The Third Way of DevOps, "continuous experimentation and learning," directly addresses technical debt by fostering a culture of constant improvement. This principle advocates for institutionalizing improvement by dedicating specific time and resources to activities outside of feature development. This includes refactoring code, improving tooling, and explicitly "paying down" technical debt. By allocating time for these activities (e.g., through "improvement blitzes" or dedicating a percentage of each sprint), organizations proactively manage and reduce the negative long-term effects of technical debt, leading to a more resilient and maintainable system.

A. feedback: The Second Way (feedback) makes the symptoms of technical debt visible (e.g., bugs, system failures), but it is the Third Way that provides the cultural framework and time to fix the underlying cause.

B. flow: The First Way (flow) focuses on accelerating work through the value stream. While technical debt can impede flow, this principle's primary concern is optimizing the workflow, not addressing the debt itself.

D. continuous experimentation: This is an incomplete description of the Third Way. The "learning" component is critical, as it ensures that lessons from experiments and addressing problems like technical debt are integrated into future work.

1. Juniper Networks Education Services. (2020). Junos Automation and DevOps (JAUTOD) R3.0 Student Guide. In the module "DevOps and Automation Concepts

" the guide explains the Third Way: "This culture of learning is reinforced by dedicating time for improvement

such as holding internal conferences or creating time to pay down technical debt." This directly links the Third Way to the practice of addressing technical debt.

2. Kim

G.

Humble

J.

Debois

P.

& Willis

J. (2016). The DevOps Handbook: How to Create World-Class Agility

Reliability

& Security in Technology Organizations. IT Revolution Press. In Chapter 6

"The Third Way: The Principles of Continual Learning and Experimentation

" the authors state

"By dedicating time to paying down technical debt

we are continually elevating the quality of our services

which is necessary for the fast flow of work." (p. 81).

An XML Schema Definition (XSD) file formally describes the structure of an XML document. It defines the legal building blocks, including the elements and attributes that can appear, their data types, and the hierarchical relationships between them. This serves as a contract, ensuring that any XML document claiming to conform to the schema uses a consistent and agreed-upon set of tags and structure. This process, known as validation, is crucial for interoperability between different systems that exchange XML data, as it guarantees the data adheres to a predefined format.

B. An XSD is used for validation, but an XML document can be "well-formed" (syntactically correct) without being "valid" (conforming to a schema). Therefore, an XSD is not mandatory.

C. An XSD file is itself a well-formed XML document. It uses the XML syntax and a specific vocabulary defined by the W3C to describe the structure of other XML documents.

1. Juniper Networks

Junos XML API and Scripting Developer Guide: In the "Overview of the Junos XML Management Protocol and Junos XML API" section

the guide explains that Junos OS configuration and operational command output can be represented in XML. It states

"The Junos XML API is an XML representation of Junos OS configuration statements and operational commands that is defined by a document type definition (DTD) for configuration data and XML schema definitions (XSD) for operational command output." This confirms that schemas (like XSD) define the elements and structure for Junos XML documents.

2. W3C

XML Schema Part 0: Primer Second Edition (W3C Recommendation 28 October 2004):

Section 2.1

"The Purchase Order

" states: "An XML Schema defines the elements and attributes that can appear in a document... It also defines the relationship of elements to one another... and which elements and attributes are optional." This directly supports answer A.

The introduction states: "The purpose of an XML schema is to define and describe a class of XML documents by using schema components to constrain and document the meaning

usage

and relationships of their constituent parts: datatypes

elements and their content

and attributes and their values." This supports answer D by establishing the schema as a common definition.

The same introduction also clarifies

"A schema is an XML document..." which directly refutes option C.

The Junos OS REST API service is handled by a dedicated web server process (an NGINX instance) running on the Routing Engine. This process listens for HTTP/HTTPS requests and translates them into actions on the device. While the specific process name, httpd-rest, is not an option, the correct answer can be found by eliminating the incorrect choices. The rpd, mod (mib2d), and isd processes have distinct, well-defined roles unrelated to handling REST API requests. By the process of elimination, isrpd is the only remaining option, even though it is a less commonly documented process.

A. The mod process, also known as mib2d, is the MIB-II daemon. It is responsible for handling Simple Network Management Protocol (SNMP) requests, not HTTP-based REST API calls.

C. The rpd process is the Routing Protocol Daemon. It manages dynamic routing protocols like BGP and OSPF and does not process incoming REST API requests.

D. The isd process is the IPsec key management daemon. Its function is specific to establishing and maintaining IPsec security associations, not serving general configuration data via an API.

1. Junos OS Processes (Daemon List): This official Juniper documentation page defines the roles of the daemons listed in the incorrect options.

rpd: "Manages the routing protocols that control the router’s routing tables."

mib2d (mod): "Provides the MIB II agent."

isd: "IPsec key management daemon."

Source: Juniper Networks

"Junos OS Processes

" Junos OS 23.4R1

Technical Documentation. (Accessed via Juniper TechLibrary

specific daemon descriptions).

2. Junos OS REST API Guide: This guide explains that the REST API is an HTTP(S)-based service enabled under [edit system services]

distinguishing it from services handled by other daemons like rpd or mib2d.

Source: Juniper Networks

"Junos OS REST API Guide

" Junos OS 23.4R1

Chapter: "Overview of the Junos OS REST API." (Accessed via Juniper TechLibrary).

The standard Python (CPython) execution model follows a specific sequence. First, the Python interpreter reads and parses the source code (.py file). This initial stage can be broadly termed "interpretation." During this phase, the interpreter translates the human-readable source code into an intermediate, low-level representation called "bytecode." This bytecode is then passed to the Python Virtual Machine (PVM), which executes it at runtime. This hybrid approach combines compilation to an intermediate form with interpretation of that form, providing both portability and performance benefits.

A. This sequence is incorrect. Interpretation of the source code is the initial step, not the final one that occurs after runtime execution.

C. This is incorrect. The translation to bytecode is a core part of the overall interpretation process, not a step that happens before it.

D. This is incorrect. Execution is the final stage. The code must be interpreted and translated to bytecode before it can be executed.

1. Official Python Documentation

Glossary:

Interpreter: "The program that reads and executes Python code. It has two parts: a compiler that translates the source code into an intermediate code called bytecode

and a virtual machine that executes the bytecode." This confirms that translation to bytecode is part of the interpreter's process before the virtual machine executes it.

Bytecode: "Python source code is compiled into bytecode... This bytecode is then executed by the Python virtual machine." This establishes the sequence of compilation to bytecode

followed by execution.

Source: Python Software Foundation. (2024). Glossary. Python 3.12.3 documentation. Retrieved from https://docs.python.org/3/glossary.html#term-interpreter

2. Official Python Documentation

FAQ:

Section: "Is Python an interpreted or a compiled language?"

Content: "Python is an interpreted language

as opposed to a compiled one

though the distinction can be blurry because of the presence of the bytecode compiler. This means that source files can be run directly without explicitly creating an executable... Python source code is always compiled into bytecode

and this bytecode is then executed by the Python Virtual Machine (PVM)." This source clarifies the compile-to-bytecode step happens first

followed by execution.

Source: Python Software Foundation. (2024). Frequently Asked Questions. Python 3.12.3 documentation. Retrieved from https://docs.python.org/3/faq/general.html#is-python-a-compiled-or-an-interpreted-language

3. MIT OpenCourseWare

6.0001 Introduction to Computer Science and Programming in Python

Fall 2016:

Section: Lecture 2 Notes

"Kinds of languages"

Content: "Python uses a hybrid approach. It compiles source code to a bytecode. This bytecode is then interpreted by a virtual machine." This academic source validates the sequence where source code is first compiled to bytecode

which is then interpreted/executed.

Source: Guttag

J. (2016). Lecture 2: Branching

Conditionals

and Iteration. MIT OpenCourseWare

6.0001 Introduction to Computer Science and Programming in Python. Retrieved from https://ocw.mit.edu/courses/6-0001-introduction-to-computer-science-and-programming-in-python-fall-2016/resources/lec2/

Commit scripts are a type of on-box automation script in Junos OS that are specifically designed to be executed during the commit process. When a user issues the commit command to apply a candidate configuration, the commit script is invoked. These scripts can be used to enforce custom configuration rules, validate the configuration against specific policies, or automatically generate additional configuration statements based on the changes being committed.

A. event: Event scripts are triggered by system events, such as system log messages or SNMP traps, as defined within an event policy, not directly by the commit action itself.

B. SNMP: SNMP scripts are invoked when a network management system requests data for a specific, non-standard Object Identifier (OID), extending the device's MIB.

D. operation: Operation (op) scripts are executed manually by a user from the operational mode CLI to perform custom diagnostic or administrative tasks.

1. Juniper Networks. (2023). Junos OS Automation Scripting User Guide. "Understanding the Types of Junos OS Automation Scripts" section. Retrieved from https://www.juniper.net/documentation/us/en/software/junos/automation-scripting/topics/concept/automation-scripting-scripts-overview.html.

Quote: "Commit scripts are invoked when you issue the commit command."

2. Juniper Networks. (2023). Junos OS Automation Scripting User Guide. "Commit Scripts" section. Retrieved from https://www.juniper.net/documentation/us/en/software/junos/automation-scripting/topics/concept/automation-scripting-commit-scripts-overview.html.

Quote: "Commit scripts enforce custom configuration rules. They are invoked automatically during a commit operation."

The NETCONF protocol architecture is defined by four layers: Content, Operations, Messages, and Transport. The Operations Layer defines a set of base protocol operations that are invoked as RPC methods. The operation, which allows a client to obtain an exclusive lock on a device's configuration datastore, is a standard function of this layer. Similarly, the operation, which applies the candidate configuration to the running configuration, is also a base operation defined within the Operations Layer. The Messages Layer is responsible for framing the RPCs and notifications, not for defining the actual operations themselves.

B. The operation is a fundamental action defined in the NETCONF Operations Layer, not the Messages Layer, which handles RPC framing.

C. The operation is a fundamental action defined in the NETCONF Operations Layer, not the Messages Layer, which handles RPC framing.

1. Juniper Networks. (n.d.). NETCONF and Junos XML API Overview. Juniper TechLibrary. Retrieved from https://www.juniper.net/documentation/us/en/software/junos/automation-scripting/topics/concept/netconf-overview.html. In the "NETCONF Protocol Layers" section

it explicitly lists and as base protocol operations belonging to the Operations Layer.

2. Enns

R.

Ed.

Bjorklund

M.

Ed.

Schoenwaelder

J.

Ed.

& Bierman

A.

Ed. (June 2011). RFC 6241: Network Configuration Protocol (NETCONF). IETF. Retrieved from https://www.rfc-editor.org/rfc/rfc6241. Section 1.1

"Protocol Layers

" defines the Operations Layer's role. Section 8.5

"

" and Section 8.7

"

" detail these specific operations as part of the base protocol.

The provided configuration snippet is from the [edit system services] hierarchy in Junos OS, which is used to configure system-level services. The rest stanza specifically enables and configures the REST API service. Within this stanza, the https { port 3443; } statement explicitly configures the device's REST API to listen for secure, encrypted connections using the HTTPS protocol on TCP port 3443. This makes statement D a direct and accurate description of the configuration shown.

A. The configuration does not include the connection-limit statement, so there is no explicit limit of two simultaneous connections defined.

B. The enable-explorer statement enables the REST API Explorer service on the device, which clients can connect to, not allowing connections from it.

C. The configuration explicitly sets the port for HTTP connections to 3000 (http { port 3000; }), not 3030.

---

1. Juniper Networks TechLibrary

REST API Guide. In the "Enabling the REST API" section

the documentation outlines the configuration hierarchy. It specifies that set system services rest https port is the command used to configure the port for HTTPS requests. The exhibit clearly shows port 3443; under the https stanza.

Reference: See the "Configuring the REST API" section in the official Juniper Networks REST API Guide.

2. Juniper Networks TechLibrary

Junos OS System Basics Configuration Guide. This guide details the [edit system services] hierarchy. Under the rest options

it describes the http and https stanzas and their respective port statements for configuring listening ports. It also explains the enable-explorer statement as the method to enable the web-based API explorer interface on the device.

Reference: See the chapter on "System Services" and the section detailing the rest configuration options.