Udostępnij za pośrednictwem

Biblioteka klienta usługi Azure Metrics Advisor dla języka Python — wersja 1.0.0

  • Artykuł

Metrics Advisor to skalowalna platforma do monitorowania, zgłaszania alertów i analizy głównych przyczyn w czasie rzeczywistym. Użyj klasyfikatora metryk, aby:

  • Analizowanie danych wielowymiarowych z wielu źródeł danych
  • Identyfikowanie i korelowanie anomalii
  • Konfigurowanie i dostosowywanie modelu wykrywania anomalii używanego na danych
  • Diagnozowanie anomalii i pomoc w analizie głównej przyczyny

Kod | źródłowy Pakiet (Pypi) | Dokumentacja referencyjna interfejsu | API Dokumentacja | produktu Próbki

Wprowadzenie

Instalowanie pakietu

Zainstaluj bibliotekę klienta usługi Azure Metrics Advisor dla języka Python przy użyciu narzędzia pip:

pip install azure-ai-metricsadvisor --pre

Wymagania wstępne

Uwierzytelnianie klienta

Do uwierzytelnienia klienta potrzebne będą dwa klucze:

  1. Klucz subskrypcji do zasobu Usługi Metrics Advisor. Można to znaleźć w sekcji Klucze i punkt końcowy zasobu w Azure Portal.
  2. Klucz interfejsu API dla wystąpienia usługi Metrics Advisor. Można to znaleźć w portalu internetowym dla usługi Metrics Advisor w obszarze Klucze interfejsu API w menu nawigacji po lewej stronie.

Możemy użyć kluczy do utworzenia nowego MetricsAdvisorClient lub MetricsAdvisorAdministrationClient.

import os
from azure.ai.metricsadvisor import (
    MetricsAdvisorKeyCredential,
    MetricsAdvisorClient,
    MetricsAdvisorAdministrationClient,
)

service_endpoint = os.getenv("ENDPOINT")
subscription_key = os.getenv("SUBSCRIPTION_KEY")
api_key = os.getenv("API_KEY")

client = MetricsAdvisorClient(service_endpoint,
                            MetricsAdvisorKeyCredential(subscription_key, api_key))

admin_client = MetricsAdvisorAdministrationClient(service_endpoint,
                            MetricsAdvisorKeyCredential(subscription_key, api_key))

Kluczowe pojęcia

MetricsAdvisorClient

MetricsAdvisorClient pomaga w:

  • wyświetlanie listy zdarzeń
  • wyświetlanie głównych przyczyn zdarzeń
  • pobieranie oryginalnych danych szeregów czasowych i danych szeregów czasowych wzbogaconych przez usługę.
  • wyświetlanie alertów
  • dodawanie opinii w celu dostosowania modelu

MetricsAdvisorAdministrationClient

MetricsAdvisorAdministrationClient umożliwia korzystanie z usługi

  • zarządzanie źródłami danych
  • zarządzanie konfiguracjami wykrywania anomalii
  • zarządzanie konfiguracjami alertów dotyczących anomalii
  • zarządzanie hakami

DataFeed

Elementy DataFeed , które doradca metryk pozyskają ze źródła danych, takie jak cosmos DB lub serwer SQL. Źródło danych zawiera wiersze:

  • Sygnatury czasowe
  • zero lub więcej wymiarów
  • co najmniej jedna miara

Metric

A DataFeedMetric jest miarą kwantyfikalną, która służy do monitorowania i oceniania stanu określonego procesu biznesowego. Może to być kombinacja wielu wartości szeregów czasowych podzielonych na wymiary. Na przykład metryka kondycji sieci Web może zawierać wymiary liczby użytkowników i rynku en-us.

AnomalyDetectionConfiguration

AnomalyDetectionConfiguration jest wymagany dla każdego szeregu czasowego i określa, czy punkt w szeregach czasowych jest anomalią.

& Zdarzenie anomalii

Po zastosowaniu konfiguracji wykrywania do metryk metryki są generowane za każdym razem, AnomalyIncidentgdy każda seria w niej ma wartość DataPointAnomaly.

Alerty

Można skonfigurować, które anomalie powinny wyzwalać element AnomalyAlert. Można ustawić wiele alertów z różnymi ustawieniami. Możesz na przykład utworzyć alert dotyczący anomalii z niższym wpływem na działalność biznesową, a inny dla ważniejszych alertów.

Punkt zaczepienia powiadomień

Usługa Metrics Advisor umożliwia tworzenie i subskrybowanie alertów w czasie rzeczywistym. Te alerty są wysyłane przez Internet przy użyciu elementu zaczepienia powiadomień, takiego jak EmailNotificationHook lub WebNotificationHook.

Przykłady

Dodawanie źródła danych z przykładu lub źródła danych

Usługa Metrics Advisor obsługuje łączenie różnych typów źródeł danych. Oto przykład pozyskiwania danych z SQL Server.

import os
import datetime
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import (
        SqlServerDataFeedSource,
        DataFeedSchema,
        DataFeedMetric,
        DataFeedDimension,
        DataFeedRollupSettings,
        DataFeedMissingDataPointFillSettings
    )

service_endpoint = os.getenv("ENDPOINT")
subscription_key = os.getenv("SUBSCRIPTION_KEY")
api_key = os.getenv("API_KEY")
sql_server_connection_string = os.getenv("SQL_SERVER_CONNECTION_STRING")
query = os.getenv("SQL_SERVER_QUERY")

client = MetricsAdvisorAdministrationClient(
    service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

data_feed = client.create_data_feed(
    name="My data feed",
    source=SqlServerDataFeedSource(
        connection_string=sql_server_connection_string,
        query=query,
    ),
    granularity="Daily",
    schema=DataFeedSchema(
        metrics=[
            DataFeedMetric(name="cost", display_name="Cost"),
            DataFeedMetric(name="revenue", display_name="Revenue")
        ],
        dimensions=[
            DataFeedDimension(name="category", display_name="Category"),
            DataFeedDimension(name="city", display_name="City")
        ],
        timestamp_column="Timestamp"
    ),
    ingestion_settings=datetime.datetime(2019, 10, 1),
    data_feed_description="cost/revenue data feed",
    rollup_settings=DataFeedRollupSettings(
        rollup_type="AutoRollup",
        rollup_method="Sum",
        rollup_identification_value="__CUSTOM_SUM__"
    ),
    missing_data_point_fill_settings=DataFeedMissingDataPointFillSettings(
        fill_type="SmartFilling"
    ),
    access_mode="Private"
)

return data_feed

Sprawdzanie stanu pozyskiwania

Po rozpoczęciu pozyskiwania danych możemy sprawdzić stan pozyskiwania.

import datetime
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient

service_endpoint = os.getenv("ENDPOINT")
subscription_key = os.getenv("SUBSCRIPTION_KEY")
api_key = os.getenv("API_KEY")
data_feed_id = os.getenv("DATA_FEED_ID")

client = MetricsAdvisorAdministrationClient(service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

ingestion_status = client.list_data_feed_ingestion_status(
    data_feed_id,
    datetime.datetime(2020, 9, 20),
    datetime.datetime(2020, 9, 25)
)
for status in ingestion_status:
    print("Timestamp: {}".format(status.timestamp))
    print("Status: {}".format(status.status))
    print("Message: {}\n".format(status.message))

Konfigurowanie konfiguracji wykrywania anomalii

Podczas gdy domyślna konfiguracja wykrywania jest automatycznie stosowana do każdej metryki, możemy dostosować tryby wykrywania używane na naszych danych, tworząc niestandardową konfigurację wykrywania anomalii.

from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import (
    ChangeThresholdCondition,
    HardThresholdCondition,
    SmartDetectionCondition,
    SuppressCondition,
    MetricDetectionCondition,
)

service_endpoint = os.getenv("ENDPOINT")
subscription_key = os.getenv("SUBSCRIPTION_KEY")
api_key = os.getenv("API_KEY")
metric_id = os.getenv("METRIC_ID")

client = MetricsAdvisorAdministrationClient(
    service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

change_threshold_condition = ChangeThresholdCondition(
    anomaly_detector_direction="Both",
    change_percentage=20,
    shift_point=10,
    within_range=True,
    suppress_condition=SuppressCondition(
        min_number=5,
        min_ratio=2
    )
)
hard_threshold_condition = HardThresholdCondition(
    anomaly_detector_direction="Up",
    upper_bound=100,
    suppress_condition=SuppressCondition(
        min_number=2,
        min_ratio=2
    )
)
smart_detection_condition = SmartDetectionCondition(
    anomaly_detector_direction="Up",
    sensitivity=10,
    suppress_condition=SuppressCondition(
        min_number=2,
        min_ratio=2
    )
)

detection_config = client.create_detection_configuration(
    name="my_detection_config",
    metric_id=metric_id,
    description="anomaly detection config for metric",
    whole_series_detection_condition=MetricDetectionCondition(
        condition_operator="OR",
        change_threshold_condition=change_threshold_condition,
        hard_threshold_condition=hard_threshold_condition,
        smart_detection_condition=smart_detection_condition
    )
)
return detection_config

Konfigurowanie konfiguracji alertu

Następnie skonfigurujmy, w których warunkach musi zostać wyzwolony alert.

from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import (
    MetricAlertConfiguration,
    MetricAnomalyAlertScope,
    TopNGroupScope,
    MetricAnomalyAlertConditions,
    SeverityCondition,
    MetricBoundaryCondition,
    MetricAnomalyAlertSnoozeCondition,
)
service_endpoint = os.getenv("ENDPOINT")
subscription_key = os.getenv("SUBSCRIPTION_KEY")
api_key = os.getenv("API_KEY")
anomaly_detection_configuration_id = os.getenv("DETECTION_CONFIGURATION_ID")
hook_id = os.getenv("HOOK_ID")

client = MetricsAdvisorAdministrationClient(
    service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

alert_config = client.create_alert_configuration(
    name="my alert config",
    description="alert config description",
    cross_metrics_operator="AND",
    metric_alert_configurations=[
        MetricAlertConfiguration(
            detection_configuration_id=anomaly_detection_configuration_id,
            alert_scope=MetricAnomalyAlertScope(
                scope_type="WholeSeries"
            ),
            alert_conditions=MetricAnomalyAlertConditions(
                severity_condition=SeverityCondition(
                    min_alert_severity="Low",
                    max_alert_severity="High"
                )
            )
        ),
        MetricAlertConfiguration(
            detection_configuration_id=anomaly_detection_configuration_id,
            alert_scope=MetricAnomalyAlertScope(
                scope_type="TopN",
                top_n_group_in_scope=TopNGroupScope(
                    top=10,
                    period=5,
                    min_top_count=5
                )
            ),
            alert_conditions=MetricAnomalyAlertConditions(
                metric_boundary_condition=MetricBoundaryCondition(
                    direction="Up",
                    upper=50
                )
            ),
            alert_snooze_condition=MetricAnomalyAlertSnoozeCondition(
                auto_snooze=2,
                snooze_scope="Metric",
                only_for_successive=True
            )
        ),
    ],
    hook_ids=[hook_id]
)

return alert_config

Wyniki wykrywania anomalii zapytań

Możemy wykonywać zapytania dotyczące alertów i anomalii.

import datetime
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient

service_endpoint = os.getenv("ENDPOINT")
subscription_key = os.getenv("SUBSCRIPTION_KEY")
api_key = os.getenv("API_KEY")
alert_config_id = os.getenv("ALERT_CONFIG_ID")
alert_id = os.getenv("ALERT_ID")

client = MetricsAdvisorClient(service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

results = client.list_alerts(
    alert_configuration_id=alert_config_id,
    start_time=datetime.datetime(2020, 1, 1),
    end_time=datetime.datetime(2020, 9, 9),
    time_mode="AnomalyTime",
)
for result in results:
    print("Alert id: {}".format(result.id))
    print("Create time: {}".format(result.created_time))

results = client.list_anomalies(
    alert_configuration_id=alert_config_id,
    alert_id=alert_id,
)
for result in results:
    print("Create time: {}".format(result.created_time))
    print("Severity: {}".format(result.severity))
    print("Status: {}".format(result.status))

Wykonywanie zapytań dotyczących zdarzeń

Możemy wykonywać zapytania dotyczące zdarzeń pod kątem konfiguracji wykrywania.

import datetime
from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient

service_endpoint = os.getenv("ENDPOINT")
subscription_key = os.getenv("SUBSCRIPTION_KEY")
api_key = os.getenv("API_KEY")
anomaly_detection_configuration_id = os.getenv("DETECTION_CONFIGURATION_ID")

client = MetricsAdvisorClient(service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

results = client.list_incidents(
            detection_configuration_id=anomaly_detection_configuration_id,
            start_time=datetime.datetime(2020, 1, 1),
            end_time=datetime.datetime(2020, 9, 9),
        )
for result in results:
    print("Metric id: {}".format(result.metric_id))
    print("Incident ID: {}".format(result.id))
    print("Severity: {}".format(result.severity))
    print("Status: {}".format(result.status))

Główne przyczyny zapytania

Możemy również wykonywać zapytania o główne przyczyny zdarzenia

from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorClient

service_endpoint = os.getenv("ENDPOINT")
subscription_key = os.getenv("SUBSCRIPTION_KEY")
api_key = os.getenv("API_KEY")
anomaly_detection_configuration_id = os.getenv("DETECTION_CONFIGURATION_ID")
incident_id = os.getenv("INCIDENT_ID")

client = MetricsAdvisorClient(service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

results = client.list_incident_root_causes(
            detection_configuration_id=anomaly_detection_configuration_id,
            incident_id=incident_id,
        )
for result in results:
    print("Score: {}".format(result.score))
    print("Description: {}".format(result.description))

Dodawanie punktów zaczepienia do odbierania alertów anomalii

Możemy dodać kilka punktów zaczepienia, aby po wyzwoleniu alertu można wrócić.

from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential, MetricsAdvisorAdministrationClient
from azure.ai.metricsadvisor.models import EmailNotificationHook

service_endpoint = os.getenv("ENDPOINT")
subscription_key = os.getenv("SUBSCRIPTION_KEY")
api_key = os.getenv("API_KEY")

client = MetricsAdvisorAdministrationClient(service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key))

hook = client.create_hook(
    hook=EmailNotificationHook(
        name="email hook",
        description="my email hook",
        emails_to_alert=["alertme@alertme.com"],
        external_link="https://docs.microsoft.com/en-us/azure/cognitive-services/metrics-advisor/how-tos/alerts"
    )
)

Asynchroniczne interfejsy API

Ta biblioteka zawiera kompletny interfejs API asynchroniczny obsługiwany w języku Python 3.6 lub nowszym. Aby go użyć, należy najpierw zainstalować transport asynchroniczny, taki jak aiohttp. Aby uzyskać więcej informacji, zobacz dokumentację platformy azure-core .

from azure.ai.metricsadvisor import MetricsAdvisorKeyCredential
from azure.ai.metricsadvisor.aio import MetricsAdvisorClient, MetricsAdvisorAdministrationClient

client = MetricsAdvisorClient(
    service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

admin_client = MetricsAdvisorAdministrationClient(
    service_endpoint,
    MetricsAdvisorKeyCredential(subscription_key, api_key)
)

Rozwiązywanie problemów

Ogólne

Klienci usługi Azure Metrics Advisor będą zgłaszać wyjątki zdefiniowane w usłudze Azure Core.

Rejestrowanie

Ta biblioteka używa standardowej biblioteki rejestrowania do rejestrowania.

Podstawowe informacje o sesjach HTTP (adresach URL, nagłówkach itp.) są rejestrowane na INFO poziomie.

Szczegółowe DEBUG rejestrowanie na poziomie, w tym treści żądań/odpowiedzi i nieredagowanych nagłówków, można włączyć na kliencie lub na operację za pomocą argumentu słowa kluczowego logging_enable .

Zobacz pełną dokumentację rejestrowania zestawu SDK z przykładami tutaj.

Następne kroki

Więcej przykładów kodu

Aby uzyskać więcej informacji, zobacz przykłady README.

Współtworzenie

W tym projekcie zachęcamy do współtworzenia i zgłaszania sugestii. Współtworzenie w większości przypadków wymaga zgody na umowę licencyjną dotyczącą współautorów (CLA, Contributor License Agreement), zgodnie z którą współautor ma prawo udzielić i faktycznie udziela nam praw do używania wytworzonej przez siebie zawartości. Aby uzyskać szczegółowe informacje, odwiedź cla.microsoft.com.

W tym projekcie przyjęto Kodeks postępowania oprogramowania Open Source firmy Microsoft. Aby uzyskać więcej informacji, zobacz Często zadawane pytania dotyczące kodeksu postępowania lub skontaktuj się z opencode@microsoft.com dodatkowymi pytaniami lub komentarzami.