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

To scale out a Self-Service (formerly Calm) deployment from a single Self-Service VM (SSVM) to a multi-node cluster, the administrator must follow a migration-style procedure rather than an in-place expansion. According to the Self-Service Administration and Operations Guide section onSetting up Scale-Out Self-Service VM:

Backup:The process involves destructive cluster commands, so the administrator must first take a backup of the existing Self-Service data.

Deploy New VMs:The administrator must deploythree new Self-Service VMsusing the provided OVA/template. This ensures a clean, uniform environment for the new cluster. (Adding nodes to an existing, potentially drifted single node is not the standard procedure).

Restore and Cluster:The administrator must then run the specific cluster creation commands (such as cluster create with the IPs of the three new nodes) andrestorethe Self-Service data and configuration from the backup to the new cluster to retain all projects, blueprints, and users.

While the exact order of "Restore" and "Cluster Create" involves technical nuance (creating the service capabilities then populating the data), the key differentiator is that the administrator must deploythree new SSVMs(Migrate) rather than just adding two to the existing one, and must explicit perform arestoreoperation to migrate the data.

The requirement to restrict VMs to specific physical hosts for licensing purposes is addressed usingVM-Host Affinity Policiesin Nutanix AHV, which relies onCategories. The complete configuration workflow is:

Categorization (Step 1):The administrator must create specific categories to tag the entities. One category (e.g., License:Oracle) is assigned to the specificHosts(the licensed ones). Another category (e.g., App:Database) is created for theVMs.

Affinity Policy (Step 2):An Affinity Policy is created in Prism Central that strictly enforces that any VM with the App:Database category must run on hosts with the License:Oracle category.

Blueprint Assignment (Step 3):In the Self-Service Blueprint, the administrator configures the VM service to automatically apply the App:Database category upon creation.

When the blueprint is deployed, the VM is created with the category, and the AHV scheduler immediately respects the Affinity Policy, ensuring the VM only starts on the licensed hosts.

Options A and C are incomplete (Categories alone do not enforce placement), and Option B (Playbook migration) is a reactive "fix" rather than a proactive placement constraint, which risks non-compliance at startup.

To use (leverage) a Dynamic Credential (provided by an external IPAM or Secrets solution like CyberArk or Vault) within a project, the administrator must configure theProject Environment.

Workflow:

Navigate to theProjectsettings and select theEnvironmenttab.

In theCredentialssection of the Environment configuration, clickAdd Credential.

Select theCredential Provider(Dynamic) rather than a Static credential.

Result:This action effectively "adds" the dynamic credential configuration to that specific environment, making it available for blueprints launched within that context.

Option A ("Allow credential provider") usually refers to theInfrastructuretab where accounts are whitelisted, but the specific configuration of the credential itself happens via the "Add" action in the Environment.

AProjectin Nutanix Self-Service (formerly Calm) acts as a logical container that defines the scope of operations for a group of users.

Primary Capability:The core purpose of a Project, once Self-Service is enabled, is to allow the users assigned to that project (Consumers, Developers, Operators) todeploy Blueprints(launch applications) andmanage the lifecyclesof the resulting workloads (VMs/Applications).

Scope:The Project restricts these users to specific Infrastructure (Clusters/VPCs), Environments, and Quotas defined by the administrator.

Exclusions:

Changing cluster-wide networking (A) and modifying global user roles (D) arePrism Admintasks, not capabilities granted to a Self-Service Project.

Managing global image repositories (B) is a Prism Central infrastructure task; Projectsconsumeimages but do not manage the global repository itself.

When troubleshooting or optimizing blueprints where complex operations (like Provisioning combined with detailed Network Configuration) frequently fail, the recommended best practice is to split the steps into smaller tasks.

In Nutanix Self-Service (Calm), theAudittab provides a sequential log of every task executed during an application's lifecycle. If provisioning and network configuration are bundled into a "single step" (e.g., a large script or a single package install), a failure makes it difficult to determine if the issue was with the VM creation, the OS boot, or the specific network parameter application.

By splitting the logic into distinct tasks (e.g., Task 1: Provision VM, Task 2: Configure Network), the administrator can:

Isolate the failure:The Audit log will clearly show "Provision VM: Success" and "Configure Network: Failed".

Validate inputs:It ensures the VM is fully available before attempting configuration.

Improve Auditing:Granular logs allow for faster root cause analysis of the "misconfigured parameters."

Retrying (Option B) or adding delays (Option D) are reactive measures that do not address the root cause of configuration errors, and disabling logging (Option C) hinders troubleshooting.

Nutanix Self-Service (formerly Calm) uses Services, app profiles, packages, substrates, and actions as the building blocks for a blueprint to define applications.

AServiceis the core logical entity within a blueprint. An application is made up of multiple components (or services) working together, such as a Database Service and a Web Server Service. Each service defines the specific infrastructure (VM), software packages, and operations required for that component of the application.

To provide users with access to Nutanix Self-Service (formerly Calm), an administrator must configure Role-Based Access Control (RBAC) within the context of a Project.

Access to Self-Service is not global; it is defined at the Project level.1An administrator must:

Add the user (or their Active Directory group) to a Project.

Assign a Roleto that user within the project.

Project Admin:Full control over the project.2

Developer:Can create blueprints and applications.

Consumer:Can only launch blueprints available in the Marketplace.3

Operator:Can perform day-2 operations on existing applications.4

Without an assigned role in a project, a user cannot access the Self-Service portal features or view any blueprints.

When creating a Runbook that involves power cycling a VM (Restart), there is a gap in connectivity while the Guest OS reboots and network services initialize.

If the Runbook moves immediately from the "VM Restart" task to the "Add new credential" task (which likely uses SSH or PowerShell to connect to the VM), the connection will fail because the VM is not yet accessible.

To correct this, the administrator must insert a Delay task between the restart and the configuration step.

The sequence should be:

VM Restart:Initiates the reboot.

Delay:Pauses the runbook execution for a set duration (e.g., 60-120 seconds) to allow the OS to boot.

Add new credential:Executes the script once the VM is back online.

When configuringHTTP Endpointswithin Nutanix Self-Service (to be used by tasks for making API calls), the system provides security controls to ensure trust.

Verify TLS Certificate:This specific checkbox setting in the Endpoint configuration determines whether the Self-Service engine validates the SSL/TLS certificate of the target server.

Security:Checking this box ensures that the connection is secure and that the target identity is verified (preventing Man-in-the-Middle attacks). Unchecking it allows connections to servers with self-signed or invalid certificates (often used in dev/test), but forsecure access, verifying the certificate is the required configuration.

Options A (SSH) and C (Static IP) are unrelated to the security of an outbound HTTP API call. Option B (Proxy) relates to routing, not the security handshake itself.

To utilize aVM-Host Affinity Policy(which pins VMs to specific Hosts) in the context of a Self-Service Blueprint, the administrator must leverageCategories.

The Mechanism:

Infrastructure Level:The administrator creates a Category (e.g., License:Oracle) and assigns it to the specific Hosts in Prism Central. They then create an Affinity Policy that enforces "VMs with Category App:Oracle must run on Hosts with Category License:Oracle."

Blueprint Level (The Answer):In the Blueprint editor, the administrator cannot "select hosts" directly. Instead, theyassign the specific Prism Central Category(e.g., App:Oracle) to the Service (VM) definition.

Execution:When the blueprint is deployed, the VM is provisioned with that Category tag. The AHV scheduler immediately recognizes the tag and enforces the pre-existing Affinity Policy, ensuring the VM lands on the correct hosts.

Option A describes a non-existent workflow (Policies are typically global or environment-mapped, not "associated to a policy within a project" in this context). Options C and D refer to "Tags," but Nutanix uses the term "Categories" for policy enforcement.

To automate the provisioning of a VM and the subsequent application installation within a Nutanix Self-Service (Calm) Blueprint, the administrator must configure a Service.

The definition of a Service in a blueprint involves three distinct components to achieve this requirement:

VM Resource:Configuring the underlying infrastructure specifications (vCPUs, Memory, Disks).

Guest Customization:Configuring Cloud-init (Linux) or Sysprep (Windows) to handle the initial OS bootstrap (hostname, user creation).

Tasks (Package Install):Adding a script task (e.g., Shell or PowerShell) under the "Service Installation" action or a dedicated Package install step. This task executesafterthe VM is provisioned and running to install the web server application.

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.

In Self-Service, anOperatorrole can:

Create blueprints

Modify blueprints

Add tasks (shell, PowerShell, script, package installs, etc.)

Use project-provided resources (images, networks, credentials)

To deploy a Linux VM with NGINX:

Asingle-VM blueprintis sufficient.

Developer must selectLinux substrate.

Installation of NGINX occurs througha shell taskin the blueprint’s package or service.

No additional permissions are required for an Operator to perform these actions.

Therefore, the correct answer isC.

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.

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

To automate a notification based on a specific change in the environment (such as a VM powering off), the administrator should leverageIntelligent Operations (X-Play)by creating an event-driven Playbook.

Event Trigger:The "VM Power Off" or "Power State Change" is a system-generatedEvent. X-Play allows administrators to select this specific event as aTrigger. This ensures the automation runs in real-time immediately when the state change occurs, rather than waiting for a schedule (as in Option A).

Action (Slack):X-Play includes a nativeSlackaction (or "Send to Slack"). The administrator configures this action with the Slack Webhook URL and the desired message content.

Why not others?

Option Ais reactive and delayed (polling every 6 hours).

Option Bonly runs once during the initial deployment of the blueprint, not continuously during the VM's lifecycle.

Option Csuggests a Webhook trigger, which requires anexternalsystem to invoke the Playbook. Here, the event originatesinternallywithin Nutanix, so an Event Trigger is the correct choice.

To ensure that Prism Central sends the appropriate notifications (Alerts/Events) to ServiceNow—allowing ServiceNow's Event Management to process them viaEvent Rules—the administrator must configure an X-Play Playbook that exports these alerts.

According to the Prism Central Intelligent Operations Guide (ServiceNow Integration):

Export of alertsfrom Prism Central is achieved by creating an X-Play playbook.

The administrator should use theAlerts Matching Criteriatrigger. This trigger allows the administrator to define the scope of the export (e.g., "All Critical Alerts" or specific categories).

The Playbook then uses theSend Alert to ServiceNowaction to push these matching alerts to the ServiceNow Event API.

By configuring a Playbook with theAlerts Matching Criteriatrigger, the administrator ensures a continuous, policy-based flow of event data into ServiceNow, satisfying the requirement for Event Rules to have data to process. Option A describes the action but lacks the governing trigger mechanism (matching criteria) that defines "appropriate" events for the integration.

In Nutanix Intelligent Operations (X-Play), a Playbook action can have a status of"Skipped"in the execution history. This status is specific and distinct from "Failed."

Conditional Execution:Administrators can configureConditionson individual Playbook actions (e.g., "Only run this step if the Alert Severity == Critical" or "Only if entity name contains 'Prod'").

The Cause:If the Playbook triggers successfully but the specific criteria for the notification step are not met during execution, X-Playskipsthat specific action while effectively completing the Playbook run.

If the service were down (Option B) or the configuration invalid (Option A), the step would typically report a"Failed"status, not "Skipped."

The visibility of clusters within a Self-Service Project is strictly controlled by theInfrastructure(or Accounts) configuration within the Project settings.

Infrastructure Whitelisting:When configuring a Project, the administrator must select which Accounts and Clusters are available for use. This is often referred to as defining theProject Scopeor whitelisting infrastructure.

The Cause:If users can see and create Environments targeting "Production Clusters," it is because the administrator explicitly selected (whitelisted) those Production Clusters in the Project's Infrastructure tab.

Environments vs. Infrastructure:Environments are definitions createdusingthe allowed infrastructure. Option D is less accurate because you whitelist theInfrastructure(resources), and then Environments are created on top of them. The root cause of the resource availability is the infrastructure whitelist in the Project Scope.

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

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 automate actions based on a signal from a third-party monitoring tool, the administrator should use the Webhook Trigger in Nutanix Intelligent Operations (X-Play).

Webhook Trigger:The administrator creates a playbook that starts with a Webhook Trigger. This generates a unique URL.

Integration:The third-party tool is configured to send an HTTP POST request (the notification) to this unique URL when the "low capacity" threshold is reached.

Automation:Receiving this signal automatically triggers the playbook to execute the expansion tasks (e.g., calling APIs to provision more VDI nodes or expand storage), removing the manual step.

While "Alert" (Option D) is used for native Nutanix alerts, the "Webhook" is the designated mechanism for receiving external events.

Comprehensive and Detailed Explanation

Nutanix Playbooks can start based on anAlert Trigger, which is defined as:

A specificPrism Central alertthat, when generated, automatically starts the Playbook.

Alert Triggers map directly to an alert definition that Calm will monitor.

Thus, the Alert Trigger doesnotgenerate alerts or notify admins by itself—itwaits for a selected alertand launches the Playbook when that alert fires.

Correct answer:D

To create or configure aCustom Providerin Nutanix Self-Service (Calm), the administrator typically defines the provider's schema (endpoints, variables, and actions) using theSelf-Service DSL(Domain Specific Language) or by constructing a definition file.

YAML Definition:The standard workflow for creating complex custom providers involves defining the provider logic in Python (via the DSL) and compiling it into aYAMLfile, or writing the YAML definition directly.

Import/Update:This YAML file is then uploaded to the Self-Service interface to create or update the Provider definition. This allows the administrator to extend Self-Service capabilities to any infrastructure or service that has an API, beyond the native supported providers.

Note:While the question option phrasing ("Update the blueprint...") may be imprecise, the action of uploading aYAML fileis the specific mechanism associated with defining Custom Providers and DSL-based constructs in Nutanix Self-Service.

Nutanix Disaster Recovery usesProtection Policiesto automate replication. These policies are applied to VMs dynamically based onCategories. To protecteveryVM from both blueprints described, the administrator must select a category that iscommon to bothsets of VMs.

Blueprint 1 Categories:OSType: Windows, AppType:IIS

Blueprint 2 Categories:OSType: Windows, Environment:Dev

Commonality:The category OSType: Windows is assigned in both blueprints.

Configuration:By creating a Protection Policy that targets the category OSType: Windows, any VM deployed fromeitherblueprint will automatically inherit this tag. Consequently, the Disaster Recovery engine will immediately detect the new VM and begin replicating it according to the policy (Asynchronous, 1 hour) without manual intervention.

Options B and D would only protect a subset of the VMs (only IIS servers or only Dev workstations, respectively).

TheLibraryin Nutanix Self-Service (formerly Calm) serves as a central repository for reusable automation assets that can be shared across multiple Blueprints and Projects. According to the Self-Service Administration Guide, the Library specifically contains:

Tasks (Scripts):The "Task Library" allows administrators to save Shell, PowerShell, Python (eScript), or HTTP tasks. These published tasks can then be imported into any blueprint, ensuring code reusability and standardization.

Variable Types (Variables):The Library also hostsVariable Types(often simply referred to as user-defined variables in the context of the library). Administrators can create and save complex variable definitions (such as lists or static values) in the Library to be reused in different blueprints without redefining them every time.

Endpoints(Option C) are configured in the global Settings or Project settings, not within the Library tab.Apps and Blueprints(Options A and D) have their own dedicated "Apps" and "Blueprints" tabs in the navigation bar.