Partage via


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

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

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 :

  1. Ajoutez le référentiel Helm.

    helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
    
  2. Mettez à jour le dépôt pour récupérer les derniers graphiques Helm.

    helm repo update
    
  3. 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 :

  1. 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.

  1. Installez le chart Helm avec la configuration suivante :

    helm install opentelemetry-collector open-telemetry/opentelemetry-collector --values .\opentelemetry-collector-config.yml
    
  2. 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
    
  3. 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.

  1. 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.

  1. 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
    
  2. 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
  1. 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.

  1. 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 :

  1. Désinstallez la passerelle auto-hébergée du chart Helm :

    helm uninstall apim-gateway
    
  2. Désinstallez le collecteur OpenTelemetry :

    helm uninstall opentelemetry-collector
    

Étapes suivantes