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

È 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 di integrazione continua di connettersi alla risorsa di test di carico Azure.
Aggiungere file di input del test di carico al repository, ad esempio lo script di test 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 gratuito.
Un test di Test di carico di Azure. Creare un test di carico basato su URL, usare uno script JMeter esistente o uno script Locust esistente per creare un test di carico.

Un'organizzazione e un progetto Azure DevOps. Se non si ha un'organizzazione 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 del test di carico. Creare un'entità del servizio per il flusso di lavoro CI/CD e assegnare il ruolo di Collaboratore del test di carico del controllo degli accessi in base al ruolo di Azure.

Creare una connessione al servizio in Azure Pipelines

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

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

Sostituire il segnaposto testo <your-organization> con l'identificatore del progetto.
Selezionare Impostazioni progetto>Connessioni servizio>+ Nuova connessione servizio.
Nel riquadro Nuova connessione al servizio selezionare il Azure Resource Manager e quindi selezionare Next.
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 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 della connessione al servizio	Immettere un nome univoco per la connessione al servizio.
Concedere l'autorizzazione di accesso a tutte le pipeline	Selezionata.

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.
Nel 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 utilizza Azure Role-Based Access Control (RBAC) per concedere autorizzazioni per eseguire attività specifiche sulla 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.

Nel portale Azure passare alla risorsa Test di carico di Azure.
Selezionare Controllo di accesso (IAM)>Aggiungi>Aggiungi assegnazione di ruolo.
Nella scheda Ruolo selezionare Collaboratore test di carico nell'elenco dei ruoli della funzione lavorativa.

Screenshot che mostra l'elenco dei ruoli nella pagina Aggiungi assegnazione di ruolo nel portale di Azure, evidenziando il ruolo di Collaboratore per il Test di Carico.
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 Revisione e assegnazione selezionare Rivedi e assegna per aggiungere l'assegnazione di ruolo.

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

Per accedere alla risorsa Test di carico di Azure dal flusso di lavoro GitHub Actions, creare prima di tutto un'entità servizio principale Microsoft Entra service principal. Questo principale del servizio rappresenta il workflow GitHub Actions in Microsoft Entra ID.

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

Creare un principale servizio

Creare un principale del servizio nella sottoscrizione Azure e assegnare il ruolo di Collaboratore Test di Carico in modo che il workflow di GitHub Actions abbia accesso alla risorsa Azure per i test di carico.

Creare un'entità servizio e assegnarle il ruoloLoad Test Contributor:

# 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/"    
}

Annotazioni

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

Copiare l'oggetto JSON di output negli Appunti.

Nel passaggio successivo si archiviano le informazioni del principale del servizio come segreto di GitHub Actions.

Archiviare le credenziali di Azure nei segreti di GitHub Actions

Creare un segreto di GitHub Actions per archiviare in modo sicuro le informazioni del principale del 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 Azure.

Annotazioni

Se si usa OpenID Connect per eseguire l'autenticazione con Azure, non è necessario passare l'oggetto principale del servizio nell'azione di accesso ad Azure. Informazioni su come usare l'azione di accesso Azure con OpenID Connect.

Per creare un segreto GitHub Actions:

In GitHub passare al repository.
Selezionare Impostazioni>Segreti e variabili>Azioni.
Selezionare Nuovo segreto del repository, immettere le informazioni segrete, 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 Azure e alla risorsa di test di carico dal flusso di lavoro GitHub Actions usando le credenziali archiviate.

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

Creare un'entità Microsoft Entra principale del servizio per connettersi alla sottoscrizione di Azure e accedere alla risorsa per i 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 segnaposto di testo <resource-group-name> 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 valori clientId, clientSecret e tenantId e archiviarli in modo sicuro come segreti nello strumento di integrazione continua (CI).

Questi valori vengono usati per accedere alla sottoscrizione Azure con il comando 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 (file JMX). Per i test basati su Locust, aggiungere uno script di test Locust (.py 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:

Nel portale 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. Viene fatto riferimento a questo file nella definizione del flusso di lavoro CI/CD.
- .jmx o .py: script di test JMeter o Locust
- 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 Test di carico di Azure di Azure DevOps Marketplace.

Aprire l'estensione dell'attività Test di carico di Azure in Azure DevOps Marketplace e selezionare Get it free.
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 Request per richiedere a un amministratore di installare l'estensione.

Aggiornare il flusso di lavoro Azure Pipelines

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

Accedere all'organizzazione 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 proprietà loadTestConfigFile.

Sostituire i segnaposto di testo <load-testing-resource> e <load-testing-resource-group> con il nome della risorsa di test di carico 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 trasmettere parametri o segreti al test di carico utilizzando la proprietà env o secrets. Impostare waitForCompletion: false se si desidera procedere senza attendere il completamento dell'esecuzione del test di carico.
Usare l'attività publish per pubblicare i risultati del test come artefatti durante l'esecuzione del flusso di lavoro di Azure Pipelines.
```
    - publish: $(System.DefaultWorkingDirectory)/loadTest
      artifact: loadTestResults
```

Aggiornare il flusso di lavoro GitHub Actions

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

In GitHub passare al repository.
Modificare il flusso di lavoro GitHub Actions o creare un nuovo flusso di lavoro nel repository GitHub.
Fare uso dell'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 azure/login per eseguire l'autenticazione 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 }}
```
Fare uso dell'azione azure/load-testing per eseguire il test di carico.

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

Sostituire i segnaposto di testo <load-testing-resource> e <load-testing-resource-group> con il nome della risorsa di test di carico 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 trasmettere parametri o segreti al test di carico utilizzando la proprietà env o secrets. Impostare waitForCompletion: false se si desidera procedere senza attendere il completamento dell'esecuzione del test di carico.
Usare l'azione actions/upload-artifact per pubblicare i risultati del test come artefatti nell'esecuzione del flusso di lavoro GitHub Actions.
```
    - uses: actions/upload-artifact@v2
      with:
        name: loadTestResults
        path: ${{ github.workspace }}/loadTest
```

Aggiorna il flusso di lavoro CI per effettuare un test di carico per la risorsa di test di carico Azure utilizzando l'interfaccia della riga di comando di Azure. Usare le specifiche dello strumento CI per aggiungere i comandi seguenti al flusso di lavoro CI:

Accedi alla sottoscrizione di Azure utilizzando il principale del servizio.

Usare i valori clientId, clientSecret e tenantId 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 segnaposto di testo <load-testing-resource>, <load-testing-resource-group>e <load-test-config-yaml> con il nome della risorsa del 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 del 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 un’ulteriore creazione di report.

Screenshot che mostra le informazioni di registrazione del flusso di lavoro.

Pulire le risorse

Se le risorse create non servono più, eliminarle per evitare ulteriori addebiti.

Rimuovere modifiche di Azure Pipelines
1. Accedere all'organizzazione Azure DevOps (https://dev.azure.com/<your-organization>) e selezionare il progetto.
  
  Sostituire il segnaposto testo <your-organization> con l'identificatore del progetto.
2. Se è stata creata una nuova 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 Project settings>Service connections 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 flusso di lavoro nella cartella .github/workflows.
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.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-04-20