CCNA Junos REST API Questions

A 415 response is returned by the Junos REST API when the request's Content-Type header does not match the payload format. Since the script sends JSON, the header must be `Content-Type: application/json`; omitting it or specifying another media type causes the device to reject the request before parsing the body.

HTTP response headers and status codes expose authentication and authorisation outcomes directly: 401 signals failed credentials, 403 signals insufficient privileges, and WWW-Authenticate reveals the required scheme. Inspecting these on the API client satisfies the stem's need to diagnose REST authentication and authorisation faults without device-side log access.

The Junos REST API exposes operational RPCs beneath /api/operational/rpc/<rpc-name>, invoked with HTTP GET or POST. This URI structure lets the engineer call custom RPCs such as get-route-information directly, with arguments supplied as query parameters or XML/JSON payload.

Trusting the device's self-signed CA certificate, or installing a proper enterprise CA certificate on the Junos device, fixes the verification failure without disabling TLS checks. This satisfies the stem's constraint of resolving the error while maintaining security best practices.

Unlike NETCONF's dedicated <validate> RPC, the Junos REST API folds validation into the commit workflow: requests can carry commit-check or validation parameters so the device parses and verifies candidate syntax before the change is finalised.

The Junos REST API returns standard HTTP status codes (e.g., 200, 400, 401, 500) and may include error details in the response body. Proper error handling involves checking these codes and parsing messages to retry or log failures. This ensures robust automation that can react to issues like authentication failures or invalid requests.

jpagent converts REST requests and JSON or XML payloads into Junos configuration and operational structures, satisfying the stem's requirement for a translation feature. Without this mapping, REST clients could not drive native Junos RPCs or configuration hierarchies.

REST maps RPCs onto HTTP verbs and URI paths, encoding arguments as JSON or XML in the request body, and returns the response over HTTPS. NETCONF instead wraps raw XML <rpc> elements inside a persistent SSH subsystem session, giving a single XML-based transport rather than per-request HTTP semantics.

An HTTP 400 Bad Request from the Junos REST API often indicates that the request was understood but the configuration data was invalid, such as a syntax error or an unrecognized statement. The JSON error message would provide details. This is a common response when loading configuration with incorrect hierarchy or unsupported commands. The developer should parse the error message to identify and correct the invalid configuration.

REST maps operations onto HTTP methods: GET retrieves, POST creates, PUT replaces and DELETE removes resources. NETCONF instead uses XML-encoded RPC elements over SSH. This verb-based interaction model is the characteristic unique to REST in the comparison.

HTTP 401 Unauthorized is returned when a Junos REST API request lacks valid authentication credentials, such as a missing or incorrect session token. This satisfies the stem's requirement for a status code covering unauthorised client requests.

The Junos REST API authenticates each request using HTTP Basic Authentication, validating the supplied credentials against the local Junos user database or an external AAA server. This default mechanism satisfies the stem's requirement without requiring token-based or session-based authentication.

NETCONF operates as a connection-oriented RPC protocol carried over SSH, maintaining a session and exchanging XML-encoded operations. The Junos REST API instead follows resource-oriented design, using HTTP methods and URIs over HTTP/HTTPS to manipulate configuration and retrieve state.

Junos configuration is inherently hierarchical, so the REST API maps each container statement to a nested JSON object, mirroring the CLI tree. This preserves parent-child relationships, letting clients traverse the payload exactly as they would the configuration hierarchy.

HTTP 403 Forbidden signals the request reached the Junos device and was authenticated, but the account's RBAC class or permission bits deny access to that specific RPC or configuration hierarchy. Insufficient privileges, not malformed syntax or transport failure, produce this authorisation rejection.

REST responses arrive as JSON or XML with defined schemas, so scripts index named fields directly instead of matching brittle regular expressions against screen-formatted CLI output. This satisfies the benefit of eliminating fragile text parsing, which breaks whenever Junos changes column widths or spacing.

PUT replaces the addressed configuration hierarchy with the supplied JSON or XML payload, overwriting the existing node rather than merging into it. This satisfies the requirement to replace an existing hierarchy on the candidate configuration through the Junos REST API.

Unlike expect scripts that parse unstable CLI text, the REST API exposes each configuration and operational model as an addressable URI resource, so automation targets a defined endpoint rather than matching screen output. This resource-based routing is the architectural feature that removes dependence on fragile terminal formatting.

The Junos REST API accepts and returns both JSON and XML payloads, selected via the Accept and Content-Type headers. JSON suits lightweight scripting; XML mirrors Junos native hierarchy. Both satisfy the stem's requirement for natively supported input and output serialisation formats.

This request uses the correct REST API endpoint for retrieving interface operational information. The Junos REST API exposes operational RPCs under the /rest/ path, and 'interface-information' corresponds to the 'show interfaces' RPC. A GET request retrieves data without modifying configuration, which is appropriate for this scenario.

The 'comment' parameter allows you to attach a descriptive comment to the commit, which is logged in the commit history. This is essential for audit trails and understanding the purpose of configuration changes. In the Junos REST API, you include it as a parameter in the commit RPC, for example: /rpc/commit?comment=my_change. It satisfies the requirement to include a descriptive comment.

Supplying `Accept: application/json` makes the Junos REST API convert the RPC's native hierarchical XML into an equivalent JSON object, preserving the same nested container and leaf structure. This satisfies the stem's constraint of requesting JSON-formatted operational data, returning the hierarchy rather than a flat or tabular representation.

Content negotiation in the Junos REST API is driven by the HTTP Accept header. Setting Accept: application/json instructs the device to serialise the candidate configuration response as JSON rather than the default XML, satisfying the JSON output requirement.

Enabling HTTPS on jpagent encrypts credentials and configuration payloads in transit, preventing interception or tampering over the management network. This satisfies the robust-execution requirement for secure transport when automating configuration through the Junos REST API.

200 OK confirms the Junos REST API processed the request and returns the requested representation in the response body, satisfying the stem's requirement for data successfully retrieved or modified. It is the standard success code for GET and POST operations that return content.

Junos REST API and NETCONF both expose the same underlying Junos data models and management daemon infrastructure, differing only in transport and encoding. This satisfies the question by confirming the shared model relationship rather than treating them as separate schemas.

REST uses standard HTTP verbs and URIs, so existing HTTP/HTTPS proxies, load balancers and firewalls handle it without protocol-specific configuration. NETCONF requires SSH transport on port 830, which many proxies cannot traverse. This satisfies the stem's lightweight automation constraint, where minimal infrastructure changes matter.

Operational endpoints expose live device state, so retrieving interface packet counters and operational states falls squarely within their scope. This satisfies the stem's requirement for read-only operational data, unlike configuration endpoints that modify candidate configuration. The REST API returns this telemetry as structured JSON or XML.

NETCONF returns faults as structured XML rpc-error elements carrying error-type, tag and severity inside the RPC reply. The Junos REST API instead signals failure through HTTP status codes with a JSON error body, so the two differ in both transport and payload.

Junos REST API responses and request bodies can be encoded as either JSON or XML, selected via the Accept and Content-Type HTTP headers. This dual-format support satisfies the question's requirement, letting clients choose whichever serialisation suits their tooling without protocol changes.

Supplying action=commit alongside the configuration payload makes the REST API validate and commit the candidate in one call, satisfying the stem's requirement to avoid dangling candidate changes. Without it, the change stays uncommitted until a separate commit request is issued.

REST API uses standard HTTP/HTTPS transport, so requests traverse existing web proxies and integrate natively with modern web frameworks via JSON payloads. This satisfies the stem's web-centric constraint, where NETCONF's SSH-based transport and XML encoding demand additional tooling and proxy configuration.

The Junos REST API supports executing RPCs via POST to /rpc/<rpc-name>. For commit, the RPC is 'commit'. The request body must be XML that includes the <commit-comment> and <synchronize> elements to add a comment and synchronize across Routing Engines. This single request accomplishes both requirements, making it the correct approach.

The Junos REST API supports session-based authentication. A client can send a POST request to the /rest/rpc/login RPC with credentials, which returns a session cookie. Subsequent requests include this cookie for authentication. This method avoids sending credentials with every request and is useful for maintaining a session. It is a supported authentication mechanism.

201 Created confirms the POST succeeded and a new static route resource now exists. The response typically includes a Location header pointing to the created object, distinguishing it from 200 OK, which signals a successful request without resource creation.

HTTP DELETE targets a specific configuration hierarchy or statement, removing it from the candidate configuration rather than committing it. This satisfies the stem's constraint that the change executes against the candidate, not the active configuration, so the deletion stays uncommitted until an explicit commit operation is issued.

The commit RPC returns an HTTP status code and a response body indicating success or failure. A successful commit returns 200 OK and a commit result. Checking this response directly confirms whether the commit succeeded. This is the most reliable way to verify the commit operation. The load-configuration call must include the configuration data and appropriate parameters.

The Junos REST API exposes operational commands through RPC endpoints. To retrieve interface status, you must call the appropriate RPC, such as get-interface-information, via the /rest/rpc/ path. A simple GET to /rest/interface does not map to an operational command and returns an empty response. Using the correct RPC endpoint returns the desired operational data.

The Junos REST API uses POST to /rest/conf/ to load configuration data into the candidate configuration. By default, the load operation merges the provided configuration with the existing candidate. This is the correct method and endpoint for loading configuration via REST.

Intermittent 401 errors with correct local credentials often indicate an external authentication server issue. If the Junos device is configured to use RADIUS or TACACS+ for authentication, a temporary network problem or server unavailability can cause authentication to fail, resulting in 401 responses. The REST API relies on the device's authentication mechanisms.

Junos REST JSON mirrors the XML hierarchy: repeated configuration nodes such as multiple static routes or next-hops are encoded as JSON arrays, each element an object holding that entry's leaf values, so every instance is represented distinctly.

HTTP Basic Authentication places the Base64-encoded username and password in the Authorization request header, prefixed with "Basic". Without this header the REST API rejects the request as unauthenticated, so it satisfies the credential-passing requirement in the stem.

The `get-software-information` RPC returns the full software package inventory, satisfying the requirement to list all installed packages. Targeting it under `/api/operational/rpc/` invokes the operational command directly via the Junos REST API, rather than a configuration or management endpoint, which would not expose installed package data.

'application/json' is a valid Accept header value for Junos REST API GET requests, returning responses serialised as JSON. This satisfies the stem's requirement by naming one of the two supported serialisation formats the device can negotiate.

REST relies on standard HTTP verbs — GET, POST, PUT, DELETE — sent over HTTP or HTTPS ports, mapping operations onto resources. NETCONF instead uses SSH transport with XML-encoded RPCs, so this HTTP-method characteristic genuinely distinguishes the two interfaces.

Junos enables the REST API over HTTPS by default on TCP port 3443, distinct from the standard 443 used by other web services. Plain HTTP REST listens on port 3000. The stem's secure HTTPS constraint therefore maps directly to 3443.

The `system services jpagent` hierarchy enables the Junos REST API agent, satisfying the stem's requirement for REST API service parameters. Unlike NETCONF over SSH or the legacy JUNOScript API, jpagent exposes RESTful HTTP/HTTPS access, so its configuration lives under `system services` alongside other daemons such as `ssh` and `telnet`.

NETCONF's SSH transport carries a long-lived, stateful session where both peers exchange capability sets at startup, then reuse that negotiated context for every subsequent RPC. This satisfies the stem's contrast with the Junos REST API, which is stateless per HTTP request and re-establishes context each call.

POST carries configuration and RPC payloads to the Junos REST API, creating or loading candidate configuration and invoking operational commands. It satisfies the stem's need for a method that manages resources rather than merely reading them.