Compartir a través de

Implementación de una puerta de enlace autohospedada en Kubernetes con la integración de OpenTelemetry

  • Artículo

SE APLICA A: Desarrollador | Premium

En este artículo se describen los pasos para implementar el componente de puerta de enlace autohospedada de Azure API Management en un clúster de Kubernetes y enviar automáticamente todas las métricas a OpenTelemetry Collector.

Importante

La compatibilidad de OpenTelemetry con la puerta de enlace autohospedada de Azure API Management está actualmente en versión preliminar y requiere etiqueta 2.0.0 o superior.

Aprenderá a:

  • Configuración e implementación de un OpenTelemetry Collector independiente en Kubernetes
  • Implemente la puerta de enlace autohospedada con métricas de OpenTelemetry.
  • Genere métricas mediante el consumo de API en la puerta de enlace autohospedada.
  • Use las métricas de OpenTelemetry Collector.

Requisitos previos

Introducción a OpenTelemetry

OpenTelemetry es un conjunto de herramientas y marcos de código abierto para el registro, las métricas y el seguimiento de una manera neutral del proveedor.

Importante

La compatibilidad de OpenTelemetry con la puerta de enlace autohospedada de Azure API Management está actualmente en versión preliminar y requiere etiqueta 2.0.0 o superior.

La puerta de enlace auto hospedada se puede configurar para recopilar y enviar métricas automáticamente a un OpenTelemetry Collector. Esto le permite traer su propia solución de recopilación de métricas e informes para la puerta de enlace autohospedada.

Nota

OpenTelemetry es un proyecto de resumen del ecosistema de Cloud Native Computing Foundation (CNCF).

Métricas

La puerta de enlace autohospedada comenzará automáticamente a medir las siguientes métricas:

  • Requests
  • DurationInMs
  • BackendDurationInMs
  • ClientDurationInMs
  • GatewayDurationInMs

Se exportan automáticamente al OpenTelemetry Collector configurado cada 1 minuto con dimensiones adicionales.

Implementación de OpenTelemetry Collector

Comenzaremos por implementar un OpenTelemetry Collector independiente en Kubernetes mediante Helm.

Sugerencia

Aunque usaremos el gráfico de Collector Helm, también proporcionan un Operador de OpenTelemetry Collector

Para empezar, tenemos que agregar el repositorio de gráficos de Helm:

  1. Adición del repositorio de Helm

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

  2. Actualice el repositorio para capturar los gráficos de Helm más recientes.

    helm repo update

  3. Compruebe la configuración de Helm enumerando todos los gráficos 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

Ahora que tenemos configurado el repositorio de gráficos, podemos implementar OpenTelemetry Collector en nuestro clúster:

  1. Cree un archivo de configuración local denominado opentelemetry-collector-config.yml con la siguiente configuración:

    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

Esto nos permite usar un recopilador independiente con el exportador Prometheus expuesto en el puerto 8889. Para exponer las métricas de Prometheus, se pide al gráfico de Helm que configure un servicio LoadBalancer.

Nota:

Estamos deshabilitando el puerto de Jaeger compacto dado que usa UDP y el servicio LoadBalancer no permite tener varios protocolos al mismo tiempo.

  1. Instale el gráfico de Helm con nuestra configuración:

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

  2. Compruebe la instalación obteniendo todos los recursos de nuestro gráfico de 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. Tome nota de la IP externa del servicio para poder consultarla más adelante.

Con OpenTelemetry Collector instalado, ahora podemos implementar la puerta de enlace autohospedada en nuestro clúster.

Implementación de la puerta de enlace autohospedada

Importante

Para obtener información general detallada sobre cómo implementar la puerta de enlace autohospedada con Helm y cómo obtener la configuración necesaria, se recomienda leer este artículo.

En esta sección, implementaremos la puerta de enlace autohospedada en nuestro clúster con Helm y la configuraremos para enviar métricas de OpenTelemetry a OpenTelemetry Collector.

  1. Instale el gráfico de Helm y configúrelo para usar las métricas de 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 en el comando anterior es el nombre de OpenTelemetry Collector. Actualice el nombre si el servicio tiene otro nombre.

  1. Compruebe la instalación obteniendo todos los recursos de nuestro gráfico de 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. Tome nota de la IP externa del servicio de puerta de enlace autohospedada para poder consultarla más adelante.

Generación y consumo de las métricas de OpenTelemetry

Ahora que tanto OpenTelemetry Collector como la puerta de enlace autohospedada están implementadas, podemos empezar a consumir las API para generar métricas.

Nota

Vamos a consumir la "API de Echo" predeterminada para este tutorial.

Asegúrese de que está configurado para:

  • Permitir solicitudes HTTP
  • Permitir que la puerta de enlace autohospedada la exponga

  1. Consulta de la API de Echo en la puerta de enlace autohospedada:

    $ 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 puerta de enlace autohospedada ahora medirá la solicitud y enviará las métricas a OpenTelemetry Collector.

  1. Consulta del punto de conexión de Prometheus en el recopilador en http://<collector-service-ip>:8889/metrics. Se mostrarán métricas similares a los siguientes:

    # 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

Limpieza

Ahora que el tutorial ha terminado, puede limpiar fácilmente el clúster como se muestra a continuación:

  1. Desinstalación del gráfico de Helm de la puerta de enlace autohospedada:

    helm uninstall apim-gateway

  2. Desinstalación del recopilador de OpenTelemetry Collector:

    helm uninstall opentelemetry-collector

Pasos siguientes