Déployer la passerelle auto-hébergée sur Kubernetes avec l’intégration OpenTelemetry

Article
06/01/2023

S’APPLIQUE À : Développeur | Premium

Cet article décrit les étapes permettant de déployer le composant de passerelle auto-hébergée de Gestion des API Azure sur un cluster Kubernetes et d’envoyer automatiquement toutes les métriques à un collecteur OpenTelemetry.

Important

La prise en charge d’OpenTelemetry pour la passerelle auto-hébergée Gestion des API Azure est actuellement en préversion et requiert l’étiquette 2.0.0 ou une version supérieure.

Vous allez apprendre à effectuer les actions suivantes :

Configurer et déployer un collecteur OpenTelemetry autonome sur Kubernetes
Déployer la passerelle auto-hébergée avec les métriques OpenTelemetry
Générer des métriques en consommant des API sur la passerelle auto-hébergée
Utiliser les métriques du collecteur OpenTelemetry

Prérequis

Créer une instance du service Gestion des API Azure
Créez un cluster Kubernetes Azure en utilisant Azure CLI, en utilisant Azure PowerShell ou en utilisant le Portail Azure.
Provisionnez une ressource de passerelle auto-hébergée dans votre instance de la Gestion des API.

Présentation d’OpenTelemetry

OpenTelemetry est un ensemble d’outils et d’infrastructures open source pour la journalisation, les métriques et le traçage indépendamment du fournisseur.

Important

La prise en charge d’OpenTelemetry pour la passerelle auto-hébergée Gestion des API Azure est actuellement en préversion et requiert l’étiquette 2.0.0 ou une version supérieure.

La passerelle auto-hébergée peut être configurée pour collecter et envoyer automatiquement des métriques à un collecteur OpenTelemetry. Cela vous permet de mettre en place votre propre solution de collecte de métriques et de création de rapports pour la passerelle auto-hébergée.

Notes

OpenTelemetry est un projet d’incubation de l’écosystème de la Cloud Native Computing Foundation (CNCF).

Mesures

La passerelle auto-hébergée commencera automatiquement à mesurer les métriques suivantes :

Demandes
DurationInMs
BackendDurationInMs
ClientDurationInMs
GatewayDurationInMs

Elles sont automatiquement exportées vers le collecteur OpenTelemetry configuré toutes les minutes, avec des dimensions supplémentaires.

Déployer le collecteur OpenTelemetry

Nous allons commencer par déployer un collecteur OpenTelemetry autonome sur Kubernetes en utilisant Helm.

Conseil

Nous allons utiliser le chart Helm du collecteur, mais un opérateur de collecteur OpenTelemetry est également fourni.

Pour commencer, nous devons ajouter le référentiel de charts Helm :

Ajoutez le référentiel Helm.

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

Mettez à jour le dépôt pour récupérer les derniers graphiques Helm.
```
helm repo update
```

Vérifiez votre configuration Helm en listant tous les graphiques disponibles.

$ 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

Maintenant que le référentiel de charts est configuré, nous pouvons déployer le collecteur OpenTelemetry sur notre cluster :

Créez un fichier config local appelé opentelemetry-collector-config.yml avec la configuration suivante :

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

Cela nous permet d’utiliser un collecteur autonome avec l’exportateur Prometheus exposé sur le port 8889. Pour exposer les métriques Prometheus, nous demandons au chart Helm de configurer un service LoadBalancer.

Notes

Nous désactivons le port compact Jaeger, car il utilise le protocole UDP et le service LoadBalancer ne permet pas d’avoir plusieurs protocoles en même temps.

Installez le chart Helm avec la configuration suivante :

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

Vérifiez l’installation en obtenant toutes les ressources de notre chart Helm.

$ 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

Notez l’adresse IP externe du service pour pouvoir l’interroger ultérieurement.

Une fois notre collecteur OpenTelemetry installé, nous pouvons maintenant déployer la passerelle auto-hébergée sur notre cluster.

Déployer la passerelle auto-hébergée

Important

Pour obtenir une vue d’ensemble détaillée de la façon de déployer la passerelle auto-hébergée avec Helm et de la façon d’obtenir la configuration requise, nous vous recommandons de lire cet article.

Dans cette section, nous allons déployer la passerelle auto-hébergée sur notre cluster avec Helm et la configurer pour envoyer les métriques OpenTelemetry au collecteur OpenTelemetry.

Installez le chart Helm et configurez-le pour qu’il utilise les métriques OpenTelemetry :

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

Notes

opentelemetry-collector dans la commande ci-dessus est le nom du collecteur OpenTelemetry. Mettez à jour le nom si votre service a un nom différent.

Vérifiez l’installation en obtenant toutes les ressources de notre chart Helm.

$ 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

Notez l’adresse IP externe du service de la passerelle auto-hébergée pour pouvoir l’interroger ultérieurement.

Générer et consommer les métriques OpenTelemetry

Maintenant que notre collecteur OpenTelemetry et la passerelle auto-hébergée sont déployés, nous pouvons commencer à consommer les API pour générer des métriques.

Notes

Nous allons utiliser l’« API Echo » par défaut pour cette procédure pas à pas.

Assurez-vous qu’elle est configurée pour :

Autoriser les requêtes HTTP
Autoriser votre passerelle auto-hébergée à l’exposer

Interrogez l’API Echo dans la passerelle auto-hébergée :

$ 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

La passerelle auto-hébergée va maintenant mesurer la requête et envoyer les métriques au collecteur OpenTelemetry.

Interrogez le point de terminaison Prometheus du collecteur sur http://<collector-service-ip>:8889/metrics. Vous devez obtenir des métriques similaires à ce qui suit :

# 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

Nettoyage

Maintenant que le tutoriel est terminé, vous pouvez facilement nettoyer votre cluster comme suit :

Désinstallez la passerelle auto-hébergée du chart Helm :
```
helm uninstall apim-gateway
```
Désinstallez le collecteur OpenTelemetry :
```
helm uninstall opentelemetry-collector
```

Étapes suivantes

Pour en savoir plus sur la passerelle auto-hébergée, consultez Vue d’ensemble de la passerelle auto-hébergée.

Pour en savoir plus sur les capacités d’observabilité des passerelles Gestion des API Azure.

Déployer une passerelle auto-hébergée sur un cluster Kubernetes avec Azure Arc

Partager via

Déployer la passerelle auto-hébergée sur Kubernetes avec l’intégration OpenTelemetry

Prérequis

Présentation d’OpenTelemetry

Mesures

Déployer le collecteur OpenTelemetry

Déployer la passerelle auto-hébergée

Générer et consommer les métriques OpenTelemetry

Nettoyage

Étapes suivantes

Commentaires

Ressources supplémentaires