Een virtuele Linux-machine inrichten met behulp van Terraform
Terraform implementeert en beheert een doelinfrastructuur met behulp van configuratiebestanden die de gewenste status van de onderdelen beschrijven. De basisindeling van de bestanden en hun algemene syntaxis, uitgedrukt in de Hashicorp Configuration Language (HCL) zijn hetzelfde, ongeacht de cloudkeuze. Afzonderlijke onderdeelbeschrijvingen zijn echter cloudafhankelijk, zoals wordt bepaald door de bijbehorende Terraform-provider.
Hoewel er verschillende Terraform-providers zijn die ondersteuning bieden voor Azure-infrastructuurbeheer, is AzureRM van bijzonder belang. De AzureRM-provider vereenvoudigt het inrichten en configureren van algemene Azure IaaS-resources, zoals virtuele machines, opslagaccounts en netwerkinterfaces. Er zijn ook aanvullende niet-cloudspecifieke providers die u mogelijk wilt opnemen in uw implementaties. Deze omvatten de willekeurige provider, die helpt bij het voorkomen van conflicten met naamgeving van resources door pseudo-willekeurige tekenreeksen te genereren; en de TLS-provider, die het beheren van asymmetrische sleutels voor het beveiligen van Linux-verificatie vereenvoudigt.
Terraform is beschikbaar als één binair bestand dat u kunt downloaden van de Hashicorp-website. Dit binaire bestand implementeert de Terraform-opdrachtregelinterface (CLI), die u vervolgens vanuit een shellsessie kunt aanroepen om Terraform te initialiseren en configuratiebestanden te verwerken. U kunt Terraform CLI gebruiken vanuit een van de shells die Ondersteuning bieden voor Azure CLI.
Notitie
Wanneer u Azure Cloud Shell gebruikt, moet u ervoor zorgen dat u de huidige versie van Terraform uitvoert door de instructies te volgen in Terraform configureren in Azure Cloud Shell met Bash.
Een Virtuele Linux-machine implementeren met behulp van Terraform
Met Terraform kunt u resources definiëren, bekijken en implementeren in een providerspecifieke cloudinfrastructuur. Het inrichtingsproces begint met het maken van configuratiebestanden die gebruikmaken van de HCL-syntaxis, waarmee u de doelcloudomgeving, zoals Azure, en de resources kunt aanwijzen waaruit uw cloudinfrastructuur bestaat. Nadat alle relevante configuratiebestanden aanwezig zijn (meestal binnen dezelfde bestandssysteemlocatie), kunt u een uitvoeringsplan genereren waarmee u een voorbeeld van de resulterende infrastructuurwijzigingen kunt bekijken voordat de daadwerkelijke implementatie wordt uitgevoerd. Hiervoor moet u Terraform initialiseren om de providermodules te downloaden die nodig zijn om cloudresources te implementeren. Nadat u de wijzigingen hebt gevalideerd, kunt u het uitvoeringsplan toepassen om de infrastructuur te implementeren.
Notitie
Het genereren van een uitvoeringsplan is optioneel, maar we raden u aan dit te doen, omdat u hiermee eventuele gevolgen van de geplande implementatie kunt identificeren zonder dat dit van invloed is op de doelomgeving. Wanneer u Azure-resources interactief implementeert, ondersteunt Terraform azure CLI-verificatie transparant door uw referenties opnieuw te gebruiken voor toegang tot het Azure-doelabonnement.
Het proces voor het inrichten van een Virtuele Linux-machine met Behulp van Terraform omvat doorgaans de volgende reeks stappen op hoog niveau:
- Identificeer de geschikte VM-installatiekopieën.
- Identificeer de geschikte VM-grootte.
- Maak configuratiebestanden die de Azure VM-resource definiëren met de bijbehorende afhankelijkheden.
- Initialiseer Terraform.
- Genereer een Terraform-uitvoeringsplan.
- Start een Terraform-implementatie.
Volg de stappen die worden beschreven in les 4 van deze module om de geschikte VM-installatiekopieën en -grootte te identificeren. Deze les is gericht op Terraform-specifieke taken.
Configuratiebestanden maken
Notitie
De bestandsnamen die u voor uw Terraform-bestanden kiest, zijn willekeurig, hoewel het een goede gewoonte is om een naam te kiezen die de bestandsinhoud of het doel weerspiegelt. U moet .tf gebruiken voor de bestandsextensie.
Als u een Virtuele Linux-machine wilt implementeren met behulp van Terraform, begint u met het maken van een map voor het hosten van configuratiebestanden. Maak vervolgens een bestand met de naam providers.tf dat de Terraform-versie afdwingt en wijst de providers aan waarop u afhankelijk bent bij het definiëren van de resources die zijn opgenomen in uw implementatie. Voor dit bestand moet de inhoud worden weergegeven in het volgende codefragment:
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 {}
}
Maak in dezelfde map een bestand met de naam main.tf met behulp van de volgende code, waarmee de azure-VM-configuratie en de bijbehorende afhankelijkheden worden gedefinieerd:
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
}
}
Maak in dezelfde map een ander bestand met de naam variables.tf met behulp van de volgende code, waarmee de waarde wordt toegewezen aan de variabelen die worden weergegeven in het main.tf bestand:
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"
}
Maak ten slotte een bestand met de naam outputs.tf met behulp van de volgende code, waarmee de uitvoer wordt bepaald die wordt weergegeven na een geslaagde implementatie:
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
}
Terraform initialiseren
Voer de volgende opdracht uit vanaf de shellprompt om de Terraform-implementatie te initialiseren:
terraform init
Met deze opdracht worden de Azure-modules gedownload die nodig zijn om Azure-resources in te richten en te beheren.
Een uitvoeringsplan genereren
Maak na de initialisatie een uitvoeringsplan door uit te voeren terraform plan. Met de opdracht wordt een uitvoeringsplan gemaakt, maar wordt het niet uitgevoerd. In plaats daarvan wordt bepaald welke acties nodig zijn om de resources te maken die zijn gedefinieerd in uw configuratiebestanden. Met de optionele -out parameter kunt u een uitvoerbestand opgeven voor het plan, waarnaar u kunt verwijzen tijdens de daadwerkelijke implementatie. Als u dit bestand gebruikt, zorgt u ervoor dat het plan dat u bekijkt overeenkomt met het exacte implementatieresultaat. Gebruik de volgende opdracht om een uitvoeringsplan te genereren:
terraform plan -out <terraform_plan>.tfplan
Een implementatie starten
Wanneer u klaar bent om het uitvoeringsplan toe te passen op uw Azure-omgeving, voert u deze uit terraform apply, inclusief de naam van het bestand dat u in de vorige stap hebt gegenereerd. U hebt nog een kans om het verwachte resultaat te bekijken. Terraform vraagt u om bevestiging om door te gaan, hoewel u de prompt kunt elimineren door de -auto-approve schakeloptie toe te voegen. Gebruik de volgende opdracht om de implementatie te starten:
terraform apply <terraform_plan>.tfplan
De Virtuele Azure-machine wordt binnenkort uitgevoerd, meestal binnen een paar minuten. De terraform apply uitvoer van de opdracht bevat de lijst met uitvoerwaarden, maar terraform vervangt de waarde door tls_private_key het <gevoelige> label:
Apply complete! Resources: 12 added, 0 changed, 0 destroyed.
Uitvoer:
public_ip_address = "74.235.10.136"
resource_group_name = "rg-flexible-shark"
tls_private_key = <sensitive>
Als u de automatisch gegenereerde persoonlijke sleutel wilt gebruiken voor het verifiëren van uw SSH-verbinding, slaat u deze op in een bestand en stelt u vervolgens de machtigingen van het bestand in om ervoor te zorgen dat deze niet toegankelijk is voor anderen. Voer hiervoor de volgende opdrachten uit:
terraform output -raw tls_private_key > id_rsa
chmod 600 id_rsa
Op dit moment kunt u verbinding maken met de Virtuele Azure-machine door de volgende opdracht uit te voeren (nadat u de tijdelijke aanduiding voor de <public_ip_address> hebt vervangen door het IP-adres dat u hebt geïdentificeerd in de door terraform gegenereerde uitvoer):
ssh -i id_rsa azureuser@<public_ip_address>