Nutanix NCP-CN - Nutanix Certified Professional - Cloud Native (NCP-CN-6.10)

The NKPA course specifies that the NKP CLI is the primary tool for deploying NKP clusters with advanced configurations, such as those required for a dark site environment, custom Service and Pod CIDR blocks, and Nutanix AHV clusters. The NKP CLI (nkp) provides granular control over cluster creation, allowing administrators to specify custom networking parameters and air-gapped deployment settings via command-line flags or configuration files.

For a dark site deployment, the NKP CLI uses an Air-Gapped Bundle to provide all necessary dependencies. Custom CIDR blocks are configured using flags like --service-cidr and --pod-cidr during the nkp create cluster command. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “The NKP CLI is used to deploy clusters with custom configurations, including dark site readiness and custom networking, on Nutanix AHV clusters.” For example: nkp create cluster --air-gapped --service-cidr 10.96.0.0/12 --pod-cidr 192.168.0.0/16 --infrastructure nutanix-ahv.

Incorrect Options:

A. kubectl CLI: kubectl manages Kubernetes resources, not NKP cluster deployment.

B. NKP GUI: The GUI supports basic deployments but lacks the flexibility for custom CIDR and dark site configurations.

D. OCP CLI: OpenShift (OCP) is a separate platform, not used for NKP deployments.

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 recommends implementing Quotas and Limit Ranges.

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

Limit Ranges set 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.

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.

According to the NKPA 6.10 documentation, Rook Ceph is the recommended out-of-the-box storage solution integrated with NKP for persistent data storage, backups, and object storage within the Kubernetes environment.

Key Reference:

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

The NKPA course explains that by default, NKP creates new AWS infrastructure (VPC, subnets, ELBs) when deploying a cluster on AWS. However, NKP supports deploying clusters on existing AWS infrastructure by providing custom configurations. The recommended method using the NKP CLI is to create an overrides file specifying the pre-existing VPC, subnets, and ELB, and then pass this file to the nkp create cluster aws command using the --overrides parameter.

The overrides file (e.g., aws-infra-overrides.yaml) contains details like vpcID, subnetIDs, and loadBalancerIDs, which NKP uses to deploy the cluster on the specified infrastructure instead of creating new resources. For example:

yaml

CollapseWrap

Copy

aws:

vpcID: vpc-12345678

subnetIDs:

- subnet-12345678

- subnet-87654321

loadBalancerIDs:

- elb-12345678

The engineer then runs: nkp create cluster aws --overrides aws-infra-overrides.yaml.

The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “To deploy an NKP cluster on existing AWS infrastructure, create an overrides file with the pre-existing VPC, subnets, and ELB details, and use the --overrides parameter with the nkp create cluster aws command to apply the custom configuration.” This method ensures the AWS team’s requirement is met while leveraging NKP’s CLI for deployment.

Incorrect Options:

A. nkp adopt infrastructure aws: There is no nkp adopt infrastructure command in NKP for this purpose.

C. Use the NKP UI: While the UI allows specifying infrastructure details, the question focuses on the CLI-based deployment, and the UI method is less relevant here.

D. Include parameters directly in nkp create cluster aws: The nkp create cluster aws command does not support direct parameters for VPC, subnets, and ELB; it requires an overrides file.

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.

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.

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.

The NKPA course explains that NKP provides a role-based access control (RBAC) system to manage permissions within its platform, in addition to Kubernetes-native RBAC. For a development team needing limited permissions to perform specific tasks (deploying applications, scaling deployments, viewing logs and metrics) within a specific namespace, the appropriate access type in the NKP GUI is an NKP Role.

NKP Roles are predefined or custom roles within the NKP platform that map to Kubernetes RBAC permissions but are managed through the NKP UI for ease of use. They allow granular control over actions within a workspace or namespace, ensuring the team can perform their tasks (e.g., deploy, scale, get logs) without having access to other environments or cluster-wide resources. For example, an NKP Role like “Developer” or a custom role can be configured to grant edit permissions in the team’s namespace while restricting access elsewhere. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “In the NKP GUI, configure an NKP Role to grant limited permissions to a development team, allowing actions like deploying applications and viewing logs within their namespace while preventing unauthorized changes in other environments.”

Incorrect Options:

B. Cluster Role: A Kubernetes Cluster Role grants permissions across all namespaces, which is too broad for the team’s limited access requirement.

C. Cluster Admin: This grants full administrative access to the entire cluster, far exceeding the team’s needs and violating the principle of least privilege.

D. Kommander Role: Kommander is a management component in NKP, but “Kommander Role” is not a specific access type in the NKP GUI for this purpose.

When an Amazon EKS cluster is attached to NKP for fleet management, NKP uses GitOps principles, leveraging Flux (a GitOps operator) to synchronize application deployments and configurations from a management Git repository to the attached cluster. The NKPA course explains that detaching a cluster from NKP removes it from the NKP management plane, but the Flux installation on the cluster may continue to reconcile with the Git repository, causing application changes to persist post-detachment.

To resolve this, the engineer must manually disconnect the Flux installation by suspending the Git repository reconciliation. The correct command, as per the NKPA course, is: kubectl -n kommmander-flux patch gitrepo management -p '{"spec":{"suspend":true}}' --type merge. This command suspends Flux’s synchronization with the management Git repository, stopping further application updates. The Nutanix Cloud Native (NCP-CN) 6.10 Study Guide states: “After detaching an external cluster from NKP, the Flux GitOps operator may continue to apply changes unless its GitRepo resource is suspended using kubectl patch in the kommmander-flux namespace.”

Incorrect Options:

A. Forcefully detach EKS cluster: The --force flag is not a standard option for the nkp detach cluster command, and forceful detachment does not address the Flux reconciliation issue.

B. Detached cluster must also be deleted from NKP: The cluster is already detached, and deletion is not necessary to stop GitOps updates. The issue lies with Flux, not NKP’s state.

C. Developers must have some bad configuration: The issue is not with developer configurations but with Flux’s ongoing synchronization, as explained in the NKPA course.