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

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

Vereisten

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

De Terraform-code implementeren

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

  2. 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 {}
    }
    
  3. 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
      }
    }
    
  4. 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."
    }
    
  5. 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:

  1. 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
    
  2. Voer terraform-uitvoer uit om het openbare IP-adres van de virtuele machine op te halen.

    terraform output public_ip_address
    
  3. 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:

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