Compartilhar via


Tutorial: Implantar ambientes em CI/CD usando o GitHub e os ambientes de implantação do Azure

Neste tutorial, você aprenderá a integrar os Ambientes de Implantação do Azure ao seu pipeline de CI/CD. Você pode usar qualquer provedor GitOps que dê suporte a CI/CD, como GitHub Actions, Azure Arc, GitLab ou Jenkins.

A integração contínua e entrega contínua (CI/CD) é uma abordagem de desenvolvimento de software que ajuda as equipes a automatizar o processo de criação, teste e implantação de alterações de software. A CI/CD permite que você libere alterações de software com mais frequência e com maior confiança.

Você usa um fluxo de trabalho que apresenta três ramificações: principal, desenvolvimento e teste.

  • A ramificação principal é sempre considerada de produção.
  • Você cria ramificações de recursos por meio da ramificação principal.
  • Você cria solicitações de pull para mesclar ramificações de recursos em principal.

Este fluxo de trabalho é um pequeno exemplo para os fins deste tutorial. Os fluxos de trabalho do mundo real podem ser mais complexos.

Antes de começar este tutorial, você pode se familiarizar com os recursos e conceitos dos ambientes de implantação revisando os Conceitos-chave para os Ambientes de Implantação Azure.

Neste tutorial, você aprenderá a:

  • Criar e configurar um centro de desenvolvimento
  • Criar um cofre de chaves
  • Criar e configurar um repositório GitHub
  • Conectar o catálogo ao centro de desenvolvimento
  • Configurar identidades de implantação
  • Configurar ambientes do GitHub
  • Testar o pipeline de CI/CD

Pré-requisitos

1. Criar e configurar um centro de desenvolvimento

Nesta seção, você cria um centro de desenvolvimento e um projeto de Ambientes de Implantação do Azure com três tipos de ambiente: Dev, Test e Prod.

  • O tipo de ambiente Prod contém o único ambiente de produção.
  • Um novo ambiente é criado em Dev para cada ramificação de recurso.
  • Um novo ambiente é criado em Teste para cada solicitação pull.

1.1 Configurar a CLI do Azure

Para começar, entre no Azure. Execute o comando a seguir e siga os prompts para concluir o processo de autenticação.

az login

Em seguida, instale a extensão do Azure devcenter para a CLI do Azure.

az extension add --name devcenter --upgrade

Agora que a extensão atual está instalada, registre o namespace Microsoft.DevCenter.

az provider register --namespace Microsoft.DevCenter

Dica

Ao longo deste tutorial, você salvará vários valores como variáveis de ambiente para usar posteriormente. Você também pode registrar esses valores em outro lugar para garantir que eles estejam disponíveis quando necessário.

Obtenha a ID do usuário e defina-a como uma variável de ambiente para usar mais tarde:

MY_AZURE_ID=$(az ad signed-in-user show --query id -o tsv)

Recupere a ID da assinatura para sua assinatura atual.

AZURE_SUBSCRIPTION_ID=$(az account show --query id --output tsv)

Recupere a ID do locatário para o seu locatário atual.

AZURE_TENANT_ID=$(az account show --query tenantId --output tsv)

Defina as seguintes variáveis de ambiente:

LOCATION="eastus"
AZURE_RESOURCE_GROUP=<resourceGroupName>
AZURE_DEVCENTER=<devcenterName>
AZURE_PROJECT=<projectName>
AZURE_KEYVAULT=<keyVaultName>

Observação

Você deve usar um nome de cofre de chaves globalmente exclusivo. Caso contrário, você pode obter o seguinte erro: Code: VaultAlreadyExists Message: The vault name 'mykeyvaultname' is already in use. Vault names are globally unique so it is possible that the name is already taken.

1.2. Criar um centro de desenvolvimento

Um centro de desenvolvimento é uma coleção de projetos e ambientes que possuem configurações semelhantes. Os centros de desenvolvimento fornecem acesso a um catálogo de modelos e artefatos que podem ser usados para criar ambientes. Os centros de desenvolvimento também fornecem uma maneira de gerenciar o acesso a ambientes e projetos.

Crie um grupos de recursos.

az group create \
  --name $AZURE_RESOURCE_GROUP \
  --location $LOCATION

Crie um novo centro de desenvolvimento.

az devcenter admin devcenter create \
  --name $AZURE_DEVCENTER \
  --identity-type SystemAssigned \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION

O comando anterior gera saída JSON. Salve os valores de id e identity.principalId como variáveis de ambiente para serem usados posteriormente.

AZURE_DEVCENTER_ID=<id>
AZURE_DEVCENTER_PRINCIPAL_ID=<identity.principalId>

1.3 Atribuir a função de proprietário de identidade do centro de desenvolvimento na assinatura

Um centro de desenvolvimento precisa de permissões para atribuir funções em assinaturas associadas a tipos de ambiente.

Para reduzir complexidades desnecessárias, neste tutorial, você usa uma única assinatura para o centro de desenvolvimento e todos os tipos de ambiente. Na prática, o centro de desenvolvimento e as assinaturas de implantação de destino provavelmente seriam assinaturas separadas com políticas diferentes aplicadas.

az role assignment create \
  --scope /subscriptions/$AZURE_SUBSCRIPTION_ID \
  --role Owner \
  --assignee-object-id $AZURE_DEVCENTER_PRINCIPAL_ID \
  --assignee-principal-type ServicePrincipal

1.4 Criar os tipos de ambiente

No nível do centro de desenvolvimento, os tipos de ambiente definem os ambientes que as equipes de desenvolvimento podem criar, como desenvolvimento, teste, área restrita, pré-produção ou produção.

Crie três novos tipos de ambiente: Dev, Test e Prod.

az devcenter admin environment-type create \
  --name Dev \
  --resource-group $AZURE_RESOURCE_GROUP \
  --dev-center $AZURE_DEVCENTER
az devcenter admin environment-type create \
  --name Test \
  --resource-group $AZURE_RESOURCE_GROUP \
  --dev-center $AZURE_DEVCENTER
az devcenter admin environment-type create \
  --name Prod \
  --resource-group $AZURE_RESOURCE_GROUP \
  --dev-center $AZURE_DEVCENTER

1.5 Criar um projeto

Um projeto é o ponto de acesso para a equipe de desenvolvimento. Cada projeto é associado a um centro de desenvolvimento.

Criar um novo projeto.

az devcenter admin project create \
  --name $AZURE_PROJECT \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --dev-center-id $AZURE_DEVCENTER_ID

O comando anterior gera saída JSON. Salve o valor id como uma variável de ambiente para usar posteriormente.

AZURE_PROJECT_ID=<id>

Atribua a si mesmo a função de administrador do projeto DevCenter no projeto.

az role assignment create \
  --scope "$AZURE_PROJECT_ID" \
  --role "DevCenter Project Admin" \
  --assignee-object-id $MY_AZURE_ID \
  --assignee-principal-type User

1.6 Criar tipos de ambiente de projeto

No nível do projeto, os engenheiros de plataforma especificam quais tipos de ambiente são apropriados para a equipe de desenvolvimento.

Crie um novo tipo de ambiente de projeto para cada um dos tipos de ambiente criados no centro de desenvolvimento.

az devcenter admin project-environment-type create \
  --name Dev \
  --roles "{\"b24988ac-6180-42a0-ab88-20f7382dd24c\":{}}" \
  --deployment-target-id /subscriptions/$AZURE_SUBSCRIPTION_ID \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --project $AZURE_PROJECT \
  --identity-type SystemAssigned \
  --status Enabled
az devcenter admin project-environment-type create \
  --name Test \
  --roles "{\"b24988ac-6180-42a0-ab88-20f7382dd24c\":{}}" \
  --deployment-target-id /subscriptions/$AZURE_SUBSCRIPTION_ID \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --project $AZURE_PROJECT \
  --identity-type SystemAssigned \
  --status Enabled
az devcenter admin project-environment-type create \
  --name Prod \
  --roles "{\"b24988ac-6180-42a0-ab88-20f7382dd24c\":{}}" \
  --deployment-target-id /subscriptions/$AZURE_SUBSCRIPTION_ID \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --project $AZURE_PROJECT \
  --identity-type SystemAssigned \
  --status Enabled

2. Criar um cofre de chaves

Nesta seção, você criará um novo cofre de chaves. Você usará esse cofre de chaves posteriormente no tutorial para salvar um token de acesso pessoal do GitHub.

az keyvault create \
  --name $AZURE_KEYVAULT \
  --resource-group $AZURE_RESOURCE_GROUP \
  --location $LOCATION \
  --enable-rbac-authorization true

Novamente, salve o id da saída JSON do comando anterior como uma variável de ambiente.

AZURE_KEYVAULT_ID=<id>

Dê a si mesmo a função de Administrador do Cofre de Chaves no novo cofre de chaves.

az role assignment create \
  --scope $AZURE_KEYVAULT_ID \
  --role "Key Vault Administrator" \
  --assignee-object-id $MY_AZURE_ID \
  --assignee-principal-type User

Atribua à identidade do centro de desenvolvimento a função de Usuário de Segredos do Cofre de Chaves.

az role assignment create \
  --scope $AZURE_KEYVAULT_ID \
  --role "Key Vault Secrets User" \
  --assignee-object-id $AZURE_DEVCENTER_PRINCIPAL_ID \
  --assignee-principal-type ServicePrincipal

3. Criar e configurar um repositório GitHub

Nesta seção, você criará um repositório GitHub para armazenar um catálogo. Os Ambientes de Implantação do Azure dão suporte a repositórios do GitHub e do Azure DevOps. Neste tutorial, você usará o GitHub.

3.1 Criar um novo repositório GitHub

Nesta etapa, você cria um novo repositório em sua conta do GitHub que tem uma estrutura de diretório, ramificações e arquivos predefinidos. Esses itens são gerados a partir de um repositório de modelo de exemplo.

  1. Use este link para gerar um novo repositório GitHub a partir do modelo de exemplo.

    Screenshot showing the GitHub create repository from template page.

  2. Se você não tiver uma conta paga do GitHub, defina seu repositório como Público.

  3. Selecione Criar repositório com base no modelo.

  4. Na guia Ações, observe que a ação Criar Ambiente falha. Esse comportamento é esperado, você pode prosseguir para a próxima etapa.

3.2 Proteger a ramificação principal do repositório

Você pode proteger ramificações importantes definindo regras de proteção de ramificação. As regras de proteção definem se os colaboradores podem excluir ou efetuar push forçado para a ramificação. Eles também definem requisitos para quaisquer pushes para a ramificação, como passar verificações de status ou um histórico de commit linear.

Observação

As ramificações protegidas estão disponíveis em repositórios públicos com o GitHub Free e GitHub Free para organizações, e em repositórios públicos e privados com o GitHub Pro, GitHub Team, GitHub Enterprise Cloud e GitHub Enterprise Server. Para obter mais informações, consulte Produtos do GitHub.

  1. Se ainda não estiver aberta, navegue até a página principal do repositório.

  2. No nome do seu repositório, selecione Configurações. Se não conseguir ver o separador Definições, selecione o menu pendente ... e, em seguida, selecione Definições.

    Screenshot showing the GitHub repository page with settings highlighted.

  3. Na seção Código e automação da barra lateral, selecione Ramificações.

    Screenshot showing the settings page, with branches highlighted.

  4. Em Regras de proteção de ramificação, selecione Adicionar regra de proteção de ramificação.

    Screenshot showing the branch protection rule page, with Add branch protection rule highlighted.

  5. Em Padrão de nome de ramificação, insira main.

    Screenshot showing the branch name pattern text box, with main highlighted.

  6. Em Proteger as ramificações correspondentes, selecione Exigir uma solicitação de pull antes de fazer a mesclagem.

    Screenshot showing protect matching branches with Require a pull request before merging selected and highlighted.

  7. Opcionalmente, você pode habilitar mais regras de proteção.

  8. Selecione Criar.

3.3 Configurar variáveis de repositório

Observação

Variáveis de configuração para o GitHub Actions estão em versão beta e sujeitas a alterações.

  1. Na seção Segurança da barra lateral, selecione Segredos e variáveis e, em seguida, selecione Ações.

    Screenshot showing the Security section of the sidebar with Actions highlighted.

  2. Selecione a guia Variáveis.

  3. Para cada item na tabela:

    1. Selecione Nova variável de repositório.
    2. No campo Nome, insira o nome da variável.
    3. No campo Valor, insira o valor descrito na tabela.
    4. Selecione Adicionar variável.
    Nome da variável Valor da variável
    AZURE_DEVCENTER O nome do seu centro de desenvolvimento
    AZURE_PROJECT O nome do seu projeto
    AZURE_CATALOG Definir como "Ambientes"
    AZURE_CATALOG_ITEM Definir como "FunctionApp"
    AZURE_SUBSCRIPTION_ID ID da assinatura do Azure
    AZURE_TENANT_ID Sua ID de locatário do Azure

    Screenshot showing the variables page with the variables table.

3.4 Criar um token de acesso pessoal do GitHub

Em seguida, crie um token de acesso pessoal refinado para permitir que o centro de desenvolvimento dos Ambientes de Implantação Azure se conecte ao repositório e consuma o catálogo de ambientes.

Observação

O token de acesso pessoal refinado está atualmente em versão beta e está sujeito a alterações. Para deixar comentários, confira a discussão de comentários.

  1. No canto superior direito de qualquer página no GitHub.com, selecione sua foto de perfil e, em seguida, selecione Configurações.

  2. Na barra lateral esquerda, clique em Configurações do desenvolvedor.

  3. Na barra lateral esquerda, em Tokens de acesso pessoal, selecione Tokens refinados e, em seguida, selecione Gerar novo token.

    Screenshot showing the GitHub personal access token options, with Fine-grained tokens and Generate new token highlighted.

  4. Na página Novo token de acesso pessoal refinado, em Nome do token, insira um nome para o token.

  5. Em Validade, selecione uma validade para o token.

  6. Selecione o usuário do GitHub em Proprietário do recurso.

  7. Em Acesso ao repositório, selecione Selecionar somente repositórios e, na lista suspensa Repositórios selecionados, pesquise e selecione o repositório que você criou.

    Screenshot showing GitHub repository access options, with Only select repositories highlighted.

  8. Em Permissões, selecione Permissões de repositório e altere Conteúdos para Somente leitura.

    Screenshot showing GitHub repository permissions with Contents highlighted.

  9. Selecione Gerar token.

  10. Copie e salve seu token de acesso pessoal agora. Você não pode vê-lo novamente.

3.5 Salve seu token de acesso pessoal no cofre de chaves

Em seguida, salve o token de acesso pessoal como um segredo do cofre de chaves chamado pat.

az keyvault secret set \
    --name pat \
    --vault-name $AZURE_KEYVAULT \
    --value <personalAccessToken>

4. Conectar o catálogo ao centro de desenvolvimento

Nos Ambientes de Implantação Azure, um catálogo é um repositório que contém um conjunto de definições do ambiente. Os itens de catálogo consistem em um modelo de infraestrutura como código (IaC) e um arquivo de ambiente que atua como um manifesto. O modelo define o ambiente, e o arquivo de ambiente fornece metadados sobre o modelo. As equipes de desenvolvimento usam as definições de ambiente do catálogo para criar ambientes.

O modelo usado para criar seu repositório GitHub contém um catálogo na pasta Ambientes.

Adicione o catálogo ao centro de desenvolvimento

No comando a seguir, substitua < Organization/Repository > pela sua organização do GitHub e nome do repositório.

az devcenter admin catalog create \
    --name Environments \
    --resource-group $AZURE_RESOURCE_GROUP \
    --dev-center $AZURE_DEVCENTER \
    --git-hub path="/Environments" branch="main" secret-identifier="https://$AZURE_KEYVAULT.vault.azure.net/secrets/pat" uri="https://github.com/< Organization/Repository >.git"

5. Configurar identidades de implantação

O OpenID Connect com GitHub Actions é um método de autenticação que usa tokens de curta duração para oferecer segurança reforçada. É a maneira recomendada de autenticar o GitHub Actions no Azure.

Você também pode autenticar uma entidade de serviço diretamente usando um segredo, mas isso está fora do escopo deste tutorial.

5.1 Gerar identidades de implantação

  1. Registre aplicativos e entidades de serviço do Microsoft Entra para cada um dos três tipos de ambiente.

    Crie o aplicativo Microsoft Entra para Dev.

    az ad app create --display-name "$AZURE_PROJECT-Dev"
    

    Esse comando gera JSON com um id que você usa ao criar credenciais federadas com a API do Graph e um appId (também chamado de ID do cliente).

    Defina as seguintes variáveis de ambiente:

    DEV_AZURE_CLIENT_ID=<appId>
    DEV_APPLICATION_ID=<id>
    

    Repita para Teste.

    az ad app create --display-name "$AZURE_PROJECT-Test"
    
    TEST_AZURE_CLIENT_ID=<appId>
    TEST_APPLICATION_ID=<id>
    

    E para Prod.

    az ad app create --display-name "$AZURE_PROJECT-Prod"
    
    PROD_AZURE_CLIENT_ID=<appId>
    PROD_APPLICATION_ID=<id>
    
  2. Crie uma entidade de serviço para cada aplicativo.

    Execute o seguinte comando para criar uma entidade de serviço para Desenvolvimento.

     az ad sp create --id $DEV_AZURE_CLIENT_ID
    

    Esse comando gera uma saída JSON com um id diferente e será usado na próxima etapa.

    Defina as seguintes variáveis de ambiente:

    DEV_SERVICE_PRINCIPAL_ID=<id>
    

    Repita para Teste.

     az ad sp create --id $TEST_AZURE_CLIENT_ID
    
    TEST_SERVICE_PRINCIPAL_ID=<id>
    

    E para Prod.

     az ad sp create --id $PROD_AZURE_CLIENT_ID
    
    PROD_SERVICE_PRINCIPAL_ID=<id>
    
  3. Execute os comandos a seguir para criar credenciais de identidade federada para cada aplicativo do Active Directory.

    Em cada um dos três comandos a seguir, substitua < Organization/Repository > pela sua organização do GitHub e nome do repositório.

    Crie a credencial de identidade federada para Dev.

    az rest --method POST \
        --uri "https://graph.microsoft.com/beta/applications/$DEV_APPLICATION_ID/federatedIdentityCredentials" \
        --body '{"name":"ADEDev","issuer":"https://token.actions.githubusercontent.com","subject":"repo:< Organization/Repository >:environment:Dev","description":"Dev","audiences":["api://AzureADTokenExchange"]}'
    

    Para teste.

    az rest --method POST \
        --uri "https://graph.microsoft.com/beta/applications/$TEST_APPLICATION_ID/federatedIdentityCredentials" \
        --body '{"name":"ADETest","issuer":"https://token.actions.githubusercontent.com","subject":"repo:< Organization/Repository >:environment:Test","description":"Test","audiences":["api://AzureADTokenExchange"]}'
    

    E para Prod.

    az rest --method POST \
        --uri "https://graph.microsoft.com/beta/applications/$PROD_APPLICATION_ID/federatedIdentityCredentials" \
        --body '{"name":"ADEProd","issuer":"https://token.actions.githubusercontent.com","subject":"repo:< Organization/Repository >:environment:Prod","description":"Prod","audiences":["api://AzureADTokenExchange"]}'
    

5.2 Atribuir funções a identidades de implantação

  1. Atribua a cada identidade de implantação a função Leitor no projeto.

    az role assignment create \
        --scope "$AZURE_PROJECT_ID" \
        --role Reader \
        --assignee-object-id $DEV_SERVICE_PRINCIPAL_ID \
        --assignee-principal-type ServicePrincipal
    
    az role assignment create \
        --scope "$AZURE_PROJECT_ID" \
        --role Reader \
        --assignee-object-id $TEST_SERVICE_PRINCIPAL_ID \
        --assignee-principal-type ServicePrincipal
    
    az role assignment create \
        --scope "$AZURE_PROJECT_ID" \
        --role Reader \
        --assignee-object-id $PROD_SERVICE_PRINCIPAL_ID \
        --assignee-principal-type ServicePrincipal
    
  2. Atribua a cada identidade de implantação a função Usuário de Ambientes de Implantação ao seu tipo de ambiente correspondente.

    az role assignment create \
        --scope "$AZURE_PROJECT_ID/environmentTypes/Dev" \
        --role "Deployment Environments User" \
        --assignee-object-id $DEV_SERVICE_PRINCIPAL_ID \
        --assignee-principal-type ServicePrincipal
    
    az role assignment create \
        --scope "$AZURE_PROJECT_ID/environmentTypes/Test" \
        --role "Deployment Environments User" \
        --assignee-object-id $TEST_SERVICE_PRINCIPAL_ID \
        --assignee-principal-type ServicePrincipal
    
    az role assignment create \
        --scope "$AZURE_PROJECT_ID/environmentTypes/Prod" \
        --role "Deployment Environments User" \
        --assignee-object-id $PROD_SERVICE_PRINCIPAL_ID \
        --assignee-principal-type ServicePrincipal
    

6. Configurar ambientes do GitHub

Com os ambientes do GitHub, você pode configurar ambientes com regras de proteção e segredos. Um trabalho de fluxo de trabalho que faz referência a um ambiente deve seguir quaisquer regras de proteção para o ambiente antes de executar ou acessar os segredos do ambiente.

Crie ambientes de Desenvolvimento, Teste e Prod mapeados para os tipos de ambiente no projeto Ambientes de Implantação do Azure.

Observação

Ambientes, segredos de ambiente e regras de proteção de ambiente estão disponíveis em repositórios públicos para todos os produtos. Para acessar ambientes, segredos de ambiente e ramificações de implantação em repositórios privados ou internos, você deve usar o GitHub Pro, o GitHub Team ou o GitHub Enterprise. Para acessar outras regras de proteção de ambiente em repositórios privados ou internos, você deve usar o GitHub Enterprise. Para obter mais informações, consulte Produtos do GitHub.

6.1 Criar o ambiente de desenvolvimento

  1. No GitHub, acesse a página principal do repositório.

  2. No nome do seu repositório, selecione Configurações. Se não conseguir ver o separador Definições, selecione o menu pendente ... e, em seguida, selecione Definições.

  3. Selecione Ambientes na barra lateral esquerda.

  4. Selecione Novo ambiente e insira Desenvolvimento para o nome do ambiente e, em seguida, selecione Configurar ambiente.

    Screenshot showing the Environments Add pane, with the environment name Dev, and Configure Environment highlighted.

  5. Em Segredos do ambiente, selecione Adicionar Segredo e insira AZURE_CLIENT_ID para o Nome.

    Screenshot showing the Environment Configure Dev pane, with Add secret highlighted.

  6. Em Valor, insira a ID do cliente () para o aplicativo *Dev**Microsoft Entra criado anteriormente (appIdsalvo como a variável de $DEV_AZURE_CLIENT_ID ambiente).

    Screenshot of the Add secret box with the name AZURE CLIENT ID, the value set to an ID number, and add secret highlighted.

  7. Selecione Adicionar segredo.

6.2 Criar o ambiente de teste

Retorne à página principal de ambientes selecionando Ambientes na barra lateral esquerda.

  1. Selecione Novo ambiente e insira Teste para o nome do ambiente e, em seguida, selecione Configurar ambiente.

  2. Em Segredos do ambiente, selecione Adicionar Segredo e insira AZURE_CLIENT_ID para o Nome.

  3. Em Valor, insira a ID do cliente (appId) para o aplicativo Teste do Microsoft Entra criado anteriormente (salvo como a variável de ambiente $TEST_AZURE_CLIENT_ID).

  4. Selecione Adicionar segredo.

6.3 Criar o ambiente de produção

Mais uma vez, retorne à página principal de ambientes selecionando Ambientes na barra lateral esquerda

  1. Selecione Novo ambiente e insira Produção para o nome do ambiente e, em seguida, selecione Configurar ambiente.

  2. Em Segredos do ambiente, selecione Adicionar Segredo e insira AZURE_CLIENT_ID para o Nome.

  3. Em Valor, insira a ID do cliente (appId) para o aplicativo de Produção do Microsoft Entra criado anteriormente (salvo como a variável de ambiente $PROD_AZURE_CLIENT_ID).

  4. Selecione Adicionar segredo.

Em seguida, defina-se como um revisor necessário para esse ambiente. Ao tentar implantar na Produção, o GitHub Actions aguarda uma aprovação antes de iniciar. Enquanto um trabalho está aguardando aprovação, ele tem um status de Espera. Se um trabalho não é aprovado em até 30 dias, ele falha automaticamente.

Para obter mais informações sobre ambientes e aprovações necessárias, consulte Usando ambientes para implantação.

  1. Selecione Revisores necessários.

  2. Pesquise e selecione o usuário do GitHub. Você pode inserir até seis pessoas ou equipes. Apenas um dos revisores precisam aprovar o trabalho para que prossiga.

  3. Selecione Salvar regras de proteção.

Finalmente, configure main como a ramificação de implantação:

  1. Na Lista suspensa de ramificações de implantação, escolha Ramificações selecionadas.

  2. Selecione Adicionar regra de ramificação de implantação e insira main para o padrão Nome da ramificação.

  3. Selecione Adicionar regra.

7. Testar o pipeline de CI/CD

Nesta seção, você fará algumas alterações no repositório e testará o pipeline de CI/CD.

7.1 Clonar o repositório

  1. Em seu terminal, faça implantação contínua em uma pasta em que você gostaria de clonar seu repositório localmente.

  2. Clonar o repositório Substitua < Organization/Repository > no comando a seguir pelo nome da organização e do repositório do GitHub.

    git clone https://github.com/< Organization/Repository >.git
    
  3. Navegue para o diretório clonado.

    cd <repository>
    
  4. Em seguida, crie uma ramificação e publique-a remotamente.

    git checkout -b feature1
    
    git push -u origin feature1
    

    Um novo ambiente é criado no Azure específico para essa ramificação.

  5. No GitHub, navegue até a página principal do repositório recém-criado.

  6. No nome do seu repositório, selecione Ações.

    Você deverá ver um novo fluxo de trabalho Criar Ambiente em execução.

7.2 Fazer uma alteração no código

  1. Abra o repositório clonado localmente no VS Code.

  2. No ADE. Pasta tutorial, faça uma alteração em um arquivo.

  3. Salve sua alteração.

7.3 Efetuar push das alterações para atualizar o ambiente

  1. Prepare suas alterações e envie por push para a ramificação feature1.

    git add .
    git commit -m '<commit message>'
    git push
    
  2. Na página Ações do repositório, você verá um novo fluxo de trabalho do Ambiente de Atualização em execução.

7.4 Criar uma solicitação de pull

  1. Crie uma solicitação pull do main <- feature1GitHub.

  2. Na página Ações do repositório, você vê que um novo fluxo de trabalho foi iniciado para criar um ambiente específico para a solicitação pull usando o tipo de ambiente Test.

7.5 Mesclar a solicitação pull

  1. No GitHub, navegue até a solicitação de pull que você criou.

  2. Mesclar a solicitação de pull.

    Suas alterações são publicadas no ambiente de produção e os ambientes de solicitação de ramificação e pull são excluídos.

Limpar os recursos

Se você não pretende usar nenhum dos recursos criados, exclua-os para não gerar custos. Se você implantou o aplicativo de exemplo em um grupo de recursos diferente, talvez queira repetir as etapas a seguir.

Para excluir recursos usando o portal do Azure:

  1. Clique no botão de menu no canto superior esquerdo e selecione Grupos de recursos.

  2. Selecione o grupo de recursos que você criou por meio da lista.

  3. Selecione Excluir grupo de recursos.

  4. Insira o nome do grupo de recursos. Em seguida, selecione Excluir.

Para excluir recursos usando a CLI do Azure, insira o seguinte comando:

az group delete --name <my-dev-center-rg>

Lembre-se de que excluir o grupo de recursos exclui todos os recursos dentro dele.