NCP-CN Sample Questions Answers

NKP Platform Applications (e.g., Rook Ceph, Prometheus, Fluent Bit) are pre-integrated tools that can be deployed to Kubernetes clusters within a workspace to provide services like storage, monitoring, and logging. The NKPA course specifies that to deploy a platform application to all clusters in a workspace from the command line, the engineer uses the nkp create appdeployment command. This command creates an application deployment resource that targets the specified workspace and clusters.

The required parameters include the application ID (to identify the platform application), the version (to specify the desired version of the application), and the NKP workspace (to define the scope of clusters). For example: nkp create appdeployment --app-id prometheus --version 2.30.0 --workspace fin-vd. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “Use the nkp create appdeployment command to deploy platform applications, specifying the application ID, version, and target workspace to apply the deployment across all clusters in that workspace.”

Incorrect Options:

B. nkp deploy platform-app: This is not a valid NKP command. The correct command is nkp create appdeployment.

C. nkp deploy app: This is not a recognized command in the NKPA documentation.

D. kubectl create appdeployment: kubectl interacts with Kubernetes resources, not NKP-specific platform applications.

NKP uses Cluster API (CAPI) to provision and manage Kubernetes clusters across supported infrastructures, including Nutanix AHV, vSphere, AWS, and GCP. CAPI components, such as controllers and providers, are deployed to manage the lifecycle of clusters on these platforms. However, when NKP attaches to a managed Kubernetes service like Azure Kubernetes Service (AKS), CAPI components are not deployed because AKS is managed by Azure, and NKP only integrates with the cluster for fleet management, not provisioning.

The NKPA course explains: “For managed Kubernetes services like AKS, NKP attaches the cluster to its management plane without deploying CAPI components, as the underlying infrastructure is managed by the cloud provider.” The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide reinforces this: “CAPI is used for NKP-managed clusters on Nutanix, vSphere, AWS, and GCP, but not for attached managed services like AKS.”

Incorrect Options:

A. vSphere: NKP deploys CAPI components (e.g., CAPV provider) to manage vSphere-based clusters.

B. GCP: NKP deploys CAPI components (e.g., CAPG provider) for GCP-based clusters.

C. Nutanix: NKP deploys CAPI components (e.g., CAPA provider for AHV) for Nutanix AHV clusters.

The Nutanix Kubernetes Platform (NKP) is designed to simplify the deployment and management of Kubernetes clusters on Nutanix infrastructure, including on-premises AHV-based clusters in dark site environments with no Internet connectivity. The requirements specified in the question—dark site, Nutanix-provided Rocky Linux VM image, and AHV-based cluster—point to a deployment scenario where the environment must be self-contained and rely on Nutanix-specific tools and resources to meet the air-gapped constraints.

According to the Nutanix Kubernetes Platform Administration (NKPA) course, deploying NKP in a dark site environment requires specific prerequisites to ensure all necessary components, such as container images, dependencies, and configuration files, are available without Internet access. The course emphasizes the use of an Air-Gapped Bundle and an existing local container registry as critical components for such deployments.

Air-Gapped Bundle (Option B):

The NKPA course explains that for dark site deployments, Nutanix provides an Air-Gapped Bundle, which is a comprehensive package containing all the software components, container images, and dependencies required to deploy and manage an NKP cluster without Internet connectivity. This bundle includes the Kubernetes binaries, NKP platform applications (e.g., Rook Ceph, monitoring tools), and other necessary artifacts.

The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide specifically states: “For air-gapped environments, the Nutanix Air-Gapped Bundle is required to provide all dependencies, including container images and installation files, to deploy NKP clusters.” This bundle is typically downloaded from the Nutanix Support Portal in an Internet-connected environment and then transferred to the dark site for deployment.

The bundle ensures that the Nutanix-provided Rocky Linux VM image, which serves as the base operating system for the Kubernetes nodes, can be provisioned with all required software components. The NKPA course further notes that the Air-Gapped Bundle is tailored for AHV-based clusters, ensuring compatibility with the Nutanix hypervisor.

Existing Local Container Registry (Option C):

In a dark site environment, a local container registry is a prerequisite to store and distribute container images required by the NKP cluster. The NKPA course highlights that NKP relies on container images for Kubernetes components, platform applications, and user workloads. In an air-gapped setup, these images cannot be pulled from public registries like Docker Hub or Quay.io.

The course instructs administrators to set up a local container registry (e.g., Harbor, Nexus, or a Nutanix-managed registry) and populate it with the container images included in the Air-Gapped Bundle. The Nutanix Cloud Bible reinforces this, stating: “In air-gapped deployments, a local container registry must be pre-configured to host all required images, which are provided as part of the Nutanix Air-Gapped Bundle.”

The local container registry ensures that the Kubernetes nodes, running on the Nutanix-provided Rocky Linux VM image, can access the necessary images during cluster bootstrapping and operation. The NKPA course provides guidance on configuring the registry and integrating it with the NKP deployment process.

Incorrect Options:

Konvoy Image Builder (Option A):

Konvoy Image Builder is a tool associated with D2iQ’s Konvoy platform, used to create custom machine images for Kubernetes deployments. While it can be used to build images for Kubernetes nodes, it is not a Nutanix-specific tool nor a prerequisite for NKP deployments. The NKPA course and NCP-CN 6.10 Study Guide do not mention Konvoy Image Builder, as NKP uses the Nutanix-provided Rocky Linux VM image, which is pre-configured for AHV-based clusters. This option is irrelevant to the Nutanix ecosystem.

Self-managed AWS cluster (Option D):

A self-managed AWS cluster is unrelated to the requirements of deploying NKP on an AHV-based cluster in a dark site. The question specifies an AHV-based cluster, which is Nutanix’s Acropolis Hypervisor running on-premises, not a cloud-based AWS environment. The NKPA course focuses on Nutanix infrastructure (AHV, Prism Central) for NKP deployments and does not include AWS as a supported platform for this scenario. This option is incorrect as it contradicts the deployment environment.

Deployment Context:

The Nutanix-provided Rocky Linux VM image is a pre-configured operating system image optimized for NKP deployments on AHV. The NKPA course notes that this image includes the necessary kernel settings, drivers, and configurations to run Kubernetes nodes efficiently on Nutanix infrastructure.

The AHV-based cluster requirement indicates that the deployment leverages Nutanix’s hypervisor, managed through Prism Central, to provision and manage the Kubernetes nodes. The Air-Gapped Bundle and local container registry ensure that all software components are available in the dark site, aligning with the NKPA course’s guidelines for air-gapped deployments.

The NKPA course details the process of deploying an NKP cluster, which begins with creating a bootstrap cluster to initialize the Cluster API (CAPI) components. The bootstrap cluster is a temporary Kubernetes cluster used to manage the provisioning of the target NKP cluster. If an error occurs and the KUBECONFIG file is missing, the engineer must recreate the bootstrap cluster and generate a new KUBECONFIG file.

The correct command, as specified in the NKPA course, is nkp create bootstrap --kubeconfig bootstrap-cluster.conf. The nkp CLI is the Nutanix-specific tool for managing NKP deployments, and the create bootstrap subcommand initializes the bootstrap cluster while generating the KUBECONFIG file with the specified name (bootstrap-cluster.conf). The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “The nkp create bootstrap command is used to create a temporary bootstrap cluster for CAPI-based NKP deployments, with the --kubeconfig flag specifying the output KUBECONFIG file.”

Incorrect Options:

A. nutanix create bootstrap --kubeconfig bootstrap-cluster.conf: There is no nutanix CLI command for NKP bootstrap creation. The correct tool is nkp.

B. kubectl create bootstrap --kubeconfig bootstrap-cluster.conf: kubectl is used for interacting with Kubernetes clusters, not for creating bootstrap clusters. The NKPA course does not support this command.

D. d2iq create bootstrap --kubeconfig bootstrap-cluster.conf: D2iQ is a separate Kubernetes platform, and its CLI is not used for NKP deployments.

For deployments in air-gapped environments where there is no external Internet connectivity, the --airgapped parameter is required. This instructs the NKP deployment to rely solely on internal resources, using pre-staged images and local container registries, ensuring that no external network dependencies cause deployment failures.

The NKPA 6.10 documentation specifies that when attaching external clusters like AKS (Azure Kubernetes Service) to an NKP management cluster using Kommander, the default kubeconfig provided by AKS is typically not directly usable because it lacks the necessary service account details and permissions for NKP to properly manage the cluster. Therefore, the recommended and required approach is to create a separate service account in AKS with the necessary permissions and generate a kubeconfig file for this service account.

Key reference:

“When importing external clusters, such as AKS, the default kubeconfig might not contain the correct permissions for NKP Kommander. A custom kubeconfig for a service account with cluster-admin privileges should be created and used to attach the cluster to NKP.”

According to the NKPA 6.10 documentation under “Air-Gapped Preparation with Konvoy Image Builder,” the konvoy-image upload command uploads essential artifacts to the target servers to prepare them to serve as cluster nodes. These artifacts include:

Container runtime (containerd)

OS bundle

Kubernetes components

It does not involve user creation or OS hardening scripts (those are separate, client-driven processes).

Key reference from documentation:

“The konvoy-image upload command uploads the required artifacts to the target server(s) to prepare them for Kubernetes deployment in air-gapped environments. This includes the container runtime, OS bundle, and Kubernetes binaries.”

The NKPA 6.10 documentation confirms that Velero is the built-in backup and recovery solution provided as part of the NKP platform. It provides cluster-level and namespace-level backup, restore, and migration capabilities.

Exact extract from the documentation:

“Velero is the integrated, out-of-the-box backup and restore solution in NKP. It supports scheduled backups, disaster recovery, and application migration workflows.”

In an air-gapped NKP installation, the engineer starts with the NKP Air-Gapped Bundle, a tarball containing all necessary components (e.g., container images, binaries, configuration files) for deployment without Internet access. The NKPA course specifies that the first step is to extract this bundle on the bastion host to make its contents available for the installation process. The correct command is tar -xzvf nkp-air-gapped-bundle_v2.12.0_linux_amd64.tar.gz, which extracts the bundle into a directory, revealing the container images, CLI tools, and other resources needed for the deployment.

The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “To begin an air-gapped NKP installation, first extract the NKP Air-Gapped Bundle using tar -xzvf .tar.gz on the bastion host to access the installation artifacts.” After extraction, the engineer can proceed with loading container images (e.g., using docker load) and running NKP CLI commands to deploy the cluster, ensuring all dependencies are available locally.

Incorrect Options:

A. nkp push bundle --bundle: This is not a valid command. The bundle must be extracted before its contents can be used.

B. docker load -i konvoy-bootstrap-image-v2.12.0.tar: Loading the bootstrap image is a subsequent step after extracting the bundle, which contains this image tarball.

D. nkp create cluster nutanix: This command creates a cluster but cannot be run until the bundle is extracted and its images are loaded.

NKP uses the Cluster Autoscaler to scale worker node replicas up or down. This ensures that resource availability dynamically matches workload demand by adjusting the number of worker nodes. Pod-level autoscaling (Horizontal-Pod autoscaler) is also supported for pod scaling but is not responsible for node pool expansion or compaction.

Key Reference:

“NKP uses the Cluster Autoscaler to dynamically adjust worker node pool replicas in response to cluster resource demands.”

The NKPA 6.10 documentation clarifies that when creating a workload cluster using the nkp create cluster command, specifying the target workspace (namespace) is critical for properly associating the workload cluster with that workspace in the NKP UI. If the --namespace parameter is omitted, the cluster is provisioned in the default workspace, not in the intended workspace (in this case, code-green).

Key documentation excerpt:

“If you do not specify the workspace (namespace) using the --namespace parameter when creating a cluster, the cluster will be created in the default workspace. It will not appear in custom workspaces until manually assigned.”

The error states:

lua

Copy

Could not find or access '/home/.../nkp-image-builder-.../playbooks/.../artifacts/1.29.6_ubuntu_22.04_x86_64.tar.gz'

This indicates that the OS package bundle (artifacts/1.29.6_ubuntu_22.04_x86_64.tar.gz) has not been created or is missing. Creating the OS package bundle is a prerequisite step in the NIB workflow.

Key Reference:

Nutanix Kubernetes Platform Administration (NKPA) 6.10 – “Creating OS Package Bundles for NIB”

NCP-CN 6.10 Study Guide – “NIB Preparation Prerequisites”

=======

The NKP documentation recommends using a combination of RBAC assignments and exported manifests to manage access across multiple clusters. By exporting the role assignments to YAML, the engineer can consistently apply these settings across the different environments, ensuring the new team has the necessary resources and limits. This approach is especially useful for environments with multiple clusters and standardized configurations.

The NKPA course explains that deleting a workspace in NKP, especially after all associated clusters have been removed, is a straightforward process through the NKP UI. The correct method is to navigate to the Global view in the top menu bar, select Workspaces from the menu, locate the target workspace, click the three-dot button next to it, and select Delete. This action removes the workspace and its associated configurations from NKP, ensuring a clean environment after the project is finished.

The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “To delete an empty workspace in NKP, go to the Global view in the UI, select Workspaces, click the three-dot menu for the workspace, and choose Delete.” The course confirms that a workspace must be empty (no clusters or resources) before it can be deleted, which aligns with the scenario where the three clusters have already been removed.

Incorrect Options:

A & B. Run kubectl delete workspace: Both options are syntactically similar, but kubectl delete workspace is not a valid command in NKP. Workspaces are managed through the NKP UI or CLI (nkp), not directly via kubectl.

D. Ask a workspace user to delete the workspace: Workspace users typically lack permissions to delete workspaces; this action is reserved for administrators via the Global view.

The NKPA course explains that NKP uses Grafana Loki as part of its logging stack to implement a multi-tenant logging system, allowing teams to access their logs securely within their respective namespaces. The exhibit indicates two namespaces, tenant-innovation and tenant-analytics, each with a ConfigMap for logging configuration. The requirement is to set a retention period of 30 days for tenant-innovation and 7 days for tenant-analytics.

The correct YAML output (Option A) configures Loki’s retention period using ConfigMaps in the appropriate namespaces:

For tenant-innovation, the ConfigMap logging-innovation-config in the tenant-innovation namespace sets retention_period: 30d.

For tenant-analytics, the ConfigMap logging-analytics-config in the tenant-analytics namespace sets retention_period: 7d.

The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “In NKP, configure multi-tenant logging with Grafana Loki by creating a ConfigMap per namespace, specifying retention periods under loki.structuredConfig.limits_config.retention_period (e.g., 30d for 30 days, 7d for 7 days).” The d suffix denotes days, aligning with the requirement for 30 days and 7 days retention periods.

Incorrect Options:

B: The second ConfigMap incorrectly uses the tenant-innovation namespace instead of tenant-analytics, breaking the multi-tenant isolation.

C: The retention periods are set to 30h and 7h (hours), not 30d and 7d (days), which does not meet the requirement.

D: Both ConfigMaps use a generic tenant namespace, which does not match the specific namespaces (tenant-innovation, tenant-analytics) shown in the exhibit.

The NKPA course specifies the supported operating systems for NKP clusters deployed using the Nutanix provisioning method (CAPX), which leverages Cluster API for Nutanix (CAPX) to provision clusters on Nutanix AHV. The supported OS platforms for CAPX are Rocky Linux and Ubuntu, as these distributions are tested and optimized for Nutanix infrastructure and Kubernetes requirements.

Rocky Linux is a CentOS replacement adopted by Nutanix after CentOS 8’s end-of-life in 2021, providing a stable, enterprise-grade OS. Ubuntu, particularly LTS versions like 20.04 or 22.04, is widely supported due to its compatibility with Kubernetes and Nutanix AHV. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “When deploying NKP with the Nutanix provisioning method (CAPX), the supported OS platforms are Rocky Linux and Ubuntu, ensuring compatibility with Nutanix AHV and Kubernetes.” These OS images are typically prepared using NKP Image Builder (NIB) to include necessary components like kubeadm and containerd.

Incorrect Options:

A. CentOS and Rocky Linux: CentOS 8 is no longer supported post-2021, and Nutanix has shifted to Rocky Linux.

C. Flatcar, Rocky Linux, and Ubuntu: Flatcar Container Linux is not a supported OS for CAPX in NKP deployments.

D. CentOS and Ubuntu: CentOS is not supported, as noted above.

The exhibit shows an NKP UI message stating “No insights identified,” indicating that NKP Insights, the platform’s predictive analytics and observability feature, is not active. The NKPA course explains that NKP Insights is a platform application that provides anomaly detection and alerting for Kubernetes clusters but requires deployment and configuration to generate insights.

The correct approach (Option C) involves two steps:

Create a persistent volume claim (PVC) and assign it to nkp-insights: NKP Insights requires persistent storage to save logs, metrics, and historical data for analysis. The course specifies that a PVC must be created to provide this storage, ensuring the application can retain data for generating insights.

Install nkp-insights with nkp create appdeployment nkp-insights --app nkp-insights-1.2.2 --workspace kommander-workspace: This command deploys the NKP Insights application across all clusters in the specified workspace (kommander-workspace). The --app flag specifies the application version, and the deployment ensures that insights are generated for all clusters in the workspace.

The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “To enable NKP Insights, create a PersistentVolumeClaim for storage and deploy the application using nkp create appdeployment nkp-insights --app --workspace to begin generating insights across clusters.” This aligns with the need to control alerts across all company clusters, as NKP Insights provides centralized observability.

Incorrect Options:

A. Acquire the NKP Insights Add-on license: NKP Insights is a platform application included in higher-tier licenses (e.g., NKP Ultimate), not a separate add-on. The course does not indicate a separate license requirement.

B. Install nkp-insights in every cluster with kubectl apply: This method is manual and inefficient. NKP’s appdeployment command automates deployment across all clusters in a workspace.

The NKPA course explains that NKP supports auto-scaling for clusters using Cluster API (CAPI), which manages the lifecycle of Kubernetes nodes. When auto-scaling is enabled, NKP monitors cluster workloads and automatically adjusts the number of nodes based on demand. The behavior involves CAPI creating or deleting nodes as needed to scale the cluster up or down, ensuring optimal resource utilization.

The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “NKP auto-scaling uses Cluster API to dynamically create or delete nodes in response to workload demands, ensuring the cluster scales efficiently.” For example, if the workload increases, CAPI provisions additional worker nodes; if demand decreases, CAPI deletes nodes to reduce costs.

Incorrect Options:

A. CPU is hot-added or hot-removed: Hot-adding/removing CPU is not a Kubernetes auto-scaling behavior; scaling involves adding/removing nodes.

B. Memory is hot-added or hot-removed: Similar to CPU, memory scaling at the node level is not supported in this context.

C. Power-On Status/Mode of a node is changed: Auto-scaling does not involve changing node power states; it adds or removes nodes.

Comprehensive and Detailed Explanation:

The correct procedure for deleting an NKP cluster involves using the nkp delete cluster command with the appropriate cluster name and namespace. This ensures that not only the Kubernetes resources but also the corresponding NKP resources (e.g., nodepools, Kommander integration) are deleted cleanly and consistently. Simply deleting the VMs does not clean up the associated NKP management objects. This approach is detailed in the NKP documentation for cluster lifecycle management, emphasizing the need to use the provided CLI commands for full removal.

The NKPA 6.10 documentation outlines that in air-gapped environments where default pod network CIDR conflicts exist, the cluster manifest (created via the nkp create cluster command) should be updated to specify an alternate, non-conflicting pod CIDR block range before deployment.

According to the NKPA 6.10 documentation, the FIPS Compliant Build feature is exclusively available for Enterprise tier licensing. This ensures compliance with NIST security standards and provides hardened cryptographic capabilities throughout the Kubernetes cluster stack.

Exact extract from documentation:

“The FIPS-compliant build feature is included in the NKP Enterprise tier, enabling deployments in environments that require strict security compliance.”

The NKPA course emphasizes that NKP’s fleet management capabilities allow administrators to manage multiple Kubernetes clusters, including lightweight clusters on edge devices, by attaching them to an NKP workspace. With the NKP Ultimate license tier, the administrator has access to advanced fleet management features, including GitOps-based application deployment across attached clusters.

The most efficient way to lifecycle manage application deployments across the 30 edge devices is to create a new workspace and attach the 30 edge devices to this workspace using the Attach Cluster functionality (Option D). Once attached, NKP can use GitOps (via Flux) to push applications to all clusters in the workspace simultaneously, ensuring consistent deployment and lifecycle management. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “For managing edge devices with lightweight Kubernetes, attach the clusters to an NKP workspace using the Attach Cluster feature, enabling centralized application deployment and lifecycle management via GitOps.” The administrator can use the kubeconfig files to attach each cluster via the NKP UI or CLI (e.g., nkp attach cluster).

Incorrect Options:

A. Create a GitHub configuration for each device: This is manual and inefficient compared to NKP’s centralized GitOps management.

B. Create a script to automate deployment: Scripting is error-prone and lacks NKP’s built-in fleet management capabilities.

C. Delete lightweight Kubernetes and deploy new clusters: This is unnecessary, as NKP can manage existing clusters, including lightweight ones.

According to the NKPA 6.10 documentation, the critical system components for NKP nodes are:

kubelet

containerdThese components are deployed in the standard Linux path: /var/lib.

Exact extract from the documentation:

“The kubelet and containerd services require disk space in /var/lib on the host operating system. It’s essential to allocate sufficient storage in /var/lib to accommodate these core Kubernetes components.”

Continuous Deployment (CD) is the practice of automatically deploying new software releases across environments after a successful build and testing phase. In the context of NKP, enabling CD ensures that software changes are consistently and reliably rolled out to all clusters associated with a project, ensuring operational uniformity and rapid feature adoption.

The NKPA 6.10 documentation confirms that the proper method to customize application deployment (including disabling Velero) is by generating a configuration file using the nkp install kommander --init command. The file can then be modified to set custom specs and disable Velero, and finally deployed using the nkp install kommander command.

Exact extract:

“Generate a custom configuration file using --init, modify it for your specific environment (including disabling Velero), and deploy with the same nkp install kommander command.”

The NKPA course details that NKP Platform Applications, such as Grafana Logging, Grafana Loki, and Project Logging, are deployed to Kubernetes clusters to provide monitoring and logging capabilities. To ensure these components are automatically deployed to new workload clusters in a workspace, the administrator must enable them in the Application section under the workspace configuration in the NKP UI.

The course explains that the Application section allows administrators to select and configure platform applications that should be applied to all clusters within a workspace. By enabling Grafana Logging, Grafana Loki (for log aggregation), and Project Logging (for project-specific log management), these components are automatically deployed as part of the cluster provisioning process. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “To deploy platform applications like Grafana Loki and logging components to new clusters, configure them in the Application section of the workspace settings in the NKP UI.”

Incorrect Options:

A. Enable them in the Insights section under workspace: The Insights section is for analytics and monitoring dashboards, not for deploying logging components.

B. Enable them in the Projects section under workspace: Projects are sub-divisions within workspaces for resource allocation, not for configuring platform applications.

C. Enable them in the Clusters section under workspace: The Clusters section is for managing cluster settings, not for enabling platform applications.

Comprehensive and Detailed Explanation From Exact Extract of Nutanix Kubernetes Platform Administration (NKPA) Course:

The NKPA course outlines the process of adding GPU-enabled worker nodes to an existing NKP-managed Kubernetes cluster, such as the production cluster in this scenario. The first step in this process is to ensure that a GPU-compatible OS image is available for the new worker nodes, as GPU support requires specific drivers and configurations (e.g., NVIDIA drivers) that are not included in standard OS images.

The correct first step is to create a GPU-compatible OS image using the command:

text

CollapseWrap

Copy

nkp create image nutanix --gpu \

--gpu-name=${GPU_NAME} \

--cluster=${NUTANIX_CLUSTER_NAME} \

--endpoint=${NUTANIX_PC_ENDPOINT} \

--subnet=${NUTANIX_SUBNET} ubuntu-22.04

(Option D). This command uses the NKP CLI to create a machine image based on Ubuntu 22.04, tailored for Nutanix AHV infrastructure (nutanix) with GPU support enabled (--gpu). The --gpu-name flag specifies the GPU type (e.g., NVIDIA GPU model), and other parameters define the Nutanix cluster, Prism Central endpoint, and subnet for image creation. The resulting image includes the necessary NVIDIA drivers and dependencies, making it suitable for GPU-enabled worker nodes. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “Before adding GPU-enabled workers to an NKP cluster on Nutanix, the first step is to create a GPU-compatible OS image using nkp create image nutanix --gpu, ensuring the image includes the required GPU drivers for the target infrastructure.”

This image is then used in subsequent steps (like Option A) to create a node pool with GPU-enabled workers. Without this image, the node pool creation in Option A would fail due to the lack of a suitable --vm-image.

Incorrect Options:

A. Create a nodepool of workers with GPU: This step requires a pre-existing GPU-compatible OS image (specified via --vm-image). Since the question does not indicate that such an image already exists, creating the image (Option D) must happen first.

B. Add the GPU Operator to the new workers: The NVIDIA GPU Operator can be installed to manage GPU resources, but this step occurs after the GPU-enabled workers are added to the cluster, not as the first step.

C. Configure Multi-Instance GPU (MIG): MIG configuration is an advanced GPU setup step that occurs after the workers are added and the GPU Operator is installed, not as the first step.

The Nutanix Kubernetes Platform (NKP) uses workspaces to provide isolated environments for different teams or projects, allowing each team to manage its own clusters, applications, and resources independently. According to the NKPA course, creating a new workspace is a key Day 2 operation to support multi-tenancy and isolated development environments, such as those required for the microservices in this scenario.

The course specifies that to create a new workspace, users must navigate to the workspace selection dropdown list in the top menu bar of the NKP user interface (UI) and select Create Workspace. This action opens a form where administrators can define the workspace name, description, and associated resources (e.g., clusters, users, and policies). The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “To create a new workspace in NKP, go to the workspace selection dropdown in the UI and select ‘Create Workspace’ to configure an isolated environment for a team or project.” This process ensures that each microservice team has its own isolated environment for development and testing, with access restricted to their specific workspace.

Incorrect Options:

A. From the Cluster selection, select Add Cluster: Adding a cluster creates a new Kubernetes cluster within an existing workspace, not a new workspace. The NKPA course distinguishes between cluster and workspace creation.

C. From the workspace selection dropdown list in the top menu bar, select Add Workspace: The NKPA course and UI use “Create Workspace” as the standard terminology, not “Add Workspace.”

D. From the Administration selection dropdown list in Infrastructure Providers, select Add Infrastructure Provider: This option is for configuring infrastructure providers (e.g., AWS, vSphere) for NKP, not for creating workspaces.

The NKPA course outlines the specifics of integrating Azure Kubernetes Service (AKS) with NKP, focusing on fleet management and the deployment architecture. The correct statements are:

Existing AKS clusters must be attached to the Management cluster (Option A):NKP does not provision AKS clusters directly because AKS is a managed Kubernetes service. Instead, NKP attaches existing AKS clusters to its management plane for centralized management. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “For AKS integration, existing AKS clusters must be attached to the NKP Management cluster using the Attach Cluster functionality, as NKP does not provision AKS clusters.” This involves creating a service account with cluster-admin permissions in the AKS cluster and providing its kubeconfig to NKP.

NKP Management cluster with the Kommander component must be installed before installing NKP on AKS cluster (Option C):The Kommander component is part of the NKP Management cluster and provides the centralized management plane for fleet management, including AKS clusters. The NKPA course specifies that an NKP Management cluster with Kommander must be deployed before attaching or managing external clusters like AKS. The NCP-CN 6.10 Study Guide notes: “An NKP Management cluster with Kommander must be installed prior to integrating AKS clusters, as Kommander enables the fleet management capabilities for external clusters.”

Incorrect Options:

B. AKS best practices encourage building customized images: AKS best practices recommend using the default node images provided by Azure, which are optimized for AKS features like autoscaling and security. Custom images can lead to loss of functionality, as noted in previous questions (e.g., Q91).

D. AKS clusters can be deployed as Management or Pro NKP clusters: AKS clusters are attached, not deployed, by NKP. Additionally, AKS clusters cannot serve as NKP Management clusters; the Management cluster must be deployed on supported infrastructure like Nutanix AHV, AWS, or vSphere. “Pro NKP clusters” is not a valid term in NKP documentation—Pro refers to a license tier, not a cluster type.