OpsCanary
Learn/Kubernetes/Observability
Kubernetes

Observability

20 articles from official documentation

Foundational1 article
kubernetesobservabilityFoundational

KubeCon + CloudNativeCon 2026: Your Essential Guide to Salt Lake City

KubeCon + CloudNativeCon is the must-attend event for anyone in the cloud native ecosystem. With an All-Access Pass, you can dive deep into co-located events and network with industry leaders. Don't miss out on this chance to elevate your Kubernetes knowledge and skills.

  • →Understand the difference between the All-Access Pass and KubeCon + CloudNativeCon Only Pass.
  • →Plan to engage in co-located events for deeper insights into specific topics.
4 min read·CNCF Blog
Read article
Practitioner19 articles
kubernetesobservabilityPractitioner

Mastering Observability for AI Agents on Amazon EKS

Observability is crucial for understanding AI agent performance and costs in production. By leveraging LLM call traces and tool call spans, you can gain insights into your agents' behavior. This article dives into practical patterns for implementing observability on Amazon EKS.

  • →Implement LLM call traces to monitor model invocations and inference times.
  • →Use tool call spans to track inputs and outputs of LLM-selected tools.
5 min read·AWS Containers Blog
Read article
kubernetesobservabilityPractitioner

Kubernetes on Edge Day: Elevating Distributed Cloud Native Workloads

Kubernetes on Edge Day is back at KubeCon + CloudNativeCon North America 2026, and it’s crucial for engineers working with distributed systems. This event dives deep into observability and security, two pillars that are essential when managing cloud native workloads across various locations.

  • →Understand the importance of observability in distributed systems.
  • →Prioritize security for cloud native workloads across diverse environments.
4 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

From 40 Seconds to Under 10: Revolutionizing Incident Detection with OpenTelemetry, Kafka, and Flink

Incident detection can make or break your system's reliability. By leveraging OpenTelemetry, Apache Kafka, and Apache Flink, you can reduce detection times from 40 seconds to under 10. This article dives into the architecture that powers this transformation.

  • →Leverage OpenTelemetry for efficient metrics collection and monitoring.
  • →Utilize Apache Kafka for a robust event bus that filters and processes operational events.
5 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

Observability Day 2026: Bridging Gaps in Cloud Native Monitoring

Observability Day at KubeCon + CloudNativeCon North America 2026 is a must-attend for anyone serious about monitoring in Kubernetes environments. This event unites maintainers and practitioners to tackle the evolving challenges of observability, especially with the recent graduation of OpenTelemetry. Don't miss out on the chance to learn from the community and enhance your observability strategies.

  • →Attend Observability Day to connect with the CNCF observability community.
  • →Explore the implications of OpenTelemetry's graduation for your observability strategies.
5 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

Building a Unified NOC Dashboard for Amazon EKS with CloudWatch

Creating a single-pane NOC dashboard for your Amazon EKS cluster can streamline your monitoring and incident response. By leveraging OpenTelemetry Protocol (OTLP) to send Kubernetes metrics to CloudWatch, you can gain real-time insights into your applications and infrastructure.

  • →Use the OpenTelemetry Protocol (OTLP) to send Kubernetes metrics to CloudWatch.
  • →Install the CloudWatch Observability EKS add-on version 6.2.0 or later.
5 min read·AWS Containers Blog
Read article
kubernetesobservabilityPractitioner

Bridging the Operations Gap: Running Applications on Kubernetes

Deploying an application is just the beginning; keeping it running smoothly is where the real challenge lies. With Elastic Beanstalk's managed deployments and automatic rollback, you can ensure your application remains healthy and compliant. Dive in to learn how to leverage these features effectively.

  • →Utilize Elastic Beanstalk's managed deployments for automatic rollback on failed health checks.
  • →Leverage health monitoring and automated responses to maintain application uptime.
5 min read·AWS Containers Blog
Read article
kubernetesobservabilityPractitioner

OpenTelemetry Migration: Scaling Your Metrics Platform in Kubernetes

Migrating to OpenTelemetry can transform your metrics platform, but it’s not without its challenges. By replacing the gostatsd sidecar with an OTel Collector, you can drastically reduce data points while maintaining application compatibility. Dive in to learn how to make this transition smoothly.

  • →Replace the gostatsd sidecar with an OTel Collector distribution for seamless migration.
  • →Utilize the contrib loadbalancingexporter to hash by streamID for better data ingestion.
5 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

Kubernetes v1.37: Embrace Native Histograms for Better Metrics

Kubernetes v1.37 brings native histograms to beta, transforming how you handle metrics. Say goodbye to static user-defined buckets and hello to dynamic, exponential buckets that offer more flexibility and precision.

  • →Enable native histograms by setting the NativeHistograms feature gate.
  • →Configure BucketFactor to adjust the width of your histogram buckets.
5 min read·Kubernetes Blog
Read article
kubernetesobservabilityPractitioner

Seamless Distributed Tracing for CI Pipelines in Kubernetes

Unlock the power of distributed tracing in your CI pipelines without modifying a single workflow file. By leveraging an OpenTelemetry Collector with GitHub webhooks, you can transform workflow events into actionable OTLP spans effortlessly.

  • →Configure an OpenTelemetry Collector with the GitHub webhook to enable distributed tracing.
  • →Understand that `workflow_run` and `workflow_job` events are converted into OTLP spans.
5 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

OpenTelemetry Graduation: What Comes Next for Kubernetes Monitoring

OpenTelemetry's graduation marks a pivotal moment in observability, merging tracing, metrics, and logs into a unified framework. With standardized APIs and a robust Collector, it simplifies monitoring in Kubernetes environments. This article dives into what this means for your production systems.

  • →Understand OpenTelemetry's role in unifying tracing, metrics, and logs.
  • →Leverage standardized APIs for consistent instrumentation across languages.
5 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

Unlocking Observability in Kubernetes: From Metrics to Meaning

Observability is crucial for managing complex Kubernetes environments. By leveraging metrics, logs, and traces, you can transform raw data into actionable insights. Learn how to implement these signals effectively in your production systems.

  • →Implement metrics using Prometheus for efficient alerting and trend analysis.
  • →Utilize logs to provide detailed narratives of service events.
5 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

Kubernetes v1.37: Metrics API Stabilization and Its Impact

Kubernetes v1.37 has promoted the metrics.k8s.io API to stable, a crucial step for monitoring resource usage in your clusters. This API provides real-time CPU and memory metrics for nodes and Pods, enabling effective autoscaling and performance tuning.

  • →Utilize the metrics.k8s.io API for real-time CPU and memory metrics.
  • →Implement metrics-server or a compatible solution to access the v1 metrics API.
5 min read·Kubernetes Blog
Read article
kubernetesobservabilityPractitioner

The Lazy Developer’s Guide to Observing Your Code with OpenTelemetry

Observability is crucial for maintaining healthy applications, yet many developers shy away from it. With zero-code instrumentation, you can add observability without touching your source code. This guide will show you how to leverage OpenTelemetry effectively.

  • →Utilize zero-code instrumentation to avoid modifying your source code.
  • →Implement observability-driven development (ODD) to integrate observability into your coding practices.
5 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

Automating RCA at Scale: Mastering Multi-Signal Correlation in Kubernetes

Root Cause Analysis (RCA) can be a nightmare in cloud-native environments. Multi-signal correlation offers a structured approach to pinpoint issues by analyzing anomalies across various signals. This article dives into how this method works and what you need to implement it effectively.

  • →Utilize multi-signal correlation to treat RCA as a correlation problem across various signal types.
  • →Configure the sliding window to group anomalies effectively, typically set to plus or minus 5 minutes.
5 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

Solving Zero+Zero=Two in Mesh Observability

In the world of mesh observability, ensuring accurate trace propagation is crucial. When Envoy creates a new root span instead of continuing an existing trace, you end up with misleading telemetry. This article dives into how to configure OpenTelemetry and Istio to avoid this pitfall.

  • →Enable tracing in Envoy to ensure spans are generated correctly.
  • →Configure applications to emit B3 headers alongside W3C Trace Context headers.
5 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

Mastering Cloud-Native Engineering: The LFX Mentorship Advantage

Tired of tutorials that don’t translate to real-world scenarios? The LFX Mentorship offers a structured approach to learning cloud-native engineering, emphasizing observability as a critical pipeline. Dive into production-style environments and learn to tackle real system failures.

  • →Understand observability as a resilient pipeline designed to survive failures.
  • →Engage in a structured mentorship that emphasizes autonomy and independent problem-solving.
5 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

LitmusChaos in 2026: Community Growth and Project Milestones

Chaos engineering is crucial for resilient systems, and LitmusChaos is at the forefront of this movement. As a CNCF Incubating project, it empowers teams to identify weaknesses in their infrastructure through controlled chaos experiments. Discover how this platform is evolving and what it means for your Kubernetes deployments.

  • →Leverage LitmusChaos to identify infrastructure weaknesses through controlled chaos experiments.
  • →Engage with the growing community to share insights and best practices in chaos engineering.
5 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

Unlocking AI Agent Debugging: The Power of Observability

Debugging AI agents is impossible without clear visibility into their operations. By implementing detailed traces that capture every decision and cost, you can gain insights that drive performance. Discover how to leverage observability for effective AI agent management.

  • →Implement detailed traces to capture every decision history of your AI agents.
  • →Utilize Langfuse as your trace backend for structured and nested traces.
5 min read·CNCF Blog
Read article
kubernetesobservabilityPractitioner

Stop Your Kubernetes Health Checks from Waking Services: Here’s How

Kubernetes health checks can inadvertently trigger your services to scale up when they should remain idle. Learn how to leverage the ProbeResponse feature to manage health checks effectively and keep your services scaled to zero when not in use.

  • →Leverage the ProbeResponse feature to prevent unnecessary scaling of services.
  • →Define probe rules that match your health check paths accurately.
5 min read·CNCF Blog
Read article
Linux Foundation🔥 OCTOBER PROMOSponsor

35% off the CKA and other certifications with code OCT26NONCYBER, or 40% off Kubernetes security certs (CKS, KCSA) with OCT26CYBER.

Claim the discount →

Get the daily digest

One email. 5 articles. Every morning.

No spam. Unsubscribe anytime.