Exercício – Configurar seu ambiente

  • 5 minutos

Importante

É preciso ter uma assinatura do Azure para fazer esse exercício, e isso pode gerar encargos. Caso ainda não tenha uma assinatura do Azure, crie uma conta gratuita antes de começar.

Antes de começar a trabalhar no fluxo de trabalho do site da empresa de brinquedos, você precisa configurar o ambiente. Nesta unidade, você verificará se os ambientes do Azure e do GitHub estão configurados para concluir o restante do módulo.

Para atingir esses objetivos, você vai:

  • Configure um repositório GitHub para este módulo.
  • Clonar o repositório do projeto no computador.
  • Crie duas identidades de carga de trabalho no Microsoft Entra ID.
  • Crie dois grupos de recursos no Azure.
  • Crie segredos e ambientes no GitHub.

Obter o repositório GitHub

Aqui, você se certifica de que o repositório GitHub está configurado para concluir o restante deste módulo. Você o configura criando um repositório com base em outro de modelo. O repositório de modelo contém os arquivos necessários para prosseguir neste módulo.

Os módulos neste roteiro de aprendizagem fazem parte de uma progressão. Para fins de aprendizado, cada módulo tem um repositório de modelo GitHub associado.

Dica

Mesmo que você tenha concluído o módulo anterior no caminho de aprendizagem, siga estas instruções para criar um repositório e dê a ele um novo nome.

Começar com o repositório de modelo

Execute um modelo que configura seu repositório GitHub.

Executar o modelo

No site do GitHub, siga estas etapas para criar um repositório com base no modelo:

  1. Selecione Usar este modelo>Criar um repositório.

    Captura de tela da interface do GitHub mostrando o repositório de modelo, com o botão 'Usar este modelo' realçado.

  2. Selecione o nome de usuário do GitHub na lista suspensa Proprietário.

  3. Insira um nome para o novo projeto, como toy-website-end-to-end.

  4. Selecione a opção Público.

    Ao criar seus repositórios, você pode querer torná-los privados. Neste módulo, você trabalhará com alguns recursos do GitHub que funcionam somente com repositórios públicos e contas do GitHub Enterprise.

  5. Selecione Criar repositório.

    Captura de tela da interface do GitHub mostrando a página de criação do repositório.

Importante

O exercício final deste módulo contém etapas de limpeza importantes. Siga as etapas de limpeza mesmo que não conclua este módulo.

Clonar o repositório

Agora você tem uma cópia do repositório de modelo na sua conta. Você clonará este repositório localmente para começar a trabalhar com ele.

  1. Selecione Código e o ícone de cópia.

    Captura de tela da interface do GitHub mostrando o novo repositório, com o botão de cópia de URL do repositório realçado.

  2. Abra o Visual Studio Code.

  3. Abra uma janela do terminal do Visual Studio Code selecionando Terminal>Novo Terminal. Geralmente, a janela é aberta na parte inferior da tela.

  4. Navegue no terminal até o diretório em que você deseja clonar o repositório do GitHub no computador local. Por exemplo, para clonar o repositório para a pasta toy-website-environments, execute o seguinte comando:

    cd toy-website-end-to-end

  5. Digite git clone e cole a URL copiada anteriormente. O comando deve ter esta aparência:

    git clone https://github.com/mygithubuser/toy-website-end-to-end.git

  6. Reabra o Visual Studio Code na pasta do repositório executando o seguinte comando no terminal do Visual Studio Code:

    code -r toy-website-end-to-end

Entrar no Azure

Para trabalhar com grupos de recursos no Azure, entre na sua conta do Azure usando o terminal do Visual Studio Code. Verifique se você instalou as ferramentas da CLI do Azure.

  1. No menu Terminal, selecione Novo Terminal. A janela do terminal geralmente é aberta na metade inferior da tela.

    O shell padrão normalmente é pwsh, conforme mostrado no lado direito da janela do terminal.

    Captura de tela da janela do terminal do Visual Studio Code, em que pwsh é mostrado como a opção de shell.

  2. Selecione a lista suspensa Perfil de Inicialização e, em seguida, selecione Azure Cloud Shell (Bash).

    Captura de tela da janela do terminal do Visual Studio Code. A lista suspensa do shell do terminal e o item de menu do Azure Cloud Shell (Bash) são mostrados.

    Um novo shell é aberto.

Entrar no Azure usando a CLI do Azure

  1. No terminal no Visual Studio Code, execute o seguinte comando para entrar no Azure:

    az login

  2. No navegador que é aberto, entre em sua conta do Azure.

Para trabalhar com grupos de recursos no Azure, entre na sua conta do Azure usando o terminal do Visual Studio Code. Verifique se você instalou o Azure PowerShell.

  1. No menu Terminal, selecione Novo Terminal. A janela do terminal geralmente é aberta na metade inferior da tela.

    O shell padrão normalmente é pwsh, conforme mostrado no lado direito da janela do terminal.

    Captura de tela da janela do terminal do Visual Studio Code, em que pwsh é mostrado como a opção de shell.

  2. Selecione a lista suspensa Perfil de Inicialização e, em seguida, selecione Azure Cloud Shell (PowerShell).

    Captura de tela da janela do terminal do Visual Studio Code. A lista suspensa do shell do terminal e o item de menu do Azure Cloud Shell (PowerShell) são mostrados.

    Um novo shell é aberto.

Entrar no Azure usando o Azure PowerShell

  1. No terminal no Visual Studio Code, execute o seguinte comando para entrar no Azure:

    Connect-AzAccount

  2. No navegador que é aberto, entre em sua conta do Azure.

Criar duas identidades de carga de trabalho

Em seguida, crie duas identidades de carga de trabalho no Microsoft Entra ID: uma para seu ambiente de testes e outra para seu ambiente de produção.

  1. Execute o código a seguir para definir as variáveis do nome de usuário e do nome do repositório do GitHub. Substitua mygithubuser pelo nome de usuário do GitHub, que você anotou anteriormente neste exercício. Além disso, especifique o nome correto do repositório do GitHub.

    githubOrganizationName='mygithubuser'
githubRepositoryName='toy-website-end-to-end'

  2. Crie uma identidade de carga de trabalho para implantações em seu ambiente de teste. A identidade da carga de trabalho precisa de duas credenciais federadas: uma é usada quando o fluxo de trabalho executa o trabalho de validação, pois esse trabalho não está associado a um ambiente do GitHub. A segunda é usada quando o fluxo de trabalho executa o trabalho de implantação, que é executado no ambiente de teste do GitHub.

    testApplicationRegistrationDetails=$(az ad app create --display-name 'toy-website-end-to-end-test')
testApplicationRegistrationObjectId=$(echo $testApplicationRegistrationDetails | jq -r '.id')
testApplicationRegistrationAppId=$(echo $testApplicationRegistrationDetails | jq -r '.appId')

az ad app federated-credential create \
   --id $testApplicationRegistrationObjectId \
   --parameters "{\"name\":\"toy-website-end-to-end-test\",\"issuer\":\"https://token.actions.githubusercontent.com\",\"subject\":\"repo:${githubOrganizationName}/${githubRepositoryName}:environment:Test\",\"audiences\":[\"api://AzureADTokenExchange\"]}"

az ad app federated-credential create \
   --id $testApplicationRegistrationObjectId \
   --parameters "{\"name\":\"toy-website-end-to-end-test-branch\",\"issuer\":\"https://token.actions.githubusercontent.com\",\"subject\":\"repo:${githubOrganizationName}/${githubRepositoryName}:ref:refs/heads/main\",\"audiences\":[\"api://AzureADTokenExchange\"]}"

  3. Execute o código a seguir, que cria uma identidade de carga de trabalho semelhante e credenciais federadas para o ambiente de produção:

    productionApplicationRegistrationDetails=$(az ad app create --display-name 'toy-website-end-to-end-production')
productionApplicationRegistrationObjectId=$(echo $productionApplicationRegistrationDetails | jq -r '.id')
productionApplicationRegistrationAppId=$(echo $productionApplicationRegistrationDetails | jq -r '.appId')

az ad app federated-credential create \
   --id $productionApplicationRegistrationObjectId \
   --parameters "{\"name\":\"toy-website-end-to-end-production\",\"issuer\":\"https://token.actions.githubusercontent.com\",\"subject\":\"repo:${githubOrganizationName}/${githubRepositoryName}:environment:Production\",\"audiences\":[\"api://AzureADTokenExchange\"]}"

az ad app federated-credential create \
   --id $productionApplicationRegistrationObjectId \
   --parameters "{\"name\":\"toy-website-end-to-end-production-branch\",\"issuer\":\"https://token.actions.githubusercontent.com\",\"subject\":\"repo:${githubOrganizationName}/${githubRepositoryName}:ref:refs/heads/main\",\"audiences\":[\"api://AzureADTokenExchange\"]}"

  1. Execute o código a seguir para definir as variáveis do nome de usuário e do nome do repositório do GitHub. Substitua mygithubuser pelo nome de usuário do GitHub, que você anotou anteriormente neste exercício. Além disso, especifique o nome correto do repositório GitHub.

    $githubOrganizationName = 'mygithubuser'
$githubRepositoryName = 'toy-website-end-to-end'

  2. Execute o seguinte código, que cria uma identidade de carga de trabalho para o ambiente de teste e a associa ao repositório do GitHub:

    $testApplicationRegistration = New-AzADApplication -DisplayName 'toy-website-end-to-end-test'
New-AzADAppFederatedCredential `
   -Name 'toy-website-end-to-end-test' `
   -ApplicationObjectId $testApplicationRegistration.Id `
   -Issuer 'https://token.actions.githubusercontent.com' `
   -Audience 'api://AzureADTokenExchange' `
   -Subject "repo:$($githubOrganizationName)/$($githubRepositoryName):environment:Test"
New-AzADAppFederatedCredential `
   -Name 'toy-website-end-to-end-test-branch' `
   -ApplicationObjectId $testApplicationRegistration.Id `
   -Issuer 'https://token.actions.githubusercontent.com' `
   -Audience 'api://AzureADTokenExchange' `
   -Subject "repo:$($githubOrganizationName)/$($githubRepositoryName):ref:refs/heads/main"

  3. Execute o seguinte código, que segue um processo semelhante para o ambiente de produção:

    $productionApplicationRegistration = New-AzADApplication -DisplayName 'toy-website-end-to-end-production'
New-AzADAppFederatedCredential `
   -Name 'toy-website-end-to-end-production' `
   -ApplicationObjectId $productionApplicationRegistration.Id `
   -Issuer 'https://token.actions.githubusercontent.com' `
   -Audience 'api://AzureADTokenExchange' `
   -Subject "repo:$($githubOrganizationName)/$($githubRepositoryName):environment:Production"
New-AzADAppFederatedCredential `
   -Name 'toy-website-end-to-end-production-branch' `
   -ApplicationObjectId $productionApplicationRegistration.Id `
   -Issuer 'https://token.actions.githubusercontent.com' `
   -Audience 'api://AzureADTokenExchange' `
   -Subject "repo:$($githubOrganizationName)/$($githubRepositoryName):ref:refs/heads/main"

Crie dois grupos de recursos no Azure e conceda acesso à identidade da carga de trabalho

Em seguida, crie um grupo de recursos para cada ambiente. Esse processo também concede à respetiva identidade de carga de trabalho a função Colaborador no grupo de recursos, o que permite que o seu fluxo de trabalho seja implementado no grupo de recursos.

  1. Para criar o grupo de recursos do ambiente de teste e garantir que a identidade da carga de trabalho acesse-o, execute os seguintes comandos da CLI do Azure no terminal do Visual Studio Code:

    testResourceGroupResourceId=$(az group create --name ToyWebsiteTest --location westus3 --query id --output tsv)

az ad sp create --id $testApplicationRegistrationObjectId
az role assignment create \
   --assignee $testApplicationRegistrationAppId \
   --role Contributor \
   --scope $testResourceGroupResourceId

  2. Executar um processo similar para criar o grupo de recursos do ambiente de produção:

    productionResourceGroupResourceId=$(az group create --name ToyWebsiteProduction --location westus3 --query id --output tsv)

az ad sp create --id $productionApplicationRegistrationObjectId
az role assignment create \
   --assignee $productionApplicationRegistrationAppId \
   --role Contributor \
   --scope $productionResourceGroupResourceId

  1. Para criar o grupo de recursos do ambiente de teste e garantir que a identidade da carga de trabalho acesse-o, execute os seguintes comandos do Azure PowerShell no terminal do Visual Studio Code:

    $testResourceGroup = New-AzResourceGroup -Name ToyWebsiteTest -Location westus3

New-AzADServicePrincipal -AppId $($testApplicationRegistration.AppId)
New-AzRoleAssignment `
   -ApplicationId $($testApplicationRegistration.AppId) `
   -RoleDefinitionName Contributor `
   -Scope $($testResourceGroup.ResourceId)

  2. Executar um processo similar para criar o grupo de recursos do ambiente de produção:

    $productionResourceGroup = New-AzResourceGroup -Name ToyWebsiteProduction -Location westus3

New-AzADServicePrincipal -AppId $($productionApplicationRegistration.AppId)
New-AzRoleAssignment `
   -ApplicationId $($productionApplicationRegistration.AppId) `
   -RoleDefinitionName Contributor `
   -Scope $($productionResourceGroup.ResourceId)

Preparar segredos do GitHub

Execute o seguinte código para emitir os valores que você precisa criar como segredos do GitHub:

echo "AZURE_CLIENT_ID_TEST: $testApplicationRegistrationAppId"
echo "AZURE_CLIENT_ID_PRODUCTION: $productionApplicationRegistrationAppId"
echo "AZURE_TENANT_ID: $(az account show --query tenantId --output tsv)"
echo "AZURE_SUBSCRIPTION_ID: $(az account show --query id --output tsv)"

$azureContext = Get-AzContext
Write-Host "AZURE_CLIENT_ID_TEST: $($testApplicationRegistration.AppId)"
Write-Host "AZURE_CLIENT_ID_PRODUCTION: $($productionApplicationRegistration.AppId)"
Write-Host "AZURE_TENANT_ID: $($azureContext.Tenant.Id)"
Write-Host "AZURE_SUBSCRIPTION_ID: $($azureContext.Subscription.Id)"

Criar segredos do GitHub

Você criou duas identidades de carga de trabalho e grupos de recursos nos quais elas podem ser implantadas. Agora, crie segredos no GitHub Actions.

  1. No navegador, navegue até o repositório do GitHub.

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

  3. Selecione Novo segredo de repositório.

    Captura de tela da interface do GitHub mostrando a página

  4. Nomeie o segredo como AZURE_CLIENT_ID_TEST.

  5. No campo Valor, cole a GUID da primeira linha da saída do terminal. Não inclua AZURE_CLIENT_ID_TEST, dois-pontos ou espaços no valor.

  6. Selecione Adicionar segredo.

    Captura de tela da interface do GitHub mostrando a página

  7. Repita o processo para criar os segredos para AZURE_CLIENT_ID_PRODUCTION, AZURE_TENANT_ID e AZURE_SUBSCRIPTION_ID, copiando os valores dos campos correspondentes na saída do terminal.

  8. Verifique se a lista de segredos agora mostra os quatro segredos.

    Captura de tela da interface GitHub mostrando a lista de segredos, incluindo os segredos de teste e de produção.

Criar ambientes no GitHub

  1. No navegador, acesse Configurações>Ambientes.

  2. Selecione Novo ambiente.

    Captura de tela da interface do GitHub que mostra a página Ambientes e o botão para criar um ambiente.

  3. Insira Teste como o nome do ambiente.

    Captura de tela da página de GitHub para um novo ambiente chamado Teste, com o botão Configurar ambiente.

  4. Selecione Configurar ambiente.

  5. Selecione Ambientes para retornar à lista de ambientes.

    Captura de tela da página de GitHub para um novo ambiente chamado Teste, com o link Ambiente.

  6. Repita o processo para criar outro ambiente chamado Produção.

Observação

Nos módulos anteriores deste roteiro de aprendizagem, você adicionou uma regra de proteção ao seu ambiente de produção. Neste módulo, para simplificar, você está ignorando a regra de proteção. No entanto, você pode adicionar a regra de proteção por conta própria, se desejar.