{"id":18173,"date":"2026-09-22T05:56:33","date_gmt":"2026-09-22T05:56:33","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18173"},"modified":"2026-09-22T05:56:33","modified_gmt":"2026-09-22T05:56:33","slug":"cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part6-q101-120","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/cisco-ccnp-automation-350-901-practice-test-questions-and-exam-dumps-part6-q101-120\/","title":{"rendered":"Cisco CCNP Automation 350-901 Practice Test Questions and Exam Dumps Part6 Q101-120"},"content":{"rendered":"

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


\n<\/b>Q101. A Python network automation application receives an API response containing device records. Some records do not contain the optional <\/b>location<\/b> key. Which approach most safely retrieves this value without raising a <\/b>KeyError<\/b> when it is missing?<\/b><\/p>\n

    \n
  1. <\/b> Access <\/span>device[“location”]<\/span> without checking<\/span>
    \n<\/span>2.<\/b> Use <\/span>device.get(“location”)<\/span> with an appropriate default<\/span>
    \n<\/span>3.<\/b> Convert the dictionary into a string first<\/span>
    \n<\/span>4.<\/b> Delete any record that lacks the key<\/span><\/li>\n<\/ol>\n

    Correct Answer: 2. Use <\/b>device.get(“location”)<\/b> with an appropriate default<\/b><\/p>\n

    Explanation:<\/b> Python dictionaries provide the <\/span>get()<\/span> method for retrieving a key while safely handling cases in which the key does not exist. The method can return <\/span>None<\/span> or a caller-supplied default rather than raising a <\/span>KeyError<\/span>. This is useful when automation consumes APIs where some attributes are optional. Direct bracket access is appropriate when a field is guaranteed to exist, but it is less resilient for optional data. Robust network automation should validate API responses and gracefully handle missing values instead of crashing or discarding otherwise useful device records.<\/span><\/p>\n

    Q102. An Ansible playbook needs to apply an ACL task only when the variable <\/b>enable_edge_acl<\/b> is set to <\/b>true<\/b>. Which mechanism should be used?<\/b><\/p>\n

      \n
    1. <\/b> A <\/span>when<\/span> conditional on the task<\/span>
      \n<\/span>2.<\/b> A <\/span>handlers<\/span> block only<\/span>
      \n<\/span>3.<\/b> A <\/span>register<\/span> statement without a condition<\/span>
      \n<\/span>4.<\/b> A new inventory file for each execution<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1. A <\/b>when<\/b> conditional on the task<\/b><\/p>\n

      Explanation:<\/b> Ansible’s <\/span>when<\/span> statement controls whether a task runs based on a Boolean expression or other evaluated condition. If <\/span>enable_edge_acl<\/span> is true, the ACL task executes; otherwise, Ansible skips it. This allows one reusable playbook to support multiple environments or device roles without duplicating entire playbooks. Handlers are intended for tasks triggered by notifications, and <\/span>register<\/span> stores task results for later use. Conditional execution is fundamental to building maintainable automation that adapts safely to variables, platform state, or previous task outcomes.<\/span><\/p>\n

      Q103. A Terraform engineer wants to expose the management IP address of a newly created network appliance so another automation workflow can consume it. Which Terraform construct should be used?<\/b><\/p>\n

        \n
      1. <\/b> A provider block<\/span>
        \n<\/span>2.<\/b> A lifecycle block<\/span>
        \n<\/span>3.<\/b> A state lock<\/span>
        \n<\/span>4.<\/b> An output value<\/span><\/li>\n<\/ol>\n

        Correct Answer: 4. An output value<\/b><\/p>\n

        Explanation:<\/b> Terraform output values expose selected information from a Terraform configuration after evaluation. An output can reference an attribute such as a management IP address, resource identifier, or generated endpoint and make it available to operators or downstream automation. Variables provide input into a configuration, while outputs communicate useful resulting values. Provider blocks configure communication with infrastructure platforms, and state locks prevent conflicting concurrent operations. Outputs are particularly useful when one automation stage provisions infrastructure and a later workflow needs attributes from the newly created resources.<\/span><\/p>\n

        Q104. A RESTCONF client wants to remove a configured loopback interface represented by a YANG-modeled resource. Which HTTP method is most appropriate?<\/b><\/p>\n

          \n
        1. <\/b> GET<\/span>
          \n<\/span>2.<\/b> HEAD<\/span>
          \n<\/span>3.<\/b> DELETE<\/span>
          \n<\/span>4.<\/b> OPTIONS<\/span><\/li>\n<\/ol>\n

          Correct Answer: 3. DELETE<\/b><\/p>\n

          Explanation:<\/b> HTTP DELETE is used to remove the resource identified by the target URI. In a RESTCONF workflow, deleting a YANG-modeled configuration object such as an interface generally uses DELETE against the appropriate data resource. GET retrieves data, HEAD requests response metadata without the normal body, and OPTIONS describes supported communication options rather than removing configuration. Automation clients should still verify that the resource exists, check the returned status code, and perform post-change validation to ensure the deletion produced the intended network state.<\/span><\/p>\n

          Q105. A network team must automate a workflow that includes complex calculations, multiple external APIs, conditional logic, and a custom operator interface. Which automation approach is most appropriate?<\/b><\/p>\n

            \n
          1. <\/b> A custom application<\/span>
            \n<\/span>2.<\/b> A simple static spreadsheet only<\/span>
            \n<\/span>3.<\/b> Manual CLI changes<\/span>
            \n<\/span>4.<\/b> A no-code tool regardless of feature limitations<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1. A custom application<\/b><\/p>\n

            Explanation:<\/b> A custom application is often appropriate when automation requires specialized business logic, numerous API integrations, complex state handling, custom user interaction, or functionality not well supported by declarative or low-code frameworks. Infrastructure as Code and no-code tools remain valuable for use cases that fit their strengths, but the architecture should be selected according to requirements rather than tool preference. A custom application introduces software-development and maintenance responsibilities, so teams should consider testing, observability, security, and lifecycle management before choosing this approach.<\/span><\/p>\n

            Q106. A Git repository contains a commit that introduced an incorrect ACL and was already pushed to a shared branch. Which operation best removes the ACL change while preserving the existing shared history?<\/b><\/p>\n

              \n
            1. <\/b> git reset –hard<\/span> followed by force push<\/span>
              \n<\/span>2.<\/b> Delete the repository<\/span>
              \n<\/span>3.<\/b> git revert<\/span> the offending commit<\/span>
              \n<\/span>4.<\/b> git init<\/span> in the same directory<\/span><\/li>\n<\/ol>\n

              Correct Answer: 3. <\/b>git revert<\/b> the offending commit<\/b><\/p>\n

              Explanation:<\/b> git revert<\/span> creates a new commit that reverses the changes introduced by an earlier commit while preserving all existing history. This is the safest normal approach on shared branches because collaborators do not need to reconcile a rewritten commit graph. A hard reset followed by a force push can rewrite shared history and disrupt other users. For network automation repositories, preserving traceability is especially useful because configuration changes may need to be audited or correlated with production events.<\/span><\/p>\n

              Q107. A GitLab pipeline uses a container image for its Python test job. The job works locally but fails in CI because the image lacks a required system package. What should the team do?<\/b><\/p>\n

                \n
              1. <\/b> Ignore the CI failure<\/span>
                \n<\/span>2.<\/b> Use or build a runner image containing the documented required dependencies<\/span>
                \n<\/span>3.<\/b> Remove all tests<\/span>
                \n<\/span>4.<\/b> Run the deployment directly from a developer laptop<\/span><\/li>\n<\/ol>\n

                Correct Answer: 2. Use or build a runner image containing the documented required dependencies<\/b><\/p>\n

                Explanation:<\/b> CI jobs should execute in reproducible environments containing the runtimes, libraries, and system packages required by the automation. If a pipeline container image lacks a dependency, the correct solution is to update the job image or create a controlled build image that includes all documented prerequisites. This makes CI behavior predictable and prevents “works on my machine” problems. Removing tests or bypassing CI would only hide the inconsistency. Reproducible pipeline environments are critical when network changes depend on automated validation before production deployment.<\/span><\/p>\n

                Q108. A CML test topology is launched automatically during a CI pipeline. What should happen after all validation tests finish successfully if the topology is needed only for that pipeline run?<\/b><\/p>\n

                  \n
                1. <\/b> Leave every lab running permanently<\/span>
                  \n<\/span>2.<\/b> Convert the lab into production infrastructure<\/span>
                  \n<\/span>3.<\/b> Remove Git history<\/span>
                  \n<\/span>4.<\/b> Tear down the temporary topology to release resources<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 4. Tear down the temporary topology to release resources<\/b><\/p>\n

                  Explanation:<\/b> Ephemeral test environments should generally be destroyed after they have served their purpose. A CI pipeline can create a CML topology, execute configuration and validation tasks, capture results, and then tear down the lab to release compute and memory resources. This improves repeatability and reduces unnecessary infrastructure consumption. Keeping temporary labs running can create cost, resource exhaustion, and state drift. Pipeline cleanup should also execute when tests fail, where practical, so abandoned test topologies do not accumulate over time.<\/span><\/p>\n

                  Q109. A source of truth lists the intended VLAN for an interface as 30, but the device currently uses VLAN 40. What type of condition has been detected?<\/b><\/p>\n

                    \n
                  1. <\/b> Certificate revocation<\/span>
                    \n<\/span>2.<\/b> Configuration drift<\/span>
                    \n<\/span>3.<\/b> Git squash merge<\/span>
                    \n<\/span>4.<\/b> API pagination<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 2. Configuration drift<\/b><\/p>\n

                    Explanation:<\/b> Configuration drift occurs when the actual infrastructure state differs from the approved or declared desired state. In this case, the source of truth expects VLAN 30 while the live device reports VLAN 40. The automation workflow should determine whether the device was changed outside the approved process or whether the source of truth is outdated before performing remediation. Detecting drift is a major advantage of declarative automation and Infrastructure as Code, but automatic correction should still follow appropriate validation and change-control policy.<\/span><\/p>\n

                    Q110. A telemetry collector receives interface utilization every 100 milliseconds from thousands of ports, but operators only need one-minute trend data. Which design can reduce storage and processing requirements?<\/b><\/p>\n

                      \n
                    1. <\/b> Increase sampling frequency further<\/span>
                      \n<\/span>2.<\/b> Store every raw sample forever<\/span>
                      \n<\/span>3.<\/b> Disable telemetry completely<\/span>
                      \n<\/span>4.<\/b> Aggregate or downsample the data according to operational requirements<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 4. Aggregate or downsample the data according to operational requirements<\/b><\/p>\n

                      Explanation:<\/b> High-frequency telemetry can generate very large datasets. If operators only need one-minute trend information, the architecture can aggregate raw samples into summary statistics such as averages, maximums, percentiles, or rates and retain detailed data only for a shorter period. This reduces long-term storage and query costs while preserving useful operational insight. The appropriate strategy depends on troubleshooting needs because overly aggressive aggregation can remove detail required for transient-event analysis. Telemetry design should balance freshness, fidelity, storage, transport capacity, and business value.<\/span><\/p>\n

                      Q111. A pyATS parser returns structured interface output as Python dictionaries instead of raw CLI text. What is a major automation benefit?<\/b><\/p>\n

                        \n
                      1. <\/b> Structured fields are easier to validate programmatically than arbitrary command text<\/span>
                        \n<\/span>2.<\/b> It prevents every network outage<\/span>
                        \n<\/span>3.<\/b> It eliminates the need for test logic<\/span>
                        \n<\/span>4.<\/b> It automatically creates Terraform state<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 3. Structured fields are easier to validate programmatically than arbitrary command text<\/b><\/p>\n

                        Explanation:<\/b> Structured parser output allows automation to reference specific fields such as operational state, protocol state, addresses, counters, or descriptions without manually parsing text using fragile regular expressions. This makes validation code clearer and more resilient to formatting differences. The automation still needs explicit test logic to determine which values are acceptable. Structured data does not guarantee a network is healthy, but it provides a better foundation for repeatable state comparison and automated verification than unstructured CLI output.<\/span><\/p>\n

                        Q112. A Python automation job catches a connection exception and logs it with <\/b>logger.exception()<\/b>. What additional information is typically included compared with a basic error message?<\/b><\/p>\n

                          \n
                        1. <\/b> A new device configuration<\/span>
                          \n<\/span>2.<\/b> Stack-trace information for the active exception<\/span>
                          \n<\/span>3.<\/b> A Terraform execution plan<\/span>
                          \n<\/span>4.<\/b> A CA-signed certificate<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 1. Stack-trace information for the active exception<\/b><\/p>\n

                          Explanation:<\/b> Python’s <\/span>logger.exception()<\/span> is normally used while handling an exception and records the supplied message together with exception traceback information. The traceback can show the code path that led to the failure and is valuable when troubleshooting automation errors. Care should still be taken to avoid logging sensitive secrets or full authentication payloads. Logging should include enough context to identify the job, device, request, and failure while protecting confidential information. High-quality error logs reduce time spent reproducing intermittent automation problems.<\/span><\/p>\n

                          Q113. An internal automation API uses TLS but its private key file is readable by every user on the server. What should the administrator do?<\/b><\/p>\n

                            \n
                          1. <\/b> Restrict filesystem permissions so only the service identity and necessary administrators can access the private key<\/span>
                            \n<\/span>2.<\/b> Upload the private key to a public repository<\/span>
                            \n<\/span>3.<\/b> Email the key to all developers<\/span>
                            \n<\/span>4.<\/b> Disable TLS<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 4. Restrict filesystem permissions so only the service identity and necessary administrators can access the private key<\/b><\/p>\n

                            Explanation:<\/b> A TLS private key is a high-value secret because anyone who obtains it may be able to impersonate the service or undermine confidentiality depending on the protocol and circumstances. File permissions should restrict access to only the service account and authorized administrators. High-value keys can also be stored in HSMs or key-management services. The key should never be published or broadly distributed. TLS security depends not only on certificate validity but also on the protection of the corresponding private key throughout its lifecycle.<\/span><\/p>\n

                            Q114. A network automation service uses a bearer token that appears in exception logs. Which secure coding change should be made?<\/b><\/p>\n

                              \n
                            1. <\/b> Log the token more frequently<\/span>
                              \n<\/span>2.<\/b> Redact or exclude secrets from logs<\/span>
                              \n<\/span>3.<\/b> Commit the token to Git instead<\/span>
                              \n<\/span>4.<\/b> Disable API authentication<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 2. Redact or exclude secrets from logs<\/b><\/p>\n

                              Explanation:<\/b> Logs are often copied into SIEM systems, troubleshooting bundles, tickets, and collaboration platforms, so credentials appearing in log messages can spread far beyond the original application. Automation code should explicitly redact bearer tokens, passwords, API keys, and other secrets from normal and exception logging. It should still preserve useful context such as request identifiers, target systems, and non-sensitive error details. If a real token has already been exposed, the token should generally be revoked or rotated rather than merely removed from future logs.<\/span><\/p>\n

                              Q115. A generative AI assistant produces an Ansible module name that does not exist. What should the engineer do before using the output?<\/b><\/p>\n

                                \n
                              1. <\/b> Validate the module and syntax against authoritative Ansible and platform documentation<\/span>
                                \n<\/span>2.<\/b> Assume the module exists because the response is detailed<\/span>
                                \n<\/span>3.<\/b> Disable testing<\/span>
                                \n<\/span>4.<\/b> Give the AI production credentials and let it determine the result<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 1. Validate the module and syntax against authoritative Ansible and platform documentation<\/b><\/p>\n

                                Explanation:<\/b> Generative AI output can contain plausible but nonexistent commands, libraries, modules, or parameters. This is one form of hallucination. Engineers should confirm generated automation against authoritative documentation and test it in controlled environments before production use. Linting, CI validation, simulation, and code review add additional safeguards. The level of confidence in the language model should not replace technical validation. Cisco’s current AUTOCOR AI domain explicitly requires understanding AI-assisted automation benefits and risks, including code-validation requirements.<\/span><\/p>\n

                                Q116. An engineer wants an AI system to generate a Python function that returns interface utilization as JSON. Which prompt element most directly improves output consistency for downstream automation?<\/b><\/p>\n

                                  \n
                                1. <\/b> Ask for “something useful” with no details<\/span>
                                  \n<\/span>2.<\/b> Omit the requested output format<\/span>
                                  \n<\/span>3.<\/b> Specify the required JSON schema or exact output structure<\/span>
                                  \n<\/span>4.<\/b> Ask for several unrelated tasks simultaneously<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. Specify the required JSON schema or exact output structure<\/b><\/p>\n

                                  Explanation:<\/b> Automation benefits from predictable machine-readable output. A prompt that clearly specifies expected fields, types, formatting, constraints, and examples gives the model a better chance of producing output that downstream systems can validate and consume. The result must still be parsed and verified because generative AI is probabilistic. Vague prompts increase ambiguity and can produce inconsistent responses. Structured output requirements are especially useful when AI-generated content becomes input to deterministic network automation workflows.<\/span><\/p>\n

                                  Q117. An MCP server exposes a function that retrieves router inventory. What is the most important reason to validate function arguments before querying the backend?<\/b><\/p>\n

                                    \n
                                  1. <\/b> To reduce the chance of invalid or malicious AI-generated input reaching network systems<\/span>
                                    \n<\/span>2.<\/b> To eliminate authentication requirements<\/span>
                                    \n<\/span>3.<\/b> To give the model unrestricted database access<\/span>
                                    \n<\/span>4.<\/b> To remove audit logging<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 2. To reduce the chance of invalid or malicious AI-generated input reaching network systems<\/b><\/p>\n

                                    Explanation:<\/b> MCP function parameters may originate from user prompts or model-generated tool calls and should therefore be treated as untrusted input. Validation can confirm expected device names, identifiers, query limits, formats, and permitted values before the request reaches the network or source of truth. Authorization should also confirm that the requesting identity is allowed to access the requested resource. Input validation is an important boundary between probabilistic AI reasoning and deterministic infrastructure operations, particularly when AI agents are allowed to use real network tools.<\/span><\/p>\n

                                    Q118. A conversational network agent needs to explain why an interface is down. Which data combination gives the strongest operational context?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Only the interface name<\/span>
                                      \n<\/span>2.<\/b> Interface state, recent logs, configuration, neighboring state, and relevant telemetry<\/span>
                                      \n<\/span>3.<\/b> The user’s favorite color<\/span>
                                      \n<\/span>4.<\/b> A year-old cached answer<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 3. Interface state, recent logs, configuration, neighboring state, and relevant telemetry<\/b><\/p>\n

                                      Explanation:<\/b> Troubleshooting usually requires context from multiple sources. Interface status reveals the current condition, configuration shows intended settings, logs can identify transitions or errors, neighboring-device state can indicate link dependencies, and telemetry can show recent trends. Feeding this structured evidence into an AI assistant can produce a more grounded explanation than asking the model to infer the cause from a device name alone. The data should be current, authorized, and validated. AI reasoning is most useful when connected to trustworthy operational evidence rather than relying solely on pretrained knowledge.<\/span><\/p>\n

                                      Q119. An AI agent recommends changing an ACL because it believes an application server is unused. The asset database shows that the server supports a critical monthly batch process. What should the automation architecture do?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Compare the recommendation with authoritative asset and dependency data before permitting the change<\/span>
                                        \n<\/span>2.<\/b> Delete the asset database because it disagrees with the model<\/span>
                                        \n<\/span>3.<\/b> Apply the change immediately<\/span>
                                        \n<\/span>4.<\/b> Disable rollback<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 4. Compare the recommendation with authoritative asset and dependency data before permitting the change<\/b><\/p>\n

                                        Explanation:<\/b> AI recommendations must not override authoritative operational and business data automatically. If the asset database identifies a critical dependency that the model did not account for, the proposed ACL modification could create an outage. The automation architecture should use deterministic checks against sources of truth, dependency information, policy, and change requirements before a destructive or connectivity-affecting action is permitted. Human approval may also be appropriate. This illustrates why AI agents should be integrated into existing governance rather than becoming the sole decision-maker.<\/span><\/p>\n

                                        Q120. A network team wants an AI assistant to perform a configuration change only after the user explicitly confirms the exact generated command set. Which design pattern is being used?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Unattended autonomous execution<\/span>
                                          \n<\/span>2.<\/b> Human-in-the-loop approval<\/span>
                                          \n<\/span>3.<\/b> Anonymous configuration management<\/span>
                                          \n<\/span>4.<\/b> Disabled authorization<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 1. Human-in-the-loop approval<\/b><\/p>\n

                                          Explanation:<\/b> Human-in-the-loop design places an explicit human decision point between AI-generated recommendations and high-impact actions. The AI can interpret intent, generate commands, explain expected effects, and prepare an automation plan, but an authorized user must confirm the exact change before the tool executes it. This reduces the risk of hallucination, prompt injection, misunderstanding, or missing business context causing an outage. Approval does not replace technical authorization, validation, logging, or rollback; it complements them as an additional safeguard for impactful infrastructure changes.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Cisco CCNP Automation 350-901 Exam Dumps and Practice Test Dumps. Q101. A Python network automation application receives an API response containing device records. Some records do not contain the optional location key. Which approach most safely retrieves this value without raising a KeyError when it is missing? Access device[“location”] without checking 2. Use […]<\/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\/18173"}],"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=18173"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18173\/revisions"}],"predecessor-version":[{"id":18174,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18173\/revisions\/18174"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18173"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18173"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18173"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}