Udostępnij za pośrednictwem


Uwierzytelnianie programu Terraform przy użyciu tożsamości zarządzanej dla usług platformy Azure

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

Tożsamości zarządzane dla zasobów platformy Azure służą do uwierzytelniania w usłudze Azure Active Directory. Firma HashiCorp zaleca używanie jednostki usługi lub tożsamości zarządzanej, jeśli używasz narzędzia Terraform w sposób nieinterakcyjny. Istnieją dwa typy tożsamości zarządzanych: przypisane przez system i przypisane przez użytkownika. Z tego artykułu dowiesz się, jak używać tożsamości przypisanych przez system.

Definiowanie tożsamości zarządzanej przypisanej przez system

Aby użyć tożsamości zarządzanej przypisanej przez system, wykonaj następujące kroki:

  1. identity Określ blok i ustaw wartość typeSystemAssigned.

    resource "azurerm_linux_virtual_machine" "example" {
      # ...
    
      identity {
        type = "SystemAssigned"
      }
    }
    
  2. Contributor Udziel roli tożsamości.

    data "azurerm_subscription" "current" {}
    
    data "azurerm_role_definition" "contributor" {
      name = "Contributor"
    }
    
    resource "azurerm_role_assignment" "example" {
      scope              = data.azurerm_subscription.current.id
      role_definition_name = "Contributor"
      principal_id       = azurerm_linux_virtual_machine.example.identity[0].principal_id
    }
    
  3. Skonfiguruj przy użyciu zmiennych środowiskowych, określając poświadczenia platformy Azure.

    export ARM_USE_MSI=true
    export ARM_SUBSCRIPTION_ID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
    export ARM_TENANT_ID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
    

Przykład: tworzenie maszyny wirtualnej z tożsamością zarządzaną

  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 {
        azapi = {
          source  = "azure/azapi"
          version = "~>1.5"
        }
        azurerm = {
          source  = "hashicorp/azurerm"
          version = "~>2.0"
        }
        random = {
          source  = "hashicorp/random"
          version = "~>3.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
    }
    
    data "azurerm_subscription" "current" {}
    
    resource "azurerm_virtual_network" "example" {
      name                = "myVnet"
      address_space       = ["10.0.0.0/16"]
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
    }
    
    resource "azurerm_subnet" "example" {
      name                 = "mySubnet"
      resource_group_name  = azurerm_resource_group.rg.name
      virtual_network_name = azurerm_virtual_network.example.name
      address_prefixes     = ["10.0.2.0/24"]
    }
    
    resource "azurerm_network_interface" "example" {
      name                = "myNic"
      location            = azurerm_resource_group.rg.location
      resource_group_name = azurerm_resource_group.rg.name
    
      ip_configuration {
        name                          = "internal"
        subnet_id                     = azurerm_subnet.example.id
        private_ip_address_allocation = "Dynamic"
      }
    }
    
    resource "azurerm_linux_virtual_machine" "example" {
      name                = "myVm"
      resource_group_name = azurerm_resource_group.rg.name
      location            = azurerm_resource_group.rg.location
      size                = "Standard_F2"
      network_interface_ids = [
        azurerm_network_interface.example.id,
      ]
    
      computer_name  = "hostname"
      admin_username = var.username
    
      admin_ssh_key {
        username   = var.username
        public_key = azapi_resource_action.ssh_public_key_gen.output.publicKey
      }
    
      identity {
        type = "SystemAssigned"
      }
    
      os_disk {
        caching              = "ReadWrite"
        storage_account_type = "Standard_LRS"
      }
    
      source_image_reference {
        publisher = "Canonical"
        offer     = "0001-com-ubuntu-server-jammy"
        sku       = "22_04-lts"
        version   = "latest"
      }
    }
    
    data "azurerm_role_definition" "contributor" {
      name = "Contributor"
    }
    
    resource "azurerm_role_assignment" "example" {
      scope              = data.azurerm_subscription.current.id
      role_definition_name = "Contributor"
      principal_id       = azurerm_linux_virtual_machine.example.identity[0].principal_id
    }
    
  4. Utwórz plik o nazwie ssh.tf i wstaw następujący kod.

    resource "random_pet" "ssh_key_name" {
      prefix    = "ssh"
      separator = ""
    }
    
    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 "azapi_resource" "ssh_public_key" {
      type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
      name      = random_pet.ssh_key_name.id
      location  = azurerm_resource_group.rg.location
      parent_id = azurerm_resource_group.rg.id
    }
    
    output "key_data" {
      value = azapi_resource_action.ssh_public_key_gen.output.publicKey
    }
        ```
    
    
  5. Utwórz plik o nazwie variables.tf i wstaw następujący kod:

    variable "resource_group_location" {
      type        = string
      description = "Location of the resource group."
      default     = "eastus"
    }
    
    variable "resource_group_name_prefix" {
      type        = string
      description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
      default     = "rg"
    }
    
    variable "username" {
      type        = string
      description = "The username for the local account that will be created on the new VM."
      default     = "azureadmin"
    }
    
  6. Utwórz plik o nazwie outputs.tf i wstaw następujący kod:

    output "resource_group_name" {
      value = azurerm_resource_group.rg.name
    }
    
    output "azurerm_linux_virtual_machine_name" {
      value = azurerm_linux_virtual_machine.example.name
    }
    

Następne kroki