Tworzenie zestawu skalowania maszyn wirtualnych platformy Azure przy użyciu narzędzia 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 skalowania maszyn wirtualnych w witrynie Azure Portal.

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

• Konfigurowanie wdrożenia narzędzia Terraform
• Używanie zmiennych i danych wyjściowych dla wdrożenia programu Terraform
• Tworzenie i wdrażanie infrastruktury sieci
• Tworzenie i wdrażanie zestawu skalowania maszyn wirtualnych i dołączanie go do sieci
• Tworzenie i wdrażanie rampy w celu nawiązywania połączeń z maszynami wirtualnymi za pośrednictwem protokołu SSH

1. Konfigurowanie środowiska

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

• Skonfiguruj narzędzie Terraform: jeśli jeszcze tego nie zrobiono, skonfiguruj program Terraform przy użyciu jednej z następujących opcji:

  • Konfigurowanie narzędzia Terraform w usłudze Azure Cloud Shell przy użyciu powłoki Bash
  • Konfigurowanie programu Terraform w usłudze Azure Cloud Shell przy użyciu programu PowerShell
  • Konfigurowanie programu Terraform w systemie Windows przy użyciu powłoki Bash
  • Konfigurowanie programu Terraform w systemie Windows przy użyciu programu PowerShell

• Tworzenie pary kluczy SSH: aby uzyskać więcej informacji, zobacz How to create and use an SSH public and private key pair for Linux VMs in Azure (Jak utworzyć parę kluczy publicznych i prywatnych SSH dla maszyn wirtualnych z systemem Linux na platformie Azure).

2. 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 = "~>2.0"
       }
     }
   }
   
   provider "azurerm" {
     features {
       resource_group {
         prevent_deletion_if_contains_resources = false
       }
     }
   }
   
   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_ids       = [azurerm_lb_backend_address_pool.bpepool.id]
     frontend_ip_configuration_name = "PublicIPAddress"
     probe_id                       = azurerm_lb_probe.vmss.id
   }
   
   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 {
       publisher = "Canonical"
       offer     = "UbuntuServer"
       sku       = "16.04-LTS"
       version   = "latest"
     }
   
     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
       custom_data          = file("web.conf")
     }
   
     os_profile_linux_config {
       disable_password_authentication = false
     }
   
     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 = false
     }
   
     tags = var.tags
   }
   

3. Utwórz plik o nazwie variables.tf zawierający zmienne projektu i wstaw następujący kod:

   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"
     default     = "ChangeMe123!"
     sensitive   = true
   }
   

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
   }
   

5. Utwórz plik o nazwie web.conf i wstaw następujący kod:

   #cloud-config
   packages:
    - nginx
   

3. Inicjowanie programu 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.

4. Tworzenie planu wykonywania 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.

5. Stosowanie planu wykonywania programu 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.

6. Sprawdź wyniki

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

   • Nazwa FQDN maszyny wirtualnej
   • Nazwa FQDN serwera przesiadkowego
   • Adres IP serwera przesiadkowego

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ą serwera przesiadkowego przy użyciu nazwy użytkownika zdefiniowanej w pliku zmiennych i hasła określonego podczas uruchamiania terraform applypolecenia . Na przykład: ssh azureuser@<ip_address>.

7. 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.

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

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