Linux Foundation Prometheus Certified Associate

Prometheus is a server that pulls numbers on a schedule and stores them as time series. You meet its parts, run it locally, and read your first data in the built-in web interface.

• The Prometheus server and its time series database
• Targets, scrapes and the up metric
• Exporters, the Pushgateway and Alertmanager
• Running Prometheus locally
• The web UI: targets, graph and status pages
• What Prometheus is not designed for

You build A local Prometheus scraping itself and one exporter, with notes on every page of the web UI.

Everything in Prometheus is a time series identified by a name and labels. You learn the four metric types, how labels create series, and why unbounded labels cause cardinality trouble.

• Samples, series and timestamps
• Metric names and label sets
• Counters and gauges
• Histograms and summaries
• Cardinality and why labels must be bounded
• Reading a series in the UI

You build A catalog of the series from one exporter, labeled by type with its cardinality estimated.

Prometheus learns what to scrape from its configuration. You write scrape jobs, set intervals and timeouts, discover targets automatically, reshape labels with relabeling, and recognize the limits of a single server.

• The configuration file and reloading it
• Scrape jobs, intervals and timeouts
• Static targets and file-based discovery
• Kubernetes and cloud service discovery
• Relabeling targets and metrics
• Limitations: retention, scale and high availability

You build A configuration that discovers targets by label and relabels them into a clean, consistent label scheme.

Anything that serves text in the right shape can be monitored. You read the exposition format by eye, check it with curl, and see how Prometheus parses types, help text and labels.

• The text exposition format
• HELP and TYPE lines
• Labels, escaping and sample values
• OpenMetrics in outline
• Checking an endpoint with curl and promtool
• Common format mistakes

You build A hand-written metrics endpoint that Prometheus scrapes, and a lint check that passes.

PromQL is how you ask questions of the data. You select series with matchers, work with instant and range vectors, and turn ever-growing counters into rates, increases and derivatives.

• Instant vectors, range vectors and scalars
• Label matchers and regular expressions
• Offsets and time windows
• rate, irate and increase
• Gauges: delta, deriv and predict_linear
• Why counters need rate

You build A set of queries giving request rate, error ratio and disk-fill prediction for a sample service.

Single series rarely answer the question. You aggregate over dimensions and over time, combine series with binary operators, and match them on labels, including one-to-many joins.

• sum, avg, min, max and count with by and without
• topk, bottomk and quantile
• Aggregating over time with the over_time functions
• Arithmetic and comparison operators
• Vector matching with on, ignoring and group_left
• Subqueries and when to avoid them

You build Queries that compute the error ratio per service and the top consumers across many instances.

Averages hide the slow requests that users remember. You read histogram buckets, compute quantiles with histogram_quantile, and learn when a summary or a histogram is the right choice.

• Buckets, counts and sums
• Computing quantiles with histogram_quantile
• Aggregating histograms across instances
• Choosing bucket boundaries
• Histograms compared with summaries
• Latency objectives as queries

You build A latency panel and an objective query built from one histogram, with bucket choices explained.

Useful monitoring starts in the application. You add metrics with a client library, follow the naming conventions, run exporters for systems you cannot change, and avoid label mistakes.

• Client libraries and the default registry
• Counters, gauges and histograms in code
• Naming: base units, suffixes and label discipline
• Node exporter for host metrics
• Other exporters and the blackbox exporter
• Textfile collection for batch jobs

You build A small service instrumented with a client library, plus an exporter for its database, both scraped.

An alert should tell a person something that needs doing. You write alerting and recording rules, then use Alertmanager to group, route, silence and suppress notifications.

• Alerting rules, thresholds and for durations
• Labels and annotations on alerts
• Recording rules for expensive queries
• Alertmanager routing trees and receivers
• Grouping, inhibition and silences
• Testing rules with promtool

You build Alerting and recording rules for a service, routed through Alertmanager to different receivers by severity.

Dashboards and alerts serve different moments. You build dashboards that answer the first question in an incident, and decide what to alert on, when and why, with symptoms ahead of causes.

• Dashboard basics: panels, variables and time ranges
• The RED and USE methods
• Alerting on symptoms rather than causes
• Reducing noise and alert fatigue
• Runbooks linked from alerts
• Reviewing alerts after an incident

You build A service dashboard and a short list of alerts, each with its reason and a linked runbook.

Take a service from no monitoring to a trusted one. You instrument it, scrape and discover it, write the queries that matter, set objectives, and alert on them, then review the result.

• Choosing indicators and objectives
• Instrumenting and scraping the service
• Writing queries and recording rules
• Building the dashboard and alerts
• Testing by breaking the service
• Reviewing gaps and noise

You build A monitored service with instrumentation, dashboards, objectives and tested alerts.