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

Testowanie obciążenia platformy Azure udostępnia bibliotekę klienta w języku JavaScript użytkownikowi, za pomocą którego 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 zapewniania jakości (QA) mogą jej używać do optymalizowania wydajności, skalowalności lub pojemności aplikacji.

Skorzystaj z tej biblioteki w dużej mierze na naszych dokumentach klienta REST

Dokumentacja

Dostępna jest różne dokumenty ułatwiające rozpoczęcie pracy

• Kod źródłowy
• Dokumentacja referencyjna interfejsu API
• Dokumentacja produktu

Wprowadzenie

Obecnie obsługiwane środowiska

• Node.js w wersji 14.x.x lub nowszej

Wymagania wstępne

• Aby użyć tego pakietu, musisz mieć subskrypcję 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 polecenia npm:

npm install @azure-rest/load-testing

Tworzenie i uwierzytelnianie AzureLoadTesting klienta

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ę za pomocą usługi AAD, należy najpierw npm zainstalować @azure/identity

Po skonfigurowaniu można wybrać typ poświadczeń@azure/identity do użycia. Na przykład wartość DefaultAzureCredential może służyć do uwierzytelniania klienta.

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 przy użyciu dedykowanego obiektu klienta.

Testowanie

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

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:

1. 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ę.

2. 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 działa równolegle w określonej liczbie aparatów testowych.

Przebieg testu

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

punkt końcowy Data-Plane

Płaszczyzna danych zasobów testowania obciążenia platformy Azure 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ępuje aaa po tym, 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 East USświadczenia usługi Azure .

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

Uruchamianie testu i pobierania metryk

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

Rozwiązywanie problemów

Rejestrowanie

Włączenie rejestrowania może pomóc odkryć przydatne informacje o błędach. Aby wyświetlić dziennik żądań HTTP i odpowiedzi, ustaw zmienną AZURE_LOG_LEVEL środowiskową na info. Możesz też włączyć rejestrowanie w czasie wykonywania, wywołując polecenie w elemecie setLogLevel@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 pakietu @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 często napotykanych dodatkowych scenariuszy.

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

Współtworzenie

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

1. Rozwidlenie
2. Tworzenie gałęzi funkcji (git checkout -b my-new-feature)
3. Zatwierdzanie zmian (git commit -am 'Add some feature')
4. Wypychanie do gałęzi (git push origin my-new-feature)
5. Tworzenie nowego żądania ściągnięcia