Een virtuele-machineschaalset van Azure maken op basis van een aangepaste Packer-installatiekopieën met behulp van Terraform

Artikel
04/06/2024

Terraform maakt de definitie, preview en implementatie van de cloudinfrastructuur mogelijk. Met Behulp van Terraform maakt u configuratiebestanden met behulp van de HCL-syntaxis. Met de HCL-syntaxis kunt u de cloudprovider opgeven, zoals Azure, en de elementen waaruit uw cloudinfrastructuur bestaat. Nadat u uw configuratiebestanden hebt gemaakt, maakt u een uitvoeringsplan waarmee u een voorbeeld van uw infrastructuurwijzigingen kunt bekijken voordat ze worden geïmplementeerd. Zodra u de wijzigingen hebt gecontroleerd, past u het uitvoeringsplan toe om de infrastructuur te implementeren.

Met virtuele-machineschaalsets van Azure kunt u identieke VM's configureren. Het aantal VM-exemplaren kan worden aangepast op basis van aanvraag of een planning. Zie Automatisch een virtuele-machineschaalset schalen in Azure Portal voor meer informatie.

In dit artikel leert u het volgende:

Een Terraform-implementatie instellen
Variabelen en uitvoer voor Terraform-implementatie gebruiken
Een netwerkinfrastructuur maken en implementeren
Een aangepaste installatiekopieën voor virtuele machines maken met Behulp van Packer
Een virtuele-machineschaalset maken en implementeren met behulp van de aangepaste installatiekopieën
Een jumpbox maken en implementeren

1. Uw omgeving configureren

Azure-abonnement: als u nog geen abonnement op Azure hebt, maakt u een gratis Azure-account aan voordat u begint.

Terraform configureren: Als u dit nog niet hebt gedaan, configureert u Terraform met een van de volgende opties:

2. Een Packer-installatiekopieën maken

Installeer Packer.

Belangrijkste punten:
- Voer de volgende opdracht uit om te bevestigen dat u toegang hebt tot het uitvoerbare Packer-bestand: packer -v
- Afhankelijk van uw omgeving moet u mogelijk uw pad instellen en de opdrachtregel opnieuw openen.
Voer az group create uit om een resourcegroep te maken die de Packer-installatiekopieën bevat.
```
az group create -n myPackerImages -l eastus
```
Voer az ad sp create-for-rbac uit om Packer in te schakelen voor verificatie bij Azure met behulp van een service-principal.
```
az ad sp create-for-rbac --role Contributor --scopes /subscriptions/<subscription_id> --query "{ client_id: appId, client_secret: password, tenant_id: tenant }"
```
Belangrijkste punten:
- Noteer de uitvoerwaarden (appId, client_secret, tenant_id).
Voer az account show uit om het huidige Azure-abonnement weer te geven.
```
az account show --query "{ subscription_id: id }"
```

Maak een Packer-sjabloonvariabelenbestand met de naam ubuntu.pkr.hcl en voeg de volgende code in. Werk de gemarkeerde regels bij met de gegevens van uw service-principal en Azure-abonnement.

packer {
  required_plugins {
    azure = {
      source  = "github.com/hashicorp/azure"
      version = "~> 2"
    }
  }
}

variable client_id {
  type    = string
  default = null
}
variable client_secret {
  type    = string
  default = null
}

variable subscription_id {
  type    = string
  default = null
}

variable tenant_id {
  type    = string
  default = null
}

variable location {
  default = "eastus"
}

variable "image_resource_group_name" {
  description = "Name of the resource group in which the Packer image will be created"
  default     = "myPackerImages"
}

variable "oidc_request_url" {
  default = null
}

variable "oidc_request_token" {
  default = null
}

# arm builder
source "azure-arm" "builder" {
  client_id                         = var.client_id
  client_secret                     = var.client_secret
  image_offer                       = "UbuntuServer"
  image_publisher                   = "canonical"
  image_sku                         = "16.04-LTS"
  location                          = var.location
  managed_image_name                = "myPackerImage"
  managed_image_resource_group_name = var.image_resource_group_name
  os_type                           = "Linux"
  subscription_id                   = var.subscription_id
  tenant_id                         = var.tenant_id
  oidc_request_url                  = var.oidc_request_url
  oidc_request_token                = var.oidc_request_token
  vm_size                           = "Standard_DS2_v2"
  azure_tags = {
    "dept" : "Engineering",
    "task" : "Image deployment",
  }
}

build {
  sources = ["source.azure-arm.builder"]
  provisioner "shell" {
    execute_command = "chmod +x {{ .Path }}; {{ .Vars }} sudo -E sh '{{ .Path }}'"
    inline = [
      "apt-get update",
      "apt-get upgrade -y",
      "apt-get -y install nginx",
      "/usr/sbin/waagent -force -deprovision+user && export HISTSIZE=0 && sync",
    ]
  }
}

Belangrijkste punten:

Stel de client_idvelden en client_secrettenant_id velden in op de respectieve waarden van uw service-principal.
Stel het subscription_id veld in op uw Azure-abonnements-id.

Bouw de Packer-installatiekopieën.
```
packer build ubuntu.json
```

3. De Terraform-code implementeren

Maak een map waarin u de Terraform-voorbeeldcode wilt testen en de huidige map kunt maken.

Maak een bestand met de naam main.tf en voeg de volgende code in:

terraform {

  required_version = ">=0.12"

  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.0"
    }
    azapi = {
      source  = "Azure/azapi"
      version = "~> 1.0"
    }
    local = {
      source  = "hashicorp/local"
      version = "2.4.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "3.5.1"
    }
    tls = {
      source  = "hashicorp/tls"
      version = "4.0.4"
    }
  }
}

provider "azurerm" {
  features {
    resource_group {
      prevent_deletion_if_contains_resources = false
    }
  }
}

resource "random_pet" "id" {}

resource "azurerm_resource_group" "vmss" {
  name     = coalesce(var.resource_group_name, "201-vmss-packer-jumpbox-${random_pet.id.id}")
  location = var.location
  tags     = var.tags
}

resource "random_string" "fqdn" {
  length  = 6
  special = false
  upper   = false
  numeric = false
}

resource "azurerm_virtual_network" "vmss" {
  name                = "vmss-vnet"
  address_space       = ["10.0.0.0/16"]
  location            = var.location
  resource_group_name = azurerm_resource_group.vmss.name
  tags                = var.tags
}

resource "azurerm_subnet" "vmss" {
  name                 = "vmss-subnet"
  resource_group_name  = azurerm_resource_group.vmss.name
  virtual_network_name = azurerm_virtual_network.vmss.name
  address_prefixes     = ["10.0.2.0/24"]
}

resource "azurerm_public_ip" "vmss" {
  name                = "vmss-public-ip"
  location            = var.location
  resource_group_name = azurerm_resource_group.vmss.name
  allocation_method   = "Static"
  domain_name_label   = random_string.fqdn.result
  tags                = var.tags
}

resource "azurerm_lb" "vmss" {
  name                = "vmss-lb"
  location            = var.location
  resource_group_name = azurerm_resource_group.vmss.name

  frontend_ip_configuration {
    name                 = "PublicIPAddress"
    public_ip_address_id = azurerm_public_ip.vmss.id
  }

  tags = var.tags
}

resource "azurerm_lb_backend_address_pool" "bpepool" {
  loadbalancer_id = azurerm_lb.vmss.id
  name            = "BackEndAddressPool"
}

resource "azurerm_lb_probe" "vmss" {
  loadbalancer_id = azurerm_lb.vmss.id
  name            = "ssh-running-probe"
  port            = var.application_port
}

resource "azurerm_lb_rule" "lbnatrule" {
  loadbalancer_id                = azurerm_lb.vmss.id
  name                           = "http"
  protocol                       = "Tcp"
  frontend_port                  = var.application_port
  backend_port                   = var.application_port
  backend_address_pool_ids       = [azurerm_lb_backend_address_pool.bpepool.id]
  frontend_ip_configuration_name = "PublicIPAddress"
  probe_id                       = azurerm_lb_probe.vmss.id
}

data "azurerm_resource_group" "image" {
  name = var.packer_resource_group_name
}

data "azurerm_image" "image" {
  name                = var.packer_image_name
  resource_group_name = data.azurerm_resource_group.image.name
}

resource "azapi_resource" "ssh_public_key" {
  type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  name      = random_pet.id.id
  location  = azurerm_resource_group.vmss.location
  parent_id = azurerm_resource_group.vmss.id
}

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 "random_password" "password" {
  count  = var.admin_password == null ? 1 : 0
  length = 20
}

locals {
  admin_password = try(random_password.password[0].result, var.admin_password)
}

resource "azurerm_virtual_machine_scale_set" "vmss" {
  name                = "vmscaleset"
  location            = var.location
  resource_group_name = azurerm_resource_group.vmss.name
  upgrade_policy_mode = "Manual"

  sku {
    name     = "Standard_DS1_v2"
    tier     = "Standard"
    capacity = 2
  }

  storage_profile_image_reference {
    id = data.azurerm_image.image.id
  }

  storage_profile_os_disk {
    name              = ""
    caching           = "ReadWrite"
    create_option     = "FromImage"
    managed_disk_type = "Standard_LRS"
  }

  storage_profile_data_disk {
    lun           = 0
    caching       = "ReadWrite"
    create_option = "Empty"
    disk_size_gb  = 10
  }

  os_profile {
    computer_name_prefix = "vmlab"
    admin_username       = var.admin_user
    admin_password       = local.admin_password
  }

  os_profile_linux_config {
    disable_password_authentication = true

    ssh_keys {
      path     = "/home/azureuser/.ssh/authorized_keys"
      key_data = azapi_resource_action.ssh_public_key_gen.output.publicKey
    }
  }

  network_profile {
    name    = "terraformnetworkprofile"
    primary = true

    ip_configuration {
      name                                   = "IPConfiguration"
      subnet_id                              = azurerm_subnet.vmss.id
      load_balancer_backend_address_pool_ids = [azurerm_lb_backend_address_pool.bpepool.id]
      primary                                = true
    }
  }

  tags = var.tags
}

resource "azurerm_public_ip" "jumpbox" {
  name                = "jumpbox-public-ip"
  location            = var.location
  resource_group_name = azurerm_resource_group.vmss.name
  allocation_method   = "Static"
  domain_name_label   = "${random_string.fqdn.result}-ssh"
  tags                = var.tags
}

resource "azurerm_network_interface" "jumpbox" {
  name                = "jumpbox-nic"
  location            = var.location
  resource_group_name = azurerm_resource_group.vmss.name

  ip_configuration {
    name                          = "IPConfiguration"
    subnet_id                     = azurerm_subnet.vmss.id
    private_ip_address_allocation = "Dynamic"
    public_ip_address_id          = azurerm_public_ip.jumpbox.id
  }

  tags = var.tags
}

resource "azurerm_virtual_machine" "jumpbox" {
  name                  = "jumpbox"
  location              = var.location
  resource_group_name   = azurerm_resource_group.vmss.name
  network_interface_ids = [azurerm_network_interface.jumpbox.id]
  vm_size               = "Standard_DS1_v2"

  storage_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "16.04-LTS"
    version   = "latest"
  }

  storage_os_disk {
    name              = "jumpbox-osdisk"
    caching           = "ReadWrite"
    create_option     = "FromImage"
    managed_disk_type = "Standard_LRS"
  }

  os_profile {
    computer_name  = "jumpbox"
    admin_username = var.admin_user
    admin_password = local.admin_password
  }

  os_profile_linux_config {
    disable_password_authentication = true

    ssh_keys {
      path     = "/home/azureuser/.ssh/authorized_keys"
      key_data = azapi_resource_action.ssh_public_key_gen.output.publicKey
    }
  }

  tags = var.tags
}

Maak een bestand met de naam variables.tf dat de projectvariabelen bevat en voeg de volgende code in:

variable "packer_resource_group_name" {
  description = "Name of the resource group in which the Packer image will be created"
  default     = "myPackerImages"
}

variable "packer_image_name" {
  description = "Name of the Packer image"
  default     = "myPackerImage"
}

variable "resource_group_name" {
  description = "Name of the resource group in which the Packer image  will be created"
  default     = null
}

variable "location" {
  default     = "eastus"
  description = "Location where resources will be created"
}

variable "tags" {
  description = "Map of the tags to use for the resources that are deployed"
  type        = map(string)
  default = {
    environment = "codelab"
  }
}

variable "application_port" {
  description = "Port that you want to expose to the external load balancer"
  default     = 80
}

variable "admin_user" {
  description = "User name to use as the admin account on the VMs that will be part of the VM scale set"
  default     = "azureuser"
}

variable "admin_password" {
  description = "Default password for admin account"
  default     = null
}

Maak een bestand met de naam output.tf om op te geven welke waarden Terraform weergeeft en voeg de volgende code in:

output "vmss_public_ip_fqdn" {
  value = azurerm_public_ip.vmss.fqdn
}

output "jumpbox_public_ip_fqdn" {
  value = azurerm_public_ip.jumpbox.fqdn
}

output "jumpbox_public_ip" {
  value = azurerm_public_ip.jumpbox.ip_address
}

4. Terraform initialiseren

Voer terraform init uit om de Terraform-implementatie te initialiseren. Met deze opdracht wordt de Azure-provider gedownload die is vereist voor het beheren van uw Azure-resources.

terraform init -upgrade

Belangrijkste punten:

Met -upgrade de parameter worden de benodigde providerinvoegtoepassingen bijgewerkt naar de nieuwste versie die voldoet aan de versiebeperkingen van de configuratie.

5. Een Terraform-uitvoeringsplan maken

Voer terraform-plan uit om een uitvoeringsplan te maken.

terraform plan -out main.tfplan

Belangrijkste punten:

De terraform plan opdracht maakt een uitvoeringsplan, maar voert het niet uit. In plaats daarvan wordt bepaald welke acties nodig zijn om de configuratie te maken die is opgegeven in uw configuratiebestanden. Met dit patroon kunt u controleren of het uitvoeringsplan aan uw verwachtingen voldoet voordat u wijzigingen aanbrengt in de werkelijke resources.
Met de optionele -out parameter kunt u een uitvoerbestand voor het plan opgeven. Door de -out parameter te gebruiken, zorgt u ervoor dat het plan dat u hebt gecontroleerd precies wordt toegepast.

6. Een Terraform-uitvoeringsplan toepassen

Terraform uitvoeren is van toepassing om het uitvoeringsplan toe te passen op uw cloudinfrastructuur.

terraform apply main.tfplan

Belangrijkste punten:

Bij de voorbeeldopdracht terraform apply wordt ervan uitgegaan dat u eerder hebt uitgevoerd terraform plan -out main.tfplan.
Als u een andere bestandsnaam voor de -out parameter hebt opgegeven, gebruikt u diezelfde bestandsnaam in de aanroep naar terraform apply.
Als u de parameter niet hebt gebruikt, roept terraform apply u deze -out aan zonder parameters.

7. Controleer de resultaten

In de uitvoer van de terraform apply opdracht ziet u waarden voor het volgende:
- FQDN van virtuele machine
- Jumpbox-FQDN
- Jumpbox-IP-adres
Blader naar de URL van de virtuele machine om een standaardpagina te bevestigen met de tekst Welkom bij nginx!.
Gebruik SSH om verbinding te maken met de jumpbox-VM met behulp van de gebruikersnaam die is gedefinieerd in het variabelenbestand en het wachtwoord dat u hebt opgegeven tijdens het uitvoeren terraform apply. Voorbeeld: ssh azureuser@<ip_address>.

8. Resources opschonen

Virtuele-machineschaalset verwijderen

Voer de volgende stappen uit wanneer u de resources die zijn gemaakt via Terraform niet meer nodig hebt:

Voer terraform-plan uit en geef de destroy vlag op.
```
terraform plan -destroy -out main.destroy.tfplan
```
Belangrijkste punten:
- De terraform plan opdracht maakt een uitvoeringsplan, maar voert het niet uit. In plaats daarvan wordt bepaald welke acties nodig zijn om de configuratie te maken die is opgegeven in uw configuratiebestanden. Met dit patroon kunt u controleren of het uitvoeringsplan aan uw verwachtingen voldoet voordat u wijzigingen aanbrengt in de werkelijke resources.
- Met de optionele -out parameter kunt u een uitvoerbestand voor het plan opgeven. Door de -out parameter te gebruiken, zorgt u ervoor dat het plan dat u hebt gecontroleerd precies wordt toegepast.
Terraform uitvoeren is van toepassing om het uitvoeringsplan toe te passen.
```
terraform apply main.destroy.tfplan
```

Packer-installatiekopieën en resourcegroep verwijderen

Voer az group delete uit om de resourcegroep te verwijderen die wordt gebruikt om de Packer-installatiekopieën te bevatten. De Packer-installatiekopieën worden ook verwijderd.

az group delete --name myPackerImages --yes

Problemen met Terraform in Azure oplossen

Veelvoorkomende problemen oplossen bij het gebruik van Terraform in Azure

Volgende stappen

Meer informatie over het gebruik van Terraform in Azure

Delen via

Een virtuele-machineschaalset van Azure maken op basis van een aangepaste Packer-installatiekopieën met behulp van Terraform

1. Uw omgeving configureren

2. Een Packer-installatiekopieën maken

3. De Terraform-code implementeren

4. Terraform initialiseren

5. Een Terraform-uitvoeringsplan maken

6. Een Terraform-uitvoeringsplan toepassen

7. Controleer de resultaten

8. Resources opschonen

Virtuele-machineschaalset verwijderen

Packer-installatiekopieën en resourcegroep verwijderen

Problemen met Terraform in Azure oplossen

Volgende stappen

Feedback

Aanvullende resources