Configure manualmente o fluxo de trabalho de CI/CD para executar testes de carga

• Uma organização e projeto Azure DevOps. Se não tiver uma organização Azure DevOps, pode criar uma gratuitamente. Se precisar de ajuda para começar com Azure Pipelines, veja Crie o seu primeiro pipeline.

• Uma conta no GitHub. Se não tiver uma conta GitHub, pode criar uma gratuitamente.
• Um repositório GitHub para armazenar os ficheiros de entrada do load test e criar um fluxo de trabalho GitHub Actions. Para criar um, consulte Criando um novo repositório.

• Permissão para criar ou modificar um pipeline de CI.
• Um repositório de código-fonte para armazenar os arquivos de entrada de teste de carga.

Criar uma ligação de serviço no Azure Pipelines

No Azure Pipelines, cria uma ligação serviço no seu projeto de Azure DevOps para aceder a recursos da sua subscrição Azure. Quando crias a ligação de serviço, o Azure DevOps cria um objeto principal de serviço Microsoft Entra.

1. Inicie sessão na sua organização Azure DevOps (https://dev.azure.com/<your-organization>) e selecione o seu projeto.

   Substitua o marcador de texto <your-organization> pelo identificador do seu projeto.

2. Selecione definições Project>Ligações de serviço>+ Nova ligação de serviço.

3. No painel Nova ligação de serviço, selecione o Azure Resource Manager e depois selecione Próximo.

4. Selecione o método de autenticação da entidade de serviço (automática) e, em seguida, selecione Avançar.

5. Insira os detalhes da conexão de serviço e selecione Salvar para criar a conexão de serviço.

   Campo	Valor
   Nível de âmbito	Subscrição.
   Subscrição	Selecione a subscrição do Azure que hospeda o seu recurso de testes de carga.
   Grupo de recursos	Selecione o grupo de recursos que contém o recurso de teste de carga.
   Nome da conexão de serviço	Insira um nome exclusivo para a conexão de serviço.
   Conceder permissão de acesso a todos os pipelines	Verificado.

6. Na lista de conexões de serviço, selecione a conexão que criou anteriormente e, em seguida, selecione Gerir Service Principal.

   

   O portal Azure abre-se num separador separado do navegador e mostra os detalhes do principal do serviço.

7. No portal Azure, copie o valor Nome de visualização.

   Use esse valor na próxima etapa para conceder permissões para a execução de testes de carga na entidade de serviço.

Conceder acesso ao Azure Load Testing

O Azure Load Testing utiliza o Azure RBAC para conceder permissões para realizar atividades específicas no seu recurso de testes de carga. Para executar um teste de carga a partir do pipeline de CI/CD, conceda a função de Colaborador de Teste de Carga ao principal de serviço.

1. No portal Azure, acede ao teu recurso Azure Load Testing.

2. Selecione Controle de acesso (IAM)>Adicionar>Adicionar atribuição de função.

3. Na guia Função, selecione Colaborador de Teste de Carga na lista de funções.

   

4. Na guia Membros, selecione Selecionar membros e use o nome de exibição copiado anteriormente para pesquisar a entidade de serviço.

5. Selecione a entidade de serviço e, em seguida, selecione Selecionar.

6. No separador Rever + atribuir, selecione Rever + atribuir para adicionar a atribuição de função.

Agora pode usar a ligação de serviço na definição do seu fluxo de trabalho Azure Pipelines para aceder ao seu recurso de testes de carga Azure.

Para aceder ao seu recurso de Azure Load Testing a partir do fluxo de trabalho GitHub Actions, primeiro, cria um principal de serviço Microsoft Entra . Este principal de serviço representa o seu fluxo de trabalho GitHub Actions no Microsoft Entra ID.

De seguida, concede permissões ao principal do serviço para criar e executar um teste de carga com o seu recurso Azure Load Testing.

Criar um "service principal"

Cria um principal de serviço na subscrição do Azure e atribui o papel de Contribuidor de Testes de Carga para que o teu fluxo de trabalho GitHub Actions tenha acesso ao teu recurso de testes de carga do Azure para executar testes de carga.

1. Crie uma entidade de serviço e atribua a Load Test Contributor função:

   # 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
   

   A saída é um objeto JSON que representa a entidade de serviço. Usa esta informação para autenticar com o Azure no fluxo de trabalho 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/"    
   }
   

   Observação

   Poderá receber um --sdk-auth aviso de desativação quando executar este comando. Em alternativa, pode usar autenticação baseada no OpenID Connect (OIDC) para autenticar o GitHub com o Azure. Aprenda a usar a ação de login Azure com o OpenID Connect.

2. Copie o objeto JSON de saída para a área de transferência.

   No passo seguinte, irá armazenar a informação do principal de serviço como um segredo do GitHub Actions.

Armazene credenciais do Azure no GitHub Actions secret

Crie um segredo GitHub Actions para armazenar as informações do principal do serviço de forma segura. Usa este segredo na definição do seu fluxo de trabalho para se ligar e autenticar com o Azure e aceder ao seu recurso de testes de carga do Azure.

Para criar um segredo do GitHub Actions:

1. Em GitHub, navegue até ao seu repositório.

2. Selecione Configurações>>

3. Selecione Novo segredo do repositório, insira as informações secretas e selecione Adicionar segredo para criar um novo segredo.

   Campo	Valor
   Nome	AZURE_CREDENTIALS
   Segredo	Cole a saída JSON do comando de criação do principal de serviço copiado anteriormente.

Agora pode aceder à sua subscrição do Azure e ao recurso de testes de carga a partir do seu fluxo de trabalho GitHub Actions, usando as credenciais armazenadas.

Se estiveres a usar outra ferramenta CI/CD, usas a CLI do Azure para interagir com os teus recursos do Azure. Execute as seguintes etapas para autorizar o acesso da ferramenta CI ao seu recurso de teste de carga:

1. Crie um principal de serviço do Microsoft Entra para se ligar à sua subscrição do Azure e aceder ao seu recurso de testes de carga do Azure.
2. Conceda à entidade de serviço permissões para criar e executar um teste de carga atribuindo a função de Colaborador de Teste de Carga.
3. Armazene as credenciais do Azure de forma segura na ferramenta CI.

Execute as seguintes etapas para configurar a autorização de serviço para sua ferramenta de CI:

1. Crie um principal de serviço e atribua a função de Colaborador de Teste de Carga:

   Substitua os espaços reservados de texto <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
   

   A saída é um objeto JSON que representa a entidade de serviço.

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

2. Copie os clientIdvalores , clientSecrete tenantId e armazene-os com segurança como segredos em sua ferramenta de CI.

   Usa estes valores para iniciar sessão na sua subscrição Azure com o comando CLI do Azure az login.

Instale a extensão Azure Load Testing para Azure DevOps

Para criar e executar um teste de carga, a definição do fluxo de trabalho Azure Pipelines utiliza a extensão Azure Load Testing task do Azure DevOps Marketplace.

1. Abra a extensão de tarefa Azure Load Testing no Azure DevOps Marketplace e selecione Obtenha-a gratuitamente.

2. Selecione a sua organização Azure DevOps e depois selecione Install para instalar a extensão.

   Se não tiver privilégios de administrador para a organização Azure DevOps selecionada, selecione Request para solicitar a instalação da extensão a um administrador.

Atualize o fluxo de trabalho Azure Pipelines

Atualize o seu fluxo de trabalho do Azure Pipelines para executar um teste de carga para o seu recurso de testes de carga do Azure.

1. Inicie sessão na sua organização Azure DevOps (https://dev.azure.com/<your-organization>) e selecione o seu projeto.

2. Selecione Pipelines na navegação à esquerda, selecione seu pipeline e selecione Editar para editar sua definição de fluxo de trabalho.

   Em alternativa, selecione Criar pipeline para criar um novo pipeline em Azure Pipelines.

3. Use a AzureLoadTest tarefa para executar o teste de carga.

   Especifique o ficheiro de configuração do teste de carga exportado anteriormente na propriedade loadTestConfigFile.

   Substitua os marcadores de texto <load-testing-resource> e <load-testing-resource-group> pelo nome do seu recurso de teste de carga Azure e do grupo de recursos.

       - task: AzureLoadTest@1
         inputs:
           azureSubscription: $(serviceConnection)
           loadTestConfigFile: 'config.yaml'
           loadTestResource: <load-testing-resource>
           resourceGroup: <load-testing-resource-group>
   

   Opcionalmente, pode passar parâmetros ou segredos para o teste de carga usando a propriedade env ou secrets. Define waitForCompletion: false se quiseres avançar sem esperar que a execução do teste de carga termine.

4. Use a tarefa publish para publicar os resultados do teste como artefatos na execução do fluxo de trabalho do Azure Pipelines.

       - publish: $(System.DefaultWorkingDirectory)/loadTest
         artifact: loadTestResults
   

Atualize o fluxo de trabalho GitHub Actions

Atualize o seu fluxo de trabalho GitHub Actions para executar um teste de carga para o seu recurso de testes de carga do Azure.

1. Em GitHub, navegue até ao seu repositório.

2. Edita o teu fluxo de trabalho GitHub Actions ou cria um novo fluxo de trabalho no teu repositório GitHub.

3. Use a ação actions/checkout para aceder ao repositório com os arquivos de entrada de teste de carga.

       - name: Checkout
         uses: actions/checkout@v3
   

4. Use a ação azure/login para autenticar com Azure usando as credenciais armazenadas.

   Cole o seguinte conteúdo YAML na definição do fluxo de trabalho:

       - name: Login to Azure
         uses: azure/login@v1
         continue-on-error: false
         with:
           creds: ${{ secrets.AZURE_CREDENTIALS }}
   

5. Use a azure/load-testing ação para executar o teste de carga.

   Especifique o ficheiro de configuração do teste de carga exportado anteriormente na propriedade loadTestConfigFile.

   Substitua os marcadores de texto <load-testing-resource> e <load-testing-resource-group> pelo nome do seu recurso de teste de carga Azure e do grupo de recursos.

       - name: 'Azure Load Testing'
         uses: azure/load-testing@v1
         with:
           loadTestConfigFile: 'config.yaml'
           loadTestResource: <load-testing-resource>
           resourceGroup: <load-testing-resource-group>
   

   Opcionalmente, pode passar parâmetros ou segredos para o teste de carga usando a propriedade env ou secrets. Define waitForCompletion: false se quiseres avançar sem esperar que a execução do teste de carga termine.

6. Utilize a ação actions/upload-artifact para publicar os resultados do teste como artefatos no seu fluxo de trabalho do GitHub Actions.

       - uses: actions/upload-artifact@v2
         with:
           name: loadTestResults
           path: ${{ github.workspace }}/loadTest
   

Atualize o seu fluxo de trabalho CI para executar um teste de carga para o seu recurso de testes de carga do Azure usando a linha de comando do CLI do Azure. Use as especificidades da sua ferramenta de CI para adicionar os seguintes comandos ao seu fluxo de trabalho de CI:

1. Inicie sessão na subscrição do Azure usando o principal do serviço.

   Utilize os valores clientId, clientSecret e tenantId que armazenou anteriormente.

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

2. Crie um teste de carga usando o arquivo YAML de configuração de teste de carga.

   Substitua os espaços reservados de texto <load-testing-resource>, <load-testing-resource-group> e <load-test-config-yaml> pelo nome do recurso de teste de carga, o nome do grupo de recursos e o nome do ficheiro YAML de configuração de teste de carga que foi adicionado ao repositório anteriormente.

   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>
   

3. Execute o teste de carga.

   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"
   

4. Recupere e exiba as métricas do lado do cliente para a execução do teste de carga.

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

1. Remover alterações do Azure Pipelines:

   1. Inicie sessão na sua organização Azure DevOps (https://dev.azure.com/<your-organization>) e selecione o seu projeto.

      Substitua o marcador de texto <your-organization> pelo identificador do seu projeto.

   2. Se você criou um novo pipeline":

      1. Selecione Pipelines e, em seguida, selecione seu pipeline.

      2. Selecione as reticências e, em seguida, selecione Eliminar.

         

      3. Insira o nome do pipeline e selecione Excluir para excluir o pipeline.

   3. Se você modificou uma definição de fluxo de trabalho existente, desfaça as modificações para executar o teste de carga e salve o fluxo de trabalho.

2. Remova a conexão de serviço:

   1. Seleciona Definições do projeto>Conexões de serviço, e depois seleciona a ligação de serviço desejada.
   2. Selecione Editar>Eliminar para remover a conexão de serviço.

1. Remover alterações no GitHub Actions:

   1. Em GitHub, navegue até ao seu repositório.
   2. Se você criou uma nova definição de fluxo de trabalho, exclua o arquivo YAML do fluxo de trabalho na .github/workflows pasta.
   3. Se você modificou uma definição de fluxo de trabalho existente, desfaça as modificações para executar o teste de carga e salve o fluxo de trabalho.

2. Remova o principal de serviço:

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

1. Desfaça as alterações no fluxo de trabalho de CI.

2. Remova o principal de serviço:

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