Delen via


Azure Load Testing-clientbibliotheek voor JavaScript - versie 1.0.0

Azure Load Testing biedt de gebruiker een clientbibliotheek in JavaScript waarmee deze systeemeigen kan communiceren met de Azure Load Testing-service. Azure Load Testing is een volledig beheerde belastingstestservice waarmee u grootschalige belasting kunt genereren. De service simuleert verkeer voor uw toepassingen, ongeacht waar ze worden gehost. Ontwikkelaars, testers en QA-technici (quality assurance) kunnen het gebruiken om de prestaties, schaalbaarheid of capaciteit van toepassingen te optimaliseren.

Vertrouw sterk op onze REST-clientdocumenten om deze bibliotheek te gebruiken

Documentatie

Er is diverse documentatie beschikbaar om u op weg te helpen

Aan de slag

Momenteel ondersteunde omgevingen

  • Node.js versie 14.x.x of hoger

Vereisten

Installeer het pakket @azure-rest/load-testing

Installeer de REST-clientbibliotheek van de AzureLoadTesting-client voor JavaScript met npm:

npm install @azure-rest/load-testing

Een client maken en verifiëren AzureLoadTesting

Als u een AAD-tokenreferentie (Azure Active Directory) wilt gebruiken, geeft u een exemplaar op van het gewenste referentietype dat is verkregen uit de @azure-/identiteitsbibliotheek .

Als u zich wilt verifiëren met AAD, moet u eerst npm installeren @azure/identity

Na de installatie kunt u kiezen welk type referentie@azure/identity u wilt gebruiken. Als voorbeeld kan DefaultAzureCredential worden gebruikt om de client te verifiëren.

Stel de waarden van de client-id, tenant-id en clientgeheim van de AAD-toepassing in als omgevingsvariabelen: 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());

Belangrijkste concepten

De volgende onderdelen vormen de Azure Load Testing-service. Met de Azure Load Test-clientbibliotheek voor JavaScript kunt u communiceren met elk van deze onderdelen door gebruik te maken van een toegewezen clientobject.

Testen

Een test specificeert het testscript en de configuratie-instellingen voor het uitvoeren van een belastingstest. U kunt een of meer tests maken in een Azure Load Testing-resource.

App-onderdeel

Wanneer u een belastingstest uitvoert voor een door Azure gehoste toepassing, kunt u metrische resourcegegevens bewaken voor de verschillende Azure-toepassingsonderdelen (metrische gegevens aan de serverzijde). Terwijl de belastingstest wordt uitgevoerd en na voltooiing van de test, kunt u de metrische resourcegegevens bewaken en analyseren in het Azure Load Testing-dashboard.

Metrische gegevens

Tijdens een belastingstest verzamelt Azure Load Testing metrische gegevens over de uitvoering van de test. Er zijn twee typen metrische gegevens:

  1. Metrische gegevens aan de clientzijde bieden u details die zijn gerapporteerd door de testengine. Deze metrische gegevens omvatten het aantal virtuele gebruikers, de reactietijd van de aanvraag, het aantal mislukte aanvragen of het aantal aanvragen per seconde.

  2. Metrische gegevens aan de serverzijde zijn beschikbaar voor door Azure gehoste toepassingen en bieden informatie over de onderdelen van uw Azure-toepassing. Metrische gegevens kunnen betrekking hebben op het aantal databaseleesbewerkingen, het type HTTP-antwoorden of het verbruik van containerresources.

Test-engine

Een testengine is een computerinfrastructuur waarmee het Apache JMeter-testscript wordt uitgevoerd. U kunt uw belastingstest uitschalen door het aantal test-engines te configureren. Het testscript wordt parallel uitgevoerd voor het opgegeven aantal testengines.

Testuitvoering

Een testuitvoering vertegenwoordigt één uitvoering van een belastingstest. Het verzamelt de logboeken die zijn gekoppeld aan het uitvoeren van het Apache JMeter-script, de YAML-configuratie van de belastingstest, de lijst met app-onderdelen die moeten worden bewaakt en de resultaten van de test.

Data-Plane-eindpunt

Gegevensvlak van Azure Load Testing-resources kan worden adresseerbaar met behulp van de volgende URL-indeling:

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

De eerste GUID 00000000-0000-0000-0000-000000000000 is de unieke id die wordt gebruikt voor toegang tot de Azure Load Testing-resource. Dit wordt gevolgd door aaa de Azure-regio van de resource.

Het eindpunt van het gegevensvlak wordt verkregen uit besturingsvlak-API's.

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

In het bovenstaande voorbeeld eus vertegenwoordigt de Azure-regio East US.

Voorbeelden

Een belastingstest maken

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

jmx-bestand uploaden naar een test

import { AzureLoadTestingClient, getLongRunningPoller, isUnexpected } from "@azure-rest/load-testing";
import AzureLoadTesting from "@azure-rest/load-testing";
import { AbortController } from "@azure/abort-controller";
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: AbortController.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
  );

Een test uitvoeren en metrische gegevens ophalen

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

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: AbortController.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);
}

Problemen oplossen

Logboekregistratie

Het inschakelen van logboekregistratie kan helpen bij het ontdekken van nuttige informatie over fouten. Als u een logboek met HTTP-aanvragen en -antwoorden wilt zien, stelt u de AZURE_LOG_LEVEL omgevingsvariabele in op info. U kunt logboekregistratie ook tijdens runtime inschakelen door aan te roepen setLogLevel in de @azure/logger:

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

setLogLevel("info");

Voor meer gedetailleerde instructies over het inschakelen van logboeken kunt u de @azure-/loggerpakketdocumenten bekijken.

Volgende stappen

Azure Loading Testing JavaScript SDK-voorbeelden zijn voor u beschikbaar in de GitHub-opslagplaats van de SDK. Deze voorbeelden bevatten voorbeeldcode voor aanvullende scenario's die vaak worden aangetroffen.

Zie Azure Load Testing-voorbeelden.

Bijdragen

Zie de handleiding voor bijdragen voor meer informatie over het bijdragen aan deze opslagplaats.

  1. Vork het
  2. Uw functiebranch maken (git checkout -b my-new-feature)
  3. Uw wijzigingen doorvoeren (git commit -am 'Add some feature')
  4. Naar de vertakking pushen (git push origin my-new-feature)
  5. Nieuwe pull-aanvraag maken