Configurare manualmente il flusso di lavoro CI/CD per l'esecuzione di test di carico

Articolo
12/15/2023

È possibile automatizzare un test di carico in Test di carico di Azure creando una pipeline CI/CD. Questo articolo illustra come configurare manualmente GitHub Actions, Azure Pipelines o altri strumenti di integrazione continua per richiamare un test esistente in Test di carico di Azure. Automatizzare un test di carico per convalidare continuamente le prestazioni e la stabilità dell'applicazione in condizioni di carico.

Per aggiungere un test di carico esistente a una pipeline CI/CD:

Configurare l'autenticazione del servizio per consentire allo strumento ci di connettersi alla risorsa di test di carico di Azure.
Aggiungere file di input del test di carico al repository, ad esempio lo script di test JMeter e la configurazione YAML del test di carico.
Aggiornare la definizione della pipeline CI/CD per richiamare Test di carico di Azure.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
Test di carico di Azure. Creare un test di carico basato su URL o usare uno script JMeter esistente per creare un test di carico.

Un'organizzazione e un progetto di Azure DevOps. Se non si ha un'organizzazione di Azure DevOps, è possibile crearne una gratuitamente. Per informazioni su come iniziare a usare Azure Pipelines, vedere Creare la prima pipeline.

Configurare l'autenticazione del servizio

Per eseguire un test di carico nel flusso di lavoro CI/CD, è necessario concedere l'autorizzazione al flusso di lavoro CI/CD per accedere alla risorsa di test di carico. Creare un'entità servizio per il flusso di lavoro CI/CD e assegnare il ruolo Controllo degli accessi in base al ruolo di Azure Collaboratore test di carico.

Creare una connessione al servizio in Azure Pipelines

In Azure Pipelines si crea una connessione al servizio nel progetto Azure DevOps per accedere alle risorse nella sottoscrizione di Azure. Quando si crea la connessione al servizio, Azure DevOps crea un oggetto entità servizio Microsoft Entra.

Accedere all'organizzazione di Azure DevOps (https://dev.azure.com/<your-organization>) e selezionare il progetto.

Sostituire il segnaposto di testo con l'identificatore <your-organization> del progetto.
Selezionare Impostazioni progetto>Connessioni> servizio+ Nuova connessione al servizio.
Nel riquadro Nuova connessione al servizio selezionare Azure Resource Manager e quindi selezionare Avanti.
Selezionare il metodo di autenticazione dell'entità servizio (automatico) e quindi selezionare Avanti.

Immettere i dettagli della connessione al servizio e quindi selezionare Salva per creare la connessione al servizio.

Campo	Valore
Livello di ambito	Sottoscrizione.
Abbonamento	Selezionare la sottoscrizione di Azure che ospita la risorsa di test di carico.
Gruppo di risorse	Selezionare il gruppo di risorse che contiene la risorsa di test di carico.
Nome connessione del servizio	Immettere un nome univoco per la connessione al servizio.
Concedere l'autorizzazione di accesso a tutte le pipeline	Selezionato.

Nell'elenco delle connessioni al servizio selezionare quella creata in precedenza e quindi selezionare Gestisci entità servizio.

Il portale di Azure viene aperto in una scheda separata del browser e mostra i dettagli dell'entità servizio.
Nella portale di Azure copiare il valore Nome visualizzato.

Questo valore viene usato nel passaggio successivo per concedere le autorizzazioni per l'esecuzione di test di carico all'entità servizio.

Concedere l'accesso a Test di carico di Azure

Test di carico di Azure usa il controllo degli accessi in base al ruolo di Azure per concedere le autorizzazioni per l'esecuzione di attività specifiche nella risorsa di test di carico. Per eseguire un test di carico dalla pipeline CI/CD, si concede il ruolo Collaboratore test di carico all'entità servizio.

Nella portale di Azure passare alla risorsa Test di carico di Azure.
Selezionare Controllo di accesso (IAM)>Aggiungi>assegnazione di ruolo.
Nella scheda Ruolo selezionare Collaboratore test di carico nell'elenco dei ruoli della funzione del processo.
Nella scheda Membri selezionare Seleziona membri e quindi usare il nome visualizzato copiato in precedenza per cercare l'entità servizio.
Selezionare l'entità servizio e quindi selezionare Seleziona.
Nella scheda Rivedi e assegna selezionare Rivedi e assegna per aggiungere l'assegnazione di ruolo.

È ora possibile usare la connessione al servizio nella definizione del flusso di lavoro di Azure Pipelines per accedere alla risorsa di test di carico di Azure.

Per accedere alla risorsa test di carico di Azure dal flusso di lavoro di GitHub Actions, creare prima un'entità servizio Microsoft Entra. Questa entità servizio rappresenta il flusso di lavoro di GitHub Actions in Microsoft Entra ID.

Successivamente, si concedono le autorizzazioni all'entità servizio per creare ed eseguire un test di carico con la risorsa Test di carico di Azure.

Creare un'entità servizio

Creare un'entità servizio nella sottoscrizione di Azure e assegnare il ruolo Collaboratore test di carico in modo che il flusso di lavoro di GitHub Actions abbia accesso alla risorsa test di carico di Azure per eseguire test di carico.

Creare un'entità servizio e assegnare il Load Test Contributor ruolo:

# Get the resource ID for the load testing resource - replace the text place holders.
loadtest=$(az resource show -g <resource-group-name> -n <load-testing-resource-name> --resource-type "Microsoft.LoadTestService/loadtests" --query "id" -o tsv)
echo $loadtest

# Create a service principal and assign the Load Test Contributor role - the scope is limited to the load testing resource.
az ad sp create-for-rbac --name "my-load-test-cicd" --role "Load Test Contributor" \
                         --scopes $loadtest \
                         --json-auth

L'output è un oggetto JSON che rappresenta l'entità servizio. Queste informazioni vengono usate per l'autenticazione con Azure nel flusso di lavoro di GitHub Actions.

Creating 'Load Test Contributor' role assignment under scope
{
  "clientId": "00000000-0000-0000-0000-000000000000",
  "clientSecret": "00000000-0000-0000-0000-000000000000",
  "subscriptionId": "00000000-0000-0000-0000-000000000000",
  "tenantId": "00000000-0000-0000-0000-000000000000",
  "activeDirectoryEndpointUrl": "https://login.microsoftonline.com",
  "resourceManagerEndpointUrl": "https://management.azure.com/",
  "activeDirectoryGraphResourceId": "https://graph.windows.net/",
  "sqlManagementEndpointUrl": "https://management.core.windows.net:8443/",
  "galleryEndpointUrl": "https://gallery.azure.com/",
  "managementEndpointUrl": "https://management.core.windows.net/"    
}

Nota

È possibile che venga visualizzato un --sdk-auth avviso di deprecazione quando si esegue questo comando. In alternativa, è possibile usare l'autenticazione basata su OpenID Connessione (OIDC) per l'autenticazione di GitHub con Azure. Informazioni su come usare l'azione di accesso di Azure con OpenID Connessione.

Copiare l'oggetto JSON di output negli Appunti.

Nel passaggio successivo si archiviano le informazioni dell'entità servizio come segreto gitHub Actions.

Archiviare le credenziali di Azure nel segreto gitHub Actions

Creare un segreto GitHub Actions per archiviare in modo sicuro le informazioni dell'entità servizio. Questo segreto viene usato nella definizione del flusso di lavoro per connettersi all'autenticazione con Azure e accedere alla risorsa di test di carico di Azure.

Nota

Se si usa OpenID Connessione per eseguire l'autenticazione con Azure, non è necessario passare l'oggetto entità servizio nell'azione di accesso di Azure. Informazioni su come usare l'azione di accesso di Azure con OpenID Connessione.

Per creare un segreto GitHub Actions:

In GitHub passare al repository.
Selezionare Impostazioni> Secrets & variables>Actions (Azioni).
Selezionare Nuovo segreto del repository, immettere le informazioni segrete e quindi selezionare Aggiungi segreto per creare un nuovo segreto.

Campo Valore

Nome AZURE_CREDENTIALS

Segreto Incollare l'output JSON dal comando di creazione dell'entità servizio copiato in precedenza.

Campo	Valore
Nome	AZURE_CREDENTIALS
Segreto	Incollare l'output JSON dal comando di creazione dell'entità servizio copiato in precedenza.

È ora possibile accedere alla sottoscrizione di Azure e alla risorsa di test di carico dal flusso di lavoro di GitHub Actions usando le credenziali archiviate.

Se si usa un altro strumento CI/CD, usare l'interfaccia della riga di comando di Azure per interagire con le risorse di Azure. Seguire questa procedura per autorizzare l'accesso dello strumento di integrazione continua alla risorsa di test di carico:

Creare un'entità servizio Microsoft Entra per connettersi alla sottoscrizione di Azure e accedere alla risorsa di test di carico di Azure.
Concedere all'entità servizio le autorizzazioni per creare ed eseguire un test di carico assegnando il ruolo Collaboratore test di carico.
Archiviare le credenziali di Azure in modo sicuro nello strumento CI.

Per configurare l'autorizzazione del servizio per lo strumento CI, seguire questa procedura:

Creare un'entità servizio e assegnare il ruolo Collaboratore test di carico:

Sostituire i <resource-group-name> segnaposto e <load-testing-resource-name> .

# Get the resource ID for the load testing resource - replace the text place holders.
loadtest=$(az resource show -g <resource-group-name> -n <load-testing-resource-name> --resource-type "Microsoft.LoadTestService/loadtests" --query "id" -o tsv)
echo $loadtest

# Create a service principal and assign the Load Test Contributor role - the scope is limited to the load testing resource.
az ad sp create-for-rbac --name "my-load-test-cicd" --role "Load Test Contributor" \
                         --scopes $loadtest \
                         --json-auth

L'output è un oggetto JSON che rappresenta l'entità servizio.

Creating 'Load Test Contributor' role assignment under scope
{
  "clientId": "00000000-0000-0000-0000-000000000000",
  "clientSecret": "00000000-0000-0000-0000-000000000000",
  "subscriptionId": "00000000-0000-0000-0000-000000000000",
  "tenantId": "00000000-0000-0000-0000-000000000000",
  "activeDirectoryEndpointUrl": "https://login.microsoftonline.com",
  "resourceManagerEndpointUrl": "https://management.azure.com/",
  "activeDirectoryGraphResourceId": "https://graph.windows.net/",
  "sqlManagementEndpointUrl": "https://management.core.windows.net:8443/",
  "galleryEndpointUrl": "https://gallery.azure.com/",
  "managementEndpointUrl": "https://management.core.windows.net/"    
}

Copiare i clientIdvalori , clientSecrete tenantId e archiviarli in modo sicuro come segreti nello strumento di integrazione continua.

Questi valori vengono usati per accedere alla sottoscrizione di Azure con il comando dell'interfaccia della riga di comando di Azure az login .

Aggiungere file di test di carico nel repository

Per eseguire un test di carico con test di carico di Azure in un flusso di lavoro CI/CD, è necessario aggiungere tutti i file di input del test di carico nel repository del controllo del codice sorgente.

Se non si dispone di un test di carico esistente, aggiungere i file seguenti al repository del codice sorgente:

File YAML di configurazione del test di carico. Informazioni su come creare un file YAML di configurazione del test di carico.
File del piano di test. Per i test basati su JMeter, aggiungere uno script di test JMeter (JMX file). Per i test basati su URL, aggiungere un file JSON di richieste.
Tutti i file delle proprietà utente di JMeter.
Qualsiasi file di dati di input usato dal piano di test. Ad esempio, file di dati CSV.

Se si dispone di un test di carico esistente, è possibile scaricare le impostazioni di configurazione e tutti i file di input direttamente dal portale di Azure. Seguire questa procedura per scaricare i file di input per un test di carico esistente nel portale di Azure:

Nella portale di Azure passare alla risorsa Test di carico di Azure.
Nel riquadro sinistro selezionare Test per visualizzare l'elenco dei test di carico e quindi selezionare il test.
Selezionare i puntini di sospensione (...) accanto all'esecuzione del test in uso e quindi selezionare Scarica file di input.

Il browser scarica una cartella compressa che contiene i file di input del test di carico.
Usare qualsiasi strumento ZIP per estrarre i file di input.

La cartella contiene i file seguenti:
- config.yaml: il file di configurazione YAML del test di carico. Questo file viene fatto riferimento nella definizione del flusso di lavoro CI/CD.
- .jmx: script di test di JMeter
- Eventuali file di input aggiuntivi, ad esempio file CSV o file di proprietà utente necessari per eseguire il test di carico.
Eseguire il commit di tutti i file di input estratti nel repository del controllo del codice sorgente.

Usare il repository del codice sorgente in cui si configura la pipeline CI/CD.

Aggiornare la definizione del flusso di lavoro CI/CD

Test di carico di Azure supporta sia GitHub Actions che Azure Pipelines per l'esecuzione di test di carico.

Installare l'estensione Test di carico di Azure per Azure DevOps

Per creare ed eseguire un test di carico, la definizione del flusso di lavoro di Azure Pipelines usa l'estensione dell'attività Test di carico di Azure da Azure DevOps Marketplace.

Aprire l'estensione dell'attività Test di carico di Azure in Azure DevOps Marketplace e selezionare Scarica gratuitamente.
Selezionare l'organizzazione Azure DevOps e quindi selezionare Installa per installare l'estensione.

Se non si hanno privilegi di amministratore per l'organizzazione Azure DevOps selezionata, selezionare Richiedi per richiedere a un amministratore di installare l'estensione.

Aggiornare il flusso di lavoro di Azure Pipelines

Aggiornare il flusso di lavoro di Azure Pipelines per eseguire un test di carico per la risorsa di test di carico di Azure.

Accedere all'organizzazione di Azure DevOps (https://dev.azure.com/<your-organization>) e selezionare il progetto.
Selezionare Pipeline nel riquadro di spostamento sinistro, selezionare la pipeline e quindi selezionare Modifica per modificare la definizione del flusso di lavoro.

In alternativa, selezionare Crea pipeline per creare una nuova pipeline in Azure Pipelines.
Usare l'attività AzureLoadTest per eseguire il test di carico.

Specificare il file di configurazione del test di carico esportato in precedenza nella loadTestConfigFile proprietà .

Sostituire i <load-testing-resource> segnaposto di testo e <load-testing-resource-group> con il nome della risorsa di test di carico di Azure e del gruppo di risorse.
```
    - task: AzureLoadTest@1
      inputs:
        azureSubscription: $(serviceConnection)
        loadTestConfigFile: 'config.yaml'
        loadTestResource: <load-testing-resource>
        resourceGroup: <load-testing-resource-group>
```
Facoltativamente, è possibile passare parametri o segreti al test di carico usando la env proprietà o secrets .
Usare l'attività publish per pubblicare i risultati del test come artefatti nell'esecuzione del flusso di lavoro di Azure Pipelines.
```
    - publish: $(System.DefaultWorkingDirectory)/loadTest
      artifact: loadTestResults
```

Aggiornare il flusso di lavoro di GitHub Actions

Aggiornare il flusso di lavoro di GitHub Actions per eseguire un test di carico per la risorsa di test di carico di Azure.

In GitHub passare al repository.
Modificare il flusso di lavoro di GitHub Actions o creare un nuovo flusso di lavoro nel repository GitHub.
Usare l'azione actions/checkout per eseguire il check-out del repository con i file di input del test di carico.
```
    - name: Checkout
      uses: actions/checkout@v3
```
Usare l'azione per eseguire l'autenticazione azure/login con Azure usando le credenziali archiviate.

Incollare il contenuto YAML seguente nella definizione del flusso di lavoro:
```
    - name: Login to Azure
      uses: azure/login@v1
      continue-on-error: false
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}
```
Usare l'azione azure/load-testing per eseguire il test di carico.

Specificare il file di configurazione del test di carico esportato in precedenza nella loadTestConfigFile proprietà .

Sostituire i <load-testing-resource> segnaposto di testo e <load-testing-resource-group> con il nome della risorsa di test di carico di Azure e del gruppo di risorse.
```
    - name: 'Azure Load Testing'
      uses: azure/load-testing@v1
      with:
        loadTestConfigFile: 'config.yaml'
        loadTestResource: <load-testing-resource>
        resourceGroup: <load-testing-resource-group>
```
Facoltativamente, è possibile passare parametri o segreti al test di carico usando la env proprietà o secrets .
Usare l'azione actions/upload-artifact per pubblicare i risultati del test come artefatti nell'esecuzione del flusso di lavoro di GitHub Actions.
```
    - uses: actions/upload-artifact@v2
      with:
        name: loadTestResults
        path: ${{ github.workspace }}/loadTest
```

Aggiornare il flusso di lavoro ci per eseguire un test di carico per la risorsa di test di carico di Azure usando l'interfaccia della riga di comando di Azure. Usare le specifiche dello strumento ci per aggiungere i comandi seguenti al flusso di lavoro ci:

Accedere alla sottoscrizione di Azure usando l'entità servizio.

Usare i clientIdvalori , clientSecrete tenandId archiviati in precedenza.

az login --service-principal -u $AZURE_CLIENT_ID -p $AZURE_CLIENT_SECRET -t $AZURE_TENANT_ID
az account set -s $AZURE_SUBSCRIPTION_ID

Creare un test di carico usando il file YAML di configurazione del test di carico.

Sostituire i <load-testing-resource>segnaposto di testo , <load-testing-resource-group>e <load-test-config-yaml> con il nome della risorsa di test di carico, il nome del gruppo di risorse e il nome file del file YAML di configurazione del test di carico aggiunto in precedenza al repository.
```
az load test create --load-test-resource <load-testing-resource> --resource-group <load-testing-resource-group> --test-id sample-test-id --load-test-config-file <load-test-config-yaml>
```

Eseguire il test di carico.

testRunId="run_"`date +"%Y%m%d%_H%M%S"`
displayName="Run"`date +"%Y/%m/%d_%H:%M:%S"`

az load test-run create --load-test-resource <load-testing-resource> --test-id sample-test-id --test-run-id $testRunId --display-name $displayName --description "Test run from CLI"

Recuperare e visualizzare le metriche lato client per l'esecuzione del test di carico.

az load test-run metrics list --load-test-resource <load-testing-resource> --test-run-id $testRunId --metric-namespace LoadTestRunMetrics

Visualizzare i risultati dei test di carico

Quando si esegue un test di carico dalla pipeline CI/CD, è possibile visualizzare i risultati di riepilogo direttamente nel log di output CI/CD. Se i risultati del test sono stati pubblicati come artefatto della pipeline, è anche possibile scaricare un file CSV per ulteriori report.

Screenshot that shows the workflow logging information.

Pulire le risorse

Se non si prevede di usare alcuna delle risorse create, eliminarle in modo da non comportare ulteriori addebiti.

Rimuovere le modifiche di Azure Pipelines:
1. Accedere all'organizzazione di Azure DevOps (https://dev.azure.com/<your-organization>) e selezionare il progetto.
  
  Sostituire il segnaposto di testo con l'identificatore <your-organization> del progetto.
2. Se è stata creata una nuova pipeline:If you created a new pipeline":
  1. Selezionare Pipeline e quindi selezionare la pipeline.
  2. Selezionare i puntini di sospensione e quindi selezionare Elimina.
  3. Immettere il nome della pipeline e quindi selezionare Elimina per eliminare la pipeline.
3. Se è stata modificata una definizione del flusso di lavoro esistente, annullare le modifiche per l'esecuzione del test di carico e salvare il flusso di lavoro.
Rimuovere la connessione al servizio:
1. Selezionare Impostazioni progetto>Connessioni al servizio e quindi selezionare la connessione al servizio.
2. Selezionare Modifica>elimina per rimuovere la connessione al servizio.

Rimuovere le modifiche di GitHub Actions:
1. In GitHub passare al repository.
2. Se è stata creata una nuova definizione del flusso di lavoro, eliminare il file YAML del .github/workflows flusso di lavoro nella cartella .
3. Se è stata modificata una definizione del flusso di lavoro esistente, annullare le modifiche per l'esecuzione del test di carico e salvare il flusso di lavoro.

Rimuovere l'entità servizio:

az ad sp delete --id $(az ad sp show --display-name "my-load-test-cicd" -o tsv)

Passaggi successivi

Passare all'articolo successivo per informazioni su come identificare le regressioni delle prestazioni definendo i criteri di esito negativo del test e confrontando le esecuzioni dei test.