Sdílet prostřednictvím


Klientská knihovna Azure Load Testing pro JavaScript – verze 1.0.1

Azure Load Testing poskytuje klientovi v JavaScriptu klientskou knihovnu, pomocí které může nativně pracovat se službou Azure Load Testing. Azure Load Testing je plně spravovaná služba zátěžového testování, která umožňuje generovat zatížení ve velkém měřítku. Služba simuluje provoz pro vaše aplikace bez ohledu na to, kde jsou hostované. Vývojáři, testeři a technici kontroly kvality ho můžou použít k optimalizaci výkonu, škálovatelnosti nebo kapacity aplikací.

Pokud chcete používat tuto knihovnu, spoléhat se na naši klientských dokumentů REST.

Dokumentace

K dispozici je různá dokumentace, která vám pomůže začít.

  • zdrojového kódu
  • Referenční dokumentace k rozhraní API
  • dokumentace k produktu

Začínáme

Aktuálně podporovaná prostředí

Požadavky

  • Abyste mohli tento balíček používat, musíte mít předplatné Azure a prostředek služby Azure Load Test Service.

Instalace balíčku @azure-rest/load-testing

Nainstalujte klientskou knihovnu REST pro AzureLoadTesting pro JavaScript s npm:

npm install @azure-rest/load-testing

Vytvoření a ověření klienta AzureLoadTesting

Pokud chcete použít přihlašovací údaje tokenu Azure Active Directory (AAD), zadejte instanci požadovaného typu přihlašovacích údajů získaného z knihovny @azure/identity.

Pokud se chcete ověřit pomocí AAD, musíte nejdřív npm nainstalovat @azure/identity

Po nastavení můžete z @azure/identity zvolit, jaký typ přihlašovacích údajů použít. Například DefaultAzureCredential lze použít k ověření klienta.

Nastavte hodnoty ID klienta, ID tenanta a tajného klíče klienta aplikace AAD jako proměnné prostředí: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET

import AzureLoadTesting, { AzureLoadTestingClient } from "@azure-rest/load-testing";
import { DefaultAzureCredential } from "@azure/identity";

const Client: AzureLoadTestingClient = AzureLoadTesting(Endpoint, new DefaultAzureCredential());

Klíčové koncepty

Následující komponenty tvoří službu Azure Load Testing. Klientská knihovna Azure Load Test pro JavaScript umožňuje interakci s každou z těchto komponent pomocí vyhrazeného klientského objektu.

Test

Test určuje testovací skript a nastavení konfigurace pro spuštění zátěžového testu. V prostředku Azure Load Testing můžete vytvořit jeden nebo více testů.

Komponenta aplikace

Když spustíte zátěžový test pro aplikaci hostované v Azure, můžete monitorovat metriky prostředků pro různé komponenty aplikací Azure (metriky na straně serveru). Během spuštění zátěžového testu a po dokončení testu můžete monitorovat a analyzovat metriky prostředků na řídicím panelu Azure Load Testing.

Metrika

Během zátěžového testu shromažďuje Zátěžové testování Azure metriky o spuštění testu. Existují dva typy metrik:

  1. Metriky na straně klienta poskytují podrobnosti hlášené testovacím modulem. Mezi tyto metriky patří počet virtuálních uživatelů, doba odezvy požadavku, počet neúspěšných požadavků nebo počet požadavků za sekundu.

  2. Metriky na straně serveru jsou k dispozici pro aplikace hostované v Azure a poskytují informace o komponentách aplikací Azure. Metriky můžou být určené pro počet čtení databáze, typ odpovědí HTTP nebo spotřebu prostředků kontejneru.

Testovací modul

Testovací modul je výpočetní infrastruktura, která spouští testovací skript Apache JMeter. Zátěžový test můžete škálovat konfigurací počtu testovacích modulů. Testovací skript běží paralelně napříč zadaným počtem testovacích modulů.

Testovací běh

Testovací běh představuje jeden spuštění zátěžového testu. Shromažďuje protokoly přidružené ke spuštění skriptu Apache JMeter, konfiguraci YAML zátěžového testu, seznam komponent aplikace pro monitorování a výsledky testu.

koncový bod Data-Plane

Rovina dat prostředků služby Azure Load Testing je adresovatelná pomocí následujícího formátu adresy URL:

00000000-0000-0000-0000-000000000000.aaa.cnt-prod.loadtesting.azure.com

První identifikátor GUID 00000000-0000-0000-0000-000000000000 je jedinečný identifikátor používaný pro přístup k prostředku azure Load Testing. Následuje aaa, což je oblast Azure prostředku.

Koncový bod roviny dat se získává z rozhraní API řídicí roviny.

Příklad :1234abcd-12ab-12ab-12ab-123456abcdef.eus.cnt-prod.loadtesting.azure.com

V předchozím příkladu eus představuje oblast Azure East US.

Příklady

Vytvoření zátěžového testu

import { AzureLoadTestingClient } from "@azure-rest/load-testing";
import AzureLoadTesting from "@azure-rest/load-testing";
import { DefaultAzureCredential } from "@azure/identity";

var TEST_ID = "some-test-id";
var DISPLAY_NAME = "my-load-test";

const client: AzureLoadTestingClient = AzureLoadTesting("<Endpoint>", new DefaultAzureCredential());

await client.path("/tests/{testId}", TEST_ID).patch({
  contentType: "application/merge-patch+json",
  body: {
    displayName: DISPLAY_NAME,
    description: "",
    loadTestConfiguration: {
      engineInstances: 1,
      splitAllCSVs: false,
    },
    secrets: {},
    environmentVariables: {},
    passFailCriteria: { passFailMetrics: {} },
  },
});

Nahrání souboru .jmx do testu

import { AzureLoadTestingClient, getLongRunningPoller, isUnexpected } from "@azure-rest/load-testing";
import AzureLoadTesting from "@azure-rest/load-testing";
import { DefaultAzureCredential } from "@azure/identity";
import { createReadStream } from "fs";

const client: AzureLoadTestingClient = AzureLoadTesting("<Endpoint>", new DefaultAzureCredential());

var TEST_ID = "some-test-id";
const readStream = createReadStream("./sample.jmx");

const fileUploadResult = await client
  .path("/tests/{testId}/files/{fileName}", TEST_ID, "sample.jmx")
  .put({
    contentType: "application/octet-stream",
    body: readStream,
  });

if (isUnexpected(fileUploadResult)) {
  throw fileUploadResult.body.error;
}

let fileValidateResult;
const fileValidatePoller = await getLongRunningPoller(client, fileUploadResult);
try{
fileValidateResult = await fileValidatePoller.pollUntilDone({
  abortSignal: AbortSignal.timeout(120*1000), // timeout of 120 seconds
});} catch (ex: any) {
new Error("Error in polling file Validation" + ex.message); //polling timed out
}

if (fileValidatePoller.getOperationState().status != "succeeded" && fileValidateResult)
  throw new Error(
    "There is some issue in validation, please make sure uploaded file is a valid JMX." +
      fileValidateResult.body.validationFailureDetails
  );

Spuštění testu a načtení metrik

import { AzureLoadTestingClient, getLongRunningPoller, isUnexpected } from "@azure-rest/load-testing";
import AzureLoadTesting from "@azure-rest/load-testing";
import { DefaultAzureCredential } from "@azure/identity";

const client: AzureLoadTestingClient = AzureLoadTesting("<Endpoint>", new DefaultAzureCredential());

var TEST_ID = "some-test-id";
var DISPLAY_NAME = "my-load-test";
var TEST_RUN_ID = "some-test-run-id";

// Creating/Updating the test run
const testRunCreationResult = await client.path("/test-runs/{testRunId}", TEST_RUN_ID).patch({
  contentType: "application/merge-patch+json",
  body: {
    testId: TEST_ID,
    displayName: DISPLAY_NAME,
  },
});

if (isUnexpected(testRunCreationResult)) {
  throw testRunCreationResult.body.error;
}

if (testRunCreationResult.body.testRunId === undefined)
  throw new Error("Test Run ID returned as undefined.");

const testRunPoller = await getLongRunningPoller(client, testRunCreationResult);
  let testRunResult;

  try {
    testRunResult = await testRunPoller.pollUntilDone({
      abortSignal: AbortSignal.timeout(60000), // timeout of 60 seconds
    });
  } catch (ex: any) {
    new Error("Error in polling test run completion" + ex.message); //polling timed out
  }

  if (testRunPoller.getOperationState().status != "succeeded")
    throw new Error("There is some issue in running the test, Error Response : " + testRunResult);

  if (testRunResult) {
    let testRunStarttime = testRunResult.body.startDateTime;
    let testRunEndTime = testRunResult.body.endDateTime;

    // get list of all metric namespaces and pick the first one
    const metricNamespaces = await client
      .path("/test-runs/{testRunId}/metric-namespaces", TEST_RUN_ID)
      .get();

    if (isUnexpected(metricNamespaces)) {
      throw metricNamespaces.body.error;
    }

    const metricNamespace = metricNamespaces.body.value[0];

    if (metricNamespace.name === undefined) {
      throw "No Metric Namespace name is defined.";
    }

    // get list of all metric definitions and pick the first one
    const metricDefinitions = await client
      .path("/test-runs/{testRunId}/metric-definitions", TEST_RUN_ID)
      .get({
        queryParameters: {
          metricNamespace: metricNamespace.name,
        },
      });

    if (isUnexpected(metricDefinitions)) {
      throw metricDefinitions.body.error;
    }

    const metricDefinition = metricDefinitions.body.value[0];

    if (metricDefinition.name === undefined) {
      throw "No Metric Namespace name is defined.";
    }

    // fetch client metrics using metric namespace and metric name
    const metricsResult = await client.path("/test-runs/{testRunId}/metrics", TEST_RUN_ID).post({
      queryParameters: {
        metricname: metricDefinition.name,
        metricNamespace: metricNamespace.name,
        timespan: testRunStarttime + "/" + testRunEndTime,
      },
    });

    console.log(metricsResult);
    console.log(testRunResult);
}

Řešení problémů

Protokolování

Povolení protokolování může pomoct odhalit užitečné informace o chybách. Pokud chcete zobrazit protokol požadavků a odpovědí HTTP, nastavte proměnnou prostředí AZURE_LOG_LEVEL na info. Případně můžete protokolování povolit za běhu voláním setLogLevel v @azure/logger:

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

setLogLevel("info");

Podrobnější pokyny k povolení protokolů najdete v dokumentaci k @azure/protokolovacímu balíčku.

Další kroky

Ukázky sady Azure Loading Testing JavaScript SDK jsou k dispozici v úložišti GitHub sady SDK. Tyto ukázky poskytují ukázkový kód pro další běžně používané scénáře.

Viz ukázky azure Load Testing.

Přispívající

Podrobnosti o přispívání do tohoto úložiště najdete v průvodce přispívání.

  1. Rozvětvovat ho
  2. Vytvoření větve funkcí (git checkout -b my-new-feature)
  3. Potvrzení změn (git commit -am 'Add some feature')
  4. Nasdílení změn do větve (git push origin my-new-feature)
  5. Vytvoření nové žádosti o přijetí změn