Udostępnij za pośrednictwem

Tworzenie zestawu skalowania maszyn wirtualnych na platformie Azure z niestandardowego obrazu Packer za pomocą Terraform.

Narzędzie Terraform umożliwia definiowanie, wyświetlanie wersji zapoznawczej i wdrażanie infrastruktury chmury. Za pomocą narzędzia Terraform tworzysz pliki konfiguracji przy użyciu składni HCL. Składnia listy HCL umożliwia określenie dostawcy chmury — takiego jak platforma Azure — oraz elementów tworzących infrastrukturę chmury. Po utworzeniu plików konfiguracji utworzysz plan wykonywania , który umożliwia wyświetlenie podglądu zmian infrastruktury przed ich wdrożeniem. Po zweryfikowaniu zmian należy zastosować plan wykonywania w celu wdrożenia infrastruktury.

Zestawy skalowania maszyn wirtualnych platformy Azure umożliwiają konfigurowanie identycznych maszyn wirtualnych. Liczba wystąpień maszyn wirtualnych może być dostosowywana na podstawie zapotrzebowania lub harmonogramu. Aby uzyskać więcej informacji, zobacz Automatyczne skalowanie zestawu maszyn wirtualnych w portalu Azure.

W tym artykule dowiesz się, jak:

  • Konfigurowanie wdrożenia narzędzia Terraform
  • Używanie zmiennych i danych wyjściowych dla wdrożenia programu Terraform
  • Tworzenie i wdrażanie infrastruktury sieciowej
  • Tworzenie niestandardowego obrazu maszyny wirtualnej przy użyciu narzędzia Packer
  • Tworzenie i wdrażanie zestawu skalowania maszyn wirtualnych przy użyciu niestandardowego obrazu
  • Tworzenie i wdrażanie jumpboxa

1. Konfigurowanie środowiska

  • Subskrypcja platformy Azure: jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto .

2. Tworzenie obrazu programu Packer

  1. Zainstaluj program Packer.

    Kluczowe punkty:

    • Aby potwierdzić, że masz dostęp do pliku wykonywalnego narzędzia Packer, uruchom następujące polecenie: packer -v.
    • W zależności od środowiska może być konieczne ustawienie ścieżki i ponowne otwarcie wiersza polecenia.

  2. Uruchom az group create, aby utworzyć grupę zasobów do przechowywania obrazu narzędzia Packer.

    az group create -n myPackerImages -l eastus

  3. Uruchom az ad sp create-for-rbac, aby umożliwić Packerowi uwierzytelnianie w Azure za pomocą konta usługi.

    az ad sp create-for-rbac --role Contributor --scopes /subscriptions/<subscription_id> --query "{ client_id: appId, client_secret: password, tenant_id: tenant }"

    Kluczowe punkty:

    • Zanotuj wartości wyjściowe (appId, client_secret, tenant_id).

  4. Uruchom az account show, aby wyświetlić bieżącą subskrypcję platformy Azure.

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

  5. Utwórz plik zmiennych szablonu usługi Packer o nazwie ubuntu.pkr.hcl i wstaw następujący kod. Zaktualizuj wyróżnione wiersze przy użyciu informacji o jednostce usługi i subskrypcji platformy Azure.

    packer {
  required_plugins {
    azure = {
      source  = "github.com/hashicorp/azure"
      version = "~> 2"
    }
  }
}

variable client_id {
  type    = string
  default = null
}
variable client_secret {
  type    = string
  default = null
}

variable subscription_id {
  type    = string
  default = null
}

variable tenant_id {
  type    = string
  default = null
}

variable location {
  default = "eastus"
}

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

variable "oidc_request_url" {
  default = null
}

variable "oidc_request_token" {
  default = null
}

# arm builder
source "azure-arm" "builder" {
  client_id                         = var.client_id
  client_secret                     = var.client_secret
  image_offer                       = "UbuntuServer"
  image_publisher                   = "canonical"
  image_sku                         = "16.04-LTS"
  location                          = var.location
  managed_image_name                = "myPackerImage"
  managed_image_resource_group_name = var.image_resource_group_name
  os_type                           = "Linux"
  subscription_id                   = var.subscription_id
  tenant_id                         = var.tenant_id
  oidc_request_url                  = var.oidc_request_url
  oidc_request_token                = var.oidc_request_token
  vm_size                           = "Standard_DS2_v2"
  azure_tags = {
    "dept" : "Engineering",
    "task" : "Image deployment",
  }
}

build {
  sources = ["source.azure-arm.builder"]
  provisioner "shell" {
    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",
    ]
  }
}

    Kluczowe punkty:

    • Ustaw pola client_id, client_secret i tenant_id na odpowiednie wartości z głównej jednostki usługi.
    • Ustaw pole subscription_id na identyfikator subskrypcji platformy Azure.

  6. Skompiluj obraz Packer.

    packer build ubuntu.json

3. Implementowanie kodu programu Terraform

  1. Utwórz katalog, w którym chcesz przetestować przykładowy kod narzędzia Terraform i ustawić go jako bieżący katalog.

  2. Utwórz plik o nazwie main.tf i wstaw następujący kod:

    terraform {

  required_version = ">=0.12"

  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.0"
    }
    azapi = {
      source  = "Azure/azapi"
      version = "~> 1.0"
    }
    local = {
      source  = "hashicorp/local"
      version = "2.4.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "3.5.1"
    }
    tls = {
      source  = "hashicorp/tls"
      version = "4.0.4"
    }
  }
}

provider "azurerm" {
  features {
    resource_group {
      prevent_deletion_if_contains_resources = false
    }
  }
}

resource "random_pet" "id" {}

resource "azurerm_resource_group" "vmss" {
  name     = coalesce(var.resource_group_name, "201-vmss-packer-jumpbox-${random_pet.id.id}")
  location = var.location
  tags     = var.tags
}

resource "random_string" "fqdn" {
  length  = 6
  special = false
  upper   = false
  numeric = 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" {
  loadbalancer_id = azurerm_lb.vmss.id
  name            = "ssh-running-probe"
  port            = var.application_port
}

resource "azurerm_lb_rule" "lbnatrule" {
  loadbalancer_id                = azurerm_lb.vmss.id
  name                           = "http"
  protocol                       = "Tcp"
  frontend_port                  = var.application_port
  backend_port                   = var.application_port
  backend_address_pool_ids       = [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 "azapi_resource" "ssh_public_key" {
  type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  name      = random_pet.id.id
  location  = azurerm_resource_group.vmss.location
  parent_id = azurerm_resource_group.vmss.id
}

resource "azapi_resource_action" "ssh_public_key_gen" {
  type        = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  resource_id = azapi_resource.ssh_public_key.id
  action      = "generateKeyPair"
  method      = "POST"

  response_export_values = ["publicKey", "privateKey"]
}

resource "random_password" "password" {
  count  = var.admin_password == null ? 1 : 0
  length = 20
}

locals {
  admin_password = try(random_password.password[0].result, var.admin_password)
}

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       = local.admin_password
  }

  os_profile_linux_config {
    disable_password_authentication = true

    ssh_keys {
      path     = "/home/azureuser/.ssh/authorized_keys"
      key_data = azapi_resource_action.ssh_public_key_gen.output.publicKey
    }
  }

  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 = local.admin_password
  }

  os_profile_linux_config {
    disable_password_authentication = true

    ssh_keys {
      path     = "/home/azureuser/.ssh/authorized_keys"
      key_data = azapi_resource_action.ssh_public_key_gen.output.publicKey
    }
  }

  tags = var.tags
}

  3. Utwórz plik o nazwie variables.tf zawierający zmienne projektu i wstaw następujący 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     = null
}

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"
  default     = null
}

  4. Utwórz plik o nazwie output.tf , aby określić wartości wyświetlane przez program Terraform i wstawić następujący 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. Inicjowanie programu Terraform

Uruchom narzędzie terraform init, aby zainicjować wdrożenie narzędzia Terraform. Polecenie to pobiera dostawcę Azure wymaganego do zarządzania zasobami Azure.

terraform init -upgrade

Kluczowe punkty:

  • Parametr -upgrade uaktualnia niezbędne wtyczki dostawcy do najnowszej wersji, która jest zgodna z ograniczeniami wersji konfiguracji.

5. Tworzenie planu wykonywania programu Terraform

Uruchom terraform plan, aby utworzyć plan wykonania.

terraform plan -out main.tfplan

Kluczowe punkty:

  • Polecenie terraform plan tworzy plan wykonania, ale nie wykonuje go. Zamiast tego, określa, jakie działania są niezbędne do stworzenia konfiguracji określonej w plikach konfiguracyjnych. Ten wzorzec pozwala Ci zweryfikować, czy plan wykonania spełnia Twoje oczekiwania, zanim wprowadzisz jakiekolwiek zmiany do rzeczywistych zasobów.
  • Opcjonalny parametr -out pozwala określić plik wyjściowy dla planu. Użycie parametru -out zapewnia, że plan, który przejrzałeś, zostanie dokładnie zastosowany.

6. Stosowanie planu wykonywania programu Terraform

Uruchom terraform apply, aby zastosować plan wykonania do swojej infrastruktury chmurowej.

terraform apply main.tfplan

Kluczowe punkty:

  • Przykładowe polecenie terraform apply zakłada, że wcześniej uruchomiono polecenie terraform plan -out main.tfplan.
  • Jeśli podałeś inną nazwę pliku dla parametru -out, użyj tej samej nazwy pliku w wywołaniu terraform apply.
  • Jeśli nie użyłeś parametru -out, wywołaj terraform apply bez żadnych parametrów.

7. Sprawdź wyniki

  1. W danych wyjściowych terraform apply polecenia są widoczne następujące wartości:

    • Nazwa FQDN maszyny wirtualnej
    • Nazwa FQDN serwera dostępowego
    • Adres IP jumpboxa

  2. Przejdź do adresu URL maszyny wirtualnej, aby potwierdzić domyślną stronę z tekstem Zapraszamy do serwera nginx!.

  3. Użyj protokołu SSH, aby nawiązać połączenie z maszyną wirtualną jump box, korzystając z nazwy użytkownika zdefiniowanej w pliku zmiennych i hasła określonego podczas uruchamiania terraform applypolecenia. Na przykład: ssh azureuser@<ip_address>.

8. Posprzątaj zasoby

Usuń zestaw skalowania maszyn wirtualnych

Jeśli zasoby utworzone za pomocą narzędzia Terraform nie są już potrzebne, wykonaj następujące czynności:

  1. Uruchom terraform plan i określ flagę destroy.

    terraform plan -destroy -out main.destroy.tfplan

    Kluczowe punkty:

    • Polecenie terraform plan tworzy plan wykonania, ale nie wykonuje go. Zamiast tego, określa, jakie działania są niezbędne do stworzenia konfiguracji określonej w plikach konfiguracyjnych. Ten wzorzec pozwala Ci zweryfikować, czy plan wykonania spełnia Twoje oczekiwania, zanim wprowadzisz jakiekolwiek zmiany do rzeczywistych zasobów.
    • Opcjonalny parametr -out pozwala określić plik wyjściowy dla planu. Użycie parametru -out zapewnia, że plan, który przejrzałeś, zostanie dokładnie zastosowany.

  2. Uruchom terraform apply, aby zastosować plan wykonania.

    terraform apply main.destroy.tfplan

Usuwanie obrazu i grupy zasobów programu Packer

Uruchom az group delete, aby usunąć grupę zasobów używaną do przechowywania obrazu Packer. Obraz Packer jest również usuwany.

az group delete --name myPackerImages --yes

Rozwiązywanie problemów z programem Terraform na platformie Azure

Rozwiązywanie typowych problemów podczas korzystania z narzędzia Terraform na platformie Azure

Dalsze kroki

Dowiedz się więcej o korzystaniu z programu Terraform na platformie Azure