Compartilhar via


Início Rápido: criar um cluster de VM do Linux no Azure usando o Terraform

Aplica-se a: ✔️ VMs do Linux

Este artigo mostra como criar um cluster de VM do Linux (contendo duas instâncias de VM do Linux) no Azure usando o Terraform.

Neste artigo, você aprenderá como:

Pré-requisitos

Implementar o código do Terraform

  1. Crie um diretório em que você vai testar o código de exemplo do Terraform, depois transforme-o no diretório atual.

  2. Crie um arquivo chamado providers.tf e insira o seguinte código:

    terraform {
      required_version = ">=1.0"
      required_providers {
        azapi = {
          source  = "azure/azapi"
          version = "~>1.5"
        }
        azurerm = {
          source  = "hashicorp/azurerm"
          version = "~>3.0"
        }
        random = {
          source  = "hashicorp/random"
          version = "~>3.0"
        }
      }
    }
    provider "azurerm" {
      features {}
    }
    
  3. Crie um arquivo chamado ssh.tf e insira o seguinte código:

    resource "random_pet" "ssh_key_name" {
      prefix    = "ssh"
      separator = ""
    }
    
    resource "azapi_resource_action" "ssh_public_key_gen" {
      type        = "Microsoft.Compute/sshPublicKeys@2022-11-01"
      resource_id = azapi_resource.ssh_public_key.id
      action      = "generateKeyPair"
      method      = "POST"
    
      response_export_values = ["publicKey", "privateKey"]
    }
    
    resource "azapi_resource" "ssh_public_key" {
      type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
      name      = random_pet.ssh_key_name.id
      location  = azurerm_resource_group.rg.location
      parent_id = azurerm_resource_group.rg.id
    }
    
    output "key_data" {
      value = azapi_resource_action.ssh_public_key_gen.output.publicKey
    }
    
  4. Crie um arquivo chamado main.tf e insira o seguinte código:

    resource "random_pet" "rg_name" {
      prefix = var.resource_group_name_prefix
    }
    
    resource "azurerm_resource_group" "rg" {
      name     = random_pet.rg_name.id
      location = var.resource_group_location
    }
    
    resource "random_pet" "azurerm_virtual_network_name" {
      prefix = "vnet"
    }
    
    resource "azurerm_virtual_network" "test" {
      name                = random_pet.azurerm_virtual_network_name.id
      address_space       = ["10.0.0.0/16"]
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
    }
    
    resource "random_pet" "azurerm_subnet_name" {
      prefix = "sub"
    }
    
    resource "azurerm_subnet" "test" {
      name                 = random_pet.azurerm_subnet_name.id
      resource_group_name  = azurerm_resource_group.rg.name
      virtual_network_name = azurerm_virtual_network.test.name
      address_prefixes     = ["10.0.2.0/24"]
    }
    
    resource "azurerm_public_ip" "test" {
      name                = "publicIPForLB"
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
      allocation_method   = "Static"
    }
    
    resource "azurerm_lb" "test" {
      name                = "loadBalancer"
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
    
      frontend_ip_configuration {
        name                 = "publicIPAddress"
        public_ip_address_id = azurerm_public_ip.test.id
      }
    }
    
    resource "azurerm_lb_backend_address_pool" "test" {
      loadbalancer_id = azurerm_lb.test.id
      name            = "BackEndAddressPool"
    }
    
    resource "azurerm_network_interface" "test" {
      count               = 2
      name                = "acctni${count.index}"
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
    
      ip_configuration {
        name                          = "testConfiguration"
        subnet_id                     = azurerm_subnet.test.id
        private_ip_address_allocation = "Dynamic"
      }
    }
    
    resource "azurerm_availability_set" "avset" {
      name                         = "avset"
      location                     = azurerm_resource_group.rg.location
      resource_group_name          = azurerm_resource_group.rg.name
      platform_fault_domain_count  = 2
      platform_update_domain_count = 2
      managed                      = true
    }
    
    resource "random_pet" "azurerm_linux_virtual_machine_name" {
      prefix = "vm"
    }
    
    resource "azurerm_linux_virtual_machine" "test" {
      count                 = 2
      name                  = "${random_pet.azurerm_linux_virtual_machine_name.id}${count.index}"
      location              = azurerm_resource_group.rg.location
      availability_set_id   = azurerm_availability_set.avset.id
      resource_group_name   = azurerm_resource_group.rg.name
      network_interface_ids = [azurerm_network_interface.test[count.index].id]
      size                  = "Standard_DS1_v2"
    
      # Uncomment this line to delete the OS disk automatically when deleting the VM
      # delete_os_disk_on_termination = true
    
      # Uncomment this line to delete the data disks automatically when deleting the VM
      # delete_data_disks_on_termination = true
    
      source_image_reference {
        publisher = "Canonical"
        offer     = "UbuntuServer"
        sku       = "16.04-LTS"
        version   = "latest"
      }
    
      admin_ssh_key {
        username   = var.username
        public_key = azapi_resource_action.ssh_public_key_gen.output.publicKey
      }
    
      os_disk {
        caching              = "ReadWrite"
        storage_account_type = "Standard_LRS"
        name                 = "myosdisk${count.index}"
      }
    
      computer_name  = "hostname"
      admin_username = var.username
    }
    
    resource "azurerm_managed_disk" "test" {
      count                = 2
      name                 = "datadisk_existing_${count.index}"
      location             = azurerm_resource_group.rg.location
      resource_group_name  = azurerm_resource_group.rg.name
      storage_account_type = "Standard_LRS"
      create_option        = "Empty"
      disk_size_gb         = "1024"
    }
    
    resource "azurerm_virtual_machine_data_disk_attachment" "test" {
      count              = 2
      managed_disk_id    = azurerm_managed_disk.test[count.index].id
      virtual_machine_id = azurerm_linux_virtual_machine.test[count.index].id
      lun                = "10"
      caching            = "ReadWrite"
    }
    
  5. Crie um arquivo chamado variables.tf e insira o seguinte código:

    variable "resource_group_location" {
      type        = string
      description = "Location for all resources."
      default     = "eastus"
    }
    
    variable "resource_group_name_prefix" {
      type        = string
      description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
      default     = "rg"
    }
    
    variable "username" {
      type        = string
      description = "The username for the local account that will be created on the new VM."
      default     = "azureadmin"
    }
    
  6. Crie um arquivo chamado outputs.tf e insira o seguinte código:

    output "resource_group_name" {
      value = azurerm_resource_group.rg.name
    }
    
    output "virtual_network_name" {
      value = azurerm_virtual_network.test.name
    }
    
    output "subnet_name" {
      value = azurerm_subnet.test.name
    }
    
    output "linux_virtual_machine_names" {
      value = [for s in azurerm_linux_virtual_machine.test : s.name[*]]
    }
    

Inicializar Terraform

Execute terraform init para inicializar a implantação do Terraform. Esse comando baixa o provedor do Azure necessário para gerenciar seus recursos do Azure.

terraform init -upgrade

Pontos principais:

  • O parâmetro -upgrade atualiza os plug-ins do provedor necessários para a versão mais recente que esteja em conformidade com as restrições de versão da configuração.

Criar um plano de execução Terraform

Execute o comando terraform plan para criar um plano de execução.

terraform plan -out main.tfplan

Pontos principais:

  • O comando terraform plan cria um plano de execução, mas não o executa. Em vez disso, ele determina quais ações são necessárias para criar a configuração especificada em seus arquivos de configuração. Esse padrão permite que você verifique se o plano de execução corresponde às suas expectativas antes de fazer qualquer alteração nos recursos reais.
  • O parâmetro opcional -out permite que você especifique um arquivo de saída para o plano. Usar o parâmetro -out garante que o plano que você examinou seja exatamente o que é aplicado.

Aplicar um plano de execução do Terraform

Execute terraform apply para aplicar o plano de execução à sua infraestrutura de nuvem.

terraform apply main.tfplan

Pontos principais:

  • O exemplo de comando do terraform apply pressupõe que você executou o terraform plan -out main.tfplan anteriormente.
  • Se você especificou um nome de arquivo diferente para o parâmetro -out, use esse mesmo nome de arquivo na chamada para terraform apply.
  • Se você não usou o parâmetro -out, chame terraform apply sem nenhum parâmetro.

As informações de custo não são apresentadas durante o processo de criação da máquina virtual para o Terraform, como acontece no portal do Microsoft Azure. Se você quiser saber mais sobre como o custo funciona para máquinas virtuais, confira a página Visão geral da otimização de custo.

Verifique os resultados

  1. Obtenha o nome do grupo de recursos do Azure.

    resource_group_name=$(terraform output -raw resource_group_name)
    
  2. Execute az vm list com uma consulta JMESPath para exibir os nomes das máquinas virtuais criadas no grupo de recursos.

    az vm list \
      --resource-group $resource_group_name \
      --query "[].{\"VM Name\":name}" -o table
    

Limpar os recursos

Quando você não precisar mais dos recursos criados por meio o Terraform, execute as seguintes etapas:

  1. Execute terraform plan e especifique o sinalizador destroy.

    terraform plan -destroy -out main.destroy.tfplan
    

    Pontos principais:

    • O comando terraform plan cria um plano de execução, mas não o executa. Em vez disso, ele determina quais ações são necessárias para criar a configuração especificada em seus arquivos de configuração. Esse padrão permite que você verifique se o plano de execução corresponde às suas expectativas antes de fazer qualquer alteração nos recursos reais.
    • O parâmetro opcional -out permite que você especifique um arquivo de saída para o plano. Usar o parâmetro -out garante que o plano que você examinou seja exatamente o que é aplicado.
  2. Execute a aplicação do Terraform para aplicar o plano de execução.

    terraform apply main.destroy.tfplan
    

Solucionar problemas do Terraform no Azure

Solucionar problemas comuns ao usar o Terraform no Azure

Próximas etapas