Ta strona została przetłumaczona przez Cloud Translation API.

Korzystanie z interfejsów API wskaźników

Przeglądasz dokumentację Apigee Edge.
Przejdź do Dokumentacja Apigee X. informacje.

Apigee Edge rejestruje dane operacyjne i firmowe przesyłane przez interfejsy API. Dane uzyskane na podstawie tych danych są: jest przydatny w monitorowaniu operacyjnym i działalności biznesowej. Korzystając z Edge API Analytics, możesz: na przykład określać, które interfejsy API radzą sobie dobrze, a które słabo, a którzy deweloperzy udostępniają ruch o najwyższej wartości oraz które aplikacje powodują najwięcej problemów z usługami backendu.

Aby ułatwić dostęp do tych danych, Edge udostępnia interfejs API typu REST. Dostępne opcje używaj interfejsu Metrics API, gdy musisz zautomatyzować niektóre funkcje Analytics, np. pobieranie danych. okresowo za pomocą klienta lub skryptu automatyzacji. Możesz też użyć interfejsu API do tworzenia własnych wizualizacje w postaci widżetów niestandardowych, które można umieszczać w portalach lub aplikacjach niestandardowych.

Aby dowiedzieć się, jak korzystać z Analytics w interfejsie API Interfejs zarządzania krawędziami znajdziesz w artykule Omówienie interfejsu API Analytics.

Interfejsy API wskaźników

Edge udostępnia 2 interfejsy API wskaźników:

Uzyskiwanie danych zwraca wskaźniki dotyczące organizacji i środowiska w konkretnym okresie, np. w ciągu godziny, dnia lub tygodnia.

Na przykład dla poprzedniego tygodnia, które chcesz uzyskać:
- Liczba błędów związanych z naruszeniem zasad
- Średni czas odpowiedzi
- Łączny ruch
Porządkowanie danych według wymiarów zwraca wskaźniki z danego okresu dla organizacji i środowiska pogrupowane według wymiar.

Na przykład w poprzednim tygodniu używasz wymiarów do grupowania danych według usługi API, oraz adres e-mail dewelopera, aby uzyskać:
- Liczba błędów związanych z zasadami na usługę API
- Średni czas odpowiedzi na serwer proxy interfejsu API
- Łączny ruch na adres e-mail dewelopera
Uporządkuj dane według wymiarów Interfejs API obsługuje dodatkowe funkcje, których nie obsługuje Pobierz wskaźniki API, w tym:

Informacje o limitach interfejsu Metrics API

Edge wymusza następujące limity w przypadku tych wywołań. Limit zależy od systemu backendu, który obsługuje połączenie:

Postgres: 40 wywołań na minutę
BigQuery 12 wywołań na minutę

Określ system backendu, który obsługuje wywołanie, sprawdzając obiekt odpowiedzi. Każdy obiekt odpowiedzi zawiera właściwość metaData, która zawiera listę usług, które obsługują wywołanie we właściwości Source. Na przykład dla Postgres:

{
  ...
  "metaData": {
    "errors": [],
    "notices": [
      "Source:Postgres",
      "Table used: xxxxxx.yyyyy",
      "query served by:111-222-333"
    ]
  }
}

W BigQuery właściwość Source to:

"Source:Big Query"

Jeśli przekroczysz limit wywołań, interfejs API zwróci odpowiedź HTTP 429.

Uzyskiwanie danych za pomocą interfejsu API zarządzania

Główna różnica między tymi dwoma interfejsami API jest taka, że uzyskiwanie danych zwraca nieprzetworzone wskaźniki dla całej organizacji i środowiska, a przy tym Porządkowanie danych według wymiarów pozwala grupować dane według różnych typów elementów, np. usługi interfejsu API, dewelopera i aplikacji.

Adres URL żądania do interfejsu API GetMetric:

https://api.enterprise.apigee.com/v1/o/{org_name}/environments/{env_name}/stats

Użyj opcji Porządkowanie danych według wymiarów API, po /stats dołącz do adresu URL dodatkowy zasób, który określa odpowiedni wymiar:

https://api.enterprise.apigee.com/v1/o/{org_name}/environments/{env_name}/stats/dimension

Aby na przykład pogrupować wskaźniki według serwera proxy interfejsu API, użyj tego adresu URL do wywołania do zarządzania interfejsem API:

https://api.enterprise.apigee.com/v1/o/{org_name}/environments/{env_name}/stats/apiproxy

Określanie wskaźników do zwrócenia

Zarówno dla tagu Uzyskaj dane i Porządkowanie danych według wymiarów Interfejsy API, które używają parametru zapytania select do określania danych oraz opcjonalną funkcję agregacji w formacie:

?select=metric

lub

?select=aggFunction(metric)

Gdzie:

dane określają dane, które chcesz zwrócić. Przykład: liczbę żądań do interfejsu API, trafień w pamięci podręcznej lub błędów związanych z zasadami. Zobacz dane dla tabeli, która określa nazwę danych do użycia w parametrze zapytania select.
aggFunction określa opcjonalną funkcję agregacji uruchamianą w odniesieniu do wskaźnika. Możesz na przykład używać tych funkcji agregacji z wskaźnikiem czasu oczekiwania na przetwarzanie:
- avg: zwraca średnie opóźnienie przetwarzania.
- min: zwraca minimalne opóźnienie przetwarzania.
- max: zwraca maksymalny czas oczekiwania na przetwarzanie.
- sum: zwraca sumę wszystkich opóźnień przetwarzania.
Nie wszystkie wskaźniki obsługują wszystkie funkcje agregacji. Dokumentacja dotycząca Parametr dane zawiera tabelę, która określa nazwę danych. i funkcję (sum, avg, min, max) obsługiwaną przez dane.

Aby na przykład zwrócić średnią liczbę transakcji, czyli żądań do serwera proxy interfejsu API, na sekundę:

?select=tps

Zwróć uwagę, że ten przykład nie wymaga funkcji agregacji. W następnym przykładzie użyto funkcję agregacji, która zwraca sumę trafień w pamięci podręcznej:

?select=sum(cache_hit)

W przypadku jednego wywołania interfejsu API możesz zwrócić wiele danych. Aby uzyskać dane dotyczące sumy błędów związanych z zasadami i średni rozmiar żądania, ustaw parametr zapytania select rozdzielany przecinkami lista danych:

?select=sum(policy_error),avg(request_size)

Określanie przedziału czasu

Interfejs Metrics API zwraca dane przez określony okres. Użyj funkcji timeRange w celu określenia okresu w formacie:

?timeRange=MM/DD/YYYY%20HH:MM~MM/DD/YYYY%20HH:MM

Zwróć uwagę na %20 przed HH:MM. Parametr timeRange wymaga spacji zakodowanej w adresie URL przed HH:MM lub +, jak na adres: MM/DD/YYYY+HH:MM~MM/DD/YYYY+HH:MM.

Na przykład:

?timeRange=03/01/2018%2000:00~03/30/2018%2023:59

Nie używaj godziny 24:00, ponieważ zaczyna się od około 00:00. Użyj formatu 23:59.

Korzystanie z separatora

Aby rozdzielić kilka wymiarów w wywołaniu interfejsu API, użyj przecinka (,) jako separatora. Na przykład w wywołaniu interfejsu API

curl https://api.enterprise.apigee.com/v1/o/myorg/e/prod/stats/apis,apps?select=sum(message_count)&timeRange=9/24/2018%2000:00~10/25/2018%2000:00&timeUnit=day

wymiary apis i apps są rozdzielone znakiem ,.

Uwaga: wcześniej do tej pory nie udokumentowano użycia ukośnika, (/) jako separatora. Ten element nie jest już obsługiwany: użyj przecinka jako separatora.

Przykładowe wywołania interfejsu API

Ta sekcja zawiera przykłady użycia metod Pobierz dane i Porządkowanie danych według wymiarów API. Dodatkowe przykłady znajdziesz w przykładach interfejsu Metrics API.

Zwraca łączną liczbę wywołań interfejsów API w ciągu jednego miesiąca

Aby zobaczyć łączną liczbę wywołań wszystkich interfejsów API w organizacji i środowisku w ciągu jednego miesiąca, użyj metody Interfejs API Get Metrics:

curl -v "https://api.enterprise.apigee.com/v1/o/{org}/e/{env}/stats/?select=sum(message_count)&timeRange=03/01/2018%2000:00~03/31/2018%2023:59" \
-u email:password

Przykładowa odpowiedź:

{
  "environments": [
    {
      "metrics": [
        {
          "name": "sum(message_count)",
          "values": [
            "7.44944088E8"
          ]
        }
      ],
      "name": "prod"
    }
  ],
...
}

Zwracanie łącznej liczby wiadomości dla każdego serwera proxy interfejsu API przez 2 dni

W tym przykładzie zwracasz wskaźniki liczby żądań otrzymanych przez wszystkie serwery proxy interfejsu API. w okresie 2 dni. Parametr zapytania select określa funkcję agregacji sum dla wskaźnika message_count w wymiarze apiproxy. Raport zwraca przepustowość wiadomości z żądaniem dla wszystkich interfejsów API dla ruchu otrzymanego między 20 czerwca 2018 r. a końcem 21 czerwca 2018 roku, w Czas UTC:

curl  https://api.enterprise.apigee.com/v1/o/{org_name}/e/{env}/stats/apiproxy?"select=sum(message_count)&timeRange=06/20/2018%2000:00~06/21/2018%2023:59" \
-u email:password

Przykładowa odpowiedź:

{
  "environments" : [ {
    "dimensions" : [ {
      "metrics" : [ {
        "name" : "sum(message_count)",
        "values" : [ {
          "timestamp" : 1498003200000,
          "value" : "1100.0"
        } ]
      } ],
      "name" : "target-reroute"
    } ],
    "name" : "test"
  } ]...
}

Ta odpowiedź wskazuje, że jeden serwer proxy interfejsu API odebrał 1100 komunikatów „target-reroute” działające w środowisku testowym między 20 czerwca 2018 r. a końcem 21.06.2018 r.

Wskazówka: pamiętaj, że sygnatura czasowa, 1498003200000, znajduje się w Format sygnatury czasowej systemu Unix. W internecie dostępnych jest wiele narzędzi do konwersji zawierających sygnatury czasowe uniksowe. których możesz użyć do zdekodowania tych sygnatur czasowych.

Aby uzyskać dane dotyczące innych wymiarów, jako parametr URI wybierz inny wymiar. Dla: możesz na przykład określić wymiar developer_app, o którym będą pobierane dane aplikacji programistycznych. Poniższe wywołanie interfejsu API zwraca łączną przepustowość (otrzymane wiadomości) ze wszystkich aplikacji w określonym przedziale czasu:

curl  https://api.enterprise.apigee.com/v1/o/{org_name}/e/{env}/stats/developer_app?"select=sum(message_count)&timeRange=06/20/2018%2000:00~06/21/2018%2023:59&timeUnit=day" \
-u email:password

Przykładowa odpowiedź:

{
  "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"
        }
  ]...
}

Sortowanie wyników według rankingu względnego

Często przy uzyskiwaniu danych chcesz uzyskać wyniki tylko dla podzbioru łącznego zbioru i skalowalnych danych. Zwykle potrzebne są wyniki z listy „10 najlepszych”, np. „10 najwolniejszych” API”, czyli „10 najbardziej aktywnych aplikacji”. Możesz to zrobić, korzystając z parametru zapytania topk do wniosku.

Być może chcesz się na przykład dowiedzieć, kim są Twoi najlepsi deweloperzy na podstawie przepustowości, lub jakie słowa kluczowe są najmniej skuteczne (np. docelowych interfejsów API, biorąc pod uwagę czas oczekiwania.

topk (czyli „pierwsze k” elementów) umożliwia generowanie raportów o powiązanych elementach. o najwyższej wartości danego wskaźnika. Dzięki temu możesz filtrować dane według listy: które ilustrują określony warunek. Aby na przykład sprawdzić, który docelowy URL był najbardziej podatne na błędy w ciągu ostatniego tygodnia, do żądania jest dołączany parametr topk, z wartością 1:

curl https://api.enterprise.apigee.com/v1/o/{org_name}/e/{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" \
  -u email:password

{
  "environments": [
    {
      "dimensions": [
        {
          "metrics": [
            {
              "name": "sum(is_error)",
              "values": [
                {
                  "timestamp": 1494201600000,
                  "value": "12077.0"
                }
              ]
            }
          ],
          "name": "http://api.company.com"
        }
      ]...
}

Wynikiem tego żądania jest zbiór wskaźników wskazujących, że najbardziej błędny docelowy adres URL to http://api.company.com

Możesz też użyć parametru topk, aby posortować interfejsy API o największej wartości i przepustowości. Ten przykład pobiera dane z interfejsu API o najwyższym rankingu, zdefiniowane przez w ciągu ostatniego tygodnia:

curl https://api.enterprise.apigee.com/v1/o/{org_name}/e/{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" \
-u email:password

Przykładowa odpowiedź

{
  "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"
    }
  ]...
}

Filtrowanie wyników

Aby uzyskać większą szczegółowość, możesz filtrować wyniki, aby ograniczyć ilość zwracanych danych. W przypadku użycia funkcji musisz użyć wymiarów jako właściwości filtra.

Załóżmy na przykład, że musisz pobrać liczbę błędów z usług backendu odfiltrowane według czasownika HTTP z żądania. Chcesz się dowiedzieć, ile żądań POST i PUT generują błędy na usługę backendu. Używa się do tego wymiaru target_url wraz z filtrem request_verb:

curl https://api.enterprise.apigee.com/v1/o/{org_name}/e/{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')" \
-u email:password

Przykładowa odpowiedź:

{
  "environments" : [
    {
      "dimensions" : [
        {
          "metrics" : [
            {
              "name" : "sum(is_error)",
              "values" : [
                {
                  "timestamp" : 1519516800000,
                  "value" : "1.0"
                }
              ]
          }
        ],
        "name" : "testCache"
        }
      ],
      "name" : "test"
    }
  ]...
}

Uwaga: nie używaj / jako skrótu do filtrów. Dla: następujące jest prawidłowe wywołanie:

curl https://api.enterprise.apigee.com/v1/o/myorg/e/prod/stats/apis?filter=(apis eq 'myapp')&select=sum(message_count)&timeRange=9/24/2018%2000:00~10/25/2018%2000:00&timeUnit=day

W tej rozmowie nie zastępuj parametru apis?filter=(apis eq 'myapp')&select= ciągiem skrót apis/myapp?select=.

Podział wyników na strony

W środowiskach produkcyjnych niektóre żądania do interfejsu Edge Analytics API zwracają bardzo duże dane. zestawów. Aby ułatwić wyświetlanie dużych zbiorów danych w kontekście aplikacji opartej na interfejsie użytkownika, Interfejs API natywnie obsługuje dzielenie na strony.

Aby podzielić wyniki na strony, używaj parametrów zapytania offset i limit. wraz z parametrem sortowania sortby, aby zapewnić spójność kolejności elementy(ów).

Uwaga: przy dzieleniu wyników na strony ważne jest, aby posortować wyniki w przewidywalny sposób za pomocą parametr zapytania sortby. Bez sortowania wyniki są zwracane w nieprzewidywalny porządek, który sprzeczny jest z celem podziału na strony;

Wartość sortby musi być taka sama jak wartość użyta w zapytaniu select . Jeśli np. select=sum(message_count), to sortby=sum(message_count)

Na przykład poniższe żądanie prawdopodobnie zwróci duży zbiór danych, ponieważ pobiera wskaźniki dotyczące wszystkich błędów dotyczących wszystkich interfejsów API w środowisku usługi za ostatni tydzień.

curl https://api.enterprise.apigee.com/v1/o/{org_name}/e/{env}/stats/apiproxy?"select=sum(is_error)&timeRange=05/08/2018%2000:00~05/15/2018%2000:00&timeUnit=week&sortby=sum(is_error)" \
-u email:password

Jeśli Twoja aplikacja korzystająca z interfejsu użytkownika może w rozsądny sposób wyświetlić 50 wyników na stronie, możesz ustawić limit. do 50. Wartość 0 jest liczona jako pierwszy element, więc kolejne wywołanie zwraca elementy 0–49 w kolejności malejącej w kolejności (domyślnie sort=DESC).

curl https://api.enterprise.apigee.com/v1/o/{org_name}/e/{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" \
-u email:password

W przypadku drugiej „strony” wyników, użyj parametru zapytania przesunięcia w następujący sposób. Pamiętaj, że parametr są takie same. Wynika to z tego, że wartość 0 jest liczona jako pierwszy element. Z limitem wynoszącym 50 i przesunięcie 0, zwracane są elementy 0–49. Jeśli ustawisz przesunięcie o 50, zwracane są elementy 50–99.

curl https://api.enterprise.apigee.com/v1/o/{org_name}/e/{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" \
-u email:password