Nutzung von OpenTelemetry zur Verbesserung von Ansible mit Jaeger-Tracing

Nutzung von OpenTelemetry zur Verbesserung von Ansible mit Jaeger-Tracing

In den komplexen IT-Umgebungen von heute stehen Systemadministratoren und DevOps-Teams ständig vor der Herausforderung, verteilte Systeme effizient zu verwalten und Fehler zu beheben. Ansible, ein leistungsstarkes Automatisierungstool, vereinfacht viele Aspekte des Konfigurationsmanagements und der Orchestrierung. Mit zunehmender Größe und Komplexität der Infrastrukturen wird es jedoch immer wichtiger, tiefere Einblicke in die Ansible-Operationen zu gewinnen, um die Leistung zu optimieren und Fehler zu beheben.

An dieser Stelle kommen OpenTelemetry und Jaeger ins Spiel. In diesem Blogbeitrag erfahren Sie, warum das Senden von Traces aus Ansible über OpenTelemetry an Jaeger für Ihre Automatisierungsprozesse von großem Nutzen sein und wie es umgesetzt werden kann.

Verstehen der Grundlagen

Bevor wir uns mit den Vorteilen befassen, sollten wir einige grundlegende Konzepte klären:

• Ansible: Ansible ist eine Open-Source-Automatisierungsplattform, mit der wir Aufgaben wie Softwarebereitstellung, Konfigurationsmanagement und Deployment von Anwendungen automatisieren können. Sie verwendet YAML-basierte Playbooks, um Automatisierungsaufgaben zu definieren.
• OpenTelemetry: OpenTelemetry ist ein Satz von APIs, Bibliotheken, Agents und Instrumentierungen zur Bereitstellung von Observability in unseren Anwendungen. Es ermöglicht uns, distributed Traces, Metriken und Logs unserer Services zu sammeln und zu exportieren.
• Jaeger: Jaeger ist ein Open-Source-System für distributed End-to-End-Tracing, das uns hilft, komplexe Microservices-basierte Architekturen effektiv zu überwachen und Fehler zu beheben.

Sehen wir uns nun an, warum die Kombination von Ansible mit OpenTelemetry und Jaeger sinnvoll ist.

1. Granulare Sichtbarkeit Automatisierungsprozesse, insbesondere in großen Umgebungen, umfassen oft mehrere Ansible-Rollen, Playbooks und Aufgaben, die auf verschiedenen Hosts ausgeführt werden. Die Verfolgung des Ausführungsflusses und die Identifizierung von Engpässen oder Problemen kann ohne angemessene Observability eine Herausforderung darstellen. Durch die Integration von OpenTelemetry erhalten wir einen detaillierten Einblick in die Abläufe von Ansible. Jede Aufgabenausführung kann nachverfolgt werden, was Einblicke in Ausführungszeiten und Abhängigkeiten ermöglicht.
2. Identifizierung von Leistungsengpässen Wenn Automatisierungsprozesse verlangsamt werden oder fehlschlagen, ist es von entscheidender Bedeutung, die Grundursache zu ermitteln. OpenTelemetry hilft bei der Identifizierung von Leistungsengpässen, indem es die Ausführung der einzelnen Tasks verfolgt. So können wir feststellen, welche Aufgaben die meiste Zeit in Anspruch nehmen, ob sie auf externe Services warten und wo es möglicherweise zu Ressourcenkonflikten kommt.
3. Debuggen komplexer Playbooks Komplexe Ansible-Playbooks können schwierig zu debuggen sein, insbesondere wenn sie mit mehreren Rollen und bedingten Aufgaben arbeiten. Die Verfolgung dieser Playbooks mit OpenTelemetry ermöglicht es uns, den Ausführungsablauf Schritt für Schritt zu verfolgen. Wir können sehen, wie sich Variablen ändern, welche Aufgaben übersprungen werden und wo Fehler auftreten.
4. Monitoring verteilter Systeme In modernen IT-Umgebungen erstreckt sich die Automatisierung oft auch auf die Verwaltung von Microservices und containerisierten Anwendungen. Mit OpenTelemetry können wir Anfragen überwachen und verfolgen, während sie das System durchlaufen. So können wir Latenzprobleme, fehlgeschlagene Anfragen und Service-Abhängigkeiten identifizieren.

Praktisches Beispiel

Um die Vorteile des Sendens von Traces aus Ansible über OpenTelemetry an Jaeger zu veranschaulichen, sehen wir uns ein praktisches Beispiel an. In diesem Szenario betrachten wir einen einfachen Anwendungsfall, bei dem wir unsere lokale Maschine pingen wollen.

Voraussetzungen für das Szenario

Bevor wir beginnen, skizzieren wir die Voraussetzungen für unser praktisches Beispiel:

• Python: Python sollte auf Ihrem lokalen Rechner installiert sein, einschließlich pip
• Ansible: Ansible sollte auf Ihrem lokalen Rechner installiert sein. Sie können die offizielle Ansible-Installationsanleitung zur Hilfe nehmen.
• Lokaler Kubernetes-Cluster: Für diese Demonstration verwenden wir einen einfachen k3d Cluster, der Docker benötigt, um zu laufen, aber Sie können auch jeden anderen Cluster verwenden, mit dem Sie vertraut sind.
• Helm: Wir werden Helm verwenden, um einen OpenTelemetry Collector zum Sammeln unserer Traces und zum Deployment einer Jaeger-Instanz einzusetzen.
• (Optional) k9s: k9s erleichtert die Verwaltung Ihres Clusters und ist daher unsere Tool-Empfehlung!

Kubernetes Teilbereich

Nachdem alle Abhängigkeiten installiert sind, können wir alles einrichten! Zunächst erstellen wir einen k3d-Cluster, indem wir den folgenden Befehl in einer CLI unserer Wahl ausführen:

1k3d cluster create otel-ansible --api-port 6550 -p "80:80@loadbalancer" --agents 2

Nun müssen wir die Jaeger-Instanz sowie den OTel-Collector installieren. Dazu erstellen wir zunächst eine Datei simplest.yaml mit folgendem Inhalt, bevor wir die nachfolgenden Befehle ausführen:

1apiVersion: jaegertracing.io/v1
2kind: Jaeger
3metadata:
4  name: simplest

Nach der Erstellung der obigen Datei können wir die folgenden Befehle ausführen:

 1helm repo add jetstack https://charts.jetstack.io
 2
 3helm upgrade --install \
 4  cert-manager jetstack/cert-manager \
 5  --namespace cert-manager \
 6  --create-namespace \
 7  --version v1.7.1 \
 8  --set installCRDs=true \
 9  --wait
10
11kubectl create namespace observability
12
13kubectl create -f https://github.com/jaegertracing/jaeger-operator/releases/download/v1.38.0/jaeger-operator.yaml -n observability
14
15kubectl apply -f simplest.yaml

Jetzt sollte unser Cluster wie folgt aussehen (Sie können einfach k9s eingeben, um Ihren Cluster zu sehen):

Die IP-Adresse des markierten Pods benötigen wir im nächsten Schritt!

Bevor wir uns Ansible zuwenden, müssen wir nur noch den OTel-Collector installieren. Wir müssen unseren Collector so anpassen, dass er Traces empfängt und sie an Jaeger sendet. Dazu erstellen wir eine Datei values.yaml, in der wir diese Änderungen definieren werden (vergessen Sie nicht, die IP-Adresse zu ändern):

 1mode: deployment
 2config:
 3  receivers:
 4    otlp:
 5      protocols:
 6        grpc:
 7          endpoint: 127.0.0.1:4317
 8
 9  exporters:
10    otlphttp:
11      endpoint: http://<YOUR JAEGER ADDRESS>:4318
12    logging:
13      loglevel: debug
14      sampling_initial: 5
15      sampling_thereafter: 200
16
17  service:
18    pipelines:
19      traces:
20        receivers: [otlp]
21        processors: []
22        exporters: [otlphttp, logging]
23      logs:
24        receivers: [otlp]
25        processors: []
26        exporters: [otlphttp, logging]

Jetzt können wir den Collector mit Helm installieren:

1helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
2
3helm install my-opentelemetry-collector open-telemetry/opentelemetry-collector --values=values.yaml

Schließlich wollen wir die Ports 16686 für unsere Jaeger-Instanz und den Port 4317 für den Collector freigeben, was durch die Verwendung des k9s-Interface leicht gemacht wird, ansonsten können Sie folgende Befehle verwenden:

1kubectl port-forward <JAEGER POD NAME> 16686:16686 &
2
3kubectl port-forward <COLLECTOR POD NAME> 4317:4317 &

Wenn Sie möchten, können Sie einen ersten Blick auf das Jaeger-Dashboard werfen, das wir gerade zugänglich gemacht haben: http://localhost:16686.

Ansible Teilbereich

Damit können wir uns endlich auf Ansible konzentrieren.

Der einfachste Weg, Ansible dazu zu bringen, unsere Daten an den OTel-Collector zu senden, ist die Verwendung eines Community-Plugins für Ansible. Folgen Sie den Anweisungen auf dieser Website, um das Plugin zu installieren.

Das Plugin erfordert, dass wir auch einige pip-Pakete installieren. Daher müssen wir eine virtuelle Umgebung mit Python erstellen, in der wir diese installieren können. Folgen Sie einfach den Anweisungen auf dieser Website, um die virtuelle Umgebung zu erstellen und zu aktivieren.

Nachdem die Umgebung aktiviert wurde, können wir die pip-Pakete installieren:

1pip install opentelemetry-api
2
3pip install opentelemetry-sdk
4
5pip install opentelemetry-exporter-otlp

Sobald dies erledigt ist, benötigen wir ein Python-Skript (ansible-runner.py), das unser Playbook ausführt, welches wir anschließend schreiben werden:

1import ansible_runner
2
3# Pfad zu Ihrem Ansible-Playbook
4playbook_path = "playbook.yaml"
5
6# Erstellt eine Instanz von AnsibleRunner und führt sie aus
7ansible_runner.run(private_data_dir='.', playbook=playbook_path)

Wie im obigen Skript zu sehen ist, wird unser Playbook playbook.yaml heißen:

1---
2- name: Ping localhost
3  hosts: localhost
4  tasks:
5    - name: Send Ping
6      ansible.builtin.ping:

Zusätzlich zum Playbook müssen wir eine Konfiguration für Ansible definieren (ansible.cfg):

1[defaults]
2inventory = inventory
3callbacks_enabled = community.general.opentelemetry

sowie unser Inventar (inventory), das eine Liste der Hosts enthält:

1localhost ansible_connection=local

Wenn wir alles erstellt haben, sollte unsere Ordnerstruktur ungefähr so aussehen:

1ansible-example
2├── artifacts # automatisch generiert
3└── YOUR PYTHON ENVIRONMENT FOLDER
4└── ansible-runner.py
5└── ansible.cfg
6└── inventory
7└── playbook.yaml

Es müssen nur noch Umgebungsvariablen festgelegt werden, die Ansible mitteilen, wohin die Traces gesendet werden sollen und wie auf den Service innerhalb von Jaeger verwiesen werden soll:

1export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
2
3export OTEL_SERVICE_NAME=ansible

Und jetzt führen wir es aus:

1python ansible-runner.py

Fazit

In den dynamischen und dezentralen IT-Landschaften von heute ist Observability in unseren Automatisierungsprozessen unerlässlich, um die Leistung aufrechtzuerhalten, Probleme zu erkennen und die Zuverlässigkeit der Infrastruktur zu gewährleisten. Die Integration von Ansible mit OpenTelemetry und Jaeger bietet eine leistungsstarke Lösung, um diese Ziele zu erreichen. Durch die Nutzung der Tracing-Funktionen von OpenTelemetry erhalten wir einen detaillierten Einblick in die Abläufe von Ansible, können Leistungsengpässe identifizieren und komplexe Playbooks debuggen. Durch das Senden dieser Traces an Jaeger können wir unsere Automatisierungsprozesse noch besser überwachen, Fehler beheben und optimieren, was letztendlich zu einem effizienteren und zuverlässigeren Infrastrukturmanagement führt.