Bereitstellen eines selbstgehosteten Gateways in Kubernetes mit OpenTelemetry-Integration

Artikel
06/01/2023

GILT FÜR: Entwickler | Premium

In diesem Artikel erfahren Sie Schritt für Schritt, wie Sie die selbstgehostete Gatewaykomponente von Azure API Management in einem Kubernetes-Cluster bereitstellen und automatisch alle Metriken an einen OpenTelemetry-Collector senden.

Wichtig

Die OpenTelemetry-Unterstützung für das selbstgehostete Gateway von Azure API Management befindet sich derzeit in der Vorschauphase und erfordert mindestens das Tag 2.0.0.

Folgendes wird vermittelt:

Konfigurieren und Bereitstellen eines eigenständigen OpenTelemetry-Collectors in Kubernetes
Bereitstellen des selbstgehosteten Gateways mit OpenTelemetry-Metriken
Generieren von Metriken durch die Nutzung von APIs auf dem selbstgehosteten Gateway
Verwenden der Metriken aus dem OpenTelemetry-Collector

Voraussetzungen

Erstellen einer neuen Azure API Management-Dienstinstanz
Erstellen Sie einen Azure Kubernetes-Cluster mithilfe der Azure CLI, mithilfe der Azure PowerShell oder mithilfe des Azure-Portals.
Stellen Sie eine selbstgehostete Gatewayressource in Ihrer API Management-Instanz bereit.

Einführung in OpenTelemetry

Bei OpenTelemetry handelt es sich um eine Reihe von Open-Source-Tools und -Frameworks für anbieterneutrale Protokollierung, Metriken und Ablaufverfolgung.

Wichtig

Die OpenTelemetry-Unterstützung für das selbstgehostete Gateway von Azure API Management befindet sich derzeit in der Vorschauphase und erfordert mindestens das Tag 2.0.0.

Das selbstgehostete Gateway kann so konfiguriert werden, dass Metriken automatisch gesammelt und an einen OpenTelemetry-Collector gesendet werden. Dadurch können Sie für das selbstgehostete Gateway Ihre eigene Lösung für die Metriksammlung und Berichterstellung verwenden.

Hinweis

OpenTelemetry ist ein in der Entwicklung befindliches Projekt des CNCF-Ökosystems (Cloud Native Computing Foundation).

Metriken

Das selbstgehostete Gateway beginnt automatisch mit der Messung folgender Metriken:

Requests
DurationInMs
BackendDurationInMs
ClientDurationInMs
GatewayDurationInMs

Sie werden automatisch im Minutentakt und mit zusätzlichen Dimensionen in den konfigurierten OpenTelemetry-Collector exportiert.

Bereitstellen des OpenTelemetry-Collectors

Zu Beginn wird mithilfe von Helm ein eigenständiger OpenTelemetry-Collector in Kubernetes bereitgestellt.

Tipp

Hier wird zwar das Collector-Helm-Chart verwendet, es steht aber auch ein OpenTelemetry-Collector-Operator zur Verfügung.

Als Erstes muss das Helm-Chartrepository hinzugefügt werden:

Fügen Sie das Helm-Repository hinzu.

helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts

Aktualisieren Sie das Repository, um die neuesten Helm-Diagramme abzurufen.
```
helm repo update
```

Überprüfen Sie Ihre Helm-Konfiguration, indem Sie alle verfügbaren Diagramme auflisten.

$ helm search repo open-telemetry
NAME                                    CHART VERSION   APP VERSION     DESCRIPTION
open-telemetry/opentelemetry-collector  0.8.1           0.37.1          OpenTelemetry Collector Helm chart for Kubernetes
open-telemetry/opentelemetry-operator   0.4.0           0.37.0          OpenTelemetry Operator Helm chart for Kubernetes

Nachdem wir das Chartrepository konfiguriert haben, können wir den OpenTelemetry-Collector in unserem Cluster bereitstellen:

Erstellen Sie eine lokale Konfigurationsdatei namens opentelemetry-collector-config.yml mit folgender Konfiguration:

mode: deployment
config:
  exporters:
    prometheus:
      endpoint: "0.0.0.0:8889"
      namespace: azure_apim
      send_timestamps: true
  service:
    pipelines:
      metrics:
        exporters:
        - prometheus
service:
  type: LoadBalancer
ports:
  jaeger-compact:
    enabled: false
  prom-exporter:
    enabled: true
    containerPort: 8889
    servicePort: 8889
    protocol: TCP

Dadurch können wir einen eigenständigen Collector verwenden, und der Prometheus-Exporter wird am Port 8889 verfügbar gemacht. Um die Prometheus-Metriken verfügbar zu machen, weisen wir das Helm-Chart an, einen LoadBalancer-Dienst zu konfigurieren.

Hinweis

Wir deaktivieren den kompakten Jaeger-Port, da er UDP verwendet und der Dienst LoadBalancer die gleichzeitige Verwendung mehrerer Protokolle nicht erlaubt.

Installieren Sie das Helm-Chart mit unserer Konfiguration:

helm install opentelemetry-collector open-telemetry/opentelemetry-collector --values .\opentelemetry-collector-config.yml

Überprüfen Sie die Installation, indem Sie alle Ressourcen für unser Helm-Chart abrufen.

$ kubectl get all -l app.kubernetes.io/instance=opentelemetry-collector
NAME                                           READY   STATUS    RESTARTS   AGE
pod/opentelemetry-collector-58477c8c89-dstwd   1/1     Running   0          27m

NAME                              TYPE           CLUSTER-IP     EXTERNAL-IP    PORT(S)                                                                                       AGE
service/opentelemetry-collector   LoadBalancer   10.0.175.135   20.103.18.53   14250:30982/TCP,14268:32461/TCP,4317:31539/TCP,4318:31581/TCP,8889:32420/TCP,9411:30003/TCP   27m

NAME                                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/opentelemetry-collector   1/1     1            1           27m

NAME                                                 DESIRED   CURRENT   READY   AGE
replicaset.apps/opentelemetry-collector-58477c8c89   1         1         1       27m

Notieren Sie sich die externe IP-Adresse des Diensts, damit wir ihn später abfragen können.

Nach der Installation des OpenTelemetry-Collectors können wir das selbstgehostete Gateway in unserem Cluster bereitstellen.

Bereitstellen des selbstgehosteten Gateways

Wichtig

Eine ausführliche Übersicht darüber, wie Sie das selbstgehostete Gateway mit Helm bereitstellen und die erforderliche Konfiguration abrufen, finden Sie in diesem Artikel.

In diesem Abschnitt stellen wir das selbstgehostete Gateway für unseren Cluster mit Helm bereit und konfigurieren es so, dass OpenTelemetry-Metriken an den OpenTelemetry-Collector gesendet werden.

Installieren Sie das Helm-Chart, und konfigurieren Sie es für die Verwendung von OpenTelemetry-Metriken:

helm install azure-api-management-gateway \
             --set gateway.configuration.uri='<your configuration url>' \
             --set gateway.auth.key='<your auth token>' \
             --set observability.opentelemetry.enabled=true \
             --set observability.opentelemetry.collector.uri=http://opentelemetry-collector:4317 \
             --set service.type=LoadBalancer \
             azure-apim-gateway/azure-api-management-gateway

Hinweis

Im obigen Befehl ist opentelemetry-collector der Name des OpenTelemetry-Collectors. Aktualisieren Sie den Namen, wenn Ihr Dienst einen anderen Namen besitzt.

Überprüfen Sie die Installation, indem Sie alle Ressourcen für unser Helm-Chart abrufen.

$ kubectl get all -l app.kubernetes.io/instance=apim-gateway
NAME                                                            READY   STATUS    RESTARTS   AGE
pod/apim-gateway-azure-api-management-gateway-fb77c6d49-rffwq   1/1     Running   0          63m

NAME                                                TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)                         AGE
service/apim-gateway-azure-api-management-gateway   LoadBalancer   10.0.67.177   20.71.82.110   8080:32267/TCP,8081:32065/TCP   63m

NAME                                                        READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/apim-gateway-azure-api-management-gateway   1/1     1            1           63m

NAME                                                                  DESIRED   CURRENT   READY   AGE
replicaset.apps/apim-gateway-azure-api-management-gateway-fb77c6d49   1         1         1       63m

Notieren Sie sich die externe IP-Adresse des Diensts des selbstgehosteten Gateways, damit wir ihn später abfragen können.

Generieren und Nutzen der OpenTelemetry-Metriken

Nachdem nun sowohl der OpenTelemetry-Collector als auch das selbstgehostete Gateway bereitgestellt sind, können wir mit der Nutzung der APIs beginnen, um Metriken zu generieren.

Hinweis

In dieser exemplarischen Vorgehensweise wird die standardmäßige Echo-API genutzt.

Vergewissern Sie sich, dass sie für Folgendes konfiguriert ist:

Zulassen von HTTP-Anforderungen
Zulassen, dass sie von Ihrem selbstgehosteten Gateway verfügbar gemacht wird

Fragen Sie die Echo-API im selbstgehosteten Gateway ab:

$ curl -i "http://<self-hosted-gateway-ip>:8080/echo/resource?param1=sample&subscription-key=abcdef0123456789"
HTTP/1.1 200 OK
Date: Mon, 20 Dec 2021 12:58:09 GMT
Server: Microsoft-IIS/8.5
Content-Length: 0
Cache-Control: no-cache
Pragma: no-cache
Expires: -1
Accept: */*
Host: echoapi.cloudapp.net
User-Agent: curl/7.68.0
X-Forwarded-For: 10.244.1.1
traceparent: 00-3192030c89fd7a60ef4c9749d6bdef0c-f4eeeee46f770061-01
Request-Id: |3192030c89fd7a60ef4c9749d6bdef0c.f4eeeee46f770061.
Request-Context: appId=cid-v1:c24f5e00-aa25-47f2-bbb5-035847e7f52a
X-Powered-By: Azure API Management - http://api.azure.com/,ASP.NET
X-AspNet-Version: 4.0.30319

Das selbstgehostete Gateway misst daraufhin die Anforderung und sendet die Metriken an den OpenTelemetry-Collector.

Fragen Sie den Prometheus-Endpunkt für den Collector unter http://<collector-service-ip>:8889/metrics ab. Die Metriken sollten in etwa wie folgt aussehen:

# HELP azure_apim_BackendDurationInMs 
# TYPE azure_apim_BackendDurationInMs histogram
azure_apim_BackendDurationInMs_bucket{Hostname="20.71.82.110",le="5"} 0 1640093731340
[...]
azure_apim_BackendDurationInMs_count{Hostname="20.71.82.110"} 22 1640093731340
# HELP azure_apim_ClientDurationInMs 
# TYPE azure_apim_ClientDurationInMs histogram
azure_apim_ClientDurationInMs_bucket{Hostname="20.71.82.110",le="5"} 22 1640093731340
[...]
azure_apim_ClientDurationInMs_count{Hostname="20.71.82.110"} 22 1640093731340
# HELP azure_apim_DurationInMs 
# TYPE azure_apim_DurationInMs histogram
azure_apim_DurationInMs_bucket{Hostname="20.71.82.110",le="5"} 0 1640093731340
[...]
azure_apim_DurationInMs_count{Hostname="20.71.82.110"} 22 1640093731340
# HELP azure_apim_GatewayDurationInMs 
# TYPE azure_apim_GatewayDurationInMs histogram
azure_apim_GatewayDurationInMs_bucket{Hostname="20.71.82.110",le="5"} 0 1640093731340
[...]
azure_apim_GatewayDurationInMs_count{Hostname="20.71.82.110"} 22 1640093731340
# HELP azure_apim_Requests 
# TYPE azure_apim_Requests counter
azure_apim_Requests{BackendResponseCode="200",BackendResponseCodeCategory="2xx",Cache="None",GatewayId="Docs",Hostname="20.71.82.110",LastErrorReason="None",Location="GitHub",ResponseCode="200",ResponseCodeCategory="2xx",Status="Successful"} 22 1640093731340

Bereinigen

Nachdem das Tutorial nun abgeschlossen ist, können Sie Ihren Cluster wie folgt bereinigt:

Deinstallieren Sie das Helm-Chart für das selbstgehostete Gateway:
```
helm uninstall apim-gateway
```
Deinstallieren Sie den OpenTelemetry-Collector:
```
helm uninstall opentelemetry-collector
```

Nächste Schritte

Weitere Informationen zum selbstgehosteten Gateway finden Sie unter Selbstgehostetes Gateway – Übersicht.

Erfahren Sie mehr über die Beobachtbarkeitsfunktionen der Azure API Management Gateways.

Bereitstellung eines selbst gehosteten Gateways für einen Azure Arc-fähigen Kubernetes-Cluster

Freigeben über

Bereitstellen eines selbstgehosteten Gateways in Kubernetes mit OpenTelemetry-Integration

Voraussetzungen

Einführung in OpenTelemetry

Metriken

Bereitstellen des OpenTelemetry-Collectors

Bereitstellen des selbstgehosteten Gateways

Generieren und Nutzen der OpenTelemetry-Metriken

Bereinigen

Nächste Schritte

Feedback

Zusätzliche Ressourcen