SaveMyCert
Log in
5 of 5 free questions left today·for 10 a day
KCNA · Domain 4

Cloud Native Architecture practice questions

Cloud Native Architecture is worth 12% of the KCNA exam — the lightest of the 4 domains. Observability, cloud-native principles and the CNCF ecosystem, and community collaboration. Official weighting 12%. 6 fully worked examples are further down this page, answers included.

Exam weight
12%
the lightest of the 4 domains
Questions
53
across 3 topics
Free, no account
5/day
a free account allows 10 a day
Explanations
Every option
right and wrong

Build a practice session

5 free questions left today.

Domains

How many?

5 free questions left today.

Mode

Ready when you are

10 fresh questions drawn across 1 of 4 domains, in Learn mode.

Review what you missed

Every question you answer incorrectly, and every question you flag while practising, is saved here automatically. Finish a session and you can come back to re-drill just those.

6 sample Cloud Native Architecture questions, fully explained

Questions from the KCNA bank mapped to domain 4, with the answer key and the reasoning behind every option. None of them repeat the examples on the main KCNA practice page.

Question 1Cloud Native Architecture

Checkout requests pass through five microservices, and some take 4 seconds. The team needs to see which service in the chain spends most of that time for an individual slow request. Which observability data answers this directly?

Choose one.

  • a
    Metrics

    Per-service latency metrics show averages and percentiles, but they cannot follow one specific request through the chain.

  • b
    Traces Correct

    Correct. A trace records one request end to end as timed spans, so the slow hop is visible in its timeline.

  • c
    Logs

    Each service's logs show what it saw locally; stitching one request together from them is slow and unreliable without trace IDs.

  • d
    Events

    Kubernetes Events report object changes such as Pod scheduling; they do not record request latency.

The concept

Distributed tracing follows a single request across service boundaries.

Why that’s the answer

A trace is the record of one request from end to end, made of spans: each span is a named, timed operation in one service. Spans nest into a timeline that shows where the milliseconds went. Metrics give aggregates across many requests, logs give per-service local detail, and Kubernetes Events describe object state changes, so none of them shows one request's path through the chain.

How to reason it out
  1. Notice the request crosses several services.
  2. Notice the need is about one individual request, not an average.
  3. Recall that traces break a request into timed spans per service.
  4. Choose traces.

Exam tip: One request across many services, and where its time went, is a job for traces.

Observability in Cloud Native: Metrics, Logs, and Traces — the lesson that teaches this.

Question 2Cloud Native Architecture

In its default configuration, how does Prometheus collect metrics from the applications running in a Kubernetes cluster?

Choose one.

  • a
    It scrapes an HTTP metrics endpoint on each discovered target at a set interval Correct

    Correct. Prometheus uses a pull model: it discovers targets (for example through Kubernetes service discovery) and scrapes their /metrics endpoints on a schedule.

  • b
    It receives samples that each application pushes to it through a message queue

    Prometheus has no message-queue ingestion. Its standard collection path is pulling from targets, not receiving pushed samples.

  • c
    It reads samples that the Pushgateway forwards to it from the applications

    The Pushgateway is an optional add-on for short-lived batch jobs, and even then Prometheus scrapes the Pushgateway. It is not the default path for all applications.

  • d
    It reads resource samples that the kubelet writes into the etcd datastore

    The kubelet does not write metrics into etcd, and Prometheus does not read etcd for metrics; etcd stores cluster object state.

The concept

Prometheus collects metrics with a pull model.

Why that’s the answer

Prometheus periodically scrapes HTTP endpoints, conventionally /metrics, exposed by each target in a simple text format, and in Kubernetes it finds those targets through service discovery as Pods come and go. The Pushgateway exists only for short-lived jobs that cannot be scraped, and Prometheus still pulls from it. There is no message-queue ingestion, and etcd holds cluster state, not metrics.

How to reason it out
  1. Recall Prometheus's defining design choice: pull, not push.
  2. Recognize the Pushgateway as an exception for batch jobs, itself scraped.
  3. Rule out etcd, which stores Kubernetes object state.
  4. Choose scraping HTTP endpoints on a schedule.

Exam tip: Prometheus pulls: it scrapes /metrics endpoints on discovered targets at an interval.

Observability in Cloud Native: Metrics, Logs, and Traces — the lesson that teaches this.

Question 3Cloud Native Architecture

A dashboard panel is defined by the expression rate(http_requests_total{job="checkout"}[5m]), which returns a per-second request rate from stored time series. Which tool evaluates this expression, and in which query language?

Choose one.

  • a
    Elasticsearch, as a Query DSL search

    Elasticsearch searches indexed documents with its JSON Query DSL; it does not evaluate metric-name-plus-label selectors with rate() over a range.

  • b
    Grafana Loki, as a LogQL query

    LogQL borrows PromQL's style, but a LogQL query starts from a log stream selector in braces, not from a metric name such as http_requests_total, and Loki stores logs, not scraped counters.

  • c
    Prometheus, as a PromQL query Correct

    Correct. A metric name with a label selector, a [5m] range and rate() is PromQL, evaluated by Prometheus over the time series it scraped.

  • d
    Grafana Tempo, as a TraceQL query

    TraceQL selects spans by their attributes inside traces; Tempo stores traces, not counters such as http_requests_total.

The concept

Prometheus data is queried with PromQL, which selects series by metric name and labels.

Why that’s the answer

Every Prometheus time series is identified by a metric name plus key-value labels. PromQL selects series by name and labels, takes a range such as [5m] and applies functions such as rate(), so rate(http_requests_total{job="checkout"}[5m]) is a per-second request rate evaluated by Prometheus. LogQL (Loki) looks similar but starts from a log stream selector, TraceQL (Tempo) selects spans in traces, and Elasticsearch uses its own JSON Query DSL.

How to reason it out
  1. Read the expression: a metric name, a label selector, a range and rate().
  2. Recognise that shape as a PromQL query over scraped time series.
  3. Separate it from look-alike languages for logs (LogQL) and traces (TraceQL).
  4. Choose Prometheus with PromQL.

Exam tip: Prometheus metrics are queried with PromQL; LogQL is for Loki logs, TraceQL for Tempo traces.

Observability in Cloud Native: Metrics, Logs, and Traces — the lesson that teaches this.

Question 4Cloud Native Architecture

A team runs a third-party database that does not expose metrics in the Prometheus format. They want Prometheus to scrape the database's internal statistics without changing the database itself. What should they deploy?

Choose one.

  • a
    Alertmanager, configured to read the database's statistics

    Alertmanager receives alerts that Prometheus has already fired and routes notifications; it does not collect metrics from anything.

  • b
    metrics-server, configured to read the database's statistics

    metrics-server only gathers current CPU and memory from kubelets for kubectl top and autoscaling; it cannot translate application statistics.

  • c
    An exporter that translates the database's statistics Correct

    Correct. An exporter reads the third-party system's statistics and exposes them on an endpoint in the Prometheus format for scraping.

  • d
    A Pushgateway that receives the database's statistics

    The Pushgateway accepts metrics pushed by short-lived jobs that already speak the Prometheus format; it does not read or translate a database's statistics.

The concept

Exporters bridge systems that do not natively speak the Prometheus format.

Why that’s the answer

An exporter is a standalone or sidecar process that reads a third-party system's own statistics and serves them on a /metrics endpoint in the Prometheus text format, so Prometheus can scrape them without any change to the system. Well-known examples are node_exporter for host metrics and kube-state-metrics for Kubernetes object state. Alertmanager routes alerts, metrics-server feeds kubectl top and the HPA, and the Pushgateway only holds metrics pushed by batch jobs.

How to reason it out
  1. Notice the target cannot be changed and does not speak the Prometheus format.
  2. Look for a component that translates into that format.
  3. Rule out alert routing, the resource Metrics API and batch-job push buffering.
  4. Choose an exporter.

Exam tip: No /metrics endpoint and no code changes? Put an exporter in front of it.

Observability in Cloud Native: Metrics, Logs, and Traces — the lesson that teaches this.

Question 5Cloud Native Architecture

During an outage, one Prometheus rule triggers separately for each of 40 Pods, and the on-call engineer receives 40 pages. The team wants these combined into one page, muted during planned maintenance and delivered to the on-call chat channel. Which component handles this?

Choose one.

  • a
    Alertmanager, receiving the firing alerts from Prometheus Correct

    Correct. Alertmanager receives alerts from Prometheus, then deduplicates, groups, silences and routes them to receivers such as chat, email or paging tools.

  • b
    A for: duration on the rule that Prometheus evaluates

    A for: duration only makes a rule wait until its condition has held for that long before firing. Each of the 40 Pods still fires its own alert, and nothing is grouped, silenced or routed.

  • c
    Grafana, charting the rule's series on a shared dashboard

    Grafana visualizes the data. It has its own alerting, but in the Prometheus stack described here grouping, silencing and routing Prometheus's alerts is Alertmanager's job.

  • d
    An exporter, exposing each Pod's statistics for scraping

    An exporter exposes a system's statistics for Prometheus to scrape; it sits before collection, not after a rule has fired.

The concept

Prometheus decides that something is wrong; Alertmanager decides who hears about it and how.

Why that’s the answer

Prometheus evaluates alerting rules written in PromQL and fires one alert per matching series, so 40 Pods give 40 alerts. Those alerts go to Alertmanager, a separate component that deduplicates them, groups related alerts into one notification, applies silences and inhibitions, and routes notifications to receivers such as chat, email or PagerDuty. A for: duration on the rule only delays firing until the condition persists; it does not merge or route anything. Exporters are on the collection side, and Grafana is the visualization layer.

How to reason it out
  1. Notice the work happens after the rule has fired.
  2. List the needs: grouping, muting during maintenance, routing to a receiver.
  3. Rule out the for: duration, which only delays firing per alert.
  4. Choose Alertmanager.

Exam tip: Prometheus fires alerts; Alertmanager groups, silences and routes them.

Observability in Cloud Native: Metrics, Logs, and Traces — the lesson that teaches this.

Question 6Cloud Native Architecture

A cluster administrator removes the metrics-server add-on to save resources. Which feature stops working as a result?

Choose one.

  • a
    Grafana dashboards charting Prometheus CPU data over weeks

    Grafana charts long-term CPU data from Prometheus, which scrapes its own targets (such as the kubelet's cAdvisor endpoint) and does not depend on metrics-server.

  • b
    kubectl logs streaming the output of a running container

    kubectl logs is served by the API server and the kubelet reading the container's log files; it does not use the Metrics API.

  • c
    Alertmanager routing of alerts that Prometheus has fired

    Alertmanager receives alerts from Prometheus; removing metrics-server does not affect that path.

  • d
    Horizontal Pod Autoscaler scaling Pods on CPU utilization Correct

    Correct. The Horizontal Pod Autoscaler reads current CPU and memory from the Metrics API that metrics-server implements, as does kubectl top, so CPU-based scaling stops working.

The concept

metrics-server implements the Kubernetes Metrics API used by kubectl top and the Horizontal Pod Autoscaler.

Why that’s the answer

metrics-server collects current CPU and memory usage for nodes and Pods from each kubelet and serves it through the Kubernetes Metrics API. Its consumers are kubectl top and the Horizontal Pod Autoscaler's resource-based scaling. kubectl logs reads container logs through the kubelet, and Prometheus, Grafana and Alertmanager form a separate pipeline that does not rely on metrics-server, even when it charts CPU.

How to reason it out
  1. Recall what metrics-server provides: the resource Metrics API.
  2. Recall its consumers: kubectl top and the HPA.
  3. Check that kubectl logs and the Prometheus stack get their data elsewhere.
  4. Choose HPA CPU-based scaling.

Exam tip: metrics-server feeds kubectl top and the HPA; Prometheus feeds dashboards and alerts; kubectl logs needs neither.

Observability in Cloud Native: Metrics, Logs, and Traces — the lesson that teaches this.

What KCNA domain 4 tests, topic by topic

The official exam guide breaks Cloud Native Architecture into 3 topics. The question bank follows the same split, so a weak topic shows up as a cluster of misses you can go back and read.

Published KCNA practice questions per topic in Cloud Native Architecture
TopicWhat it coversQuestions
ObservabilityOfficial KCNA competency (Cloud Native Architecture). Observability pillars — metrics, logs, and traces; Prometheus and the observability tooling landscape; and cost and performance monitoring.16
Cloud Native Ecosystem and PrinciplesOfficial KCNA competency. Cloud-native principles (autoscaling, serverless, microservices, immutability, declarative APIs) and the CNCF project and ecosystem landscape.16
Cloud Native Community and CollaborationOfficial KCNA competency. How the cloud-native community works: CNCF project maturity levels (Sandbox, Incubating, Graduated), governance, open-source collaboration, and the roles and personas in the ecosystem.21
Total53

Revise Cloud Native Architecture before you drill it

Other KCNA domains

Cloud Native Architecture: your questions

Cloud Native Architecture is domain 4 of the KCNA exam guide and carries 12% of the scored content — the lightest of the 4 domains. On a 60-question paper that works out to roughly 7 questions, though CNCF does not publish an exact per-domain count and individual exam forms vary.

Source

The domain weight and topic list on this page come from the official KCNA exam guide.