{"id":18179,"date":"2026-09-22T05:57:32","date_gmt":"2026-09-22T05:57:32","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18179"},"modified":"2026-09-22T05:57:32","modified_gmt":"2026-09-22T05:57:32","slug":"cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part9-q161-180","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part9-q161-180\/","title":{"rendered":"Cisco CCNP Automation 350-901 Practice Test Questions and Exam Dumps Part9 Q161-180"},"content":{"rendered":"

View Full <\/b>Cisco CCNP Automation 350-901 Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/p>\n


\n<\/b>Q161. A Python network automation function opens a file containing generated configurations. The engineer wants the file to be closed automatically even if an exception occurs. Which Python technique is most appropriate?<\/b><\/p>\n

    \n
  1. <\/b> Keep the file open until the script exits<\/span>
    \n<\/span>2.<\/b> Use a <\/span>with<\/span> context manager<\/span>
    \n<\/span>3.<\/b> Open the file repeatedly inside an infinite loop<\/span>
    \n<\/span>4.<\/b> Store the file descriptor in a global variable<\/span><\/li>\n<\/ol>\n

    Correct Answer: 2. Use a <\/b>with<\/b> context manager<\/b><\/p>\n

    Explanation:<\/b> A Python <\/span>with<\/span> statement uses a context manager to manage resources such as files safely. When execution leaves the <\/span>with<\/span> block, Python closes the file automatically, including when an exception occurs inside the block. This reduces resource leaks and makes code easier to understand than manually opening and closing files across multiple execution paths. Similar context-management patterns can be useful for other resources that require setup and cleanup. Reliable network automation code should manage files, sessions, and other resources predictably because failed cleanup can create locked files, resource exhaustion, or inconsistent workflow behavior.<\/span><\/p>\n

    Q162. A Terraform resource should be replaced before the existing instance is destroyed because removing the old instance first would interrupt a critical service. Which lifecycle setting is most appropriate?<\/b><\/p>\n

      \n
    1. <\/b> prevent_destroy = false<\/span>
      \n<\/span>2.<\/b> ignore_changes<\/span>
      \n<\/span>3.<\/b> depends_on<\/span>
      \n<\/span>4.<\/b> create_before_destroy = true<\/span><\/li>\n<\/ol>\n

      Correct Answer: 4. <\/b>create_before_destroy = true<\/b><\/p>\n

      Explanation:<\/b> The <\/span>create_before_destroy<\/span> lifecycle setting instructs Terraform to attempt creation of the replacement resource before removing the existing resource when replacement is required. This can reduce downtime for resources that can coexist temporarily. Engineers must still confirm that the underlying platform allows both instances to exist simultaneously and that identifiers, capacity, or addressing do not conflict. <\/span>ignore_changes<\/span> tells Terraform to disregard selected attribute differences, while <\/span>depends_on<\/span> expresses dependency ordering. Lifecycle behavior should be designed carefully because infrastructure changes can have availability consequences beyond the Terraform configuration itself.<\/span><\/p>\n

      Q163. An engineer uses NETCONF to modify configuration on a device that supports a candidate datastore. What is a key advantage of using the candidate datastore?<\/b><\/p>\n

        \n
      1. <\/b> Changes can be prepared and validated before they are committed to the active configuration<\/span>
        \n<\/span>2.<\/b> It permanently disables configuration validation<\/span>
        \n<\/span>3.<\/b> It eliminates the need for authentication<\/span>
        \n<\/span>4.<\/b> It converts NETCONF messages into unstructured CLI text<\/span><\/li>\n<\/ol>\n

        Correct Answer: 1. Changes can be prepared and validated before they are committed to the active configuration<\/b><\/p>\n

        Explanation:<\/b> A NETCONF candidate datastore allows configuration changes to be staged separately from the active running configuration. Automation can edit the candidate configuration, perform validation where supported, and then commit the prepared changes as a controlled operation. This can reduce the risk of leaving a device in a partially modified state when several related changes must be applied together. The exact datastore capabilities depend on the network platform. NETCONF still requires appropriate authentication and structured operations. The candidate model supports transactional configuration workflows that can be safer than applying a long series of unrelated CLI commands individually.<\/span><\/p>\n

        Q164. An API client must process 10,000 device objects returned in multiple pages. Each response contains a <\/b>next<\/b> URL until the final page. What should the client do?<\/b><\/p>\n

          \n
        1. <\/b> Process only the first page<\/span>
          \n<\/span>2.<\/b> Guess URLs for later pages manually<\/span>
          \n<\/span>3.<\/b> Follow each returned <\/span>next<\/span> URL until no continuation URL remains<\/span>
          \n<\/span>4.<\/b> Increase the timeout and assume all objects are on page one<\/span><\/li>\n<\/ol>\n

          Correct Answer: 3. Follow each returned <\/b>next<\/b> URL until no continuation URL remains<\/b><\/p>\n

          Explanation:<\/b> This API is using link-based pagination. The client should process the current page and follow the server-provided continuation URL until the response indicates there are no additional pages. Using the API’s supplied link avoids assumptions about how pagination is implemented and helps ensure all objects are retrieved. The automation should also handle errors and avoid processing the same page repeatedly if malformed continuation data appears. Pagination is important in network automation because inventory, event, and configuration APIs can return datasets far larger than a single response should reasonably contain.<\/span><\/p>\n

          Q165. A Terraform team repeatedly computes the same complex expression from several input variables inside one module. Which Terraform construct can improve readability by assigning that computed value a reusable name?<\/b><\/p>\n

            \n
          1. <\/b> Local value<\/span>
            \n<\/span>2.<\/b> State lock<\/span>
            \n<\/span>3.<\/b> Provider alias<\/span>
            \n<\/span>4.<\/b> Backend block<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1. Local value<\/b><\/p>\n

            Explanation:<\/b> Terraform local values allow expressions to be assigned meaningful names and reused elsewhere within a module. This can make configurations easier to read when the same derived value, naming convention, prefix, tag set, or address calculation is needed multiple times. Locals are not user-supplied inputs and do not expose results externally in the same way outputs do. A backend controls state storage, while provider aliases configure multiple provider instances. Using locals appropriately reduces duplicated expressions and makes Infrastructure as Code easier to review and maintain without introducing unnecessary repetition.<\/span><\/p>\n

            Q166. A Git branch has several local commits that should be replayed on top of the latest <\/b>main<\/b> branch to produce a linear history. Which Git operation is most appropriate?<\/b><\/p>\n

              \n
            1. <\/b> git clean<\/span>
              \n<\/span>2.<\/b> git init<\/span>
              \n<\/span>3.<\/b> git tag<\/span>
              \n<\/span>4.<\/b> git rebase main<\/span><\/li>\n<\/ol>\n

              Correct Answer: 4. <\/b>git rebase main<\/b><\/p>\n

              Explanation:<\/b> Rebasing replays the current branch’s commits on top of another base commit, such as the latest <\/span>main<\/span> branch. This can create a cleaner linear history by avoiding an additional merge commit. Because rebase rewrites commit identifiers, teams should be cautious when rebasing commits that have already been shared with other collaborators. Conflicts may also need to be resolved during the operation. Although core AUTOCOR Git objectives emphasize several specific version-control operations, understanding branch-history management helps engineers maintain clean Infrastructure as Code repositories and integrate network automation changes predictably.<\/span><\/p>\n

              Q167. A GitLab deployment job should run only when changes are merged into the protected <\/b>main<\/b> branch, not for every feature-branch commit. Which pipeline capability should be used?<\/b><\/p>\n

                \n
              1. <\/b> Remove all branch information from the pipeline<\/span>
                \n<\/span>2.<\/b> Configure job rules or conditions based on the branch<\/span>
                \n<\/span>3.<\/b> Run production deployment from every commit<\/span>
                \n<\/span>4.<\/b> Disable source control integration<\/span><\/li>\n<\/ol>\n

                Correct Answer: 2. Configure job rules or conditions based on the branch<\/b><\/p>\n

                Explanation:<\/b> GitLab pipeline rules can control whether a job is included based on conditions such as branch name, pipeline source, changed files, or variables. A production deployment can therefore be restricted to the protected <\/span>main<\/span> branch while tests and validation still run on feature branches. This reduces the chance of unreviewed development changes reaching production. Branch protection, approvals, and required validation can provide additional safeguards. CI\/CD automation should encode deployment policy explicitly rather than relying on engineers to remember which jobs are safe to run manually.<\/span><\/p>\n

                Q168. A CI pipeline launches a CML topology for testing, but a failed test prevents the normal cleanup stage from running. What design improvement best prevents abandoned lab environments from accumulating?<\/b><\/p>\n

                  \n
                1. <\/b> Never destroy test topologies<\/span>
                  \n<\/span>2.<\/b> Run cleanup only after successful deployments<\/span>
                  \n<\/span>3.<\/b> Configure cleanup to execute even when earlier jobs fail<\/span>
                  \n<\/span>4.<\/b> Require users to remove every lab manually<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3. Configure cleanup to execute even when earlier jobs fail<\/b><\/p>\n

                  Explanation:<\/b> Temporary test environments should have reliable cleanup logic that runs whether validation succeeds or fails. CI\/CD platforms commonly provide ways to define cleanup jobs or execution conditions that allow teardown after failed stages. Without this protection, failed pipelines can leave CML labs running and eventually consume CPU, memory, licensing capacity, or address resources. The pipeline should preserve relevant logs and test results before destruction, but infrastructure intended to be ephemeral should not depend on a completely successful pipeline for cleanup. This pattern improves repeatability and operational hygiene.<\/span><\/p>\n

                  Q169. A model-driven telemetry deployment sends data to a message bus before several analytics applications consume it. What is a major architectural benefit of the message bus?<\/b><\/p>\n

                    \n
                  1. <\/b> It removes the need for device telemetry subscriptions<\/span>
                    \n<\/span>2.<\/b> It converts all telemetry into CLI commands<\/span>
                    \n<\/span>3.<\/b> It prevents every collector failure<\/span>
                    \n<\/span>4.<\/b> It decouples telemetry producers from multiple downstream consumers<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 4. It decouples telemetry producers from multiple downstream consumers<\/b><\/p>\n

                    Explanation:<\/b> A message bus can separate telemetry ingestion from downstream processing. Devices or collectors publish data into the messaging layer, while monitoring, analytics, alerting, or storage systems consume the information independently. This makes it easier to add consumers without requiring every device to send separate streams to every application. The architecture can also absorb bursts and provide buffering depending on the technology used. It does not eliminate the need for subscriptions, sizing, retention planning, or fault tolerance. Decoupling components is especially useful when telemetry platforms must support several operational use cases simultaneously.<\/span><\/p>\n

                    Q170. A network automation application receives a webhook event containing a unique event identifier. Why should it record identifiers that have already been processed?<\/b><\/p>\n

                      \n
                    1. <\/b> To support deduplication and avoid performing the same action twice<\/span>
                      \n<\/span>2.<\/b> To disable webhook authentication<\/span>
                      \n<\/span>3.<\/b> To make events larger<\/span>
                      \n<\/span>4.<\/b> To replace all application logs<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 2. To support deduplication and avoid performing the same action twice<\/b><\/p>\n

                      Explanation:<\/b> Webhook delivery can be retried when the sender does not receive an acknowledgment or experiences a transient network problem. As a result, the same logical event may arrive more than once. Recording a unique event identifier allows the receiver to determine whether an event has already been processed and avoid duplicate changes. This is especially important when the action is not naturally idempotent. Authentication, signatures, and schema validation should still protect the webhook. Deduplication improves reliability by ensuring transport-level retries do not unintentionally produce repeated infrastructure operations.<\/span><\/p>\n

                      Q171. A network automation service logs events in JSON with fields for timestamp, device, operation, result, and correlation ID. What is the main advantage of this structured logging approach?<\/b><\/p>\n

                        \n
                      1. <\/b> It makes machine parsing, filtering, and correlation easier<\/span>
                        \n<\/span>2.<\/b> It guarantees the application will never fail<\/span>
                        \n<\/span>3.<\/b> It removes the need for log storage<\/span>
                        \n<\/span>4.<\/b> It automatically fixes configuration errors<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 1. It makes machine parsing, filtering, and correlation easier<\/b><\/p>\n

                        Explanation:<\/b> Structured logs represent attributes as predictable fields instead of embedding all context in arbitrary free-form messages. Log collectors and SIEM platforms can therefore index fields, search by device or job ID, build dashboards, and correlate related events across distributed automation components. Correlation identifiers are especially useful when one workflow interacts with several APIs or devices. Structured logging does not eliminate failures, but it improves the ability to diagnose them. Sensitive information should still be redacted so the operational benefits of rich logging do not create credential exposure.<\/span><\/p>\n

                        Q172. A network automation API certificate has been compromised before its normal expiration date. Which PKI mechanism can clients use to determine that the certificate should no longer be trusted?<\/b><\/p>\n

                          \n
                        1. <\/b> Git commit signing<\/span>
                          \n<\/span>2.<\/b> Terraform state locking<\/span>
                          \n<\/span>3.<\/b> Certificate revocation information such as CRL or OCSP<\/span>
                          \n<\/span>4.<\/b> Docker image tagging<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 3. Certificate revocation information such as CRL or OCSP<\/b><\/p>\n

                          Explanation:<\/b> Certificate revocation mechanisms allow a certificate authority to indicate that a certificate should no longer be trusted even though its validity period has not expired. A Certificate Revocation List contains revoked certificate information, while the Online Certificate Status Protocol can provide status information more dynamically. Client behavior depends on platform and configuration, but revocation checking is part of a complete PKI lifecycle. If a private key is compromised, administrators should revoke and replace the affected certificate promptly. Expiration alone is insufficient because the compromised certificate could otherwise remain valid for months.<\/span><\/p>\n

                          Q173. An automation system receives a device hostname from an external API. The hostname will later be included in a shell command. Which approach is safest?<\/b><\/p>\n

                            \n
                          1. <\/b> Concatenate the raw hostname directly into the command<\/span>
                            \n<\/span>2.<\/b> Validate against an allowlisted format and avoid shell execution when a safer API is available<\/span>
                            \n<\/span>3.<\/b> Trust the value because another application supplied it<\/span>
                            \n<\/span>4.<\/b> Disable command logging and execute it as root<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 2. Validate against an allowlisted format and avoid shell execution when a safer API is available<\/b><\/p>\n

                            Explanation:<\/b> Data from another application should still be treated as untrusted. The automation should validate the hostname against expected syntax and, where possible, avoid constructing shell commands from external text altogether. Safer libraries or APIs that separate arguments from command syntax reduce injection risk. If shell execution is genuinely required, the script should use strict allowlists and appropriate argument-handling mechanisms. Running as root increases the impact of any injection flaw. Secure automation design assumes data can become malicious or malformed regardless of which upstream system supplied it.<\/span><\/p>\n

                            Q174. A network team uses a local LLM for automation assistance. Which metric is most useful when evaluating whether the model consistently generates correct configuration recommendations for a defined test set?<\/b><\/p>\n

                              \n
                            1. <\/b> Number of CPU fans in the server<\/span>
                              \n<\/span>2.<\/b> Size of the terminal window<\/span>
                              \n<\/span>3.<\/b> Average prompt length only<\/span>
                              \n<\/span>4.<\/b> Accuracy against a validated set of expected answers or outcomes<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 1. Accuracy against a validated set of expected answers or outcomes<\/b><\/p>\n

                              Explanation:<\/b> A controlled evaluation dataset with known correct outcomes allows the team to measure how often the model produces technically correct recommendations. Accuracy alone may not capture every operational concern, so teams can also examine unsafe outputs, consistency, latency, and false positive or false negative behavior depending on the use case. However, comparing results against authoritative expected answers provides direct evidence of technical quality. Subjective impressions from a few prompts are insufficient for production decisions. AI-assisted network automation should be evaluated systematically before being trusted for consequential workflows.<\/span><\/p>\n

                              Q175. An AI assistant needs access to internal network documentation when answering questions but should not require that all documentation be embedded permanently in the model. Which approach best supports this requirement?<\/b><\/p>\n

                                \n
                              1. <\/b> Remove access to documentation entirely<\/span>
                                \n<\/span>2.<\/b> Fine-tune the model after every document edit<\/span>
                                \n<\/span>3.<\/b> Retrieve relevant current documents at query time and provide them as grounded context<\/span>
                                \n<\/span>4.<\/b> Ask the model to guess from general training data<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 4. Retrieve relevant current documents at query time and provide them as grounded context<\/b><\/p>\n

                                Explanation:<\/b> Retrieval-augmented workflows can search approved documentation when a question is asked and provide relevant passages to the language model as context. This allows the system to use current organizational information without retraining the model every time documentation changes. Access controls should be enforced during retrieval so users do not gain information they are not permitted to view. Retrieved content should also be treated as potentially untrusted input because documents can contain malicious instructions. Grounding the response in approved current sources generally improves factual relevance compared with relying only on pretrained model knowledge.<\/span><\/p>\n

                                Q176. A FastMCP tool accepts a <\/b>device_name<\/b> parameter. Why is defining a clear tool schema useful to an AI agent?<\/b><\/p>\n

                                  \n
                                1. <\/b> It eliminates all need for authorization<\/span>
                                  \n<\/span>2.<\/b> It tells the model what arguments the tool expects and their intended structure<\/span>
                                  \n<\/span>3.<\/b> It gives the agent unrestricted shell access<\/span>
                                  \n<\/span>4.<\/b> It guarantees every generated argument is safe<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. It tells the model what arguments the tool expects and their intended structure<\/b><\/p>\n

                                  Explanation:<\/b> A clear MCP tool schema describes the function, its parameters, expected types, and often useful descriptions. This helps the model select an appropriate tool and construct a correctly structured call. Schema definition improves interoperability between the AI client and the MCP server, but it is not a security boundary by itself. The server must still validate every argument and enforce authentication and authorization. A correctly shaped request can still be malicious or inappropriate. Tool schemas support reliable AI integration, while deterministic server-side controls provide the necessary operational protection.<\/span><\/p>\n

                                  Q177. An AI agent is asked to troubleshoot a routing problem. Its available tools include <\/b>show_routes<\/b>, <\/b>show_interfaces<\/b>, and <\/b>erase_startup_config<\/b>. Which design change best follows least privilege?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Remove the destructive configuration tool from the troubleshooting agent’s available tool set<\/span>
                                    \n<\/span>2.<\/b> Keep every tool and rely only on prompt instructions<\/span>
                                    \n<\/span>3.<\/b> Remove authentication from all tools<\/span>
                                    \n<\/span>4.<\/b> Allow arbitrary commands instead of named tools<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. Remove the destructive configuration tool from the troubleshooting agent’s available tool set<\/b><\/p>\n

                                    Explanation:<\/b> Least privilege means an agent should receive only the capabilities necessary for its assigned task. A troubleshooting assistant requires read-oriented diagnostic functions but does not need a destructive startup-configuration operation. Removing that capability creates a stronger control than merely instructing the model not to use it. If prompt injection or model error occurs, an unavailable tool cannot be selected. Tool authorization, input validation, audit logging, and identity controls should still be enforced. AI systems should be designed so that accidental reasoning failures have a limited operational blast radius.<\/span><\/p>\n

                                    Q178. A generative AI system produces two different configurations from the same prompt on separate runs. Which property of LLM behavior does this demonstrate?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Terraform state corruption<\/span>
                                      \n<\/span>2.<\/b> Probabilistic output variability<\/span>
                                      \n<\/span>3.<\/b> Git branch protection<\/span>
                                      \n<\/span>4.<\/b> Deterministic compilation<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2. Probabilistic output variability<\/b><\/p>\n

                                      Explanation:<\/b> Large language models generate tokens probabilistically, so identical or nearly identical prompts can produce different responses depending on model configuration, sampling parameters, and internal generation behavior. This means AI-generated automation should not be assumed to be deterministic. Teams should validate generated code and configuration every time it is used, especially for infrastructure changes. Lower-temperature or constrained generation can reduce variability but does not transform an LLM into a deterministic policy engine. Critical network decisions should therefore rely on explicit validation, policy checks, and authoritative state rather than raw model output alone.<\/span><\/p>\n

                                      Q179. A conversational network agent proposes an interface shutdown. Which architecture provides the strongest audit trail for determining later why the action occurred?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Store only the final device configuration<\/span>
                                        \n<\/span>2.<\/b> Disable model and tool logging<\/span>
                                        \n<\/span>3.<\/b> Keep only the user’s username<\/span>
                                        \n<\/span>4.<\/b> Record the user request, relevant retrieved context, model decision, approval, tool call, and resulting network outcome<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 4. Record the user request, relevant retrieved context, model decision, approval, tool call, and resulting network outcome<\/b><\/p>\n

                                        Explanation:<\/b> End-to-end auditability requires more than the final device state. Logging the original request, retrieved operational evidence, model output, human approval where applicable, exact tool invocation, timestamps, identity information, and post-change result allows investigators to reconstruct why an action happened. Sensitive information should be protected or redacted appropriately. This type of traceability is particularly important for AI-assisted automation because the reasoning layer may be probabilistic. Detailed audit records support troubleshooting, governance, incident investigation, and accountability when automated systems are allowed to influence production infrastructure.<\/span><\/p>\n

                                        Q180. An organization is considering whether an AI network agent should autonomously reboot production routers when it detects a fault. What is the most appropriate design principle?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Make every AI recommendation execute automatically<\/span>
                                          \n<\/span>2.<\/b> Remove post-action validation<\/span>
                                          \n<\/span>3.<\/b> Match autonomy to risk, using deterministic checks and human approval for high-impact actions<\/span>
                                          \n<\/span>4.<\/b> Give the model unrestricted administrator credentials<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 3. Match autonomy to risk, using deterministic checks and human approval for high-impact actions<\/b><\/p>\n

                                          Explanation:<\/b> AI autonomy should be proportional to the potential operational impact of an action. Low-risk read operations may be safely automated, while rebooting a production router can disrupt many users and should normally require strong validation, policy controls, and potentially explicit human approval. The automation should confirm the device, fault condition, dependencies, redundancy, and maintenance context before acting. Post-action validation should verify recovery. An AI model can contribute analysis, but high-impact decisions should remain bounded by deterministic controls that continue to function even if the model is mistaken or manipulated.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Cisco CCNP Automation 350-901 Exam Dumps and Practice Test Dumps. Q161. A Python network automation function opens a file containing generated configurations. The engineer wants the file to be closed automatically even if an exception occurs. Which Python technique is most appropriate? Keep the file open until the script exits 2. Use a […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18179"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=18179"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18179\/revisions"}],"predecessor-version":[{"id":18180,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18179\/revisions\/18180"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18179"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18179"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18179"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}