Criar um cluster de AKS (Serviço de Kubernetes do Azure) privado

• Terraform instalado localmente. Para obter instruções de instalação, consulte Instalar o Terraform.

Criar um grupo de recursos

Crie um grupo de recursos usando o comando az group create. Você também pode usar um grupo de recursos existente para seu cluster do AKS.

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

Crie um cluster privado com rede básica padrão usando o comando az aks create com o sinalizador --enable-private-cluster.

Parâmetros de chave neste comando:

• --enable-private-cluster: habilita o modo de cluster privado.

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

1. Crie um arquivo chamado main.tf e adicione o seguinte código para definir a versão do Terraform e especificar o provedor de 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. Adicione o código a seguir para main.tf para criar variáveis de entrada para sua ID de assinatura Azure, nome do grupo de recursos, local e nome do cluster do AKS. Você pode modificar os valores padrão conforme necessário.

   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. Adicione o seguinte código a main.tf para criar um grupo de recursos Azure:

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

4. Adicione o seguinte código a main.tf para criar um cluster privado do AKS com rede básica:

   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. Siga as etapas para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e conectar-se ao cluster do AKS.

Crie um cluster privado com rede avançada usando o az aks create comando.

Parâmetros de chave neste comando:

• --enable-private-cluster: habilita o modo de cluster privado.
• --network-plugin azure: especifica o plug-in de rede Azure CNI.
• --vnet-subnet-id <subnet-id>: o ID de recurso de uma sub-rede existente em uma VNet.
• --dns-service-ip <dns-service-ip>: um endereço IP disponível dentro do intervalo de endereços de serviço do Kubernetes a ser usado para o serviço DNS do cluster. Por exemplo, 10.2.0.10.
• --service-cidr <service-cidr>: um intervalo IP com notação CIDR do qual designar serviço de cluster IPs. Por exemplo, 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. Crie um arquivo chamado main.tf e adicione o seguinte código para definir a versão do Terraform e especificar o provedor de 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. Adicione o código a seguir para main.tf para criar variáveis de entrada para sua ID de assinatura Azure, nome do grupo de recursos, local, nome do cluster do AKS, nome da rede virtual (VNet) e nome da sub-rede. Você pode modificar os valores padrão conforme necessário.

   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. Adicione o seguinte código a main.tf para criar um grupo de recursos Azure, VNet e sub-rede:

   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. Adicione o seguinte código em main.tf para criar o cluster do AKS com rede avançada:

   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. Siga as etapas para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e conectar-se ao cluster do AKS.

Desabilite um FQDN público ao criar um cluster do AKS privado usando o comando az aks create com o sinalizador --disable-public-fqdn.

Parâmetros de chave neste comando:

• --disable-public-fqdn: desabilita o FQDN (nome de domínio totalmente qualificado) público para o servidor de API.
• --assign-identity <resource-id>: especifica a identidade gerenciada a ser usada para o cluster.
• --private-dns-zone [system|none]: especifica a zona DNS privada a ser usada para o cluster. system é o valor padrão ao configurar uma zona DNS privada. Se você omitir --private-dns-zone, o AKS criará uma zona DNS privada no grupo de recursos do nó. none desabilita a criação de uma zona DNS privada.

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. Siga as etapas 1 a 3 em Criar um cluster do AKS privado com rede avançada ou criar um cluster privado do AKS com rede básica padrão para configurar a configuração do Terraform e criar os recursos necessários dependendo do seu cenário. Este exemplo usa rede avançada.

2. Adicione o seguinte código em main.tf para criar um cluster AKS privado com uma identidade atribuída pelo usuário e o FQDN público desabilitado:

   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. Siga as etapas para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e conectar-se ao cluster do AKS.

Desabilite um FQDN público em um cluster do AKS existente usando o comando az aks update com o sinalizador --disable-public-fqdn.

Parâmetros de chave neste comando:

• --disable-public-fqdn: desabilita o FQDN (nome de domínio totalmente qualificado) público para o servidor de API.

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

1. Adicione o código a seguir ao existente main.tf para desabilitar o FQDN público em um cluster do AKS existente. Este exemplo usa rede avançada. Você pode modificá-la para usar a rede básica padrão alterando os parâmetros e os recursos do Terraform relevantes.

   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. Aplique a configuração atualizada do Terraform usando os comandos terraform plan e terraform apply.

   terraform plan
   terraform apply
   

Opções de configuração para DNS privado

Você pode definir configurações de DNS privadas para um cluster do AKS privado usando o CLI do Azure (com o parâmetro --private-dns-zone) ou um modelo de Azure Resource Manager (ARM) (com a propriedade privateDNSZone). A tabela a seguir descreve as opções disponíveis para o --private-dns-zone parâmetro/ privateDNSZone propriedade:

Considerações sobre DNS privado

Tenha as seguintes considerações em mente ao configurar o DNS privado para um cluster privado do AKS:

• Se a zona DNS privada estiver em uma assinatura diferente do cluster do AKS, você precisará registrar o provedor Microsoft.ContainerService Azure em ambas as assinaturas.
• Se o cluster do AKS estiver configurado com um principal de serviço do Active Directory, o AKS não oferece suporte para o uso de uma identidade gerenciada atribuída pelo sistema com uma zona DNS privada personalizada. O cluster deve usar a autenticação de identidade gerenciada atribuída pelo usuário.

Crie um cluster do AKS privado com uma zona DNS privada usando o az aks create comando.

Parâmetros de chave neste comando:

• --enable-private-cluster: habilita o modo de cluster privado.
• --private-dns-zone [system|none]: configura a zona DNS privada para o cluster. system é o valor padrão ao configurar uma zona DNS privada. Se você omitir --private-dns-zone, o AKS criará uma zona DNS privada no grupo de recursos do nó. none desabilita a criação de uma zona DNS privada.
• --assign-identity <resource-id>: o ID de recurso de uma identidade gerenciada atribuída pelo usuário com as funções Colaborador de Zona DNS Privada e Colaborador de Rede.

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. Siga as etapas 1 a 3 em Criar um cluster do AKS privado com rede avançada ou criar um cluster privado do AKS com rede básica padrão para configurar a configuração do Terraform e criar os recursos necessários dependendo do seu cenário. Este exemplo usa rede avançada.

2. Adicione o seguinte código para main.tf criar um cluster privado do AKS com uma zona DNS privada gerenciada pelo 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. Siga as etapas para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e conectar-se ao cluster do AKS.

Criar um cluster do AKS privado sem uma zona DNS privada

1. Siga as etapas 1 a 3 em Criar um cluster do AKS privado com rede avançada ou criar um cluster privado do AKS com rede básica padrão para configurar a configuração do Terraform e criar os recursos necessários dependendo do seu cenário. Este exemplo usa rede avançada.

2. Adicione o seguinte código para main.tf criar o cluster do AKS sem uma zona DNS privada:

   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. Siga as etapas para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e conectar-se ao cluster do AKS.

Crie um cluster do AKS privado com uma zona DNS privada personalizada ou subzone usando o az aks create comando.

Parâmetros de chave neste comando:

• --enable-private-cluster: habilita o modo de cluster privado.
• --private-dns-zone [<custom-private-dns-zone-resource-id>|<custom-private-dns-subzone-resource-id>]: O ID de recurso de uma zona ou subzona DNS privada existente no seguinte formato para nuvem global do Azure: privatelink.<region>.azmk8s.io ou <subzone>.privatelink.<region>.azmk8s.io.
• --assign-identity <resource-id>: o ID de recurso de uma identidade gerenciada atribuída pelo usuário com as funções Colaborador de Zona DNS Privada e Colaborador de Rede.

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

Ao usar uma zona DNS privada personalizada, você é responsável por criar e gerenciar a infraestrutura DNS em vez de depender do DNS gerenciado por Azure. Isso inclui criar a zona DNS, vinculá-la à sua VNet e atribuir as permissões necessárias para o AKS gerenciar registros.

Para configurações de DNS personalizadas, você deve usar uma identidade gerenciada atribuída pelo usuário com as funções DNS privado Zone Contributor e Network Contributor.

1. Siga as etapas 1 a 3 em Criar um cluster do AKS privado com rede avançada ou criar um cluster privado do AKS com rede básica padrão para configurar a configuração do Terraform e criar os recursos necessários dependendo do seu cenário. Este exemplo usa rede avançada.

2. Adicione o código em main.tf para criar um cluster AKS privado com uma zona DNS privada personalizada ou subzona:

   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. Siga as etapas para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e conectar-se ao cluster do AKS.

Crie um cluster do AKS privado com uma zona DNS privada personalizada e um subdomínio usando o az aks create comando.

Parâmetros de chave neste comando:

• --enable-private-cluster: habilita o modo de cluster privado.
• --private-dns-zone <custom-private-dns-zone-resource-id>: O ID do recurso de uma zona DNS privada existente no seguinte formato para a nuvem global do Azure: privatelink.<region>.azmk8s.io.
• --fqdn-subdomain <subdomain>: o subdomínio a ser usado para o FQDN do cluster dentro da zona DNS privada personalizada.
• --assign-identity <resource-id>: o ID de recurso de uma identidade gerenciada atribuída pelo usuário com as funções Colaborador de Zona DNS Privada e Colaborador de Rede.

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. Siga as etapas 1 a 3 em Criar um cluster do AKS privado com rede avançada ou criar um cluster privado do AKS com rede básica padrão para configurar a configuração do Terraform e criar os recursos necessários dependendo do seu cenário. Este exemplo usa rede avançada.

2. Adicione o seguinte código para main.tf criar um cluster privado do AKS com uma zona DNS privada personalizada e um subdomínio:

   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. Siga as etapas para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e conectar-se ao cluster do AKS.

Você apenas pode atualizar de byo (traga seu próprio) ou system para none. Não há suporte para nenhuma outra combinação de valores de atualização.

Atualize um cluster privado de byo ou system para none usando o comando az aks update com o parâmetro --private-dns-zone definido como none.

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

1. Adicione o código a seguir ao existente main.tf para atualizar o cluster do AKS privado de uma zona DNS privada para pública. Este exemplo usa rede avançada. Você pode modificá-la para usar a rede básica padrão alterando os parâmetros e os recursos do Terraform relevantes.

   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. Aplique a configuração atualizada do Terraform usando os comandos terraform plan e terraform apply.

   terraform plan
   terraform apply
   

Inicializar Terraform

Inicialize o Terraform no diretório que contém o main.tf arquivo usando o terraform init comando. Esse comando baixa o provedor de Azure necessário para gerenciar Azure recursos com o Terraform.

terraform init

Formatar e validar a configuração do Terraform

Formate e valide a configuração do Terraform usando os comandos terraform fmt e terraform validate.

terraform fmt
terraform validate

Criar um plano de execução do Terraform

Crie um plano de execução do Terraform usando o comando terraform plan. Este comando mostra os recursos que o Terraform criará ou modificará em sua assinatura Azure.

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

Aplicar a configuração do Terraform

Depois de examinar e confirmar o plano de execução, aplique a configuração do Terraform usando o terraform apply comando. Esse comando cria ou modifica os recursos definidos em seu arquivo de main.tf em sua assinatura de Azure.

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