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 ofereça suporte a CI/CD, como GitHub Actions, Azure Arc, GitLab ou Jenkins.

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

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

• O ramo principal é sempre considerado produção.
• Você cria branches de funcionalidades a partir da branch principal.
• Você cria pull requests para mesclar branches de funcionalidade 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 dos Ambientes de Implantação do 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
• Conecte o catálogo ao seu centro de desenvolvimento
• Configurar identidades de implementação
• Configurar ambientes GitHub
• Teste a pipeline de CI/CD

Pré-requisitos

Produto	Requerimentos
Azure	- Uma assinatura do Azure. - Permissões de proprietário na assinatura do Azure. - CLI do Azure instalada.
Git	- Uma conta no GitHub. - Git instalado.

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 no Dev para cada ramificação de recurso.
• Um novo ambiente é criado em Test para cada solicitação pull.

1.1 Configurar a CLI do Azure

Para começar, entre no Azure. Execute o seguinte comando e siga as instruções 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

Sugestão

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

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

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

Recupere o ID da subscrição da sua subscrição atual:

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

Recupere o ID do 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

O nome do cofre de chaves que você usar deve ser globalmente único. 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 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

Crie 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 produz JSON. Salve os valores para id e identity.principalId como variáveis de ambiente para usar mais tarde:

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 subscrição

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, as assinaturas do centro de desenvolvimento e as destinadas à implantação seriam provavelmente 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, sandbox, pré-produção e 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 está 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 produz JSON. Salve o id valor como uma variável de ambiente para usar mais tarde:

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. Crie um cofre de chaves

Nesta seção, você cria um novo cofre de chaves. Você usa 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 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 Utilizador do Key Vault Secrets:

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ê cria um novo repositório GitHub para armazenar um catálogo. Os Ambientes de Implantação do Azure dão suporte aos repositórios GitHub e Azure DevOps. Neste tutorial, você usa 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órios, ramificações e arquivos predefinidos. 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 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 eliminar uma ramificação ou forçar o push para a ramificação. Eles também definem requisitos para pushes para a ramificação, 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 GitHub Free e 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 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 Ramos:

   

4. Em Regras de proteção de ramificação, selecione Adicionar conjunto de regras de ramificação:

   

5. Na página Novo conjunto de regras de ramificação , em Nome do conjunto de regras, digite CI-CD-tutorial-ruleset:

   

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

   

7. Em Regras de ramificação, selecione Exigir uma solicitação 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 secção Segurança da barra lateral, selecione Segredos e variáveis e, em seguida, selecione Ações:

   

2. Selecione a guia Variáveis .

3. Para cada item da 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 variável
   AZURE_DEVCENTER	O nome do seu centro de desenvolvimento
   AZURE_PROJECT	O nome do seu projeto
   AZURE_CATALOG	Definir para Ambientes
   AZURE_CATALOG_ITEM	Definir como FunctionApp
   AZURE_SUBSCRIPTION_ID	Sua ID de assinatura do Azure
   AZURE_TENANT_ID	Seu ID de locatário do Azure

   

3.4 Criar um token de acesso pessoal do GitHub

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

Observação

Você pode dar feedback sobre os tokens de acesso pessoal detalhados na discussão de feedback.

1. No canto superior direito de qualquer página GitHub.com, selecione a sua foto de perfil e, em seguida, selecione Definiçõ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 , em Nome do token, insira um nome para o token.

5. Em Expiração, selecione uma expiração para o token.

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

7. Em Acesso ao repositório, selecione Selecionar apenas repositórios. Em Repositórios selecionados, procure e selecione o repositório que você criou:

   

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

   

9. Selecione Gerar token.

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

3.5 Guarde o 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. Conecte o catálogo ao seu 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 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 definições de ambiente do catálogo para criar ambientes.

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

Adicionar o catálogo ao seu centro de desenvolvimento

No comando a seguir, substitua < Organization/Repository > pelo nome da organização e do repositório do GitHub:

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 with GitHub Actions é um método de autenticação que usa tokens de curta duração para fornecer segurança reforçada. É a maneira recomendada de autenticar as Ações do GitHub no Azure.

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

5.1 Gerar identidades de implantação

1. Registe aplicações e princípios de serviço do Microsoft Entra para cada um dos três tipos de ambientes.

   Crie o aplicativo Microsoft Entra para Dev:

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

   Este 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 estas etapas para Teste:

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

   TEST_AZURE_CLIENT_ID=<appId>
   TEST_APPLICATION_ID=<id>
   

   Repita os passos novamente 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 um novo principal de serviço para Dev:

    az ad sp create --id $DEV_AZURE_CLIENT_ID
   

   Este comando gera saída JSON com um diferente id 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 os passos 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 Microsoft Entra.

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

   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 o 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 papéis às 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 Usuário de 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 GitHub

Com ambientes GitHub, você pode configurar ambientes com regras de proteção e segredos. Uma tarefa que faz referência a um ambiente deve seguir todas as regras de proteção para o ambiente antes de realizar ou aceder aos segredos desse 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 ambientais e regras de proteção ambiental 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, a Equipe do GitHub 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 Planos do GitHub.

6.1 Criar o ambiente de desenvolvimento

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

2. Sob o nome do 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. Na barra lateral esquerda, selecione Ambientes.

4. Selecione Novo ambiente e digite Dev para o nome do ambiente e, em seguida, selecione Configurar ambiente:

   

5. Em Segredos do ambiente, selecione Adicionar segredo do ambiente e digite AZURE_CLIENT_ID na caixa Nome .

   

6. Na caixa Valor, insira o ID do cliente (appId) para a aplicação Dev Microsoft Entra que criou anteriormente (como variável de ambiente salvo $DEV_AZURE_CLIENT_ID):

   

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, insira Testar o nome do ambiente e selecione Configurar ambiente.

2. Em Segredos do ambiente, selecione Adicionar segredo do ambiente e digite AZURE_CLIENT_ID na caixa Nome .

3. Na caixa Valor, insira a ID de cliente (appId) para a aplicação Test Microsoft Entra que foi criada anteriormente (guardado como variável de $TEST_AZURE_CLIENT_ID ambiente).

4. Selecione Adicionar segredo.

6.3 Criar o ambiente Prod

Mais uma vez, volte para a página principal de ambientes selecionando Ambientes na barra lateral esquerda.

1. Selecione Novo ambiente, digite Prod para o nome do ambiente e, em seguida, selecione Configurar ambiente.

2. Em Segredos do ambiente, selecione Adicionar segredo do ambiente e digite AZURE_CLIENT_ID na caixa Nome .

3. Na caixa Valor, insira o ID do cliente (appId) para a aplicação Microsoft Entra Prod que foi criada anteriormente (guardada como variável de ambiente $PROD_AZURE_CLIENT_ID).

4. Selecione Adicionar segredo.

Em seguida, defina-se como um revisor obrigatório para este ambiente. Quando é feita uma tentativa de implantação no Prod, o GitHub Actions aguarda uma aprovação antes de iniciar. Enquanto um trabalho está aguardando aprovação, ele tem um status de Esperando. 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 obrigatórios.

2. Procure e selecione seu nome de usuário do GitHub. Pode inscrever até seis pessoas ou equipas. Apenas um dos revisores necessários precisa aprovar o trabalho para que ele prossiga.

3. Selecione Salvar regras de proteção.

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

1. Na lista Ramificações e tags de implantação , selecione Ramificações e tags selecionadas.

2. Selecione Adicionar regra de ramificação ou etiqueta de implantação, verifique se Tipo de referência: Ramificação está selecionada e digite main no campo Padrão de nome.

3. Selecione Adicionar regra.

Teste o pipeline de CI/CD

Nesta secção, fazes algumas alterações no repositório e testas a pipeline de CI/CD.

7.1 Clone o repositório

1. No Git Bash, use cd para alternar para uma pasta onde você deseja clonar seu repositório localmente.

2. Clone o repositório. Certifique-se de substituir < 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 até o diretório clonado:

   cd <repository>
   

4. Crie uma nova ramificação e publique-a remotamente:

   git checkout -b feature1
   

   git push -u origin feature1
   

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

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

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

   Deverá ver um novo fluxo de trabalho de criação de ambiente em execução.

7.2 Fazer uma alteração ao código

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

2. No ADE.Tutorial, faça uma alteração em um ficheiro.

3. Guarde as suas alterações.

7.3 Envie suas alterações para atualizar o ambiente

1. Prepare suas alterações e faça o push para o ramo 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 um pull request

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

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

7.5 Mesclar a solicitação pull

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

2. Mescle a solicitação pull.

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

Limpar recursos

Se você não planeja usar nenhum dos recursos que criou, exclua-os para não incorrer em mais cobranças. Se você implantou o aplicativo de exemplo em um grupo de recursos diferente, convém repetir as etapas a seguir.

Para excluir recursos usando o portal do Azure:

1. Selecione o botão de menu no canto superior esquerdo e, em seguida, selecione Grupos de recursos.

2. Na lista, selecione o grupo de recursos que você criou.

3. Selecione Eliminar grupo de recursos.

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

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

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

Lembre-se, 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 listagens de comandos completas, consulte a Microsoft Dev Box e a documentação da CLI do Azure Deployment Environments