Guia de início rápido: criar um gateway NAT

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.

• Azure Cloud Shell ou Azure PowerShell.

  As etapas neste início rápido executam os cmdlets do Azure PowerShell interativamente no Azure Cloud Shell. Para executar os comandos no Cloud Shell, selecione Abrir Cloudshell no canto superior direito de um bloco de código. Selecione Copiar para copiar o código e cole-o no Cloud Shell para executá-lo. Você também pode executar o Cloud Shell de dentro do portal do Azure.

  Você também pode instalar o Azure PowerShell localmente para executar os cmdlets. As etapas neste artigo exigem o módulo do Azure PowerShell versão 5.4.1 ou posterior. Execute Get-Module -ListAvailable Az para encontrar a versão instalada. Se você precisar atualizar, consulte Atualizar o módulo do Azure PowerShell.

Se não tiver uma conta do Azure, crie uma conta gratuita antes de começar.

• Utilize o ambiente Bash no Azure Cloud Shell. Para mais informações, veja Get started with Azure Cloud Shell.

  

• Se preferir executar comandos de referência da CLI localmente, instale o CLI do Azure. Se estiver a usar Windows ou macOS, considere executar o Azure CLI num contentor Docker. Para obter mais informações, consulte Como executar a CLI do Azure em um contêiner do Docker.

  • Se você estiver usando uma instalação local, entre na CLI do Azure usando o comando az login . Para concluir o processo de autenticação, siga os passos exibidos no seu terminal. Para outras opções de entrada, consulte Autenticar no Azure usando a CLI do Azure.

  • Quando solicitado, instale a extensão do Azure CLI na primeira utilização. Para obter mais informações sobre extensões, consulte Usar e gerenciar extensões com a CLI do Azure.

  • Execute az version para descobrir a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.

• Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.

Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.

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

• Instale e configure o Terraform.

Criar um gateway NAT

Antes de implantar o recurso de gateway NAT e os outros recursos, um grupo de recursos é necessário para conter os recursos implantados. Nas etapas a seguir, você cria um grupo de recursos, um recurso de gateway NAT e um endereço IP público. Você pode usar um ou mais recursos de endereço IP público, prefixos IP públicos ou ambos.

Para obter informações sobre prefixos IP públicos e um gateway NAT, consulte Gerir gateway NAT.

1. Na caixa de pesquisa na parte superior do portal, digite NAT gateway. Selecione NAT Gateways nos resultados da pesquisa.

2. Selecione + Criar.

3. Em Criar gateway NAT (conversão de endereços de rede), insira ou selecione essas informações na guia Noções básicas :

   Configuração	Valor
   Detalhes do Projeto
   Subscrição	Selecione sua assinatura do Azure.
   Grupo de Recursos	Selecione Criar novo. Digite test-rg. Selecione OK.
   Detalhes da instância
   Nome do gateway NAT	Aceder ao nat-gateway
   Região	Selecione Leste dos EUA 2
   Zona de Disponibilidade	Selecione Sem zona.
   Tempo limite de inatividade TCP (minutos)	Deixe o padrão de 4.

   Para obter informações sobre zonas de disponibilidade e gateway NAT, consulte Gateway NAT e zonas de disponibilidade.

4. Selecione o separador IP de Saída ou clique no botão Seguinte: IP de Saída na parte inferior da página.

5. Na guia IP de saída, insira ou selecione as seguintes informações:

   Configuração	Valor
   Endereços IP públicos	Selecione Criar um novo endereço IP público. Em Nome, insira public-ip-nat. Selecione OK.

6. Selecione a aba Rever + criar ou selecione o botão azul Rever + criar na parte inferior da página.

7. Selecione Criar.

Criar uma rede virtual e um host bastion

O procedimento a seguir cria uma rede virtual com uma sub-rede de recursos, uma sub-rede do Azure Bastion e um host do Azure Bastion.

1. No portal, procure e selecione Redes virtuais.

2. Na página Redes virtuais , selecione + Criar.

3. Na guia Noções básicas de Criar rede virtual, insira ou selecione as seguintes informações:

   Configurações	Valor
   Detalhes do projeto
   Subscrição	Selecione a sua subscrição.
   Grupo de recursos	Selecione test-rg.
   Detalhes da instância
   Nome	Insira vnet-1.
   Região	Selecione (EUA) Leste dos EUA 2.

   

4. Selecione Avançar para prosseguir para a guia Segurança .

5. Selecione Habilitar Bastião do Azure na seção Bastião do Azure da guia Segurança .

   O Azure Bastion utiliza o seu navegador para se conectar a máquinas virtuais na sua rede virtual, através de secure shell (SSH) ou do protocolo de ambiente de trabalho remoto (RDP), utilizando os seus endereços IP privados. As VMs não precisam de endereços IP públicos, software cliente ou configuração especial. Para obter mais informações sobre o Azure Bastion, consulte Azure Bastion

   Observação

   A faturação horária inicia-se no momento em que o Bastion é implantado, independentemente do uso de dados enviados. Para obter mais informações, consulte Preços e SKUs. Se estiver a implementar o Bastion como parte de um tutorial ou teste, recomendamos que elimine este recurso após terminar de o utilizar.

6. Insira ou selecione as seguintes informações no Azure Bastion:

   Configurações	Valor
   Nome do host do Azure Bastion	Entre bastião.
   Endereço IP público do Azure Bastion	Selecione Criar um endereço IP público. Digite public-ip-bastion em Name. Selecione OK.

   

7. Selecione Avançar para ir para o separador Endereços IP.

8. Na caixa de espaço de endereço em Sub-redes, selecione a sub-rede padrão .

9. Em Editar sub-rede, insira ou selecione as seguintes informações:

   Configurações	Valor
   Finalidade da sub-rede	Deixe o padrão Default.
   Nome	Introduza subnet-1.
   IPv4
   Intervalo de endereços IPv4	Deixe o padrão de 10.0.0.0/16.
   Endereço inicial	Deixe o padrão de 10.0.0.0.
   Tamanho	Deixe o padrão de /24(256 endereços).
   Segurança
   Porta de entrada NAT	Selecione nat-gateway.

   

10. Selecione Guardar.

11. Selecione Rever + criar na parte inferior do ecrã e, quando a validação for aprovada, selecione Criar.

Criar máquina virtual de teste

O procedimento a seguir cria uma máquina virtual (VM) de teste chamada vm-1 na rede virtual.

1. No portal, procure e selecione Máquinas virtuais.

2. Em Máquinas virtuais, selecione + Criar e, em seguida , Máquina virtual do Azure.

3. Na guia Noções básicas de Criar uma máquina virtual, insira ou selecione as seguintes informações:

   Configurações	Valor
   Detalhes do projeto
   Subscrição	Selecione a sua subscrição.
   Grupo de recursos	Selecione test-rg.
   Detalhes da instância
   Nome da máquina virtual	Introduza vm-1.
   Região	Selecione Leste dos EUA 2.
   Opções de disponibilidade	Selecione Sem necessidade de redundância de infraestrutura.
   Tipo de segurança	Deixe o valor predefinido de Padrão.
   Imagem	Selecione Ubuntu Server 22.04 LTS - x64 Gen2.
   Arquitetura VM	Deixe o padrão de x64.
   Tamanho	Selecione um tamanho.
   Conta de administrador
   Tipo de autenticação	Selecione Senha.
   Nome de utilizador	Insira azureuser.
   Palavra-passe	Introduza uma palavra-passe.
   Confirme a palavra-passe	Reintroduza a palavra-passe.
   Regras de porta de entrada
   Portas de entrada públicas	Selecione Nenhum.

4. Selecione o separador Redes na parte superior da página.

5. Insira ou selecione as seguintes informações no separador Rede:

   Configurações	Valor
   Interface de Rede
   Rede virtual	Selecione vnet-1.
   sub-rede	Seleccione subnet-1 (10.0.0.0/24).
   IP público	Selecione Nenhum.
   Grupo de segurança de rede NIC	Selecione Avançado.
   Configurar grupo de segurança de rede	Selecione Criar novo. Digite nsg-1 para o nome. Deixe o restante nos padrões e selecione OK.

6. Deixe o restante das configurações nos padrões e selecione Revisar + criar.

7. Revise as configurações e selecione Criar.

Criar um grupo de recursos

Crie um grupo de recursos com New-AzResourceGroup. Um grupo de recursos do Azure é um contêiner lógico no qual recursos do Azure são implantados e geridos.

O exemplo a seguir cria um grupo de recursos chamado test-rg no local eastus2:

$rsg = @{
    Name = 'test-rg'
    Location = 'eastus2'
}
New-AzResourceGroup @rsg

Criar o gateway NAT

Nesta seção, crie o gateway NAT e os recursos de suporte.

## Create public IP address for NAT gateway ##
$ip = @{
    Name = 'public-ip-nat'
    ResourceGroupName = 'test-rg'
    Location = 'eastus2'
    Sku = 'Standard'
    AllocationMethod = 'Static'
    Zone = 1,2,3
}
$publicIP = New-AzPublicIpAddress @ip

## Create NAT gateway resource ##
$nat = @{
    ResourceGroupName = 'test-rg'
    Name = 'nat-gateway'
    IdleTimeoutInMinutes = '10'
    Sku = 'Standard'
    Location = 'eastus2'
    PublicIpAddress = $publicIP
}
$natGateway = New-AzNatGateway @nat

## Create subnet config and associate NAT gateway to subnet##
$subnet = @{
    Name = 'subnet-1'
    AddressPrefix = '10.0.0.0/24'
    NatGateway = $natGateway
}
$subnetConfig = New-AzVirtualNetworkSubnetConfig @subnet 

## Create Azure Bastion subnet ##
$bastsubnet = @{
    Name = 'AzureBastionSubnet' 
    AddressPrefix = '10.0.1.0/26'
}
$bastsubnetConfig = New-AzVirtualNetworkSubnetConfig @bastsubnet

## Create the virtual network ##
$net = @{
    Name = 'vnet-1'
    ResourceGroupName = 'test-rg'
    Location = 'eastus2'
    AddressPrefix = '10.0.0.0/16'
    Subnet = $subnetConfig,$bastsubnetConfig
}
$vnet = New-AzVirtualNetwork @net

## Create public IP address for bastion host ##
$ip = @{
    Name = 'public-ip'
    ResourceGroupName = 'test-rg'
    Location = 'eastus2'
    Sku = 'Standard'
    AllocationMethod = 'Static'
    Zone = 1,2,3
}
$publicip = New-AzPublicIpAddress @ip

## Create bastion host ##
$bastion = @{
    Name = 'bastion'
    ResourceGroupName = 'test-rg'
    PublicIpAddressRgName = 'test-rg'
    PublicIpAddressName = 'public-ip'
    VirtualNetworkRgName = 'test-rg'
    VirtualNetworkName = 'vnet-1'
    Sku = 'Basic'
}
New-AzBastion @bastion

O host bastion pode levar vários minutos para ser implantado. Aguarde a implantação do bastion host antes de passar para a próxima seção.

Criar a máquina virtual

Nesta seção, você cria uma máquina virtual para testar o gateway NAT e verificar o endereço IP público da conexão de saída.

# Set the administrator and password for the VM ##
$cred = Get-Credential

## Place the virtual network into a variable ##
$vnet = Get-AzVirtualNetwork -Name 'vnet-1' -ResourceGroupName 'test-rg'

## Create network interface for virtual machine ##
$nic = @{
    Name = "nic-1"
    ResourceGroupName = 'test-rg'
    Location = 'eastus2'
    Subnet = $vnet.Subnets[0]
}
$nicVM = New-AzNetworkInterface @nic

## Create a virtual machine configuration ##
$vmsz = @{
    VMName = 'vm-1'
    VMSize = 'Standard_DS1_v2'  
}
$vmos = @{
    ComputerName = 'vm-1'
    Credential = $cred
}
$vmimage = @{
    PublisherName = 'Canonical'
    Offer = '0001-com-ubuntu-server-jammy'
    Skus = '22_04-lts-gen2'
    Version = 'latest'     
}
$vmConfig = New-AzVMConfig @vmsz `
    | Set-AzVMOperatingSystem @vmos -Linux `
    | Set-AzVMSourceImage @vmimage `
    | Add-AzVMNetworkInterface -Id $nicVM.Id

## Create the virtual machine ##
$vm = @{
    ResourceGroupName = 'test-rg'
    Location = 'eastus2'
    VM = $vmConfig
}
New-AzVM @vm

Aguarde a conclusão da criação da máquina virtual antes de passar para a próxima seção.

Criar um grupo de recursos

Crie um grupo de recursos com az group create. Um grupo de recursos do Azure é um contêiner lógico no qual recursos do Azure são implantados e geridos.

az group create \
    --name test-rg \
    --___location eastus2

Criar o gateway NAT

Nesta seção, crie o gateway NAT e os recursos de suporte.

Criar endereço IP público

Para acessar a Internet, você precisa de um ou mais endereços IP públicos para o gateway NAT. Use az network public-ip create para criar um recurso de endereço IP público.

az network public-ip create \
    --resource-group test-rg \
    --name public-ip-nat \
    --sku Standard \
    --allocation-method Static \
    --___location eastus2 \
    --zone 1 2 3

Criar recurso de gateway NAT

Crie um recurso de gateway NAT usando az network nat gateway create. O gateway NAT usa o endereço IP público criado na etapa anterior. O tempo limite de inatividade é definido como 10 minutos.

az network nat gateway create \
    --resource-group test-rg \
    --name nat-gateway \
    --public-ip-addresses public-ip-nat \
    --idle-timeout 10

Criar rede virtual e sub-rede

Crie uma rede virtual chamada vnet-1 com uma sub-rede chamada subnet-1 usando az network vnet create. O espaço de endereço IP para a rede virtual é 10.0.0.0/16. A sub-rede dentro da rede virtual é 10.0.0.0/24.

az network vnet create \
    --resource-group test-rg \
    --name vnet-1 \
    --address-prefix 10.0.0.0/16 \
    --subnet-name subnet-1 \
    --subnet-prefixes 10.0.0.0/24

Criar sub-rede do Azure Bastion

Crie uma sub-rede do Azure Bastion chamada AzureBastionSubnet usando az network vnet subnet create:

az network vnet subnet create \
    --name AzureBastionSubnet \
    --resource-group test-rg \
    --vnet-name vnet-1 \
    --address-prefix 10.0.1.0/26

Associar gateway NAT à sub-rede

Associe o gateway NAT à sub-rede usando o comando az network vnet subnet update:

az network vnet subnet update \
    --resource-group test-rg \
    --vnet-name vnet-1 \
    --name subnet-1 \
    --nat-gateway nat-gateway

Criar endereço IP público para o host Bastion

Crie um endereço IP público para o host Bastion usando az network public-ip create:

az network public-ip create \
    --resource-group test-rg \
    --name public-ip \
    --sku Standard \
    --___location eastus2 \
    --zone 1 2 3

Criar servidor Bastion

Crie o host do Azure Bastion usando az network bastion create:

az network bastion create \
    --name bastion \
    --public-ip-address public-ip \
    --resource-group test-rg \
    --vnet-name vnet-1 \
    --___location eastus2

O host Bastion pode levar vários minutos para ser implantado. Aguarde pela implantação do host Bastion antes de avançar para a próxima secção.

Criar a máquina virtual

Crie uma máquina virtual chamada vm-1 para testar o gateway NAT e verificar o endereço IP público da conexão de saída. Use az vm create:

az vm create \
    --resource-group test-rg \
    --name vm-1 \
    --image Ubuntu2204 \
    --admin-username azureuser \
    --authentication-type password \
    --public-ip-address "" \
    --subnet subnet-1 \
    --vnet-name vnet-1

Aguarde a conclusão da criação da máquina virtual antes de passar para a próxima seção.

Um modelo do Azure Resource Manager é um arquivo JSON (JavaScript Object Notation) que define a infraestrutura e a configuração do seu projeto. O modelo usa sintaxe declarativa. Você descreve a implantação pretendida sem escrever a sequência de comandos de programação para criar a implantação.

Se o seu ambiente cumpre os pré-requisitos e se está familiarizado com a utilização de modelos ARM, selecione o botão Implementar no Azure. O modelo é aberto no portal do Azure.

Rever o modelo

O modelo utilizado neste início rápido pertence aos Modelos de Início Rápido do Azure.

Este modelo está configurado para criar um:

• Rede virtual

• Recurso de gateway NAT

• Máquina virtual Ubuntu

A máquina virtual do Ubuntu é implantada em uma sub-rede associada ao recurso de gateway NAT.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.37.4.10188",
      "templateHash": "15883485077174970612"
    }
  },
  "parameters": {
    "vmname": {
      "type": "string",
      "defaultValue": "vm-1",
      "metadata": {
        "description": "Name of the virtual machine"
      }
    },
    "vmsize": {
      "type": "string",
      "defaultValue": "Standard_D2s_v3",
      "metadata": {
        "description": "Size of the virtual machine"
      }
    },
    "vnetname": {
      "type": "string",
      "defaultValue": "vnet-1",
      "metadata": {
        "description": "Name of the virtual network"
      }
    },
    "subnetname": {
      "type": "string",
      "defaultValue": "subnet-1",
      "metadata": {
        "description": "Name of the subnet for virtual network"
      }
    },
    "vnetaddressspace": {
      "type": "string",
      "defaultValue": "10.0.0.0/16",
      "metadata": {
        "description": "Address space for virtual network"
      }
    },
    "vnetsubnetprefix": {
      "type": "string",
      "defaultValue": "10.0.0.0/24",
      "metadata": {
        "description": "Subnet prefix for virtual network"
      }
    },
    "natgatewayname": {
      "type": "string",
      "defaultValue": "nat-gateway",
      "metadata": {
        "description": "Name of the NAT gateway"
      }
    },
    "networkinterfacename": {
      "type": "string",
      "defaultValue": "nic-1",
      "metadata": {
        "description": "Name of the virtual machine nic"
      }
    },
    "publicipname": {
      "type": "string",
      "defaultValue": "public-ip-nat",
      "metadata": {
        "description": "Name of the NAT gateway public IP"
      }
    },
    "bastionName": {
      "type": "string",
      "defaultValue": "bastion-host",
      "metadata": {
        "description": "Name of the Bastion host"
      }
    },
    "nsgname": {
      "type": "string",
      "defaultValue": "nsg-1",
      "metadata": {
        "description": "Name of the virtual machine NSG"
      }
    },
    "adminusername": {
      "type": "string",
      "metadata": {
        "description": "Administrator username for virtual machine"
      }
    },
    "authenticationType": {
      "type": "string",
      "defaultValue": "sshPublicKey",
      "allowedValues": [
        "sshPublicKey",
        "password"
      ],
      "metadata": {
        "description": "Type of authentication to use on the Virtual Machine. SSH key is recommended."
      }
    },
    "adminPasswordOrKey": {
      "type": "securestring",
      "metadata": {
        "description": "SSH Key or password for the Virtual Machine. SSH key is recommended."
      }
    },
    "___location": {
      "type": "string",
      "defaultValue": "[resourceGroup().___location]",
      "metadata": {
        "description": "Name of resource group"
      }
    }
  },
  "variables": {
    "linuxConfiguration": {
      "disablePasswordAuthentication": true,
      "ssh": {
        "publicKeys": [
          {
            "path": "[format('/home/{0}/.ssh/authorized_keys', parameters('adminusername'))]",
            "keyData": "[parameters('adminPasswordOrKey')]"
          }
        ]
      }
    }
  },
  "resources": [
    {
      "type": "Microsoft.Network/networkSecurityGroups",
      "apiVersion": "2024-01-01",
      "name": "[parameters('nsgname')]",
      "___location": "[parameters('___location')]",
      "properties": {}
    },
    {
      "type": "Microsoft.Network/publicIPAddresses",
      "apiVersion": "2024-01-01",
      "name": "[parameters('publicipname')]",
      "___location": "[parameters('___location')]",
      "sku": {
        "name": "StandardV2"
      },
      "properties": {
        "publicIPAddressVersion": "IPv4",
        "publicIPAllocationMethod": "Static",
        "idleTimeoutInMinutes": 4
      }
    },
    {
      "type": "Microsoft.Compute/virtualMachines",
      "apiVersion": "2023-09-01",
      "name": "[parameters('vmname')]",
      "___location": "[parameters('___location')]",
      "properties": {
        "hardwareProfile": {
          "vmSize": "[parameters('vmsize')]"
        },
        "storageProfile": {
          "imageReference": {
            "publisher": "Canonical",
            "offer": "0001-com-ubuntu-server-jammy",
            "sku": "22_04-lts-gen2",
            "version": "latest"
          },
          "osDisk": {
            "osType": "Linux",
            "name": "[format('{0}_disk1', parameters('vmname'))]",
            "createOption": "FromImage",
            "caching": "ReadWrite",
            "managedDisk": {
              "storageAccountType": "Premium_LRS"
            },
            "diskSizeGB": 30
          }
        },
        "osProfile": {
          "computerName": "[parameters('vmname')]",
          "adminUsername": "[parameters('adminusername')]",
          "adminPassword": "[parameters('adminPasswordOrKey')]",
          "linuxConfiguration": "[if(equals(parameters('authenticationType'), 'password'), null(), variables('linuxConfiguration'))]"
        },
        "networkProfile": {
          "networkInterfaces": [
            {
              "id": "[resourceId('Microsoft.Network/networkInterfaces', parameters('networkinterfacename'))]"
            }
          ]
        }
      },
      "dependsOn": [
        "[resourceId('Microsoft.Network/networkInterfaces', parameters('networkinterfacename'))]"
      ]
    },
    {
      "type": "Microsoft.Network/virtualNetworks",
      "apiVersion": "2024-01-01",
      "name": "[parameters('vnetname')]",
      "___location": "[parameters('___location')]",
      "properties": {
        "addressSpace": {
          "addressPrefixes": [
            "[parameters('vnetaddressspace')]"
          ]
        },
        "subnets": [
          {
            "name": "[parameters('subnetname')]",
            "properties": {
              "addressPrefix": "[parameters('vnetsubnetprefix')]",
              "natGateway": {
                "id": "[resourceId('Microsoft.Network/natGateways', parameters('natgatewayname'))]"
              },
              "privateEndpointNetworkPolicies": "Enabled",
              "privateLinkServiceNetworkPolicies": "Enabled"
            }
          }
        ],
        "enableDdosProtection": false,
        "enableVmProtection": false
      },
      "dependsOn": [
        "[resourceId('Microsoft.Network/natGateways', parameters('natgatewayname'))]"
      ]
    },
    {
      "type": "Microsoft.Network/natGateways",
      "apiVersion": "2024-01-01",
      "name": "[parameters('natgatewayname')]",
      "___location": "[parameters('___location')]",
      "sku": {
        "name": "StandardV2"
      },
      "properties": {
        "idleTimeoutInMinutes": 4,
        "publicIpAddresses": [
          {
            "id": "[resourceId('Microsoft.Network/publicIPAddresses', parameters('publicipname'))]"
          }
        ]
      },
      "dependsOn": [
        "[resourceId('Microsoft.Network/publicIPAddresses', parameters('publicipname'))]"
      ]
    },
    {
      "type": "Microsoft.Network/virtualNetworks/subnets",
      "apiVersion": "2024-01-01",
      "name": "[format('{0}/{1}', parameters('vnetname'), 'subnet-1')]",
      "properties": {
        "addressPrefix": "[parameters('vnetsubnetprefix')]",
        "natGateway": {
          "id": "[resourceId('Microsoft.Network/natGateways', parameters('natgatewayname'))]"
        },
        "privateEndpointNetworkPolicies": "Enabled",
        "privateLinkServiceNetworkPolicies": "Enabled"
      },
      "dependsOn": [
        "[resourceId('Microsoft.Network/natGateways', parameters('natgatewayname'))]",
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('vnetname'))]"
      ]
    },
    {
      "type": "Microsoft.Network/networkInterfaces",
      "apiVersion": "2024-01-01",
      "name": "[parameters('networkinterfacename')]",
      "___location": "[parameters('___location')]",
      "properties": {
        "ipConfigurations": [
          {
            "name": "ipconfig-1",
            "properties": {
              "privateIPAddress": "10.0.0.4",
              "privateIPAllocationMethod": "Dynamic",
              "subnet": {
                "id": "[resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('vnetname'), 'subnet-1')]"
              },
              "primary": true,
              "privateIPAddressVersion": "IPv4"
            }
          }
        ],
        "enableAcceleratedNetworking": false,
        "enableIPForwarding": false,
        "networkSecurityGroup": {
          "id": "[resourceId('Microsoft.Network/networkSecurityGroups', parameters('nsgname'))]"
        }
      },
      "dependsOn": [
        "[resourceId('Microsoft.Network/networkSecurityGroups', parameters('nsgname'))]",
        "[resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('vnetname'), 'subnet-1')]"
      ]
    },
    {
      "type": "Microsoft.Network/bastionHosts",
      "apiVersion": "2024-01-01",
      "name": "[parameters('bastionName')]",
      "___location": "[parameters('___location')]",
      "sku": {
        "name": "Developer"
      },
      "properties": {
        "virtualNetwork": {
          "id": "[resourceId('Microsoft.Network/virtualNetworks', parameters('vnetname'))]"
        }
      },
      "dependsOn": [
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('vnetname'))]"
      ]
    }
  ],
  "outputs": {
    "___location": {
      "type": "string",
      "value": "[parameters('___location')]"
    },
    "name": {
      "type": "string",
      "value": "[parameters('natgatewayname')]"
    },
    "resourceGroupName": {
      "type": "string",
      "value": "[resourceGroup().name]"
    },
    "resourceId": {
      "type": "string",
      "value": "[resourceId('Microsoft.Network/natGateways', parameters('natgatewayname'))]"
    }
  }
}

Nove recursos do Azure são definidos no modelo:

• Microsoft.Network/networkSecurityGroups: Cria um grupo de segurança de rede.

• Microsoft.Network/networkSecurityGroups/securityRules: cria uma regra de segurança.

• Microsoft.Network/publicIPAddresses: cria um endereço IP público.

• Microsoft.Network/publicIPPrefixes: cria um prefixo IP público.

• Microsoft.Compute/virtualMachines: cria uma máquina virtual.

• Microsoft.Network/virtualNetworks: cria uma rede virtual.

• Microsoft.Network/natGateways: Cria um recurso de gateway NAT.

• Microsoft.Network/virtualNetworks/subnets: cria uma sub-rede de rede virtual.

• Microsoft.Network/networkinterfaces: cria uma interface de rede.

Implementar o modelo

Portal

Analisar os recursos implementados

1. Inicie sessão no portal Azure.

2. Selecione Grupos de recursos no painel esquerdo.

3. Selecione o grupo de recursos que você criou na seção anterior. O nome padrão do grupo de recursos é myResourceGroupNAT

4. Verifique se os seguintes recursos foram criados no grupo de recursos:

   

PowerShell

$___location = Read-Host -Prompt "Enter the ___location (i.e. westcentralus)"
$templateUri = "https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/quickstarts/microsoft.network/nat-gateway-1-vm/azuredeploy.json"

$resourceGroupName = "myResourceGroupNAT"

New-AzResourceGroup -Name $resourceGroupName -Location $___location
New-AzResourceGroupDeployment -ResourceGroupName $resourceGroupName -TemplateUri $templateUri

Azure CLI (Interface de Linha de Comando da Azure)

read -p "Enter the ___location (i.e. westcentralus): " ___location
resourceGroupName="myResourceGroupNAT"
templateUri="https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/quickstarts/microsoft.network/nat-gateway-1-vm/azuredeploy.json"

az group create \
--name $resourceGroupName \
--___location $___location

az deployment group create \
--resource-group $resourceGroupName \
--template-uri  $templateUri

Revise o arquivo Bicep

O arquivo Bicep utilizado neste início rápido é dos Modelos de Início Rápido do Azure.

Este arquivo Bicep está configurado para criar um:

• Rede virtual

• Recurso de gateway NAT

• Máquina virtual Ubuntu

A VM do Ubuntu é implantada em uma sub-rede associada ao recurso de gateway NAT.

@description('Name of the virtual machine')
param vmname string = 'vm-1'

@description('Size of the virtual machine')
param vmsize string = 'Standard_D2s_v3'

@description('Name of the virtual network')
param vnetname string = 'vnet-1'

@description('Name of the subnet for virtual network')
param subnetname string = 'subnet-1'

@description('Address space for virtual network')
param vnetaddressspace string = '10.0.0.0/16'

@description('Subnet prefix for virtual network')
param vnetsubnetprefix string = '10.0.0.0/24'

@description('Name of the NAT gateway')
param natgatewayname string = 'nat-gateway'

@description('Name of the virtual machine nic')
param networkinterfacename string = 'nic-1'

@description('Name of the NAT gateway public IP')
param publicipname string = 'public-ip-nat'

@description('Name of the Bastion host')
param bastionName string = 'bastion-host'

@description('Name of the virtual machine NSG')
param nsgname string = 'nsg-1'

@description('Administrator username for virtual machine')
param adminusername string

@description('Type of authentication to use on the Virtual Machine. SSH key is recommended.')
@allowed([
  'sshPublicKey'
  'password'
])
param authenticationType string = 'sshPublicKey'

@description('SSH Key or password for the Virtual Machine. SSH key is recommended.')
@secure()
param adminPasswordOrKey string

@description('Name of resource group')
param ___location string = resourceGroup().___location

var linuxConfiguration = {
  disablePasswordAuthentication: true
  ssh: {
    publicKeys: [
      {
        path: '/home/${adminusername}/.ssh/authorized_keys'
        keyData: adminPasswordOrKey
      }
    ]
  }
}

resource nsg 'Microsoft.Network/networkSecurityGroups@2024-01-01' = {
  name: nsgname
  ___location: ___location
  properties: {}
}

resource publicip 'Microsoft.Network/publicIPAddresses@2024-01-01' = {
  name: publicipname
  ___location: ___location
  sku: {
    name: 'StandardV2'
  }
  properties: {
    publicIPAddressVersion: 'IPv4'
    publicIPAllocationMethod: 'Static'
    idleTimeoutInMinutes: 4
  }
}

resource vm 'Microsoft.Compute/virtualMachines@2023-09-01' = {
  name: vmname
  ___location: ___location
  properties: {
    hardwareProfile: {
      vmSize: vmsize
    }
    storageProfile: {
      imageReference: {
        publisher: 'Canonical'
        offer: '0001-com-ubuntu-server-jammy'
        sku: '22_04-lts-gen2'
        version: 'latest'
      }
      osDisk: {
        osType: 'Linux'
        name: '${vmname}_disk1'
        createOption: 'FromImage'
        caching: 'ReadWrite'
        managedDisk: {
          storageAccountType: 'Premium_LRS'
        }
        diskSizeGB: 30
      }
    }
    osProfile: {
      computerName: vmname
      adminUsername: adminusername
      adminPassword: adminPasswordOrKey
      linuxConfiguration: ((authenticationType == 'password') ? null : linuxConfiguration)
    }
    networkProfile: {
      networkInterfaces: [
        {
          id: networkinterface.id
        }
      ]
    }
  }
}

resource vnet 'Microsoft.Network/virtualNetworks@2024-01-01' = {
  name: vnetname
  ___location: ___location
  properties: {
    addressSpace: {
      addressPrefixes: [
        vnetaddressspace
      ]
    }
    subnets: [
      {
        name: subnetname
        properties: {
          addressPrefix: vnetsubnetprefix
          natGateway: {
            id: natgateway.id
          }
          privateEndpointNetworkPolicies: 'Enabled'
          privateLinkServiceNetworkPolicies: 'Enabled'
        }
      }
    ]
    enableDdosProtection: false
    enableVmProtection: false
  }
}

resource natgateway 'Microsoft.Network/natGateways@2024-01-01' = {
  name: natgatewayname
  ___location: ___location
  sku: {
    name: 'StandardV2'
  }
  properties: {
    idleTimeoutInMinutes: 4
    publicIpAddresses: [
      {
        id: publicip.id
      }
    ]
  }
}

resource subnet 'Microsoft.Network/virtualNetworks/subnets@2024-01-01' = {
  parent: vnet
  name: 'subnet-1'
  properties: {
    addressPrefix: vnetsubnetprefix
    natGateway: {
      id: natgateway.id
    }
    privateEndpointNetworkPolicies: 'Enabled'
    privateLinkServiceNetworkPolicies: 'Enabled'
  }
}

resource networkinterface 'Microsoft.Network/networkInterfaces@2024-01-01' = {
  name: networkinterfacename
  ___location: ___location
  properties: {
    ipConfigurations: [
      {
        name: 'ipconfig-1'
        properties: {
          privateIPAddress: '10.0.0.4'
          privateIPAllocationMethod: 'Dynamic'
          subnet: {
            id: subnet.id
          }
          primary: true
          privateIPAddressVersion: 'IPv4'
        }
      }
    ]
    enableAcceleratedNetworking: false
    enableIPForwarding: false
    networkSecurityGroup: {
      id: nsg.id
    }
  }
}

resource bastionHost 'Microsoft.Network/bastionHosts@2024-01-01' = {
  name: bastionName
  ___location: ___location
  sku: {
    name: 'Developer'
  }
  properties: {
    virtualNetwork: {
      id: vnet.id
    }
  }
}

output ___location string = ___location
output name string = natgateway.name
output resourceGroupName string = resourceGroup().name
output resourceId string = natgateway.id

Nove recursos do Azure são definidos no arquivo Bicep:

• Microsoft.Network/networkSecurityGroups: Cria um grupo de segurança de rede.

• Microsoft.Network/networkSecurityGroups/securityRules: cria uma regra de segurança.

• Microsoft.Network/publicIPAddresses: cria um endereço IP público.

• Microsoft.Network/publicIPPrefixes: cria um prefixo IP público.

• Microsoft.Compute/virtualMachines: cria uma máquina virtual.

• Microsoft.Network/virtualNetworks: cria uma rede virtual.

• Microsoft.Network/natGateways: Cria um recurso de gateway NAT.

• Microsoft.Network/virtualNetworks/subnets: cria uma sub-rede de rede virtual.

• Microsoft.Network/networkinterfaces: cria uma interface de rede.

Desdobrar o arquivo Bicep

1. Salve o arquivo Bicep como main.bicep em seu computador local.

2. Implante o arquivo Bicep usando o Azure CLI ou o Azure PowerShell.

   Azure CLI (Interface de Linha de Comando da Azure)

   az group create --name exampleRG --___location eastus
   az deployment group create --resource-group exampleRG --template-file main.bicep --parameters adminusername=<admin-name>
   

   PowerShell

   New-AzResourceGroup -Name exampleRG -Location eastus
   New-AzResourceGroupDeployment -ResourceGroupName exampleRG -TemplateFile ./main.bicep -adminusername "<admin-name>"
   

   ---

   Observação

   Substitua <admin-name> pelo nome de usuário do administrador da máquina virtual. Você também será solicitado a inserir adminpassword.

   Quando a implantação terminar, você verá uma mensagem indicando que a implantação foi bem-sucedida.

Analisar os recursos implementados

Utilize o portal do Azure, Azure CLI ou Azure PowerShell para listar os recursos implantados no grupo de recursos.

Azure CLI (Interface de Linha de Comando da Azure)

az resource list --resource-group exampleRG

PowerShell

Get-AzResource -ResourceGroupName exampleRG

Este arquivo Terraform implanta uma rede virtual, um recurso de gateway NAT e uma máquina virtual Ubuntu. A máquina virtual do Ubuntu é implantada em uma sub-rede associada ao recurso de gateway NAT.

O script também gera uma chave pública SSH aleatória e a associa à máquina virtual para acesso seguro. A chave pública é exibida no final da execução do script.

O script usa os provedores Random e AzAPI, além do provedor AzureRM. O provedor aleatório é usado para gerar um nome exclusivo para o grupo de recursos e a chave SSH. O provedor AzAPI é usado para gerar a chave pública SSH.

Assim como acontece com a chave pública, os nomes do grupo de recursos criado, rede virtual, sub-rede e gateway NAT são impressos quando o script é executado.

Terraform permite a definição, visualização e implantação de infraestrutura em nuvem. Usando Terraform, você cria arquivos de configuração usando a sintaxe HCL. A sintaxe HCL permite especificar 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 na infraestrutura antes que elas sejam implantadas. Depois de verificar as alterações, você aplica o plano de execução para implantar a infraestrutura.

Implementar o código Terraform

1. Crie um diretório no qual testar e executar o código Terraform de exemplo e torná-lo o diretório atual.

2. Crie um arquivo chamado main.tf e insira o seguinte código:

   # Resource Group
   resource "azurerm_resource_group" "rg" {
     ___location = var.resource_group_location
     name     = "${random_pet.prefix.id}-rg"
   }
   
   # Virtual Network
   resource "azurerm_virtual_network" "my_terraform_network" {
     name                = "${random_pet.prefix.id}-vnet"
     address_space       = ["10.0.0.0/16"]
     ___location            = azurerm_resource_group.rg.___location
     resource_group_name = azurerm_resource_group.rg.name
   }
   
   # Subnet 1
   resource "azurerm_subnet" "my_terraform_subnet_1" {
     name                 = "subnet-1"
     resource_group_name  = azurerm_resource_group.rg.name
     virtual_network_name = azurerm_virtual_network.my_terraform_network.name
     address_prefixes     = ["10.0.0.0/24"]
   }
   
   # Public IP address for NAT gateway
   resource "azurerm_public_ip" "my_public_ip" {
     name                = "public-ip-nat"
     ___location            = azurerm_resource_group.rg.___location
     resource_group_name = azurerm_resource_group.rg.name
     allocation_method   = "Static"
     sku                 = "Standard"
   }
   
   # NAT Gateway
   resource "azurerm_nat_gateway" "my_nat_gateway" {
     name                = "nat-gateway"
     ___location            = azurerm_resource_group.rg.___location
     resource_group_name = azurerm_resource_group.rg.name
   }
   
   # Associate NAT Gateway with Public IP
   resource "azurerm_nat_gateway_public_ip_association" "example" {
     nat_gateway_id       = azurerm_nat_gateway.my_nat_gateway.id
     public_ip_address_id = azurerm_public_ip.my_public_ip.id
   }
   
   # Associate NAT Gateway with Subnet
   resource "azurerm_subnet_nat_gateway_association" "example" {
     subnet_id      = azurerm_subnet.my_terraform_subnet_1.id
     nat_gateway_id = azurerm_nat_gateway.my_nat_gateway.id
   }
   
   # Create public IP for virtual machine
   resource "azurerm_public_ip" "my_public_ip_vm" {
     name                = "public-ip-vm"
     ___location            = azurerm_resource_group.rg.___location
     resource_group_name = azurerm_resource_group.rg.name
     allocation_method   = "Static"
     sku                 = "Standard"
   }
   
   # Create Network Security Group and rule
   resource "azurerm_network_security_group" "my_terraform_nsg" {
     name                = "nsg-1"
     ___location            = azurerm_resource_group.rg.___location
     resource_group_name = azurerm_resource_group.rg.name
   
     security_rule {
       name                       = "SSH"
       priority                   = 1001
       direction                  = "Inbound"
       access                     = "Allow"
       protocol                   = "Tcp"
       source_port_range          = "*"
       destination_port_range     = "22"
       source_address_prefix      = "*"
       destination_address_prefix = "*"
     }
   }
   
   # Create network interface
   resource "azurerm_network_interface" "my_terraform_nic" {
     name                = "nic-1"
     ___location            = azurerm_resource_group.rg.___location
     resource_group_name = azurerm_resource_group.rg.name
   
     ip_configuration {
       name                          = "my_nic_configuration"
       subnet_id                     = azurerm_subnet.my_terraform_subnet_1.id
       private_ip_address_allocation = "Dynamic"
       public_ip_address_id          = azurerm_public_ip.my_public_ip_vm.id
     }
   }
   
   # Connect the security group to the network interface
   resource "azurerm_network_interface_security_group_association" "example" {
     network_interface_id      = azurerm_network_interface.my_terraform_nic.id
     network_security_group_id = azurerm_network_security_group.my_terraform_nsg.id
   }
   
   # Generate random text for a unique storage account name
   resource "random_id" "random_id" {
     keepers = {
       # Generate a new ID only when a new resource group is defined
       resource_group = azurerm_resource_group.rg.name
     }
   
     byte_length = 8
   }
   
   # Create storage account for boot diagnostics
   resource "azurerm_storage_account" "my_storage_account" {
     name                     = "diag${random_id.random_id.hex}"
     ___location                 = azurerm_resource_group.rg.___location
     resource_group_name      = azurerm_resource_group.rg.name
     account_tier             = "Standard"
     account_replication_type = "LRS"
   }
   
   # Create virtual machine
   resource "azurerm_linux_virtual_machine" "my_terraform_vm" {
     name                  = "vm-1"
     ___location              = azurerm_resource_group.rg.___location
     resource_group_name   = azurerm_resource_group.rg.name
     network_interface_ids = [azurerm_network_interface.my_terraform_nic.id]
     size                  = "Standard_DS1_v2"
   
     os_disk {
       name                 = "myOsDisk"
       caching              = "ReadWrite"
       storage_account_type = "Premium_LRS"
     }
   
     source_image_reference {
       publisher = "Canonical"
       offer     = "0001-com-ubuntu-server-jammy"
       sku       = "22_04-lts-gen2"
       version   = "latest"
     }
   
     computer_name  = "hostname"
     admin_username = var.username
   
     admin_ssh_key {
       username   = var.username
       public_key = azapi_resource_action.ssh_public_key_gen.output.publicKey
     }
   
     boot_diagnostics {
       storage_account_uri = azurerm_storage_account.my_storage_account.primary_blob_endpoint
     }
   }
   
   resource "random_pet" "prefix" {
     prefix = var.resource_group_name_prefix
     length = 1
   }
   

3. Crie um arquivo chamado outputs.tf e insira o seguinte código:

   output "resource_group_name" {
     description = "The name of the created resource group."
     value       = azurerm_resource_group.rg.name
   }
   
   output "virtual_network_name" {
     description = "The name of the created virtual network."
     value       = azurerm_virtual_network.my_terraform_network.name
   }
   
   output "subnet_name_1" {
     description = "The name of the created subnet 1."
     value       = azurerm_subnet.my_terraform_subnet_1.name
   }
   
   output "nat_gateway"{
     description = "The name of the created NAT gateway."
     value       = azurerm_nat_gateway.my_nat_gateway.id
   }
   

4. Crie um arquivo chamado providers.tf e insira o seguinte código:

   terraform {
     required_providers {
       azapi = {
         source  = "azure/azapi"
         version = "~>1.5"
       }
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~>3.0"
       }
       random = {
         source  = "hashicorp/random"
         version = "~>3.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   

5. Crie um arquivo chamado ssh.tf e insira o seguinte código:

   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
   }
   

6. Crie um arquivo chamado variables.tf e insira o seguinte código:

   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 "username" {
     type        = string
     description = "The username for the local account that will be created on the new VM."
     default     = "azureuser"
   }
   

Inicializar Terraform

Execute terraform init para inicializar a implantação do Terraform. Este 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 de provedor necessários para a versão mais recente que está em conformidade com as restrições de versão da configuração.

Criar um plano de execução do 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 quaisquer alterações nos recursos reais.
• O parâmetro opcional -out permite especificar um arquivo de saída para o plano. O uso do -out parâmetro garante que o plano revisado 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 já executaste terraform plan -out main.tfplan anteriormente.
• 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.

Verificar os resultados

Azure CLI (Interface de Linha de Comando da Azure)

1. Obtenha o nome do grupo de recursos do Azure.

   resource_group_name=$(terraform output -raw resource_group_name)
   

2. Obtenha o ID do gateway NAT.

   nat_gateway=$(terraform output -raw nat_gateway)
   

3. Execute az network nat gateway show para exibir os detalhes sobre o gateway NAT.

   az network nat gateway show \
       --resource-group $resource_group_name \
       --ids $nat_gateway
   

PowerShell

1. Obtenha o nome do grupo de recursos do Azure.

   $resource_group_name=$(terraform output -raw resource_group_name)
   

2. Obtenha o ID do gateway NAT.

   $nat_gateway=$(terraform output -raw nat_gateway)
   

3. Execute Get-AzNatGateway para exibir os detalhes sobre o gateway NAT.

   $nat = @{
       Name = $nat_gateway
       ResourceGroupName = $resource_group_name
   }
   Get-AzNatGateway @nat
   

Quando terminar de usar os recursos que criou, você poderá excluir o grupo de recursos e todos os seus recursos.

1. No portal do Azure, procure e selecione Grupos de recursos.

2. Na página Grupos de recursos, selecione o grupo de recursos test-rg.

3. Na página test-rg, selecione Excluir grupo de recursos.

4. Digite test-rg em Digite o nome do grupo de recursos para confirmar a exclusão e selecione Excluir.

Se você não vai continuar a usar esse aplicativo, exclua a rede virtual, a máquina virtual e o gateway NAT com o seguinte comando:

Remove-AzResourceGroup -Name 'test-rg' -Force

Se você não vai continuar a usar esse aplicativo, exclua a rede virtual, a máquina virtual e o gateway NAT com o seguinte comando:

az group delete \
    --name test-rg \
    --yes

Quando não for mais necessário, você pode usar o comando Remove-AzResourceGroup para remover o grupo de recursos e todos os recursos contidos nele.

Remove-AzResourceGroup -Name myResourceGroupNAT

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

1. Execute terraform plan e especifique o parâmetro 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 quaisquer alterações nos recursos reais.
   • O parâmetro opcional -out permite especificar um arquivo de saída para o plano. O uso do -out parâmetro garante que o plano revisado seja exatamente o que é aplicado.

2. Execute terraform apply para aplicar o plano de execução.

   terraform apply main.destroy.tfplan