NCP-MCA Nutanix Certified Professional - Multicloud Automation (NCP-MCA 6.10) Exam Free Practice Exam Questions (2025 Updated)

The "Environment" construct in Nutanix Self-Service is designed specifically to abstract infrastructure details from the end user while ensuring correct placement.

Within a single Project, an administrator can define multipleEnvironments(e.g., "Development" and "Production").

TheDevelopment Environmentis configured to map to theDevelopment Clusterand its associated networks.

TheProduction Environmentis configured to map to theProduction Clusterand its associated networks.

When a blueprint is launched, the user (or the application profile) simply selects the target Environment. The Self-Service engine then automatically directs the provisioning to the specific cluster defined in that Environment's settings, ensuring correct placement without requiring the user to know cluster details or manual intervention.

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.

Comprehensive and Detailed Explanation

Nutanix Calm documentation states:

TheBlueprint Editoris the graphical interface used to design, visualize, and modify a blueprint’s components, such as services, packages, substrates, dependencies, and tasks.

The editor provides avisual topologyof the multi-tier application.

Thus, the correct answer isC. Blueprint Editor.

To enforce different configurations for different types of workloads within the same Project, Nutanix Self-Service usesEnvironments.

Environments:These are logical configurations within a Project that map to specific infrastructure settings. An administrator can define multiple environments (e.g., "Development" and "Production") within the "Engineering" project.

Category Assignment:Within each Environment configuration, the administrator can define specificVM Categoriesthat will be automatically applied to any VM provisioned into that environment.

Mapping:

Production Environment:Assign the category Protection: async_1hr_repl (Matches requirement: Asynchronous remote replication every 1 hour).

Development Environment:Assign the category Protection: snap_24_hr (Matches requirement: Daily snapshots).

Execution:When a user launches a blueprint, they select the target Environment (Dev or Prod). The system automatically tags the VMs with the categories defined in that environment, which in turn engages the Protection Policies associated with those tags.

Option B uses the wrong category values (sync_remote_repl instead of async). Options C and D suggest using Playbooks, but the native and most efficient method for applying deployment-time governance in Self-Service is via theProject Environmentsettings.

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.

To automate a remediation action (like restarting a VM) based on a specific performance threshold (like CPU usage > 90%), the administrator must useIntelligent Operations (X-Play)with an event-driven trigger.

Alert-Based Trigger:The administrator first ensures there is an Alert Policy in Prism Central for "VM High CPU" configured with a threshold of 90%.

Playbook Configuration:The administrator then creates a Playbook and selects theAlerttrigger (orAlerts Matching Criteriatrigger). They link this trigger to the specific CPU alert policy.

Action:The administrator adds theVM Reboot(or Power Cycle) action to the Playbook.

Result:As soon as the system detects the CPU exceeding 90%, the Alert fires, which immediately triggers the Playbook to reboot the VM without human intervention.

Options A (Scheduled) and C (Manual) do not meet the requirement of "whenever it exceeds," which implies real-time reaction. Option B is incorrect because Project Quotas manage resource allocation limits, not runtime performance monitoring or remediation.

The placement of applications in Nutanix Self-Service is dictated by the intersection of theProjectconfiguration and theBlueprintdefinition.

Project Construct:The Project defines which infrastructure accounts (Providers) are available for use (e.g., AHV, AWS, Azure). If the Project is configured to allow access tobothAWS and another provider (like on-prem AHV or Azure), the potential exists for deployment to those targets.

Blueprints:The Blueprint (or the specific Environment selected at launch) dictates where the workload actually goes. If the administrator intended "Only AWS," but the Project allows multiple providers and the Blueprints (or the users launching them) are configured to use a non-AWS environment, the application will be deployed there.

Therefore, the cause is that theProject construct(allowing multiple clouds) and theBlueprints(utilizing those available clouds) are configured to allow this distribution. To restrict it, the administrator should remove the unintended providers from the Project's "Infrastructure" or "Environment" settings.

According to the Self-Service Administration Guide regardingError Handling in Runbook and Blueprint Tasks, there is a specific documented limitation regarding VM Power actions.

General Behavior:The error handling mechanism is designed to allow workflows to continue or alert when tasks (including VM Power On/Off) fail for reasons such as the Prism Central being unreachable or the VM being deleted.

The Exception (Option D):The documentation explicitly states:"Error handling, however, does not take into account the power on, power off, or restart task failures because of authentication errors."

If the "VM Power On" task fails specifically due to an authentication issue (e.g., token expiry or connectivity preventing authentication with the host), the standard error handling flow may not trigger as expected, matching the scenario described.

Option A is incorrect because Self-Servicecanhandle infrastructure task failures (like Power On), with specific exceptions like the one noted in D.

According to the Nutanix Prism Central Admin Guide, a category is a grouping of entities into key-value pairs. Categories are used to group entities (such as VMs, hosts, or subnets) based on specific criteria (e.g., Department: Marketing or Environment: Production).

Once entities are assigned to a category, administrators can link policies (such as security, protection, or automation playbooks) to the category rather than to individual entities. This allows for scalable and dynamic management, as any new entity tagged with that category will automatically inherit the associated policies.

To ensure a Playbook executes at a specific resource threshold (95% Memory), the administrator must link the Playbook to anAlert Policydefined with that specific threshold.

Relationship between Alerts and Playbooks:In Nutanix Intelligent Operations (X-Play), Playbooks are typically event-driven. The most common trigger is theAlerttrigger. The Playbook itself does not define the threshold (e.g., "95%"); rather, it waits for an Alert to fire.

Configuration:The administrator must configure a specific Alert Policy (e.g., "Critical Memory Usage") in Prism Central to trigger when Memory Usage exceeds 95%.

The Solution:By selecting"Change Trigger to be based off Critical Memory Usage Alert"(Option B), the administrator ensures the Playbook reacts specifically to the alert that corresponds to the 95% threshold. If the system was previously alerting at 100%, it implies the Playbook was linked to a different or default policy. Switching the trigger to the correct "Critical" policy (configured for 95%) solves the issue.

Autopilot (Option A):Autopilot is used totuneinfrastructure limits (like adding CPU/Memory) based on KPI targetsaftera playbook runs; it does not trigger the initial remediation playbook itself.

Nutanix Self-Service governance supportsApproval Policiesthat enforce control over resource consumption and automation actions. Nutanix documentation states that approval policies:

Apply toblueprint deployments,runbook executions,day-2 actions, orresource scale-up requests.

Requireexplicit authorizationfrom a designated approver before the action proceeds.

Provide governance to ensure resource usage aligns with organizational policies.

Thus, Approval Policies existspecifically to require authorization before a user-triggered task is executed, makingOption C correct.

Options A, B, and D are unrelated to approval workflows.

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).

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.

Nutanix Calm and Self-Service automation workflows require validation within the same execution context used by end users. Nutanix documentation specifies the following principles:

1. Playbook validation requires execution in the same user and project context

Playbooks that target resources using aCalmProjectcategory must be tested in the exact context in which they will operate.

The"Execute on behalf of"option allows the administrator to run the Playbookas if a project user initiated it, ensuring validation of:

Project-based scoping

User permissions

Category-based triggers

Playbook logic and automation flow

This matches the documented requirement that Playbooks must be validated under theintended user execution model, makingOption B correct.

2. Deployment must occur inside the Project to activate category-driven Playbooks

Blueprint deployments only trigger Playbooks when:

The deployment occursinside the Project, and

The VM receives metadata (such as CalmProject category) associated with that Project.

Nutanix Calm documentation highlights that Playbooks relying onProject categoriesonly activate when VMs are provisionedfrom that specific Project.

Deploying from the Marketplace does not guarantee that the correct project context or categories will be applied.

Thus, verifying Playbook execution requires deploying the blueprint assigned to the Project, makingOption D correct.

Why the other options are incorrect

❌Option A – “Execute”

This executes Playbooks only in the admin context, not the Project context. It doesnotvalidate permissions, user behavior, or category-based triggers required for Self-Service operation.

❌Option C – Marketplace deployment

Marketplace deployments do not necessarily apply Project-specific categories or metadata, so they cannot reliably test integration with Playbooks bound to a Project.

In Nutanix Prism Central Disaster Recovery, when a Prism Central instance fails over to a recovered site, several automation components—including Playbooks—must be revalidated. Nutanix documentation clearly states:

Playbooks store encrypted credentials locally in the Prism Central database.

When Prism Central is recovered on a DR site, the credential encryption keys donottransfer.

As a result,any credentials previously stored in Playbooks become invalidand must be manually re-entered.

This requirement ensures that the scripts, tasks, remediation sequences, and integrations invoked by the Playbook can authenticate properly after recovery.

Therefore:

Playbookscannot automatically use previously stored credentialsafter a DR failover.

Administrators mustre-enter all credentialsin enabled Playbooks so the automation continues functioning.

Hence, OptionCis correct.

Options A and D are incorrect because Playbooks donotautomatically retain functional credentials after DR recovery.

Option B is incorrect because the presence or absence of a credential provider does not change the need to re-enter credentials.

When creating a variable in a Nutanix Self-Service Blueprint or Runbook, the administrator must select aData Type. The standard supported data types areString,Integer,Date,Time, andDateTime.

String (Single-line):This is the fundamental text data type (typically just labeled "String" in the UI). It is used for standard alphanumeric inputs.

Input Options:While a String variable can be configured with an attribute to accept "Multi-line" input (useful for SSH keys or scripts), the base data type itself isString(which defaults to single-line).

Invalid Options:"Multi-line integer" is not a valid type. "Year Month Day" is a format description, not the name of theDatedata type. Therefore,Single-line string(representing the standard String type) is the correct available option among the choices.

In a Nutanix Self-Service Blueprint, actions that affect theentire application lifecycleor its structural configuration are defined asProfile Actions.

Application Profile Actions:These are operations that run at the level of the Application Profile.

Custom Profile Actions:To enable capabilities likeScale Out(adding more replicas),Scale In(removing replicas), orUpgrade(updating the application software across the deployment), the developer createsCustom Profile Actions.

These actions are distinct from "Service Actions" (which apply to a single VM/Service, like "Restart Apache").

Once defined, these Custom Profile Actions appear as buttons on the "Manage" tab of the deployed application, allowing the application admin to trigger the scaling or upgrade workflows defined by the developer.

In Nutanix Self-Service (Calm), Macros are used to reference variables and properties dynamically using the syntax @@{Entity.Attribute}@@.

Servicesare a primary supported entity for macros. You can reference properties of other services within the same application blueprint. For example, a web server service might need the IP address of a database service. This can be achieved using a macro like @@{Database_Service.address}@@. This allows for dynamic orchestration where values are populated at runtime based on the actual deployment details of the Service entity.

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.