CCNA Prometheus Fundamentals Questions

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.

`group_by` aggregates alerts sharing specified label values into a single notification, directly satisfying the stem's requirement to group alerts. It defines which labels Alertmanager uses to batch related alerts, reducing notification noise. Other labels merely route or match alerts rather than controlling aggregation.

A scrape fails when the target returns a non-2xx status, when the connection times out, or when the exposition body cannot be parsed. Invalid metric format breaks parsing, so the scrape is marked unsuccessful even though the HTTP request itself succeeded.

The Prometheus HTTP API exposes the `/api/v1/rules` endpoint, which returns currently configured alerting and recording rules, optionally filtered by type, rule name or group. This directly satisfies the stem's requirement to retrieve alert rules, distinguishing it from endpoints handling queries, targets or metadata.

dns_sd_configs performs DNS SRV or A record lookups to discover targets, refreshing them on a configurable interval. This satisfies the stem's valid discovery mechanism, since Prometheus supports it natively alongside static_configs, file_sd_configs and the cloud provider integrations.

Remote write streams samples to an external system such as Thanos or Cortex, whose object storage retains data far beyond the local TSDB's retention window. This satisfies the long-term storage requirement, since Prometheus's own disk is sized for weeks, not years.

The up metric is synthesised by Prometheus for every scrape, reporting 1 when the target responded and 0 otherwise. It satisfies the stem's constraint because it is added automatically to all scraped targets, independent of exporter-supplied metrics.

file_sd_configs makes Prometheus read target lists from JSON or YAML files on disk, refreshing them periodically without a restart. This satisfies the stem's constraint of discovering targets from a file rather than via API-based service discovery.

The rule_files directive lists the files Prometheus loads to evaluate alerting rules and recording rules. Alerting rules generate alerts sent to Alertmanager; recording rules precompute frequently used expressions into new time series, satisfying the need to define both rule types.

PromQL is Prometheus's native functional query language, used across the expression browser, HTTP API and alerting rules to select and aggregate time series. It satisfies the stem's requirement as the primary language for querying Prometheus data.

Prometheus's server process binds to TCP port 9090 by default, serving its web UI, HTTP API and metrics endpoint there. This is the port scraped for Prometheus's own self-metrics and the one exposed in the default --web.listen-address setting.

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 WAL stores data that hasn't been flushed to disk blocks yet.

Recording rules precompute expensive or frequently used PromQL expressions and store the results as new time series. Dashboards and alerts then query those precalculated series instead of re-evaluating heavy aggregations across raw data at request time, cutting query latency and load on Prometheus.

Memory scales with the number of distinct label-value series, so cardinality is the constraint. relabel_configs can drop or rewrite labels before ingestion, collapsing many series into fewer and directly cutting the stored time series that drive memory usage.

Tombstones record deleted time ranges within a series, letting Prometheus's TSDB skip those blocks during queries without immediately rewriting data on disk. This satisfies the stem's deletion-marking purpose: the series persists physically, but tombstoned intervals are excluded from reads until compaction removes them.

Each distinct dynamic URL parameter value creates its own label set, so cardinality scales with the number of unique parameter combinations. This satisfies the stem's requirement for a common high-cardinality source, since unbounded parameter variation multiplies time series far beyond a fixed label set.

Prometheus defaults its scrape interval to one minute when no explicit value is set, so a target without a custom `scrape_interval` is polled every 60 seconds. This satisfies the stem's request for the default, distinguishing it from shorter intervals such as 15s or 30s that must be configured manually.

Evaluating rules is a core Prometheus server responsibility: it periodically runs the alerting and recording rules loaded from rule_files, producing alerts and precomputed series. This sits alongside scraping and storing time series in the server's own duties.

Scrape intervals are set per job within `scrape_configs`, where each job's `scrape_interval` overrides the global default. This satisfies the stem's requirement to define the interval for a specific target, since targets are grouped under a job and inherit that job's interval unless individually relabelled.

The write-ahead log persists incoming samples to disk before they reach in-memory blocks, so a crash can be recovered by replaying it. This satisfies the durability requirement, unlike the head block, which is volatile until flushed.

The 'or' operator returns the union of two instant vectors, taking the left-hand series and adding any right-hand series whose label sets do not already match. 'and' and 'unless' perform intersection and complement instead, so they cannot produce a union.

Changing a metric's label set alters its identity, so Prometheus treats it as a distinct series rather than mutating the existing one. The original series stops receiving samples and a new time series begins under the modified labels, satisfying the stem's constraint that label changes during a metric's lifetime create separate series.

In Prometheus relabelling, `$1` references the first regex capture group, satisfying the `label_replace` requirement to extract and substitute a matched substring. The `replacement` field uses `$n` syntax, where `n` is the capture group index, so `$1` inserts the first parenthesised match into the target label.

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.

Prometheus retains scraped samples for 15 days by default, after which the oldest blocks are deleted. This satisfies the stem's constraint because no explicit retention flag is required; the default applies unless overridden via storage.tsdb.retention.time.

Pushgateway retains pushed metrics indefinitely, so stale series from terminated batch jobs persist until removed via the API or by deleting the entire group. This satisfies the scenario's requirement to identify genuine Pushgateway behaviour: unlike pull-based exporters, no scrape-based expiry or automatic garbage collection occurs.

When a scrape exceeds scrape_timeout, Prometheus aborts the HTTP request and records the target as down, incrementing up=0 and scrape failure metrics. The sample set is discarded, so the scrape is marked failed rather than partially ingested.

`rate()` calculates the per-second average rate of increase of a counter over a specified range, handling counter resets and extrapolating to the range boundaries. This directly satisfies the stem's requirement to convert a monotonically increasing counter into a per-second rate, unlike `irate()`, which uses only the last two samples.

Registering the metric with the OpenTelemetry meter provider creates the instrument the application emits values through, satisfying the requirement to expose a new metric. Without a registered instrument, recorded measurements have no defined name, type or unit, so no metric is exported to the backend.

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.

Running identical Prometheus instances in parallel satisfies the horizontal scaling requirement: each replica scrapes the same targets independently, so queries can be served by any instance and a failed replica does not lose data. This removes the single-node bottleneck without needing sharding or federation.

Gauge is a valid Prometheus metric type representing a value that can rise or fall arbitrarily, such as temperature or memory usage. It is one of the four core types alongside counter, histogram and summary, and supports functions like delta() and predict_linear().

scrape_interval is set in the global block of the Prometheus configuration file, establishing the default collection frequency for every scrape job. Individual jobs may override it, but the global value applies cluster-wide unless explicitly superseded.

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.

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 counter is monotonically increasing, so each received request increments it and never resets except on process restart. This satisfies the stem's request-counting requirement, letting rate() or increase() derive requests per second across any window.

The le label is attached by Prometheus when recording histogram buckets, encoding each bucket's upper bound. It forms part of the default ecosystem label set alongside job and instance, so it satisfies the stem's requirement for a standard ecosystem label.

An alert enters the inactive state when its expression evaluates to false, meaning no alert instance exists for that series. This satisfies the stem's requirement for a genuine Prometheus alert state, alongside pending and firing, as defined by the Prometheus alerting lifecycle.

Prometheus TSDB persists time-series samples in immutable `chunks` segment files, which hold compressed sample data for a fixed time window before being compacted. This satisfies the stem's requirement for a valid TSDB file type, since chunks are written directly by the head block and queried during reads.

Prometheus synthesises the up metric per scrape target, recording 1 when the scrape succeeds and 0 when it fails. It therefore reports reachability of each configured target, satisfying the stem's requirement to detect whether a target can be scraped.

route is a top-level Alertmanager block defining the routing tree that matches alerts by label and dispatches them to child routes or receivers. It is required for alert delivery, making it a valid configuration block.

absent() returns an empty vector when the given instant vector has samples, and returns a single-element vector with value 1 when the selector matches nothing, letting alerting rules fire on missing metrics such as a target that stopped reporting.

Running Prometheus as a container satisfies the portability constraint, packaging the server and its dependencies into a single image deployable via Docker or Kubernetes. Configuration and time-series data persist through mounted volumes, so the TSDB survives restarts. This decouples Prometheus from the host, enabling consistent deployment across environments.