Início Rápido: Criar um circuito do ExpressRoute e um gateway de rede virtual com o Terraform

Neste início rápido, você usará o Terraform para criar um circuito do Azure ExpressRoute e sua infraestrutura associada. O modelo Terraform cria uma configuração completa do ExpressRoute que inclui uma rede virtual, um gateway do ExpressRoute, a configuração do circuito e o emparelhamento privado. Todos os recursos são implantados com parâmetros configuráveis que permitem personalizar a implantação para seus requisitos específicos.

O Terraform permite a definição, a visualização e a implantação da infraestrutura de nuvem. Usando o Terraform, você cria arquivos de configuração usando sintaxe de HCL. A sintaxe da HCL permite que você especifique o provedor de nuvem, como o Azure, e os elementos que compõem sua infraestrutura de nuvem. Depois de criar os arquivos de configuração, você cria um plano de execução que permite visualizar as alterações de infraestrutura antes de serem implantadas. Depois de verificar as alterações, aplique o plano de execução para implantar a infraestrutura.

Neste artigo, você aprenderá como:

Pré-requisitos

• Criar uma conta do Azure com uma assinatura ativa. Você pode criar uma conta gratuitamente.

• instale e configure o Terraform.

Implementar o código do Terraform

1. Crie um diretório no qual testar e executar o código de exemplo do Terraform e faça dele o diretório atual.

2. Crie um arquivo chamado main.tf, depois insira o código a seguir:

   # Create Resource Group
   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
     tags     = var.tags
   }
   
   # Random String for unique naming
   resource "random_string" "name" {
     length  = 8
     special = false
     upper   = false
     lower   = true
     numeric = false
   }
   
   # Create Virtual Network
   resource "azurerm_virtual_network" "vnet" {
     name                = "vnet-${random_string.name.result}"
     address_space       = var.virtual_network_address_space
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
     tags                = var.tags
   }
   
   # Create ExpressRoute Gateway using Azure Verified Module with HOBO
   module "expressroute_gateway" {
     source  = "Azure/avm-ptn-vnetgateway/azurerm"
     version = "~> 0.10.0"
   
     # Basic Configuration
     location  = azurerm_resource_group.rg.location
     name      = "vgw-${random_string.name.result}"
     parent_id = azurerm_resource_group.rg.id
   
     # ExpressRoute Gateway Configuration
     type                                  = "ExpressRoute"
     sku                                   = var.gateway_sku
     hosted_on_behalf_of_public_ip_enabled = var.enable_hosted_on_behalf_of_public_ip # Enable Azure-managed public IP (HOBO)
   
     # Virtual Network Configuration
     virtual_network_id    = azurerm_virtual_network.vnet.id
     subnet_address_prefix = var.gateway_subnet_address_prefix # GatewaySubnet CIDR
   
     # Optional: Enable telemetry for Azure Verified Module
     enable_telemetry = true
   
     # Express Route Circuit Connection (if circuit is provided)
     express_route_circuits = var.express_route_circuit_id != null ? {
       "primary" = {
         id = var.express_route_circuit_id
         connection = {
           authorization_key = var.express_route_authorization_key
         }
       }
     } : {}
   
     tags = merge(var.tags, {
       environment  = "production"
       project      = "expressroute-hobo"
       gateway_type = "ExpressRoute"
       deployment   = "azure-verified-module"
     })
   
     depends_on = [azurerm_virtual_network.vnet]
   }
   
   # Create ExpressRoute Circuit (if enabled)
   resource "azurerm_express_route_circuit" "circuit" {
     count = var.create_express_route_circuit ? 1 : 0
   
     name                  = "erc-${random_string.name.result}"
     resource_group_name   = azurerm_resource_group.rg.name
     location              = azurerm_resource_group.rg.location
     service_provider_name = var.service_provider_name
     peering_location      = var.peering_location
     bandwidth_in_mbps     = var.bandwidth_in_mbps
   
     sku {
       tier   = var.circuit_sku_tier
       family = var.circuit_sku_family
     }
   
     tags = merge(var.tags, {
       environment = "production"
       project     = "expressroute-hobo"
     })
   }
   
   # Create ExpressRoute Circuit Peering (if circuit is created)
   resource "azurerm_express_route_circuit_peering" "private" {
     count = var.create_express_route_circuit && var.create_private_peering ? 1 : 0
   
     peering_type                  = "AzurePrivatePeering"
     express_route_circuit_name    = azurerm_express_route_circuit.circuit[0].name
     resource_group_name           = azurerm_resource_group.rg.name
     primary_peer_address_prefix   = var.primary_peer_address_prefix
     secondary_peer_address_prefix = var.secondary_peer_address_prefix
     vlan_id                       = var.vlan_id
     peer_asn                      = var.peer_asn
   }
   

3. Crie um arquivo chamado outputs.tf, depois insira o código a seguir:

   output "resource_group_name" {
     description = "Name of the resource group"
     value       = azurerm_resource_group.rg.name
   }
   
   output "express_route_circuit_id" {
     description = "ID of the ExpressRoute circuit (if created)"
     value       = var.create_express_route_circuit ? azurerm_express_route_circuit.circuit[0].id : null
   }
   
   output "express_route_circuit_service_key" {
     description = "Service key for the ExpressRoute circuit (if created)"
     value       = var.create_express_route_circuit ? azurerm_express_route_circuit.circuit[0].service_key : null
     sensitive   = true
   }
   
   output "gateway_id" {
     description = "ID of the ExpressRoute Virtual Network Gateway"
     value       = module.expressroute_gateway.virtual_network_gateway.id
   }
   
   output "gateway_name" {
     description = "Name of the ExpressRoute Virtual Network Gateway"
     value       = module.expressroute_gateway.virtual_network_gateway.name
   }
   
   output "gateway_subnet_id" {
     description = "ID of the GatewaySubnet created by the module"
     value       = module.expressroute_gateway.subnet.id
   }
   
   output "hosted_on_behalf_of_public_ip_note" {
     description = "Information about the Azure-managed public IP for ExpressRoute gateway"
     value       = "This ExpressRoute Virtual Network Gateway uses an Azure-managed public IP address. The public IP is automatically provisioned and managed by Azure, and is not visible in your subscription's public IP resources. This feature is only available for ExpressRoute gateways, not VPN gateways."
   }
   
   output "public_ip_addresses" {
     description = "Public IP addresses created by the module (empty when using HOBO for ExpressRoute)"
     value       = module.expressroute_gateway.public_ip_addresses
   }
   
   output "virtual_network_id" {
     description = "ID of the virtual network"
     value       = azurerm_virtual_network.vnet.id
   }
   
   output "virtual_network_gateway_connections" {
     description = "Virtual Network Gateway Connections created by the module"
     value       = module.expressroute_gateway.virtual_network_gateway_connections
   }
   

4. Crie um arquivo chamado providers.tf, depois insira o código a seguir:

   terraform {
     required_version = ">= 1.3"
   
     required_providers {
       azapi = {
         source  = "Azure/azapi"
         version = "~> 2.4"
       }
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~> 4.0"
       }
       random = {
         source  = "hashicorp/random"
         version = "~> 3.5"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   

5. Crie um arquivo chamado variables.tf, depois insira o código a seguir:

   variable "resource_group_location" {
     type        = string
     default     = "eastus"
     description = "Location of the resource group."
   }
   
   variable "resource_group_name_prefix" {
     type        = string
     default     = "rg"
     description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
   }
   
   variable "tags" {
     type        = map(string)
     default     = {}
     description = "A map of tags to assign to all resources."
   }
   
   # Virtual Network Configuration
   variable "virtual_network_address_space" {
     type        = list(string)
     default     = ["10.0.0.0/16"]
     description = "The address space that is used by the virtual network."
   
     validation {
       condition     = length(var.virtual_network_address_space) > 0
       error_message = "At least one address space must be provided."
     }
   }
   
   variable "gateway_subnet_address_prefix" {
     type        = string
     default     = "10.0.0.0/24"
     description = "The address prefix for the GatewaySubnet. Must be at least /29."
   
     validation {
       condition     = can(cidrhost(var.gateway_subnet_address_prefix, 0)) && tonumber(split("/", var.gateway_subnet_address_prefix)[1]) <= 29
       error_message = "gateway_subnet_address_prefix must be a valid CIDR block with at least /29 prefix."
     }
   }
   
   # ExpressRoute Gateway Configuration
   variable "gateway_sku" {
     type        = string
     default     = "ErGw1AZ"
     description = "The SKU of the ExpressRoute Virtual Network Gateway. Valid values: ErGw1AZ, ErGw2AZ, ErGw3AZ, ErGwScale, HighPerformance, Standard, UltraPerformance."
   
     validation {
       condition     = contains(["ErGw1AZ", "ErGw2AZ", "ErGw3AZ", "ErGwScale", "HighPerformance", "Standard", "UltraPerformance"], var.gateway_sku)
       error_message = "gateway_sku must be one of: ErGw1AZ, ErGw2AZ, ErGw3AZ, ErGwScale, HighPerformance, Standard, UltraPerformance."
     }
   }
   
   variable "enable_hosted_on_behalf_of_public_ip" {
     type        = bool
     default     = true
     description = "Enable Azure-managed public IP for the ExpressRoute gateway (HOBO feature). When enabled, Azure manages the public IP internally and it won't appear in your subscription."
   }
   
   # ExpressRoute Circuit Configuration
   variable "create_express_route_circuit" {
     type        = bool
     default     = true
     description = "Whether to create an ExpressRoute circuit. Set to false if you want to connect to an existing circuit."
   }
   
   variable "express_route_circuit_id" {
     type        = string
     default     = null
     description = "ID of an existing ExpressRoute circuit to connect to. Only used if create_express_route_circuit is false."
   }
   
   variable "express_route_authorization_key" {
     type        = string
     default     = null
     description = "Authorization key for connecting to an existing ExpressRoute circuit."
     sensitive   = true
   }
   
   variable "service_provider_name" {
     type        = string
     default     = "Equinix"
     description = "The name of the ExpressRoute circuit service provider."
   }
   
   variable "peering_location" {
     type        = string
     default     = "Washington DC"
     description = "The name of the peering location and not the Azure resource location."
   }
   
   variable "bandwidth_in_mbps" {
     type        = number
     default     = 50
     description = "The bandwidth in Mbps of the ExpressRoute circuit."
   
     validation {
       condition     = contains([50, 100, 200, 500, 1000, 2000, 5000, 10000], var.bandwidth_in_mbps)
       error_message = "bandwidth_in_mbps must be one of: 50, 100, 200, 500, 1000, 2000, 5000, 10000."
     }
   }
   
   variable "circuit_sku_tier" {
     type        = string
     default     = "Standard"
     description = "The service tier of the ExpressRoute circuit SKU."
   
     validation {
       condition     = contains(["Basic", "Local", "Standard", "Premium"], var.circuit_sku_tier)
       error_message = "circuit_sku_tier must be one of: Basic, Local, Standard, Premium."
     }
   }
   
   variable "circuit_sku_family" {
     type        = string
     default     = "MeteredData"
     description = "The billing mode for the ExpressRoute circuit SKU."
   
     validation {
       condition     = contains(["MeteredData", "UnlimitedData"], var.circuit_sku_family)
       error_message = "circuit_sku_family must be either MeteredData or UnlimitedData."
     }
   }
   
   # ExpressRoute Private Peering Configuration
   variable "create_private_peering" {
     type        = bool
     default     = true
     description = "Whether to create Azure Private Peering for the ExpressRoute circuit."
   }
   
   variable "primary_peer_address_prefix" {
     type        = string
     default     = "192.168.10.16/30"
     description = "A /30 subnet for the primary link."
   
     validation {
       condition     = can(cidrhost(var.primary_peer_address_prefix, 0))
       error_message = "primary_peer_address_prefix must be a valid CIDR block."
     }
   }
   
   variable "secondary_peer_address_prefix" {
     type        = string
     default     = "192.168.10.20/30"
     description = "A /30 subnet for the secondary link."
   
     validation {
       condition     = can(cidrhost(var.secondary_peer_address_prefix, 0))
       error_message = "secondary_peer_address_prefix must be a valid CIDR block."
     }
   }
   
   variable "vlan_id" {
     type        = number
     default     = 200
     description = "A valid VLAN ID to establish this peering on."
   
     validation {
       condition     = var.vlan_id >= 1 && var.vlan_id <= 4094
       error_message = "vlan_id must be between 1 and 4094."
     }
   }
   
   variable "peer_asn" {
     type        = number
     default     = 65001
     description = "A valid private ASN for the customer side BGP session."
   
     validation {
       condition     = (var.peer_asn >= 64512 && var.peer_asn <= 65534) || (var.peer_asn >= 4200000000 && var.peer_asn <= 4294967294)
       error_message = "peer_asn must be a valid private ASN (64512-65534 or 4200000000-4294967294)."
     }
   }
   

Inicializar Terraform

Execute terraform init para inicializar a implantação do Terraform. Esse comando baixa o provedor do Azure necessário para gerenciar seus recursos do Azure.

terraform init -upgrade

Pontos principais:

• O parâmetro -upgrade atualiza os plug-ins do provedor necessários para a versão mais recente que esteja em conformidade com as restrições de versão da configuração.

Criar um plano de execução Terraform

Execute o comando terraform plan para criar um plano de execução.

terraform plan -out main.tfplan

Pontos principais:

• O comando terraform plan cria um plano de execução, mas não o executa. Em vez disso, ele determina quais ações são necessárias para criar a configuração especificada em seus arquivos de configuração. Esse padrão permite que você verifique se o plano de execução corresponde às suas expectativas antes de fazer qualquer alteração nos recursos reais.
• O parâmetro opcional -out permite que você especifique um arquivo de saída para o plano. Usar o parâmetro -out garante que o plano que você examinou seja exatamente o que é aplicado.

Aplicar um plano de execução do Terraform

Execute terraform apply para aplicar o plano de execução à sua infraestrutura de nuvem.

terraform apply main.tfplan

Pontos principais:

• O comando de exemplo terraform apply pressupõe que você já executou terraform plan -out main.tfplan.
• Se você especificou um nome de arquivo diferente para o parâmetro -out, use esse mesmo nome de arquivo na chamada para terraform apply.
• Se você não usou o parâmetro -out, chame terraform apply sem nenhum parâmetro.

Verifique os resultados

Limpar os recursos

Quando você não precisar mais dos recursos criados por meio o Terraform, execute as seguintes etapas:

1. Execute terraform plan e especifique o sinalizador destroy.

   terraform plan -destroy -out main.destroy.tfplan
   

   Pontos principais:

   • O comando terraform plan cria um plano de execução, mas não o executa. Em vez disso, ele determina quais ações são necessárias para criar a configuração especificada em seus arquivos de configuração. Esse padrão permite que você verifique se o plano de execução corresponde às suas expectativas antes de fazer qualquer alteração nos recursos reais.
   • O parâmetro opcional -out permite que você especifique um arquivo de saída para o plano. Usar o parâmetro -out garante que o plano que você examinou seja exatamente o que é aplicado.

2. Execute a aplicação do Terraform para aplicar o plano de execução.

   terraform apply main.destroy.tfplan
   

Solucionar problemas do Terraform no Azure

Solucionar problemas comuns ao usar o Terraform no Azure.

Próximas etapas

Veja mais artigos sobre o gateway de rede virtual do Azure.

Para saber como vincular uma rede virtual a um circuito, prossiga para os tutoriais do ExpressRoute.