Updated Mar-2026 PCA Free Exam Files Downloaded Instantly
Practice Exams and Training Solutions for Certifications
Linux Foundation PCA Exam Syllabus Topics:
| Topic | Details |
|---|---|
| Topic 1 |
|
| Topic 2 |
|
| Topic 3 |
|
| Topic 4 |
|
| Topic 5 |
|
NEW QUESTION # 14
Which field in alerting rules files indicates the time an alert needs to go from pending to firing state?
- A. interval
- B. duration
- C. timeout
- D. for
Answer: D
Explanation:
In Prometheus alerting rules, the for field specifies how long a condition must remain true continuously before the alert transitions from the pending to the firing state. This feature prevents transient spikes or brief metric fluctuations from triggering false alerts.
Example:
alert: HighRequestLatency
expr: http_request_duration_seconds_avg > 1
for: 5m
labels:
severity: warning
annotations:
description: "Request latency is above 1s for more than 5 minutes."
In this configuration, Prometheus evaluates the expression every rule evaluation cycle. The alert only fires if the condition (http_request_duration_seconds_avg > 1) remains true for 5 consecutive minutes. If it returns to normal before that duration, the alert resets and never fires.
This mechanism adds stability and noise reduction to alerting systems by ensuring only sustained issues generate notifications.
Reference:
Verified from Prometheus documentation - Alerting Rules Configuration Syntax, Pending vs. Firing States, and Best Practices for Alert Timing and Thresholds sections.
NEW QUESTION # 15
Which of the following is an invalid @ modifier expression?
- A. go_goroutines @ end()
- B. sum(http_requests_total{method="GET"} @ 1609746000)
- C. go_goroutines @ start()
- D. sum(http_requests_total{method="GET"}) @ 1609746000
Answer: B
Explanation:
The @ modifier in PromQL allows querying data as it existed at a specific point in time rather than the evaluation time. It can be applied after a selector or an entire expression, but the syntax rules are strict.
✅ go_goroutines @ start() → Valid; queries value at the start of the evaluation range.
✅ sum(http_requests_total{method="GET"}) @ 1609746000 → Valid; applies the modifier after the full expression.
✅ go_goroutines @ end() → Valid; queries value at the end of the evaluation range.
❌ sum(http_requests_total{method="GET"} @ 1609746000) → Invalid, because the @ modifier cannot appear inside the selector braces; it must appear after the selector or aggregation expression.
This invalid placement violates PromQL's syntax grammar for subquery and modifier ordering.
Reference:
Verified from Prometheus documentation - PromQL @ Modifier Syntax, Evaluation Modifiers, and PromQL Expression Grammar sections.
NEW QUESTION # 16
http_requests_total{verb="POST"} 30
http_requests_total{verb="GET"} 30
What is the issue with the metric family?
- A. Metric names are missing a prefix to indicate which application is exposing the query.
- B. The value represents two different things across the dimensions: code and verb.
- C. verb label content should be normalized to lowercase.
- D. Unit is missing in the http_requests_total metric name.
Answer: D
Explanation:
Prometheus metric naming best practices require that every metric name include a unit suffix that indicates the measurement type, where applicable. The unit should follow the base name, separated by an underscore, and must use base 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 a base unit of measurement (such as time, bytes, or duration). However, for event 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.
Reference:
Prometheus documentation - Metric and Label Naming Conventions, Instrumentation Best Practices, and Metric Type Naming (Counters, Gauges, and Units) sections.
NEW QUESTION # 17
How can you send metrics from your Prometheus setup to a remote system, e.g., for long-term storage?
- A. With "remote write"
- B. With "scraping"
- C. With S3 Buckets
- D. With "federation"
Answer: A
Explanation:
Prometheus provides a feature called Remote Write to 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.
Reference:
Extracted and verified from Prometheus documentation - Remote Write/Read APIs and Long-Term Storage Integrations sections.
NEW QUESTION # 18
Which Alertmanager feature allows you to temporarily stop notifications for a specific alert?
- A. Deduplication
- B. Grouping
- C. Silence
- D. Inhibition
Answer: C
Explanation:
The Silence feature in Alertmanager allows operators to mute specific alerts for a defined period. Each silence includes a matcher (labels), a creator, a comment, and an expiration time.
Silencing is useful during maintenance windows or known outages to prevent alert noise. Unlike inhibition, silences are manual and explicit.
NEW QUESTION # 19
What does the evaluation_interval parameter in the Prometheus configuration control?
- A. How often Prometheus evaluates recording and alerting rules.
- B. How often Prometheus sends metrics to remote storage.
- C. How often Prometheus scrapes targets.
- D. How often Prometheus compacts the TSDB data blocks.
Answer: A
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 # 20
Which of the following signals belongs to symptom-based alerting?
- A. Disk space
- B. Database availability
- C. API latency
- D. CPU usage
Answer: C
Explanation:
Symptom-based alerting focuses on detecting user-visible or service-impacting issues rather than internal resource states. Metrics like API latency, error rates, and availability directly 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 the RED (Rate, Errors, Duration) and USE (Utilization, Saturation, Errors) monitoring models promoted in Prometheus and SRE best practices.
Reference:
Verified from Prometheus documentation - Alerting Best Practices, Symptom vs. Cause Alerting, and RED/USE Monitoring Principles.
NEW QUESTION # 21
How do you configure the rule evaluation interval in Prometheus?
- A. You can configure the evaluation interval in the global configuration file and in the rule configuration file.
- B. You can configure the evaluation interval in the service discovery configuration and in the command-line flags.
- C. You can configure the evaluation interval in the scraping job configuration file and in the command-line flags.
- D. You can configure the evaluation interval in the Prometheus TSDB configuration file and in the rule configuration file.
Answer: A
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 # 22
Given the following Histogram metric data, how many requests took less than or equal to 0.1 seconds?
apiserver_request_duration_seconds_bucket{job="kube-apiserver", le="+Inf"} 3 apiserver_request_duration_seconds_bucket{job="kube-apiserver", le="0.05"} 0 apiserver_request_duration_seconds_bucket{job="kube-apiserver", le="0.1"} 1 apiserver_request_duration_seconds_bucket{job="kube-apiserver", le="1"} 3 apiserver_request_duration_seconds_count{job="kube-apiserver"} 3 apiserver_request_duration_seconds_sum{job="kube-apiserver"} 0.554003785
- A. 0
- B. 0.554003785
- C. 1
- D. 2
Answer: C
Explanation:
In Prometheus, histogram metrics use cumulative buckets to record the count of observations that fall within specific duration thresholds. Each bucket has a label le ("less than or equal to"), representing the upper bound of that bucket.
In the given metric, the bucket labeled le="0.1" has a value of 1, meaning exactly one request took less than or equal to 0.1 seconds. Buckets are cumulative, so:
le="0.05" → 0 requests ≤ 0.05 seconds
le="0.1" → 1 request ≤ 0.1 seconds
le="1" → 3 requests ≤ 1 second
le="+Inf" → all 3 requests total
The _sum and _count values represent total duration and request count respectively, but the number of requests below a given threshold is read directly from the bucket's le value.
Reference:
Verified from Prometheus documentation - Understanding Histograms and Summaries, Bucket Semantics, and Histogram Query Examples sections.
NEW QUESTION # 23
Given the metric prometheus_tsdb_lowest_timestamp_seconds, how do you know in which month the lowest timestamp of your Prometheus TSDB belongs?
- A. prometheus_tsdb_lowest_timestamp_seconds % month
- B. (time() - prometheus_tsdb_lowest_timestamp_seconds) / 86400
- C. month(prometheus_tsdb_lowest_timestamp_seconds)
- D. format_date(prometheus_tsdb_lowest_timestamp_seconds,"%M")
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 # 24
What does the increase() function do in PromQL?
- A. Calculates the derivative of a gauge over time.
- B. Returns the total sum of values in a vector.
- C. Returns the absolute increase in a counter over a specified range.
- D. Calculates the percentage increase of a counter over time.
Answer: C
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 # 25
What is the role of the Pushgateway in Prometheus?
- A. To visualize metrics in Grafana.
- B. To store metrics long-term for historical analysis.
- C. To receive metrics pushed by short-lived batch jobs for later scraping by Prometheus.
- D. To scrape short-lived targets directly.
Answer: C
Explanation:
The Pushgateway is a Prometheus component used to handle short-lived batch jobs that cannot be scraped directly. These jobs push their metrics to the Pushgateway, which then exposes them for Prometheus to scrape.
This ensures metrics persist beyond the job's lifetime. However, it's not designed for continuously running services, as metrics in the Pushgateway remain static until replaced.
NEW QUESTION # 26
What is the minimum requirement for an application to expose Prometheus metrics?
- A. It must be compiled for 64-bit architectures.
- B. It must run on Linux.
- C. It must be exposed to the Internet.
- D. It must be able to serve text over HTTP.
Answer: D
Explanation:
Prometheus collects metrics by scraping an HTTP endpoint exposed by the target application. Therefore, the only essential requirement for an application to expose metrics to Prometheus is that it serves metrics in the Prometheus text exposition format over HTTP.
This endpoint is conventionally available at /metrics and provides metrics in plain text format (e.g., Content-Type: text/plain; version=0.0.4). The application can run on any operating system, architecture, or network - as long as Prometheus can reach its endpoint.
It does not need to be Internet-accessible (it can be internal) and is not limited to Linux or any specific bitness.
Reference:
Verified from Prometheus documentation - Exposition Formats, Instrumenting Applications, and Target Scraping Requirements sections.
NEW QUESTION # 27
Which kind of metrics are associated with the function deriv()?
- A. Histograms
- B. Counters
- C. Summaries
- D. Gauges
Answer: D
Explanation:
The deriv() function in PromQL calculates the per-second derivative of a time series using linear regression over the provided time range. It estimates the instantaneous rate of change for metrics that can both increase and decrease - which are typically gauges.
Because counters can only increase (except when reset), rate() or increase() functions are more appropriate for them. deriv() is used to identify trends in fluctuating metrics like CPU temperature, memory utilization, or queue depth, where values rise and fall continuously.
In contrast, summaries and histograms consist of multiple sub-metrics (e.g., _count, _sum, _bucket) and are not directly suited for derivative calculation without decomposition.
Reference:
Extracted and verified from Prometheus documentation - PromQL Functions - deriv(), Understanding Rates and Derivatives, and Gauge Metric Examples.
NEW QUESTION # 28
What's "wrong" with the myapp_filG_uploads_total{userid=,,5123",status="failed"} metric?
- A. The userid should not be exposed as a label.
- B. The metric name should consist of dashes instead of underscores.
- C. The status should not be exposed as a label.
- D. The _total suffix should be omitted.
Answer: A
Explanation:
In Prometheus best practices, high-cardinality labels-especially those containing unique or user-specific identifiers-should be avoided. The metric myapp_filG_uploads_total{userid="5123",status="failed"} exposes the userid as a label, which is problematic. Each distinct value of a label generates a new time series in Prometheus. If there are thousands or millions of unique users, this would exponentially increase the number of time series, leading to cardinality explosion, degraded performance, and high memory usage.
The _total suffix is actually correct and required for counters, as per the Prometheus naming convention. The use of underscores in metric names is also correct, as Prometheus does not support dashes in metric identifiers. The status label, however, is perfectly valid because it typically has a low number of possible values (e.g., "success", "failed").
Reference:
Verified from Prometheus official documentation sections Instrumentation - Metric and Label Naming Best Practices and Writing Exporters.
NEW QUESTION # 29
What is a difference between a counter and a gauge?
- A. Counters and gauges are different names for the same thing.
- B. Counters are only incremented, while gauges can go up and down.
- C. Counters change value on each scrape and gauges remain static.
- D. Counters have no labels while gauges can have many labels.
Answer: B
Explanation:
The key difference between a counter and a gauge in Prometheus lies in how their values change over time. A counter is a cumulative metric that only increases-it resets to zero only when the process restarts. Counters are typically used for metrics like total requests served, bytes processed, or errors encountered. You can derive rates of change from counters using functions like rate() or increase() in PromQL.
A gauge, on the other hand, represents a metric that can go up and down. It measures values that fluctuate, such as CPU usage, memory consumption, temperature, or active session counts. Gauges provide a snapshot of current state rather than a cumulative total.
This distinction ensures proper interpretation of time-series trends and prevents misrepresentation of one-time or fluctuating values as cumulative metrics.
Reference:
Extracted and verified from Prometheus official documentation - Metric Types section explaining Counters and Gauges definitions and usage examples.
NEW QUESTION # 30
Given the metric prometheus_tsdb_lowest_timestamp_seconds, how do you know in which month the lowest timestamp of your Prometheus TSDB belongs?
- A. prometheus_tsdb_lowest_timestamp_seconds % month
- B. (time() - prometheus_tsdb_lowest_timestamp_seconds) / 86400
- C. month(prometheus_tsdb_lowest_timestamp_seconds)
- D. format_date(prometheus_tsdb_lowest_timestamp_seconds,"%M")
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 # 31
......
Q&As with Explanations Verified & Correct Answers: https://passitsure.itcertmagic.com/Linux-Foundation/real-PCA-exam-prep-dumps.html