[Apr-2026] Pass PCA Exam in First Attempt Updated PCA Exam Questions
Cloud & Containers Dumps PCA Exam for Full Questions - Exam Study Guide
NEW QUESTION # 21
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 # 22
What should you do with counters that have labels?
- A. Instantiate them with their possible label values when creating them so they are exposed with a zero value.
- B. Investigate if you can move their label value inside their metric name to limit the number of labels.
- C. Save their state between application runs so you can restore their last value on startup.
- D. Make sure every counter with labels has an extra counter, aggregated, without labels.
Answer: A
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 # 23
Which PromQL statement returns the sum of all values of the metric node_memory_MemAvailable_bytes from 10 minutes ago?
- A. offset sum(node_memory_MemAvailable_bytes[10m])
- B. sum(node_memory_MemAvailable_bytes) offset 10m
- C. sum(node_memory_MemAvailable_bytes) setoff 10m
- D. sum(node_memory_MemAvailable_bytes offset 10m)
Answer: D
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 # 24
What function calculates the tp-quantile from a histogram?
- A. predict_linear()
- B. avg_over_time()
- C. histogram()
- 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 # 25
What is an example of a single-target exporter?
- A. SNMP Exporter
- B. Node Exporter
- C. Blackbox Exporter
- D. Redis Exporter
Answer: D
Explanation:
A single-target exporter in Prometheus is designed to expose metrics for a specific service instance rather than multiple dynamic endpoints. The Redis Exporter is a prime example - it connects to one Redis server instance and exports its metrics (like memory usage, keyspace hits, or command statistics) to Prometheus.
By contrast, exporters like the SNMP Exporter and Blackbox Exporter can probe multiple targets dynamically, making them multi-target exporters. The Node Exporter, while often deployed per host, is considered a host-level exporter, not a true single-target one in configuration behavior.
The Redis Exporter is instrumented specifically for a single Redis endpoint per configuration, aligning it with Prometheus's single-target exporter definition. This design simplifies monitoring and avoids dynamic reconfiguration.
Reference:
Verified from Prometheus documentation and official exporter guidelines - Writing Exporters, Exporter Types, and Redis Exporter Overview sections.
NEW QUESTION # 26
How would you correctly name a metric that provides metadata information about the binary?
- A. app_build_info
- B. app_build
- C. app_build_desc
- D. app_metadata
Answer: A
Explanation:
The Prometheus naming convention for metrics that expose build or version information about an application binary uses the _info suffix. The standard pattern is:
<application>_build_info
This metric typically includes constant labels such as version, revision, branch, and goversion to describe the build environment.
For example:
app_build_info{version="1.2.3", revision="abc123", goversion="go1.22"} 1 This approach follows the official Prometheus instrumentation guidelines, where metrics ending in _info convey metadata or constant characteristics about the running process.
The other options do not conform to the Prometheus best practice of suffix-based semantic naming.
Reference:
Extracted and verified from Prometheus documentation - Metric Naming Conventions, Exposing Build Information, and Standard _info Metrics sections.
NEW QUESTION # 27
What does the evaluation_interval parameter in the Prometheus configuration control?
- A. How often Prometheus sends metrics to remote storage.
- B. How often Prometheus compacts the TSDB data blocks.
- C. How often Prometheus evaluates recording and alerting rules.
- D. How often Prometheus scrapes targets.
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 # 28
What are Inhibition rules?
- A. Inhibition rules mute a set of alerts when another matching alert is firing.
- B. Inhibition rules inject a new set of alerts when a matching alert is firing.
- C. Inhibition rules inspect alerts when a matching set of alerts is firing.
- D. Inhibition rules repeat a set of alerts when another matching alert is firing.
Answer: A
Explanation:
Inhibition rules in Prometheus's Alertmanager are used to suppress (mute) alerts that would otherwise be redundant when a higher-priority or related alert is already active. This feature helps avoid alert noise and ensures that operators focus on the root cause rather than multiple cascading symptoms.
For example, if a "DatacenterDown" alert is firing, inhibition rules can mute all "InstanceDown" alerts that share the same datacenter label, preventing redundant notifications. Inhibition is configured in the Alertmanager configuration file under the inhibit_rules section.
Each rule defines:
A source match (the alert that triggers inhibition),
A target match (the alert to mute), and
A match condition (labels that must be equal for inhibition to apply).
Only when the source alert is active are the target alerts silenced.
Reference:
Verified from Prometheus documentation - Alertmanager Configuration - Inhibition Rules, Alert Deduplication and Grouping, and Alert Routing Best Practices.
NEW QUESTION # 29
Which of the following is a valid metric name?
- A. go routines
- B. go_goroutines
- C. go.goroutines
- D. 99_goroutines
Answer: B
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 # 30
Which Prometheus component handles service discovery?
- A. Node Exporter
- B. Pushgateway
- C. Prometheus Server
- D. Alertmanager
Answer: C
Explanation:
The Prometheus Server is responsible for service discovery, which identifies the list of targets to scrape. It integrates with multiple service discovery mechanisms such as Kubernetes, Consul, EC2, and static configurations.
This allows Prometheus to automatically adapt to dynamic environments without manual reconfiguration.
NEW QUESTION # 31
How can you select all the up metrics whose instance label matches the regex fe-.*?
- A. up{instance=~"fe-.*"}
- B. up{instance="fe-.*"}
- C. up{instance=regexp(fe-.*)}
- D. up{instance~"fe-.*"}
Answer: A
Explanation:
PromQL supports regular expression matching for label values using the =~ operator. To select all time series whose label values match a given regex pattern, you use the syntax {label_name=~"regex"}.
In this case, to select all up metrics where the instance label begins with fe-, the correct query is:
up{instance=~"fe-.*"}
Explanation of operators:
= → exact match.
!= → not equal.
=~ → regex match.
!~ → regex not match.
Option D uses the correct =~ syntax. Options A and B use invalid PromQL syntax, and option C is almost correct but includes a misplaced extra quote style (~''), which would cause a parsing error.
Reference:
Verified from Prometheus documentation - Expression Language Data Selectors, Label Matchers, and Regular Expression Matching Rules.
NEW QUESTION # 32
Which Alertmanager feature prevents duplicate notifications from being sent?
- A. Grouping
- B. Deduplication
- C. Inhibition
- D. Silencing
Answer: B
Explanation:
Deduplication in Alertmanager ensures that identical alerts from multiple Prometheus servers or rule evaluations do not trigger duplicate notifications.
Alertmanager compares alerts based on their labels and fingerprints; if an alert with identical labels already exists, it merges or refreshes the existing one instead of creating a new notification.
This mechanism is essential in high-availability setups where multiple Prometheus instances monitor the same targets.
NEW QUESTION # 33
What is considered the best practice when working with alerting notifications?
- A. Minor alerts are as important as major alerts and should be treated with equal care.
- B. Have as many alerts as possible to catch minor problems before they become outages.
- C. Have as few alerts as possible by alerting only when symptoms might become externally visible.
- D. Make sure to generate alerts on every metric of every component of the stack.
Answer: C
Explanation:
The Prometheus alerting philosophy emphasizes signal over noise - meaning alerts should focus only on actionable and user-impacting issues. The best practice is to alert on symptoms that indicate potential or actual user-visible problems, not on every internal metric anomaly.
This approach reduces alert fatigue, avoids desensitizing operators, and ensures high-priority alerts get the attention they deserve. For example, alerting on "service unavailable" or "latency exceeding SLO" is more effective than alerting on "CPU above 80%" or "disk usage increasing," which may not directly affect users.
Option B correctly reflects this principle: keep alerts meaningful, few, and symptom-based. The other options contradict core best practices by promoting excessive or equal-weight alerting, which can overwhelm operations teams.
Reference:
Verified from Prometheus documentation - Alerting Best Practices, Alertmanager Design Philosophy, and Prometheus Monitoring and Reliability Engineering Principles.
NEW QUESTION # 34
Which PromQL expression computes the rate of API Server requests across the different cloud providers from the following metrics?
apiserver_request_total{job="kube-apiserver", instance="192.168.1.220:6443", cloud="aws"} 1 apiserver_request_total{job="kube-apiserver", instance="192.168.1.121:6443", cloud="gcloud"} 5
- A. rate(apiserver_request_total{job="kube-apiserver"}[5m]) by (cloud)
- B. sum by (cloud)(rate(apiserver_request_total{job="kube-apiserver"}[5m]))
- C. rate(sum by (cloud)(apiserver_request_total{job="kube-apiserver"})[5m])
- D. sum by (cloud) (apiserver_request_total{job="kube-apiserver"})
Answer: B
Explanation:
The rate() function computes the per-second increase of a counter metric over a specified range, while sum by (label) aggregates those rates across dimensions - in this case, the cloud label.
The correct query is:
sum by (cloud)(rate(apiserver_request_total{job="kube-apiserver"}[5m])) This expression:
Calculates the rate of increase in API requests per second for each instance.
Groups and sums those rates by cloud, giving the total request rate per cloud provider.
Option A incorrectly places by (cloud) after rate(), which is not valid syntax.
Option B returns raw counter totals (not rates).
Option D incorrectly applies rate() after aggregation, which distorts the calculation since rate() must operate on individual time series before aggregation.
Reference:
Verified from Prometheus documentation - rate() Function, Aggregation Operators, and Querying Counters Across Labels sections.
NEW QUESTION # 35
How would you name a metric that tracks HTTP request duration?
- A. http.request_latency
- B. http_request_duration_seconds
- C. request_duration_seconds
- D. http_request_duration
Answer: B
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 # 36
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. prometheus_tsdb_lowest_timestamp_seconds % month
- C. month(prometheus_tsdb_lowest_timestamp_seconds)
- D. (time() - prometheus_tsdb_lowest_timestamp_seconds) / 86400
Answer: D
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 # 37
What is a difference between a counter and a gauge?
- A. Counters have no labels while gauges can have many labels.
- B. Counters and gauges are different names for the same thing.
- C. Counters change value on each scrape and gauges remain static.
- D. Counters are only incremented, while gauges can go up and down.
Answer: D
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 # 38
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 $labels.instance instead of INSTANCE_NAME_HERE
- B. Use $metric.instance instead of INSTANCE_NAME_HERE
- C. Use $expr.instance instead of INSTANCE_NAME_HERE
- D. Use $value.instance instead of INSTANCE_NAME_HERE
Answer: A
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 # 39
......
Authentic Best resources for PCA Online Practice Exam: https://www.lead2passexam.com/Linux-Foundation/valid-PCA-exam-dumps.html
Get the superior quality PCA Dumps with explanations waiting just for you, get it now: https://drive.google.com/open?id=1UjK1bsokERdBk4Lok9Rh4QjXdNxWsGyt