Esta página se ha traducido con Cloud Translation API.

Usar métricas de API

Esta página se aplica a Apigee y Apigee Hybrid.

Consulta la documentación de Apigee Edge.

Apigee registra una amplia variedad de datos operativos y empresariales que se transfieren a través de las APIs. Las métricas derivadas de estos datos son útiles para la monitorización operativa y empresarial. Con Apigee Analytics, puedes, por ejemplo, determinar qué APIs tienen un buen o mal rendimiento, qué desarrolladores ofrecen el tráfico de mayor valor y qué aplicaciones están causando la mayoría de los problemas en tus servicios backend.

Para acceder fácilmente a estos datos de métricas, usa la API Metrics cuando necesites automatizar determinadas funciones analíticas, como recuperar métricas periódicamente mediante un cliente o una secuencia de comandos de automatización. También puedes usar la API para crear tus propias visualizaciones en forma de widgets personalizados que puedes insertar en portales o aplicaciones personalizadas.

Para saber cómo usar Analytics en la interfaz de usuario de Apigee, consulta la descripción general de Apigee Analytics.

Acerca de la API de métricas

Hay dos formas de usar la API Metrics:

Obtener métricas de una organización y un entorno durante un periodo, como una hora, un día o una semana. Este método devuelve métricas sin procesar de toda la organización y el entorno.
Por ejemplo, si quieres obtener los datos de la semana anterior:
- Número de errores de políticas
- Tiempo medio de respuesta
- Tráfico total
Obtén métricas organizadas por dimensión durante un periodo de tiempo para una organización y un entorno.

Por ejemplo, en la semana anterior, puede usar dimensiones para agrupar métricas por producto de API, proxy de API y correo electrónico del desarrollador (que también puede ser un ID de AppGroup) para obtener lo siguiente:
- Número de errores de políticas por producto de API
- Tiempo medio de respuesta por proxy de API
- Tráfico total por correo del desarrollador
Para gestionar el resultado devuelto, la API Metrics admite las siguientes funciones:
Para obtener más información, consulta la referencia de la API Metrics.

Empezar a usar la API Metrics

La URL de solicitud de la API Metrics es la siguiente:
```
https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats[dimension]
```
Por ejemplo, para obtener métricas agrupadas por proxy de API, use la siguiente URL para llamar a la API de Apigee:
```
https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/apiproxy?timeRange=07/21/2018+00:00:00~08/23/2018+00:00:00
```
Omita la dimensión para devolver métricas sin procesar de toda la organización y el entorno durante el periodo especificado:
```
https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats?timeRange=07/21/2019+00:00:00~08/23/2018+00:00:00
```
Especificar las métricas que se van a devolver

Usa el parámetro de consulta select para especificar las métricas que quieres obtener y una función de agregación opcional, con el siguiente formato:
```
?select=metric
```
También puedes hacerlo de esta otra forma, si lo prefieres:
```
?select=aggFunction(metric)
```
Donde:
- metric especifica los datos que quieres devolver. Por ejemplo, el número de solicitudes a la API, de resultados en caché o de errores de política. Consulta las métricas para ver una tabla que especifica el nombre de la métrica que se debe usar con el parámetro de consulta select.
- aggFunction especifica la función de agregación opcional que se ejecuta en la métrica. Por ejemplo, puede usar las siguientes funciones de agregación con la métrica de latencia de procesamiento:
  - avg: devuelve la latencia media de procesamiento.
  - min: devuelve la latencia de procesamiento mínima.
  - max: devuelve la latencia máxima de procesamiento.
  - sum: devuelve la suma de todas las latencias de procesamiento.
  - p50: devuelve el percentil 50 de las latencias de procesamiento, calculado mediante percentile(latency_metric,50)&aggTable=agg_percentile.
  - p95: devuelve el percentil 95 de las latencias de procesamiento, calculado mediante percentile(latency_metric,95)&aggTable=agg_percentile.
  - p99: devuelve el percentil 99 de las latencias de procesamiento, calculado mediante percentile(latency_metric,99)&aggTable=agg_percentile.
  El latency_metric puede ser:
  - total_response_time
  - target_response_time
  - response_processing_latency
  - request_processing_latency
  No todas las métricas admiten todas las funciones de agregación. En la documentación sobre métricas, se incluye una tabla que especifica el nombre de la métrica y la función (sum, avg, min o max) que admite.
Por ejemplo, para devolver el número medio de transacciones (es decir, solicitudes de proxy de API) por segundo, haz lo siguiente:
```
?select=tps
```
Ten en cuenta que este ejemplo no requiere una función de agregación. En el siguiente ejemplo se usa una función de agregación para devolver la suma de aciertos de caché:
```
?select=sum(cache_hit)
```
Puedes devolver varias métricas en una sola llamada a la API. Para obtener métricas de la suma de errores de política y el tamaño medio de las solicitudes, defina el parámetro de consulta select con una lista de métricas separadas por comas:
```
?select=sum(policy_error),avg(request_size)
```
Especificar el periodo

La API Metrics devuelve datos de un periodo concreto. Usa el parámetro de consulta timeRange (6 meses como máximo) para especificar el periodo. El formato es el siguiente:
```
?timeRange=MM/DD/YYYY%20HH:MM~MM/DD/YYYY%20HH:MM
```
Fíjate en el %20 antes de HH:MM. El parámetro timeRange requiere un carácter de espacio codificado como URL antes de HH:MM o un carácter +, como en el siguiente ejemplo: MM/DD/YYYY+HH:MM~MM/DD/YYYY+HH:MM.

Por ejemplo:
```
?timeRange=03/01/2018%2000:00~03/30/2018%2023:59
```
No uses las 24:00 como hora, ya que se convierte en las 00:00. Usa las 23:59.

Nota: Para obtener información sobre el periodo de conservación de los datos, consulta la página de planes de Apigee.

Ejemplos de llamadas a la API de métricas

En esta sección se proporcionan ejemplos de uso de la API de métricas. Consulta más ejemplos en Ejemplos de la API Metrics.
Devuelve el número total de llamadas realizadas a tus APIs durante un mes

Para devolver el número total de llamadas realizadas a todas las APIs de tu organización y entorno durante un mes, usa una llamada similar a la siguiente:
```
curl -v "https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/?select=sum(message_count)&timeRange=03/01/2018%2000:00~03/31/2018%2023:59" \
  -H "Authorization: Bearer $TOKEN"
```
Donde $TOKEN es tu token de acceso OAuth 2.0, tal como se describe en Obtener un token de acceso OAuth 2.0. Para obtener información sobre las opciones de curl que se usan en este ejemplo, consulta Usar curl. Para ver una descripción de las variables de entorno que puedes usar, consulta Definir variables de entorno para solicitudes a la API de Apigee.

A continuación, se muestra un ejemplo de la respuesta:
```
{
  "environments": [
    {
      "metrics": [
        {
          "name": "sum(message_count)",
          "values": [
            "7.44944088E8"
          ]
        }
      ],
      "name": "prod"
    }
  ],
...
}
```
Devuelve el número total de mensajes por proxy de API durante dos días

En este ejemplo, se devuelven métricas del número de solicitudes recibidas por todos los proxies de API durante un periodo de dos días. El parámetro de consulta select define la función de agregación sum de la métrica message_count en la dimensión apiproxy. El informe devuelve el rendimiento de mensajes de solicitud de todas las APIs del tráfico recibido entre el inicio del 20/06/2018 y el final del 21/06/2018, en hora UTC:
```
curl  https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/apiproxy?"select=sum(message_count)&timeRange=06/20/2018%2000:00~06/21/2018%2023:59" \
  -H "Authorization: Bearer $TOKEN"
```
Donde $TOKEN es tu token de acceso OAuth 2.0, tal como se describe en Obtener un token de acceso OAuth 2.0. Para obtener información sobre las opciones de curl que se usan en este ejemplo, consulta Usar curl. Para ver una descripción de las variables de entorno que puedes usar, consulta Definir variables de entorno para solicitudes a la API de Apigee.

A continuación, se muestra un ejemplo de la respuesta:
```
{
  "environments" : [ {
    "dimensions" : [ {
      "metrics" : [ {
        "name" : "sum(message_count)",
        "values" : [ {
          "timestamp" : 1498003200000,
          "value" : "1100.0"
        } ]
      } ],
      "name" : "target-reroute"
    } ],
    "name" : "test"
  } ]...
}
```
Esta respuesta indica que un proxy de API llamado "target-reroute" ha recibido 1100 mensajes en el entorno de prueba entre el 20 y el 21 de junio del 2018.

Nota: La marca de tiempo, 1498003200000, está en formato de marca de tiempo de Unix. En Internet hay muchas herramientas de conversión de marcas de tiempo de Unix que puedes usar para decodificar estas marcas de tiempo.

Para obtener métricas de otras dimensiones, especifique otra dimensión como parámetro URI. Por ejemplo, puedes especificar la dimensión developer_app para obtener métricas de las aplicaciones de desarrolladores. La siguiente llamada a la API devuelve el rendimiento total (mensajes recibidos) de cualquier aplicación durante el intervalo de tiempo especificado:
```
curl  https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/developer_app?"select=sum(message_count)&timeRange=06/20/2018%2000:00~06/21/2018%2023:59&timeUnit=day" \
  -H "Authorization: Bearer $TOKEN"
```
A continuación, se muestra un ejemplo de la respuesta:
```
{
  "environments": [
    {
      "dimensions": [
        {
          "metrics": [
            {
              "name": "sum(message_count)",
              "values": [
                {
                  "timestamp": 1498003200000,
                  "value": "886.0"
                }
              ]
            }
          ],
          "name": "Test-App"
        },
        {
          "metrics": [
            {
              "name": "sum(message_count)",
              "values": [
                {
                  "timestamp": 1498003200000,
                  "value": "6645.0"
                }
              ]
            }
          ],
          "name": "johndoe_app"
        },
        {
          "metrics": [
            {
              "name": "sum(message_count)",
              "values": [
                {
                  "timestamp": 1498003200000,
                  "value": "1109.0"
                }
              ]
            }
          ],
          "name": "marys_app"
        }
  ]...
}
```
Ordenar los resultados por clasificación relativa

Muchas veces, al obtener métricas, solo quieres obtener resultados de un subconjunto del conjunto total de datos. Normalmente, tienes que obtener los resultados de los 10 primeros elementos, por ejemplo, las 10 APIs más lentas o las 10 aplicaciones más activas. Para ello, puedes usar el parámetro de consulta topk como parte de la solicitud.

Por ejemplo, puede que te interese saber quiénes son tus principales desarrolladores, medidos por el rendimiento, o cuáles son los que tienen un rendimiento más bajo (es decir, más lentas") se ordenan por latencia.

La topk (es decir, las entidades principales) permite generar informes sobre las entidades asociadas al valor más alto de una métrica determinada. De esta forma, puede filtrar las métricas de una lista de entidades que cumplan una condición concreta.

Por ejemplo, para saber qué URL de destino ha sido la que ha tenido más errores durante la última semana, se añade el parámetro topk a la solicitud con el valor 1:
```
curl https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/target_url?"select=sum(is_error)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=week&sortby=sum(is_error)&topk=1" \
  -H "Authorization: Bearer $TOKEN"
```
Donde $TOKEN es tu token de acceso OAuth 2.0, tal como se describe en Obtener un token de acceso OAuth 2.0. Para obtener información sobre las opciones de curl que se usan en este ejemplo, consulta Usar curl. Para ver una descripción de las variables de entorno que puedes usar, consulta Definir variables de entorno para solicitudes a la API de Apigee.

A continuación, se muestra un ejemplo de la respuesta:
```
{
  "environments": [
    {
      "dimensions": [
        {
          "metrics": [
            {
              "name": "sum(is_error)",
              "values": [
                {
                  "timestamp": 1494201600000,
                  "value": "12077.0"
                }
              ]
            }
          ],
          "name": "http://api.company.com"
        }
      ]...
}
```
El resultado de esta solicitud es un conjunto de métricas que muestra que la URL de destino con más errores es http://api.company.com.

También puede usar el parámetro topk para ordenar las APIs que experimentan el mayor rendimiento. En el siguiente ejemplo se obtienen métricas de la API mejor clasificada, definida por el mayor rendimiento de la última semana:
```
curl https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV}/stats/apiproxy?"select=sum(message_count)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=day&sortby=sum(message_count)&sort=DESC&topk=1" \
  -H "Authorization: Bearer $TOKEN"
```
A continuación, se muestra un ejemplo de la respuesta:
```
{
  "environments": [
    {
      "dimensions": [
        {
          "metrics": [
            {
              "name": "sum(message_count)",
              "values": [
                {
                  "timestamp": 1494720000000,
                  "value": "5750.0"
                },
                {
                  "timestamp": 1494633600000,
                  "value": "5752.0"
                },
                {
                  "timestamp": 1494547200000,
                  "value": "5747.0"
                },
                {
                  "timestamp": 1494460800000,
                  "value": "5751.0"
                },
                {
                  "timestamp": 1494374400000,
                  "value": "5753.0"
                },
                {
                  "timestamp": 1494288000000,
                  "value": "5751.0"
                },
                {
                  "timestamp": 1494201600000,
                  "value": "5752.0"
                }
              ]
            }
          ],
          "name": "testCache"
        }
      ],
      "name": "test"
    }
  ]...
}
```
Filtrar resultados

Para obtener una mayor granularidad, puede filtrar los resultados para limitar los datos devueltos. Cuando uses filtros, debes usar dimensiones como propiedades de filtro.

Por ejemplo, supongamos que necesitas obtener un recuento de errores de los servicios de backend filtrados por el verbo HTTP de la solicitud. Tu objetivo es averiguar cuántas solicitudes POST y PUT generan errores por servicio backend. Para ello, usa la dimensión target_url junto con el filtro request_verb:
```
curl https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/target_url?"select=sum(is_error)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=week&filter=(request_verb%20in%20'POST','PUT')" \
  -H "Authorization: Bearer $TOKEN"
```
Donde $TOKEN es tu token de acceso OAuth 2.0, tal como se describe en Obtener un token de acceso OAuth 2.0. Para obtener información sobre las opciones de curl que se usan en este ejemplo, consulta Usar curl. Para ver una descripción de las variables de entorno que puedes usar, consulta Definir variables de entorno para solicitudes a la API de Apigee.

Nota: Debes poner el texto del filtro entre comillas simples; por ejemplo, 'POST'. No uses comillas dobles.

A continuación, se muestra un ejemplo de la respuesta:
```
{
  "environments" : [
    {
      "dimensions" : [
        {
          "metrics" : [
            {
              "name" : "sum(is_error)",
              "values" : [
                {
                  "timestamp" : 1519516800000,
                  "value" : "1.0"
                }
              ]
          }
        ],
        "name" : "testCache"
        }
      ],
      "name" : "test"
    }
  ]...
}
```
Paginación de resultados

En los entornos de producción, algunas solicitudes a la API Analytics de Apigee devuelven conjuntos de datos muy grandes. Para que sea fácil mostrar grandes conjuntos de datos en el contexto de una aplicación basada en una interfaz de usuario, la API admite la paginación de forma nativa.

Para paginar los resultados, usa los parámetros de consulta offset y limit, así como el parámetro de ordenación sortby para asegurarte de que los elementos se ordenen de forma coherente.

Nota: Al paginar los resultados, es importante ordenarlos de forma predecible mediante el parámetro de consulta sortby. Si no se ordenan, los resultados se devuelven en un orden impredecible, lo que anula el propósito de la paginación.
El valor de sortby debe ser el mismo que el que se usa en el parámetro de consulta select. Por ejemplo, si select=sum(message_count), entonces sortby=sum(message_count).

Por ejemplo, es probable que la siguiente solicitud devuelva un conjunto de datos grande, ya que obtiene métricas de todos los errores de todas las APIs del entorno de producción de la última semana.
```
curl https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/apiproxy?"select=sum(is_error)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=week&sortby=sum(is_error)" \
  -H "Authorization: Bearer $TOKEN"
```
Donde $TOKEN es tu token de acceso OAuth 2.0, tal como se describe en Obtener un token de acceso OAuth 2.0. Para obtener información sobre las opciones de curl que se usan en este ejemplo, consulta Usar curl. Para ver una descripción de las variables de entorno que puedes usar, consulta Definir variables de entorno para solicitudes a la API de Apigee.

Si tu aplicación basada en interfaz de usuario puede mostrar razonablemente 50 resultados por página, puedes definir el límite en 50. Como 0 cuenta como el primer elemento, la siguiente llamada devuelve los elementos del 0 al 49 en orden descendente (sort=DESC es el valor predeterminado).
```
curl https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/apiproxy?"select=sum(is_error)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=week&sortby=sum(is_error)&limit=50&offset=0" \
  -H "Authorization: Bearer $TOKEN"
```
Para la segunda "página" de resultados, usa el parámetro de consulta offset, como se indica a continuación. Ten en cuenta que el límite y el desplazamiento son idénticos. Esto se debe a que 0 cuenta como el primer elemento. Con un límite de 50 y un desplazamiento de 0, se devuelven los elementos del 0 al 49. Con un desplazamiento de 50, se devuelven los elementos del 50 al 99.
```
curl https://apigee.googleapis.com/v1/organizations/$ORG/environments/$ENV/stats/apiproxy?"select=sum(is_error)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=week&sortby=sum(is_error)&limit=50&offset=50" \
  -H "Authorization: Bearer $TOKEN"
```

Usar métricas de API Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Acerca de la API de métricas

Empezar a usar la API Metrics

Especificar las métricas que se van a devolver

Especificar el periodo

Ejemplos de llamadas a la API de métricas

Ordenar los resultados por clasificación relativa

Filtrar resultados

Paginación de resultados

Usar métricas de API