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

Artykuł
11/29/2022
Czas czytania: 6 min

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

Uwaga

Przykładowy kod w tym artykule znajduje się w repozytorium GitHub microsoft Terraform. Zobacz więcej artykułów i przykładowego kodu pokazującego, jak zarządzać zasobami platformy Azure za pomocą narzędzia Terraform

Wymagania wstępne

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

Instalowanie i konfigurowanie programu Terraform

Implementowanie kodu narzędzia Terraform

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

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 {}
}

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

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

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:

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
```
Uruchom dane wyjściowe narzędzia terraform , aby uzyskać publiczny adres IP maszyny wirtualnej.
```
terraform output public_ip_address
```
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:

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

Samouczki dla maszyny wirtualnej platformy Azure z systemem Linux