Avvio rapido: Usare Terraform per creare una macchina virtuale Linux

Articolo
03/24/2023

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. Queste 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 una rete virtuale

Creare una subnet

Creare un indirizzo IP pubblico

Creare un gruppo di sicurezza di rete e una regola in ingresso SSH

Creare una scheda di interfaccia di rete virtuale

Connettere il gruppo di sicurezza di rete all'interfaccia di rete

Creare un account di archiviazione per la diagnostica di avvio

Creare una chiave SSH

Creare una macchina virtuale

Usare SSH per connettersi alla macchina virtuale

Nota

Il codice di esempio in questo articolo si trova nel repository GitHub Microsoft Terraform. Per gestire le risorse di Azure, vedere altri articoli e codice di esempio che illustrano come usare Terraform

Prerequisiti

Sottoscrizione di Azure: Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Installare e configurare Terraform

Implementare il codice Terraform

Creare una directory in cui testare il codice Terraform di esempio e renderla la directory corrente.

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

terraform {
  required_version = ">=0.12"

  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>2.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~>3.0"
    }
    tls = {
      source = "hashicorp/tls"
      version = "~>4.0"
    }
  }
}

provider "azurerm" {
  features {}
}

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 (and display) an SSH key
resource "tls_private_key" "example_ssh" {
  algorithm = "RSA"
  rsa_bits  = 4096
}

# 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                   = "myvm"
  admin_username                  = "azureuser"
  disable_password_authentication = true

  admin_ssh_key {
    username   = "azureuser"
    public_key = tls_private_key.example_ssh.public_key_openssh
  }

  boot_diagnostics {
    storage_account_uri = azurerm_storage_account.my_storage_account.primary_blob_endpoint
  }
}

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

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
}

output "tls_private_key" {
  value     = tls_private_key.example_ssh.private_key_pem
  sensitive = true
}

Inizializzare Terraform

Eseguire terraform init per inizializzare la distribuzione 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 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 in terraform plan -out main.tfplanprecedenza .
Se è stato specificato un nome file diverso per il -out parametro, usare lo stesso nome file nella chiamata a terraform apply.
Se non è stato usato il -out parametro, chiamare terraform apply senza parametri.

Verificare i risultati

Per usare SSH per connettersi alla macchina virtuale, seguire questa procedura:

Eseguire l'output terraform per ottenere la chiave privata SSH e salvarla in un file.
```
terraform output -raw tls_private_key > id_rsa
```
Eseguire l'output terraform per ottenere l'indirizzo IP pubblico della macchina virtuale.
```
terraform output public_ip_address
```
Usare SSH per connettersi alla macchina virtuale.
```
ssh -i id_rsa azureuser@<public_ip_address>
```
Punti principali:
- A seconda delle autorizzazioni dell'ambiente, potrebbe verificarsi un errore durante il tentativo di ssh nella macchina virtuale usando il id_rsa file di chiave. Se viene visualizzato un errore che indica che il file di chiave privata non è protetto e non può essere usato, provare a eseguire il comando seguente: chmod 600 id_rsa, che limita l'accesso in lettura e scrittura al proprietario del file.

Pulire le risorse

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

Eseguire il piano terraform 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 relativi a Terraform in Azure

Risolvere i problemi comuni quando si usa 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

Avvio rapido: Usare Terraform per creare una macchina virtuale Linux

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 relativi a Terraform in Azure

Passaggi successivi

Risorse aggiuntive

Risorse aggiuntive