Ingress-NGINX

Overview

Ingress-NGINX Controller is a Kubernetes ingress controller that uses NGINX as a reverse proxy and load balancer. It provides a robust, high-performance solution for managing ingress traffic in Kubernetes clusters with advanced routing, SSL termination, and load balancing capabilities.

The Dash0 integration provides comprehensive observability for Ingress-NGINX Controller deployments using OpenTelemetry-native instrumentation for distributed tracing, and prometheus metrics plus access logs with trace correlation.

For more information, visit the Ingress-NGINX Controller Documentation.

Use Cases

Gain comprehensive visibility into your Ingress-NGINX Controller setup and optimize performance with the following observability features:

• Monitor Request Flows with Tracing: Visualize the complete lifecycle of requests from ingress through backend services. OpenTelemetry distributed tracing provides insights into latency, routing decisions, and upstream interactions—ideal for debugging complex traffic flows.
• Track Performance and Traffic Metrics: Collect real-time performance data including request rates, response times, error rates, connection states, and resource utilization across all ingress rules.
• Analyze Traffic Patterns with Access Logs: Record detailed information about incoming requests with trace correlation, enabling deep analysis of traffic patterns, error conditions, and performance bottlenecks.
• Monitor Resource Usage: Track memory consumption, connection states, and upstream health to ensure your ingress infrastructure operates efficiently.

Use this integration to monitor ingress traffic, debug routing issues, analyze performance patterns, and ensure your Kubernetes ingress layer operates reliably at scale.

Overview

Ingress-NGINX Controller includes built-in support for observability via OpenTelemetry metrics, distributed tracing, and structured access logs with trace correlation. This integration uses the recommended patterns of deploying an OpenTelemetry Collector in your cluster to collect telemetry from Ingress-NGINX Controller and forward it to Dash0.

For more details, refer to the Ingress-NGINX Controller OpenTelemetry Documentation.

Configure

Prerequisites

You'll need an OpenTelemetry Collector deployed in your cluster to collect telemetry from Ingress-NGINX Controller and forward it to Dash0.

For production environments, consider using one of these deployment methods:

• Dash0 operator for Kubernetes
• OpenTelemetry Operator for Kubernetes

• Helm Chart for The OpenTelemetry Collector

For a complete working example with collector configuration, see the Dash0 Ingress-NGINX Example.

Collecting Telemetry

Step 1: Create a values.yaml File

Configure Ingress-NGINX Controller to export metrics and traces to an OpenTelemetry Collector in your cluster by storing the following configuration in a values.yaml file:

Note:

• The collector handles authentication and forwards telemetry to Dash0
• Configure the otlp-collector-host to match your OpenTelemetry Collector service endpoint
• The custom log format includes trace_id and span_id for trace-logs correlation
• Prometheus metrics are exposed on port 10254 for collection by the OpenTelemetry Collector

This configuration enables:

• Metrics: Request rates, latencies, and connection metrics scraped by the OpenTelemetry Collector
• Tracing: Distributed traces for all ingress requests sent to the OpenTelemetry Collector via OTLP
• Access Logs: Structured logs with trace correlation written to stdout, collected by the OpenTelemetry Collector's filelog receiver

Step 2: Deploy Ingress-NGINX Controller with Helm

Install or upgrade Ingress-NGINX Controller using the official Helm chart:

This installs Ingress-NGINX Controller with the specified configuration to export observability data to Dash0.

Step 3: Configure OpenTelemetry Collector

Ensure your OpenTelemetry Collector is configured to:

1. Scrape Prometheus metrics from Ingress-NGINX Controller pods
2. Receive OTLP traces on port 4317
3. Collect logs from Ingress-NGINX Controller containers
4. Transform logs to extract trace context for correlation

For trace-logs correlation, configure a transform processor in your collector to parse trace_id and span_id from the log format.

What Gets Collected

Once deployed, Ingress-NGINX Controller will send telemetry to the OpenTelemetry Collector, which then forwards to Dash0:

• Metrics: Request rates, response durations, error rates, active connections, and resource usage
• Traces: HTTP request lifecycles through the ingress controller with full span details and upstream interactions
• Access Logs: logs with trace correlation for all ingress traffic

The OpenTelemetry Collector acts as a central aggregation point, handling authentication with Dash0 and providing additional processing capabilities like sampling, filtering, and trace-logs correlation.

For more details, refer to the Ingress-NGINX Controller Monitoring and OpenTelemetry documentation.

For a complete working example with Ingress-NGINX Controller, OpenTelemetry Collector, and demo applications, see the Dash0 Ingress-NGINX Example.