Biblioteca cliente de Azure Load Testing para Java: versión 1.0.7

Artículo
10/21/2023

Azure Load Testing proporciona biblioteca cliente en Java al usuario mediante la cual puede interactuar de forma nativa con el servicio Azure Load Testing. Azure Load Testing es un servicio de prueba de carga totalmente administrado que permite generar una carga a gran escala. El servicio simula el tráfico de las aplicaciones, independientemente del lugar en que se hospeden. Los desarrolladores, evaluadores y ingenieros de control de calidad (QA) pueden usarlo para optimizar el rendimiento de las aplicaciones, la escalabilidad o la capacidad.

Este paquete contiene la biblioteca cliente loadTesting para desarrolladores de Microsoft Azure.

Documentación

Hay varias documentación disponibles para ayudarle a empezar.

Introducción

Requisitos previos

Kit de desarrollo de Java (JDK) con la versión 8 o posterior
Suscripción de Azure
Recurso de Azure Load Testing

Adición del paquete al producto

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-developer-loadtesting</artifactId>
    <version>1.0.7</version>
</dependency>

Authentication

El paquete de identidad de Azure proporciona la implementación predeterminada para autenticar el cliente.

De forma predeterminada, la autenticación de tokens de Azure Active Directory depende de la configuración correcta de las siguientes variables de entorno.

AZURE_CLIENT_ID para el identificador de cliente de Azure.
AZURE_TENANT_ID para el identificador de inquilino de Azure.
AZURE_CLIENT_SECRET o AZURE_CLIENT_CERTIFICATE_PATH para el secreto de cliente o el certificado de cliente.

Además, el identificador de suscripción de Azure se puede configurar a través de la variable AZURE_SUBSCRIPTION_IDde entorno .

Con la configuración anterior, azure el cliente se puede autenticar mediante el código siguiente:

// ensure the user, service principal or managed identity used has Loadtesting Contributor role for the resource
TokenCredential credential = new DefaultAzureCredentialBuilder()
    .build();
// create client using DefaultAzureCredential
LoadTestAdministrationClient adminClient = new LoadTestAdministrationClientBuilder()
        .credential(credential)
        .endpoint("<Enter Azure Load Testing Data-Plane URL>")
        .buildClient();
LoadTestRunClient testRunClient = new LoadTestRunClientBuilder()
        .credential(credential)
        .endpoint("<Enter Azure Load Testing Data-Plane URL>")
        .buildClient();

RequestOptions reqOpts = new RequestOptions()
    .addQueryParam("orderBy", "lastModifiedDateTime")
    .addQueryParam("maxPageSize", "10");
adminClient.listTests(reqOpts);

reqOpts = new RequestOptions()
    .addQueryParam("orderBy", "lastModifiedDateTime")
    .addQueryParam("status", "EXECUTING,DONE")
    .addQueryParam("maxPageSize", "10");
testRunClient.listTestRuns(reqOpts);

Conceptos clave

Los siguientes componentes componen el servicio Azure Load Testing. La biblioteca cliente de Azure Load Test para Java permite interactuar con cada uno de estos componentes mediante el uso de clientes. Hay dos clientes de nivel superior que son los puntos de entrada principales de la biblioteca.

LoadTestingClient
LoadTestingAsyncClient

Los dos clientes también tienen métodos similares, excepto los métodos del cliente asincrónico.

Los clientes de nivel superior tienen dos sub-clientes

LoadTestAdministration
TestRun

Estos sub-clientes se usan para administrar y usar distintos componentes del servicio.

Cliente de administración de pruebas de carga

Los LoadTestAdministration sub-clientes se usan para administrar y configurar las pruebas de carga, los componentes y las métricas de la aplicación.

Prueba

Una prueba especifica el script de prueba y las opciones de configuración para ejecutar una prueba de carga. Puede crear una o varias pruebas en un recurso de Azure Load Testing.

Componente de aplicación

Al ejecutar una prueba de carga para una aplicación hospedada en Azure, puede supervisar las métricas de recursos de los distintos componentes de la aplicación de Azure (métricas del lado servidor). Mientras se ejecuta la prueba de carga y después de la finalización de la prueba, puede supervisar y analizar las métricas de recursos en el panel Azure Load Testing.

Métricas

Durante una prueba de carga, Azure Load Testing recopila métricas sobre la ejecución de pruebas. Existen dos tipos de métricas:

Las métricas del cliente proporcionan los detalles notificados por el motor de prueba. Estas métricas incluyen el número de usuarios virtuales, el tiempo de respuesta de la solicitud, el número de solicitudes con error o el número de solicitudes por segundo.
Las métricas del lado servidor están disponibles para las aplicaciones hospedadas en Azure y proporcionan información sobre los componentes de las aplicaciones de Azure. Las métricas pueden ser para el número de lecturas de base de datos, el tipo de respuestas HTTP o el consumo de recursos de contenedor.

Probar el cliente de ejecución

Los TestRun sub-clientes se usan para iniciar y detener las ejecuciones de pruebas correspondientes a una prueba de carga. Una serie de pruebas representa la ejecución de una prueba de carga. Recopila los registros asociados a la ejecución del script de Apache JMeter, la configuración de YAML de prueba de carga, la lista de componentes de la aplicación que se va a supervisar y los resultados de la prueba.

punto de conexión de Data-Plane

El plano de datos de los recursos de Azure Load Testing se puede direccionable mediante el siguiente formato de dirección URL:

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

El primer GUID 00000000-0000-0000-0000-000000000000 es el identificador único que se usa para acceder al recurso de Azure Load Testing. Esto va seguido de aaa la región de Azure del recurso.

El punto de conexión del plano de datos se obtiene de las API del plano de control.

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

En el ejemplo anterior, eus representa la región East USde Azure .

Ejemplos

Creación de una prueba de carga

LoadTestAdministrationClient adminClient = new LoadTestAdministrationClientBuilder()
        .credential(new DefaultAzureCredentialBuilder().build())
        .endpoint("<endpoint>")
        .buildClient();

// construct Test object using nested String:Object Maps
Map<String, Object> testMap = new HashMap<String, Object>();
testMap.put("displayName", "Sample Display Name");
testMap.put("description", "Sample Description");

// loadTestConfig describes the number of test engines to generate load
Map<String, Object> loadTestConfigMap = new HashMap<String, Object>();
loadTestConfigMap.put("engineInstances", 1);
testMap.put("loadTestConfiguration", loadTestConfigMap);

// environmentVariables are plain-text data passed to test engines
Map<String, Object> envVarMap = new HashMap<String, Object>();
envVarMap.put("a", "b");
envVarMap.put("x", "y");
testMap.put("environmentVariables", envVarMap);

// secrets are secure data sent using Azure Key Vault
Map<String, Object> secretMap = new HashMap<String, Object>();
Map<String, Object> sampleSecretMap = new HashMap<String, Object>();
sampleSecretMap.put("value", "https://samplevault.vault.azure.net/secrets/samplesecret/f113f91fd4c44a368049849c164db827");
sampleSecretMap.put("type", "AKV_SECRET_URI");
secretMap.put("sampleSecret", sampleSecretMap);
testMap.put("secrets", secretMap);

// passFailCriteria define the conditions to conclude the test as success
Map<String, Object> passFailMap = new HashMap<String, Object>();
Map<String, Object> passFailMetrics = new HashMap<String, Object>();
Map<String, Object> samplePassFailMetric = new HashMap<String, Object>();
samplePassFailMetric.put("clientmetric", "response_time_ms");
samplePassFailMetric.put("aggregate", "percentage");
samplePassFailMetric.put("condition", ">");
samplePassFailMetric.put("value", "20");
samplePassFailMetric.put("action", "continue");
passFailMetrics.put("fefd759d-7fe8-4f83-8b6d-aeebe0f491fe", samplePassFailMetric);
passFailMap.put("passFailMetrics", passFailMetrics);
testMap.put("passFailCriteria", passFailMap);

// convert the object Map to JSON BinaryData
BinaryData test = BinaryData.fromObject(testMap);

// receive response with BinaryData content
Response<BinaryData> testOutResponse = adminClient.createOrUpdateTestWithResponse("test12345", test, null);
System.out.println(testOutResponse.getValue().toString());

Carga del archivo .jmx en una prueba de carga

LoadTestAdministrationClient adminClient = new LoadTestAdministrationClientBuilder()
    .credential(new DefaultAzureCredentialBuilder().build())
    .endpoint("<endpoint>")
    .buildClient();

// extract file contents to BinaryData
BinaryData fileData = BinaryData.fromFile(new File("path/to/file").toPath());

// receive response with BinaryData content
Response<BinaryData> fileUrlOut = adminClient.uploadTestFileWithResponse("test12345", "sample-file.jmx", fileData, null);
System.out.println(fileUrlOut.getValue().toString());

Ejecución de una prueba de carga

LoadTestRunClient testRunClient = new LoadTestRunClientBuilder()
    .credential(new DefaultAzureCredentialBuilder().build())
    .endpoint("<endpoint>")
    .buildClient();

// construct Test Run object using nested String:Object Maps
Map<String, Object> testRunMap = new HashMap<String, Object>();
testRunMap.put("testId", "test12345");
testRunMap.put("displayName", "SDK-Created-TestRun");

// convert the object Map to JSON BinaryData
BinaryData testRun = BinaryData.fromObject(testRunMap);

// start test with poller
SyncPoller<BinaryData, BinaryData> poller = testRunClient.beginTestRun("testrun12345", testRun, null);
Duration pollInterval = Duration.ofSeconds(5);
poller = poller.setPollInterval(pollInterval);

// wait for test to reach terminal state
JsonNode testRunJson = null;
String testStatus;
PollResponse<BinaryData> pollResponse = poller.poll();
while (pollResponse.getStatus() == LongRunningOperationStatus.IN_PROGRESS || pollResponse.getStatus() == LongRunningOperationStatus.NOT_STARTED) {
    try {
        testRunJson = new ObjectMapper().readTree(pollResponse.getValue().toString());
        testStatus = testRunJson.get("status").asText();
        System.out.println("Test run status: " + testStatus);
    } catch (JsonProcessingException e) {
        System.out.println("Error processing JSON response");
        // handle error condition
    }

    // wait and check test status every 5 seconds
    try {
        Thread.sleep(pollInterval.toMillis());
    } catch (InterruptedException e) {
        // handle interruption
    }

    pollResponse = poller.poll();
}

poller.waitForCompletion();
BinaryData testRunBinary = poller.getFinalResult();
try {
    testRunJson = new ObjectMapper().readTree(testRunBinary.toString());
    testStatus = testRunJson.get("status").asText();
} catch (JsonProcessingException e) {
    System.out.println("Error processing JSON response");
    // handle error condition
}

String startDateTime = testRunJson.get("startDateTime").asText();
String endDateTime = testRunJson.get("endDateTime").asText();

// get list of all metric namespaces and pick the first one
Response<BinaryData> metricNamespacesOut = testRunClient.getMetricNamespacesWithResponse("testrun12345", null);
String metricNamespace = null;
// parse JSON and read first value
try {
    JsonNode metricNamespacesJson = new ObjectMapper().readTree(metricNamespacesOut.getValue().toString());
    metricNamespace = metricNamespacesJson.get("value").get(0).get("metricNamespaceName").asText();
} catch (JsonProcessingException e) {
    System.out.println("Error processing JSON response");
    // handle error condition
}

// get list of all metric definitions and pick the first one
Response<BinaryData> metricDefinitionsOut = testRunClient.getMetricDefinitionsWithResponse("testrun12345", metricNamespace, null);
String metricName = null;
// parse JSON and read first value
try {
    JsonNode metricDefinitionsJson = new ObjectMapper().readTree(metricDefinitionsOut.getValue().toString());
    metricName = metricDefinitionsJson.get("value").get(0).get("name").get("value").asText();
} catch (JsonProcessingException e) {
    System.out.println("Error processing JSON response");
    // handle error condition
}

// fetch client metrics using metric namespace and metric name
PagedIterable<BinaryData> clientMetricsOut = testRunClient.listMetrics("testrun12345", metricName, metricNamespace, startDateTime + '/' + endDateTime, null);
clientMetricsOut.forEach((clientMetric) -> {
    System.out.println(clientMetric.toString());
});

Solución de problemas

Los SDK de Azure para Java ofrecen una historia de registro coherente para ayudar a solucionar errores de aplicación y acelerar su resolución. Los registros generados capturarán el flujo de una aplicación antes de alcanzar el estado terminal para ayudar a encontrar el problema raíz. Consulte la wiki de registro para obtener instrucciones sobre cómo habilitar el registro.

Pasos siguientes

Los ejemplos del SDK de Java para Pruebas de carga de Azure están disponibles en el repositorio de GitHub del SDK. Estos ejemplos proporcionan código de ejemplo para escenarios adicionales que se suelen encontrar. Consulte ejemplos de Azure Load Testing.

Contribuciones

Para más información sobre cómo contribuir a este repositorio, consulte la guía de contribución.

Bifurcarlo
Creación de la rama de características (git checkout -b my-new-feature)
Confirmar los cambios (git commit -am 'Add some feature')
Inserción en la rama (git push origin my-new-feature)
Creación de una nueva solicitud de incorporación de cambios