Free Linux Foundation PCA Exam 2026 Practice Materials Collection
PCA Exam Info and Free Practice Test All-in-One Exam Guide Feb-2026
NEW QUESTION # 17
What are the four golden signals of monitoring as defined by Google's SRE principles?
- A. Availability, Logging, Errors, Throughput
- B. Utilization, Load, Disk, Network
- C. Requests, CPU, Memory, Latency
- D. Traffic, Errors, Latency, Saturation
Answer: D
Explanation:
The Four 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.
NEW QUESTION # 18
Which of the following signal belongs to symptom-based alerting?
- A. Database memory utilization
- B. API latency
- C. Disk space
- D. CPU usage
Answer: B
Explanation:
Symptom-based alerting focuses on user-visible problems or service-impacting symptoms rather than low-level resource metrics. In Prometheus and Site Reliability Engineering (SRE) practices, alerts should signal conditions that affect users' experience - such as high latency, request failures, or service unavailability - instead of merely reflecting internal resource states.
Among the options, API latency directly represents the performance perceived by end users. If API response times increase, it immediately impacts user satisfaction and indicates a possible service degradation.
In contrast, metrics like disk space, CPU usage, or database memory utilization are cause-based metrics - they may correlate with problems but do not always translate into observable user impact.
Prometheus alerting best practices recommend alerting on symptoms (via RED metrics - Rate, Errors, Duration) while using cause-based metrics for deeper investigation and diagnosis, not for immediate paging alerts.
Reference:
Verified from Prometheus documentation - Alerting Best Practices, Symptom vs. Cause Alerting, and RED/USE Monitoring Principles sections.
NEW QUESTION # 19
Which PromQL statement returns the sum of all values of the metric node_memory_MemAvailable_bytes from 10 minutes ago?
- A. sum(node_memory_MemAvailable_bytes offset 10m)
- B. offset sum(node_memory_MemAvailable_bytes[10m])
- C. sum(node_memory_MemAvailable_bytes) offset 10m
- D. sum(node_memory_MemAvailable_bytes) setoff 10m
Answer: A
Explanation:
In PromQL, the offset modifier allows you to query metrics as they were at a past time relative to the current evaluation. To retrieve the value of node_memory_MemAvailable_bytes as it was 10 minutes ago, you place the offset keyword inside 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 to instant and range vector selectors, not to complete expressions.
Reference:
Verified from Prometheus documentation - PromQL Evaluation Modifiers: offset, Aggregation Operators, and Temporal Query Examples.
NEW QUESTION # 20
Which PromQL statement returns the average free bytes of the filesystems over the last hour?
- A. sum_over_time(node_filesystem_avail_bytes[1h])
- B. avg(node_filesystem_avail_bytes[1h])
- C. sum(node_filesystem_avail_bytes[1h])
- D. avg_over_time(node_filesystem_avail_bytes[1h])
Answer: D
Explanation:
The avg_over_time() function calculates the average value of a time series over a specified range vector. It is used to measure how a gauge metric (like available filesystem bytes) behaves over time rather than at a single instant.
For example:
avg_over_time(node_filesystem_avail_bytes[1h])
This query returns the average amount of available filesystem space observed across all samples within the last hour for each time series.
By contrast:
avg() performs aggregation across different series at a single point, not over time.
sum() and sum_over_time() compute totals rather than averages.
Thus, only avg_over_time() provides the correct temporal average.
Reference:
Extracted and verified from Prometheus documentation - Range Vector Functions, avg_over_time() Definition, and Working with Gauge Metrics Over Time sections.
NEW QUESTION # 21
How would you name a metric that tracks HTTP request duration?
- A. http_request_duration_seconds
- B. http_request_duration
- C. request_duration_seconds
- D. http.request_latency
Answer: A
Explanation:
According to Prometheus metric naming conventions, a metric name must clearly describe what is being measured and include a unit suffix that specifies the base unit of measurement, following SI standards. For durations, the suffix _seconds is mandatory.
Therefore, the correct and standards-compliant name for a metric tracking HTTP request duration is:
http_request_duration_seconds
This name communicates:
http_request → the subject being measured (HTTP requests),
duration → the aspect being measured (the latency or time taken),
_seconds → the unit of measurement (seconds).
This metric name typically corresponds to a histogram or summary, exposing submetrics such as _count, _sum, and _bucket. These represent the number of observations, total duration, and distribution across time buckets respectively.
Options A, B, and C fail to fully comply with Prometheus naming standards - they either omit the http_ prefix, use invalid separators (dots), or lack the required unit suffix.
Reference:
Verified from Prometheus documentation - Metric and Label Naming Conventions, Instrumentation Best Practices, and Histogram and Summary Metric Naming Patterns.
NEW QUESTION # 22
Given the metric prometheus_tsdb_lowest_timestamp_seconds, how do you know in which month the lowest timestamp of your Prometheus TSDB belongs?
- A. format_date(prometheus_tsdb_lowest_timestamp_seconds,"%M")
- B. (time() - prometheus_tsdb_lowest_timestamp_seconds) / 86400
- C. prometheus_tsdb_lowest_timestamp_seconds % month
- D. month(prometheus_tsdb_lowest_timestamp_seconds)
Answer: B
Explanation:
The metric prometheus_tsdb_lowest_timestamp_seconds provides the oldest stored sample timestamp in Prometheus's local TSDB (in Unix epoch seconds). To determine the age or approximate date of this timestamp, you compare it with the current 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 from seconds 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.
Reference:
Extracted and verified from Prometheus documentation - TSDB Internal Metrics, Time Functions in PromQL, and Using time() for Relative Calculations.
NEW QUESTION # 23
With the following metrics over the last 5 minutes:
up{instance="localhost"} 1 1 1 1 1
up{instance="server1"} 1 0 0 0 0
What does the following query return:
min_over_time(up[5m])
- A. {instance="localhost"} 1 {instance="server1"} 0
- B. {instance="server1"} 0
Answer: A
Explanation:
The min_over_time() function in PromQL returns the minimum sample value observed 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 therefore 1.
For up{instance="server1"}, the sequence is 1 0 0 0 0. The minimum observed value is 0.
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).
Reference:
Verified from Prometheus documentation - PromQL Range Vector Functions, min_over_time() definition, and up Metric Semantics sections.
NEW QUESTION # 24
Given the metric prometheus_tsdb_lowest_timestamp_seconds, how do you know in which month the lowest timestamp of your Prometheus TSDB belongs?
- A. format_date(prometheus_tsdb_lowest_timestamp_seconds,"%M")
- B. (time() - prometheus_tsdb_lowest_timestamp_seconds) / 86400
- C. prometheus_tsdb_lowest_timestamp_seconds % month
- D. month(prometheus_tsdb_lowest_timestamp_seconds)
Answer: B
Explanation:
The metric prometheus_tsdb_lowest_timestamp_seconds provides the oldest stored sample timestamp in Prometheus's local TSDB (in Unix epoch seconds). To determine the age or approximate date of this timestamp, you compare it with the current 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 from seconds 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.
Reference:
Extracted and verified from Prometheus documentation - TSDB Internal Metrics, Time Functions in PromQL, and Using time() for Relative Calculations.
NEW QUESTION # 25
How many metric types does Prometheus text format support?
- A. 0
- B. 1
- C. 2
- D. 3
Answer: A
Explanation:
Prometheus defines four core metric types in its official exposition format, which are: Counter, Gauge, Histogram, and Summary. These types represent the fundamental building blocks for expressing quantitative measurements of system performance, behavior, and state.
A Counter is a cumulative metric that only increases (e.g., number of requests served).
A Gauge represents a value that can go up and down, such as memory usage or temperature.
A Histogram samples observations (e.g., request durations) and counts them in configurable buckets, providing both counts and sum of observed values.
A Summary is similar to a histogram but provides quantile estimation over a sliding time window along with count and sum metrics.
These four types are the only officially supported metric types in the Prometheus text exposition format as defined by the Prometheus data model. Any additional metrics or custom naming conventions are built on top of these core types but do not constitute new types.
Reference:
Extracted and verified from Prometheus official documentation sections on Metric Types and Exposition Formats in the Prometheus study materials.
NEW QUESTION # 26
What should you do with counters that have labels?
- A. Save their state between application runs so you can restore their last value on startup.
- B. Investigate if you can move their label value inside their metric name to limit the number of labels.
- C. Make sure every counter with labels has an extra counter, aggregated, without labels.
- D. Instantiate them with their possible label values when creating them so they are exposed with a zero value.
Answer: D
Explanation:
Prometheus counters with labels can cause missing time series in queries if some label combinations have not yet been observed. To ensure visibility and continuity, the recommended best practice is to instantiate 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's ephemeral metric model.
Reference:
Verified from Prometheus documentation - Instrumentation Best Practices, Counters with Labels, and Avoid Missing Time Series by Initializing Metrics.
NEW QUESTION # 27
What is the name of the official *nix OS kernel metrics exporter?
- A. metrics_exporter
- B. node_exporter
- C. os_exporter
- D. Prometheus_exporter
Answer: B
Explanation:
The official Prometheus exporter for collecting system-level and kernel-related metrics from Linux and other UNIX-like operating systems is the Node Exporter.
The Node Exporter exposes hardware and OS metrics including CPU load, memory usage, disk I/O, network traffic, and kernel statistics. It is designed to provide host-level observability and serves data at the default endpoint :9100/metrics in the standard Prometheus exposition text format.
This exporter is part of the official Prometheus ecosystem and is widely deployed for infrastructure monitoring. None of the other listed options (Prometheus_exporter, metrics_exporter, or os_exporter) are official components of the Prometheus project.
Reference:
Verified from Prometheus documentation - Node Exporter Overview, System Metrics Collection, and Official Exporters List.
NEW QUESTION # 28
How do you configure the rule evaluation interval in Prometheus?
- A. You can configure the evaluation interval in the service discovery configuration and in the command-line flags.
- B. You can configure the evaluation interval in the scraping job configuration file and in the command-line flags.
- C. You can configure the evaluation interval in the global configuration file and in the rule configuration file.
- D. You can configure the evaluation interval in the Prometheus TSDB configuration file and in the rule configuration file.
Answer: C
Explanation:
Prometheus evaluates alerting and recording rules at a regular cadence determined by the evaluation_interval setting. This can be defined globally in the main Prometheus configuration file (prometheus.yml) under the global: section or overridden for specific rule groups in the rule configuration files.
The global evaluation_interval specifies how frequently Prometheus should execute all configured rules, while rule-specific intervals can fine-tune evaluation frequency for individual groups. For instance:
global:
evaluation_interval: 30s
This means Prometheus evaluates rules every 30 seconds unless a rule file specifies otherwise.
This parameter is distinct from scrape_interval, which governs metric collection frequency from targets. It has no relation to TSDB, service discovery, or command-line flags.
Reference:
Verified from Prometheus documentation - Configuration File Reference, Rule Evaluation and Recording Rules sections.
NEW QUESTION # 29
What does the increase() function do in PromQL?
- A. Returns the total sum of values in a vector.
- B. Returns the absolute increase in a counter over a specified range.
- C. Calculates the derivative of a gauge over time.
- D. Calculates the percentage increase of a counter over time.
Answer: B
Explanation:
The increase() function computes the total increase in a counter metric over 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 the absolute number of increments.
NEW QUESTION # 30
What does the evaluation_interval parameter in the Prometheus configuration control?
- A. How often Prometheus sends metrics to remote storage.
- B. How often Prometheus scrapes targets.
- C. How often Prometheus evaluates recording and alerting rules.
- D. How often Prometheus compacts the TSDB data blocks.
Answer: C
Explanation:
The evaluation_interval parameter defines how frequently Prometheus evaluates 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.
NEW QUESTION # 31
What is metamonitoring?
- A. Metamonitoring is monitoring social networks for end user complaints about quality of service.
- B. Metamonitoring is a monitoring that covers 100% of a service.
- C. Metamonitoring is the monitoring of non-IT systems.
- D. Metamonitoring is the monitoring of the monitoring infrastructure.
Answer: D
Explanation:
Metamonitoring refers to monitoring the monitoring system itself-ensuring that Prometheus, Alertmanager, exporters, and dashboards are functioning properly. In other words, it's the observability of your observability stack.
This practice helps detect issues such as:
Prometheus not scraping targets,
Alertmanager being unreachable,
Exporters not exposing data, or
Storage being full or corrupted.
Without metamonitoring, an outage in the monitoring system could go unnoticed, leaving operators blind to actual infrastructure problems. A common approach is to use a secondary Prometheus instance (or external monitoring service) to monitor the health metrics of the primary Prometheus and related components.
Reference:
Verified from Prometheus documentation - Monitoring Prometheus Itself, Operational Best Practices, and Reliability of the Monitoring Infrastructure.
NEW QUESTION # 32
Which of the following is a valid metric name?
- A. go_goroutines
- B. go.goroutines
- C. go routines
- D. 99_goroutines
Answer: A
Explanation:
According to Prometheus naming rules, metric names must match the regex [a-zA-Z_:][a-zA-Z0-9_:]*. This means metric names must begin with a letter, underscore, or colon, and can only contain letters, digits, and underscores thereafter.
The valid metric name among the options is go_goroutines, which follows all these rules. It starts with a letter (g), uses underscores to separate words, and contains only allowed characters.
By contrast:
go routines is invalid because it contains a space.
go.goroutines is invalid because it contains a dot (.), which is reserved for recording rule naming hierarchies, not metric identifiers.
99_goroutines is invalid because metric names cannot start with a number.
Following these conventions ensures compatibility with PromQL syntax and Prometheus' internal data model.
Reference:
Extracted from Prometheus documentation - Metric Naming Conventions and Data Model Rules sections.
NEW QUESTION # 33
How would you add text from the instance label to the alert's description for the following alert?
alert: InstanceDown
expr: up == 0
for: 5m
labels:
severity: page
annotations:
description: "Instance INSTANCE_NAME_HERE down"
- A. Use $metric.instance instead of INSTANCE_NAME_HERE
- B. Use $value.instance instead of INSTANCE_NAME_HERE
- C. Use $expr.instance instead of INSTANCE_NAME_HERE
- D. Use $labels.instance instead of INSTANCE_NAME_HERE
Answer: D
Explanation:
In Prometheus alerting rules, you can dynamically reference label values in annotations and labels using template variables. Each alert has access to its labels via the variable $labels, which allows direct insertion of label data into alert messages or descriptions.
To include the value of the instance label dynamically in the description, replace the placeholder INSTANCE_NAME_HERE with:
description: "Instance {{$labels.instance}} down"
or equivalently:
description: "Instance $labels.instance down"
Both forms are valid - the first follows Go templating syntax and is the recommended format.
This ensures that when the alert fires, the instance label (e.g., a hostname or IP) is automatically included in the message, producing outputs like:
Instance 192.168.1.15:9100 down
Options B, C, and D are invalid because $value, $expr, and $metric are not recognized context variables in alert templates.
Reference:
Verified from Prometheus documentation - Alerting Rules Configuration, Using Template Variables in Annotations and Labels, and Prometheus Templating Guide (Go Templates and $labels usage) sections.
NEW QUESTION # 34
What function calculates the tp-quantile from a histogram?
- A. avg_over_time()
- B. histogram()
- C. predict_linear()
- D. histogram_quantile()
Answer: D
Explanation:
In Prometheus, the histogram_quantile() function is specifically designed to compute quantiles (such as tp90, tp95, or tp99) from histogram bucket data. A histogram metric records cumulative bucket counts for observed values under specific thresholds (le label).
The function works by interpolating between buckets based on the target quantile. For example, to compute the 90th percentile latency from a histogram named http_request_duration_seconds_bucket, you would use:
histogram_quantile(0.9, sum(rate(http_request_duration_seconds_bucket[5m])) by (le)) Here, 0.9 represents the tp90 quantile, and rate() converts counter increments into per-second rates.
Other options are incorrect:
histogram() is not a valid PromQL function.
predict_linear() forecasts future values of a time series.
avg_over_time() computes a simple average over a time window, not quantiles.
Reference:
Verified from Prometheus documentation - PromQL Function: histogram_quantile(), Working with Histograms, and Quantile Calculation Details.
NEW QUESTION # 35
What does the rate() function in PromQL return?
- A. The number of samples in a range vector.
- B. The per-second rate of increase of a counter metric.
- C. The total increase of a counter over a range.
- D. The average of all values in a vector.
Answer: B
Explanation:
The rate() function calculates the average per-second rate of increase of a counter over the specified range. It smooths out short-term fluctuations and adjusts for counter resets.
Example:
rate(http_requests_total[5m])
returns the number of requests per second averaged over the last five minutes. This function is frequently used in dashboards and alerting expressions.
NEW QUESTION # 36
What is the difference between client libraries and exporters?
- A. Exporters are written in Go. Client libraries are written in many languages.
- B. Exporters and client libraries mean the same thing.
- C. Exporters expose metrics for scraping. Client libraries push metrics via Remote Write.
- D. Exporters run next to the services to monitor, and use client libraries internally.
Answer: D
Explanation:
The fundamental difference between Prometheus client libraries and exporters lies in how and where they are used.
Client libraries are integrated directly into the application's codebase. They allow developers to instrument their own code to define and expose custom metrics. Prometheus provides official client libraries for multiple languages, including Go, Java, Python, and Ruby.
Exporters, on the other hand, are standalone processes that run alongside the applications or systems they monitor. They use client libraries internally to collect and expose metrics from software that cannot be instrumented directly (e.g., operating systems, databases, or third-party services). Examples include the Node Exporter (for system metrics) and MySQL Exporter (for database metrics).
Thus, exporters are typically used for external systems, while client libraries are used for self-instrumented applications.
Reference:
Verified from Prometheus documentation - Writing Exporters, Client Libraries Overview, and Best Practices for Exporters and Instrumentation.
NEW QUESTION # 37
......
Linux Foundation PCA Exam Syllabus Topics:
| Topic | Details |
|---|---|
| Topic 1 |
|
| Topic 2 |
|
| Topic 3 |
|
| Topic 4 |
|
| Topic 5 |
|
Pass Linux Foundation PCA Actual Free Exam Q&As Updated Dump: https://www.practicematerial.com/PCA-exam-materials.html
Latest PCA Actual Free Exam Updated 62 Questions: https://drive.google.com/open?id=1IZwdqqbAunqIWImhWMCkPS6BBrZoRQDh
