NCP-MCA Nutanix Certified Professional - Multicloud Automation (NCP-MCA 6.10) Exam Question and Answers

According to the Self-Service Blueprint and Task configuration settings, the specific parameter that enables and controls the number of retries for a failed task is theRetry Count.

Retry Count:This integer value determines how many times the system will attempt to re-execute the task if it returns a failure status. If this is set to 0 (default in some views), no retries occur. Setting it to a value of 1 or higher enables the retry logic.

Retry Interval (Option A):This setting defines thewait time(in seconds) between the attempts, but without a positiveRetry Count, the interval is irrelevant.

Timeout (Option B):This defines how long the system waits for a single attempt to complete before marking it as failed.

The most efficient and scalable method for managing user access in Nutanix Self-Service Projects is leveraging existing Identity Providers (such as Active Directory).

Add an Active Directory group to a role:When adding users to a Project, the administrator can select an entireDirectory Group(AD Group) and assign a specific Project Role (e.g., Developer, Consumer, Operator) to that group.

Result:All users currently in that AD group, and any users added to that AD group in the future, automatically inherit the assigned Project Role. This eliminates the need to manually manage individual user accounts (Option D) or maintain separate local groups (Option A) within Prism Central.

In Nutanix Self-Service (formerly Calm), the Infrastructure tab within a Project is the designated location for configuring and assigning provider accounts.

When an administrator navigates toProjects>[Project Name]>Infrastructure, they can click"Add Infrastructure". This workflow presents the option to select:

Account:Cloud provider accounts (e.g., Nutanix AHV, AWS, Azure, VMware) that the project is allowed to use.

Credential Provider:External credential stores (if configured) or specific credential provider accounts that the project users can access for authenticating workloads.

The other tabs serve different purposes: "Users & Groups" handles RBAC, "Policies" handles Quotas and Approvals, and "Tunnels" handles VPC network connectivity.

To satisfy the requirement of acting on alerts based on specific properties (such as Severity levels: Info or Warning) rather than just the alert policy itself, the administrator must use the Alerts Matching Criteria trigger.

In Nutanix Intelligent Operations (X-Play), there are two primary alert triggers:

Alert Trigger:This triggers a playbook when aspecificAlert Policy is generated (e.g., "Host Down"). It applies to all instances of that policy regardless of severity, unless the policy itself is severity-specific.

Alerts Matching Criteria:This trigger allows the administrator to define a playbook that fires onany alert matching specified criteria. Configurable criteria includeSeverity(Critical, Warning, Info),Impact Type,Target Entity, andAlert Policy.

By creating a playbook with theAlerts Matching Criteriatrigger, the administrator can specifically selectSeverity: InfoandSeverity: Warningand filter for theNGT Alert Policy. The action "Acknowledge Alert" can then be added. This ensures that only non-critical NGT alerts are auto-acknowledged, while Critical NGT alerts (which do not match the criteria) continue to notify the administrator.

To satisfy the requirement where a user mustmanually entera value (Cost Center) at request time, and have that specific value applied to the resulting VM'sCategory, the administrator must use aRuntime Variablecombined with aTask.

Runtime Variable:Configuring a variable (e.g., @@{cost_center}@@) as "Runtime" in the Blueprint ensures that the Self-Service Marketplace prompts the user to input this data when they click "Launch."

Task for Categorization:In standard Self-Service blueprints, Categories defined in the VM configuration pane are typically static or tied to the Project/Environment defaults. To apply adynamiccategory based on a specific user input string, the administrator creates aTask(typically a script using the API or a "Set Category" action if available in the version) that runs post-create. This task takes the value from the runtime variable and updates the VM entity with the corresponding CostCenter:Value category tag.

Why not others?

Option Auses a "Pre-Defined" variable, which typically implies a static value fixed by the admin, not input by the user.

Option Csuggests using the Environment to set the value. Environments are used to map deployments to infrastructure (e.g., "Production" vs "Dev" clusters) and do not support dynamic injection of arbitrary user strings into category values during the launch process.

Option Dsuggests associating the variable to the Category in theProject. Project-level categories are generally static defaults applied toallworkloads in that project (e.g., all VMs in the "HR Project" get CostCenter:HR), which contradicts the requirement for therequesterto enter the specific cost center at launch.

To troubleshoot why a post-deployment automation workflow (Playbook) is not executing, the administrator should investigate the specific execution records and the trigger configuration:

Check Playbook Execution History (C):The Playbook "Plays" or execution history (found in the Intelligent Operations or Self-Service Audit tab depending on the specific type of playbook used) provides the definitive record of whether the system attempted to run the automation. If the playbook appears in the history with a "Failed" status, the logs will indicate which specific step (e.g., HTTP task or API call) failed. If it does not appear at all, the issue lies in the trigger.

Verify Invocation (D):If the playbook is intended to run "post-deployment," it must be explicitly triggered.

ForX-Play Playbooks, this involves verifying theTriggerlogic (e.g., ensuring the "VM Created" event filter matches the specific Project Categories assigned to the new VMs).

ForSelf-Service (Calm) Runbooks, this involves verifying that the blueprint's "Post-Create" or "Profile" actions are correctly configured to call the Runbook.

Confirming these settings ensures the automation is properly "hooked" into the deployment lifecycle.

Reviewing VM creation logs in Prism Element (Option B) only confirms the VM was built (which is already known), and reassigning the project (Option A) is a destructive test that does not isolate the automation logic.

When configuring a Playbook in Intelligent Operations (X-Play), the "User Execution" settings allow the administrator to define a specific user context (impersonation) under which the playbook actions run.

However, for alocal user accountcreated in Prism Central to be available and valid for this impersonation, that usermust have logged into the Prism Central interface at least once. This login event creates the necessary user profile and mapping within the Prism Central database that X-Play requires to authenticate and execute actions on their behalf. If the user has been created but never logged in, they cannot be successfully used for playbook execution.

InIntelligent Operations (X-Play) Playbooks, the syntax for string interpolation (using parameters) differs from Self-Service (Calm).

Playbook Syntax:X-Play uses thedouble curly bracesyntax {{ ... }} to reference parameters.

Example:To reference the name of the entity that triggered the playbook, the correct parameter string is {{trigger[0].source_entity_info.name}} or {{trigger[0].alert_entity_info.name}} depending on the trigger type.

Contrast:@@{...}@@ (Option B) is the syntax used inSelf-Service (Calm)macros, not X-Play Playbooks.

To configure and enforce resource limits within a Nutanix Self-Service (formerly Calm) project, the specific governance component known as thePolicy Enginemust be active.2

According to the Self-Service Administration and Operations Guide regarding thePolicy Engine and Quotas Overview:

Enabling the Policy Engine:You enable and use the policy engine to enforce resource quota policies for infrastructure resources (compute, memory, and storage) on Nutanix and VMware accounts.3

Prerequisite status:Until the policy engine is enabled in the Admin Center Settings, Prism Central cannot perform any quota checks or validation on resource consumption.4

Availability:The options to define resource quota limits (such as vCPU, Memory, and Disk fields in the Project configuration)appear only when you enable the policy enginein your Prism Central instance.5If the policy engine is not enabled, the Quota section in the Projects pages remains unavailable.6

For users to successfully deploy Marketplace Blueprints to a specific infrastructure, the Project must have a configuredEnvironment.

The Gap:Merely adding the Account and whitelisting the Cluster in the Project settings (the "Infrastructure" tab) onlyauthorizesaccess. It does not tell the Self-Service enginehowto use that infrastructure (e.g., which Networks to attach, which Storage Containers to use, or what sizing policies to apply).

The Solution:The administrator must go to theEnvironmentstab within the Project andCreate a New Environmentmapped to the new Account and Cluster.

Marketplace Logic:Marketplace blueprints are typically "Environment Agnostic." When a user launches one, they are prompted to select a destination Environment. If no Environment exists for the new cluster, the user cannot select it as a target for deployment.

In Nutanix Cloud Manager (NCM) Intelligent Operations (formerly Prism Pro/X-Play), the primary method for troubleshooting and validating Playbook behavior is through the Plays view in Prism Central.

When a Playbook is reported as not executing as expected, the administrator must examine thePlaystab (Execution History). This view provides a detailed log of all playbook activity, including:

Status:Whether the playbook succeeded, failed, or is in progress.

Trigger Details:Information regarding what specific event or alert triggered the playbook. If the playbook is not running at all, the administrator needs to verify if the "Idle VM" trigger conditions (e.g., CPU usage threshold, duration) are actually being met by the VMs in question.

Step-by-Step Execution:If the playbook triggered but failed during execution, the history details exactly which step failed and provides error messages (e.g., permission issues or API failures).

Options such as rebooting Prism Central or increasing quotas do not address the need to diagnose why specific automation logic failed to fire or complete. Modifying the execution context is a potential fix onlyafterthe execution history reveals a permission error, but checking the history is the mandatory first step to validate the configuration.

Nutanix Prism Central includesPredefined Playbooks(System Playbooks) that cover common use cases (e.g., "Email on Alert"). These system playbooks are protected templates.

Immutability:You cannot directly edit or modify a Predefined Playbook (making Option D incorrect).

Cloning Workflow:To customize a Predefined Playbook—such as adding an additional action step like "Slack Notification" or "VM Snapshot" at the end—the administrator mustClonethe playbook.

Process:Select the Predefined Playbook -> Click "Clone" -> Save as a new User Playbook. The administrator can then fully edit triggers and actions in this new copy.

While this effectively creates a "new" playbook (Option B), the specific mechanism provided in the interface and documentation to leverage the existing definition isCloning.

When a Blueprint is designed to trigger external automation (like a Playbook via Webhook or API) or perform post-deployment actions (like applying categories via script), these actions must be explicitly defined asTaskswithin the Blueprint's lifecycle.

The Symptom:The VM provisioning (Substrate) succeeded, but the subsequent logic (Categories/Notifications) failed to happen.

The Cause:In Self-Service, simply creating a Blueprint does not automatically link it to an Intelligent Operations Playbook. The developer must add a specific task (e.g., an HTTP Request task targeting the Playbook trigger, or a specific "Execute Playbook" action) to theService Profile(specifically the Post-Create or Create phase).

If this task is missing, disabled, or misconfigured (e.g., wrong URL or payload), the VM will deploy, but the call to the Playbook will never occur, resulting in missing categories and notifications.

Option A is incorrect because deployment would not start at all without a Project. Option D is incorrect because Playbooks are not published to the Marketplace (Blueprints are).

In Nutanix Self-Service (formerly Calm),Macrosare used to reference variables within scripts, task definitions, and configurations. The documented syntax for all macros requires the variable name to be enclosed within double "at" symbols and curly braces.

Syntax:@@{variable_name}@@

Usage:This format is used for both user-defined variables (e.g., @@{db_password}@@) and built-in system macros (e.g., @@{address}@@, @@{calm_time}@@, @@{calm_project_name}@@).

Evaluation:When the Self-Service engine executes a task, it parses the string, identifies the pattern @@{...}@@, and substitutes it with the actual value of the variable from the current context before sending the script to the target machine.

TheHTTP Taskin Nutanix Self-Service (Calm) is designed to interact with external REST APIs without requiring the developer to write custom code (Python/Shell) to handle the connection logic.

No-Code Configuration:The HTTP Task provides a graphical interface where the developer inputs the Request URL, Method (GET/POST), Headers, and Body.

Output Mapping:Crucially, it allows the developer to parse the JSON response from the API and map specific values (like the IP address) directly to aOutput Variable(Service Variable) using JSONPath syntax.

Result:This variable can then be referenced in the VM configuration (e.g., in the Network Adapter settings), effectively automating the IP fetch and assignment purely through configuration, satisfying the "no script" requirement.

Self-Service Domain-Specific Language (DSL)is the specific capability within Nutanix Self-Service (formerly Calm) that enablesInfrastructure-as-Code (IaC).

Definition:The Self-Service DSL is a Python-based domain-specific language that allows administrators and developers to define Blueprints, Runbooks, and Projects as code.

Functionality:Instead of using the Graphical User Interface (GUI), users can write Python code to describe the application structure, services, and logic. This code can then be version-controlled (e.g., in Git), reviewed, and deployed via the CLI, fulfilling the principles of Infrastructure-as-Code.

Contrast:While "Application Development" and "Orchestration" are broad concepts, theDSLis the specific tool/feature that delivers the IaC mechanism.

In Nutanix Self-Service,Projectsare the foundational organizational construct. Documentation states that Projects allow administrators to:

Groupusers and user groups

Assignroles(Consumer, Developer, Project Admin, etc.)

Defineresources(clusters, networks, images) allocated to that project

Attachblueprints, application profiles, and environments

Thus,Projects manage user grouping and role-based access, which matchesOption A.

Options B, C, and D do not represent Project functionality within Self-Service.

According to theSelf-Service Administration and Operations Guide(specifically the section on System Limits and Maintenance), the retention policy for soft-deleted entities is explicitly defined:

Retention Period:"Data related to deleted apps and blueprints is cleaned up after3 months."

This mechanism is part of the internal database maintenance ("garbage collection") to manage resource usage on the Prism Central/Self-Service VM while allowing for audit trails or recovery within a reasonable window.

The scenario describes a "Zero Trust" style Security Policy (Flow Network Security) where all traffic is blocked unless explicitly allowed by a rule matching a Category.

The Rule:The policy specifically states that SSH (port 22) traffic is allowedonlyfor VMs tagged with the category AppType: Admin-VM.

The Issue:The deployed VM cannot be accessed via SSH. This indicates that the VM does not match the allow rule.

The Fix:The Blueprint used to deploy these Administrator VMs must be updated toassign the AppType: Admin-VM categoryto the VM service definition.

Once the VM is deployed with this tag, the Flow Security Policy will recognize it and permit the inbound SSH traffic. Assigning Web-Servers (Option B) would open port 443, not 22.

In the context of Nutanix Self-Service (Calm) Blueprints, anApplication Profileacts as a configuration wrapper that defines a specific variation of the application deployment.1

Combinations:It allows the blueprint developer to define multiple "sizes" or "flavors" of the same application (e.g., "Small," "Medium," "Large") within a single blueprint.

Variables:Each Application Profile maps specific values to the variables defined in the underlying Services and Packages. For example, the "Small" profile might set the vCPU variable to 2 and the Memory variable to 4GB, while the "Large" profile sets them to 8 and 32GB respectively.

User Experience:When a user launches a blueprint from the Marketplace, they select the desired Application Profile, which then determines the specific infrastructure resources (VM specs) and software packages that get deployed.2

When a Playbook fails to fire despite an Alert occurring, the most common and "likely" cause is a mismatch in theTriggerconfiguration logic.

Trigger Precision:X-Play Triggers are precise. If the administrator selected theAlerttrigger, they must select asingle specificAlert Policy (e.g., "Host High Memory"). If the high-severity alert that occurred was "VM High Memory" (a different policy), the Playbook will not trigger, even if both are "High Severity."

Alerts Matching Criteria:To coverallhigh-severity alerts, the administrator must use theAlerts Matching Criteriatrigger and filter by Severity == Critical. If they used the specific "Alert" trigger or configured the criteria incorrectly (e.g., wrong entity type), the system is "working as implemented" (ignoring non-matching events), but the logic does not match the user's intent.

Autopilot (Option C):While X-Play has an Autopilot feature for KPI optimization, it is not a mandatory requirement for standard alert-based remediation playbooks to function.

The image typically shows the distinction between the "Alert" trigger (Select one policy) and "Alerts Matching Criteria" trigger (Select filters like Severity/Entity), illustrating how a configuration error here leads to the issue described in Question 40.

ThePolicy Engineis the core component in Prism Central that enables governance and scheduling capabilities for Self-Service.

Requirement:According to the Administration Guide, thePolicy Enginemust be enabled to useQuotas,Approvals, andSchedulerfeatures.

Function:The Scheduler relies on the Policy Engine to enforce timing and execution rules for Application Actions and Runbooks. Without this engine running, the Scheduler tab and functionality are unavailable.

TheLibrary(specifically theTask Library) is the designated repository in Nutanix Self-Service for creating and managing reusable automation building blocks.

Task Library:This feature allows administrators to define discrete tasks (such as Shell scripts, PowerShell scripts, HTTP requests, or Python scripts) once and store them centrally.

Reusability:These tasks serve as fundamental "building blocks" because they can be imported into multiple Blueprints and Runbooks across different Projects.

Differentiation:

Tasks (Option C):While "Tasks" are the actual units of work, the question askswherethey are created for the purpose of establishing them as foundational, reusable blocks. They are createdin the Library.

Projects (Option B):Projects are logical containers for users, quotas, and environments, not the repository for reusable script definitions.

Thus, theLibraryis the correct location for creating shared automation assets.

In Nutanix Self-Service (Calm) Projects, the "Allow Collaboration" setting controls the visibility and management of entities shared among project members.

Allow Collaboration Enabled:This allows any group member to see the VMs, applications, scheduler jobs, and other objects created by other members of the group. With the appropriate role permissions, they can also modify these shared entities.

Allow Collaboration Disabled:Project users can manageonlythe objects that they strictly created themselves. They cannot view or edit objects created by other users, even if they are in the same project.

To modify a Scheduler Job created by another user, "Allow Collaboration" must be enabled for that Project.

In the Nutanix Self-Service (Calm) Blueprint lifecycle, tasks are executed in a specific order relative to the provisioning of the infrastructure (Substrate).

Pre-Create Task:This is the specific phase designed to run scripts or set variablesbeforethe VM provision call is sent to the provider (AHV).

Workflow:

The developer creates a pre-create task (e.g., a Python script) to generate the custom hostname string based on logic (e.g., date, user input, or sequence).

The script outputs this string to a variable (e.g., @@{vm_hostname}@@).

The VM Service configuration (Substrate) references this variable in the "VM Name" or "Hostname" field.

Execution:When the blueprint launches, the pre-create task runs first, populates the variable, and then the VM creation occurs using that calculated name.

Tasks in post-create or package-install (Options B and C) runafterthe VM has already been provisioned and named, making them too late for this requirement.

In Nutanix Self-Service (Calm), a Quota Policy limits the total infrastructure resources that can be consumed by a Project.5

When configuring a Project, the administrator sets limits for the following specific resources:

vCPUs:The total number of virtual CPUs allocated to VMs in the project.

Memory:The total amount of RAM (in GiB) allocated to VMs.

Disk:The total storage capacity (in GiB) allocated to VMs.

These quotas are enforced during the provisioning process. If a user attempts to launch a blueprint that would cause the project to exceed these defined limits (vCPU, Memory, or Disk), the deployment will fail. Quotas do not monitor IOPs, NIC counts, or the number of blueprints stored.

TheAccount(often referred to as theProvider Account) is the foundational prerequisite for any public cloud integration in Nutanix Self-Service.

Configuration Hierarchy:

Account (A):The administrator must first configure the Provider Account (e.g., AWS, Azure, GCP) in the Settings tab, providing the necessary API keys, Secret keys, or Service Principal credentials to establish the connection.

Project (B):Once the Account exists, it can be assigned to a Project.

Blueprint (D):Once the Project has access to the Account, Blueprints can be designed to target it.

Therefore, without theAccountconfigured first, the downstream components (Projects and Blueprints) cannot interface with the public cloud.