Snabbstart: Använda Terraform för att skapa en virtuell Linux-dator

  • Artikel
  • 6 minuter för att läsa

Gäller för: ✔️ Virtuella Linux-datorer

Artikel testad med följande Terraform- och Terraform-providerversioner:

Den här artikeln visar hur du skapar en komplett Linux-miljö och stödresurser med Terraform. Dessa resurser omfattar ett virtuellt nätverk, undernät, offentlig IP-adress med mera.

Terraform möjliggör definition, förhandsversion och distribution av molninfrastruktur. Med Terraform skapar du konfigurationsfiler med hjälp av HCL-syntax. Med HCL-syntaxen kan du ange molnleverantören – till exempel Azure – och de element som utgör din molninfrastruktur. När du har skapat konfigurationsfilerna skapar du en körningsplan som gör att du kan förhandsgranska dina infrastrukturändringar innan de distribueras. När du har verifierat ändringarna tillämpar du körningsplanen för att distribuera infrastrukturen.

I den här artikeln kan du se hur du:

  • Skapa ett virtuellt nätverk
  • Skapa ett undernät
  • Skapa en offentlig IP-adress
  • Skapa en nätverkssäkerhetsgrupp och SSH-regel för inkommande trafik
  • Skapa ett kort för virtuellt nätverksgränssnitt
  • Ansluta nätverkssäkerhetsgruppen till nätverksgränssnittet
  • Skapa ett lagringskonto för startdiagnostik
  • Skapa SSH-nyckel
  • Skapa en virtuell dator
  • Använda SSH för att ansluta till en virtuell dator

Anteckning

Exempelkoden i den här artikeln finns på GitHub-lagringsplatsen microsoft Terraform. Se fler artiklar och exempelkod som visar hur du använder Terraform för att hantera Azure-resurser

Krav

  • Azure-prenumeration: Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.

Implementera Terraform-koden

  1. Skapa en katalog där du kan testa Terraform-exempelkoden och göra den till den aktuella katalogen.

  2. Skapa en fil med namnet providers.tf och infoga följande kod:

    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. Skapa en fil med namnet main.tf och infoga följande kod:

    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. Skapa en fil med namnet variables.tf och infoga följande kod:

    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. Skapa en fil med namnet outputs.tf och infoga följande kod:

    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
}

Initiera Terraform

Kör terraform init för att initiera Terraform-distributionen. Det här kommandot laddar ned de Azure-moduler som krävs för att hantera dina Azure-resurser.

terraform init

Skapa en Terraform-körningsplan

Kör terraform-planen för att skapa en körningsplan.

terraform plan -out main.tfplan

Viktiga punkter:

  • Kommandot terraform plan skapar en körningsplan, men kör den inte. I stället avgör den vilka åtgärder som krävs för att skapa konfigurationen som anges i konfigurationsfilerna. Med det här mönstret kan du kontrollera om körningsplanen matchar dina förväntningar innan du gör några ändringar i faktiska resurser.
  • Med den valfria -out parametern kan du ange en utdatafil för planen. Med hjälp av parametern -out ser du till att den plan som du har granskat är exakt det som tillämpas.
  • Mer information om beständiga körningsplaner och säkerhet finns i avsnittet säkerhetsvarning.

Tillämpa en Terraform-körningsplan

Kör terraform apply för att tillämpa körningsplanen på din molninfrastruktur.

terraform apply main.tfplan

Viktiga punkter:

  • Kommandot terraform apply ovan förutsätter att du tidigare körde terraform plan -out main.tfplan.
  • Om du har angett ett annat filnamn för parametern -out använder du samma filnamn i anropet till terraform apply.
  • Om du inte använde parametern -out anropar terraform apply du utan några parametrar.

Verifiera resultaten

Om du vill använda SSH för att ansluta till den virtuella datorn gör du följande:

  1. Kör terraform-utdata för att hämta den privata SSH-nyckeln och spara den i en fil.

    terraform output -raw tls_private_key > id_rsa

  2. Kör terraform-utdata för att hämta den virtuella datorns offentliga IP-adress.

    terraform output public_ip_address

  3. Använd SSH för att ansluta till den virtuella datorn.

    ssh -i id_rsa azureuser@<public_ip_address>

    Viktiga punkter:

    • Beroende på behörigheterna för din miljö kan du få ett fel när du försöker ssh-ansluta till den virtuella datorn med hjälp av id_rsa nyckelfilen. Om du får ett felmeddelande om att den privata nyckelfilen är oskyddad och inte kan användas kan du prova att köra följande kommando: chmod 600 id_rsa, vilket begränsar läs- och skrivåtkomsten till filens ägare.

Rensa resurser

Gör följande när du inte längre behöver de resurser som skapats via Terraform:

  1. Kör terraform-planen och ange destroy flaggan .

    terraform plan -destroy -out main.destroy.tfplan

    Viktiga punkter:

    • Kommandot terraform plan skapar en körningsplan, men kör den inte. I stället avgör den vilka åtgärder som krävs för att skapa konfigurationen som anges i konfigurationsfilerna. Med det här mönstret kan du kontrollera om körningsplanen matchar dina förväntningar innan du gör några ändringar i faktiska resurser.
    • Med den valfria -out parametern kan du ange en utdatafil för planen. Med hjälp av parametern -out ser du till att den plan som du har granskat är exakt det som tillämpas.
    • Mer information om beständiga körningsplaner och säkerhet finns i avsnittet säkerhetsvarning.

  2. Kör terraform apply för att tillämpa körningsplanen.

    terraform apply main.destroy.tfplan

Felsöka Terraform på Azure

Felsöka vanliga problem när du använder Terraform på Azure

Nästa steg

I den här snabbstarten har du distribuerat en enkel virtuell dator med Terraform. Om du vill veta mer om virtuella Azure-datorer fortsätter du till självstudien för virtuella Linux-datorer.

Självstudier om virtuella Azure Linux-datorer