PCA Exam Questions and Answers

Multiplication has higher precedence than addition.

PromQL follows standard arithmetic precedence, so multiplication and division bind more tightly than addition and subtraction. Thus in an expression mixing * and +, the multiplication is evaluated first, matching conventional mathematical ordering rather than strict left-to-right evaluation.

http_requests_total{environment!="production"}

The != operator is Prometheus's label matcher for inequality, so environment!="production" selects every time series of http_requests_total whose environment label holds any value other than production. This satisfies the stem's requirement to exclude production while retaining all other environments.

sum by (instance) (node_cpu_seconds_total)

The by (instance) modifier groups series by the instance label and sums each group's CPU counters, retaining instance while collapsing other labels such as cpu and mode. This satisfies the stem's requirement to aggregate across nodes yet keep instance.

on(...)

The `on(...)` modifier restricts matching to the labels you list, so vectors with differing label sets still pair up on that shared subset. Without it, Prometheus requires identical label sets for vector-to-vector binary operations, returning no results. This directly satisfies the stem's constraint of matching on common labels only.

Instant vector

An instant query evaluates at a single timestamp, so PromQL returns an instant vector holding one sample per matching series. This satisfies the stem's default behaviour, since a range vector only appears when the selector explicitly supplies a duration such as [5m].

histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m]))

histogram_quantile() estimates the 0.99 quantile from the le bucket series, and rate() over the 5m range converts cumulative bucket counters into per-second rates. This satisfies the constraint of computing the 99th percentile latency from a histogram rather than a summary.

route

The `route` block defines Alertmanager's routing tree, matching alerts to receivers by label. It satisfies the requirement to direct Slack notifications, since child routes inherit and override parent settings, with `receiver: slack` specified at the appropriate node. Without `route`, no alert reaches the Slack receiver.

YAML

Prometheus reads its main configuration from a YAML file, conventionally `prometheus.yml`, parsed at startup and on reload. This satisfies the stem's requirement for the native format of the primary config file, where scrape jobs, rule files and service discovery targets are declared.

A value and a timestamp

A sample is the smallest unit of data in the Prometheus model: a single float64 value paired with a millisecond-precision timestamp. A time series is an ordered sequence of such samples identified by its metric name and labels.

kubernetes_sd_configs

kubernetes_sd_configs is the service discovery block that queries the Kubernetes API for pods, services and endpoints. It supplies the role-based targets Prometheus needs to find pods labelled app=frontend, satisfying the discovery requirement in the stem.

Use the Pushgateway

The Pushgateway accepts metrics from short-lived jobs that Prometheus cannot reliably scrape within their 30-second lifetime. Because the batch job terminates before a scrape interval elapses, it must push its metrics to the Pushgateway, which retains them for Prometheus to collect afterwards.

Alertmanager

Alertmanager receives alerts pushed by Prometheus and handles their routing, grouping, inhibition and silencing before dispatching notifications to receivers such as email, Slack or PagerDuty. This satisfies the stem's requirement for the component managing notification delivery, since Prometheus itself only evaluates rules and fires alerts.

The memory overhead of storing time series with unique label sets.

Each unique label combination creates a distinct time series held in memory, so ephemeral pods with churning names, IDs or hashes generate vast numbers of short-lived series. This memory overhead, not scrape volume, is the dominant cardinality constraint in dynamic clusters.

Increasing metric cardinality.

Each distinct label combination creates a separate time series held in memory. With constant traffic but rising cardinality, new series accumulate faster than stale ones are garbage-collected, so memory grows linearly. This directly explains the symptom described in the stem.

The amount of queued work.

Saturation quantifies how full a resource is, typically expressed as queued work awaiting service, such as requests in a queue or threads waiting. It signals impending degradation before latency or errors appear, matching the Four Golden Signals definition the stem requests.

The job is too fast for HTTP polling.

A short-lived batch job may exit before Prometheus's next scrape interval, so its metrics endpoint disappears and the samples are never collected. This directly satisfies the stem's constraint: the job finishes in seconds, far quicker than typical polling, requiring a push gateway or similar mechanism instead.

Latency

Latency as a Golden Signal distinguishes successful-request duration from error duration, so you can break down response time by dependency. If external calls dominate the slow percentile, the latency originates outside the service, directly satisfying the need to isolate external-dependency causation.

It bypasses Prometheus's liveness check for the source.

Pushgateway accepts pushed metrics without verifying that the source service is still running, so Prometheus scrapes stale values indefinitely. This directly satisfies the stem's constraint: long-running services lose Prometheus's liveness detection, since the target's up metric reflects the gateway, not the actual service instance.

The 'for' field

The 'for' field requires the alert's condition to remain true for a specified duration before firing, so brief flapping spikes are ignored while sustained problems still alert. This suppresses transient noise without silencing the rule entirely, unlike inhibition or muting.

In the Prometheus TSDB

Recording rules evaluate their expression and write the resulting samples back into the Prometheus time-series database under the new metric name. The rule does not create a separate store; results persist in the TSDB alongside scraped metrics.

The alert is grouped under a null value

Alertmanager evaluates group_by labels against each alert's label set. A label absent from an incoming alert resolves to an empty string, so all alerts missing that label collapse into a single group keyed by a null value.

Use a Silence

A Silence matches alerts by label set and suppresses notifications for a defined time window, which maps directly onto a scheduled maintenance period. Unlike inhibition, which depends on another firing alert, a Silence is time-bounded and configured in advance, satisfying the maintenance-window constraint.

Inhibition rules

Inhibition rules suppress a target alert when a matching source alert is firing, using equal label matchers such as instance. This directly satisfies the stem's requirement to mute DiskSpaceLow while InstanceDown is active for the same host, which silences and routing cannot achieve.

Increase the evaluation_interval

Raising evaluation_interval lengthens the gap between rule evaluations, so each rule query executes less often and consumes proportionally less CPU. Recorded series remain written to storage, satisfying the constraint of keeping data available while cutting load.

Pushgateway

Pushgateway lets short-lived batch jobs push their metrics to an intermediary that Prometheus then scrapes, since the job terminates before a normal pull scrape can occur. This satisfies the stem's constraint of a job finishing before scraping.

Counter

A Counter is a monotonically increasing value that only goes up, resetting to zero on restart, which suits a cumulative request tally. Tracking requests received requires this monotonic behaviour, and rate() or increase() can then derive per-second rates.

Using high-cardinality labels

High-cardinality labels, such as unique user IDs or timestamps, create unbounded time series that inflate storage costs and slow PromQL queries. The stem asks what to avoid, and this directly violates the cardinality constraint that keeps custom metrics performant and cost-effective in Prometheus.

Prometheus Text Format

Prometheus scrapes metrics endpoints expecting the Prometheus Text Format, a line-based exposition syntax of metric name, optional labels and a sample value. A custom exporter emitting JSON, CSV or XML cannot be parsed by the scrape pipeline, so the text format satisfies the stem's scraping requirement.

http_2xx

The http_2xx module probes the endpoint and marks success only when the returned HTTP status code falls in the 2xx range, directly satisfying the requirement to check the status code. Other modules such as tcp_connect or icmp test reachability, not HTTP response codes.

Gauge

A gauge represents a value that can rise or fall arbitrarily, such as current memory usage, which fluctuates as a process allocates and releases memory. Counters and histograms cannot capture this instantaneous, bidirectional measurement correctly.