Demo OpenTelemetry Operator Auto Instrumentation

This walkthrough demonstrates how to enable automatic OpenTelemetry instrumentation for a Python Flask application using the OpenTelemetry Operator and Collector in Kubernetes. The operator can inject language-specific auto-instrumentation into pods so you don’t need to modify application code. What you’ll do:

Deploy an Instrumentation custom resource (CR) to configure auto-instrumentation.
Annotate a Deployment to opt the pod into Python auto-instrumentation.
Generate traffic and verify traces in Jaeger.

Prerequisites:

A Kubernetes cluster (e.g., kind, GKE, EKS).
OpenTelemetry Operator and an OpenTelemetry Collector deployed in the cluster.
A tracing backend such as Jaeger.

For operator installation and examples, see the OpenTelemetry operator docs: https://opentelemetry.io/docs/operator/

This image shows a screenshot of the OpenTelemetry documentation webpage, focusing on the installation and configuration of an OpenTelemetry Operator for Kubernetes. It includes sections on installing the operator, creating a collector, and configuring automatic instrumentation.

Sample Flask application (no manual instrumentation)

Save this Flask app as app.py (this example contains no OpenTelemetry code):

import time
import random
from flask import Flask

app = Flask(__name__)

@app.get("/")
def get_products():
    time.sleep(random.uniform(0.02, 0.08))
    return "Get All Products"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Because the app is uninstrumented, the operator will inject auto-instrumentation at pod startup.

Verify cluster components

Confirm nodes and that the Collector pod and operator are running:

kubectl get node -o wide
# Example output:
# NAME                   STATUS   ROLES           AGE   VERSION     INTERNAL-IP     EXTERNAL-IP   OS-IMAGE
# kind-control-plane     Ready    control-plane   56m   v1.23.1     192.168.97.3    <none>        Debian GNU/Linux 12 (bookworm)
# kind-worker            Ready    <none>          56m   v1.23.1     192.168.97.4    <none>        Debian GNU/Linux 12 (bookworm)
# kind-worker2           Ready    <none>          56m   v1.23.1     192.168.97.2    <none>        Debian GNU/Linux 12 (bookworm)

Create the Instrumentation CR

Create an Instrumentation resource to tell the operator:

which exporter endpoint to use (Collector HTTP OTLP/4318),
which context propagators to enable,
the sampling strategy.

Save as instrumentation.yaml:

apiVersion: opentelemetry.io/v1alpha1
kind: Instrumentation
metadata:
  name: python-instrumentation
spec:
  exporter:
    endpoint: http://my-collector-collector:4318
  propagators:
    - tracecontext
    - baggage
  sampler:
    type: parentbased_traceidratio
    argument: "1"

Key fields explained:

Field	Purpose	Example
`exporter.endpoint`	Collector HTTP endpoint where auto-instrumented telemetry is sent	`http://my-collector-collector:4318`
`propagators`	Context propagation formats to support	`tracecontext`, `baggage`
`sampler`	Sampling strategy for generated traces	`type: parentbased_traceidratio`, `argument: "1"` (sample 100%)

Apply the Instrumentation CR:

kubectl apply -f instrumentation.yaml
# Expected:
# instrumentation.opentelemetry.io/python-instrumentation created

Confirm pods (operator, Collector, Jaeger, app):

kubectl get pod
# Example output:
# NAME                                              READY   STATUS    RESTARTS   AGE
# jaeger-75f7bdcc4-srv6                             1/1     Running   0          58m
# my-collector-collector-dd46d98c-kpg4n             1/1     Running   0          5m7s
# my-opentelemetry-operator-77fcd668d-54258         2/2     Running   0          12m
# myapp-5d474bfa96-nz8c2                            1/1     Running   0          3m11s

Opt your Deployment into auto-instrumentation

To enable Python auto-instrumentation for a Deployment, add the annotation instrumentation.opentelemetry.io/inject-python: "true" to the pod template. You can also reference a specific Instrumentation CR by name (e.g., "python-instrumentation") or use cross-namespace format ("other-namespace/my-instrumentation").

Add instrumentation.opentelemetry.io/inject-python: "true" to your Deployment pod template to enable Python auto-instrumentation. You may also set the annotation value to the Instrumentation CR name to bind to a specific configuration.

The operator documentation lists language-specific annotation options for other runtimes as well.

The image shows a webpage from the OpenTelemetry documentation, focusing on adding annotations for automatic instrumentation in different programming languages. There is a sidebar for navigation and various options for language-specific configurations.

Deployment and Service (example)

Save this Deployment + Service as flask_deployment.yaml. It includes the Python injection annotation and exposes the app via a NodePort.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-api
spec:
  selector:
    matchLabels:
      app: myapp-api
  template:
    metadata:
      annotations:
        instrumentation.opentelemetry.io/inject-python: "true"
      labels:
        app: myapp-api
    spec:
      containers:
        - name: myapp
          image: sloppynetworks/traces-auto-py
          imagePullPolicy: Always
          ports:
            - containerPort: 5000
---
apiVersion: v1
kind: Service
metadata:
  name: myapp-api-service
  labels:
    app: myapp-api
spec:
  selector:
    app: myapp-api
  ports:
    - port: 5000
      targetPort: 5000
      nodePort: 30008
  type: NodePort

Apply the Deployment and Service:

kubectl apply -f flask_deployment.yaml
# Expected:
# deployment.apps/myapp-api created
# service/myapp-api-service created

Confirm the new pods are running:

kubectl get pod
# Example:
# NAME                                     READY   STATUS    RESTARTS   AGE
# jaeger-757fbdcc4-sr2v6                  1/1     Running   0          62m
# my-collector-collector-dd46d98c6-kpg4n  1/1     Running   0          9m38s
# my-opentelemetry-operator-77fcd686bd-54258   2/2     Running   0          17m
# myapp-5d474bf946-nz8c2                  1/1     Running   0          7m42s
# myapp-api-5ff7979564-vmhfl              1/1     Running   0          15s

Verify nodes:

kubectl get node -o wide
# Example:
# NAME                    STATUS   ROLES           AGE   VERSION         CONTAINER-RUNTIME
# kind-control-plane      Ready    control-plane   63m   v1.23.1        containerd://2.1.1
# kind-worker             Ready    <none>          63m   v1.23.1        containerd://2.1.1
# kind-worker2            Ready    <none>          63m   v1.23.1        containerd://2.1.1

Generate traffic and verify traces

Send a request to the service using a node IP and the NodePort (replace with your node IP):

curl 192.168.97.2:30008
# Expected:
# Get All Products

Because the operator injected the Python instrumentation and exported telemetry to the Collector, you should see traces for myapp-api in Jaeger. Open the Jaeger UI and refresh the traces list to locate recent traces for the service.

The image shows the Jaeger UI dashboard displaying search results for traces related to a service. It includes a timeline graph, trace details, and filtering options.

Click a trace to inspect attributes automatically added by the instrumentation—pod name, node name, replica set, service instance, HTTP attributes, and more.

The image shows a trace analysis interface displaying details of a GET request, including HTTP and process information in a structured format.

Summary

Steps recap:

Deploy the OpenTelemetry Operator and a Collector.
Create an Instrumentation CR that configures exporter, propagators, and sampler.
Annotate your Deployment pod template to enable language-specific auto-instrumentation.
Generate traffic and verify traces in your tracing backend (Jaeger/Zipkin).

Links and references

OpenTelemetry Operator docs: https://opentelemetry.io/docs/operator/
OpenTelemetry Python auto-instrumentation: https://opentelemetry.io/docs/instrumentation/python/
Jaeger UI: https://www.jaegertracing.io/

If you need help adapting this to another runtime (Java, Node.js, .NET), the operator supports language-specific annotations — see the Operator docs for details.

Watch Video

Practice Lab

Demo OpenTelemetry Operator

Internal Logs of the Collector

​Sample Flask application (no manual instrumentation)

​Verify cluster components

​Create the Instrumentation CR

​Opt your Deployment into auto-instrumentation

​Deployment and Service (example)

​Generate traffic and verify traces

​Summary

​Links and references

Watch Video

Practice Lab

Sample Flask application (no manual instrumentation)

Verify cluster components

Create the Instrumentation CR

Opt your Deployment into auto-instrumentation

Deployment and Service (example)

Generate traffic and verify traces

Summary

Links and references