Biblioteka klienta testowania obciążenia platformy Azure dla języka JavaScript — wersja 1.0.1

Testowanie obciążenia platformy Azure udostępnia użytkownikowi bibliotekę klienta w języku JavaScript, za pomocą której mogą natywnie korzystać z usługi Azure Load Testing. Testowanie obciążenia platformy Azure to w pełni zarządzana usługa testowania obciążenia, która umożliwia generowanie obciążenia na dużą skalę. Usługa symuluje ruch dla aplikacji, niezależnie od tego, gdzie są hostowane. Deweloperzy, testerzy i inżynierowie zajmujący się zapewnieniem jakości (QA) mogą jej używać do optymalizowania wydajności, skalowalności lub pojemności aplikacji.

w dużym stopniu polegaj na naszych dokumentacji klienta REST do korzystania z tej biblioteki

Dokumentacja

Dostępne są różne dokumenty ułatwiające rozpoczęcie pracy

kod źródłowy
Dokumentacja referencyjna interfejs u API
dokumentacja produktu

Wprowadzenie

Obecnie obsługiwane środowiska

wersje Node.js LTS

Warunki wstępne

Aby korzystać z tego pakietu, musisz mieć subskrypcji platformy Azure i zasób usługi Azure Load Test Service.

Instalowanie pakietu `@azure-rest/load-testing`

Zainstaluj bibliotekę klienta REST klienta AzureLoadTesting dla języka JavaScript przy użyciu npm:

npm install @azure-rest/load-testing

Tworzenie i uwierzytelnianie klienta `AzureLoadTesting`

Aby użyć poświadczeń tokenu usługi Azure Active Directory (AAD), podaj wystąpienie żądanego typu poświadczeń uzyskanego z biblioteki @azure/tożsamości.

Aby uwierzytelnić się w usłudze AAD, musisz najpierw npm zainstalować @azure/identity

Po skonfigurowaniu możesz wybrać typ poświadczeń z do użycia. Na przykład do uwierzytelniania klienta można użyć DefaultAzureCredential.

Ustaw wartości identyfikatora klienta, identyfikatora dzierżawy i wpisu tajnego klienta aplikacji usługi AAD jako zmienne środowiskowe: 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());

Kluczowe pojęcia

Poniższe składniki składają się na usługę Azure Load Testing Service. Biblioteka klienta usługi Azure Load Test dla języka JavaScript umożliwia interakcję z każdym z tych składników za pomocą dedykowanego obiektu klienta.

Test

Test określa skrypt testowy i ustawienia konfiguracji do uruchamiania testu obciążeniowego. W zasobie testowania obciążenia platformy Azure można utworzyć co najmniej jeden test.

Składnik aplikacji

Po uruchomieniu testu obciążeniowego dla aplikacji hostowanej na platformie Azure można monitorować metryki zasobów dla różnych składników aplikacji platformy Azure (metryki po stronie serwera). Podczas uruchamiania testu obciążeniowego i po zakończeniu testu można monitorować i analizować metryki zasobów na pulpicie nawigacyjnym testowania obciążenia platformy Azure.

Metryki

Podczas testu obciążeniowego usługa Azure Load Testing zbiera metryki dotyczące wykonywania testu. Istnieją dwa typy metryk:

Metryki po stronie klienta zawierają szczegółowe informacje zgłaszane przez aparat testowy. Te metryki obejmują liczbę użytkowników wirtualnych, czas odpowiedzi żądania, liczbę żądań zakończonych niepowodzeniem lub liczbę żądań na sekundę.
Metryki po stronie serwera są dostępne dla aplikacji hostowanych na platformie Azure i zawierają informacje o składnikach aplikacji platformy Azure. Metryki mogą być przeznaczone dla liczby odczytów bazy danych, typu odpowiedzi HTTP lub użycia zasobów kontenera.

Aparat testowy

Aparat testowy to infrastruktura obliczeniowa, która uruchamia skrypt testowy Apache JMeter. Test obciążeniowy można skalować w poziomie, konfigurując liczbę aparatów testowych. Skrypt testowy jest uruchamiany równolegle w określonej liczbie aparatów testowych.

Przebieg testu

Przebieg testu reprezentuje jedno wykonanie testu obciążeniowego. Zbiera dzienniki skojarzone ze skryptem Apache JMeter, konfiguracją testu obciążeniowego YAML, listą składników aplikacji do monitorowania i wynikami testu.

punkt końcowy Data-Plane

Płaszczyzna danych zasobów usługi Azure Load Testing jest adresowalna przy użyciu następującego formatu adresu URL:

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

Pierwszy identyfikator GUID 00000000-0000-0000-0000-000000000000 jest unikatowym identyfikatorem używanym do uzyskiwania dostępu do zasobu testowania obciążenia platformy Azure. Następnie następuje aaa, który jest regionem świadczenia usługi Azure zasobu.

Punkt końcowy płaszczyzny danych jest uzyskiwany z interfejsów API płaszczyzny sterowania.

przykład :1234abcd-12ab-12ab-12ab-123456abcdef.eus.cnt-prod.loadtesting.azure.com

W powyższym przykładzie eus reprezentuje region świadczenia usługi Azure East US.

Przykłady

Tworzenie testu obciążeniowego

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

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

Uruchamianie testów i pobieranie metryk

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

Rozwiązywanie problemów

Wyrąb

Włączenie rejestrowania może pomóc odkryć przydatne informacje o błędach. Aby wyświetlić dziennik żądań i odpowiedzi HTTP, ustaw zmienną środowiskową AZURE_LOG_LEVEL na info. Alternatywnie rejestrowanie można włączyć w czasie wykonywania, wywołując setLogLevel w @azure/logger:

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

setLogLevel("info");

Aby uzyskać bardziej szczegółowe instrukcje dotyczące włączania dzienników, zapoznaj się z dokumentami dotyczącymi pakietów @azure/rejestratora.

Następne kroki

Przykłady zestawu SDK języka JavaScript dotyczące ładowania platformy Azure są dostępne w repozytorium GitHub zestawu SDK. Te przykłady zawierają przykładowy kod dla dodatkowych scenariuszy, które często występują.

Zobacz przykłady testowania obciążenia platformy Azure.

Przyczyniając się

Aby uzyskać szczegółowe informacje na temat współtworzenia tego repozytorium, zobacz przewodnik współtworzenia.

Rozwidlenie
Tworzenie gałęzi funkcji (git checkout -b my-new-feature)
Zatwierdź zmiany (git commit -am 'Add some feature')
Wypychanie do gałęzi (git push origin my-new-feature)
Tworzenie nowego żądania ściągnięcia

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-01-20