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

Dotyczy: ✔️ Maszyny wirtualne z systemem Linux

Artykuł przetestowany przy użyciu następujących wersji dostawcy programu Terraform i programu Terraform:

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

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

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

  • Tworzenie sieci wirtualnej
  • Tworzenie podsieci
  • Tworzenie publicznego adresu IP
  • Tworzenie sieciowej grupy zabezpieczeń i reguły ruchu przychodzącego SSH
  • Tworzenie wirtualnej karty sieciowej
  • Łączenie sieciowej grupy zabezpieczeń z interfejsem sieciowym
  • Tworzenie konta magazynu na potrzeby diagnostyki rozruchu
  • Tworzenie klucza SSH
  • Tworzenie maszyny wirtualnej
  • Nawiązywanie połączenia z maszyną wirtualną za pomocą protokołu SSH

Wymagania wstępne

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

Implementowanie kodu 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 {
        azurerm = {
          source  = "hashicorp/azurerm"
          version = "~>2.0"
        }
        random = {
          source  = "hashicorp/random"
          version = "~>3.0"
        }
        tls = {
          source = "hashicorp/tls"
          version = "~>4.0"
        }
      }
    }
    
    provider "azurerm" {
      features {}
    }
    
  3. 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 (and display) an SSH key
    resource "tls_private_key" "example_ssh" {
      algorithm = "RSA"
      rsa_bits  = 4096
    }
    
    # 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     = "UbuntuServer"
        sku       = "18.04-LTS"
        version   = "latest"
      }
    
      computer_name                   = "myvm"
      admin_username                  = "azureuser"
      disable_password_authentication = true
    
      admin_ssh_key {
        username   = "azureuser"
        public_key = tls_private_key.example_ssh.public_key_openssh
      }
    
      boot_diagnostics {
        storage_account_uri = azurerm_storage_account.my_storage_account.primary_blob_endpoint
      }
    }
    
  4. Utwórz plik o nazwie variables.tf i wstaw następujący kod:

    variable "resource_group_location" {
      default     = "eastus"
      description = "Location of the resource group."
    }
    
    variable "resource_group_name_prefix" {
      default     = "rg"
      description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
    }
    
  5. 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
    }
    
    output "tls_private_key" {
      value     = tls_private_key.example_ssh.private_key_pem
      sensitive = true
    }
    

Inicjowanie narzędzia Terraform

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

terraform init

Tworzenie planu wykonania programu Terraform

Uruchom plan terraform , aby utworzyć plan wykonania.

terraform plan -out main.tfplan

Kluczowe kwestie:

  • 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 zapewnia, że przeglądany 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 wykonania programu Terraform

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

terraform apply main.tfplan

Kluczowe kwestie:

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

Weryfikowanie wyników

Aby nawiązać połączenie z maszyną wirtualną za pomocą protokołu SSH, wykonaj następujące czynności:

  1. Uruchom dane wyjściowe narzędzia terraform , aby pobrać klucz prywatny SSH i zapisać go w pliku.

    terraform output -raw tls_private_key > id_rsa
    
  2. Uruchom dane wyjściowe narzędzia terraform , aby uzyskać publiczny adres IP maszyny wirtualnej.

    terraform output public_ip_address
    
  3. Nawiązywanie połączenia z maszyną wirtualną za pomocą protokołu SSH.

    ssh -i id_rsa azureuser@<public_ip_address>
    

    Kluczowe kwestie:

    • W zależności od uprawnień środowiska podczas próby użycia protokołu SSH na maszynie wirtualnej przy użyciu id_rsa pliku klucza może wystąpić błąd. Jeśli zostanie wyświetlony komunikat o błędzie informujący, że plik klucza prywatnego jest niechroniony i nie można go użyć, spróbuj uruchomić następujące polecenie: chmod 600 id_rsa, co spowoduje ograniczenie dostępu do odczytu i zapisu do właściciela pliku.

Czyszczenie zasobów

Jeśli zasoby utworzone za pomocą programu 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 kwestie:

    • 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 zapewnia, że przeglądany 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 apply , 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 programu 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.