Exercício - Provisionar recursos do Azure

Concluído

Neste exercício, você configurará um fluxo de trabalho de automação para provisionar seus recursos do Terraform.

Acesse o aplicativo de exemplo

Neste exercício, você criará um repositório GitHub a partir de um modelo que contém todo o código para provisionamento do Terraform.

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

   https://github.com/MicrosoftDocs/mslearn-java-petclinic-simplified
   

2. Acima da lista de ficheiros, selecione Utilizar este modelo e, em seguida, selecione Criar um novo repositório.

   

3. Na caixa Nome do repositório, insira um nome exclusivo para o repositório. Certifique-se de seguir a convenção de nomenclatura para repositórios do GitHub.

4. Verifique se a opção Privado está selecionada e selecione Criar repositório.

   

Fluxo de Trabalho

Dentro do diretório do projeto para o repositório que você criou, você verá um diretório chamado terraform e, dentro dele, um arquivo chamado main.tf.

Vejamos algumas seções que você pode usar para definir a configuração do módulo:

• Provedor: Um arquivo de configuração Terraform começa com a especificação do provedor. Ao usar o Azure, você especifica o provedor do Azure (azurerm) no bloco do provedor.
• Terraform: A versão Terraform com a qual você está trabalhando.
• Dados: Obtém dados de serviços existentes.
• Locais: gera novas variáveis usando funções e expressões.
• Recurso: descreve recursos e dependências.
• Módulo: Reusabilidade e abstração de complexidade.

Para provisionar nosso aplicativo e banco de dados, só precisaremos incluir as seções Provedor e Recurso .

Em seguida, abra o arquivo de main.tf e revise a estrutura de tópicos e os comentários:

provider "azurerm" {
  version = "=2.20.0"
  features {}
}

# Creates a resource group
resource "azurerm_resource_group" "main" {
  name     = var.resource_group
  location = var.location

  tags = {
    "Terraform" = "true"
  }
}

resource "random_password" "password" {
  length = 32
  special = true
  override_special = "_%@"
}

# Creates a MySQL server
resource "azurerm_mysql_server" "main" {
  name                              = "${azurerm_resource_group.main.name}-mysql-server"
  location                          = azurerm_resource_group.main.location
  resource_group_name               = azurerm_resource_group.main.name

  administrator_login               = "petclinic"
  administrator_login_password      = random_password.password.result

  sku_name   = "B_Gen5_1"
  storage_mb = 5120
  version    = "5.7"
  auto_grow_enabled                 = true
  backup_retention_days             = 7
  geo_redundant_backup_enabled      = false
  infrastructure_encryption_enabled = false
  public_network_access_enabled     = true
  ssl_enforcement_enabled           = true
  ssl_minimal_tls_version_enforced  = "TLS1_2"
}

# The database that your application will use
resource "azurerm_mysql_database" "main" {
  name                = "${azurerm_resource_group.main.name}_mysql_db"
  resource_group_name = azurerm_resource_group.main.name
  server_name         = azurerm_mysql_server.main.name
  charset             = "utf8"
  collation           = "utf8_unicode_ci"
}

# Enables the 'Allow access to Azure services' check box
resource "azurerm_mysql_firewall_rule" "main" {
  name                = "${azurerm_resource_group.main.name}-mysql-firewall"
  resource_group_name = azurerm_resource_group.main.name
  server_name         = azurerm_mysql_server.main.name
  start_ip_address    = "0.0.0.0"
  end_ip_address      = "0.0.0.0"
}

# Creates the plan that the service uses
resource "azurerm_app_service_plan" "main" {
  name                = "${var.application_name}-plan"
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name
  kind                = "Linux"
  reserved            = true

  sku {
    tier = "PremiumV2"
    size = "P1v2"
  }
}

# Creates the service definition
resource "azurerm_app_service" "main" {
  name                = var.application_name
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name
  app_service_plan_id = azurerm_app_service_plan.main.id
  https_only          = true

  site_config {
    always_on        = true
    linux_fx_version = "JAVA|8-jre8"
  }

  # Contains application-specific environment variables
  app_settings = {
    "WEBSITES_ENABLE_APP_SERVICE_STORAGE" = "false"

    "SPRING_PROFILES_ACTIVE"     = "mysql"
    "SPRING_DATASOURCE_URL"      = "jdbc:mysql://${azurerm_mysql_server.main.fqdn}:3306/${azurerm_mysql_database.main.name}?useUnicode=true&characterEncoding=utf8&useSSL=true&useLegacyDatetimeCode=false&serverTimezone=UTC"
    "SPRING_DATASOURCE_USERNAME" = "${azurerm_mysql_server.main.administrator_login}@${azurerm_mysql_server.main.name}"
    "SPRING_DATASOURCE_PASSWORD" = azurerm_mysql_server.main.administrator_login_password
  }
}

Configure seu fluxo de trabalho de Ações do GitHub com o Terraform

Vamos fornecer ao seu fluxo de trabalho do GitHub acesso à sua conta do Azure.

Na CLI do Azure, crie uma entidade de serviço executando o seguinte comando:

Importante

Substitua <yourServicePrincipalName> pelo nome da entidade de serviço que você deseja usar.

az ad sp create-for-rbac --name "<yourServicePrincipalName>" --role contributor --scopes /subscriptions/<subscriptionId> --sdk-auth

O comando anterior retorna o seguinte JSON. Copie-o para uso na próxima etapa:

{
  "clientId": "XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXXX",
  "clientSecret": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
  "subscriptionId": "XXXXXXXXX-XXXXX-XXXX-XXXX-XXXXXXXXXXXXX",
  "tenantId": "XXXXXXXX-XXXXX-XXXX-XXXX-XXXXXXXXXXX",
  ...
}

Segredos do GitHub

Seu repositório GitHub tem um recurso chamado Segredos, onde você pode armazenar informações confidenciais usadas pelo Terraform para autenticar no Azure.

Depois de criar os IDs necessários e o segredo na etapa anterior, a próxima etapa nesta unidade é adicioná-los ao armazenamento de segredos em seu projeto GitHub.

Para este exercício, você precisa armazenar os seguintes segredos:

• AZURE_CLIENT_ID
• AZURE_CLIENT_SECRET
• AZURE_SUBSCRIPTION_ID
• AZURE_TENANT_ID

Para armazenar os segredos, vá para o repositório bifurcado do GitHub, selecione Configurações e, em seguida, selecione Segredos e variáveis e, em seguida, selecione Ações no painel esquerdo.

Crie quatro segredos usando os valores retornados da criação da Entidade de Serviço.

Certifique-se de armazenar os segredos sem as aspas (" "), como mostrado na captura de tela a seguir:

Ficheiro de fluxo de trabalho

Dentro do diretório do seu projeto há um diretório chamado .github/workflows e, dentro dele, um arquivo chamado main.yml.

O arquivo main.yml é um fluxo de trabalho do GitHub. Ele usa o segredo que você configurou para implantar seu aplicativo em sua assinatura do Azure.

No arquivo de fluxo de trabalho main.yml, você encontrará o seguinte conteúdo:

name: TERRAFORM

on:
  push:
    branches: [ main ]
    paths:
    - 'terraform/**'
  pull_request:
    branches: [ main ]
    paths:
    - 'terraform/**'

  workflow_dispatch:
jobs:
  terraform:
    runs-on: ubuntu-latest

    env:
      ARM_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
      ARM_CLIENT_SECRET: ${{secrets.AZURE_CLIENT_SECRET}}
      ARM_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
      ARM_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}

    defaults:
      run:
        working-directory: ./terraform
    steps:
      - uses: actions/checkout@v2

      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v1

      - name: Terraform Init
        run: terraform init

      - name: Terraform Plan
        run: terraform plan

      - name: Terraform Apply
        run: terraform apply -auto-approve

Este fluxo de trabalho executa as seguintes ações:

• Ele verifica se a configuração está formatada corretamente.
• Ele gera um plano para cada solicitação pull.
• Ele aciona a configuração quando você atualiza arquivos no diretório terraform .

Nota

Você também pode acionar o fluxo de trabalho Ações do GitHub indo para Ações, selecionando o fluxo de trabalho Terraform e selecionando Executar novamente trabalhos existentes.

Acionar o fluxo de trabalho

Em seguida, em seu repositório, acione sua ação do GitHub ao:

1. No editor de texto GitHub integrado ou em um editor de sua escolha, edite terraform/variables.tf da seguinte maneira:

   a. Altere "CHANGE_ME_RESOURCE_GROUP" para o nome do grupo de recursos pretendido.
   b. Altere "CHANGE_ME_APP_NAME" para o nome do aplicativo pretendido. Certifique-se de que o nome do aplicativo é exclusivo.

   variable "resource_group" {
     description = "The resource group"
     default = "CHANGE_ME_RESOURCE_GROUP"
   }
   
   variable "application_name" {
     description = "The Spring Boot application name"
     default     = "CHANGE_ME_APP_NAME"
   }
   
   variable "location" {
     description = "The Azure location where all resources in this example should be created"
     default     = "westeurope"
   }
   

2. Confirme suas alterações.

Verificar a compilação de Ações do GitHub

1. No repositório, selecione Ações e, em seguida, selecione o fluxo de trabalho TERRAFORM no painel esquerdo.

2. Na lista de etapas, verifique se Terraform Init, Terraform Plan e Terraform Validate foram acionados.

   

3. Na lista de etapas, expanda Terraform Apply e verifique se:

• O Terraform criou os recursos e exibe a URL da instância do Azure.

• Sua instância do aplicativo do Azure está disponível publicamente.

  

Próximos passos

No próximo exercício, você usará as Ações do GitHub para implantar um aplicativo Spring Boot de exemplo.

Configurar o nome do aplicativo e o grupo de recursos do Azure

No repositório do GitHub, edite os nomes dos recursos do Azure executando a seguinte ação:

1. No editor de texto GitHub integrado ou em um editor de sua escolha, edite terraform/variables.tf da seguinte maneira:

   a. Altere "<CHANGE_ME_RESOURCE_GROUP>" para o nome do grupo de recursos pretendido.
   b. Altere "<CHANGE_ME_APP_NAME>" para o nome do aplicativo pretendido. Certifique-se de que o nome do aplicativo é exclusivo.

   variable "resource_group" {
     description = "The resource group"
     default = "<CHANGE_ME_RESOURCE_GROUP>"
   }
   
   variable "application_name" {
     description = "The Spring Boot application name"
     default     = "CHANGE_ME_APP_NAME"
   }
   
   variable "location" {
     description = "The Azure location where all resources in this example should be created"
     default     = "westeurope"
   }
   

2. Consolidar as alterações

Criar um Pipeline do Azure para provisionar seus recursos do Terraform

Em nosso projeto Azure DevOps, criaremos dois pipelines separados para provisionamento e compilação e implantação. O pipeline de provisionamento cria os recursos do Azure que serão liberados por meio do pipeline de compilação e implantação em um ponto posterior.

Vamos criar o primeiro pipeline de provisionamento:

1. Escolha a sua organização e, em seguida, selecione Novo projeto.

2. Especifique os seguintes parâmetros.

   Parâmetro	Description
   Nome do Projeto	Necessário
   Description	Opcional
   Visibility	Escolha Privado
   Avançado
   Controlo de versões	Escolha o GIT
   Processo de Item de Trabalho	Escolha Básico

3. Selecione Criar projeto para criar o projeto e abra uma página de boas-vindas.

Configurar sua Conexão de Serviço de Pipeline do Azure

Vamos dar ao seu Azure Pipeline acesso à sua conta do Azure.

1. No Azure DevOps, abra a página Conexões de serviço na página de configurações do projeto

2. Escolha Criar conexão de serviço, selecione Gerenciador de Recursos do Azure e, em seguida, selecione Avançar.

3. Selecione Entidade de serviço (automática) e, em seguida, selecione Seguinte.

4. Especifique os seguintes parâmetros.

   Parâmetro	Description
   Nível de âmbito	Selecionar Subscrição do Azure
   Subscrição	Selecione sua assinatura existente do Azure
   Grupo de Recursos	Deixar em branco para permitir que os usuários acessem todos os recursos definidos na assinatura
   Nome da Ligação	Obrigatório. O nome que você usará para se referir a essa conexão de serviço nas propriedades da tarefa. Esse nome não é o nome da sua assinatura do Azure.

5. Selecione Guardar para criar a ligação.

Criar o pipeline de provisionamento

Importante

Os pré-requisitos deste módulo exigiam que você instalasse a extensão Terraform Azure Pipelines. Se você não o tiver instalado, seu pipeline não será executado.

Depois de configurar seu projeto e conexão com o Azure, você precisará criar um Pipeline do Azure para provisionar seus recursos de terraform.

No Azure DevOps, vá para o seu Projeto, selecione Pipelines no menu esquerdo e, em seguida, selecione Criar Pipeline.

1. Na guia "Conectar", selecione "GitHub" (arquivo YAML).
2. Se for solicitado a autorizar o acesso ao GitHub, insira suas Credenciais do GitHub e aprove o acesso para o Azure Pipelines com os privilégios solicitados.
3. Na guia "Selecionar", selecione o repositório GitHub que contém seu modelo.
4. Selecione Configurar pipeline na guia Inventário .
5. Na guia "Configurar", selecione para usar um "Arquivo YAML do Azure Pipelines existente".
6. No caminho, selecione "/azuredevops/provision.yml"
7. Selecione Continuar para ir para a guia Revisão e revisar seu pipeline.

Na tela "Review your pipeline YAML", vamos inspecionar o arquivo Yaml que usaremos para criar nosso pipeline.

name: Provision Resources

trigger: none

pool:
  vmImage: 'ubuntu-latest'

steps:

# Initialize the Terraform environment and bind to your Service Connection
- task: TerraformTaskV1@0
  inputs:
    provider: 'azurerm'
    command: 'init'
    workingDirectory: $(Build.Repository.LocalPath)/terraform
    backendServiceArm: $(serviceConnection)
    backendAzureRmResourceGroupName: $(serviceConnection)
    backendAzureRmStorageAccountName: $(serviceConnection)
    backendAzureRmContainerName: 'tfstate'
    backendAzureRmKey: 'tf/terraform.tfstate'

# Apply the Terraform config and deploy to Azure
- task: TerraformTaskV1@0
  inputs:
    provider: 'azurerm'
    command: 'apply'
    workingDirectory: $(Build.Repository.LocalPath)/terraform
    backendAzureRmContainerName: 'tfstate'
    backendAzureRmKey: 'tf/terraform.tfstate'
    environmentServiceNameAzureRM: $(serviceConnection)

Vejamos alguns dos campos que usamos na configuração:

• serviceConnection: Sua conexão de serviço do Azure PipeLine sua configuração anterior
• comando: Seu comando de fluxo de trabalho Terraform: iniciar ou aplicar
• backendAzure: campos obrigatórios que são necessários em um ambiente de equipe para armazenar o estado compartilhado.\

Antes de salvar e executar o pipeline, precisamos adicionar a variável que será vinculada à sua conexão de serviço:

1. Selecione Variáveis (canto superior direito) e adicione uma variável chamada "serviceConnection" com o valor como o nome da sua Conexão de serviço.
2. Selecione OK (canto inferior direito) para salvar a variável.

Finalmente, selecione "executar" (canto superior direito) para salvar e executar o pipeline

Veja o pipeline correr

Em Trabalhos, rastreie o processo de compilação através de cada uma das etapas.

À medida que seu pipeline é executado, observe como seu primeiro estágio de inicialização do Terraform e, em seguida, seu segundo estágio de aplicação, passe de azul (em execução) para verde (concluído). Você pode selecionar os estágios para observar seu pipeline em ação.

Gorjeta

Verifique o seu e-mail. Talvez você já tenha recebido uma notificação de compilação com os resultados da sua execução. Você pode usar essas notificações para saber se cada compilação passa ou falha.

Próximos passos

No próximo exercício, você usará o Azure Pipelines para criar e implantar seu aplicativo Spring Boot de exemplo.