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

• Uma organização Azure DevOps e um projeto. Se você não tiver uma organização Azure DevOps, poderá criar uma gratuitamente. Se precisar de ajuda para começar a usar Azure Pipelines, consulte Criar seu primeiro pipeline.

• Uma conta GitHub. Se você não tiver uma conta GitHub, poderá criar uma gratuitamente.
• Um repositório GitHub para armazenar os arquivos de entrada do teste de carga e criar um fluxo de trabalho do 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 do teste de carga.

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

Em Azure Pipelines, você cria uma conexão service em seu projeto Azure DevOps para acessar recursos em sua assinatura Azure. Quando você cria a conexão de serviço, o Azure DevOps cria um objeto de entidade de serviço do Microsoft Entra.

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

   Substitua o espaço reservado para texto <your-organization> pelo identificador do seu projeto.

2. Selecione Configurações do projeto>Conexões de serviço>+ Nova conexão de serviço.

3. No painel A nova conexão de serviço, selecione o Azure Resource Manager e selecione Next.

4. Selecione o método de autenticação Entidade de serviço (automático) 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 escopo	Assinatura.
   Subscrição	Selecione a assinatura Azure que hospeda o recurso de teste 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 que você criou anteriormente e, em seguida, selecione Gerenciar Entidade de Serviço.

   

   O portal do Azure é aberto em uma guia separada do navegador e mostra os detalhes da entidade de serviço.

7. No portal Azure, copie o valor do Display name.

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

Conceder acesso ao Azure Load Testing

Azure Load Testing usa Azure RBAC para conceder permissões para executar atividades específicas no recurso de teste de carga. Para executar um teste de carga a partir do pipeline de CI/CD, conceda a função Colaborador de Teste de Carga à entidade de serviço.

1. No Azure portal, vá para o 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 de trabalho.

   

4. Na guia Membros, selecione Selecionar membros e, em seguida, use o nome de exibição que você copiou anteriormente para pesquisar a entidade de serviço.

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

6. Na guia Examinar + atribuir, selecione Examinar + atribuir para adicionar a atribuição de função.

Agora você pode usar a conexão de serviço em sua definição de fluxo de trabalho Azure Pipelines para acessar seu recurso de teste de carga Azure.

Para acessar o recurso de Teste de Carga do Azure a partir do fluxo de trabalho do GitHub Actions, primeiro crie uma entidade de serviço do Microsoft Entra. Essa entidade de serviço representa o fluxo de trabalho do GitHub Actions no Microsoft Entra ID.

Em seguida, você concede permissões à entidade de serviço para criar e executar um teste de carga com seu recurso de Azure Load Testing.

Criar uma entidade de serviço

Crie uma entidade de serviço na assinatura Azure e atribua a função Colaborador de Teste de Carga para que seu fluxo de trabalho GitHub Actions tenha acesso ao recurso de teste de carga Azure para executar testes de carga.

1. Crie uma entidade de serviço e atribua a função Load 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
   

   A saída é um objeto JSON que representa a entidade de serviço. Use essas informações para autenticar com 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

   Você pode receber um aviso de preterido --sdk-auth ao executar esse comando. Como alternativa, você pode usar a autenticação baseada em OIDC (OpenID Connect) para autenticar GitHub com Azure. Saiba como usar a ação de entrada no Azure com o OpenID Connect.

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

   Na próxima etapa, você armazenará as informações do principal do serviço como um segredo do GitHub Actions.

Armazenar credenciais do Azure no segredo do GitHub Actions

Crie um segredo do GitHub Actions para armazenar com segurança as informações da entidade de serviço. Use esse segredo em sua definição de fluxo de trabalho para se conectar para autenticar com Azure e acessar seu recurso de teste de carga Azure.

Para criar um segredo do GitHub Actions:

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

2. Selecione Configurações>Segredos e variáveis>Ações.

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

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

Agora você pode acessar sua assinatura Azure e carregar o recurso de teste do fluxo de trabalho GitHub Actions usando as credenciais armazenadas.

Se você estiver usando outra ferramenta de CI/CD, use o Azure CLI para interagir com seus recursos de Azure. Execute as etapas a seguir para autorizar o acesso da ferramenta de CI ao recurso de teste de carga:

1. Crie uma entidade de serviço do Microsoft Entra para se conectar à sua assinatura do Azure e acessar o recurso de teste de carga do Azure.
2. Conceda permissões à entidade de serviço para criar e executar um teste de carga atribuindo a função Colaborador de Teste de Carga.
3. Armazene as credenciais de Azure com segurança na ferramenta de CI.

Execute as etapas a seguir para configurar a autorização de serviço da ferramenta de CI:

1. Crie uma entidade de serviço e atribua a função 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 valores clientId, clientSecret e tenantId e armazene-os com segurança como segredos na ferramenta de CI.

   Você usa esses valores para entrar em sua assinatura Azure com o comando Azure CLI az login.

Instalar a extensão Azure Load Testing para Azure DevOps

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

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

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

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

Atualizar o fluxo de trabalho Azure Pipelines

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

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

2. Selecione Pipelines na navegação à esquerda, selecione o pipeline e, em seguida, selecione Editar para editar a definição do fluxo de trabalho.

   Como alternativa, selecione Create Pipeline para criar um novo pipeline no Azure Pipelines.

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

   Especifique o arquivo de configuração do teste de carga que você exportou anteriormente na propriedade loadTestConfigFile.

   Substitua os espaços reservados de texto <load-testing-resource> e <load-testing-resource-group> pelo nome do 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, você pode passar parâmetros ou segredos para o teste de carga usando a propriedade env ou secrets. Defina waitForCompletion: false se você deseja continuar sem aguardar a conclusão da execução do teste de carga.

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
   

Atualizar o fluxo de trabalho GitHub Actions

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

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

2. Edite seu fluxo de trabalho GitHub Actions ou criar um novo fluxo de trabalho em seu repositório de GitHub.

3. Use a ação actions/checkout para verificar o 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 ação azure/load-testing para executar o teste de carga.

   Especifique o arquivo de configuração do teste de carga que você exportou anteriormente na propriedade loadTestConfigFile.

   Substitua os espaços reservados de texto <load-testing-resource> e <load-testing-resource-group> pelo nome do 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, você pode passar parâmetros ou segredos para o teste de carga usando a propriedade env ou secrets. Defina waitForCompletion: false se você deseja continuar sem aguardar a conclusão da execução do teste de carga.

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

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

Atualize o fluxo de trabalho de CI para executar um teste de carga para o recurso de teste de carga Azure usando o Azure CLI. Use as especificações da ferramenta de CI para adicionar os seguintes comandos ao fluxo de trabalho de CI:

1. Entre na assinatura do Azure usando a entidade de serviço.

   Use os valores clientId, clientSecret e tenantId armazenados 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 do 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 arquivo YAML de configuração do teste de carga que você adicionou 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. Remova as alterações do Azure Pipelines:

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

      Substitua o espaço reservado para 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 Excluir.

         

      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. Remover a conexão de serviço:

   1. Selecione Configurações do Projeto>Conexões de Serviço e depois selecione sua conexão de serviço.
   2. Selecione Editar>Excluir para remover a conexão de serviço.

1. Remova alterações do GitHub Actions

   1. Em GitHub, navegue até seu repositório.
   2. Se você criou uma nova definição de fluxo de trabalho, exclua o arquivo YAML do fluxo de trabalho na pasta .github/workflows.
   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. Remover a entidade 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. Remover a entidade de serviço:

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