Szybki start: tworzenie maszyny wirtualnej z systemem Linux przy użyciu narzędzia Terraform

Dotyczy: ✔️ maszyny wirtualne z systemem Linux

Artykuł przetestowany z następującymi wersjami dostawcy programu Terraform i programu Terraform:

W tym artykule pokazano, jak utworzyć kompletne środowisko systemu Linux i zasoby pomocnicze za pomocą narzędzia Terraform. Te zasoby obejmują sieć wirtualną, podsieć, publiczny adres IP i inne.

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.

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

• Utwórz losową wartość dla nazwy grupy zasobów platformy Azure przy użyciu random_pet.
• Utwórz grupę zasobów platformy Azure przy użyciu azurerm_resource_group.
• Utwórz sieć wirtualną przy użyciu azurerm_virtual_network.
• Utwórz podsieć przy użyciu azurerm_subnet.
• Utwórz publiczny adres IP przy użyciu azurerm_public_ip.
• Utwórz sieciową grupę zabezpieczeń przy użyciu azurerm_network_security_group.
• Utwórz interfejs sieciowy przy użyciu azurerm_network_interface.
• Utwórz skojarzenie między sieciową grupą zabezpieczeń a interfejsem sieciowym przy użyciu azurerm_network_interface_security_group_association.
• Wygeneruj losową wartość unikatowej nazwy konta magazynu przy użyciu random_id.
• Utwórz konto magazynu na potrzeby diagnostyki rozruchu przy użyciu azurerm_storage_account.
• Tworzenie maszyny wirtualnej z systemem Linux przy użyciu azurerm_linux_virtual_machine
• Utwórz azapi_resource zasobu AzAPI.
• Utwórz zasób AzAPI, aby wygenerować parę kluczy SSH przy użyciu azapi_resource_action.

Wymagania wstępne

• Instalowanie i konfigurowanie narzędzia Terraform

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 = ">=0.12"
   
     required_providers {
       azapi = {
         source  = "azure/azapi"
         version = "~>1.5"
       }
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~>2.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" {
     location = var.resource_group_location
     name     = random_pet.rg_name.id
   }
   
   # Create virtual network
   resource "azurerm_virtual_network" "my_terraform_network" {
     name                = "myVnet"
     address_space       = ["10.0.0.0/16"]
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
   }
   
   # Create subnet
   resource "azurerm_subnet" "my_terraform_subnet" {
     name                 = "mySubnet"
     resource_group_name  = azurerm_resource_group.rg.name
     virtual_network_name = azurerm_virtual_network.my_terraform_network.name
     address_prefixes     = ["10.0.1.0/24"]
   }
   
   # Create public IPs
   resource "azurerm_public_ip" "my_terraform_public_ip" {
     name                = "myPublicIP"
     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" "my_terraform_nsg" {
     name                = "myNetworkSecurityGroup"
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
   
     security_rule {
       name                       = "SSH"
       priority                   = 1001
       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" "my_terraform_nic" {
     name                = "myNIC"
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
   
     ip_configuration {
       name                          = "my_nic_configuration"
       subnet_id                     = azurerm_subnet.my_terraform_subnet.id
       private_ip_address_allocation = "Dynamic"
       public_ip_address_id          = azurerm_public_ip.my_terraform_public_ip.id
     }
   }
   
   # Connect the security group to the network interface
   resource "azurerm_network_interface_security_group_association" "example" {
     network_interface_id      = azurerm_network_interface.my_terraform_nic.id
     network_security_group_id = azurerm_network_security_group.my_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" "my_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 virtual machine
   resource "azurerm_linux_virtual_machine" "my_terraform_vm" {
     name                  = "myVM"
     location              = azurerm_resource_group.rg.location
     resource_group_name   = azurerm_resource_group.rg.name
     network_interface_ids = [azurerm_network_interface.my_terraform_nic.id]
     size                  = "Standard_DS1_v2"
   
     os_disk {
       name                 = "myOsDisk"
       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  = "hostname"
     admin_username = var.username
   
     admin_ssh_key {
       username   = var.username
       public_key = jsondecode(azapi_resource_action.ssh_public_key_gen.output).publicKey
     }
   
     boot_diagnostics {
       storage_account_uri = azurerm_storage_account.my_storage_account.primary_blob_endpoint
     }
   }
   

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

   variable "resource_group_location" {
     type        = string
     default     = "eastus"
     description = "Location of the resource group."
   }
   
   variable "resource_group_name_prefix" {
     type        = string
     default     = "rg"
     description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
   }
   
   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 "public_ip_address" {
     value = azurerm_linux_virtual_machine.my_terraform_vm.public_ip_address
   }
   

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

Interfejs wiersza polecenia platformy Azure

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
   

Azure PowerShell

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

   $resource_group_name=$(terraform output -raw resource_group_name)
   

2. Uruchom polecenie Get-AzVm , aby wyświetlić nazwy wszystkich maszyn wirtualnych w grupie zasobów.

   Get-AzVm -ResourceGroupName $resource_group_name
   

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

W tym przewodniku Szybki start wdrożono prostą maszynę wirtualną przy użyciu narzędzia Terraform. Aby dowiedzieć się więcej o maszynach wirtualnych platformy Azure, przejdź do samouczka dla maszyn wirtualnych z systemem Linux.

Samouczki dla maszyny wirtualnej platformy Azure z systemem Linux