Etablera en virtuell Linux-dator med terraform

20 minuter

Terraform implementerar och styr en målinfrastruktur med hjälp av konfigurationsfiler som beskriver det önskade tillståndet för dess komponenter. Det grundläggande formatet för filerna och deras allmänna syntax – uttryckt i Hashicorp Configuration Language (HCL) – är samma oavsett molnval. Enskilda komponentbeskrivningar är dock molnberoende, vilket bestäms av motsvarande Terraform-provider.

Även om det finns flera Terraform-leverantörer som stöder Azure-infrastrukturhantering är AzureRM särskilt relevant. AzureRM-providern underlättar etablering och konfiguration av vanliga Azure IaaS-resurser, till exempel virtuella datorer, lagringskonton och nätverksgränssnitt. Det finns också ytterligare icke-molnspecifika leverantörer som du kanske vill införliva i dina distributioner. Dessa inkluderar den slumpmässiga providern, som hjälper till att undvika konflikter med resursnamngivning genom att generera pseudo-slumpmässiga teckensträngar. och tls-providern, vilket förenklar hanteringen av asymmetriska nycklar för att skydda Linux-autentisering.

Terraform är tillgängligt som en enda binär fil som du kan ladda ned från Hashicorps webbplats. Den här binärfilen implementerar Terraform-kommandoradsgränssnittet (CLI), som du sedan kan anropa från en shell-session för att initiera Terraform- och processkonfigurationsfiler. Du kan använda Terraform CLI från något av de gränssnitt som stöder Azure CLI.

Kommentar

När du använder Azure Cloud Shell ska du köra den aktuella versionen av Terraform genom att följa anvisningarna i Konfigurera Terraform i Azure Cloud Shell med Bash.

Distribuera en virtuell Linux-dator med hjälp av Terraform

Med Terraform kan du definiera, förhandsgranska och distribuera resurser till en leverantörsspecifik molninfrastruktur. Etableringsprocessen börjar med att skapa konfigurationsfiler som använder HCL-syntaxen, vilket gör att du kan ange målmolnmiljön , till exempel Azure, och de resurser som utgör din molninfrastruktur. När alla relevanta konfigurationsfiler är på plats (vanligtvis på samma plats i filsystemet) kan du generera en körningsplan som gör att du kan förhandsgranska de resulterande infrastrukturändringarna före den faktiska distributionen. Detta kräver att du initierar Terraform för att ladda ned de providermoduler som krävs för att implementera molnresurser. När du har verifierat ändringarna kan du använda körningsplanen för att distribuera infrastrukturen.

Kommentar

Det är valfritt att generera en körningsplan, men vi rekommenderar att du gör det eftersom du kan identifiera eventuella effekter från den planerade distributionen utan att påverka målmiljön. När du distribuerar Azure-resurser interaktivt stöder Terraform Azure CLI-autentisering transparent genom att återanvända dina autentiseringsuppgifter för att få åtkomst till azure-målprenumerationen.

Processen med att etablera en virtuell Azure-dator som kör Linux med Terraform omfattar vanligtvis följande sekvens med övergripande steg:

Identifiera lämplig VM-avbildning.
Identifiera lämplig VM-storlek.
Skapa konfigurationsfiler som definierar resursen för den virtuella Azure-datorn med dess beroenden.
Initiera Terraform.
Generera en Terraform-körningsplan.
Initiera en Terraform-distribution.

Följ stegen som beskrivs i lektion 4 i den här modulen för att identifiera lämplig VM-avbildning och storlek. Den här lektionen fokuserar på Terraform-specifika uppgifter.

Skapa konfigurationsfiler

Kommentar

De filnamn som du väljer för Dina Terraform-filer är godtyckliga, även om det är en bra idé att välja ett namn som återspeglar filinnehållet eller syftet. Du bör använda ".tf" för filnamnstillägget.

Om du vill distribuera en virtuell Linux-dator med Terraform börjar du med att skapa en katalog som är värd för konfigurationsfiler. Skapa sedan en fil med namnet providers.tf som framtvingar Terraform-versionen och anger de leverantörer som du förlitar dig på när du definierar de resurser som ingår i distributionen. Den här filen ska ha innehållet som visas i följande kodfragment:

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

I samma katalog skapar du en fil med namnet main.tf med hjälp av följande kod, som definierar konfigurationen av den virtuella Azure-datorn och dess beroenden:

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" "terraform_network" {
  name                = "lnx-tf-vnet"
  address_space       = ["10.1.0.0/16"]
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
}

# Create subnet
resource "azurerm_subnet" "terraform_subnet" {
  name                 = "subnet0"
  resource_group_name  = azurerm_resource_group.rg.name
  virtual_network_name = azurerm_virtual_network.terraform_network.name
  address_prefixes     = ["10.1.0.0/24"]
}

# Create public IPs
resource "azurerm_public_ip" "terraform_public_ip" {
  name                = "lnx-tf-pip"
  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" "terraform_nsg" {
  name                = "lnx-tf-nsg"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name

  security_rule {
    name                       = "ssh"
    priority                   = 300
    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" "terraform_nic" {
  name                = "lnx-tf-nic"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name

  ip_configuration {
    name                          = "nic_configuration"
    subnet_id                     = azurerm_subnet.terraform_subnet.id
    private_ip_address_allocation = "Dynamic"
    public_ip_address_id          = azurerm_public_ip.terraform_public_ip.id
  }
}

# Connect the security group to the network interface
resource "azurerm_network_interface_security_group_association" "lnx-tf-nic-nsg" {
  network_interface_id      = azurerm_network_interface.terraform_nic.id
  network_security_group_id = azurerm_network_security_group.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" "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" "lnx-tf-ssh" {
  algorithm = "RSA"
  rsa_bits  = 4096
}

# Create virtual machine
resource "azurerm_linux_virtual_machine" "lnx-tf-vm" {
  name                  = "lnx-tf-vm"
  location              = azurerm_resource_group.rg.location
  resource_group_name   = azurerm_resource_group.rg.name
  network_interface_ids = [azurerm_network_interface.terraform_nic.id]
  size                  = "Standard_F4s"

  os_disk {
    name                 = "lnx-tf-vm-osdisk"
    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                   = "lnx-tf-vm"
  admin_username                  = "azureuser"
  disable_password_authentication = true

  admin_ssh_key {
    username   = "azureuser"
    public_key = tls_private_key.lnx-tf-ssh.public_key_openssh
  }

  boot_diagnostics {
    storage_account_uri = azurerm_storage_account.storage_account.primary_blob_endpoint
  }
}

I samma katalog skapar du en annan fil med namnet variables.tf med hjälp av följande kod, som tilldelar värdet till variablerna som visas i main.tf-filen:

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

Slutligen skapar du en fil med namnet outputs.tf med hjälp av följande kod, som avgör vilka utdata som visas efter en lyckad distribution:

output "resource_group_name" {
  value = azurerm_resource_group.rg.name
}

output "public_ip_address" {
  value = azurerm_linux_virtual_machine.lnx-tf-vm.public_ip_address
}

output "tls_private_key" {
  value     = tls_private_key.lnx-tf-ssh.private_key_pem
  sensitive = true
}

Initiera Terraform

Om du vill initiera Terraform-distributionen kör du följande kommando från kommandotolken:

terraform init

Det här kommandot laddar ned de Azure-moduler som krävs för att etablera och hantera Azure-resurser.

Generera en körningsplan

Efter initieringen skapar du en körningsplan genom att köra terraform-planen. Kommandot 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 de resurser som definierats i konfigurationsfilerna. Med den valfria -out parametern kan du ange en utdatafil för planen, som du kan referera till under den faktiska distributionen. Genom att använda den här filen ser du till att den plan som du granskar matchar det exakta distributionsresultatet. Använd följande kommando för att generera en körningsplan:

terraform plan -out <terraform_plan>.tfplan

Initiera en distribution

När du är redo att tillämpa körningsplanen på din Azure-miljö kör terraform applydu , inklusive namnet på filen som du genererade i föregående steg. Du får en ny chans att granska det förväntade resultatet. Terraform uppmanar dig att bekräfta att du fortsätter, men du kan eliminera uppmaningen genom att lägga till växeln -auto-approve . Använd följande kommando för att initiera distributionen:

terraform apply <terraform_plan>.tfplan

Den virtuella Azure-datorn börjar snart köras, vanligtvis inom ett par minuter. Kommandoutdata terraform apply innehåller listan med utdata, men terraform ersätter värdet tls_private_key för med den <känsliga> etiketten:

Apply complete! Resources: 12 added, 0 changed, 0 destroyed.

Utgångar:

public_ip_address = "74.235.10.136"
resource_group_name = "rg-flexible-shark"
tls_private_key = <sensitive>

Om du vill använda den autogenererade privata nyckeln för att autentisera din SSH-anslutning lagrar du den i en fil och anger sedan filens behörigheter för att säkerställa att den inte är tillgänglig för andra. Kör följande kommandon för att åstadkomma detta:

terraform output -raw tls_private_key > id_rsa
chmod 600 id_rsa

Nu kan du ansluta till den virtuella Azure-datorn genom att köra följande kommando (efter att <ha ersatt platshållaren public_ip_address> med DEN IP-adress som du identifierade i terraform apply-generated-utdata):

ssh -i id_rsa azureuser@<public_ip_address>

Fortsätt

Etablera en virtuell Linux-dator med terraform

Distribuera en virtuell Linux-dator med hjälp av Terraform

Skapa konfigurationsfiler

Initiera Terraform

Generera en körningsplan

Initiera en distribution

Feedback