Azure Load Testing-Clientbibliothek für JavaScript – Version 1.0.1

Azure Load Testing stellt clientbibliothek in JavaScript für den Benutzer bereit, mit dem er nativ mit dem Azure Load Testing-Dienst interagieren kann. Azure Load Testing ist ein vollständig verwalteter Lastentestdienst, mit dem Sie eine hohe Auslastung generieren können. Der Dienst simuliert den Datenverkehr für Ihre Anwendungen, unabhängig davon, wo er gehostet wird. Entwickler, Tester und Qualitätssicherungsingenieure (Quality Assurance, QA) können sie verwenden, um die Anwendungsleistung, Skalierbarkeit oder Kapazität zu optimieren.

Verlassen Sie sich auf unsere REST-Clientdokumente, um diese Bibliothek

Dokumentation

Verschiedene Dokumentationen stehen Ihnen bei den ersten Schritten zur Verfügung.

Erste Schritte

Derzeit unterstützte Umgebungen

LTS-Versionen von Node.js

Voraussetzungen

Sie müssen über ein Azure-Abonnement und Azure Load Test Service Resource verfügen, um dieses Paket zu verwenden.

Installieren des `@azure-rest/load-testing`-Pakets

Installieren Sie die Rest-Clientbibliothek des AzureLoadTesting-Clients für JavaScript mit npm:

npm install @azure-rest/load-testing

Erstellen und Authentifizieren eines `AzureLoadTesting`-Clients

Um eine Azure Active Directory (AAD)-Tokenanmeldeinformationenzu verwenden, stellen Sie eine Instanz des gewünschten Anmeldeinformationstyps bereit, der aus der @azure/Identitätsbibliothek Bibliothek abgerufen wird.

Um sich bei AAD zu authentifizieren, müssen Sie zuerst npm installieren @azure/identity

Nach dem Setup können Sie auswählen, welche Art von Anmeldeinformationen von @azure/identity verwendet werden soll. Beispielsweise können DefaultAzureCredential- zum Authentifizieren des Clients verwendet werden.

Legen Sie die Werte der Client-ID, der Mandanten-ID und des geheimen Clientschlüssels der AAD-Anwendung als Umgebungsvariablen fest: 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());

Schlüsselkonzepte

Die folgenden Komponenten bilden den Azure Load Testing Service. Mit der Azure Load Test-Clientbibliothek für JavaScript können Sie mithilfe eines dedizierten Clientobjekts mit jedem dieser Komponenten interagieren.

Test

Ein Test gibt das Testskript und die Konfigurationseinstellungen für die Ausführung eines Auslastungstests an. Sie können einen oder mehrere Tests in einer Azure Load Testing-Ressource erstellen.

App-Komponente

Wenn Sie einen Auslastungstest für eine von Azure gehostete Anwendung ausführen, können Sie Ressourcenmetriken für die verschiedenen Azure-Anwendungskomponenten (serverseitige Metriken) überwachen. Während der Auslastungstest und nach Abschluss des Tests ausgeführt wird, können Sie die Ressourcenmetriken im Azure Load Testing-Dashboard überwachen und analysieren.

Metrik

Während eines Auslastungstests sammelt Azure Load Testing Metriken zur Testausführung. Es gibt zwei Arten von Metriken:

Clientseitige Metriken enthalten Details, die vom Testmodul gemeldet wurden. Diese Metriken umfassen die Anzahl der virtuellen Benutzer, die Anforderungsantwortzeit, die Anzahl der fehlgeschlagenen Anforderungen oder die Anzahl der Anforderungen pro Sekunde.
Serverseitige Metriken sind für von Azure gehostete Anwendungen verfügbar und stellen Informationen zu Ihren Azure-Anwendungskomponenten bereit. Metriken können für die Anzahl der Datenbanklesevorgänge, den Typ der HTTP-Antworten oder den Ressourcenverbrauch von Containern sein.

Testmodul

Ein Testmodul ist die Computerinfrastruktur, die das Apache JMeter-Testskript ausführt. Sie können den Auslastungstest skalieren, indem Sie die Anzahl der Testmodule konfigurieren. Das Testskript wird parallel über die angegebene Anzahl von Testmodulen ausgeführt.

Testlauf

Eine Testausführung stellt eine Ausführung eines Auslastungstests dar. Es sammelt die Protokolle, die mit der Ausführung des Apache JMeter-Skripts, der YaML-Konfiguration des Ladetests, der Liste der zu überwachenden App-Komponenten und den Ergebnissen des Tests verbunden sind.

Data-Plane Endpunkt

Datenebene von Azure Load Testing-Ressourcen kann mithilfe des folgenden URL-Formats adressiert werden:

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

Die erste GUID-00000000-0000-0000-0000-000000000000 ist der eindeutige Bezeichner, der für den Zugriff auf die Azure Load Testing-Ressource verwendet wird. Dies folgt aaa der Azure-Region der Ressource.

Der Endpunkt der Datenebene wird von Steuerelementebenen-APIs abgerufen.

Beispiel:1234abcd-12ab-12ab-12ab-123456abcdef.eus.cnt-prod.loadtesting.azure.com

Im obigen Beispiel stellt eus die Azure-Region East USdar.

Beispiele

Erstellen eines Auslastungstests

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: {} },
  },
});

Hochladen der JMX-Datei auf einen Test

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
  );

Ausführen eines Tests und Abrufen von Metriken

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);
}

Fehlerbehebung

Protokollierung

Das Aktivieren der Protokollierung kann hilfreiche Informationen zu Fehlern aufdecken. Um ein Protokoll von HTTP-Anforderungen und -Antworten anzuzeigen, legen Sie die AZURE_LOG_LEVEL Umgebungsvariable auf infofest. Alternativ kann die Protokollierung zur Laufzeit durch Aufrufen von setLogLevel im @azure/loggeraktiviert werden:

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

setLogLevel("info");

Ausführlichere Anweisungen zum Aktivieren von Protokollen finden Sie in den @azure/Logger-Paketdokumenten.

Nächste Schritte

Azure Loading Testing JavaScript SDK-Beispiele stehen Ihnen im GitHub-Repository des SDK zur Verfügung. Diese Beispiele stellen Beispielcode für häufig auftretende zusätzliche Szenarien bereit.

Siehe Beispiele für Azure Load Testing.

Beitragend

Ausführliche Informationen zum Beitragen zu diesem Repository finden Sie im Mitwirkenden Leitfaden.

Verzweigung
Erstellen der Feature-Verzweigung (git checkout -b my-new-feature)
Übernehmen Sie Ihre Änderungen (git commit -am 'Add some feature')
An die Verzweigung schieben (git push origin my-new-feature)
Neue Pullanforderung erstellen

Feedback

War diese Seite hilfreich?

Last updated on 2025-01-20