Szybki start: tworzenie klastra maszyn wirtualnych z systemem Linux na platformie Azure przy użyciu narzędzia Terraform

Dotyczy: ✔️ maszyny wirtualne z systemem Linux

W tym artykule pokazano, jak utworzyć klaster maszyn wirtualnych z systemem Linux (zawierający dwa wystąpienia maszyn wirtualnych z systemem Linux) na platformie Azure przy użyciu narzędzia Terraform.

W tym artykule omówiono sposób wykonywania następujących zadań:

Wymagania wstępne

Implementowanie kodu narzędzia Terraform

Uwaga

Przykładowy kod tego artykułu znajduje się w repozytorium GitHub programu Azure Terraform. Możesz wyświetlić plik dziennika zawierający wyniki testu z bieżących i poprzednich wersji programu Terraform.

Zobacz więcej artykułów i przykładowego kodu pokazującego, jak zarządzać zasobami platformy Azure za pomocą narzędzia 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 providers.tf i wstaw następujący kod:

    terraform {
      required_version = ">=1.0"
      required_providers {
        azapi = {
          source  = "azure/azapi"
          version = "~>1.5"
        }
        azurerm = {
          source  = "hashicorp/azurerm"
          version = "~>3.0"
        }
        random = {
          source  = "hashicorp/random"
          version = "~>3.0"
        }
      }
    }
    provider "azurerm" {
      features {}
    }
    
  3. Utwórz plik o nazwie ssh.tf i wstaw następujący kod:

    resource "random_pet" "ssh_key_name" {
      prefix    = "ssh"
      separator = ""
    }
    
    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 "azapi_resource" "ssh_public_key" {
      type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
      name      = random_pet.ssh_key_name.id
      location  = azurerm_resource_group.rg.location
      parent_id = azurerm_resource_group.rg.id
    }
    
    output "key_data" {
      value = jsondecode(azapi_resource_action.ssh_public_key_gen.output).publicKey
    }
    
  4. Utwórz plik o nazwie main.tf i wstaw następujący kod:

    resource "random_pet" "rg_name" {
      prefix = var.resource_group_name_prefix
    }
    
    resource "azurerm_resource_group" "rg" {
      name     = random_pet.rg_name.id
      location = var.resource_group_location
    }
    
    resource "random_pet" "azurerm_virtual_network_name" {
      prefix = "vnet"
    }
    
    resource "azurerm_virtual_network" "test" {
      name                = random_pet.azurerm_virtual_network_name.id
      address_space       = ["10.0.0.0/16"]
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
    }
    
    resource "random_pet" "azurerm_subnet_name" {
      prefix = "sub"
    }
    
    resource "azurerm_subnet" "test" {
      name                 = random_pet.azurerm_subnet_name.id
      resource_group_name  = azurerm_resource_group.rg.name
      virtual_network_name = azurerm_virtual_network.test.name
      address_prefixes     = ["10.0.2.0/24"]
    }
    
    resource "azurerm_public_ip" "test" {
      name                = "publicIPForLB"
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
      allocation_method   = "Static"
    }
    
    resource "azurerm_lb" "test" {
      name                = "loadBalancer"
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
    
      frontend_ip_configuration {
        name                 = "publicIPAddress"
        public_ip_address_id = azurerm_public_ip.test.id
      }
    }
    
    resource "azurerm_lb_backend_address_pool" "test" {
      loadbalancer_id = azurerm_lb.test.id
      name            = "BackEndAddressPool"
    }
    
    resource "azurerm_network_interface" "test" {
      count               = 2
      name                = "acctni${count.index}"
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
    
      ip_configuration {
        name                          = "testConfiguration"
        subnet_id                     = azurerm_subnet.test.id
        private_ip_address_allocation = "Dynamic"
      }
    }
    
    resource "azurerm_availability_set" "avset" {
      name                         = "avset"
      location                     = azurerm_resource_group.rg.location
      resource_group_name          = azurerm_resource_group.rg.name
      platform_fault_domain_count  = 2
      platform_update_domain_count = 2
      managed                      = true
    }
    
    resource "random_pet" "azurerm_linux_virtual_machine_name" {
      prefix = "vm"
    }
    
    resource "azurerm_linux_virtual_machine" "test" {
      count                 = 2
      name                  = "${random_pet.azurerm_linux_virtual_machine_name.id}${count.index}"
      location              = azurerm_resource_group.rg.location
      availability_set_id   = azurerm_availability_set.avset.id
      resource_group_name   = azurerm_resource_group.rg.name
      network_interface_ids = [azurerm_network_interface.test[count.index].id]
      size                  = "Standard_DS1_v2"
    
      # Uncomment this line to delete the OS disk automatically when deleting the VM
      # delete_os_disk_on_termination = true
    
      # Uncomment this line to delete the data disks automatically when deleting the VM
      # delete_data_disks_on_termination = true
    
      source_image_reference {
        publisher = "Canonical"
        offer     = "UbuntuServer"
        sku       = "16.04-LTS"
        version   = "latest"
      }
    
      admin_ssh_key {
        username   = var.username
        public_key = jsondecode(azapi_resource_action.ssh_public_key_gen.output).publicKey
      }
    
      os_disk {
        caching              = "ReadWrite"
        storage_account_type = "Standard_LRS"
        name                 = "myosdisk${count.index}"
      }
    
      computer_name  = "hostname"
      admin_username = var.username
    }
    
    resource "azurerm_managed_disk" "test" {
      count                = 2
      name                 = "datadisk_existing_${count.index}"
      location             = azurerm_resource_group.rg.location
      resource_group_name  = azurerm_resource_group.rg.name
      storage_account_type = "Standard_LRS"
      create_option        = "Empty"
      disk_size_gb         = "1024"
    }
    
    resource "azurerm_virtual_machine_data_disk_attachment" "test" {
      count              = 2
      managed_disk_id    = azurerm_managed_disk.test[count.index].id
      virtual_machine_id = azurerm_linux_virtual_machine.test[count.index].id
      lun                = "10"
      caching            = "ReadWrite"
    }
    
  5. Utwórz plik o nazwie variables.tf i wstaw następujący kod:

    variable "resource_group_location" {
      type        = string
      description = "Location for all resources."
      default     = "eastus"
    }
    
    variable "resource_group_name_prefix" {
      type        = string
      description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
      default     = "rg"
    }
    
    variable "username" {
      type        = string
      description = "The username for the local account that will be created on the new VM."
      default     = "azureadmin"
    }
    
  6. Utwórz plik o nazwie outputs.tf i wstaw następujący kod:

    output "resource_group_name" {
      value = azurerm_resource_group.rg.name
    }
    
    output "virtual_network_name" {
      value = azurerm_virtual_network.test.name
    }
    
    output "subnet_name" {
      value = azurerm_subnet.test.name
    }
    
    output "linux_virtual_machine_names" {
      value = [for s in azurerm_linux_virtual_machine.test : s.name[*]]
    }
    

Inicjowanie narzędzia Terraform

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

terraform init -upgrade

Kluczowe punkty:

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

Tworzenie planu wykonania programu Terraform

Uruchom plan terraform, 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 akcje są niezbędne do utworzenia konfiguracji określonej w plikach konfiguracji. Ten wzorzec umożliwia sprawdzenie, czy plan wykonania jest zgodny z oczekiwaniami przed wprowadzeniem jakichkolwiek zmian w rzeczywistych zasobach.
  • Opcjonalny -out parametr umożliwia określenie pliku wyjściowego dla planu. Użycie parametru -out gwarantuje, że sprawdzony plan jest dokładnie tym, co jest stosowane.
  • Aby dowiedzieć się więcej na temat utrwalania planów wykonywania i zabezpieczeń, zobacz sekcję ostrzeżenie o zabezpieczeniach.

Stosowanie planu wykonywania narzędzia Terraform

Uruchom narzędzie terraform, aby zastosować plan wykonania do infrastruktury chmury.

terraform apply main.tfplan

Kluczowe punkty:

  • Przykładowe terraform apply polecenie zakłada, że wcześniej uruchomiono terraform plan -out main.tfplanpolecenie .
  • Jeśli określono inną nazwę pliku parametru -out , użyj tej samej nazwy pliku w wywołaniu metody terraform apply.
  • Jeśli parametr nie został użyty, wywołaj metodę -outterraform apply bez żadnych parametrów.

Informacje o kosztach nie są prezentowane podczas procesu tworzenia maszyny wirtualnej dla programu Terraform, tak jak w witrynie Azure Portal. Jeśli chcesz dowiedzieć się więcej na temat sposobu działania kosztów dla maszyn wirtualnych, zobacz stronę Przegląd optymalizacji kosztów.

Weryfikowanie wyników

  1. Pobierz nazwę grupy zasobów platformy Azure.

    resource_group_name=$(terraform output -raw resource_group_name)
    
  2. Uruchom polecenie az vm list z zapytaniem JMESPath , aby wyświetlić nazwy maszyn wirtualnych utworzonych w grupie zasobów.

    az vm list \
      --resource-group $resource_group_name \
      --query "[].{\"VM Name\":name}" -o table
    

Czyszczenie zasobów

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

  1. Uruchom plan terraform 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 akcje są niezbędne do utworzenia konfiguracji określonej w plikach konfiguracji. Ten wzorzec umożliwia sprawdzenie, czy plan wykonania jest zgodny z oczekiwaniami przed wprowadzeniem jakichkolwiek zmian w rzeczywistych zasobach.
    • Opcjonalny -out parametr umożliwia określenie pliku wyjściowego dla planu. Użycie parametru -out gwarantuje, że sprawdzony plan jest dokładnie tym, co jest stosowane.
    • Aby dowiedzieć się więcej na temat utrwalania planów wykonywania i zabezpieczeń, zobacz sekcję ostrzeżenie o zabezpieczeniach.
  2. Uruchom narzędzie terraform zastosuj, aby zastosować plan wykonania.

    terraform apply main.destroy.tfplan
    

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

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

Następne kroki