Guida introduttiva: Creare un cluster di macchine virtuali Linux in Azure con Terraform

Articolo
07/27/2023

Si applica a: ✔️ Macchine virtuali Linux

Questo articolo illustra come creare un cluster di macchine virtuali Linux (contenente due istanze di macchine virtuali Linux) in Azure usando Terraform.

In questo articolo vengono illustrate le operazioni seguenti:

Creare un valore casuale per il nome del gruppo di risorse di Azure usando random_pet.
Creare un gruppo di risorse di Azure usando azurerm_resource_group.
Creare una rete virtuale usando azurerm_virtual_network
Creare una subnet usando azurerm_subnet
Creare un indirizzo IP pubblico usando azurerm_public_ip
Creare un servizio di bilanciamento del carico usando azurerm_lb
Creare un pool di indirizzi del servizio di bilanciamento del carico usando azurerm_lb_backend_address_pool
Creare un'interfaccia di rete usando azurerm_network_interface
Creare un disco gestito usando azurerm_managed_disk
Creare un set di disponibilità usando azurerm_availability_set
Creare una macchina virtuale Linux usando azurerm_linux_virtual_machine
Creare una risorsa AzAPI azapi_resource.
Creare una risorsa AzAPI per generare una coppia di chiavi SSH usando azapi_resource_action.

Prerequisiti

Installare e configurare Terraform

Implementare il codice Terraform

Nota

Il codice di esempio per questo articolo si trova nel repository GitHub di Azure Terraform. È possibile visualizzare il file di log contenente i risultati del test delle versioni correnti e precedenti di Terraform.

Vedere altri articoli e codice di esempio che illustrano come usare Terraform per gestire le risorse di Azure

Creare una directory in cui testare il codice Terraform di esempio e impostarla come directory corrente.

Creare un file denominato providers.tf e inserire il codice seguente:

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 {}
}

Creare un file denominato ssh.tf e inserire il codice seguente:

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 = jsondecode(azapi_resource_action.ssh_public_key_gen.output).publicKey
}

Creare un file denominato main.tf e inserire il codice seguente:

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 = jsondecode(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"
}

Creare un file denominato variables.tf e inserire il codice seguente:

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"
}

Creare un file denominato outputs.tf e inserire il codice seguente:

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[*]]
}

Inizializzare Terraform

Eseguire terraform init per inizializzare la distribuzione di Terraform. Questo comando scarica il provider di Azure necessario per gestire le risorse di Azure.

terraform init -upgrade

Punti principali:

Il -upgrade parametro aggiorna i plug-in del provider necessari alla versione più recente conforme ai vincoli di versione della configurazione.

Creare un piano di esecuzione Terraform

Eseguire terraform plan per creare un piano di esecuzione.

terraform plan -out main.tfplan

Punti principali:

Il comando terraform plan consente di creare un piano di esecuzione, ma non di eseguirlo. Determina invece le azioni necessarie per creare la configurazione specificata nei file di configurazione. Questo modello consente di verificare se il piano di esecuzione corrisponde alle aspettative prima di apportare modifiche alle risorse effettive.
Il parametro -out facoltativo consente di specificare un file di output per il piano. L'uso del parametro -out garantisce che il piano esaminato sia esattamente quello che viene applicato.
Per altre informazioni su come rendere persistenti i piani di esecuzione e la sicurezza, vedere la sezione relativa agli avvisi di sicurezza.

Applicare un piano di esecuzione terraform

Eseguire terraform apply per applicare il piano di esecuzione all'infrastruttura cloud.

terraform apply main.tfplan

Punti principali:

Il comando di esempio terraform apply presuppone che sia stato eseguito terraform plan -out main.tfplanin precedenza .
Se è stato specificato un nome file diverso per il -out parametro , usare lo stesso nome file nella chiamata a terraform apply.
Se il parametro non è stato usato -out , chiamare terraform apply senza parametri.

Le informazioni sui costi non vengono presentate durante il processo di creazione della macchina virtuale per Terraform, come per il portale di Azure. Per altre informazioni sul funzionamento dei costi per le macchine virtuali, vedere la pagina Panoramica sull'ottimizzazione dei costi.

Verificare i risultati

Interfaccia della riga di comando di Azure
Azure PowerShell

Ottenere il nome del gruppo di risorse di Azure.

resource_group_name=$(terraform output -raw resource_group_name)

Eseguire az vm list con una query JMESPath per visualizzare i nomi delle macchine virtuali create nel gruppo di risorse.
```
az vm list \
  --resource-group $resource_group_name \
  --query "[].{\"VM Name\":name}" -o table
```

Ottenere il nome del gruppo di risorse di Azure.

$resource_group_name=$(terraform output -raw resource_group_name)

Eseguire Get-AzVm per visualizzare i nomi di tutte le macchine virtuali nel gruppo di risorse.
```
Get-AzVm -ResourceGroupName $resource_group_name
```

Pulire le risorse

Quando le risorse create tramite Terraform non sono più necessarie, seguire questa procedura:

Eseguire terraform plan e specificare il destroy flag.
```
terraform plan -destroy -out main.destroy.tfplan
```
Punti principali:
- Il comando terraform plan consente di creare un piano di esecuzione, ma non di eseguirlo. Determina invece le azioni necessarie per creare la configurazione specificata nei file di configurazione. Questo modello consente di verificare se il piano di esecuzione corrisponde alle aspettative prima di apportare modifiche alle risorse effettive.
- Il parametro -out facoltativo consente di specificare un file di output per il piano. L'uso del parametro -out garantisce che il piano esaminato sia esattamente quello che viene applicato.
- Per altre informazioni su come rendere persistenti i piani di esecuzione e la sicurezza, vedere la sezione relativa agli avvisi di sicurezza.
Eseguire terraform apply per applicare il piano di esecuzione.
```
terraform apply main.destroy.tfplan
```

Risolvere i problemi di Terraform in Azure

Risolvere i problemi comuni relativi all'uso di Terraform in Azure

Passaggi successivi

Esercitazioni per le macchine virtuali di Linux in Azure

Guida introduttiva: Creare un cluster di macchine virtuali Linux in Azure con Terraform

Prerequisiti

Implementare il codice Terraform

Inizializzare Terraform

Creare un piano di esecuzione Terraform

Applicare un piano di esecuzione terraform

Verificare i risultati

Pulire le risorse

Risolvere i problemi di Terraform in Azure

Passaggi successivi

Risorse aggiuntive