Avvio rapido: Usare Terraform per creare una macchina virtuale Linux

Si applica a: ✔️ macchine virtuali Linux

Articolo testato con le versioni del provider Terraform e Terraform seguenti:

In questo articolo viene illustrato come creare un ambiente Linux completo e le risorse di supporto con Terraform. Tali risorse includono una rete virtuale, una subnet, un indirizzo IP pubblico e altro ancora.

Terraform consente di definire, visualizzare in anteprima e distribuire l'infrastruttura cloud. Con Terraform è possibile creare file di configurazione usando la sintassi HCL. La sintassi HCL consente di specificare il provider di servizi cloud, ad esempio Azure, e gli elementi che costituiscono l'infrastruttura cloud. Dopo aver creato i file di configurazione, è necessario creare un piano di esecuzione che consenta di visualizzare in anteprima le modifiche apportate all'infrastruttura prima che vengano distribuite. Dopo aver verificato le modifiche, è possibile applicare il piano di esecuzione per distribuire l'infrastruttura.

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 gruppo di sicurezza di rete usando azurerm_network_security_group.
• Creare un'interfaccia di rete usando azurerm_network_interface.
• Creare un'associazione tra il gruppo di sicurezza di rete e l'interfaccia di rete usando azurerm_network_interface_security_group_association.
• Generare un valore casuale per un nome di account di archiviazione univoco usando random_id.
• Creare un account di archiviazione per la diagnostica di avvio usando azurerm_storage_account.
• 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

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

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

   terraform {
     required_version = ">=0.12"
   
     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. 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 = azapi_resource_action.ssh_public_key_gen.output.publicKey
   }
   

4. 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" {
     location = var.resource_group_location
     name     = random_pet.rg_name.id
   }
   
   # Create virtual network
   resource "azurerm_virtual_network" "my_terraform_network" {
     name                = "myVnet"
     address_space       = ["10.0.0.0/16"]
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
   }
   
   # Create subnet
   resource "azurerm_subnet" "my_terraform_subnet" {
     name                 = "mySubnet"
     resource_group_name  = azurerm_resource_group.rg.name
     virtual_network_name = azurerm_virtual_network.my_terraform_network.name
     address_prefixes     = ["10.0.1.0/24"]
   }
   
   # Create public IPs
   resource "azurerm_public_ip" "my_terraform_public_ip" {
     name                = "myPublicIP"
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
     allocation_method   = "Dynamic"
   }
   
   # Create Network Security Group and rule
   resource "azurerm_network_security_group" "my_terraform_nsg" {
     name                = "myNetworkSecurityGroup"
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
   
     security_rule {
       name                       = "SSH"
       priority                   = 1001
       direction                  = "Inbound"
       access                     = "Allow"
       protocol                   = "Tcp"
       source_port_range          = "*"
       destination_port_range     = "22"
       source_address_prefix      = "*"
       destination_address_prefix = "*"
     }
   }
   
   # Create network interface
   resource "azurerm_network_interface" "my_terraform_nic" {
     name                = "myNIC"
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
   
     ip_configuration {
       name                          = "my_nic_configuration"
       subnet_id                     = azurerm_subnet.my_terraform_subnet.id
       private_ip_address_allocation = "Dynamic"
       public_ip_address_id          = azurerm_public_ip.my_terraform_public_ip.id
     }
   }
   
   # Connect the security group to the network interface
   resource "azurerm_network_interface_security_group_association" "example" {
     network_interface_id      = azurerm_network_interface.my_terraform_nic.id
     network_security_group_id = azurerm_network_security_group.my_terraform_nsg.id
   }
   
   # Generate random text for a unique storage account name
   resource "random_id" "random_id" {
     keepers = {
       # Generate a new ID only when a new resource group is defined
       resource_group = azurerm_resource_group.rg.name
     }
   
     byte_length = 8
   }
   
   # Create storage account for boot diagnostics
   resource "azurerm_storage_account" "my_storage_account" {
     name                     = "diag${random_id.random_id.hex}"
     location                 = azurerm_resource_group.rg.location
     resource_group_name      = azurerm_resource_group.rg.name
     account_tier             = "Standard"
     account_replication_type = "LRS"
   }
   
   # Create virtual machine
   resource "azurerm_linux_virtual_machine" "my_terraform_vm" {
     name                  = "myVM"
     location              = azurerm_resource_group.rg.location
     resource_group_name   = azurerm_resource_group.rg.name
     network_interface_ids = [azurerm_network_interface.my_terraform_nic.id]
     size                  = "Standard_DS1_v2"
   
     os_disk {
       name                 = "myOsDisk"
       caching              = "ReadWrite"
       storage_account_type = "Premium_LRS"
     }
   
     source_image_reference {
       publisher = "Canonical"
       offer     = "0001-com-ubuntu-server-jammy"
       sku       = "22_04-lts-gen2"
       version   = "latest"
     }
   
     computer_name  = "hostname"
     admin_username = var.username
   
     admin_ssh_key {
       username   = var.username
       public_key = azapi_resource_action.ssh_public_key_gen.output.publicKey
     }
   
     boot_diagnostics {
       storage_account_uri = azurerm_storage_account.my_storage_account.primary_blob_endpoint
     }
   }
   

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

   variable "resource_group_location" {
     type        = string
     default     = "eastus"
     description = "Location of the resource group."
   }
   
   variable "resource_group_name_prefix" {
     type        = string
     default     = "rg"
     description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
   }
   
   variable "username" {
     type        = string
     description = "The username for the local account that will be created on the new VM."
     default     = "azureadmin"
   }
   

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

   output "resource_group_name" {
     value = azurerm_resource_group.rg.name
   }
   
   output "public_ip_address" {
     value = azurerm_linux_virtual_machine.my_terraform_vm.public_ip_address
   }
   

Inizializzare Terraform

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

terraform init -upgrade

Punti principali:

• Il parametro -upgrade 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.

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 terraform apply di esempio presuppone che in precedenza sia stato eseguito terraform plan -out main.tfplan.
• Se è stato specificato un nome file diverso per il parametro -out, usare lo stesso nome file nella chiamata a terraform apply.
• Se non è stato usato il parametro -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 dell'ottimizzazione dei costi.

Verificare i risultati

Interfaccia della riga di comando di Azure

1. Ottenere il nome del gruppo di risorse di Azure.

   resource_group_name=$(terraform output -raw resource_group_name)
   

2. 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
   

Azure PowerShell

1. Ottenere il nome del gruppo di risorse di Azure.

   $resource_group_name=$(terraform output -raw resource_group_name)
   

2. 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, eseguire i passaggi seguenti:

1. Eseguire terraform plan e specificare il flag destroy.

   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.

2. 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

In questa guida introduttiva è stata distribuita una semplice macchina virtuale usando Terraform. Per altre informazioni sulle macchine virtuali di Azure, passare all'esercitazione per le VM di Linux.

Esercitazioni per le macchine virtuali di Linux in Azure