Biblioteca de clientes do Teste de Carga do Azure para Java – versão 1.0.7

Artigo
10/21/2023

O Teste de Carga do Azure fornece a biblioteca de clientes em Java para o usuário pelo qual ele pode interagir nativamente com o serviço de Teste de Carga do Azure. Teste de Carga do Azure é um serviço de teste de carga totalmente gerenciado que permite gerar cargas de alta escala. O serviço simula o tráfego para seus aplicativos, independentemente de onde estão hospedados. Desenvolvedores, testadores e engenheiros de garantia de qualidade (QA) podem usá-lo para otimizar o desempenho, a escalabilidade ou a capacidade do aplicativo

Este pacote contém a biblioteca de clientes loadTesting do Desenvolvedor do Microsoft Azure.

Documentação

Várias documentações estão disponíveis para ajudá-lo a começar

Introdução

Pré-requisitos

JDK (Java Development Kit) com a versão 8 ou superior
Assinatura do Azure
Recurso de Teste de Carga do Azure

Adicionando o pacote ao seu produto

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

Autenticação

O pacote de Identidade do Azure fornece a implementação padrão para autenticar o cliente.

Por padrão, a autenticação de token do Azure Active Directory depende da configuração correta das variáveis de ambiente a seguir.

AZURE_CLIENT_ID para a ID do cliente do Azure.
AZURE_TENANT_ID para a ID do locatário do Azure.
AZURE_CLIENT_SECRET ou AZURE_CLIENT_CERTIFICATE_PATH para o segredo do cliente ou certificado do cliente.

Além disso, a ID da assinatura do Azure pode ser configurada por meio da variável AZURE_SUBSCRIPTION_IDde ambiente .

Com a configuração acima, azure o cliente pode ser autenticado pelo seguinte código:

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

Principais conceitos

Os componentes a seguir compõem o serviço de Teste de Carga do Azure. A biblioteca de clientes do Teste de Carga do Azure para Java permite que você interaja com cada um desses componentes por meio do uso de clientes. Há dois clientes de nível superior que são os pontos de entrada main para a biblioteca

LoadTestingClient
LoadTestingAsyncClient

Os dois clientes têm métodos semelhantes, exceto que os métodos no cliente assíncrono também são assíncronos.

Os clientes de nível superior têm dois subprojetos

LoadTestAdministration
TestRun

Esses sub-clientes são usados para gerenciar e usar diferentes componentes do serviço.

Cliente de Administração de Teste de Carga

Os LoadTestAdministration subprocuradores são usados para administrar e configurar os testes de carga, os componentes do aplicativo e as métricas.

Teste

Um teste especifica o script de teste e as definições de configuração para executar um teste de carga. É possível criar um ou mais testes em um recurso de Teste de Carga do Azure.

Componente do aplicativo

Ao executar um teste de carga para um aplicativo hospedado no Azure, você pode monitorar as métricas de recursos para os diferentes componentes de aplicativo do Azure (métricas do lado do servidor). Enquanto o teste de carga é executado e após a conclusão do teste, você pode monitorar e analisar as métricas de recurso no painel de Teste de Carga do Azure.

Métricas

Durante um teste de carga, o Teste de Carga do Azure coleta métricas sobre a execução do teste. Há dois tipos de métricas:

Métricas do lado do cliente fornecem detalhes relatados pelo mecanismo de teste. Essas métricas incluem o número de usuários virtuais, o tempo de resposta da solicitação, o número de solicitações com falha ou o número de solicitações por segundo.
As métricas do lado do servidor estão disponíveis para aplicativos hospedados no Azure e fornecem informações sobre os componentes do aplicativo do Azure. As métricas podem ser para o número de leituras de banco de dados, o tipo de respostas HTTP ou o consumo de recursos de contêiner.

Cliente de Execução de Teste

Os TestRun subprocuradores são usados para iniciar e parar execuções de teste correspondentes a um teste de carga. Uma execução de teste representa uma execução de um teste de carga. Ele coleta os logs associados à execução do script Apache JMeter, a configuração yaml de teste de carga, a lista de componentes do aplicativo a monitorar e os resultados do teste.

ponto de extremidade Data-Plane

O plano de dados dos recursos do Teste de Carga do Azure é endereçável usando o seguinte formato de URL:

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

O primeiro GUID 00000000-0000-0000-0000-000000000000 é o identificador exclusivo usado para acessar o recurso de Teste de Carga do Azure. Isso é seguido por aaa qual é a região do Azure do recurso.

O ponto de extremidade do plano de dados é obtido das APIs do Painel de Controle.

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

No exemplo acima, eus representa a região East USdo Azure .

Exemplos

Criando um teste 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());

Carregando o arquivo .jmx em um teste 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());

Executando um teste 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());
});

Solução de problemas

Os SDKs do Azure para Java oferecem uma história de log consistente para ajudar a solucionar problemas de erros do aplicativo e agilizar a resolução. Os logs produzidos capturam o fluxo de um aplicativo antes que acessem o estado do terminal para ajudar a localizar o problema raiz. Exiba o wiki de log para obter diretrizes sobre como habilitar o registro em log.

Próximas etapas

Os exemplos do SDK do Java de Teste de Carregamento do Azure estão disponíveis para você no repositório GitHub do SDK. Esses exemplos fornecem código de exemplo para cenários adicionais comumente encontrados. Confira Exemplos do Teste de Carga do Azure.

Participante

Para obter detalhes sobre como contribuir para esse repositório, consulte o guia de contribuição.

Bifurcar
Criar seu branch de recurso (git checkout -b my-new-feature)
Confirmar suas alterações (git commit -am 'Add some feature')
Enviar por push para o branch (git push origin my-new-feature)
Criar nova solicitação de pull

Partilhar via