Aprowizowanie maszyny wirtualnej z systemem Linux przy użyciu narzędzia Terraform
Narzędzie Terraform implementuje i kontroluje infrastrukturę docelową przy użyciu plików konfiguracji, które opisują żądany stan jego składników. Podstawowy format plików i ich składni ogólnej — wyrażony w języku HCL (Hashicorp Configuration Language) — są takie same niezależnie od wyboru chmury. Jednak poszczególne opisy składników są zależne od chmury określone przez odpowiedniego dostawcę programu Terraform.
Chociaż istnieje kilka dostawców programu Terraform, którzy obsługują zarządzanie infrastrukturą platformy Azure, moduł AzureRM ma szczególne znaczenie. Dostawca modułu AzureRM ułatwia aprowizowanie i konfigurowanie typowych zasobów IaaS platformy Azure, takich jak maszyny wirtualne, konta magazynu i interfejsy sieciowe. Istnieją również dodatkowi dostawcy, którzy nie są specyficzni dla chmury, którzy mogą chcieć dołączyć do wdrożeń. Obejmują one dostawcę losowego, który pomaga uniknąć konfliktów nazewnictwa zasobów przez generowanie ciągów znaków pseudolosowych; oraz dostawca tls, który upraszcza zarządzanie kluczami asymetrycznymi na potrzeby zabezpieczania uwierzytelniania systemu Linux.
Narzędzie Terraform jest dostępne jako pojedynczy plik binarny, który można pobrać z witryny internetowej hashicorp. Ten plik binarny implementuje interfejs wiersza polecenia programu Terraform, który można następnie wywołać z sesji powłoki w celu zainicjowania plików konfiguracji programu Terraform i przetwarzania. Interfejs wiersza polecenia programu Terraform można używać z dowolnej powłoki, która obsługuje interfejs wiersza polecenia platformy Azure.
Uwaga
W przypadku korzystania z usługi Azure Cloud Shell upewnij się, że uruchomiono bieżącą wersję programu Terraform, postępując zgodnie z instrukcjami podanymi w temacie Konfigurowanie programu Terraform w usłudze Azure Cloud Shell przy użyciu powłoki Bash.
Wdrażanie maszyny wirtualnej z systemem Linux przy użyciu narzędzia Terraform
Narzędzie Terraform umożliwia definiowanie, wyświetlanie podglądu i wdrażanie zasobów w infrastrukturze chmury specyficznej dla dostawcy. Proces aprowizacji rozpoczyna się od utworzenia plików konfiguracji korzystających ze składni HCL, która umożliwia wyznaczenie docelowego środowiska chmury — takiego jak platforma Azure — oraz zasobów tworzących infrastrukturę chmury. Po wdrożeniu wszystkich odpowiednich plików konfiguracji (zazwyczaj w tej samej lokalizacji systemu plików) można wygenerować plan wykonania, który umożliwia wyświetlenie podglądu wynikowych zmian infrastruktury przed rzeczywistym wdrożeniem. Wymaga to zainicjowania programu Terraform w celu pobrania modułów dostawcy niezbędnych do zaimplementowania zasobów w chmurze. Po zweryfikowaniu zmian można zastosować plan wykonywania w celu wdrożenia infrastruktury.
Uwaga
Generowanie planu wykonania jest opcjonalne, ale zalecamy wykonanie tej czynności, ponieważ pozwala zidentyfikować wpływ planowanego wdrożenia bez wpływu na środowisko docelowe. Podczas interaktywnego wdrażania zasobów platformy Azure program Terraform obsługuje uwierzytelnianie interfejsu wiersza polecenia platformy Azure w sposób niewidoczny, ponownie używając poświadczeń w celu uzyskania dostępu do docelowej subskrypcji platformy Azure.
Proces aprowizacji maszyny wirtualnej platformy Azure z systemem Linux przy użyciu narzędzia Terraform zwykle obejmuje następującą sekwencję kroków wysokiego poziomu:
- Zidentyfikuj odpowiedni obraz maszyny wirtualnej.
- Zidentyfikuj odpowiedni rozmiar maszyny wirtualnej.
- Utwórz pliki konfiguracji definiujące zasób maszyny wirtualnej platformy Azure z jego zależnościami.
- Zainicjuj narzędzie Terraform.
- Wygeneruj plan wykonywania programu Terraform.
- Zainicjuj wdrożenie narzędzia Terraform.
Aby zidentyfikować odpowiedni obraz i rozmiar maszyny wirtualnej, wykonaj kroki opisane w lekcji 4 tego modułu. Ta lekcja koncentruje się na zadaniach specyficznych dla programu Terraform.
Tworzenie plików konfiguracji
Uwaga
Nazwy plików wybrane dla plików programu Terraform są dowolne, chociaż dobrym rozwiązaniem jest wybranie nazwy odzwierciedlającej zawartość lub przeznaczenie pliku. Należy użyć pliku ".tf" dla rozszerzenia pliku.
Aby wdrożyć maszynę wirtualną z systemem Linux przy użyciu programu Terraform, należy rozpocząć od utworzenia katalogu do hostowania plików konfiguracji. Następnie utwórz plik o nazwie providers.tf , który wymusza wersję programu Terraform i wyznacza dostawców, których będziesz polegać podczas definiowania zasobów uwzględnionych we wdrożeniu. Ten plik powinien zawierać zawartość wyświetlaną w następującym fragmencie kodu:
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 {}
}
W tym samym katalogu utwórz plik o nazwie main.tf przy użyciu następującego kodu, który definiuje konfigurację maszyny wirtualnej platformy Azure i jej zależności:
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" "terraform_network" {
name = "lnx-tf-vnet"
address_space = ["10.1.0.0/16"]
location = azurerm_resource_group.rg.location
resource_group_name = azurerm_resource_group.rg.name
}
# Create subnet
resource "azurerm_subnet" "terraform_subnet" {
name = "subnet0"
resource_group_name = azurerm_resource_group.rg.name
virtual_network_name = azurerm_virtual_network.terraform_network.name
address_prefixes = ["10.1.0.0/24"]
}
# Create public IPs
resource "azurerm_public_ip" "terraform_public_ip" {
name = "lnx-tf-pip"
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" "terraform_nsg" {
name = "lnx-tf-nsg"
location = azurerm_resource_group.rg.location
resource_group_name = azurerm_resource_group.rg.name
security_rule {
name = "ssh"
priority = 300
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" "terraform_nic" {
name = "lnx-tf-nic"
location = azurerm_resource_group.rg.location
resource_group_name = azurerm_resource_group.rg.name
ip_configuration {
name = "nic_configuration"
subnet_id = azurerm_subnet.terraform_subnet.id
private_ip_address_allocation = "Dynamic"
public_ip_address_id = azurerm_public_ip.terraform_public_ip.id
}
}
# Connect the security group to the network interface
resource "azurerm_network_interface_security_group_association" "lnx-tf-nic-nsg" {
network_interface_id = azurerm_network_interface.terraform_nic.id
network_security_group_id = azurerm_network_security_group.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" "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" "lnx-tf-ssh" {
algorithm = "RSA"
rsa_bits = 4096
}
# Create virtual machine
resource "azurerm_linux_virtual_machine" "lnx-tf-vm" {
name = "lnx-tf-vm"
location = azurerm_resource_group.rg.location
resource_group_name = azurerm_resource_group.rg.name
network_interface_ids = [azurerm_network_interface.terraform_nic.id]
size = "Standard_F4s"
os_disk {
name = "lnx-tf-vm-osdisk"
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 = "lnx-tf-vm"
admin_username = "azureuser"
disable_password_authentication = true
admin_ssh_key {
username = "azureuser"
public_key = tls_private_key.lnx-tf-ssh.public_key_openssh
}
boot_diagnostics {
storage_account_uri = azurerm_storage_account.storage_account.primary_blob_endpoint
}
}
W tym samym katalogu utwórz inny plik o nazwie variables.tf przy użyciu następującego kodu, który przypisuje wartość do zmiennych wyświetlanych w pliku main.tf :
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"
}
Na koniec utwórz plik o nazwie outputs.tf przy użyciu następującego kodu, który określa dane wyjściowe wyświetlane po pomyślnym wdrożeniu:
output "resource_group_name" {
value = azurerm_resource_group.rg.name
}
output "public_ip_address" {
value = azurerm_linux_virtual_machine.lnx-tf-vm.public_ip_address
}
output "tls_private_key" {
value = tls_private_key.lnx-tf-ssh.private_key_pem
sensitive = true
}
Inicjowanie narzędzia Terraform
Aby zainicjować wdrożenie programu Terraform, uruchom następujące polecenie w wierszu polecenia powłoki:
terraform init
To polecenie pobiera moduły platformy Azure niezbędne do aprowizowania zasobów platformy Azure i zarządzania nimi.
Generowanie planu wykonania
Po zainicjowaniu utwórz plan wykonania, uruchamiając plan terraform. Polecenie tworzy plan wykonania, ale nie uruchamia go. Zamiast tego określa, jakie akcje są niezbędne do utworzenia zasobów zdefiniowanych w plikach konfiguracji. Opcjonalny -out parametr umożliwia określenie pliku wyjściowego dla planu, do którego można się odwołać podczas rzeczywistego wdrożenia. Użycie tego pliku gwarantuje, że przeglądany plan jest zgodny z dokładnym wynikiem wdrożenia. Użyj następującego polecenia, aby wygenerować plan wykonania:
terraform plan -out <terraform_plan>.tfplan
Inicjowanie wdrożenia
Gdy wszystko będzie gotowe do zastosowania planu wykonania w środowisku platformy Azure, uruchom polecenie terraform apply, w tym nazwę pliku wygenerowanego w poprzednim kroku. Będziesz mieć kolejną szansę na przejrzenie oczekiwanego wyniku. Narzędzie Terraform monituje o kontynuowanie potwierdzenia, chociaż można wyeliminować monit, dodając -auto-approve przełącznik. Aby zainicjować wdrożenie, użyj następującego polecenia:
terraform apply <terraform_plan>.tfplan
Maszyna wirtualna platformy Azure wkrótce rozpocznie działanie, zazwyczaj w ciągu kilku minut. Dane terraform apply wyjściowe polecenia zawierają listę danych wyjściowych, ale narzędzie terraform zastąpi wartość tls_private_key etykietą wrażliwą<>:
Apply complete! Resources: 12 added, 0 changed, 0 destroyed.
Wyjść:
public_ip_address = "74.235.10.136"
resource_group_name = "rg-flexible-shark"
tls_private_key = <sensitive>
Aby użyć automatycznie wygenerowanego klucza prywatnego do uwierzytelniania połączenia SSH, zapisz go w pliku, a następnie ustaw uprawnienia pliku, aby upewnić się, że nie jest dostępny dla innych osób. Aby to osiągnąć, uruchom następujące polecenia:
terraform output -raw tls_private_key > id_rsa
chmod 600 id_rsa
Na tym etapie będzie można nawiązać połączenie z maszyną wirtualną platformy Azure, uruchamiając następujące polecenie (po zastąpieniu <symbolu zastępczego public_ip_address> adresem IP zidentyfikowanym w danych wyjściowych programu terraform wygenerowanych za pomocą zastosowania):
ssh -i id_rsa azureuser@<public_ip_address>