CNPA Exam Dumps - Certified Cloud Native Platform Engineering Associate

An API-driven service catalog provides a centralized and standardized interface where developers can discover and provision platform services. Option A is correct because it simplifies service discovery, allowing teams to connect to databases, messaging systems, and other infrastructure without needing in-depth platform knowledge. This improves productivity and developer experience by reducing cognitive load and ensuring consistent, governed access.

Option B is the opposite of the benefit—catalogs accelerate provisioning. Option C is incorrect because catalogs do not bypass security; they enforce guardrails and compliance. Option D is also incorrect because service catalogs abstract away provisioning details rather than forcing developers to manage them.

By providing golden paths and API-driven self-service, service catalogs ensure developers focus on building applications while platform teams maintain consistency and compliance.

A golden path in platform engineering refers to a curated, opinionated workflow that makes the easiest way the right way for developers. Option C is correct because a templated workflow for deploying a microservice with integrated testing and monitoring embodies the golden path concept. It provides developers with a pre-validated, secure, and efficient approach that reduces cognitive load and accelerates delivery.

Option A (documentation) provides information but lacks automation and enforced best practices. Option B (monitoring dashboards) improves observability but does not guide developers in delivery workflows. Option D (API service catalog) is useful but more about service discovery than curated workflows.

Golden paths improve adoption by embedding guardrails, automation, and organizational standards directly into workflows, making compliance seamless. They ensure consistency while allowing developers to focus on innovation rather than platform complexity.

The Kubernetes reconciliation loop ensures that the actual state of a resource matches the desired state defined in its manifest. If the replica count of a Deployment is changed from 3 to 5, option B is correct: Kubernetes will automatically create two new Pods to satisfy the new desired replica count.

Option A is incorrect because Deployments are not deleted; they are updated in place. Option C contradicts Kubernetes’ declarative model—no manual intervention is required. Option D is wrong because Kubernetes does not restart existing Pods unless necessary; it simply adds additional Pods.

This reconciliation process is core to Kubernetes’ declarative infrastructure approach, where desired states are continuously monitored and enforced. It reduces human toil and ensures consistency, making it fundamental for platform engineering practices like GitOps.

In Istio, PeerAuthentication is used to configure how workloads authenticate traffic coming from other services in the mesh. Option C is correct because PeerAuthentication primarily secures service-to-service communication using mutual TLS (mTLS), ensuring encryption in transit and verifying the identity of both communicating parties.

Option A (network policies for ingress traffic) relates to Kubernetes NetworkPolicy, not Istio PeerAuthentication. Option B (traffic routing) is handled by Istio’s VirtualService and DestinationRule resources. Option D (monitoring/logging) is part of Istio’s telemetry features, not PeerAuthentication.

PeerAuthentication policies define whether mTLS is disabled, permissive, or strict, giving platform teams fine-grained control over how services communicate securely. This aligns with zero-trust security models and ensures compliance with organizational policies without requiring application code changes.

Declarative Infrastructure as Code (IaC) is a key principle in cloud native environments because it enables platform teams to define the desired state of infrastructure rather than step-by-step procedures. Option A is correct since declarative IaC focuses on describing the “what” (e.g., the infrastructure resources needed) rather than the “how” to create them. Tools such as Terraform, Pulumi (in declarative mode), and Kubernetes manifests embody this model.

Option B is incorrect; declarative IaC is particularly well-suited for dynamic environments due to reconciliation loops. Option C is misleading—imperative methods typically provide more granular control, but declarative abstracts it for simplicity. Option D is false; declarative IaC usually reduces coding effort by relying on higher-level abstractions.

This model allows for consistent, reproducible environments, simplifies management, and integrates naturally with GitOps workflows. It reduces human error and ensures the platform continuously enforces the desired infrastructure state.

Automation in DevOps practices is central to platform engineering because it enables faster, reliable, and repeatable deployments. Option D is correct: automation accelerates deployments, reduces bottlenecks, and enables continuous delivery and rapid iterations. By automating build, test, and deployment pipelines, teams can deliver new features quickly while maintaining high quality and compliance.

Option A is incorrect because automation does not reduce the need for communication—it complements collaboration by removing friction. Option B is unrealistic: some manual oversight may remain (e.g., in production approvals for sensitive workloads). Option C is not a primary benefit—while tools may be involved, the focus is on outcomes, not tool dependency.

By embedding automation, teams reduce toil, enforce consistency, and free developers to focus on value creation rather than repetitive tasks. This results in shorter lead times, higher deployment frequency, and overall improved developer experience, which aligns with DORA metrics.

To achieve repeatability and consistency, CI pipelines must produce immutable artifacts that are uniquely identifiable and reproducible. Option D is correct because immutable artifacts (such as container images tagged with digests or versioned binaries) ensure that the same build artifact can be promoted across environments (dev, staging, production) without modification. This eliminates discrepancies caused by rebuilding code in different environments.

Option A (notifications) improves feedback but does not guarantee consistency. Option B (dynamic scaling) optimizes resource usage but does not address build reproducibility. Option C (dashboards) aid in visibility but are not critical to ensuring consistent outputs.

Immutable artifacts are essential for compliance, traceability, and reliability. They ensure that what has been tested is exactly what gets deployed, which is central to continuous delivery and GitOps practices.

OpenCost is the CNCF-supported open-source project designed specifically for Kubernetes cost visibility and optimization. Option B is correct because OpenCost provides granular, real-time allocation of Kubernetes costs across namespaces, workloads, and teams. This allows organizations to understand true cost drivers and optimize resource utilization effectively.

Option A (APM tools) may track performance but usually lack deep integration with Kubernetes cost allocation. Option C provides partial visibility but requires complex manual correlation of resource usage with billing data. Option D (cloud provider estimators) typically offer limited or high-level insights and do not map costs down to Kubernetes workloads.

By adopting OpenCost, platform teams can align financial accountability with engineering usage, a practice known as FinOps. This supports sustainable scaling, cost efficiency, and transparency—critical aspects of measuring platform success.