NCP-CN Practice Exam Questions with Answers Nutanix Certified Professional - Cloud Native (NCP-CN-6.10) Certification

To push the NKP Catalog Applications image bundle to a private registry, the officialnkp push bundlecommand must be used with the specified parameters to authenticate and push the bundle to the registry.

Exact extract:

“Use the nkp push bundle command to upload the NKP catalog applications image bundle to the specified private registry, ensuring secure and complete image upload.”

The NKPA course outlines the process for deploying an NKP cluster on Nutanix AHV infrastructure using the NKP CLI. For a prompt-based deployment, where the administrator is guided through configuration options interactively, the correct command isnkp create cluster ahv. This command initiates the deployment of an NKP cluster on the AHV hypervisor, prompting the administrator to input details like cluster name, node counts, and networking settings.

The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “To deploy an NKP cluster on AHV using the prompt-based CLI method, use nkp create cluster ahv, which guides the administrator through the configuration process.” The command is specific to the AHV hypervisor (part of AOS 6.10) and is suitable for the specified hardware (NX-8170-G9 nodes).

Incorrect Options:

A. nkp create cluster nutanix: The provider is specified as ahv, not nutanix, in the NKP CLI syntax.

C. nkp create nodepool nutanix: This creates a node pool, not a cluster, and is not prompt-based.

D. nkp install kommander: Kommander is a management component, not used for cluster creation on AHV.

The Nutanix Kubernetes Platform (NKP) leverages Cluster API (CAPI) to manage the lifecycle of Kubernetes clusters. When preparing machine images for NKP deployment, the Nutanix Image Builder (NIB) or Kubernetes Image Builder (KIB) process is used to create custom machine images that are compatible with NKP’s infrastructure requirements. According to the NKPA course, the primary purpose of this process is to createCAPI-compliant imagesthat can be used as the base for NKP cluster nodes.

The NKPA course explains that NKP uses CAPI to provision and manage Kubernetes clusters, and CAPI requires machine images that meet specific criteria, such as including the necessary Kubernetes components, container runtimes, and operating system configurations. The NIB/KIB process ensures that the images are pre-configured with these components, making them suitable for use as NKP worker and control plane nodes. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “The Nutanix Image Builder (NIB) or Kubernetes Image Builder (KIB) is used to create CAPI-compliant machine images that include the required OS, Kubernetes binaries, and dependencies for NKP cluster nodes.”

These images are typically based on supported operating systems like Rocky Linux or Ubuntu, as provided by Nutanix, and are customized to include the container runtime (e.g., containerd), kubeadm, and other dependencies required for CAPI-based cluster provisioning. The resulting images are stored in a location accessible to the NKP deployment process, such as a local registry or Nutanix Prism Central.

Incorrect Options:

A. Hardening an OS image with client-supplied hardening scripts: While hardening the OS is a good practice, it is not the primary purpose of the NIB/KIB process. The NKPA course notes that hardening can be applied as part of image customization, but the core goal is to ensure CAPI compliance, not just hardening.

B. Creating a custom user account for NKP admins to ensure access to NKP nodes: The NIB/KIB process does not focus on creating user accounts. User access is managed through Kubernetes RBAC or external identity providers, as covered in the NKPA course’s authentication section.

C. Tagging the image to be used specifically for NKP: Tagging may occur as part of image management, but it is not the primary purpose. The NKPA course emphasizes CAPI compliance over tagging.

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 NKPA course details the process for upgrading an NKP-managed Kubernetes cluster, such as one running on AWS from version 1.28.1 to 1.29.9. Upgrading a Kubernetes cluster involves two distinct steps: upgrading the control plane nodes and upgrading the worker nodes, ensuring minimal disruption and maintaining compatibility. The NKP CLI provides specific commands to handle these upgrades separately for AWS clusters.

Upgrade Control Planes with nkp update controlplane aws --cluster-name=${CLUSTER_NAME} --ami AMI_ID --kubernetes-version=v1.29.9 (Option B):The control plane must be upgraded first to the target Kubernetes version (1.29.9). The nkp update controlplane aws command updates the control plane nodes, specifying the cluster name, the new Kubernetes version, and an updated AMI (Amazon Machine Image) that supports the target version. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “To upgrade an NKP cluster on AWS, first update the control plane using nkp update controlplane aws --cluster-name --ami --kubernetes-version to ensure the control plane runs the desired Kubernetes version.” The --ami flag is required to specify a compatible image for the upgraded control plane nodes.

Upgrade Workers with nkp upgrade nodepool aws ${NODEPOOL_NAME} --cluster-name=${CLUSTER_NAME} --kubernetes-version=v1.29.9 (Option C):After the control plane is upgraded, the worker nodes in each node pool must be upgraded to match the control plane version. The nkp upgrade nodepool aws command updates the specified node pool to the target Kubernetes version (1.29.9). The NKPA course notes: “Upgrade worker nodes using nkp upgrade nodepool aws --cluster-name --kubernetes-version , which performs a rolling update to ensure minimal downtime.” This command automatically handles the rolling update of worker nodes, replacing them with new nodes running the updated version. Note that the --ami flag is not required here, as NKP typically uses the same AMI as the control plane or retrieves a compatible one based on the version.

Incorrect Options:

A. nkp update nodepool aws: The correct command is nkp upgrade nodepool, not nkp update nodepool. The NKPA course uses upgrade for version changes to node pools.

D. nkp update cluster aws: This command is not the standard approach for upgrading Kubernetes versions in NKP. The course specifies separate commands for control plane and node pool upgrades to ensure a controlled process.

When mirroring the NKP bundle to a private registry, the recommended method is to use the nkp bundle push or similar commands with the--to-registryoption, specifying the target registry along with the credentials (--to-registry-username and --to-registry-password).

Key reference from documentation:

“Use the --to-registry flag along with --to-registry-username and --to-registry-password to push the NKP bundle to a private registry.”

According to theNKPA 6.10 documentation,Rook Cephis the recommended out-of-the-box storage solution integrated with NKP forpersistent data storage, backups, and object storagewithin the Kubernetes environment.

Key Reference:

“Rook Ceph is integrated with NKP for providing persistent storage and backup support within the cluster.”

The NKPA course emphasizes that NKP supports multi-tenancy through workspaces, each of which can be configured with its own Identity Provider (IdP) for authentication. In this scenario, each group (Fin VD, Fin Insurance, Fin Travel) has its own IdP, and the engineer has created separate workspaces for them. To assign the Tenant Administrators role, the engineer must configure a dedicated IdP for each group’s workspace, enabling users to authenticate via their group-specific IdP and assume the Tenant Administrator role.

The course details that NKP uses Dex as the OIDC provider to integrate with external IdPs. For each workspace, the engineer configures a Dex connector to the group’s IdP, maps the IdP groups to NKP roles (e.g., Tenant Administrator), and assigns permissions via role bindings. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “To assign Tenant Administrator roles in NKP, configure a dedicated IdP for each workspace using Dex connectors, mapping IdP groups to the appropriate roles for workspace management.” This ensures that each group’s administrators can access only their designated workspace.

Incorrect Options:

B. Create a role named admin-tenant-X: NKP uses predefined roles like Tenant Administrator, not custom roles with specific naming conventions.

C. Create a role binding and assign it: Role bindings are part of the process, but the primary step is configuring the IdP for authentication, as per the NKPA course.

D. Configure the global Active Directory: The scenario specifies separate IdPs per group, not a global Active Directory for all groups.

TheNKPA 6.10 documentationspecifies 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.”

As outlined in theNKPA 6.10 documentation,Gossis used tovalidatethat an OS image meets the requirements to serve as an NKP node (such as the presence of required packages, kernel modules, and system settings). Goss is not used to modify or harden the image; rather, it validates conformance.

Key reference:

“During the image build process, Goss tests validate that the image meets the required standards for use as a Kubernetes node in NKP deployments.”

The NKPA course clarifies that NKP licenses are based on the number ofCPU coresin the infrastructure hosting the Kubernetes clusters. This licensing model applies to both on-premises (e.g., Nutanix AHV) and cloud-based deployments. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “NKP licenses are obtained based on the total number of CPU cores allocated to the clusters managed by the platform.” This core-based licensing ensures flexibility across different infrastructure types while aligning with the resource consumption of Kubernetes workloads.

Incorrect Options:

A. Flash: Flash storage is not a licensing unit for NKP.

B. CPU Sockets: Nutanix licenses for other products may use sockets, but NKP uses cores.

C. TiBs: Terabytes are used for storage licensing, not NKP.

The exhibit shows the NKP UI with the "Create Cluster" option grayed out in a new workspace, indicating that a prerequisite for cluster creation is missing. The NKPA course explains that to create a new Kubernetes cluster in a workspace, anInfrastructure Providermust be configured for that workspace. An Infrastructure Provider defines the underlying infrastructure (e.g., Nutanix AHV, AWS, vSphere) where the cluster will be provisioned, and without it, the Create Cluster option remains disabled in the UI.

The NKP Ultimate license supports creating clusters across various infrastructures, but the workspace must be associated with an Infrastructure Provider to enable cluster creation. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “Before creating a cluster in a new workspace, ensure an Infrastructure Provider is configured for the workspace in the NKP UI; otherwise, the Create Cluster option will be grayed out.” The engineer should navigate to the Infrastructure Providers section in the NKP UI (typically under the Global or Administration view), create a provider (e.g., for Nutanix AHV, AWS, or vSphere), and associate it with the workspace. Once this is done, the Create Cluster option will become available.

Incorrect Options:

A. Create the cluster only using YAML and not the GUI: The issue is not with the GUI itself but with the missing Infrastructure Provider, which affects both GUI and CLI cluster creation. YAML alone does not resolve this.

B. Attach existing clusters instead of creating a new cluster: Attaching existing clusters is an alternative but does not address the requirement to create a new cluster.

D. Ensure NKP is upgraded to a minimum version of 2.12: The NKP Ultimate license implies a recent version, and the course does not indicate that version 2.12 is specifically required for this functionality. The issue is configuration-related, not version-related.

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 involvesCAPI creating or deleting nodesas 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.

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 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 anAir-Gapped Bundleand anexisting local container registryas critical components for such deployments.

Air-Gapped Bundle (Option B):

The NKPA course explains that for dark site deployments, Nutanix provides anAir-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.

As per theNKPA 6.10 documentationand cluster autoscaler behavior, when nodes are scaled down in NKP (or any CAPI-managed environment), the node isdeletedfrom the infrastructure provider (vSphere, AWS, Nutanix, etc.). This effectively removes it from both the cluster and the underlying hypervisor or cloud provider, thus freeing up resources and reducing costs.

For deploying NKP clusters in AWS, setting theAWS_REGIONenvironment variable is a key prerequisite to ensure that the AWS CLI and underlying deployment scripts know which region to target. This is essential for provisioning instances using the specified AMI.

Exact extract:

“Set the AWS_REGION environment variable to the appropriate region prior to deploying clusters to ensure proper interaction with the AWS API.”

TheNKPA 6.10 documentationclarifies that the supported and recommended method to delete an entirenode pool(including its worker nodes) in an NKP cluster is by using the nkp delete nodepool command. This command removes the specified node pool and all associated resources from the cluster in a controlled and supported manner.

Key reference from the documentation:

“Use nkp delete nodepool --cluster-name= to safely remove the node pool and its associated resources.”

Manual VM deletion via ACLI or NCLI is not recommended because it bypasses the Kubernetes and NKP resource lifecycle, potentially leaving orphaned resources or inconsistent cluster states.

The documentation confirms that when a new license is activated to upgrade to a higher tier, users mustlog out and log back infor the license changes to take effect. This ensures that updated entitlements are loaded into the UI and CLI environment.

Exact extract from documentation:

“After applying a new license for a higher-tier product, log out and log back in to see and activate the newly available features.”

TheNKPA 6.10 documentationoutlines 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.

As per theNKPA 6.10 documentation, the primary requirement for attaching external (self-managed) Kubernetes clusters to NKP isnetwork connectivity. Specifically, theNKP management cluster must be able to communicate with the Kubernetes API serverand relevant services of the target cluster. This allows NKP to collect metrics, perform health checks, and manage the attached cluster through Kommander and associated tools.

Exact extract:

“For attaching existing Kubernetes clusters, ensure the NKP management cluster can reach the Kubernetes API server of the target cluster and that the kubeconfig used has sufficient permissions.”

There is no requirement that the Kubernetes versions be exactly matched or within N-1, nor that an NKP admin account be directly established on the target clusters; the connectivity and valid kubeconfig file are the essential requirements.

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 tocreate a GPU-compatible OS imageusing 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.

Comprehensive and Detailed Explanation:

Both the Konvoy Image Builder (KIB) and the Nutanix Image Builder (NIB) are included tools used to create and manage custom OS images suitable for NKP deployments. KIB is responsible for building images that conform to the standards required by Konvoy-based environments, while NIB is designed for direct integration with the Nutanix AHV infrastructure. These tools support automated preparation, hardening, and upload of images to the appropriate repositories.

TheSecure Tunnelfeature in NKP relies on HTTPS (TCP port 443) to establish secure, encrypted connections between the attached cluster and the management cluster, enabling fleet management even in restricted network environments.

Exact extract:

“Secure Tunnel uses TCP/443 (HTTPS) for establishing a secure connection between the attached cluster and NKP.”

The NKPA course addresses resource contention in Kubernetes clusters, where one application (e.g., ApplicationB) consumes excessive resources, impacting others (e.g., ApplicationA). To mitigate this, the course recommendsimplementing Quotas and Limit Ranges.

Resource Quotasrestrict the total amount of CPU, memory, and other resources a namespace can consume, ensuring fair resource allocation across teams.

Limit Rangesset minimum and maximum resource limits for individual pods and containers within a namespace, preventing any single application from monopolizing resources.

The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “To prevent resource contention in NKP clusters, apply Resource Quotas to limit namespace resource usage and Limit Ranges to enforce pod and container resource boundaries.” For example, the administrator can create a ResourceQuota to cap ApplicationB’s namespace resource usage and a LimitRange to restrict its pod resource requests/limits, ensuring ApplicationA has sufficient resources.

Incorrect Options:

B. Setting up Network Policies: Network Policies control network traffic, not resource usage.

C. Configuring RBAC: RBAC manages access permissions, not resource allocation.

D. Implementing Continuous Deployment (CD): CD automates deployments but does not address resource contention.

When deploying NKP to AWS, the bootstrap process requires AWS credentials to interact with AWS APIs for provisioning resources like EC2 instances. The NKPA course specifies that the nkp CLI supports the --aws-profile flag to specify a custom AWS profile for authentication. This profile, defined in the AWS credentials file (~/.aws/credentials), contains the access key and secret key for the desired AWS account.

The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “To deploy NKP on AWS with custom credentials, use the --aws-profile= flag during the nkp create bootstrap command to reference a specific AWS profile.” This approach leverages the AWS CLI’s profile management, ensuring secure and flexible credential handling. For example, the command would be nkp create bootstrap --aws-profile=my-profile --kubeconfig bootstrap-cluster.conf.

Incorrect Options:

B. --cloud-credentials=<my-profile></my-profile>: This flag is not used by the nkp CLI. The NKPA course specifies --aws-profile for AWS.

C. --with-aws-bootstrap-credentials=true: This flag does not exist in the NKPA documentation for NKP bootstrap.

D. --aws-access-key=<aws access="" key=""> --aws-secret-key=<aws secret="" key=""></aws></aws>: While these flags may be used in some tools, the NKPA course recommends using --aws-profile to avoid hardcoding sensitive credentials.

As per theNKPA 6.10 documentation, the correct approach for deleting an entire NKP-managed cluster (including nodes and deployed applications) is to use the nkp delete cluster command with the cluster name and --kubeconfig parameter. The --self-managed flag ensures the deletion of resources provisioned by the cluster.

Exact extract:

“Use nkp delete cluster --cluster-name= --self-managed --kubeconfig= to delete a cluster and its associated resources.”