Creare un cluster Servizio Azure Kubernetes (AKS) privato

• Terraform installato localmente. Per istruzioni di installazione, vedere Installare Terraform.

Creare un gruppo di risorse

Creare un gruppo di risorse usando il comando az group create. È anche possibile usare un gruppo di risorse esistente per il cluster del servizio Azure Kubernetes.

az group create \
    --name <private-cluster-resource-group> \
    --location <location>

Creare un cluster privato con la rete di base predefinita usando il comando az aks create con il flag --enable-private-cluster.

Parametri chiave in questo comando:

• --enable-private-cluster: abilita la modalità cluster privato.

az aks create \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --generate-ssh-keys

1. Creare un file denominato main.tf e aggiungere il codice seguente per definire la versione di Terraform e specificare il provider Azure:

   terraform {
     required_version = ">= 1.3.0"
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~> 4.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
     subscription_id = var.subscription_id
   }
   

2. Aggiungere il codice seguente a main.tf per creare variabili di input per l'ID della sottoscrizione di Azure, il gruppo di risorse, l'area geografica e il nome del cluster AKS. È possibile modificare i valori predefiniti in base alle esigenze.

   variable "subscription_id" {
     description = "The Azure subscription ID."
     type = string
   }
   
   variable "resource_group_name" {
     description = "The name of the resource group for the AKS cluster."
     type        = string
     default     = "rg-private-aks-basic"
   }
   
   variable "location" {
     description = "The Azure region where the resources will be created."
     type        = string
     default     = "eastus"
   }
   
   variable "aks_cluster_name" {
     description = "The name of the AKS cluster."
     type        = string
     default     = "aks-private-basic"
   }
   

3. Aggiungere il codice seguente a main.tf per creare un gruppo di risorse Azure:

   resource "azurerm_resource_group" "this" {
     name     = var.resource_group_name
     location = var.location
   }
   

4. Aggiungere il codice seguente a main.tf per creare un cluster AKS privato con la rete di base.

   resource "azurerm_kubernetes_cluster" "this" {
     name                = var.aks_cluster_name
     location            = azurerm_resource_group.this.location
     resource_group_name = azurerm_resource_group.this.name
     dns_prefix          = "privatebasicaks"
   
     private_cluster_enabled = true
   
     default_node_pool {
       name       = "system"
       node_count = 1
       vm_size    = "Standard_DS2_v2"
     }
   
     identity {
       type = "SystemAssigned"
     }
   
     network_profile {
       load_balancer_sku = "standard"
       network_plugin    = "kubenet"
     }
   }
   

5. Seguire la procedura per inizializzare Terraform, formattare e convalidare la configurazione terraform, creare un piano di esecuzione Terraform, applicare la configurazione terraform e connettersi al cluster del servizio Azure Kubernetes.

Creare un cluster privato con funzionalità di rete avanzate usando il az aks create comando .

Parametri chiave in questo comando:

• --enable-private-cluster: abilita la modalità cluster privato.
• --network-plugin azure: specifica il plug-in di rete CNI Azure.
• --vnet-subnet-id <subnet-id>: ID risorsa di una subnet esistente in una rete virtuale.
• --dns-service-ip <dns-service-ip>: indirizzo IP disponibile all'interno dell'intervallo di indirizzi del servizio Kubernetes da usare per il servizio DNS del cluster. Ad esempio: 10.2.0.10.
• --service-cidr <service-cidr>: intervallo IP di notazione CIDR da cui assegnare indirizzi IP del cluster di servizi. Ad esempio: 10.2.0.0/24.

az aks create \
    --resource-group <private-cluster-resource-group> \
    --name <private-cluster-name> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --network-plugin azure \
    --vnet-subnet-id <subnet-id> \
    --dns-service-ip <dns-service-ip> \
    --service-cidr <service-cidr> \
    --generate-ssh-keys

1. Creare un file denominato main.tf e aggiungere il codice seguente per definire la versione di Terraform e specificare il provider Azure:

   terraform {
     required_version = ">= 1.3.0"
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~> 4.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
     subscription_id = var.subscription_id
   }
   

2. Aggiungere il codice seguente a main.tf per creare variabili di input per l'ID della sottoscrizione Azure, il nome del gruppo di risorse, la località, il nome del cluster AKS, il nome della rete virtuale (VNet) e il nome della subnet. È possibile modificare i valori predefiniti in base alle esigenze.

   variable "subscription_id" {
     description = "The Azure subscription ID."
     type = string
   }
   
   variable "resource_group_name" {
     description = "The name of the resource group for the AKS cluster."
     type = string
     default = "rg-private-aks-advanced"
   }
   
   variable "location" {
     description = "The Azure region where the resources will be created."
     type = string
     default = "eastus"
   }
   
   variable "aks_cluster_name" {
     description = "The name of the AKS cluster."
     type = string
     default = "aks-private-advanced"
   }
   
   variable "vnet_name" {
     description = "The name of the virtual network."
     type = string
     default = "vnet-private-aks"
   }
   
   variable "subnet_name" {
     description = "The name of the subnet used by AKS."
     type = string
     default = "snet-aks"
   }
   

3. Aggiungere il codice seguente a main.tf per creare un gruppo di risorse Azure, una rete virtuale e una subnet:

   resource "azurerm_resource_group" "this" {
     name = var.resource_group_name
     location = var.location
   }
   
   resource "azurerm_virtual_network" "this" {
     name = var.vnet_name
     location = azurerm_resource_group.this.location
     resource_group_name = azurerm_resource_group.this.name
     address_space = ["10.0.0.0/8"]
   }
   
   resource "azurerm_subnet" "aks" {
     name = var.subnet_name
     resource_group_name  = azurerm_resource_group.this.name
     virtual_network_name = azurerm_virtual_network.this.name
     address_prefixes = ["10.240.0.0/16"]
   }
   

4. Aggiungi il seguente codice a main.tf per creare il cluster AKS con funzionalità di rete avanzate.

   resource "azurerm_kubernetes_cluster" "this" {
     name = var.aks_cluster_name
     location = azurerm_resource_group.this.location
     resource_group_name = azurerm_resource_group.this.name
     dns_prefix = "privateadvancedaks"
   
     private_cluster_enabled = true
   
     default_node_pool {
       name = "system"
       node_count = 1
       vm_size = "Standard_DS2_v2"
       vnet_subnet_id = azurerm_subnet.aks.id
     }
   
     identity {
       type = "SystemAssigned"
     }
   
     network_profile {
       load_balancer_sku = "standard"
       network_plugin = "azure"
       dns_service_ip = "10.2.0.10"
       service_cidr = "10.2.0.0/24"
     }
   }
   

5. Seguire la procedura per inizializzare Terraform, formattare e convalidare la configurazione terraform, creare un piano di esecuzione Terraform, applicare la configurazione terraform e connettersi al cluster del servizio Azure Kubernetes.

Disabilitare un FQDN pubblico durante la creazione di un cluster del servizio Azure Kubernetes privato usando il comandoaz aks create con il flag--disable-public-fqdn.

Parametri chiave in questo comando:

• --disable-public-fqdn: disabilita il nome di dominio completo (FQDN) pubblico per il server API.
• --assign-identity <resource-id>: specifica l'identità gestita da usare per il cluster.
• --private-dns-zone [system|none]: specifica la zona DNS privata da usare per il cluster. system è il valore predefinito durante la configurazione di una zona DNS privata. Se si omette --private-dns-zone, AKS crea una zona DNS privata nel gruppo di risorse del nodo. none disabilita la creazione di una zona DNS privata.

az aks create \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --assign-identity <resource-id> \
    --private-dns-zone [system|none] \
    --disable-public-fqdn \
    --generate-ssh-keys

1. Seguire i passaggi da 1 a 3 in Creare un cluster del servizio Azure Kubernetes privato con rete avanzata o Creare un cluster del servizio Azure Kubernetes privato con rete di base predefinita per configurare la configurazione terraform e creare le risorse necessarie a seconda dello scenario. In questo esempio viene usata la rete avanzata.

2. Aggiungere il seguente codice a main.tf per creare un cluster privato di Azure Kubernetes Service (AKS) con un'identità assegnata dall'utente e il nome di dominio completo pubblico disabilitato:

   resource "azurerm_user_assigned_identity" "aks" {
     name = "id-private-aks-public-fqdn-off"
     location = azurerm_resource_group.this.location
     resource_group_name = azurerm_resource_group.this.name
   }
   resource "azurerm_kubernetes_cluster" "this" {
     name = var.aks_cluster_name
     location = azurerm_resource_group.this.location
     resource_group_name = azurerm_resource_group.this.name
     dns_prefix = "privateaks"
     private_cluster_enabled = true
     private_cluster_public_fqdn_enabled = false
   
     private_dns_zone_id = "System"
   
     default_node_pool {
       name = "system"
       node_count = 1
       vm_size = "Standard_DS2_v2"
       vnet_subnet_id = azurerm_subnet.aks.id
     }
     identity {
       type = "UserAssigned"
       identity_ids = [azurerm_user_assigned_identity.aks.id]
     }
     network_profile {
       load_balancer_sku = "standard"
       network_plugin = "azure"
       dns_service_ip = "10.2.0.10"
       service_cidr = "10.2.0.0/24"
     }
   }
   

3. Seguire la procedura per inizializzare Terraform, formattare e convalidare la configurazione terraform, creare un piano di esecuzione Terraform, applicare la configurazione terraform e connettersi al cluster del servizio Azure Kubernetes.

Disabilitare un FQDN pubblico in un cluster del servizio Azure Kubernetes esistente usando il comando az aks update con il flag --disable-public-fqdn.

Parametri chiave in questo comando:

• --disable-public-fqdn: disabilita il nome di dominio completo (FQDN) pubblico per il server API.

az aks update \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --disable-public-fqdn

1. Aggiungere il seguente codice all'esistente main.tf per disabilitare il FQDN pubblico in un cluster AKS (Azure Kubernetes Service) esistente. In questo esempio viene usata la rete avanzata. È possibile modificarlo per usare la rete di base predefinita modificando le risorse e i parametri Terraform pertinenti.

   resource "azurerm_kubernetes_cluster" "this" {
     name = var.aks_cluster_name
     location = azurerm_resource_group.this.location
     resource_group_name = azurerm_resource_group.this.name
     dns_prefix = "privateaks"
   
     private_cluster_enabled = true
     private_cluster_public_fqdn_enabled = false
     private_dns_zone_id = "System"
   
     default_node_pool {
       name = "system"
       node_count = 1
       vm_size = "Standard_DS2_v2"
       vnet_subnet_id = azurerm_subnet.aks.id
     }
   
     identity {
       type = "UserAssigned"
       identity_ids = [azurerm_user_assigned_identity.aks.id]
     }
   
     network_profile {
       load_balancer_sku = "standard"
       network_plugin = "azure"
       dns_service_ip = "10.2.0.10"
       service_cidr = "10.2.0.0/24"
     }
   }
   

2. Applicare la configurazione aggiornata di Terraform utilizzando i comandi terraform plan e terraform apply.

   terraform plan
   terraform apply
   

Opzioni di configurazione per DNS privato

È possibile configurare le impostazioni DNS private per un cluster del servizio Azure Kubernetes privato usando il interfaccia della riga di comando di Azure (con il parametro --private-dns-zone) o un modello di Azure Resource Manager (ARM) (con la proprietà /privateDNSZone). La tabella seguente illustra le opzioni disponibili per il --private-dns-zone parametro/ privateDNSZone proprietà:

Considerazioni sul DNS privato

Quando si configura il DNS privato per un cluster del servizio Azure Kubernetes privato, tenere presenti le considerazioni seguenti:

• Se la zona DNS privata si trova in una sottoscrizione diversa rispetto al cluster AKS, è necessario registrare il provider Azure Microsoft.ContainerService in entrambe le sottoscrizioni.
• Se il cluster AKS è configurato con un'entità servizio Active Directory, AKS non supporta l'uso di un'identità gestita di sistema con una zona DNS privata personalizzata. Il cluster deve usare l'autenticazione dell'identità gestita assegnata dall'utente.

Creare un cluster AKS privato con una zona DNS privata utilizzando il comando az aks create.

Parametri chiave in questo comando:

• --enable-private-cluster: abilita la modalità cluster privato.
• --private-dns-zone [system|none]: configura la zona DNS privata per il cluster. system è il valore predefinito durante la configurazione di una zona DNS privata. Se si omette --private-dns-zone, AKS crea una zona DNS privata nel gruppo di risorse del nodo. none disabilita la creazione di una zona DNS privata.
• --assign-identity <resource-id>: L'ID risorsa di un'identità gestita assegnata dall'utente con i ruoli di Collaboratore della zona DNS privata e Collaboratore di rete.

az aks create \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --assign-identity <resource-id> \
    --private-dns-zone [system|none] \
    --generate-ssh-keys

1. Seguire i passaggi da 1 a 3 in Creare un cluster del servizio Azure Kubernetes privato con rete avanzata o Creare un cluster del servizio Azure Kubernetes privato con rete di base predefinita per configurare la configurazione terraform e creare le risorse necessarie a seconda dello scenario. In questo esempio viene usata la rete avanzata.

2. Aggiungere il codice seguente a main.tf per creare un cluster AKS privato con una zona DNS privata gestita da AKS:

   resource "azurerm_kubernetes_cluster" "this" {
    name                = var.aks_cluster_name
    location            = azurerm_resource_group.this.location
    resource_group_name = azurerm_resource_group.this.name
    dns_prefix          = "aks-system-dns"
    private_cluster_enabled = true
    private_dns_zone_id     = "System"
    default_node_pool {
      name           = "system"
      node_count     = 1
      vm_size        = "Standard_DS2_v2"
      vnet_subnet_id = azurerm_subnet.aks.id
    }
    identity {
      type = "SystemAssigned"
    }
    network_profile {
      network_plugin    = "azure"
      load_balancer_sku = "standard"
      dns_service_ip    = "10.2.0.10"
      service_cidr      = "10.2.0.0/24"
    }
   }
   

3. Seguire la procedura per inizializzare Terraform, formattare e convalidare la configurazione terraform, creare un piano di esecuzione Terraform, applicare la configurazione terraform e connettersi al cluster del servizio Azure Kubernetes.

Creare un cluster AKS privato senza una zona privata DNS

1. Seguire i passaggi da 1 a 3 in Creare un cluster del servizio Azure Kubernetes privato con rete avanzata o Creare un cluster del servizio Azure Kubernetes privato con rete di base predefinita per configurare la configurazione terraform e creare le risorse necessarie a seconda dello scenario. In questo esempio viene usata la rete avanzata.

2. Aggiungere il codice seguente a main.tf per creare il cluster AKS senza una zona DNS privata.

   resource "azurerm_kubernetes_cluster" "this" {
    name                = var.aks_cluster_name
    location            = azurerm_resource_group.this.location
    resource_group_name = azurerm_resource_group.this.name
    dns_prefix          = "aks-no-dns"
    private_cluster_enabled = true
    private_dns_zone_id     = "None"
    default_node_pool {
      name           = "system"
      node_count     = 1
      vm_size        = "Standard_DS2_v2"
      vnet_subnet_id = azurerm_subnet.aks.id
    }
    identity {
      type = "SystemAssigned"
    }
    network_profile {
      network_plugin    = "azure"
      load_balancer_sku = "standard"
      dns_service_ip    = "10.2.0.10"
      service_cidr      = "10.2.0.0/24"
    }
   }
   

3. Seguire la procedura per inizializzare Terraform, formattare e convalidare la configurazione terraform, creare un piano di esecuzione Terraform, applicare la configurazione terraform e connettersi al cluster del servizio Azure Kubernetes.

Creare un cluster privato di Azure Kubernetes Service (AKS) con una zona DNS privata personalizzata o un sottodominio utilizzando il comando az aks create.

Parametri chiave in questo comando:

• --enable-private-cluster: abilita la modalità cluster privato.
• --private-dns-zone [<custom-private-dns-zone-resource-id>|<custom-private-dns-subzone-resource-id>]: ID risorsa di una zona DNS privata o di una sottozone esistente nel formato seguente per Azure cloud globale: privatelink.<region>.azmk8s.io o <subzone>.privatelink.<region>.azmk8s.io.
• --assign-identity <resource-id>: ID risorsa di un'identità gestita assegnata dall'utente con i ruoli di Collaboratore zona DNS privata e Collaboratore rete.

az aks create \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --assign-identity <resource-id> \
    --private-dns-zone [<custom-private-dns-zone-resource-id>|<custom-private-dns-subzone-resource-id>] \
    --generate-ssh-keys

Quando si usa una zona DNS privata personalizzata, si è responsabili della creazione e della gestione dell'infrastruttura DNS invece di basarsi sul DNS gestito Azure. Ciò include la creazione della zona DNS, il collegamento alla VNet e l'assegnazione delle autorizzazioni necessarie affinché AKS gestisca i record.

Per le configurazioni DNS personalizzate, è necessario usare un'identità gestita assegnata dall'utente con i ruoli collaboratore DNS privato zona e Network Contributor.

1. Seguire i passaggi da 1 a 3 in Creare un cluster del servizio Azure Kubernetes privato con rete avanzata o Creare un cluster del servizio Azure Kubernetes privato con rete di base predefinita per configurare la configurazione terraform e creare le risorse necessarie a seconda dello scenario. In questo esempio viene usata la rete avanzata.

2. Aggiungere il codice a main.tf per creare un cluster AKS privato con una zona DNS privata personalizzata o una sottozona:

   resource "azurerm_user_assigned_identity" "aks" {
    name                = "aks-custom-dns-id"
    location            = azurerm_resource_group.this.location
    resource_group_name = azurerm_resource_group.this.name
   }
   resource "azurerm_private_dns_zone" "aks" {
    name                = "privatelink.eastus.azmk8s.io"
    resource_group_name = azurerm_resource_group.this.name
   }
   resource "azurerm_private_dns_zone_virtual_network_link" "link" {
    name                  = "aks-dns-link"
    resource_group_name   = azurerm_resource_group.this.name
    private_dns_zone_name = azurerm_private_dns_zone.aks.name
    virtual_network_id    = azurerm_virtual_network.this.id
   }
   resource "azurerm_role_assignment" "dns" {
    scope                = azurerm_private_dns_zone.aks.id
    role_definition_name = "Private DNS Zone Contributor"
    principal_id         = azurerm_user_assigned_identity.aks.principal_id
   }
   resource "azurerm_role_assignment" "network" {
    scope                = azurerm_virtual_network.this.id
    role_definition_name = "Network Contributor"
    principal_id         = azurerm_user_assigned_identity.aks.principal_id
   }
   resource "azurerm_kubernetes_cluster" "this" {
    name                = var.aks_cluster_name
    location            = azurerm_resource_group.this.location
    resource_group_name = azurerm_resource_group.this.name
    dns_prefix          = "aks-custom-dns"
    private_cluster_enabled = true
    private_dns_zone_id     = azurerm_private_dns_zone.aks.id
    default_node_pool {
      name           = "system"
      node_count     = 1
      vm_size        = "Standard_DS2_v2"
      vnet_subnet_id = azurerm_subnet.aks.id
    }
    identity {
      type         = "UserAssigned"
      identity_ids = [azurerm_user_assigned_identity.aks.id]
    }
    network_profile {
      network_plugin    = "azure"
      load_balancer_sku = "standard"
      dns_service_ip    = "10.2.0.10"
      service_cidr      = "10.2.0.0/24"
    }
    depends_on = [
      azurerm_role_assignment.dns,
      azurerm_role_assignment.network
    ]
   }
   

3. Seguire la procedura per inizializzare Terraform, formattare e convalidare la configurazione terraform, creare un piano di esecuzione Terraform, applicare la configurazione terraform e connettersi al cluster del servizio Azure Kubernetes.

Crea un cluster privato di AKS con una zona DNS privata personalizzata e un sottodominio usando il comando az aks create.

Parametri chiave in questo comando:

• --enable-private-cluster: abilita la modalità cluster privato.
• --private-dns-zone <custom-private-dns-zone-resource-id>: ID risorsa di una zona DNS privata esistente nel formato seguente per Azure cloud globale: privatelink.<region>.azmk8s.io.
• --fqdn-subdomain <subdomain>Il sottodominio da usare per il FQDN del cluster all'interno della zona DNS privata personalizzata.
• --assign-identity <resource-id>: ID risorsa di un'identità gestita assegnata dall'utente con i ruoli Collaboratore zona DNS privato e Network Contributor.

az aks create \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --assign-identity <resource-id> \
    --private-dns-zone <custom-private-dns-zone-resource-id> \
    --fqdn-subdomain <subdomain> \
    --generate-ssh-keys

1. Seguire i passaggi da 1 a 3 in Creare un cluster del servizio Azure Kubernetes privato con rete avanzata o Creare un cluster del servizio Azure Kubernetes privato con rete di base predefinita per configurare la configurazione terraform e creare le risorse necessarie a seconda dello scenario. In questo esempio viene usata la rete avanzata.

2. Aggiungere il codice seguente a main.tf per creare un cluster privato del servizio Azure Kubernetes con una zona DNS privata personalizzata e un sottodominio.

   resource "azurerm_kubernetes_cluster" "this" {
    name                = var.aks_cluster_name
    location            = azurerm_resource_group.this.location
    resource_group_name = azurerm_resource_group.this.name
    dns_prefix          = "aks-subdomain"
    private_cluster_enabled = true
    private_dns_zone_id     = azurerm_private_dns_zone.aks.id
    fqdn_subdomain          = "team1"
    default_node_pool {
      name           = "system"
      node_count     = 1
      vm_size        = "Standard_DS2_v2"
      vnet_subnet_id = azurerm_subnet.aks.id
    }
    identity {
      type         = "UserAssigned"
      identity_ids = [azurerm_user_assigned_identity.aks.id]
    }
    network_profile {
      network_plugin    = "azure"
      load_balancer_sku = "standard"
      dns_service_ip    = "10.2.0.10"
      service_cidr      = "10.2.0.0/24"
    }
   }
   

3. Seguire la procedura per inizializzare Terraform, formattare e convalidare la configurazione terraform, creare un piano di esecuzione Terraform, applicare la configurazione terraform e connettersi al cluster del servizio Azure Kubernetes.

È possibile eseguire l'aggiornamento solo da byo (bring your own) o system a none. Non sono supportate altre combinazioni di valori di aggiornamento.

Aggiornare un cluster privato da byo o system a none usando il az aks update comando con il --private-dns-zone parametro impostato su none.

az aks update \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --private-dns-zone none

1. Aggiungere il seguente codice all'esistente main.tf per aggiornare il cluster AKS privato da una zona DNS privata a una pubblica. In questo esempio viene usata la rete avanzata. È possibile modificarlo per usare la rete di base predefinita modificando le risorse e i parametri Terraform pertinenti.

   resource "azurerm_kubernetes_cluster" "this" {
    name                = var.aks_cluster_name
    location            = azurerm_resource_group.this.location
    resource_group_name = azurerm_resource_group.this.name
    dns_prefix          = "aks-update"
    private_cluster_enabled = true
    private_dns_zone_id     = "None"
    default_node_pool {
      name           = "system"
      node_count     = 1
      vm_size        = "Standard_DS2_v2"
      vnet_subnet_id = azurerm_subnet.aks.id
    }
    identity {
      type         = "UserAssigned"
      identity_ids = [azurerm_user_assigned_identity.aks.id]
    }
    network_profile {
      network_plugin    = "azure"
      load_balancer_sku = "standard"
      dns_service_ip    = "10.2.0.10"
      service_cidr      = "10.2.0.0/24"
    }
   }
   

2. Applicare la configurazione aggiornata di Terraform utilizzando i comandi terraform plan e terraform apply.

   terraform plan
   terraform apply
   

Inizializzare Terraform

Inizializzare Terraform nella directory contenente il main.tf file usando il terraform init comando . Questo comando scarica il provider di Azure necessario per gestire le risorse Azure con Terraform.

terraform init

Formattare e convalidare la configurazione di Terraform

Formattare e convalidare la configurazione di Terraform usando i terraform fmt comandi e terraform validate .

terraform fmt
terraform validate

Crea un piano di esecuzione di Terraform

Creare un piano di esecuzione terraform usando il comando terraform plan. Questo comando mostra le risorse che Terraform creerà o modificherà nella sottoscrizione Azure.

terraform plan -var="subscription_id=<your-subscription-id>"

Applicare la configurazione di Terraform

Dopo aver esaminato e confermato il piano di esecuzione, applicare la configurazione di Terraform usando il terraform apply comando . Questo comando crea o modifica le risorse definite nel file main.tf nella sottoscrizione Azure.

terraform apply -var="subscription_id=<your-subscription-id>"