Quickstart: Terraform gebruiken om een Virtuele Linux-machine te maken

Artikel
11/29/2022
6 minuten om te lezen

Van toepassing op: ✔️ Virtuele Linux-machines

Artikel getest met de volgende terraform- en Terraform-providerversies:

In dit artikel wordt beschreven hoe u een volledige Linux-omgeving en ondersteunende resources maakt met Terraform. Deze resources omvatten een virtueel netwerk, subnet, openbaar IP-adres en meer.

Terraform maakt de definitie, preview en implementatie van cloudinfrastructuur mogelijk. Met Terraform maakt u configuratiebestanden met behulp van de HCL-syntaxis. Met de HCL-syntaxis kunt u de cloudprovider opgeven, zoals Azure, en de elementen waaruit uw cloudinfrastructuur bestaat. Nadat u uw configuratiebestanden hebt gemaakt, maakt u een uitvoeringsplan waarmee u een voorbeeld van uw infrastructuurwijzigingen kunt bekijken voordat ze worden geïmplementeerd. Zodra u de wijzigingen hebt gecontroleerd, past u het uitvoeringsplan toe om de infrastructuur te implementeren.

In dit artikel leert u het volgende:

Een virtueel netwerk maken

Een subnet maken

Een openbaar IP-adres maken

Een netwerkbeveiligingsgroep en een inkomende SSH-regel maken

Een virtuele netwerkinterfacekaart maken

De netwerkbeveiligingsgroep verbinden met de netwerkinterface

Een opslagaccount maken voor diagnostische gegevens over opstarten

SSH-sleutel maken

Een virtuele machine maken

SSH gebruiken om verbinding te maken met virtuele machine

Notitie

De voorbeeldcode in dit artikel bevindt zich in de Microsoft Terraform GitHub-opslagplaats. Bekijk meer artikelen en voorbeeldcode die laat zien hoe u Terraform gebruikt om Azure-resources te beheren

Vereisten

Azure-abonnement: Als u nog geen abonnement op Azure hebt, maak dan een gratis account aan voordat u begint.

Terraform installeren en configureren

De Terraform-code implementeren

Maak een map waarin u de Terraform-voorbeeldcode wilt testen en deze de huidige map kunt maken.

Maak een bestand met de naam providers.tf en voeg de volgende code in:

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

Maak een bestand met de naam main.tf en voeg de volgende code in:

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     = "UbuntuServer"
    sku       = "18.04-LTS"
    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
  }
}

Maak een bestand met de naam variables.tf en voeg de volgende code in:

variable "resource_group_location" {
  default     = "eastus"
  description = "Location of the resource group."
}

variable "resource_group_name_prefix" {
  default     = "rg"
  description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
}

Maak een bestand met de naam outputs.tf en voeg de volgende code in:

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
}

Terraform initialiseren

Voer terraform init uit om de Terraform-implementatie te initialiseren. Met deze opdracht worden de Azure-modules gedownload die nodig zijn om uw Azure-resources te beheren.

terraform init

Een Terraform-uitvoeringsplan maken

Voer terraform-plan uit om een uitvoeringsplan te maken.

terraform plan -out main.tfplan

Belangrijke punten:

Met de terraform plan opdracht wordt een uitvoeringsplan gemaakt, maar niet uitgevoerd. In plaats daarvan wordt bepaald welke acties nodig zijn om de configuratie te maken die is opgegeven in uw configuratiebestanden. Met dit patroon kunt u controleren of het uitvoeringsplan voldoet aan uw verwachtingen voordat u wijzigingen aanbrengt in werkelijke resources.
Met de optionele -out parameter kunt u een uitvoerbestand voor het plan opgeven. Met behulp van de -out parameter zorgt u ervoor dat het plan dat u hebt gecontroleerd precies wordt toegepast.
Zie de sectie beveiligingswaarschuwingen voor meer informatie over het persistent maken van uitvoeringsplannen en beveiliging.

Een Terraform-uitvoeringsplan toepassen

Terraform uitvoeren is van toepassing om het uitvoeringsplan toe te passen op uw cloudinfrastructuur.

terraform apply main.tfplan

Belangrijke punten:

In de terraform apply bovenstaande opdracht wordt ervan uitgegaan dat u eerder hebt uitgevoerd terraform plan -out main.tfplan.
Als u een andere bestandsnaam voor de -out parameter hebt opgegeven, gebruikt u diezelfde bestandsnaam in de aanroep naar terraform apply.
Als u de -out parameter niet hebt gebruikt, roept terraform apply u zonder parameters aan.

De resultaten controleren

Voer de volgende stappen uit om SSH te gebruiken om verbinding te maken met de virtuele machine:

Voer terraform-uitvoer uit om de persoonlijke SSH-sleutel op te halen en op te slaan in een bestand.
```
terraform output -raw tls_private_key > id_rsa
```
Voer terraform-uitvoer uit om het openbare IP-adres van de virtuele machine op te halen.
```
terraform output public_ip_address
```
Gebruik SSH om verbinding te maken met de virtuele machine.
```
ssh -i id_rsa azureuser@<public_ip_address>
```
Belangrijke punten:
- Afhankelijk van de machtigingen van uw omgeving krijgt u mogelijk een foutmelding wanneer u met behulp van het id_rsa sleutelbestand naar de virtuele machine probeert te sshen. Als er een foutmelding wordt weergegeven dat het bestand met de persoonlijke sleutel niet is beveiligd en niet kan worden gebruikt, voert u de volgende opdracht uit: chmod 600 id_rsa, waarmee de lees- en schrijftoegang tot de eigenaar van het bestand wordt beperkt.

Resources opschonen

Wanneer u de resources die zijn gemaakt via Terraform niet meer nodig hebt, voert u de volgende stappen uit:

Voer terraform-plan uit en geef de destroy vlag op.
```
terraform plan -destroy -out main.destroy.tfplan
```
Belangrijke punten:
- Met de terraform plan opdracht wordt een uitvoeringsplan gemaakt, maar niet uitgevoerd. In plaats daarvan wordt bepaald welke acties nodig zijn om de configuratie te maken die is opgegeven in uw configuratiebestanden. Met dit patroon kunt u controleren of het uitvoeringsplan voldoet aan uw verwachtingen voordat u wijzigingen aanbrengt in werkelijke resources.
- Met de optionele -out parameter kunt u een uitvoerbestand voor het plan opgeven. Met behulp van de -out parameter zorgt u ervoor dat het plan dat u hebt gecontroleerd precies wordt toegepast.
- Zie de sectie beveiligingswaarschuwingen voor meer informatie over het persistent maken van uitvoeringsplannen en beveiliging.
Terraform uitvoeren is van toepassing om het uitvoeringsplan toe te passen.
```
terraform apply main.destroy.tfplan
```

Problemen met Terraform in Azure oplossen

Veelvoorkomende problemen bij het gebruik van Terraform in Azure oplossen

Volgende stappen

In deze quickstart hebt u een eenvoudige virtuele machine geïmplementeerd met behulp van Terraform. Voor meer informatie over virtuele machines in Azure, gaat u verder met de zelfstudie voor virtuele Linux-machines.

Zelfstudies over virtuele Linux-machines