Real PCA Exam Questions are the Best Preparation Material
Practice on 2026 LATEST PCA Exam Updated 62 Questions
Linux Foundation PCA Exam Syllabus Topics:
| Topic | Details |
|---|---|
| Topic 1 |
|
| Topic 2 |
|
| Topic 3 |
|
| Topic 4 |
|
| Topic 5 |
|
NEW QUESTION # 17
When can you use the Grafana Heatmap panel?
- A. You can use it to graph a histogram metric.
- B. You can use it to graph an info metric.
- C. You can use it to graph a gauge metric.
- D. You can use it to graph a counter metric.
Answer: A
Explanation:
The Grafana Heatmap panel is best suited for visualizing histogram metrics collected from Prometheus. Histograms provide bucketed data distributions (e.g., request durations, response sizes), and the heatmap effectively displays these as a two-dimensional density chart over time.
In Prometheus, histogram metrics are exposed as multiple time series with the _bucket suffix and the label le (less than or equal). Grafana interprets these buckets to create visual bands showing how frequently different value ranges occurred.
Counters, gauges, and info metrics do not have bucketed distributions, so a heatmap would not produce meaningful output for them.
Reference:
Verified from Grafana documentation - Heatmap Panel Overview, Visualizing Prometheus Histograms, and Prometheus documentation - Understanding Histogram Buckets.
NEW QUESTION # 18
Which of the following metrics is unsuitable for a Prometheus setup?
- A. user_last_login_timestamp_seconds{email="[email protected]"}
- B. http_response_total{handler="static/*filepath"}
- C. promhttp_metric_handler_requests_total{code="500"}
- D. prometheus_engine_query_log_enabled
Answer: A
Explanation:
The metric user_last_login_timestamp_seconds{email="[email protected]"} is unsuitable for Prometheus because it includes a high-cardinality label (email). Each unique email address would generate a separate time series, potentially numbering in the millions, which severely impacts Prometheus performance and memory usage.
Prometheus is optimized for low- to medium-cardinality metrics that represent system-wide behavior rather than per-user data. High-cardinality metrics cause data explosion, complicating queries and overwhelming the storage engine.
By contrast, the other metrics-prometheus_engine_query_log_enabled, promhttp_metric_handler_requests_total{code="500"}, and http_response_total{handler="static/*filepath"}-adhere to Prometheus best practices. They represent operational or service-level metrics with limited, manageable label value sets.
Reference:
Extracted and verified from Prometheus documentation - Metric and Label Naming Best Practices, Cardinality Management, and Anti-Patterns for Metric Design sections.
NEW QUESTION # 19
What is metamonitoring?
- A. Metamonitoring is monitoring social networks for end user complaints about quality of service.
- B. Metamonitoring is the monitoring of the monitoring infrastructure.
- C. Metamonitoring is a monitoring that covers 100% of a service.
- D. Metamonitoring is the monitoring of non-IT systems.
Answer: B
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 # 20
Which kind of metrics are associated with the function deriv()?
- A. Counters
- B. Histograms
- C. Gauges
- D. Summaries
Answer: C
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 # 21
Where does Prometheus store its time series data by default?
- A. In an external database such as InfluxDB.
- B. In etcd.
- C. In-memory only.
- D. In an embedded TSDB on local disk.
Answer: D
Explanation:
By default, Prometheus stores its time series data in a local, embedded Time Series Database (TSDB) on disk. The data is organized in block files under the data/ directory inside Prometheus's storage path.
Each block typically covers two hours of data, containing chunks, index, and metadata files. Older blocks are compacted and deleted based on retention settings.
NEW QUESTION # 22
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) setoff 10m
- B. sum(node_memory_MemAvailable_bytes) offset 10m
- C. sum(node_memory_MemAvailable_bytes offset 10m)
- D. offset sum(node_memory_MemAvailable_bytes[10m])
Answer: C
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 # 23
What does the increase() function do in PromQL?
- A. Returns the absolute increase in a counter over a specified range.
- B. Calculates the derivative of a gauge over time.
- C. Calculates the percentage increase of a counter over time.
- D. Returns the total sum of values in a vector.
Answer: A
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 # 24
How do you calculate the average request duration during the last 5 minutes from a histogram or summary called http_request_duration_seconds?
- A. rate(http_request_duration_seconds_total[5m]) / rate(http_request_duration_seconds_average[5m])
- B. rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_average[5m])
- C. rate(http_request_duration_seconds_total[5m]) / rate(http_request_duration_second$_count[5m])
- D. rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_count[5m])
Answer: D
Explanation:
In Prometheus, histograms and summaries expose metrics with _sum and _count suffixes to represent total accumulated values and sample counts, respectively. To compute the average request duration over a given time window (for example, 5 minutes), you divide the rate of increase of _sum by the rate of increase of _count:
\text{Average duration} = \frac{\text{rate(http_request_duration_seconds_sum[5m])}}{\text{rate(http_request_duration_seconds_count[5m])}} Here,
http_request_duration_seconds_sum represents the total accumulated request time, and
http_request_duration_seconds_count represents the number of requests observed.
By dividing these rates, you obtain the average request duration per request over the specified time range.
Reference:
Extracted and verified from Prometheus documentation - Querying Histograms and Summaries, PromQL Rate Function, and Metric Naming Conventions sections.
NEW QUESTION # 25
What is api_http_requests_total in the following metric?
api_http_requests_total{method="POST", handler="/messages"}
- A. "api_http_requests_total" is a metric label name.
- B. "api_http_requests_total" is a metric name.
- C. "api_http_requests_total" is a metric field.
- D. "api_http_requests_total" is a metric type.
Answer: B
Explanation:
In Prometheus, the part before the curly braces {} represents the metric name. Therefore, in the metric api_http_requests_total{method="POST", handler="/messages"}, the term api_http_requests_total is the metric name. Metric names describe the specific quantity being measured - in this example, the total number of HTTP requests received by an API.
The portion within the braces defines labels, which provide additional dimensions to the metric. Here, method="POST" and handler="/messages" are labels describing request attributes. The metric name should follow Prometheus conventions: lowercase letters, numbers, and underscores only, and ending in _total for counters.
This naming scheme ensures clarity and standardization across instrumented applications. The metric type (e.g., counter, gauge) is declared separately in the exposition format, not within the metric name itself.
Reference:
Verified from Prometheus documentation - Metric and Label Naming, Data Model, and Instrumentation Best Practices sections.
NEW QUESTION # 26
What should you do with counters that have labels?
- A. Investigate if you can move their label value inside their metric name to limit the number of labels.
- B. Make sure every counter with labels has an extra counter, aggregated, without labels.
- C. Instantiate them with their possible label values when creating them so they are exposed with a zero value.
- D. Save their state between application runs so you can restore their last value on startup.
Answer: C
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 maximum number of Alertmanagers that can be added to a Prometheus instance?
- A. 0
- B. More than 3
- C. 1
- D. 2
Answer: B
Explanation:
Prometheus supports integration with multiple Alertmanager instances for redundancy and high availability. The alerting section of the Prometheus configuration file (prometheus.yml) allows specifying a list of Alertmanager targets, enabling Prometheus to send alerts to several Alertmanager nodes simultaneously.
There is no hard-coded limit on the number of Alertmanagers that can be added. The typical best practice is to run a minimum of three Alertmanagers in a clustered setup to achieve fault tolerance and ensure reliable alert delivery, but Prometheus can be configured with more than three if desired.
Each Alertmanager node in the cluster communicates state information (active, silenced, inhibited alerts) with its peers to maintain consistency.
Reference:
Verified from Prometheus documentation - Alertmanager Integration, High Availability Setup, and Prometheus Configuration - alerting Section.
NEW QUESTION # 28
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. rate(sum by (cloud)(apiserver_request_total{job="kube-apiserver"})[5m])
- C. sum by (cloud)(rate(apiserver_request_total{job="kube-apiserver"}[5m]))
- D. sum by (cloud) (apiserver_request_total{job="kube-apiserver"})
Answer: C
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 # 29
What is the difference between client libraries and exporters?
- A. Exporters are written in Go. Client libraries are written in many languages.
- B. Exporters expose metrics for scraping. Client libraries push metrics via Remote Write.
- C. Exporters run next to the services to monitor, and use client libraries internally.
- D. Exporters and client libraries mean the same thing.
Answer: C
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 # 30
What is an example of a single-target exporter?
- A. Node Exporter
- B. SNMP Exporter
- C. Redis Exporter
- D. Blackbox Exporter
Answer: C
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 # 31
How would you name a metric that measures gRPC response size?
- A. grpc_response_size_sum
- B. grpc_response_size_total
- C. grpc_response_size_bytes
- D. grpc_response_size
Answer: C
Explanation:
Following Prometheus's metric naming conventions, every metric should indicate:
What it measures (the quantity or event).
The unit of measurement in base SI units as a suffix.
Since the metric measures response size, the base unit is bytes. Therefore, the correct and compliant metric name is:
grpc_response_size_bytes
This clearly communicates that it measures gRPC response payload sizes expressed in bytes.
The _bytes suffix is the Prometheus-recommended unit indicator for data sizes. The other options violate naming rules:
_total is reserved for counters.
_sum is used internally by histograms or summaries.
Omitting the unit (grpc_response_size) is discouraged, as it reduces clarity.
Reference:
Extracted and verified from Prometheus documentation - Metric Naming Conventions, Instrumentation Best Practices, and Standard Units for Size and Time Measurements.
NEW QUESTION # 32
What are the four golden signals of monitoring as defined by Google's SRE principles?
- A. Traffic, Errors, Latency, Saturation
- B. Availability, Logging, Errors, Throughput
- C. Requests, CPU, Memory, Latency
- D. Utilization, Load, Disk, Network
Answer: A
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 # 33
......
Authentic PCA Exam Dumps PDF - Mar-2026 Updated: https://www.dumpsquestion.com/PCA-exam-dumps-collection.html
Download Latest PCA Dumps with Authentic Real Exam QA's: https://drive.google.com/open?id=1HuJLLCncjZvDir57VP0pTwG1JBvxAtg1