Exercício – Implantar modelos do ARM como parte dos esforços de CI/CD com o GitHub Actions

10 minutos

Aqui, você implanta um modelo do ARM (Azure Resource Manager) com base no fluxo de trabalho do GitHub Actions.

Importante

Você realiza este exercício fora do ambiente do Microsoft Learn. Este exercício exige que você tenha uma assinatura própria do Azure e poderá gerar encargos. Isso é necessário porque você precisará criar uma entidade de serviço, o que não tem suporte da assinatura da área restrita. Caso ainda não tenha uma assinatura do Azure, crie uma conta gratuita antes de começar.

Criar a conta e o repositório do GitHub

Primeiro, se você não tiver uma conta do GitHub, crie uma agora na página de criação de conta do GitHub. (É gratuito.)

Captura de tela que mostra a página de criação de conta do GitHub.

Quando tiver uma conta, entre e crie um repositório em que você pode manter seus modelos como parte do modelo de IaC (infraestrutura como código). Para criar o repositório (comumente conhecido como repositório no setor), siga estas etapas:

No canto superior direito de qualquer página do site do GitHub, use o menu suspenso + e selecione Novo repositório. Ou selecione o botão verde Criar repositório se ele estiver lá.
Insira um nome breve e fácil de memorizar para o repositório. Por exemplo, use Implantar-modelo-ARM. Opcionalmente, adicione uma descrição do repositório. Por exemplo, use Implantando meu primeiro modelo do ARM com o GitHub Actions.
Escolha a configuração de visibilidade do repositório. Os repositórios públicos podem ser acessados por todos na Internet. Repositórios privados só podem ser acessados por você e pelas pessoas com quem você compartilha o acesso explicitamente. (Ou funciona com esse exercício.)
Em Inicializar este repositório com:, selecione Adicionar um arquivo LEIAME.
Selecione Criar repositório.

Você criou o repositório e o inicializou com um arquivo LEIAME. É hora de confirmar um modelo e um arquivo de parâmetros de modelo para o repositório.

Observação

Arquivos LEIAME são um ótimo lugar para descrever o projeto com mais detalhes ou para adicionar alguma documentação, por exemplo, sobre como instalar ou usar o projeto. O conteúdo do arquivo LEIAME aparece automaticamente na página inicial do repositório.

Confirmar um arquivo de modelo do ARM no repositório

No GitHub, vá até a página principal do repositório.
Acima da lista de arquivos, na lista suspensa Adicionar arquivo, selecione Criar arquivo.

No campo de nome do arquivo, insira o nome e a extensão do modelo. No exercício, use o nome azuredeploy.json. Copie e cole o seguinte modelo no novo arquivo do GitHub.

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "VnetName": {
            "type": "string",
            "defaultValue": "VNet-001",
            "metadata": {
                "description": "Virtual Network Name"
            }
        },
        "CostCenterIO": {
            "type": "string",
            "defaultValue": "12345",
            "metadata": {
                "description": "Cost Center IO number for cross billing"
            }
        },
        "OwnerName": {
            "type": "string",
            "defaultValue": "John Smith",
            "metadata": {
                "description": "Name of the stakeholder responsible for this resource"
            }
        }
    },
    "variables": {},
    "resources": [
        {
            "apiVersion": "2018-10-01",
            "type": "Microsoft.Network/virtualNetworks",
            "name": "[parameters('VnetName')]",
            "location": "[resourceGroup().location]",
            "tags": {
                "CostCenter": "[parameters('CostCenterIO')]",
                "Owner": "[parameters('OwnerName')]"
            },
            "properties": {
                "addressSpace": {
                    "addressPrefixes": [
                        "10.0.0.0/16"
                    ]
                },
                "enableVmProtection": false,
                "enableDdosProtection": false,
                "subnets": [
                    {
                        "name": "subnet001",
                        "properties": {
                            "addressPrefix": "10.0.0.0/24"
                        }
                    },
                    {
                        "name": "subnet002",
                        "properties": {
                            "addressPrefix": "10.0.1.0/24"
                        }
                    }
                ]
            }
        }
    ]
}

Adicione uma descrição na seção Confirmar novo arquivo e selecione Confirmar novo arquivo para salvar no repositório.

Configurar a autenticação entre o GitHub Actions e a assinatura do Azure

Para implantar qualquer recurso no Azure usando o GitHub Actions, você precisará criar uma entidade de serviço do Azure e conceder a ela permissões para criar recursos definidos nos modelos. Você executa essa etapa na seção do Azure Cloud Shell do portal do Azure após entrar em sua assinatura.

Criar a entidade de serviço

Para a entidade de segurança de um fluxo de trabalho do GitHub Actions implantar recursos do Azure, ela precisa ter o colaborador interno correto.

O script a seguir da CLI do Azure mostra como você pode gerar uma entidade de serviço do Azure com permissões de colaborador em um grupo de recursos do Azure. Esse grupo de recursos é onde o fluxo de trabalho implanta os recursos definidos no modelo do ARM.

projectName="GitHubActionExercise"
location="eastus"
resourceGroupName="${projectName}-rg"
appName="http://${projectName}"

# Create the resource group
az group create --name $resourceGroupName --location $location

# Store the resource group ID in a variable
scope=$(az group list --query "[?contains(name, '$resourceGroupName')].id" -o tsv)

# Create the service principal with contributor rights to the resource group we just created
az ad sp create-for-rbac --name $appName --role Contributor --scopes $scope --sdk-auth

No portal, quando estiver conectado à sua assinatura, selecione o ícone do Cloud Shell para abrir o shell na parte inferior da página.

Animação que mostra a abertura do Cloud Shell.

No shell, use o código anterior para criar a entidade de serviço. Você terá os resultados a seguir. Copie a parte do JSON dos resultados (o conteúdo na caixa vermelha na captura de tela a seguir), pois você precisa dela ao configurar o segredo no GitHub.

Captura de tela que mostra os resultados da criação de uma entidade de serviço no Azure.

Copie a saída JSON e armazene-a como um segredo do GitHub em seu repositório GitHub executando as seguintes etapas no GitHub: No repositório GitHub, selecione a guia Configurações. No menu à esquerda, selecione a lista suspensa Segredos e selecione Codespaces.

Insira os seguintes valores e selecione Adicionar segredo:

Nome: insira AZURE_CREDENTIALS.
Segredo: cole a saída JSON que você copiou anteriormente.

Captura de tela que mostra a adição de informações de segredo da nova entidade de serviço a um segredo do GitHub.

Você precisa dessas informações para especificar a autenticação no fluxo de trabalho.

Criar um fluxo de trabalho

O arquivo de fluxo de trabalho deve ser armazenado na pasta .github/workflows, na raiz do repositório. A extensão do arquivo do fluxo de trabalho pode ser .yml ou .yaml.

Você pode criar um arquivo de fluxo de trabalho e enviar por push/carregar o arquivo para o repositório. Ou pode usar o seguinte procedimento para criá-lo na interface do GitHub:

No repositório do GitHub, selecione Ações no menu superior e selecione Configurar um fluxo de trabalho por conta própria.
Renomeie o arquivo de fluxo de trabalho se você preferir um nome diferente de main.yml. Por exemplo, use deployARMTemplate.yml.
Substitua o conteúdo do arquivo .yml pelo código a seguir.

Observação

O Marketplace do GitHub tem algumas ações personalizadas que você pode usar para implantar modelos do ARM. Este módulo usa o provedor do marketplace chamado Implantar modelo do ARM (Azure Resource Manager).
```
name: Deploy ARM Template

on:
  push:
    branches:
      - main
env:
  AZURE_SUBSCRIPTION_ID: << Subscription Id >>   # set this to your Azure Subscription Id
  AZURE_RESOURCE_GROUP: GitHubActionExercise-rg   # set this to your target resource group

jobs:
  deploy-virtual-network-template:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout source code
        uses: actions/checkout@main

      - name: Login to Azure
        uses: azure/login@v1
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

      - name: Deploy ARM Template
        uses: azure/arm-deploy@v1
        with:
          scope: resourcegroup
          subscriptionId: ${{ env.AZURE_SUBSCRIPTION_ID }}
          resourceGroupName: ${{ env.AZURE_RESOURCE_GROUP }}
          template: ./azuredeploy.json
```
O arquivo de fluxo de trabalho tem três seções.
- name: O nome do fluxo de trabalho.
- on: O nome do evento do GitHub que dispara o fluxo de trabalho. O fluxo de trabalho é acionado quando um evento push está na ramificação principal e modifica pelo menos um arquivo nessa ramificação.
- jobs: uma execução de fluxo de trabalho é composta por um ou mais trabalhos. Somente um trabalho é chamado de deploy-virtual-network-template. Esse trabalho tem três etapas.
  1. Fazer check-out do código-fonte.
  2. Entre no Azure.
  3. Implantar o modelo do ARM.
Importante

Verifique se o nome do segredo na expressão creds: ${{ secrets.AZURE_CREDENTIALS }} corresponde ao nome do segredo que você salvou nas configurações do repositório. Verifique também se o nome do modelo do ARM na etapa template: $GITHUB_WORKSPACE/azuredeploy.json de Deploy ARM Template corresponde ao que você salvou no repositório anteriormente.

Observação

O nome do grupo de recursos deve ser GitHubActionExercise-rg se você usou o código da CLI do Azure anterior ao configurar as credenciais de implantação. O nome do grupo de recursos gerado é o nome do projeto com rg acrescentado.
Selecione Confirmar início. Adicione um comentário e uma descrição, se necessário.
Verifique se Confirmar diretamente na ramificação principal está selecionado e marque a opção Confirmar novo arquivo (ou Confirmar alterações).

Depois que o arquivo de fluxo de trabalho for criado e confirmado para a ramificação principal do repositório, o fluxo de trabalho será iniciado automaticamente porque o gatilho em seu fluxo de trabalho é uma confirmação/envio para a ramificação principal.
```
on:
  push:
    branches:
      - main
```
Acesse seu repositório e verifique o status do fluxo de trabalho.

Verificar sua implantação

Quando o fluxo de trabalho for concluído, vá para o portal do Azure a fim de verificar o status da implantação.

No painel esquerdo, selecione Grupos de recursos>GitHubActionExercise-rg. No painel Implantações, verifique se a implantação foi bem-sucedida.

Captura de tela que mostra o status da implantação.