PCA Prometheus Certified Associate Exam Questions and Answers

In Prometheus, arule groupis a logical collection ofrecording and alerting rulesthat areevaluated sequentiallyat a specified interval. Rule groups are defined in YAML files under the groups: key, with each group containing a name, an interval, and a list of rules.

For example:

groups:

- name: example

interval: 1m

rules:

- record: job:http_inprogress_requests:sum

expr: sum(http_inprogress_requests) by (job)

All rules in a group share the same evaluation schedule and are executed one after another. This ensures deterministic order, especially when one rule depends on another’s result.

ThePrometheus Serveris responsible forservice discovery, which identifies the list of targets to scrape. It integrates with multiple service discovery mechanisms such as Kubernetes, Consul, EC2, and static configurations.

This allows Prometheus to automatically adapt to dynamic environments without manual reconfiguration.

The metric prometheus_tsdb_lowest_timestamp_seconds provides theoldest stored sample timestampin Prometheus’s local TSDB (in Unix epoch seconds). To determine theage or approximate dateof this timestamp, you compare it with thecurrent time(using time() in PromQL).

The expression:

(time() - prometheus_tsdb_lowest_timestamp_seconds) / 86400

converts the difference between the current time and the oldest timestamp fromseconds into days(1 day = 86,400 seconds). This gives the number of days since the earliest sample was stored, allowing you to infer the time range and approximate month manually.

The other options are invalid because PromQL does not support direct date formatting (format_date) or month() extraction functions.

TheFour Golden Signals—Traffic, Errors, Latency, and Saturation—are key service-level indicators defined by Google’s Site Reliability Engineering (SRE) discipline.

Traffic:Demand placed on the system (e.g., requests per second).

Errors:Rate of failed requests.

Latency:Time taken to serve requests.

Saturation:How “full” the system resources are (CPU, memory, etc.).

Prometheus and its metrics-based model are ideal for capturing these signals.

Prometheus provides a feature calledRemote Writeto transmit scraped and processed metrics to an external system for long-term storage, aggregation, or advanced analytics. When configured, Prometheus continuously pushes time series data to the remote endpoint defined in the remote_write section of the configuration file.

This mechanism is often used to integrate with long-term data storage backends such as Cortex, Thanos, Mimir, or InfluxDB, enabling durable retention and global query capabilities beyond Prometheus’s local time series database limits.

In contrast, “scraping” refers to data collection from targets, while “federation” allows hierarchical Prometheus setups (pulling metrics from other Prometheus instances) but does not serve as long-term storage. Using “S3 Buckets” directly is also unsupported in native Prometheus configurations.

Prometheus metric naming best practices require thatevery metric name include a unit suffixthat indicates the measurement type, where applicable. The unit should follow the base name, separated by an underscore, and must usebase SI units(for example, _seconds, _bytes, _total, etc.).

In the case of http_requests_total, while the metric correctly includes the _total suffix—indicating it is a counter—it lacks abase unit of measurement(such as time, bytes, or duration). However, forevent counters, _total is itself considered the unit, representing “total occurrences” of an event. Thus, the naming would be acceptable in strict Prometheus terms, but if this metric were measuring something like duration, size, or latency, then including a specific unit would be mandatory.

However, since the question implies that the missing unit is the issue and not the label schema, the expected answer aligns with ensuring metric names convey measurable units when applicable.

In PromQL, theoffset modifierallows you to query metricsas they were at a past timerelative to the current evaluation. To retrieve the value of node_memory_MemAvailable_bytes as it was10 minutes ago, you place the offset keywordinside the aggregation function’s argument, not after it.

The correct query is:

sum(node_memory_MemAvailable_bytes offset 10m)

This computes the total available memory across all instances, based on data from exactly 10 minutes in the past.

Placing offset after the aggregation (as in option B) is syntactically invalid because modifiers apply toinstant and range vector selectors, not to complete expressions.

Therate()function computes theper-second increaseof a counter metric over a specified range, whilesum by (label)aggregates those rates across dimensions — in this case, the cloud label.

The correct query is:

sum by (cloud)(rate(apiserver_request_total{job="kube-apiserver"}[5m]))

This expression:

Calculates the rate of increase in API requests per second for each instance.

Groups and sums those rates by cloud, giving the total request rate per cloud provider.

Option A incorrectly places by (cloud) after rate(), which is not valid syntax.

Option B returns raw counter totals (not rates).

Option D incorrectly applies rate() after aggregation, which distorts the calculation since rate() must operate on individual time series before aggregation.

Prometheus requires that asingle metric name represents one well-defined thing, and all time series in that metricshare the same set of label keysso the value’s meaning is consistent across dimensions. The official guidance states that metrics should not “mix different dimensions under the same name,” and that a metric name should have aconsistent label schema; otherwise, “the same metric name would represent different things,” making queries ambiguous and aggregations error-prone. In the example, http_requests_total{code="…"} expressesper-status-code request counts, while http_requests_total{verb="…"} expressesper-HTTP-method request counts. Because some series have only code and others only verb, thevalue changes its meaning across label sets, violating the consistency principle for a metric family. The correct approach is to exposeone metric with both labels present on every series, e.g., http_requests_total{code="200", method="GET"}, ensuring every time series has the same label keys and the value always means “count of requests,” sliced by thesamedimensions. A missing application prefix is optional and not the core issue here.

Symptom-based alertingfocuses on detectinguser-visible or service-impacting issuesrather than internal resource states. Metrics likeAPI latency,error rates, andavailabilitydirectly indicate degraded user experience and are therefore the preferred triggers for alerts.

In contrast,resource-based alerts(like CPU usage or disk space) often represent underlying causes, not symptoms. Alerting on them can produce noise and distract from actual service health problems.

For example, high API latency (http_request_duration_seconds) clearly reflects that users are experiencing delays, which is actionable and business-relevant.

This concept aligns with theRED(Rate, Errors, Duration) andUSE(Utilization, Saturation, Errors) monitoring models promoted in Prometheus and SRE best practices.

In Prometheus, when you have multiple time series that represent the same type of measurement across different instances, thesum() aggregation operatoris used to compute their total value.

Here, each instance (1 and 2) exposes the metric apiserver_current_inflight_requests, indicating the number of active API requests currently being processed.

To find thetotal number of in-flight requests across all instances, the correct expression is:

sum(apiserver_current_inflight_requests)

This returns 5 + 7 = 12.

min() would return the lowest value (5).

max() would return the highest value (7).

sum_over_time() calculates the cumulative sumover a range vector, not the current value, so it’s incorrect here.

Theevaluation_intervalparameter defines how frequently Prometheusevaluates its recording and alerting rules. It determines the schedule at which the rule engine runs, checking whether alert conditions are met and generating new time series for recording rules.

For example, setting:

global:

evaluation_interval: 30s

means Prometheus evaluates all configured rules every 30 seconds. This setting differs from scrape_interval, which controls how often Prometheus collects data from targets.

Having a proper evaluation interval ensures alerting latency is balanced with system performance.

Theincrease()function computes thetotal increase in a counter metricover a specified range vector. It accounts for counter resets and only measures the net change in the counter’s value during the time window.

Example:

increase(http_requests_total[5m])

This query returns how many HTTP requests occurred in the last five minutes. Unlike rate(), which provides a per-second average rate, increase() gives theabsolute number of increments.

Themin_over_time()function in PromQL returns theminimum sample valueobserved within the specified time range for each time series.

In the given data:

For up{instance="localhost"}, all samples are 1. The minimum value over 5 minutes is therefore1.

For up{instance="server1"}, the sequence is 1 0 0 0 0. The minimum observed value is0.

Thus, the query min_over_time(up[5m]) returns two series — one per instance:

{instance="localhost"} 1

{instance="server1"} 0

This query is commonly used to check uptime consistency. If the minimum value over the time window is 0, it indicates at least one scrape failure (target down).

Prometheus counters with labels can causemissing time seriesin queries if some label combinations have not yet been observed. To ensure visibility and continuity, therecommended best practiceis toinstantiate counters with all expected label values at application startup, even if their initial value is zero.

This ensures that every possible labeled time series is exported consistently, which helps when dashboards or alerting rules expect the presence of those series. For example, if a counter like http_requests_total{method="POST",status="200"} has not yet received a POST request, initializing it with a zero ensures it is still exposed.

Option A is incorrect — label values should never be encoded into metric names.

Option B adds redundancy and does not solve the initialization issue.

Option D is discouraged; counters should reset naturally upon restart, reflecting Prometheus’sephemeral metric model.