Pass the Linux Foundation Kubernetes and Cloud Native KCNA Questions and answers with ExamsMirror

https://kubernetes.io/docs/concepts/workloads/pods/#pod-networking

Text Description automatically generated

https://kubernetes.io/docs/concepts/storage/persistent-volumes/#types-of-persistent-volumes

Table Description automatically generated with medium confidence

https://github.com/cncf/landscape#trail-map

https://semver.org/

RegEx SemVer at https://regex101.com/r/vkijKf/1/

https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/

Graphical user interface, text, application, email Description automatically generated

https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#edit

Graphical user interface, text, application, email Description automatically generated

https://kubernetes.io/docs/concepts/overview/working-with-objects/_print/

Text, letter Description automatically generated

In Prometheus, aGaugerepresents a single numerical value that canincrease and decreaseover time, which makesDthe correct answer. Gauges are used for values like current memory usage, number of in-flight requests, queue depth, temperature, or CPU usage—anything that can move up and down.

This contrasts with aCounter, which is strictly monotonically increasing (it only goes up, except for resets when a process restarts). Counters are ideal for cumulative totals like total HTTP requests served, total errors, or bytes transmitted. Histograms and Summaries are used to capture distributions (often latency distributions), providing bucketed counts (histogram) or quantile approximations (summary), and are not the “single value that goes up and down” primitive the question asks for.

In Kubernetes observability, metrics are a primary signal for understanding system health and performance. Prometheus is widely used to scrape metrics from Kubernetes components (kubelet, API server, controller-manager), cluster add-ons, and applications. Gauges are common for resource utilization metrics and for instantaneous states, such as container_memory_working_set_bytes or go_goroutines.

When you build alerting and dashboards, selecting the right metric type matters. For example, if you want to alert on thecurrentmemory usage, a gauge is appropriate. If you want to compute request rates, you typically use counters with Prometheus functions like rate() to derive per-second rates. Histograms and summaries are used when you need latency percentiles or distribution analysis.

So, for “a single numerical value that can go up and down,” the correct Prometheus metric type isGauge (D).

=========

Yes, a KubernetesService can expose multiple ports, and when it does, each port should have aunique, unambiguous name, makingBcorrect. In the Service spec, the ports field is an array, allowing you to define multiple port mappings (e.g., 80 for HTTP and 443 for HTTPS, or grpc and metrics). Each entry can include port (Service port), targetPort (backend Pod port), and protocol.

The naming requirement becomes important because Kubernetes needs to disambiguate ports, especially when other resources refer to them. For example, an Ingress backend or some proxies/controllers can reference Service ports byname. Also, when multiple ports exist, a name helps humans and automation reliably select the correct port. Kubernetes documentation and common practice recommend naming ports whenever there is more than one, and in several scenarios it’s effectively required to avoid ambiguity.

Option A is incorrect because multi-port Services are common and fully supported. Option C is insufficient: while different port numbers are necessary, naming is the correct distinguishing rule emphasized by Kubernetes patterns and required by some integrations. Option D is incorrect and nonsensical—Services can expose many ports and are not restricted to 443.

Operationally, exposing multiple ports through one Service is useful when a single backend workload provides multiple interfaces (e.g., application traffic and a metrics endpoint). You can keep stable discovery under one DNS name while still differentiating ports. The backend Pods must still listen on the target ports, and selectors determine which Pods are endpoints. The key correctness point for this question is:multi-port Services are allowed, and each port should be uniquely named to avoid confusion and integration issues.

=========

The standard way to deploy workloads to Kubernetes using only built-in tooling is to createKubernetes manifests(YAML/JSON definitions of API objects) and apply them withkubectl, soCis correct. Kubernetes is a declarative system: you describe the desired state of resources (e.g., a Deployment, Service, ConfigMap, Ingress) in a manifest file, then submit that desired state to the API server. Controllers reconcile the actual cluster state to match what you declared.

A manifest typically includes mandatory fields like apiVersion, kind, and metadata, and then a spec describing desired behavior. For example, a Deployment manifest declares replicas and the Pod template (containers, images, ports, probes, resources). Applying the manifest with kubectl apply -f creates or updates the resources. kubectl apply is also designed to work well with iterative changes: you update the file, re-apply, and Kubernetes performs a controlled rollout based on controller logic.

Option B (Helm) is indeed a popular deployment tool, but Helm is explicitly an “additional tool” beyond kubectl and the Kubernetes API. The question asks “without additional tools,” so Helm is excluded by definition. Option A (running Bash scripts on worker nodes) bypasses Kubernetes’ desired-state control and is not how Kubernetes workload deployment is intended; it also breaks portability and operational safety. Option D is not a standard Kubernetes deployment mechanism; kubectl does not “run Python scripts” to deploy workloads (though scripts can automate kubectl, that’s still not the primary mechanism).

From a cloud native delivery standpoint, manifests support GitOps, reviewable changes, and repeatable deployments across environments. The Kubernetes-native approach is:declareresources in manifests andapplythem to the cluster. Therefore,Cis the verified correct answer.