Observability for Kubernetes and serverless is the practice of collecting metrics, logs and traces from containers, functions and the platform around them, so a team can ask why a failure is happening and not only see that it is. It matters most where many small services change independently and a fault cannot be reproduced on a laptop.
This page is for platform, DevOps and data engineering leads who run microservices on Kubernetes or functions on a serverless service. It covers the problem, the building blocks, how the solution is assembled, how observability differs from monitoring, where AI agents fit and what to check before you adopt it.
The OpenTelemetry observability primer describes observability as the ability to understand a system from the outside by asking questions about it, without knowing its internals. It defines telemetry as data emitted from a system and its behaviour, in the form of traces, metrics or logs. The use case on this page rests on four building blocks: monitoring, alerting and visualisation, distributed tracing infrastructure, and log aggregation and analytics.
Kubernetes and serverless suit these ideas because both split an application into small units. Microservices are the opposite of a monolith built all in one piece: each service is deployed and maintained on its own. That independence helps delivery and complicates diagnosis.
The use case describes a platform that monitors, logs, traces and visualises a big data cluster and Kubernetes, follows a real-time data pipeline and raises an alert when something critical happens in the cluster. It also produces cluster reports, such as HDFS quota, file counts and directory access, over a chosen time span. The primer says distributed tracing helps with behaviour that is hard to reproduce locally and calls it essential for distributed systems.
The page describes a reactive platform. The steps below pair its components with what the Kubernetes and AWS documentation say about emitting telemetry.
The page also calls for continuous security, compliance and automation across the integration, testing, deployment and delivery pipeline of cloud-native applications.
| Aspect | Reactive monitoring | Reactive observability |
|---|---|---|
| Core question | Is the system in the state we expect over time? | Why is it behaving this way? |
| Scope | Infrastructure, data pipeline and application or job levels | Granular insight into performance, with rich context |
| Failure modes | Conditions you already know to watch | Clarity into implicit failure modes (the primer's "unknown unknowns") |
| Debugging | A dashboard or alert points to a symptom | Information needed for debugging is generated on the fly |
Designing for this from the start is the idea behind Observability-Driven Development, and the data side is covered in our guide to Data Observability. You can also read more about Observability for Kubernetes and Serverless.
AI agents sit on top of telemetry, not in place of it. An agent can read correlated alerts, logs and traces, propose a likely cause and hand a person the next steps, or run a pre-approved runbook step. It is only as reliable as the signals it can read, which is why instrumentation comes first. ElixirClaw is XenonStack's AI agents computing platform.
To map one operational decision your agents make, and the telemetry and policy it depends on, book a Context Workshop. See what happens in the workshop.
Metrics, logs and traces. The OpenTelemetry primer describes metrics as aggregations over a period of time of numeric data, a log as a timestamped message emitted by services or other components, and traces as following requests across services.
Monitoring watches the state of a system over time at the infrastructure, pipeline and application levels. Observability adds granular, contextual insight so teams can work out why a failure is happening, including failure modes nobody planned for.
Kubernetes components expose metrics in Prometheus format, and containers can write logs to standard output. The Kubernetes documentation says the native functionality of a container engine is usually not enough for a complete logging solution, so teams add aggregation and analysis.
AWS Lambda sends function logs to CloudWatch Logs by default when the execution role allows it. Teams then add tracing and alerting so related events can be viewed together.
They can read correlated telemetry, suggest a cause and prepare or run approved remediation steps. They depend on good instrumentation and clear ownership of each alert.