Megosztás a következőn keresztül:

Azure Metrics Advisor ügyfélkódtár JavaScripthez – 1.0.0-s verzió

A Metrics Advisor az Azure Cognitive Services része, amely AI-t használ az adatmonitorozás és anomáliadetektálás idősorozat-adatokban való végrehajtásához. A szolgáltatás automatizálja a modellek adatokra való alkalmazásának folyamatát, és api-k webes munkaterületét biztosítja az adatbetöltéshez, az anomáliadetektáláshoz és a diagnosztikahoz anélkül, hogy ismernie kellene a gépi tanulást. A Metrics Advisor használatával:

  • Többdimenziós adatok elemzése több adatforrásból
  • Anomáliák azonosítása és korrelálása
  • Az adatokon használt anomáliadetektálási modell konfigurálása és finomhangolása
  • Az anomáliák diagnosztizálása és segítség a kiváltó okok elemzésében.

Főbb hivatkozások:

Első lépések

Jelenleg támogatott környezetek

További részletekért tekintse meg támogatási szabályzatunkat .

Előfeltételek

Ha az Azure CLI-t használja, cserélje le <your-resource-group-name> a és <your-resource-name> nevet a saját egyedi nevére:

az cognitiveservices account create --kind MetricsAdvisor --resource-group <your-resource-group-name> --name <your-resource-name> --sku <sku level> --location <location>

Telepítse a(z) @azure/ai-metrics-advisor csomagot

Telepítse a JavaScripthez készült Azure Metrics Advisor ügyfélkódtárat a következővel npm:

npm install @azure/ai-metrics-advisor

Létrehozás és hitelesítés MetricsAdvisorClient vagy MetricsAdvisorAdministrationClient

Ahhoz, hogy létrehozhasson egy ügyfélobjektumot a Metrics Advisor API eléréséhez, szüksége lesz a endpoint Metrics Advisor-erőforrásra és egy credential. A Metrics Advisor-ügyfelek a Metrics Advisor kulcs hitelesítő adatait használják a hitelesítéshez.

A Metrics Advisor-erőforrás végpontját az Azure Portalon vagy az alábbi Azure CLI-kódrészlet használatával találja meg:

az cognitiveservices account show --name <your-resource-name> --resource-group <your-resource-group-name> --query "endpoint"

Előfizetési kulcs és API-kulcs használata

Az ügyfél hitelesítéséhez két kulcs szükséges:

  • A Metrics Advisor-erőforrás előfizetési kulcsa. Ezt az erőforrás Kulcsok és végpontok szakaszában találja az Azure Portalon.
  • A Metrics Advisor-példány API-kulcsa. Ezt a Metrics Advisor webes portálján, a bal oldali navigációs menü API-kulcsaiban találja. A webportál URL-címe az erőforrás Áttekintés szakaszában található az Azure Portalon.

Az Azure Portalon keresse meg a Metrics Advisor-erőforrást, és kérjen le egy előfizetési kulcsot, vagy használja az alábbi Azure CLI-kódrészletet :

az cognitiveservices account keys list --resource-group <your-resource-group-name> --name <your-resource-name>

Emellett szüksége lesz a Metrics Advisor webportál felhasználónkénti API-kulcsára is.

Miután megkapta a két kulcsot és végpontot, a MetricsAdvisorKeyCredential osztály használatával hitelesítheti az ügyfeleket az alábbiak szerint:

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorClient,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");

const credential = new MetricsAdvisorKeyCredential("<subscription Key>", "<API key>");

const client = new MetricsAdvisorClient("<endpoint>", credential);
const adminClient = new MetricsAdvisorAdministrationClient("<endpoint>", credential);

Az Azure Service Directory használata

Az API-kulcsok hitelesítése a legtöbb példában használatos, de az azure-identitástár használatával is hitelesítheti az ügyfelet az Azure Active Directoryval. Az alább látható DefaultAzureCredential szolgáltató vagy az Azure SDK-hoz biztosított egyéb hitelesítőadat-szolgáltatók használatához telepítse a @azure/identity csomagot:

npm install @azure/identity

A szolgáltatásnévvel történő hitelesítéshez regisztrálnia kell egy AAD-alkalmazást is, és hozzáférést kell adnia a Metrics Advisorhoz úgy, hogy hozzárendeli a "Cognitive Services-felhasználó" szerepkört a szolgáltatásnévhez (megjegyzés: más szerepkörök, például a "Tulajdonos" nem biztosítják a szükséges engedélyeket, csak a "Cognitive Services-felhasználó" elegendő a példák és a mintakód futtatásához).

Állítsa be az AAD-alkalmazás ügyfél-azonosítójának, bérlőazonosítójának és titkos ügyfélkulcsának értékeit környezeti változókként: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET. Az Azure Active Directoty-hitelesítő adatok hitelesítését is támogatjuk. Környezeti változókként szüksége lesz az Azure-bérlőazonosítóra, az Azure-ügyfél-azonosítóra és az Azure Client Secretre.

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorClient,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");
import { DefaultAzureCredential } from "@azure/identity";
const credential = new DefaultAzureCredential();
const client = new MetricsAdvisorClient("<endpoint>", credential);
const adminClient = new MetricsAdvisorAdministrationClient("<endpoint>", credential);

Fő fogalmak

MetricsAdvisorClient

MetricsAdvisorClient A a Metrics Advisor ügyfélkódtárat használó fejlesztők elsődleges lekérdezési felülete. Aszinkron módszereket biztosít a Metrics Advisor adott használatának eléréséhez, például az incidensek listázásához, az incidensek kiváltó okainak újrapróbálásához, az eredeti idősoradatok lekéréséhez és a szolgáltatás által bővített idősoradatokhoz.

MetricsAdvisorAdministrationClient

MetricsAdvisorAdministrationClient A a Metrics Advisor-erőforrások entitásainak kezeléséért felelős felület, például az adatcsatornák, az anomáliadetektálási konfigurációk és az anomáliadetektálási konfigurációk kezelése.

Adatcsatorna

A Metrics Advisor az adatforrásból, például a Cosmos DB-ből vagy egy SQL Serverből származó adatcsatornát használ. Az adatcsatornák a következő sorokat tartalmazzák:

  • Időbélyegek
  • nulla vagy több dimenzió
  • egy vagy több mérték

Metrika

A metrika egy számszerűsíthető mérték, amely egy adott üzleti folyamat állapotának monitorozására és értékelésére szolgál. Több idősor értékeinek kombinációja lehet dimenziókra osztva. Egy webes állapotmetrika például tartalmazhat dimenziókat a felhasználók számához és az en-us piachoz.

AnomalyDetectionConfiguration

AnomalyDetectionConfiguration minden idősorhoz szükséges, és meghatározza, hogy az idősor egy pontja anomália-e.

Anomália & incidens

Miután alkalmazta az észlelési konfigurációt a metrikákra, a rendszer s-eket hoz létre, AnomalyIncidentamikor a benne lévő összes adatsor rendelkezik egy DataPointAnomaly.

Riasztás

Konfigurálhatja, hogy mely anomáliák aktiválják a eseményt AnomalyAlert. Több riasztást is beállíthat különböző beállításokkal. Létrehozhat például egy alacsonyabb üzleti hatással rendelkező anomáliákra vonatkozó riasztást, egy másikat pedig a fontosabb riasztásokhoz.

Horog

A Metrics Advisor segítségével valós idejű riasztásokat hozhat létre és iratkozhat fel. Ezeket a riasztásokat az interneten keresztül, egy értesítési horog használatával küldi el a rendszer.

A fogalmak átfogó listáját a Metrics Advisory Glossary dokumentációs oldalán találja.

Példák

A következő szakasz számos JavaScript-kódrészletet tartalmaz, amely a Metrics Advisor ügyfélkódtárakban használt gyakori mintákat szemlélteti.

Adatcsatorna hozzáadása mintaadatforrásból

A Metrics Advisor támogatja a különböző típusú adatforrások összekapcsolását. Íme egy minta a SQL Server adatainak betöltéséhez.

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");

async function main() {
  // You will need to set these environment variables or edit the following values
  const endpoint = process.env["METRICS_ADVISOR_ENDPOINT"] || "<service endpoint>";
  const subscriptionKey = process.env["METRICS_ADVISOR_SUBSCRIPTION_KEY"] || "<subscription key>";
  const apiKey = process.env["METRICS_ADVISOR_API_KEY"] || "<api key>";
  const sqlServerConnectionString =
    process.env["METRICS_ADVISOR_SQL_SERVER_CONNECTION_STRING"] ||
    "<connection string to SQL Server>";
  const sqlServerQuery =
    process.env["METRICS_ADVISOR_AZURE_SQL_SERVER_QUERY"] || "<SQL Server query to retrive data>";
  const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);

  const adminClient = new MetricsAdvisorAdministrationClient(endpoint, credential);

  const created = await createDataFeed(adminClient, sqlServerConnectionString, sqlServerQuery);
  console.log(`Data feed created: ${created.id}`);
}

async function createDataFeed(adminClient, sqlServerConnectionString, sqlServerQuery) {
  console.log("Creating Datafeed...");
  const dataFeed = {
    name: "test_datafeed_" + new Date().getTime().toString(),
    source: {
      dataSourceType: "SqlServer",
      connectionString: sqlServerConnectionString,
      query: sqlServerQuery,
      authenticationType: "Basic"
    },
    granularity: {
      granularityType: "Daily"
    },
    schema: {
      metrics: [
        {
          name: "revenue",
          displayName: "revenue",
          description: "Metric1 description"
        },
        {
          name: "cost",
          displayName: "cost",
          description: "Metric2 description"
        }
      ],
      dimensions: [
        { name: "city", displayName: "city display" },
        { name: "category", displayName: "category display" }
      ],
      timestampColumn: null
    },
    ingestionSettings: {
      ingestionStartTime: new Date(Date.UTC(2020, 5, 1)),
      ingestionStartOffsetInSeconds: 0,
      dataSourceRequestConcurrency: -1,
      ingestionRetryDelayInSeconds: -1,
      stopRetryAfterInSeconds: -1
    },
    rollupSettings: {
      rollupType: "AutoRollup",
      rollupMethod: "Sum",
      rollupIdentificationValue: "__CUSTOM_SUM__"
    },
    missingDataPointFillSettings: {
      fillType: "SmartFilling"
    },
    accessMode: "Private",
    admins: ["xyz@example.com"]
  };
  const result = await adminClient.createDataFeed(dataFeed);

  return result;
}

A betöltési állapot ellenőrzése

Az adatbetöltés megkezdése után ellenőrizheti a betöltési állapotot.

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");

async function main() {
  // You will need to set these environment variables or edit the following values
  const endpoint = process.env["METRICS_ADVISOR_ENDPOINT"] || "<service endpoint>";
  const subscriptionKey = process.env["METRICS_ADVISOR_SUBSCRIPTION_KEY"] || "<subscription key>";
  const apiKey = process.env["METRICS_ADVISOR_API_KEY"] || "<api key>";
  const dataFeedId = process.env["METRICS_DATAFEED_ID"] || "<data feed id>";
  const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);

  const adminClient = new MetricsAdvisorAdministrationClient(endpoint, credential);
  await checkIngestionStatus(
    adminClient,
    dataFeedId,
    new Date(Date.UTC(2020, 8, 1)),
    new Date(Date.UTC(2020, 8, 12))
  );
}

async function checkIngestionStatus(adminClient, datafeedId, startTime, endTime) {
  // This shows how to use for-await-of syntax to list status
  console.log("Checking ingestion status...");
  const iterator = adminClient.listDataFeedIngestionStatus(datafeedId, startTime, endTime);
  for await (const status of iterator) {
    console.log(`  [${status.timestamp}] ${status.status} - ${status.message}`);
  }
}

Anomáliadetektálási konfiguráció konfigurálása

Anomáliadetektálási konfigurációra van szükségünk annak meghatározásához, hogy az idősor egy pontja anomália-e. Bár a rendszer automatikusan alkalmaz egy alapértelmezett észlelési konfigurációt az egyes metrikákra, az adatokon használt észlelési módokat testre szabott anomáliadetektálási konfiguráció létrehozásával hangolhatja.

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");

async function main() {
  // You will need to set these environment variables or edit the following values
  const endpoint = process.env["METRICS_ADVISOR_ENDPOINT"] || "<service endpoint>";
  const subscriptionKey = process.env["METRICS_ADVISOR_SUBSCRIPTION_KEY"] || "<subscription key>";
  const apiKey = process.env["METRICS_ADVISOR_API_KEY"] || "<api key>";
  const metricId = process.env["METRICS_ADVISOR_METRIC_ID"] || "<metric id>";
  const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);

  const adminClient = new MetricsAdvisorAdministrationClient(endpoint, credential);

  const detectionConfig = await configureAnomalyDetectionConfiguration(adminClient, metricId);
  console.log(`Detection configuration created: ${detectionConfig.id}`);
}

async function configureAnomalyDetectionConfiguration(adminClient, metricId) {
  console.log(`Creating an anomaly detection configuration on metric '${metricId}'...`);
  const anomalyConfig = {
    name: "test_detection_configuration" + new Date().getTime().toString(),
    metricId,
    wholeSeriesDetectionCondition: {
      smartDetectionCondition: {
        sensitivity: 100,
        anomalyDetectorDirection: "Both",
        suppressCondition: {
          minNumber: 1,
          minRatio: 1
        }
      }
    },
    description: "Detection configuration description"
  };
  return await adminClient.createDetectionConfig(anomalyConfig);
}

Horgok hozzáadása anomáliariasztások fogadásához

Horogokat használunk a valós idejű riasztásokra való feliratkozáshoz. Ebben a példában létrehozunk egy webhookot a Metrics Advisor szolgáltatáshoz, amellyel közzétehetjük a riasztást.

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");

async function main() {
  // You will need to set these environment variables or edit the following values
  const endpoint = process.env["METRICS_ADVISOR_ENDPOINT"] || "<service endpoint>";
  const subscriptionKey = process.env["METRICS_ADVISOR_SUBSCRIPTION_KEY"] || "<subscription key>";
  const apiKey = process.env["METRICS_ADVISOR_API_KEY"] || "<api key>";
  const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);

  const adminClient = new MetricsAdvisorAdministrationClient(endpoint, credential);
  const hook = await createWebhookHook(adminClient);
  console.log(`Webhook hook created: ${hook.id}`);
}

async function createWebhookHook(adminClient) {
  console.log("Creating a webhook hook");
  const hook = {
    hookType: "Webhook",
    name: "web hook " + new Date().getTime().toString(),
    description: "description",
    hookParameter: {
      endpoint: "https://example.com/handleAlerts",
      username: "username",
      password: "password"
      // certificateKey: "certificate key",
      // certificatePassword: "certificate password"
    }
  };

  return await adminClient.createHook(hook);
}

Riasztáskonfiguráció konfigurálása

Ezután konfiguráljuk, hogy milyen feltételek mellett kell aktiválni egy riasztást, és hogy mely horgok küldjék el a riasztást.

const {
  MetricsAdvisorKeyCredential,
  MetricsAdvisorAdministrationClient
} = require("@azure/ai-metrics-advisor");

async function main() {
  // You will need to set these environment variables or edit the following values
  const endpoint = process.env["METRICS_ADVISOR_ENDPOINT"] || "<service endpoint>";
  const subscriptionKey = process.env["METRICS_ADVISOR_SUBSCRIPTION_KEY"] || "<subscription key>";
  const apiKey = process.env["METRICS_ADVISOR_API_KEY"] || "<api key>";
  const detectionConfigId = process.env["METRICS_ADVISOR_DETECTION_CONFIG_ID"] || "<detection id>";
  const hookId = process.env["METRICS_ADVISOR_HOOK_ID"] || "<hook id>";
  const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);

  const adminClient = new MetricsAdvisorAdministrationClient(endpoint, credential);
  const alertConfig = await configureAlertConfiguration(adminClient, detectionConfigId, [hookId]);
  console.log(`Alert configuration created: ${alertConfig.id}`);
}

async function configureAlertConfiguration(adminClient, detectionConfigId, hookIds) {
  console.log("Creating a new alerting configuration...");
  const anomalyAlertConfig = {
    name: "test_alert_config_" + new Date().getTime().toString(),
    crossMetricsOperator: "AND",
    metricAlertConfigurations: [
      {
        detectionConfigurationId: detectionConfigId,
        alertScope: {
          scopeType: "All"
        },
        alertConditions: {
          severityCondition: { minAlertSeverity: "Medium", maxAlertSeverity: "High" }
        },
        snoozeCondition: {
          autoSnooze: 0,
          snoozeScope: "Metric",
          onlyForSuccessive: true
        }
      }
    ],
    hookIds,
    description: "Alerting config description"
  };
  return await adminClient.createAlertConfig(anomalyAlertConfig);
}

Anomáliadetektálási eredmények lekérdezése

Lekérdezhetjük a riasztásokat és az anomáliákat.

const { MetricsAdvisorKeyCredential, MetricsAdvisorClient } = require("@azure/ai-metrics-advisor");

async function main() {
  // You will need to set these environment variables or edit the following values
  const endpoint = process.env["METRICS_ADVISOR_ENDPOINT"] || "<service endpoint>";
  const subscriptionKey = process.env["METRICS_ADVISOR_SUBSCRIPTION_KEY"] || "<subscription key>";
  const apiKey = process.env["METRICS_ADVISOR_API_KEY"] || "<api key>";
  const alertConfigId = process.env["METRICS_ADVISOR_ALERT_CONFIG_ID"] || "<alert config id>";
  const credential = new MetricsAdvisorKeyCredential(subscriptionKey, apiKey);

  const client = new MetricsAdvisorClient(endpoint, credential);

  const alerts = await queryAlerts(
    client,
    alertConfigId,
    new Date(Date.UTC(2020, 8, 1)),
    new Date(Date.UTC(2020, 8, 12))
  );

  if (alerts.length > 1) {
    // query anomalies using an alert id.
    await queryAnomaliesByAlert(client, alerts[0]);
  } else {
    console.log("No alerts during the time period");
  }
}

async function queryAlerts(client, alertConfigId, startTime, endTime) {
  let alerts = [];
  const iterator = client.listAlerts(alertConfigId, startTime, endTime, "AnomalyTime");
  for await (const alert of iterator) {
    alerts.push(alert);
  }

  return alerts;
}

async function queryAnomaliesByAlert(client, alert) {
  console.log(
    `Listing anomalies for alert configuration '${alert.alertConfigId}' and alert '${alert.id}'`
  );
  const iterator = client.listAnomaliesForAlert(alert);
  for await (const anomaly of iterator) {
    console.log(
      `  Anomaly ${anomaly.severity} ${anomaly.status} ${anomaly.seriesKey} ${anomaly.timestamp}`
    );
  }
}

Hibaelhárítás

Naplózás

A naplózás engedélyezése hasznos információkat deríthet fel a hibákról. A HTTP-kérések és -válaszok naplójának megtekintéséhez állítsa a környezeti változót értékre AZURE_LOG_LEVELinfo. A naplózás futásidőben is engedélyezhető a következő hívásával setLogLevel@azure/logger:

import { setLogLevel } from "@azure/logger";

setLogLevel("info");

A naplók engedélyezésére vonatkozó részletesebb utasításokért tekintse meg a @azure/logger csomag dokumentációját.

Következő lépések

A kódtár használatára vonatkozó részletes példákért tekintse meg a mintakönyvtárat.

Közreműködés

Ha szeretne közreműködni ebben a könyvtárban, olvassa el a közreműködői útmutatót , amelyből többet is megtudhat a buildelésről és a tesztelésről
a kódot.

Megjelenések

  • Last updated on