Skapa en VM-skalningsuppsättning i Azure från en anpassad Packer-avbildning med terraform

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

Med skalningsuppsättningar för virtuella Azure-datorer kan du konfigurera identiska virtuella datorer. Antalet VM-instanser kan justeras baserat på efterfrågan eller ett schema. Mer information finns i Skala en VM-skalningsuppsättning automatiskt i Azure Portal.

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

  • Konfigurera din Terraform-distribution
  • Använda variabler och utdata för Terraform-distribution
  • Skapa och distribuera en nätverksinfrastruktur
  • Skapa en anpassad avbildning av en virtuell dator med Packer
  • Skapa och distribuera en VM-skalningsuppsättning med hjälp av den anpassade avbildningen
  • Skapa och distribuera en jumpbox

1. Konfigurera din miljö

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

2. Skapa en Packer-avbildning

  1. Installera Packer.

    Viktiga punkter:

    • Kontrollera att du har åtkomst till den körbara packer-filen genom att köra följande kommando: packer -v .
    • Beroende på din miljö kan du behöva ange sökvägen och öppna kommandoraden igen.

  2. Kör az group create för att skapa en resursgrupp som ska innehålla Packer-avbildningen.

    az group create -n myPackerImages -l eastus

  3. Kör az ad sp create-for-rbac så att Packer kan autentisera till Azure med hjälp av ett huvudnamn för tjänsten.

    az ad sp create-for-rbac --role Contributor --query "{ client_id: appId, client_secret: password, tenant_id: tenant }"

    Viktiga punkter:

    • Anteckna utdatavärdena ( appId , client_secret , tenant_id ).

  4. Kör az account show för att visa den aktuella Azure-prenumerationen.

    az account show --query "{ subscription_id: id }"

  5. Skapa en Packer-mallfil med ubuntu.json namnet och infoga följande kod:

    {
    "builders": [{
      "type": "azure-arm",
  
      "client_id": "0bfc2293-4d69-49b5-83f7-bf0d60d20c45",
      "client_secret": "G3.6ytCh44Kcla~_JRPBDLkzsXLOa3edDL",
      "tenant_id": "c3fd441d-b8ad-487e-aa27-453079018fca",
      "subscription_id": "b162117f-53fa-4f42-8c77-6a65ca966c40",
  
      "managed_image_resource_group_name": "myPackerImages",
      "managed_image_name": "myPackerImage",
  
      "os_type": "Linux",
      "image_publisher": "Canonical",
      "image_offer": "UbuntuServer",
      "image_sku": "16.04-LTS",
  
      "azure_tags": {
          "dept": "Engineering",
          "task": "Image deployment"
      },
  
      "location": "East US",
      "vm_size": "Standard_DS2_v2"
    }],
    "provisioners": [{
      "execute_command": "chmod +x {{ .Path }}; {{ .Vars }} sudo -E sh '{{ .Path }}'",
      "inline": [
        "apt-get update",
        "apt-get upgrade -y",
        "apt-get -y install nginx",
  
        "/usr/sbin/waagent -force -deprovision+user && export HISTSIZE=0 && sync"
      ],
      "inline_shebang": "/bin/sh -x",
      "type": "shell"
    }]
  }

    Viktiga punkter:

    • Ange fälten client_id , och till respektive värden från client_secrettenant_id tjänstens huvudnamn.
    • Ange fältet subscription_id till ID:t för Azure-prenumerationen.

  6. Skapa Packer-avbildningen.

    packer build ubuntu.json

3. 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 main.tf namnet och infoga följande kod:

    terraform {

  required_version = ">=0.12"

  required_providers {
    azurerm = {
      source = "hashicorp/azurerm"
      version = "~>2.0"
    }
  }
}

provider "azurerm" {
  features {}
}

resource "azurerm_resource_group" "vmss" {
  name     = var.resource_group_name
  location = var.location
  tags = var.tags
}

resource "random_string" "fqdn" {
 length  = 6
 special = false
 upper   = false
 number  = false
}

resource "azurerm_virtual_network" "vmss" {
  name                = "vmss-vnet"
  address_space       = ["10.0.0.0/16"]
  location            = var.location
  resource_group_name = azurerm_resource_group.vmss.name
  tags = var.tags
}

resource "azurerm_subnet" "vmss" {
  name                 = "vmss-subnet"
  resource_group_name  = azurerm_resource_group.vmss.name
  virtual_network_name = azurerm_virtual_network.vmss.name
  address_prefixes       = ["10.0.2.0/24"]
}

resource "azurerm_public_ip" "vmss" {
  name                         = "vmss-public-ip"
  location                     = var.location
  resource_group_name          = azurerm_resource_group.vmss.name
  allocation_method            = "Static"
  domain_name_label            = random_string.fqdn.result
  tags = var.tags
}

resource "azurerm_lb" "vmss" {
  name                = "vmss-lb"
  location            = var.location
  resource_group_name = azurerm_resource_group.vmss.name

  frontend_ip_configuration {
    name                 = "PublicIPAddress"
    public_ip_address_id = azurerm_public_ip.vmss.id
  }

  tags = var.tags
}

resource "azurerm_lb_backend_address_pool" "bpepool" {
  loadbalancer_id     = azurerm_lb.vmss.id
  name                = "BackEndAddressPool"
}

resource "azurerm_lb_probe" "vmss" {
  resource_group_name = azurerm_resource_group.vmss.name
  loadbalancer_id     = azurerm_lb.vmss.id
  name                = "ssh-running-probe"
  port                = var.application_port
}

resource "azurerm_lb_rule" "lbnatrule" {
  resource_group_name            = azurerm_resource_group.vmss.name
  loadbalancer_id                = azurerm_lb.vmss.id
  name                           = "http"
  protocol                       = "Tcp"
  frontend_port                  = var.application_port
  backend_port                   = var.application_port
  backend_address_pool_id        = azurerm_lb_backend_address_pool.bpepool.id
  frontend_ip_configuration_name = "PublicIPAddress"
  probe_id                       = azurerm_lb_probe.vmss.id
}

data "azurerm_resource_group" "image" {
  name                = var.packer_resource_group_name
}

data "azurerm_image" "image" {
  name                = var.packer_image_name
  resource_group_name = data.azurerm_resource_group.image.name
}

resource "azurerm_virtual_machine_scale_set" "vmss" {
  name                = "vmscaleset"
  location            = var.location
  resource_group_name = azurerm_resource_group.vmss.name
  upgrade_policy_mode = "Manual"

  sku {
    name     = "Standard_DS1_v2"
    tier     = "Standard"
    capacity = 2
  }

  storage_profile_image_reference {
    id=data.azurerm_image.image.id
  }

  storage_profile_os_disk {
    name              = ""
    caching           = "ReadWrite"
    create_option     = "FromImage"
    managed_disk_type = "Standard_LRS"
  }

  storage_profile_data_disk {
    lun          = 0
    caching        = "ReadWrite"
    create_option  = "Empty"
    disk_size_gb   = 10
  }

  os_profile {
    computer_name_prefix = "vmlab"
    admin_username       = var.admin_user
    admin_password       = var.admin_password
  }

  os_profile_linux_config {
    disable_password_authentication = true

    ssh_keys {
      path     = "/home/azureuser/.ssh/authorized_keys"
      key_data = file("~/.ssh/id_rsa.pub")
    }
  }

  network_profile {
    name    = "terraformnetworkprofile"
    primary = true

    ip_configuration {
      name                                   = "IPConfiguration"
      subnet_id                              = azurerm_subnet.vmss.id
      load_balancer_backend_address_pool_ids = [azurerm_lb_backend_address_pool.bpepool.id]
      primary = true
    }
  }
  
  tags = var.tags
}

resource "azurerm_public_ip" "jumpbox" {
  name                         = "jumpbox-public-ip"
  location                     = var.location
  resource_group_name          = azurerm_resource_group.vmss.name
  allocation_method            = "Static"
  domain_name_label            = "${random_string.fqdn.result}-ssh"
  tags = var.tags
}

resource "azurerm_network_interface" "jumpbox" {
  name                = "jumpbox-nic"
  location            = var.location
  resource_group_name = azurerm_resource_group.vmss.name

  ip_configuration {
    name                          = "IPConfiguration"
    subnet_id                     = azurerm_subnet.vmss.id
    private_ip_address_allocation = "dynamic"
    public_ip_address_id          = azurerm_public_ip.jumpbox.id
  }

  tags = var.tags
}

resource "azurerm_virtual_machine" "jumpbox" {
  name                  = "jumpbox"
  location              = var.location
  resource_group_name   = azurerm_resource_group.vmss.name
  network_interface_ids = [azurerm_network_interface.jumpbox.id]
  vm_size               = "Standard_DS1_v2"

  storage_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "16.04-LTS"
    version   = "latest"
  }

  storage_os_disk {
    name              = "jumpbox-osdisk"
    caching           = "ReadWrite"
    create_option     = "FromImage"
    managed_disk_type = "Standard_LRS"
  }

  os_profile {
    computer_name  = "jumpbox"
    admin_username = var.admin_user
    admin_password = var.admin_password
  }

  os_profile_linux_config {
    disable_password_authentication = true

    ssh_keys {
      path     = "/home/azureuser/.ssh/authorized_keys"
      key_data = file("~/.ssh/id_rsa.pub")
    }
  }

  tags = var.tags
}

  3. Skapa en fil med variables.tf namnet som ska innehålla projektvariablerna och infoga följande kod:

    variable "packer_resource_group_name" {
   description = "Name of the resource group in which the Packer image will be created"
   default     = "myPackerImages"
}

variable "packer_image_name" {
   description = "Name of the Packer image"
   default     = "myPackerImage"
}

variable "resource_group_name" {
   description = "Name of the resource group in which the Packer image  will be created"
   default     = "myPackerImages"
}

variable "resource_group_name" {
   description = "Name of the resource group in which the resources will be created"
   default     = "myResourceGroup"
}

variable "location" {
   default = "eastus"
   description = "Location where resources will be created"
}

variable "tags" {
   description = "Map of the tags to use for the resources that are deployed"
   type        = map(string)
   default = {
      environment = "codelab"
   }
}

variable "application_port" {
   description = "Port that you want to expose to the external load balancer"
   default     = 80
}

variable "admin_user" {
   description = "User name to use as the admin account on the VMs that will be part of the VM scale set"
   default     = "azureuser"
}

variable "admin_password" {
   description = "Default password for admin account"
}

  4. Skapa en fil med output.tf namnet för att ange vilka värden Som Terraform visar och infoga följande kod:

    output "vmss_public_ip_fqdn" {
    value = azurerm_public_ip.vmss.fqdn
}

output "jumpbox_public_ip_fqdn" {
    value = azurerm_public_ip.jumpbox.fqdn
}

output "jumpbox_public_ip" {
    value = azurerm_public_ip.jumpbox.ip_address
}

4. Initiera Terraform

Kör terraform init för att initiera Terraform-distributionen.

terraform init

Viktiga punkter:

  • Det här kommandot laddar ned de Azure-moduler som krävs för att skapa en Azure-resursgrupp.

5. Skapa en Terraform-körningsplan

Kör terraform-plan 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 -out valfria parametern kan du ange en utdatafil för planen. Med -out parametern ser du till att den plan som du granskade är exakt det som tillämpas.
  • Mer information om att bevara körningsplaner och säkerhet finns i säkerhetsvarningsavsnittet.

6. 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 -out parametern använder du samma filnamn i anropet till terraform apply .
  • Om du inte använder parametern -out anropar du helt enkelt terraform apply utan parametrar.

7. Verifiera resultaten

  1. I kommandots terraform apply utdata ser du värden för följande:

    • FQDN för virtuell dator
    • Jumpbox FQDN
    • IP-adress för Jumpbox

  2. Bläddra till URL:en för den virtuella datorn för att bekräfta en standardsida med texten Välkommen till nginx!.

  3. Använd SSH för att ansluta till den virtuella jumpbox-datorn med hjälp av det användarnamn som definierats i variabelfilen och lösenordet som du angav när du körde terraform apply . Exempel: ssh azureuser@<ip_address>.

8. Rensa resurser

Ta bort VM-skalningsuppsättning

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

  1. Kör terraform-planen och ange 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 -out valfria parametern kan du ange en utdatafil för planen. Med -out parametern ser du till att den plan som du granskade är exakt det som tillämpas.
    • Mer information om att bevara körningsplaner och säkerhet finns i säkerhetsvarningsavsnittet.

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

    terraform apply main.destroy.tfplan

Ta bort Packer-avbildning och resursgrupp

Kör az group delete för att ta bort resursgruppen som innehåller Packer-avbildningen. Packer-avbildningen tas också bort.

az group delete --name myPackerImages --yes

Felsöka Terraform på Azure

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

Nästa steg

Läs mer om hur du använder Terraform i Azure