Condividi tramite


Distribuire un gateway self-hosted in Kubernetes con l'integrazione di OpenTelemetry

SI APPLICA A: Sviluppatore | Premium

Questo articolo descrive i passaggi per distribuire il componente gateway self-hosted di Gestione API di Azure in un cluster Kubernetes e inviare automaticamente tutte le metriche a un agente di raccolta OpenTelemetry.

Importante

Il supporto di OpenTelemetry per il gateway self-hosted di Gestione API di Azure è attualmente in anteprima e richiede il tag 2.0.0 o versione successiva.

Scopri come:

  • Configurare e distribuire un agente di raccolta OpenTelemetry autonomo in Kubernetes
  • Distribuire il gateway self-hosted con le metriche OpenTelemetry.
  • Generare metriche usando le API sul gateway self-hosted.
  • Usare le metriche dell'agente di raccolta OpenTelemetry.

Prerequisiti

Introduzione a OpenTelemetry

OpenTelemetry è un set di strumenti e framework open source per la registrazione, le metriche e la traccia in modo indipendente dal fornitore.

Importante

Il supporto di OpenTelemetry per il gateway self-hosted di Gestione API di Azure è attualmente in anteprima e richiede il tag 2.0.0 o versione successiva.

Il gateway self-hosted può essere configurato per raccogliere e inviare automaticamente le metriche a un agente di raccolta OpenTelemetry. In questo modo è possibile usare la propria soluzione di raccolta e creazione di report delle metriche per il gateway self-hosted.

Nota

OpenTelemetry è un progetto di incubazione dell'ecosistema Cloud Native Computing Foundation (CNCF).

Metrica

Il gateway self-hosted inizierà automaticamente a misurare le metriche seguenti:

  • Richieste
  • DurationInMs
  • BackendDurationInMs
  • ClientDurationInMs
  • GatewayDurationInMs

Queste vengono esportate automaticamente nell'agente di raccolta OpenTelemetry configurato ogni minuto, con dimensioni aggiuntive.

Distribuire l'agente di raccolta OpenTelemetry

Si inizierà distribuendo un agente di raccolta OpenTelemetry autonomo in Kubernetes usando Helm.

Suggerimento

Anche se si usa il grafico Helm dell'agente di raccolta, forniscono anche un operatore dell'agente di raccolta OpenTelemetry

Per iniziare, è necessario aggiungere il repository dei grafici Helm:

  1. Aggiungere il repository Helm

    helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
    
  2. Aggiornare il repository per recuperare i grafici Helm più recenti.

    helm repo update
    
  3. Verificare la configurazione Helm elencando tutti i grafici disponibili.

    $ 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
    

Dopo aver configurato il repository dei grafici, è possibile distribuire sul cluster l’agente di raccolta OpenTelemetry:

  1. Creare un file di configurazione locale denominato opentelemetry-collector-config.yml con la configurazione seguente:

    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
    

In questo modo è possibile usare un agente di raccolta autonomo con l'utilità di esportazione Prometheus esposta sulla porta 8889. Per esporre le metriche Prometheus, viene chiesto al grafico Helm di configurare un servizio LoadBalancer.

Nota

La porta Jaeger compatta viene disabilitata perché usa UDP e il servizio LoadBalancer non consente di avere più protocolli contemporaneamente.

  1. Installare il grafico Helm con la configurazione:

    helm install opentelemetry-collector open-telemetry/opentelemetry-collector --values .\opentelemetry-collector-config.yml
    
  2. Verificare l'installazione ottenendo tutte le risorse per il grafico 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. Prendere nota dell'indirizzo IP esterno del servizio, in modo da poterlo interrogare in un secondo momento.

Con l'agente di raccolta OpenTelemetry installato, è ora possibile distribuire il gateway self-hosted nel cluster.

Distribuire il gateway self-hosted

Importante

Per una panoramica dettagliata su come distribuire il gateway self-hosted con Helm e su come ottenere la configurazione necessaria, è consigliabile leggere questo articolo.

In questa sezione, il gateway self-hosted verrà distribuito nel cluster con Helm e configurato per inviare le metriche OpenTelemetry all'agente di raccolta OpenTelemetry.

  1. Installare il grafico Helm e configurarlo per l'uso delle metriche 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
    

Nota

opentelemetry-collector nel comando precedente è il nome dell'agente di raccolta OpenTelemetry. Aggiornare il nome se il servizio ha un nome diverso.

  1. Verificare l'installazione ottenendo tutte le risorse per il grafico 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. Prendere nota dell'indirizzo IP esterno del servizio del gateway self-hosted, in modo da poterlo interrogare in un secondo momento.

Generare e usare le metriche OpenTelemetry

Ora che sono stati distribuiti sia l'agente di raccolta OpenTelemetry che il gateway self-hosted, è possibile iniziare a usare le API per generare le metriche.

Nota

Per questa procedura dettagliata verrà usata l'API Echo predefinita.

Assicurarsi che sia configurata per:

  • Consentire richieste HTTP
  • Consentire al gateway self-hosted di esporla
  1. Eseguire una query sull'API Echo nel gateway self-hosted:

    $ 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:00001111-aaaa-2222-bbbb-3333cccc4444
    X-Powered-By: Azure API Management - http://api.azure.com/,ASP.NET
    X-AspNet-Version: 4.0.30319
    

Il gateway self-hosted ora misurerà la richiesta e invierà le metriche all'agente di raccolta OpenTelemetry.

  1. Eseguire una query sull'endpoint Prometheus in merito all’agente di raccolta in http://<collector-service-ip>:8889/metrics. Le metriche visualizzate saranno simili alle seguenti:

    # 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
    

Pulizia

Ora che l'esercitazione è finita, è possibile pulire facilmente il cluster come segue:

  1. Disinstallare il grafico Helm del gateway self-hosted:

    helm uninstall apim-gateway
    
  2. Disinstallare l'agente di raccolta OpenTelemetry:

    helm uninstall opentelemetry-collector
    

Passaggi successivi