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 pipeline de CI/CD. Você pode usar qualquer provedor GitOps compatível com CI/CD, como GitHub Actions, Azure Arc, GitLab ou Jenkins.

A CI/CD (integração contínua e entrega contínua) é 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 as alterações de software com mais frequência e com mais confiança.

Você usa um fluxo de trabalho que apresenta três branches: principal, desenvolvimento e teste.

• O branch principal é sempre considerado de produção.
• Você cria ramificações de funcionalidades do ramo principal.
• Você cria pull requests para mesclar ramificações de funcionalidades na main.

O fluxo de trabalho neste tutorial é um exemplo simplificado. Os fluxos de trabalho do mundo real podem ser mais complexos.

Antes de começar este tutorial, você pode se familiarizar com os componentes e conceitos dos Ambientes de Implantação examinando os principais conceitos para ambientes de implantação do Azure.

Neste tutorial, você aprenderá como:

• 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

Product	Requirements
Azul	– Uma assinatura do Azure. – Permissões de proprietário na assinatura do Azure. - CLI do Azure instalada.
Git	- Uma conta do GitHub. - Git instalado.

1. Criar e configurar um centro de desenvolvimento

Nesta seção, você criará um centro de desenvolvimento e um projeto dos Ambientes de Implantação do Azure com três tipos de ambiente: Desenvolvimento, Teste e Prod.

• O tipo de ambiente Prod contém o ambiente de produção único.
• Um novo ambiente é criado em Desenvolvimento para cada ramo de funcionalidade.
• Um novo ambiente é criado no Teste para cada solicitação de pull.

1.1 Configurar a CLI do Azure

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

az login

Em seguida, instale a extensão do centro de desenvolvimento do Azure para a CLI do Azure:

az extension add --name devcenter --upgrade

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

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 querer registrar esses valores em outro lugar para garantir que eles estejam disponíveis quando você precisar deles.

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

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

Recupere a ID da 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 global exclusivo do cofre de chaves. Caso contrário, você poderá receber 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 têm 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 grupo de recursos:

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

Criar um 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 JSON. Salve os valores para id e identity.principalId como variáveis de ambiente a serem usados posteriormente:

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

1.3 Atribuir a função de proprietário da 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 a complexidade desnecessária, 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 e produção.

Crie três novos tipos de ambiente: Desenvolvimento, Teste 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.

Crie um 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 JSON. Salve o id valor como uma variável de ambiente a ser usada posteriormente:

AZURE_PROJECT_ID=<id>

Atribua a si mesmo a função DevCenter Project Admin 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 mais adiante 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 a id 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 Key Vault 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 a identidade do centro de desenvolvimento à função de Usuário de Segredos do Key Vault:

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 novo repositório GitHub para armazenar um catálogo. Os Ambientes de Implantação do Azure dão suporte a repositórios GitHub e Azure DevOps. Neste tutorial, você usará o GitHub.

3.1 Criar um repositório GitHub

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

1. Gere um novo repositório GitHub a partir do modelo de exemplo:

   

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

3. Selecione Criar repositório.

3.2 Proteger o ramo 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 um branch ou forçar o push para o branch. Eles também definem os requisitos de pushes para o branch, como passar verificações de status ou impor um histórico de confirmação linear.

Observação

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

1. Se ainda não estiver aberto, vá para a página principal do repositório.

2. Selecione Configurações no menu na parte superior da janela:

   

3. Na seção Código e automação da barra lateral esquerda, selecione Branches:

   

4. De acordo com as regras de proteção do Branch, selecione Adicionar conjunto de regras de branch:

   

5. Na página Novo conjunto de regras do branch, no Nome do conjunto de regras, insira CI-CD-tutorial-ruleset:

   

6. Em ramificações de destino, selecione Adicionar ramificação de destino e, em seguida, selecione Incluir ramificação padrão ou Incluir todas as ramificações:

   

7. Nas regras do Branch, selecione Exigir uma solicitação de pull antes de mesclar:

   

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

9. Selecione Criar.

3.3 Configurar variáveis de repositório

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

   

2. Selecione a guia Variáveis.

3. Para cada item na tabela a seguir:

   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	Seu nome do centro de desenvolvimento
   AZURE_PROJECT	Nome do projeto
   AZURE_CATALOG	Definir como Ambientes
   AZURE_CATALOG_ITEM	Definir como FunctionApp
   AZURE_SUBSCRIPTION_ID	Sua ID de assinatura do Azure
   AZURE_TENANT_ID	Sua ID de tenant do Azure

   

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 do Azure se conecte ao repositório e consuma o catálogo de ambientes.

Observação

Você pode deixar comentários sobre tokens de acesso pessoal granulares na discussão de feedback.

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

2. Na barra lateral esquerda, selecione Configurações do Desenvolvedor.

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

   

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

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

6. Em Proprietário do recurso, selecione o nome de usuário do GitHub.

7. Em Acesso ao Repositório, selecione Somente selecionar repositórios. Em repositórios selecionados, pesquise e selecione o repositório que você criou:

   

8. Em Permissões, selecione permissões de Repositório e altere o Conteúdo para Somente Leitura:

   

9. Selecione Gerar token.

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

3.5 Salvar 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 do Azure, um catálogo é um repositório que contém um conjunto de definições de ambiente. Os itens de catálogo consistem em um modelo de IaC (infraestrutura como código) 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 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 .

Adicionar o catálogo ao centro de desenvolvimento

No comando a seguir, substitua < Organization/Repository > pela organização do GitHub e pelo 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 o GitHub Actions é um método de autenticação que usa tokens de curta duração para fornecer segurança protegida. É 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 uma appId (também chamada de ID do cliente).

   Defina as seguintes variáveis de ambiente:

   DEV_AZURE_CLIENT_ID=<appId>
   DEV_APPLICATION_ID=<id>
   

   Repita estas etapas para Teste:

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

   TEST_AZURE_CLIENT_ID=<appId>
   TEST_APPLICATION_ID=<id>
   

   Repita as etapas novamente para Prod:

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

   PROD_AZURE_CLIENT_ID=<appId>
   PROD_APPLICATION_ID=<id>
   

2. Crie um principal de serviço para cada aplicativo.

   Execute o seguinte comando para criar uma nova entidade de serviço para Dev:

    az ad sp create --id $DEV_AZURE_CLIENT_ID
   

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

   Defina a seguinte variável de ambiente:

   DEV_SERVICE_PRINCIPAL_ID=<id>
   

   Repita estas etapas para Teste:

    az ad sp create --id $TEST_AZURE_CLIENT_ID
   

   TEST_SERVICE_PRINCIPAL_ID=<id>
   

   Repita as etapas novamente para Prod:

    az ad sp create --id $PROD_AZURE_CLIENT_ID
   

   PROD_SERVICE_PRINCIPAL_ID=<id>
   

3. Execute os comandos a seguir para criar uma nova credencial de identidade federada para cada aplicativo do Microsoft Entra.

   Em cada um dos três comandos a seguir, substitua < Organization/Repository > pela sua organização do GitHub e pelo 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"]}'
   

   Crie a credencial 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"]}'
   

   Crie a credencial 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 implementaçã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 função de usuário dos Ambientes de Implantação ao tipo de ambiente correspondente de cada identidade de implantação:

   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 referencia um ambiente deve seguir todas as regras de proteção para o ambiente antes de executar ou acessar os segredos do ambiente.

Crie ambientes Dev, Test 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 do 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 do ambiente em repositórios privados ou internos, você deve usar o GitHub Enterprise. Para obter mais informações, consulte os planos do GitHub.

6.1 Criar o ambiente de desenvolvimento

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

2. No nome do seu repositório, selecione Configurações. Se você não conseguir ver a guia Configurações , selecione o menu suspenso ... e selecione Configurações.

3. Na barra lateral esquerda, selecione Ambientes.

4. Selecione Novo ambiente e insira Desenvolvimento para o nome do ambiente e selecione Configurar ambiente:

   

5. Em Segredos do Ambiente, selecione Adicionar segredo do ambiente e, em seguida, insira AZURE_CLIENT_ID na caixa Nome .

   

6. Na caixa Valor, insira a ID do cliente (appId) para o aplicativo de Desenvolvimento do Microsoft Entra criado anteriormente (salvo como a variável de ambiente $DEV_AZURE_CLIENT_ID ):

   

7. Selecione Adicionar segredo.

6.2 Criar o ambiente de teste

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

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

2. Em Segredos do Ambiente, selecione Adicionar segredo do ambiente e, em seguida, insira AZURE_CLIENT_ID na caixa Nome .

3. Na caixa Valor, insira o identificador do cliente (appId) para o aplicativo Test Microsoft Entra criado anteriormente (salvo como variável de ambiente $TEST_AZURE_CLIENT_ID).

4. Selecione Adicionar segredo.

6.3 Criar o ambiente Prod

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

1. Selecione Novo ambiente, insira Prod para o nome do ambiente e selecione Configurar ambiente.

2. Em Segredos do Ambiente, selecione Adicionar segredo do ambiente e, em seguida, insira AZURE_CLIENT_ID na caixa Nome .

3. Na caixa Valor insira a ID do cliente (appId) do aplicativo Prod Microsoft Entra que você criou anteriormente (salvo como $PROD_AZURE_CLIENT_ID variável de ambiente).

4. Selecione Adicionar segredo.

Em seguida, defina-se como um revisor necessário para esse ambiente. Quando é feita uma tentativa de implantação no Prod, o GitHub Actions aguarda uma aprovação antes de começar. Enquanto um trabalho aguarda aprovação, ele tem um status de Espera. Se um trabalho não for aprovado dentro de 30 dias, ele falhará 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 nome de 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.

Por fim, configure main como o branch de implantação:

1. Na lista branches e tags de implantação, selecione branches e tags selecionados.

2. Selecione Adicionar branch de implantação ou regra de tag, verifique se o Tipo Ref: Branch está selecionado e, em seguida, insira principal na caixa Padrão de nome.

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. No Git Bash, use cd para alternar para uma pasta em que você deseja clonar seu repositório localmente.

2. Clone o repositório. Certifique-se de substituir < Organization/Repository > no seguinte comando pelo nome da sua organização e do repositório no GitHub.

   git clone https://github.com/< Organization/Repository >.git
   

3. Navegue até o diretório clonado:

   cd <repository>
   

4. Crie um novo branch e publique-o remotamente:

   git checkout -b feature1
   

   git push -u origin feature1
   

   Um novo ambiente, específico para esse branch, é criado no Azure.

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

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

   Você deve ver um novo fluxo de trabalho de criação de ambiente em execução.

7.2 Fazer uma alteração no código

1. Abra o repositório clonado localmente no Visual Studio Code.

2. No ADE.Tutorial folder, 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 o branch 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. Criar uma solicitação main <- feature1de pull do GitHub.

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

7.5 Mesclar a solicitação de pull

1. No GitHub, vá para a solicitação de pull que você criou.

2. Mescle a pull request.

   Suas alterações são publicadas no ambiente de produção, e os ambientes de branch e pull request 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.

Conteúdo relacionado

• Criar e acessar um ambiente usando a CLI do Azure
• Para obter listas de comandos completas, consulte a documentação da CLI do Microsoft Dev Box e dos Ambientes de Implantação do Azure