Konfigurieren eines Auslastungstests in YAML

Erfahren Sie, wie Sie Ihren Auslastungstest in Azure Load Testing mithilfe von YAML konfigurieren. Sie verwenden die YAML-Datei für die Testkonfiguration, um Auslastungstests aus Ihrem CI/CD-Workflow (Continuous Integration und Continuous Delivery) zu erstellen und auszuführen.

YAML-Syntax des Auslastungstests

Eine Auslastungstestkonfiguration verwendet die folgenden Schlüssel:

Schlüssel	Typ	Erforderlich	Standardwert	BESCHREIBUNG
`version`	Schnur	Ja		Spezifikationsversion des Auslastungstests. Der einzige unterstützte Wert ist `v0.1`.
`testId`	Schnur	Ja		Eindeutiger Bezeichner des Auslastungstests. Der Wert muss zwischen 2 und 50 Zeichen lang sein ([a-z0-9_-]). Für einen vorhandenen Test können Sie `testId` von der Testdetailseite im Azure-Portal abrufen.
`testName`	Schnur	N		Veraltet. Eindeutiger Bezeichner des Auslastungstests. Diese Einstellung wird durch `testId`. Sie können weiterhin vorhandene Tests mit dem Feld `testName` ausführen.
`displayName`	Schnur	N		Anzeigename des Tests. Dieser Wert wird in der Liste der Tests im Azure-Portal angezeigt. Wenn er nicht angegeben, wird `testId` als Anzeigename verwendet.
`description`	Schnur	N		Kurze Beschreibung des Tests. Der Wert hat eine maximale Länge von 100 Zeichen.
`testType`	Schnur	Ja		Testtyp. Mögliche Werte: `URL`: URL-basierter Auslastungstest `JMX`: JMeter-basierte Auslastungstest `Locust`: Locust-basierte Auslastungstest
`testPlan`	Schnur	Ja		Verweis auf die Testplandatei. Bei `testType: JMX`: relativer Pfad zum JMeter-Testskript. Wenn `testType: Locust`: relativer Pfad zum Locust-Testskript. Wenn`testType: URL`: relativer Pfad zur JSON-Anforderungsdatei.
`engineInstances`	Integer	Ja		Anzahl der parallelen Testmodulinstanzen für die Ausführung des Testplans. Erfahren Sie mehr über das Konfigurieren von Hochskalenlasten.
`configurationFiles`	Array von Zeichenfolgen	N		Liste der externen Dateien, die für das Testskript erforderlich sind. Beispielsweise JMX-Fragmentdateien, CSV-Datendateien, Bilder oder andere Datendateien. Azure Load Testing lädt alle Dateien in denselben Ordner wie das Testskript hoch. Verweisen Sie im JMeter-Skript oder im Locust-Skript nur auf externe Dateien unter Verwendung des Dateinamens, und entfernen Sie alle Dateipfadinformationen.
`failureCriteria`	Objekt	N		Fehler bei Auslastungstests. Weitere Informationen finden Sie unter failureCriteria .
`autoStop`	Zeichenfolge oder Objekt	N		Beenden Sie den Auslastungstest automatisch, wenn der Fehlerprozentsatz einen Wert überschreitet. Mögliche Werte: - `disable`: Beenden Sie einen Auslastungstest nicht automatisch. - object: see autotop configuration for more details.
`properties`	Objekt	N		If `testType: JMX`: JMeter user property file references. Wenn `testType: Locust`: Locust-Konfigurationsdateiverweise. Weitere Informationen finden Sie in den Eigenschaften .
`zipArtifacts`	Array von Zeichenfolgen	N		Gibt die Liste der ZIP-Artefaktdateien an. Für Dateien, die nicht das Haupttestskript und die Benutzereigenschaften für JMeter-basierte Tests und Locust-Skript- und Konfigurationsdateien für Locust-basierte Tests sind, komprimieren Sie sie in eine ZIP-Datei, wenn die Dateigröße 50 MB überschreitet. Stellen Sie sicher, dass die ZIP-Datei nicht größer als 50 MB wird. Es sind nur 5 ZIP-Artefakte mit maximal 1000 Dateien in jeder und nicht komprimierter Größe von 1 GB zulässig. Gilt nur für `testType: JMX` und `testType: Locust`.
`splitAllCSVs`	Boolescher Wert	N	Falsch	Teilen Sie die CSV-Eingabedateien gleichmäßig auf alle Testmodulinstanzen auf. Weitere Informationen finden Sie unter Lesen einer CSV-Datei in Auslastungstests.
`secrets`	Objekt	N		Liste der Geheimnisse, auf die das Apache JMeter- oder Locust-Skript verweist. Weitere Details finden Sie unter geheimen Schlüsseln.
`env`	Objekt	N		Liste der Umgebungsvariablen, auf die das Apache JMeter-Skript oder Locust verweist. Weitere Informationen finden Sie unter Umgebungsvariablen .
`certificates`	Objekt	N		Liste der Clientzertifikate für die Authentifizierung mit Anwendungsendpunkten im JMeter- oder Locust-Skript. Weitere Informationen finden Sie unter Zertifikaten .
`appComponents`	Objekt	N		Liste der Server--side Ressourcen, die während des Auslastungstests überwacht werden sollen. Weitere Details finden Sie unter "appComponents ".
`subnetId`	Schnur	N		Ressourcen-ID des Subnetzes des virtuellen Netzwerks zum Testen von privat gehosteten Endpunkten. Dieses Subnetz hostet die eingefügten Testmodul-VMs. Weitere Informationen finden Sie unter Durchführen von Auslastungstests für privat gehostete Endpunkte.
`publicIPDisabled`	Boolescher Wert	N		Deaktivieren Sie die Bereitstellung einer öffentlichen IP-Adresse, eines Lastenausgleichs und einer Netzwerksicherheitsgruppe, während Sie einen privaten Endpunkt testen. Weitere Informationen finden Sie unter Durchführen von Auslastungstests für privat gehostete Endpunkte.
`regionalLoadTestConfig`	Objekt	N		Verteilen Sie Die Last über Regionen hinweg, um den Benutzerdatenverkehr aus mehreren Regionen zu simulieren. Weitere Informationen finden Sie in der konfiguration für regionale Auslastungstests .
`referenceIdentities`	Objekt	N		Liste der verwalteten Identitäten, die im Test für den Zugriff auf die geheimen Schlüssel aus Ihrem Azure Key Vault verwendet werden, Metriken für serverseitige Fehlerkriterien und Authentifizierung Ihrer Endpunkte. Weitere Informationen finden Sie unter referenceIdentities .

Beispiel für die Auslastungstestkonfiguration

Der folgende YAML-Codeschnipsel enthält eine Beispielkonfiguration für Auslastungstests.

version: v0.1
testId: SampleTest
displayName: Sample Test
description: Load test website home page
testPlan: SampleTest.jmx
testType: JMX
engineInstances: 1
subnetId: /subscriptions/abcdef01-2345-6789-0abc-def012345678/resourceGroups/sample-rg/providers/Microsoft.Network/virtualNetworks/load-testing-vnet/subnets/load-testing
configurationFiles:
  - 'sampledata.csv'
  - 'testfragment.jmx'
zipArtifacts:
   - bigdata.zip
splitAllCSVs: True
failureCriteria:
  - avg(response_time_ms) > 300
  - percentage(error) > 50
  - GetCustomerDetails: avg(latency) >200
autoStop:
  errorPercentage: 80
  timeWindow: 60
secrets:
  - name: my-secret
    value: https://akv-contoso.vault.azure.net/secrets/MySecret/abc1234567890def12345
keyVaultReferenceIdentity: /subscriptions/abcdef01-2345-6789-0abc-def012345678/resourceGroups/sample-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/sample-identity

`failureCriteria` Konfiguration

Testfehlerkriterien ermöglichen es Ihnen, Bedingungen zu definieren, um zu ermitteln, ob eine Auslastungstestausführung erfolgreich war oder nicht. Wenn mindestens ein Fehlerkriterium erfüllt ist, erhält der Test ein fehlgeschlagenes Testergebnis. Erfahren Sie mehr über die Verwendung von Auslastungstestfehlerkriterien. Sie können Fehlerkriterien für Clientmetriken wie Antwortzeit, Latenz usw. und serverseitige Metriken für Ihre serverseitigen App-Komponenten definieren.

Clientmetriken

Sie können Fehlerkriterien definieren, die für den gesamten Auslastungstest gelten oder für eine bestimmte Anforderung gelten. Fehlerkriterien weisen die folgende Struktur auf:

Testkriterien auf Ebene des Auslastungstests: Aggregate_function (client_metric) condition threshold.
Testkriterien, die auf bestimmte Anforderungen angewendet werden: Request: Aggregate_function (client_metric) condition threshold.

Azure Load Testing unterstützt die folgenden Clientmetriken:

Maßeinheit	Aggregatfunktion	Schwellenwert	Zustand	BESCHREIBUNG
`response_time_ms`	`avg` (Durchschnitt) `min` (Minimum) `max` (Maximum) `pxx` (Perzentil), xx kann 50, 75, 90, 95, 96, 97, 98, 99, 999 und 9.999 sein	Integerwert, der die Anzahl der Millisekunden (ms) darstellt.	`>` (größer als) `<` (kleiner als)	Antwortzeit oder verstrichene Zeit in Millisekunden. Erfahren Sie mehr über verstrichene Zeit in der Apache JMeter-Dokumentation.
`latency`	`avg` (Durchschnitt) `min` (Minimum) `max` (Maximum) `pxx` (Quantil), xx kann 50, 90, 95, 99 sein	Integerwert, der die Anzahl der Millisekunden (ms) darstellt.	`>` (größer als) `<` (kleiner als)	Wartezeit in Millisekunden. Erfahren Sie mehr über Wartezeit in der Apache JMeter-Dokumentation.
`error`	`percentage`	Numerischer Wert im Bereich von 0 bis 100, der einen Prozentsatz darstellt.	`>` (größer als)	Prozentanteil der fehlerhaften Anforderungen.
`requests_per_sec`	`avg` (Durchschnitt)	Numerischer Wert mit bis zu zwei Dezimalstellen.	`>` (Größer als) `<` (kleiner als)	Anzahl der Anforderungen pro Sekunde.
`requests`	`count`	Ganzzahliger Wert.	`>` (Größer als) `<` (kleiner als)	Gesamtanzahl der Anforderungen.

Serverseitige Metriken

Sie können Fehlerkriterien für serverseitige Metriken für Ihre serverseitigen App-Komponenten definieren.

In der folgenden Tabelle werden die verschiedenen Felder in der serverMetrics: Konfiguration beschrieben:

Parameter	BESCHREIBUNG
`resourceId`	Erforderlich. Die Ressourcen-ID der App-Komponente, auf die die Kriterien angewendet werden sollen
`metricNamespace`	Erforderlich. Der serverseitige Metriknamespace.
`metricName`	Erforderlich. Die serverseitigen Metriken, auf die die Kriterien angewendet werden sollen.
`aggregation`	Erforderlich. Die Aggregation, die auf die serverseitigen Metriken angewendet werden soll.
`condition`	Wahlfrei. Der Vergleichsoperator, z. B. `greater than` oder `less than`.
`value`	Erforderlich. Der numerische Wert, der mit der Metrik verglichen werden soll.

Konfigurationsbeispiel für Fehlerkriterien

Der folgende Codeausschnitt zeigt eine Auslastungstestkonfiguration, die drei Auslastungstestfehlerkriterien enthält.

version: v0.1
testId: SampleTest
displayName: Sample Test
description: Load test website home page
testPlan: SampleTest.jmx
testType: JMX
engineInstances: 1
failureCriteria:
  clientMetrics:
    - avg(responseTimeMs) > 300
    - percentage(error) > 50
    - getCustomerDetails: avg(latency) > 200
  serverMetrics:
    - resourceId: /subscriptions/abcdef01-2345-6789-0abc-def012345678/resourceGroups/sample-rg/providers/Microsoft.Compute/virtualMachines/sample-vm
      metricNamespace: Microsoft.Compute/virtualMachines
      metricName: Percentage CPU
      aggregation: Average
      condition: GreaterThan
      value: 80
    - resourceId: /subscriptions/abcdef01-2345-6789-0abc-def012345678/resourceGroups/sample-rg/providers/Microsoft.Compute/virtualMachines/sample-vm
      metricNamespace: Microsoft.Compute/virtualMachines
      metricName: Available Memory
      aggregation: Average
      condition: LessThan
      value: 20

`appComponents` Konfiguration

Sie können serverseitige Ressourcen während des Auslastungstests überwachen. Erfahren Sie mehr über die Überwachung serverseitiger Ressourcen. Wenn Sie einen Auslastungstest für eine in Azure gehostete Anwendung durchführen, sammelt Azure Load Testing Ressourcenmetriken für Ihre Anwendungskomponenten und stellt sie im Load-Testing-Dashboard dar.

In der folgenden Tabelle werden die verschiedenen Felder in der appComponents: Konfiguration beschrieben:

Parameter	BESCHREIBUNG
`resourceId`	Erforderlich. Die Ressourcen-ID der App-Komponente, auf die die Kriterien angewendet werden sollen.
`resourceName`	Wahlfrei. Der Name der zu überwachenden Ressource.
`kind`	Wahlfrei. Die Art der zu überwachenden Ressource.
`metrics`	Erforderlich. Die Liste der Metriken, die für die App-Komponente überwacht werden sollen. Dies enthält den Namen, den Namespace und die Aggregation für die Metrik.

Konfigurationsbeispiel für App-Komponenten

Der folgende Codeausschnitt zeigt eine Auslastungstestkonfiguration mit zwei App-Komponenten.

version: v0.1
testId: SampleTest
displayName: Sample Test
description: Load test website home page
testPlan: SampleTest.jmx
testType: JMX
engineInstances: 1
appComponents:
  - resourceId: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/samplerg/providers/microsoft.insights/components/appComponentResource"
    resourceName: appComponentResource #Optional
    kind: web # Optional
    metrics:
      - name: "requests/duration"
        namespace: microsoft.insights/components 
        aggregation: "Average"
      - name: "requests/count"
        aggregation: "Total"
        namespace: microsoft.insights/components   
  - resourceId: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/samplerg/providers/microsoft.insights/components/appComponentResource"
    resourceName: appComponentResource #Optional
    kind: web # Optional
    metrics:
      - name: "requests/duration"
        aggregation: "Average"
        namespace: microsoft.insights/components
      - name: "requests/count"
        aggregation: "Total"
        namespace: microsoft.insights/components

`autoStop` Konfiguration

Mit der Autotopfunktion "Auslastungstest" können Sie einen Auslastungstest automatisch beenden, wenn der Fehlerprozentsatz einen bestimmten Schwellenwert während eines bestimmten Zeitfensters überschreitet. Erfahren Sie mehr über die Autotop-Funktionalität des Auslastungstests.

Schlüssel	Typ	Standardwert	BESCHREIBUNG
`errorPercentage`	Integer	90	Schwellenwert für den Fehlerprozentsatz während der `timeWindow`. Wenn der Fehlerprozentsatz diesen Prozentsatz während eines bestimmten Zeitfensters überschreitet, wird die Testausführung automatisch beendet.
`timeWindow`	Integer	60	Zeitfenster in Sekunden für die Berechnung der `errorPercentage`.

Beispiel für die Automatische Konfiguration

Der folgende Codeausschnitt zeigt eine Auslastungstestkonfiguration, die drei Auslastungstestfehlerkriterien enthält.

version: v0.1
testId: SampleTest
displayName: Sample Test
description: Load test website home page
testPlan: SampleTest.jmx
testType: JMX
engineInstances: 1
autoStop:
  errorPercentage: 80
  timeWindow: 60

`properties` Konfiguration

Sie können eine JMeter-Benutzereigenschaftendatei für den Ladetest angeben. Die Benutzereigenschaftendatei wird zusammen mit dem Testplan und anderen Dateien hochgeladen. Erfahren Sie mehr über die Verwendung von JMeter-Benutzereigenschaften in Azure Load Testing.

Schlüssel	Typ	Standardwert	BESCHREIBUNG
`userPropertyFile`	Schnur		Datei, die als Apache JMeter-Benutzereigenschaftendateioder als Locust-Konfigurationsdatei verwendet werden soll. Für Locust werden Dateien mit Erweiterungen .conf, .ini und .toml als Konfigurationsdatei unterstützt. Die Datei wird zusammen mit dem Testskript und anderen Konfigurationsdateien in die Azure Load Testing-Ressource hochgeladen. Wenn sich die Datei in einem Unterordner auf Ihrem lokalen Computer befindet, verwenden Sie einen Dateipfad, der relativ zum Speicherort des Testskripts ist.

Beispiel für die Konfiguration der Benutzereigenschaftsdatei

Der folgende Codeausschnitt zeigt eine Auslastungstestkonfiguration, die eine Benutzereigenschaftendatei angibt.

version: v0.1
testId: SampleTest
displayName: Sample Test
description: Load test website home page
testPlan: SampleTest.jmx
testType: JMX
engineInstances: 1
properties:
  userPropertyFile: 'user.properties'

Der folgende Codeausschnitt zeigt eine Auslastungstestkonfiguration, die eine Locust-Konfigurationsdatei angibt.

version: v0.1
testId: SampleTest
displayName: Sample Test
description: Load test website home page
testPlan: SampleTest.py
testType: Locust
engineInstances: 1
properties:
  userPropertyFile: 'locust.conf'

`secrets` Konfiguration

Sie können geheime Werte in Azure Key Vault speichern und in Ihrem Testplan darauf verweisen. Erfahren Sie mehr über die Verwendung von geheimen Schlüsseln mit Azure Load Testing.

Schlüssel	Typ	Standardwert	BESCHREIBUNG
`name`	Schnur		Der Name des geheimen Schlüssels. Dieser Name sollte mit dem geheimen Namen übereinstimmen, den Sie in den Testplananforderungen verwenden.
`value`	Schnur		URI (Geheimnisbezeichner) für das Azure Key Vault-Geheimnis.

Konfigurationsbeispiel für geheime Schlüssel

Der folgende Codeausschnitt zeigt eine Auslastungstestkonfiguration, die auf einen geheimen Schlüssel my-secret in Azure Key Vault verweist.

version: v0.1
testId: SampleTest
displayName: Sample Test
description: Load test website home page
testPlan: SampleTest.jmx
testType: JMX
engineInstances: 1
secrets:
  - name: my-secret
    value: https://akv-contoso.vault.azure.net/secrets/MySecret/abc1234567890def12345

`env` Konfiguration

Sie können Umgebungsvariablen angeben und in Ihrem Testplan darauf verweisen. Erfahren Sie mehr über die Verwendung von Umgebungsvariablen mit Azure Load Testing.

Schlüssel	Typ	Standardwert	BESCHREIBUNG
`name`	Schnur		Der Name der Umgebungsvariablen. Dieser Name sollte mit dem Variablennamen übereinstimmen, den Sie in den Testplananforderungen verwenden.
`value`	Schnur		Der Wert der Umgebungsvariablen.

Beispiel für die Umgebungsvariablenkonfiguration

Der folgende Codeausschnitt zeigt eine Auslastungstestkonfiguration, die eine Umgebungsvariable my-variable und einen Wert my-valueangibt.

version: v0.1
testId: SampleTest
displayName: Sample Test
description: Load test website home page
testPlan: SampleTest.jmx
testType: JMX
engineInstances: 1
env:
  - name: my-variable
    value: my-value

`certificates` Konfiguration

Sie können Clientzertifikate an Ihren Auslastungstest übergeben. Das Zertifikat wird in Azure Key Vault gespeichert. Erfahren Sie mehr über die Verwendung von Clientzertifikaten mit Azure Load Testing.

Schlüssel	Typ	Standardwert	BESCHREIBUNG
`name`	Schnur		Name des Zertifikats.
`value`	Schnur		URI (Geheimnisbezeichner) für das Zertifikat in Azure Key Vault.

Beispiel für die Zertifikatkonfiguration

Der folgende Codeausschnitt zeigt eine Auslastungstestkonfiguration, die auf ein Clientzertifikat in Azure Key Vault verweist.

version: v0.1
testId: SampleTest
displayName: Sample Test
description: Load test website home page
testPlan: SampleTest.jmx
testType: JMX
engineInstances: 1
certificates:
  - name: my-certificate
    value: https://akv-contoso.vault.azure.net/certificates/MyCertificate/abc1234567890def12345

`referenceIdentities` Konfiguration

Sie können verwaltete Identitäten für verschiedene Szenarien in Ihrem Auslastungstest verwenden. Verwaltete Identitäten können im Test verwendet werden, um auf die geheimen Schlüssel oder Zertifikate aus Ihrem Azure Key Vault zuzugreifen, Metriken für serverseitige Fehlerkriterien und die Authentifizierung Ihrer Endpunkte abzurufen.

In der folgenden Tabelle werden die verschiedenen Felder in der referenceIdentities: Konfiguration beschrieben:

Parameter	BESCHREIBUNG
`kind`	Erforderlich. Dadurch wird das Szenario definiert, für das die verwaltete Identität verwendet wird. Dies kann eine der folgenden `KeyVaultMetrics`oder `Engine`. Es können mehrere Elemente für die Art `Engine`vorhanden sein.
`type`	Erforderlich. Der Identitätstyp. Dies kann `UserAssigned` oder `SystemAssigned`sein.
`value`	Erforderlich. Die Ressourcen-ID der verwalteten Identität. Dies muss nicht angegeben werden, wenn der Typ ist `SystemAssigned`.

Konfigurationsbeispiel für Referenzidentitäten

Der folgende Codeausschnitt zeigt eine Auslastungstestkonfiguration für mehrere Identitäten.

version: v0.1
testId: SampleTest
displayName: Sample Test
description: Load test website home page
testPlan: SampleTest.jmx
testType: JMX
engineInstances: 1
secrets:
  - name: my-secret
    value: https://akv-contoso.vault.azure.net/secrets/MySecret/abc1234567890def12345
failureCriteria:
  serverMetrics:
    - resourceId: /subscriptions/abcdef01-2345-6789-0abc-def012345678/resourceGroups/sample-rg/providers/Microsoft.Compute/virtualMachines/sample-vm
      metricNamespace: Microsoft.Compute/virtualMachines
      metricName: Percentage CPU
      aggregation: Average
      condition: GreaterThan
      value: 80
referenceIdentities:
  - kind: KeyVault
    type: UserAssigned
    value: /subscriptions/abcdef01-2345-6789-0abc-def012345678/resourceGroups/sample-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/sample-identity
  - kind: Metrics
    type: SystemAssigned
  - kind: Engine
    type: UserAssigned
    value: /subscriptions/abcdef01-2345-6789-0abc-def012345678/resourceGroups/sample-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/sample-identity
  - kind: Engine
    type: UserAssigned
    value: /subscriptions/abcdef01-2345-6789-0abc-def012345678/resourceGroups/sample-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/sample-identity1

JSON-Datei anfordert

Wenn Sie einen URL-basierten Test verwenden, können Sie die HTTP-Anforderungen in einer JSON-Datei angeben, anstatt ein Testskript zu verwenden. Stellen Sie sicher, dass Sie die Zeichenfolge testTypeURL in der YAML-Testkonfigurationsdatei festlegen und auf die JSON-Anforderungsdatei verweisen.

HTTP-Anforderungen

Die JSON-Anforderungsdatei verwendet die folgenden Eigenschaften zum Definieren von Anforderungen in der requests Eigenschaft:

Eigentum	Typ	BESCHREIBUNG
`requestName`	Schnur	Eindeutiger Anforderungsname. Sie können beim Konfigurieren von Testfehlerkriterien auf den Anforderungsnamen verweisen.
`responseVariables`	Array	Liste der Antwortvariablen. Verwenden Sie Antwortvariablen, um einen Wert aus der Anforderung zu extrahieren und in einer nachfolgenden Anforderung darauf zu verweisen. Erfahren Sie mehr über Antwortvariablen.
`responseVariables.extractorType`	Schnur	Mechanismus zum Extrahieren eines Werts aus der Antwortausgabe. Unterstützte Werte sind `XPathExtractor`, `JSONExtractor` und `RegularExpression`.
`responseVariables.expression`	Schnur	Ausdruck zum Abrufen der Antwortausgabe. Der Ausdruck hängt vom Extraktortypwert ab.
`responseVariables.variableName`	Schnur	Eindeutiger Name der Antwortvariable. Sie können diese Variable in einer nachfolgenden Anforderung mithilfe der `{$variable-name}` Syntax referenzieren.
`queryParameters`	Array	Liste der Abfragezeichenfolgenparameter, die an den Endpunkt übergeben werden sollen.
`queryParameters.key`	Schnur	Name des Abfragezeichenfolgenparameters.
`queryParameters.value`	Schnur	Parameterwert der Abfragezeichenfolge.
`requestType`	Schnur	Anforderungstyp Unterstützte Werte sind: `URL` oder `CURL`.
`endpoint`	Schnur	DIE URL des zu testenden Anwendungsendpunkts.
`headers`	Array	Liste der HTTP-Header, die an den Anwendungsendpunkt übergeben werden sollen. Geben Sie ein Schlüssel-Wert-Paar für jede Kopfzeile an.
`body`	Schnur	Textkörper für die HTTP-Anforderung. Sie können das `requestBodyFormat` Format des Textkörperinhalts angeben.
`requestBodyFormat`	Schnur	Format des Textkörperinhalts. Unterstützte Werte: `Text`, `JSON`, `JavaScript`, `HTML` und `XML`.
`method`	Schnur	HTTP-Methode zum Aufrufen des Endpunkts. Unterstützte Werte sind: `GET`, , `POST`, `PUT`, `DELETE`, `PATCH`, und `HEADOPTIONS`.
`curlCommand`	Schnur	cURL-Befehl, der ausgeführt werden soll. Erfordert, dass dies `requestType` ist `CURL`.

Der folgende JSON-Codeausschnitt enthält eine JSON-Beispieldatei für Anforderungen:

{
    "version": "1.0",
    "scenarios": {
        "requestGroup1": {
            "requests": [
                {
                    "requestName": "add",
                    "responseVariables": [],
                    "queryParameters": [
                        {
                            "key": "param1",
                            "value": "value1"
                        }
                    ],
                    "requestType": "URL",
                    "endpoint": "https://www.contoso.com/orders",
                    "headers": {
                        "api-token": "my-token"
                    },
                    "body": "{\r\n  \"customer\": \"Contoso\",\r\n  \"items\": {\r\n\t  \"product_id\": 321,\r\n\t  \"count\": 50,\r\n\t  \"amount\": 245.95\r\n  }\r\n}",
                    "method": "POST",
                    "requestBodyFormat": "JSON"
                },
                {
                    "requestName": "get",
                    "responseVariables": [],
                    "requestType": "CURL",
                    "curlCommand": "curl --request GET 'https://www.contoso.com/orders'"
                },
            ],
            "csvDataSetConfigList": []
        }
    },
    "testSetup": [
        {
            "virtualUsersPerEngine": 1,
            "durationInSeconds": 600,
            "loadType": "Linear",
            "scenario": "requestGroup1",
            "rampUpTimeInSeconds": 30
        }
    ]
}

Laden der Konfiguration

Die JSON-Anforderungsdatei verwendet die folgenden Eigenschaften zum Definieren der Ladekonfiguration in der testSetup Eigenschaft:

Eigentum	Typ	Lasttyp	BESCHREIBUNG
`loadType`	Schnur		Typ des Lademusters. Folgende Werte werden unterstützt: `linear`, `step` und `spike`.
`scenario`	Schnur		Verweis auf die Anforderungsgruppe, die in der `scenarios` Eigenschaft angegeben ist.
`virtualUsersPerEngine`	Integer	Alle	Anzahl der virtuellen Benutzer pro Testmodulinstanz.
`durationInSeconds`	Integer	Alle	Gesamtdauer des Auslastungstests in Sekunden.
`rampUpTimeInSeconds`	Integer	Linear, Schritt	Dauer in Sekunden, um die Zielanzahl virtueller Benutzer hochzufahren.
`rampUpSteps`	Integer	Schritt	Die Anzahl der Schritte, um die Zielanzahl der virtuellen Benutzer zu erreichen.
`spikeMultiplier`	Integer	Spitze	Der Faktor, um die Anzahl der Zielbenutzer während der Spitzendauer zu multiplizieren.
`spikeHoldTimeInSeconds`	Integer	Spitze	Gesamtdauer in Sekunden, um die Spitzenlast beizubehalten.

Konfiguration für regionale Auslastungstests

Sie können Last über Regionen verteilen, um reale Verkehrsmuster besser zu simulieren. Sie können die Regionen angeben, aus denen Sie die Last generieren möchten, und die Menge der Last, die Sie aus den einzelnen Regionen simulieren möchten. Dazu können Sie den Regionsnamen und die Anzahl der gewünschten Modulinstanzen in dieser Region angeben. Erfahren Sie mehr über das Generieren von Lasten aus mehreren Regionen.

Schlüssel	Typ	Standardwert	BESCHREIBUNG
`region`	Schnur		Name der Azure-Region.
`engineInstances`	Integer		Anzahl der Modulinstanzen für diese Azure-Region.

Beispiel für regionale Auslastungstestkonfiguration

Der folgende Codeausschnitt zeigt eine Auslastungstestkonfiguration, die zwei Azure-Regionen eastus und eastasia die Anzahl der Modulinstanzen für jede Region angibt.

displayName: Sample Test
testPlan: sampleScript.jmx
description: 'Load test website home page'
engineInstances: 4
testId: SampleTest
testType: Locust
splitAllCSVs: False
regionalLoadTestConfig:
- region: eastus
  engineInstances: 2
- region: eastasia
  engineInstances: 2
failureCriteria:
- p90(response_time_ms) > 10000
autoStop:
  errorPercentage: 90
  timeWindow: 60

Erfahren Sie, wie Sie automatisierte Regressionstests in Ihrem CI/CD-Workflow erstellen.
Erfahren Sie, wie Sie Auslastungstests mit Geheimnissen und Umgebungsvariablen parametrisieren.
Erfahren Sie, wie Sie Auslastungstests für gesicherte Endpunkte durchführen.

Feedback

War diese Seite hilfreich?

Last updated on 2025-08-15