Exam Bundle

The investigation identifies the changed setting and a corrected configuration restores the expected app behavior. That observed result would support another specific correction: Inspect the effective mounted or environment configuration and revision history alongside application logs. The other scenario concerns: A crash occurs only after a recent ConfigMap update and a team blames the container image without comparing live configuration. The current Timberline Foods problem is: An app works within one Pod but fails through its Service and a trainee concludes the process must have crashed. The evidence required here is: The app remains Running while the fixed endpoint or port mapping restores Service-level client access.

The deployed release returns an expected response and related Pods report Ready, not merely Running. That observed result would support another specific correction: Combine workload status with a legitimate end-to-end probe through the application Service or entry point. The other scenario concerns: A team tests application health only through kubectl get and never checks whether the process is actually serving responses. The current Timberline Foods problem is: An app works within one Pod but fails through its Service and a trainee concludes the process must have crashed. The evidence required here is: The app remains Running while the fixed endpoint or port mapping restores Service-level client access.

The Pod is excluded from the Service until its required dependency is ready and then joins the endpoint set. That observed result would support another specific correction: Use a readiness check reflecting whether the Pod can currently serve legitimate requests and preserve liveness separately. The other scenario concerns: An application passes liveness checks yet its dependencies are unavailable and the release immediately receives normal traffic. The current Timberline Foods problem is: An app works within one Pod but fails through its Service and a trainee concludes the process must have crashed. The evidence required here is: The app remains Running while the fixed endpoint or port mapping restores Service-level client access.

Read previous container logs, state and exit codes to identify startup and crash diagnostics. That choice addresses a different foundational issue: A Kubernetes app crashes before emitting normal logs and a trainee assumes there is no way to inspect its last termination. The issue at Juniper Media is instead: A staging issue disappears after a Pod restart but the team closes it without preserving the logs and resource conditions. It does not establish the required correction; the decisive verification would be: The incident record contains traceable pre-restart evidence and a repeat test validates the actual corrective change.

Use rollout status, Deployment conditions and Pod events to isolate scheduling, image or readiness failures. That choice addresses a different foundational issue: A failed rollout reports a progress deadline but the engineer keeps running apply instead of inspecting deployment conditions. The issue at Juniper Media is instead: A staging issue disappears after a Pod restart but the team closes it without preserving the logs and resource conditions. It does not establish the required correction; the decisive verification would be: The incident record contains traceable pre-restart evidence and a repeat test validates the actual corrective change.

Use a readiness check reflecting whether the Pod can currently serve legitimate requests and preserve liveness separately. That choice addresses a different foundational issue: An application passes liveness checks yet its dependencies are unavailable and the release immediately receives normal traffic. The issue at Juniper Media is instead: A staging issue disappears after a Pod restart but the team closes it without preserving the logs and resource conditions. It does not establish the required correction; the decisive verification would be: The incident record contains traceable pre-restart evidence and a repeat test validates the actual corrective change.

The Service resolves to the intended new ready Pods and user requests reach the correct release. That observed result would support another specific correction: Compare Deployment Pod labels against Service selectors and the resulting EndpointSlices. The other scenario concerns: A release's Pods start but users receive errors because the Service selector still points to the previous version label. The current Juniper Media problem is: A staging issue disappears after a Pod restart but the team closes it without preserving the logs and resource conditions. The evidence required here is: The incident record contains traceable pre-restart evidence and a repeat test validates the actual corrective change.

The app remains Running while the fixed endpoint or port mapping restores Service-level client access. That observed result would support another specific correction: Check Service port mapping, ready endpoints, and permitted network paths separately from the container's health. The other scenario concerns: An app works within one Pod but fails through its Service and a trainee concludes the process must have crashed. The current Juniper Media problem is: A staging issue disappears after a Pod restart but the team closes it without preserving the logs and resource conditions. The evidence required here is: The incident record contains traceable pre-restart evidence and a repeat test validates the actual corrective change.

The investigation identifies the changed setting and a corrected configuration restores the expected app behavior. That observed result would support another specific correction: Inspect the effective mounted or environment configuration and revision history alongside application logs. The other scenario concerns: A crash occurs only after a recent ConfigMap update and a team blames the container image without comparing live configuration. The current Juniper Media problem is: A staging issue disappears after a Pod restart but the team closes it without preserving the logs and resource conditions. The evidence required here is: The incident record contains traceable pre-restart evidence and a repeat test validates the actual corrective change.

Inspect waiting container reasons, image pull status and application startup logs before modifying network exposure. That choice addresses a different foundational issue: A developer tries to debug a crash by changing Service type even though the Pod never starts its container. The issue at Meadowbrook Finance is instead: A staging issue disappears after a Pod restart but the team closes it without preserving the logs and resource conditions. It does not establish the required correction; the decisive verification would be: The incident record contains traceable pre-restart evidence and a repeat test validates the actual corrective change.

Use a readiness check reflecting whether the Pod can currently serve legitimate requests and preserve liveness separately. That choice addresses a different foundational issue: An application passes liveness checks yet its dependencies are unavailable and the release immediately receives normal traffic. The issue at Meadowbrook Finance is instead: A staging issue disappears after a Pod restart but the team closes it without preserving the logs and resource conditions. It does not establish the required correction; the decisive verification would be: The incident record contains traceable pre-restart evidence and a repeat test validates the actual corrective change.

Inspect the current rollout's Pods, conditions and per-container logs to identify the new version's failure. That choice addresses a different foundational issue: A new release fails readiness but developers only read the old version's logs and conclude the application is healthy. The issue at Meadowbrook Finance is instead: A staging issue disappears after a Pod restart but the team closes it without preserving the logs and resource conditions. It does not establish the required correction; the decisive verification would be: The incident record contains traceable pre-restart evidence and a repeat test validates the actual corrective change.

The Service resolves to the intended new ready Pods and user requests reach the correct release. That observed result would support another specific correction: Compare Deployment Pod labels against Service selectors and the resulting EndpointSlices. The other scenario concerns: A release's Pods start but users receive errors because the Service selector still points to the previous version label. The current Meadowbrook Finance problem is: A staging issue disappears after a Pod restart but the team closes it without preserving the logs and resource conditions. The evidence required here is: The incident record contains traceable pre-restart evidence and a repeat test validates the actual corrective change.

The Pod starts and completes initialization without any unnecessary external Service change. That observed result would support another specific correction: Inspect waiting container reasons, image pull status and application startup logs before modifying network exposure. The other scenario concerns: A developer tries to debug a crash by changing Service type even though the Pod never starts its container. The current Meadowbrook Finance problem is: A staging issue disappears after a Pod restart but the team closes it without preserving the logs and resource conditions. The evidence required here is: The incident record contains traceable pre-restart evidence and a repeat test validates the actual corrective change.

The investigation identifies the changed setting and a corrected configuration restores the expected app behavior. That observed result would support another specific correction: Inspect the effective mounted or environment configuration and revision history alongside application logs. The other scenario concerns: A crash occurs only after a recent ConfigMap update and a team blames the container image without comparing live configuration. The current Meadowbrook Finance problem is: A staging issue disappears after a Pod restart but the team closes it without preserving the logs and resource conditions. The evidence required here is: The incident record contains traceable pre-restart evidence and a repeat test validates the actual corrective change.

Expose the relevant metric through an approved instrumentation endpoint and retain it in a time-series monitoring backend. That choice addresses a different foundational issue: A metric is collected only by reading an ephemeral Pod's stdout and cannot support reliable trend analysis over a week. The issue at Eastshore Energy is instead: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. It does not establish the required correction; the decisive verification would be: A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes.

Use bounded-cardinality metric dimensions and keep per-request identifiers in logs or traces instead. That choice addresses a different foundational issue: A cluster team creates a separate high-cardinality metric label for each request ID and overwhelms time-series storage. The issue at Eastshore Energy is instead: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. It does not establish the required correction; the decisive verification would be: A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes.

Define a measurable SLI, its target over a time window as an SLO, and track the error budget against that target. That choice addresses a different foundational issue: A monitoring team defines an SLO as a chart title and cannot explain how to tell whether a reliability goal is met. The issue at Eastshore Energy is instead: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. It does not establish the required correction; the decisive verification would be: A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes.

A report links workload usage and allocated capacity to cost estimates without sacrificing required availability signals. That observed result would support another specific correction: Combine workload utilization and resource allocation signals with cost attribution to evaluate the capacity trade-off. The other scenario concerns: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. The current Eastshore Energy problem is: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. The evidence required here is: A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes.

A single trace connects the three service spans and its associated sanitized log events. That observed result would support another specific correction: Propagate trace context and correlation identifiers through the service chain using supported observability instrumentation. The other scenario concerns: A distributed request fails between three microservices and operators cannot match the separate service logs to one request. The current Eastshore Energy problem is: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. The evidence required here is: A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes.

The dashboard distinguishes replica churn from actual user-facing availability and latency regressions. That observed result would support another specific correction: Measure service-level indicators such as successful request rate and latency in addition to individual container restarts. The other scenario concerns: An operator declares an outage whenever one Pod restarts despite end-user traffic remaining healthy across other replicas. The current Eastshore Energy problem is: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. The evidence required here is: A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes.

Propagate trace context and correlation identifiers through the service chain using supported observability instrumentation. That choice addresses a different foundational issue: A distributed request fails between three microservices and operators cannot match the separate service logs to one request. The issue at Alpine Healthcare is instead: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. It does not establish the required correction; the decisive verification would be: A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes.

Use bounded-cardinality metric dimensions and keep per-request identifiers in logs or traces instead. That choice addresses a different foundational issue: A cluster team creates a separate high-cardinality metric label for each request ID and overwhelms time-series storage. The issue at Alpine Healthcare is instead: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. It does not establish the required correction; the decisive verification would be: A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes.

Combine workload utilization and resource allocation signals with cost attribution to evaluate the capacity trade-off. That choice addresses a different foundational issue: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. The issue at Alpine Healthcare is instead: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. It does not establish the required correction; the decisive verification would be: A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes.

A week-long service trend remains queryable even after individual Pods are replaced. That observed result would support another specific correction: Expose the relevant metric through an approved instrumentation endpoint and retain it in a time-series monitoring backend. The other scenario concerns: A metric is collected only by reading an ephemeral Pod's stdout and cannot support reliable trend analysis over a week. The current Alpine Healthcare problem is: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. The evidence required here is: A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes.

The dashboard distinguishes replica churn from actual user-facing availability and latency regressions. That observed result would support another specific correction: Measure service-level indicators such as successful request rate and latency in addition to individual container restarts. The other scenario concerns: An operator declares an outage whenever one Pod restarts despite end-user traffic remaining healthy across other replicas. The current Alpine Healthcare problem is: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. The evidence required here is: A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes.

A brief harmless spike no longer pages the on-call team while a sustained service failure still alerts. That observed result would support another specific correction: Define actionable alert conditions with suitable persistence and user-impact context rather than raw instantaneous spikes. The other scenario concerns: An alert sends a page to operators for every short-lived CPU peak even though no service impairment occurs. The current Alpine Healthcare problem is: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. The evidence required here is: A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes.

Combine workload utilization and resource allocation signals with cost attribution to evaluate the capacity trade-off. That choice addresses a different foundational issue: A project tracks application latency but ignores the cost impact of over-provisioned always-on replicas in a shared cluster. The issue at Brookside Manufacturing is instead: An engineer expects Prometheus to be a container runtime that schedules observability agents onto workers. It does not establish the required correction; the decisive verification would be: The architecture maps metric scraping to Prometheus and Pod scheduling to Kubernetes rather than treating them as one component.

Measure service-level indicators such as successful request rate and latency in addition to individual container restarts. That choice addresses a different foundational issue: An operator declares an outage whenever one Pod restarts despite end-user traffic remaining healthy across other replicas. The issue at Brookside Manufacturing is instead: An engineer expects Prometheus to be a container runtime that schedules observability agents onto workers. It does not establish the required correction; the decisive verification would be: The architecture maps metric scraping to Prometheus and Pod scheduling to Kubernetes rather than treating them as one component.

Use OpenTelemetry instrumentation and supported exporters to collect telemetry with backend-independent interfaces. That choice addresses a different foundational issue: A team treats OpenTelemetry as a proprietary replacement for every monitoring backend and locks telemetry to one vendor. The issue at Brookside Manufacturing is instead: An engineer expects Prometheus to be a container runtime that schedules observability agents onto workers. It does not establish the required correction; the decisive verification would be: The architecture maps metric scraping to Prometheus and Pod scheduling to Kubernetes rather than treating them as one component.

The dashboard distinguishes replica churn from actual user-facing availability and latency regressions. That observed result would support another specific correction: Measure service-level indicators such as successful request rate and latency in addition to individual container restarts. The other scenario concerns: An operator declares an outage whenever one Pod restarts despite end-user traffic remaining healthy across other replicas. The current Brookside Manufacturing problem is: An engineer expects Prometheus to be a container runtime that schedules observability agents onto workers. The evidence required here is: The architecture maps metric scraping to Prometheus and Pod scheduling to Kubernetes rather than treating them as one component.

A sample transaction is represented with a log event, latency metric and correlated trace without confusing their purposes. That observed result would support another specific correction: Distinguish discrete event logs, numeric time-series metrics and request-span traces for appropriate diagnostic questions. The other scenario concerns: A dashboard displays log lines and the team assumes logs, metrics, and distributed traces are interchangeable telemetry types. The current Brookside Manufacturing problem is: An engineer expects Prometheus to be a container runtime that schedules observability agents onto workers. The evidence required here is: The architecture maps metric scraping to Prometheus and Pod scheduling to Kubernetes rather than treating them as one component.

The same application instrumentation sends representative traces or metrics to an alternative approved backend. That observed result would support another specific correction: Use OpenTelemetry instrumentation and supported exporters to collect telemetry with backend-independent interfaces. The other scenario concerns: A team treats OpenTelemetry as a proprietary replacement for every monitoring backend and locks telemetry to one vendor. The current Brookside Manufacturing problem is: An engineer expects Prometheus to be a container runtime that schedules observability agents onto workers. The evidence required here is: The architecture maps metric scraping to Prometheus and Pod scheduling to Kubernetes rather than treating them as one component.