Automation and DevOps, Associate (JNCIA-DevOps) — Free Practice Questions
10 free sample questions from a bank of 10, with the correct answers and explanations. No signup required — start practising right now.
1Which transport protocol is used for remote JET API calls?
SSH
NETCONF
gRPC
telnet
Answer: C
The short version
C — gRPC. The JET API is a gRPC service: clients open a gRPC channel to the Junos device and exchange protobuf-encoded RPCs over HTTP/2 (with TLS) to run Junos RPCs remotely.
Key concepts
JET (Junos Automation Toolset): an open-source, high-performance automation library for Junos devices that exposes Junos RPCs over gRPC instead of XML-RPC over NETCONF.
gRPC: a Remote Procedure Call framework built on HTTP/2 with Protocol Buffers serialisation, supporting unary and bidirectional streaming, used as JET's transport.
PyEZ over gRPC: jnpr.junos.Device(host, gRPC=True) (juniper-eznc / junos-eznc with gRPC support) is the usual way to reach JET from Python.
NETCONF: RFC 6241 XML-RPC management protocol, typically over SSH on port 830, served by mgd — the older automation path.
SSH (TCP 22): transport for CLI/operational-mode automation such as running show commands over a command-line script.
Why C is correct
JET was designed to remove the XML parsing bottleneck of NETCONF. Junos exposes a gRPC endpoint (default TCP 50051) that returns protobufs, and a JET call is therefore a gRPC call: HTTP/2 framing, protobuf message encoding, TLS for confidentiality and integrity, and client-side stub generation from .proto files. When you write device = jnpr.junos.Device(host, gRPC=True) and then device.rpc.get_software_information(), PyEZ is serialising an RPC over the gRPC channel — gRPC is the transport protocol of the remote JET API call, which is what the question is testing.
Why the others are wrong
A. SSH is the transport for CLI- or shell-based automation (scp'ing configs, piping show commands over ssh user@host -c ...). JET does not run over an SSH session; it replaces exactly that model.
B. NETCONF is the XML management protocol served by mgd, and it is the old Junos automation interface, not the JET transport. Confusing JET with NETCONF is the classic distractor here, because both ultimately "run Junos RPCs".
D. Telnet is an unencrypted TCP 23 terminal protocol that Junos does not use for any automation API. It would be a spectacularly insecure choice and is not part of JET.
JN0-224 exam tip
Two eras, two transports: classic Junos automation = XML over NETCONF/SSH; JET automation = protobuf over gRPC. If you see the words "JET" or "gRPC port 50051", the transport is gRPC — no exceptions.
2Which two processes manage all Junos automation? (Choose two.)
the rpd process
the mgd process
the dfwd process
the jsd process
Answer: B, D
The short version
B and D — the mgd process and the jsd process. mgd is the entry point for configuration management automation (NETCONF, REST), and jsd hosts the scripting/execution automation framework (on-box scripts, RPCs, PyEZ, JET) — together they are the two automation front doors on a Junos device.
Key concepts
mgd (management daemon): the Junos process that serves NETCONF, the REST API and SNMP to remote clients and applies the resulting configuration commits.
jsd (Junos scripting device daemon): the process that hosts on-box scripts and RPCs (SLAX, Python, XML RPCs), PyEZ sessions and the JET gRPC service that aggregates the Junos RPCs.
rpd (routing protocol daemon): the control-plane process that runs OSPF, IS-IS, BGP, LDP and RSVP — the routing engine's protocol suite.
dfwd (data forwarding process): the data-plane process that builds and installs the forwarding/session table and runs dataplane services (flow, UTM, IPsec).
Process separation on Junos: management (mgd/jsd), control plane (rpd), data plane (dfwd) run in separate OS processes so that a fault in one does not crash the others.
Why B and D are correct
B. mgd is where configuration-management automation lands. NETCONF sessions, REST API calls and SNMP operations are all received and applied by mgd, which talks to the commit/change-management machinery on your behalf. Nothing else provides this.
D. jsd is where execution automation lands. It loads and runs on-box scripts (operation, commit and event scripts), serves RPCs to PyEZ, and hosts the JET gRPC endpoint that aggregates the individual Junos RPCs into one API. Pairing mgd with jsd therefore covers configuration push plus script/RPC automation — i.e. all Junos automation.
Why the others are wrong
A. rpd is the routing control plane. It computes the RIB and FIB inputs from OSPF/BGP/IS-IS and RSVP signalled LSPs. It is a routing daemon, not an automation interface, and no client ever automates through it.
C. dfwd is the data plane. It programs the forwarding table, handles flow/session lookup and runs dataplane security services. Automation clients never talk to dfwd; it acts on state that rpd/mgd/jsd have handed it.
JN0-224 exam tip
Learn the three-process split: mgd (configure) + jsd (script/execute) = automation, rpd = control plane, dfwd = data plane. If a question says "automation", only mgd and jsd qualify.
3In the context of DevOps, what does “technical debt” mean?
spending too much money on DevOps
when a team does not adopt to a new development culture
overspending on a project’s budget
a short term workaround that stays long term
Answer: D
The short version
D — a short-term workaround that stays long term. Technical debt is what you incur by shipping a fast, imperfect solution now and paying interest later in rework, because the shortcut stays in the code.
Key concepts
Technical debt: Ward Cunningham's metaphor for the future cost of rework caused by choosing an expedient solution over a better one that would take longer.
The "interest": the extra work — refactoring, retesting, migration, tribal-knowledge maintenance — charged every time the shortcut is touched.
DevOps CALMS: Culture, Automation, Lean, Measurement, Sharing — the pillars that reduce debt by automating testing, integration and deployment.
Automation as debt repayment: automated tests, pipelines and configuration-as-code are how a team pays down accumulated debt safely.
Why D is correct
Technical debt is defined by the gap between the expedient solution you shipped and the better solution you skipped. The workaround is deliberately short term and cheap, which is why it was chosen; the debt is the fact that it stays — it is never revisited or refactored — so every future change must be built around it. That "short term, long lived" definition is precisely what option D says, and it is why debt is measured by the cost it will impose rather than by the quality of the code today.
Why the others are wrong
A. DevOps spend is a consequence area, not the definition. If anything, adopting DevOps reduces spending by automating manual steps — the term has nothing to do with how much money a team spends.
B. Refusing to adopt a new development culture is an organisational anti-pattern and a change-management problem. Cultural resistance can cause debt, but it is not what the term denotes.
C. Overspending on a budget is a project cost-control problem. Technical debt is about code and design choices, not about estimates or funding.
JN0-224 exam tip
Picture it as a credit card for your codebase: the shortcut is the purchase, the "interest" is the rework. If the option mentions money, budget or culture, it is not technical debt — it is the shortcut that outlives its welcome.
4Which two statements are correct about a continuous integration process? (Choose two.)
The code should only be tested at the end of the process.
The code updates should be merged only after a large amount of changes.
The code updates should be merged frequently.
The code is tested throughout the process.
Answer: C, D
The short version
C and D. Continuous integration means merging code updates frequently and testing continuously, so every commit is integrated, built and validated automatically and problems surface within minutes.
Key concepts
Continuous Integration (CI): developers merge small changes into the main branch many times a day, and an automated build plus test suite validates each merge.
Continuous Delivery / Continuous Deployment: CI extended so that the build is automatically packaged and released (delivery stops at a manual approval, deployment goes straight out).
Trunk-based development: short-lived branches merged into the trunk continuously, as opposed to long-lived feature branches.
Late detection: the anti-pattern of batching changes and testing only at the end, which magnifies integration defects and makes root-cause analysis far harder.
Why C and D are correct
C. "The code updates should be merged frequently" is the defining habit of CI. Frequent small merges keep the branch-to-branch gap small, so integration is continuous and conflict-prone "merge hell" never accumulates; each merge is also independently validated by the pipeline.
D. "The code is tested throughout the process" is the other half: unit and integration tests run automatically on every commit, so feedback arrives in minutes and the developer who wrote the line of code is the one who sees the failure.
Why the others are wrong
A. Testing only at the end of the process is precisely the anti-pattern continuous integration was invented to eliminate. Batching tests until the end means defects surface late, when they are expensive to trace and when half the integration work is already built on them.
B. Merging only after a large amount of changes produces long-lived divergent branches and integration hell, the opposite of the trunk-based, small-batch-merge practice CI requires.
JN0-224 exam tip
Remember the two CI keywords: frequent merge and continuous test. Anything phrased as "test at the end" or "merge a big batch" is the waterfall mindset, not CI.
5Which Junos process aggregates individual Junos APIs and is used by the JET API?
dcd
dfwd
snmpd
jsd
Answer: D
The short version
D — jsd. The JET API runs inside jsd, which takes the individual Junos RPCs and aggregates them behind a single gRPC service so that remote clients never deal with raw XML-RPC payloads.
Key concepts
jsd (Junos scripting device daemon): hosts on-box scripts and RPCs, serves PyEZ, and implements the JET gRPC service that aggregates the Junos API.
mgd: the management daemon serving NETCONF, REST and SNMP — the configuration-side automation front door.
Junos RPC: an XML Remote Procedure Call (get_software_information, get_interface_information) exchanged with the device's XML API.
JET (Junos Automation Toolset): the automation layer that exposes those Junos RPCs over gRPC/protobuf for speed and lower CPU cost than XML-RPC.
Why D is correct
JET exists because XML-RPC parsing is slow and verbose. jsd is the process that owns script and RPC execution, and it is the process that implements the JET endpoint: it aggregates the individual Junos RPCs into one coherent gRPC API, serves it over TLS on port 50051, and translates gRPC/protobuf requests back into internal RPC execution. When a client makes a "JET API call", the server side of that call is jsd — you can confirm this on the device with show system processes, where jsd is visible handling the gRPC/API workload while mgd handles NETCONF/REST.
Why the others are wrong
A. dcd is an internal daemon concerned with dynamic/system configuration bookkeeping (for example saving and applying configuration state); it does not serve an external automation API and does not aggregate RPCs.
B. dfwd is the data forwarding process. It programs the forwarding table and runs dataplane services, so it is the last thing in the box that would expose a management API.
C. snmpd is the SNMP agent. It answers MIBs and raises traps — pure monitoring, one object at a time, with no RPC aggregation and no automation surface.
JN0-224 exam tip
Two daemons, two jobs: jsd = scripts/RPCs/JET, mgd = NETCONF/REST/SNMP. Any question pairing "aggregates the Junos API" or "JET" with a process name is looking for jsd.
6What are two aspects of the Feedback DevOps principle? (Choose two.)
It is the primary method for identifying ways to improve flow.
It does not let local improvements degrade the system as a whole.
It rewards taking risks.
It allocates time for process improvement.
Answer: A, B
The short version
A and B. The Feedback principle is about creating fast, honest loops that reveal where flow is breaking, and about making sure local improvements serve the whole system instead of quietly degrading it.
Key concepts
Feedback (DevOps Handbook): the second of the three principles — "continuously, respectfully and relentlessly improve" — backed by short feedback loops, observability and the Andon cord (stop-the-line authority).
Flow: the smooth, uninterrupted progression of work from idea to deployed value; optimising it, and removing queues and batching, is the goal of improvement.
Optimising the whole system: the Toyota-kata lesson that a locally improved team or component that makes the global flow worse is a regression, not a gain.
Kaizen: continuous, incremental, small improvement by empowered teams rather than big-bang redesign.
Why A and B are correct
A. Feedback is the primary method for identifying where to improve. You cannot improve flow you cannot see, so the principle insists on tight loops, visible work in progress and frequent, unfiltered reporting of what actually happened in production and delivery.
B. A local improvement that degrades the system as a whole is exactly the failure mode feedback loops are meant to catch. For example, a team that silences its alerts to hit a delivery target has locally reduced noise while globally destroying observability — the end-to-end flow got worse.
Why the others are wrong
C. "It rewards taking risks" is a statement about incentives and psychological safety, not one of the two aspects of the Feedback principle asked about here. Blameless, learning-oriented cultures do value experimentation, but that is a cultural attribute of the organisation, not what the feedback loop is for.
D. "It allocates time for process improvement" is a resourcing/kaizen statement about making improvement work possible. It is not one of the two aspects selected as the Feedback principle's defining characteristics here, which concern discovering improvement opportunities and protecting global flow.
JN0-224 exam tip
Feedback = see the flow, keep the whole system better. Two memories: "can we see it?" (A) and "did our local tweak wreck the global flow?" (B) — the second is the kata test every improvement must pass.
7What are two supported programming languages for on-box Junos scripting? (Choose two.)
SLAX
Python
Java
C++
Answer: A, B
The short version
A and B — SLAX and Python. SLAX is Junos's native XML DSL and Python is the general-purpose scripting language supported on-box; Java and C++ are not on-box languages.
Key concepts
SLAX: Juniper's XML-based scripting language — an XPath-like DSL with extension functions — interpreted directly by jsd with no external runtime.
Python on-box (PyEZ): jnpr.junos scripts run by jsd, giving full programmatic access to configuration, operational state and JET/gRPC bindings.
Operation / commit / event scripts: the three on-box script types; each is invoked by a different trigger but they share the same interpreter environment.
Off-box SDK: the alternative for languages without an on-box interpreter — you build a client with the gRPC stubs and run the script from a management host.
Why A and B are correct
A. SLAX runs natively on the device: the script is essentially XPath over the Junos XML API plus custom functions, and jsd executes it locally. That makes SLAX the default choice for quick on-box operational and commit automation.
B. Python is the other officially supported on-box language. PyEZ scripts are executed by jsd inside the device, letting you read and commit configuration with RPCs and, with gRPC=True, drive JET. Python is what the JET documentation and examples use.
Why the others are wrong
C. Java is not supported as an on-box scripting language on Junos devices. You can use Java off the box with the SDK/gRPC stubs, but there is no JVM or Java interpreter in the device's scripting environment.
D. C++ is likewise not an on-box language. Compiled C++ belongs in an off-box client or a custom SRX service, never in the device's script interpreter set.
JN0-224 exam tip
On-box script languages: SLAX (native DSL) and Python (PyEZ) — nothing compiled. Anything you would have to compile or that needs a JVM is an off-box SDK client, not an on-box script.
8What are two primary automation tools handled by the management process (mgd)? (Choose two.)
SNMP
NETCONF
REST API
JET
Answer: B, C
The short version
B and C — NETCONF and the REST API. Those are the two primary automation tools mgd handles: NETCONF gives transactional XML configuration management, and the REST API gives stateless HTTP/JSON access for operations and data.
Key concepts
mgd (management daemon): the Junos process that serves NETCONF, the REST API and SNMP to remote automation clients.
NETCONF (RFC 6241): XML-RPC over SSH, port 830 by default — edit-config, commit, lock, get-config, with candidate/datastore semantics and rollback-on-error.
REST API: HTTP/HTTPS request-response interface exposing Junos data and operations in JSON or XML, ideal for orchestration tools that prefer stateless REST.
JET: the gRPC-based automation toolkit served by jsd, not one of mgd's interfaces.
SNMP: served by mgd, but a monitoring protocol for MIB polling and traps rather than an automation/configuration tool.
Why B and C are correct
B. NETCONF is the primary declarative configuration tool: it delivers <rpc> messages over a secure SSH transport, supports candidate configuration, validate/commit semantics and :rollback-on-error, which is why orchestrators such as Ansible and PyEZ rely on it.
C. The REST API is the second primary tool: ordinary HTTP requests and responses over TLS carrying Junos operational and configuration data, which is trivially consumed from any language with an HTTP client and is what Junos Space, Mist-adjacent tooling and many CI pipelines use.
Why the others are wrong
A. SNMP is a monitoring protocol — it polls MIB objects and sends traps. It is served by mgd, but it is not an automation tool: it cannot express "change this stanza of configuration", it carries no transaction semantics and no configuration commit model.
D. JET is the gRPC automation toolkit whose server side lives in jsd, not mgd. mgd's two primary automation interfaces are NETCONF and REST; mixing JET into the mgd answer set is the trap in this item.
JN0-224 exam tip
mgd owns NETCONF + REST (+ SNMP for monitoring); jsd owns JET and on-box scripts. Pair the protocol with the process: NETCONF/REST -> mgd, gRPC/JET -> jsd.
9Design change, commit change to Version Control System (VCS), feedback and peer review, automated testing, automated deployment, continuous monitoring, and continuous improvement are all stages in which process or model?
Infrastructure as Code
waterfall development model
network DevOps pipeline
change control process
Answer: C
The short version
C — network DevOps pipeline. Design, VCS commit, peer review, automated test, automated deploy, continuous monitoring and continuous improvement are the stages of a CI/CD (DevOps) pipeline applied to network automation.
Key concepts
DevOps pipeline: the automated path from change design to production monitoring — design/plan, code in version control, peer review, automated test, automated deploy, monitor, then feed findings back into improvement.
Continuous feedback loop: monitoring and improvement close the loop, so operational reality (failed commits, config drift, alarms) drives the next iteration.
Infrastructure as Code (IaC): managing device configuration and topology declaratively in a VCS (templates, Ansible, Puppet, Terraform) — an enabling practice inside the pipeline, not the pipeline's name.
Change control process: the governance/ticketing/approval mechanism (CAB, windows, approvals) that authorises changes; it sits outside the automated loop.
Why C is correct
Every item in the list is a stage of an automated delivery loop that ends by feeding monitoring data back into the next change. That is precisely a network DevOps pipeline: instead of configuring devices by hand under a change window, the configuration is authored as code, reviewed by peers, validated by automated tests (syntax, reachability, security policy checks), deployed automatically, and then monitored continuously so the feedback drives continuous improvement. This is the model Juniper documents for automating SRX and MX networks.
Why the others are wrong
A. Infrastructure as Code is the practice of expressing configuration and topology declaratively so it can be version-controlled and diffed. It is an input to the pipeline, not the name of the seven-stage process listed.
B. The waterfall development model is strictly sequential with phase gates and documentation between phases — the opposite of a continuous, automated, feedback-driven loop.
D. A change control process is the governance path for approvals, risk assessment and maintenance windows. It is a management overlay, and in mature DevOps environments it is automated into the pipeline rather than being the pipeline itself.
JN0-224 exam tip
If the list contains automated testing, automated deployment and continuous monitoring with feedback, it is the DevOps pipeline. Governance (change control), method (waterfall) and IaC are all things that surround or feed the pipeline, never its name.
10Which Junos on-box script type is triggered automatically based on an entry in a log file?
event script
operation script
SNMP script
commit script
Answer: A
The short version
A — event script. An event script runs automatically when the device writes a matching entry to the system log (or receives an SNMP request), because an event policy under event-options matches the log entry and invokes the script.
Key concepts
Event script: an on-box script invoked by the device's eventing framework rather than by a human; it runs in the context of root and is configured with a trigger, event-handling actions and an action that runs the script.
Event policy (event-options): binds a pattern match on a log/syslog message or an SNMP request to handling actions, including raise or execute-scripts.
Operation script (op script): an on-box script run manually or from automation by typing op script run <name>.
Commit script: a script that runs automatically during commit, where it inspects or builds configuration.
Event trigger types: log, commit-confirm, process, interface, snmp-request, alarm — these are triggers for event scripts, not separate script languages.
Why A is correct
The trigger named in the stem — an entry appearing in a log file — is exactly what the eventing subsystem watches. You configure an event policy under event-options with a log trigger whose pattern matches the syslog entry, and the script named in the policy's actions is executed automatically (as root) at that moment. Typical examples: reacting to link-down, to repeated authentication failures, or to an alarm being set — the whole point of an event script is autonomous reaction without anyone logged in.
Why the others are wrong
B. An operation script only runs when invoked explicitly with op script run <name> (or by automation calling that RPC). Nothing about it fires on a log entry, so it is the wrong trigger model.
C. "SNMP script" is not an on-box script type. There is an snmp-request event trigger that an event script can react to, but that is a trigger for an event script, not a separate script class — so C confuses trigger with type.
D. A commit script is triggered by commit, not by a log file. It runs during configuration commit to generate or validate configuration, so its trigger is the commit transaction rather than log content.
JN0-224 exam tip
Trigger-to-type mapping: log/syslog entry -> event script, operator command -> operation script, commit -> commit script. When a question names the trigger, the answer is whichever type that trigger belongs to.