Início Rápido: Criar uma Rede Virtual do Azure

2025-05-02

Neste início rápido, saiba como criar uma VNet (Rede Virtual) do Azure usando o portal do Azure, a CLI do Azure, o Azure PowerShell, o modelo do Resource Manager, o modelo Bicep e o Terraform. Duas máquinas virtuais e um host do Azure Bastion são implantados para testar a conectividade entre as máquinas virtuais na mesma rede virtual. O host do Azure Bastion possibilita conectividade RDP e SSH segura e contínua com as máquinas virtuais diretamente no portal do Azure via SSL.

A rede virtual é o bloco de construção fundamental para redes privadas no Azure. A Rede Virtual do Azure permite que os recursos do Azure, como VMs, se comuniquem com segurança entre si e com a Internet.

Se você não possui uma assinatura do serviço, crie uma conta de avaliação gratuita.

Pré-requisitos

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

Uma conta do Azure com uma assinatura ativa. Você pode criar uma conta gratuitamente.
Azure Cloud Shell ou Azure PowerShell.

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

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

Se você executar o PowerShell localmente, execute Connect-AzAccount para se conectar ao Azure.

Entrar no Azure

Entre no portal do Azure com sua conta do Azure.

Criar uma rede virtual e um host do Azure Bastion

O seguinte procedimento cria uma rede virtual com uma sub-rede de recurso, uma sub-rede do Azure Bastion e um host do Bastion:

No portal, pesquise e selecione redes virtuais.
Na página Redes virtuais, selecione + Criar.

Na guia Informações Básicas em Criar rede virtual, insira ou selecione as seguintes informações:

Configurações	Valor
Detalhes do projeto
Subscrição	Selecione sua assinatura.
Grupo de recursos	Selecione Criar novo. Insira test-rg para o nome. Selecione OK.
Detalhes da instância
Nome	Insira vnet-1.
Região	Selecione Leste dos EUA 2.

Captura de tela da guia Básicos para criar uma rede virtual no portal do Azure.

Selecione Avançar para prosseguir para a guia Segurança.
Na seção Azure Bastion, selecione Habilitar o Azure Bastion.

O Bastion usa seu navegador para se conectar às VMs em sua rede virtual por meio do Secure Shell (SSH) ou do Protocolo de Área de Trabalho Remota (RDP) usando os respectivos 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, confira O que é o Azure Bastion?.

Observação

A tarifação por hora começa no momento em que o Bastion é implantado, independentemente do consumo de dados de saída. Para saber mais, confira Preços e SKUs. Se estiver implantando o Bastion como parte de um tutorial ou teste, recomendamos que você exclua esse recurso após terminar de usá-lo.

Em Azure Bastion, digite ou selecione as seguintes informações:

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

Captura de tela das opções para habilitar um host do Azure Bastion como parte da criação de uma rede virtual no portal do Azure.

Selecione Avançar para prosseguir para a guia Endereços IP.
Na caixa de espaço de endereço em Sub-redes, selecione a sub-rede padrão.

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

Configurações	Valor
Finalidade da sub-rede	Mantenha o padrão como Padrão.
Nome	Digite subnet-1.
IPv4
Intervalo de endereços IPv4	Mantenha 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).

Clique em Salvar.
Selecione Examinar + criar na parte inferior da página. Quando a validação for aprovada, selecione Criar.

Criar máquinas virtuais

O seguinte procedimento cria duas VMs denominadas vm-1 e vm-2 na rede virtual:

No portal, pesquise e selecione Máquinas virtuais.
Em Máquinas virtuais, selecione + Criar e então selecione Máquina virtual do Azure.

Na guia Informações Básicas em Criar uma máquina virtual, insira ou selecione as informações a seguir:

Configurações	Valor
Detalhes do projeto
Subscrição	Selecione sua assinatura.
Grupo de recursos	Selecione test-rg.
Detalhes da instância
Nome da máquina virtual	Insira vm-1.
Região	Selecione Leste dos EUA 2.
Opções de disponibilidade	Selecione Nenhuma redundância de infraestrutura necessária.
Tipo de segurança	Deixe o padrão de Standard.
Imagem	Selecione Ubuntu Server 22.04 LTS - x64 Gen2.
Arquitetura de VMs;	Mantenha o padrão x64.
Tamanho	Selecione um tamanho.
Conta de administrador
Tipo de autenticação	Selecione Senha.
Nome de usuário	insira azureuser.
Senha	Digite uma senha.
Confirmar senha	Digitar novamente a senha.
Regras do porto de entrada
Portas de entrada públicas	Selecione Nenhum.

Selecione a guia Rede. Insira ou selecione as seguintes informações:

Configurações	Valor
Interface de rede
Rede virtual	Selecione vnet-1.
Sub-rede	Selecione sub-rede-1 (10.0.0.0/24).
IP público	Selecione Nenhum.
Grupo de segurança de rede da NIC	Selecione Avançado.
Configurar um grupo de segurança de rede	Selecione Criar novo. Insira nsg-1 no nome. Deixe os demais valores como padrão e selecione OK.

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

Aguarde até que a primeira máquina virtual seja implantada e repita as etapas anteriores para criar uma segunda máquina virtual com as seguintes configurações:

Configurações	Valor
Nome da máquina virtual	Insira vm-2.
Rede virtual	Selecione vnet-1.
Sub-rede	Selecione sub-rede-1 (10.0.0.0/24).
IP público	Selecione Nenhum.
Grupo de segurança de rede da NIC	Selecione Avançado.
Configurar um grupo de segurança de rede	Selecione nsg-1.

Observação

Máquinas virtuais em uma rede virtual com um host do Azure Bastion não precisam de endereços IP públicos. O Bastion fornece o IP público e as VMs usam IPs privados para se comunicar dentro da rede. Você pode remover os IPs públicos de qualquer VM em redes virtuais hospedadas no Bastion. Para obter mais informações, veja Dissociar um endereço IP público de uma VM do Azure.

Observação

O Azure fornece um IP de acesso de saída padrão para VMs que não receberam um endereço IP público ou que estão no pool de back-end de um balanceador de carga do Azure básico interno. O mecanismo de IP de acesso de saída padrão fornece um endereço IP de saída que não é configurável.

O IP de acesso de saída padrão é desabilitado quando um dos seguintes eventos acontece:

Um endereço IP público é atribuído à VM.
A VM é colocada no pool de back-end de um balanceador de carga padrão, com ou sem regras de saída.
Um recurso Azure NAT Gateway é atribuído à sub-rede da VM.

As VMs criadas por meio de conjuntos de escalonamento de máquinas virtuais no modo de orquestração flexível não têm acesso de saída padrão.

Para mais informações sobre conexões de saída no Azure, confira Acesso de saída padrão no Azure e Usar SNAT (conversão de endereços de rede de origem) para conexões de saída.

Criar um grupo de recursos

Primeiro, use New-AzResourceGroup para criar um grupo de recursos para hospedar a rede virtual. Execute o seguinte código para criar um grupo de recursos chamado test-rg na região eastus2 do Azure:

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

Criar uma rede virtual

Use New-AzVirtualNetwork para criar uma rede virtual chamada vnet-1 com o prefixo de endereço IP 10.0.0.0/16 no grupo de recursos test-rg e na localização eastus2:

$vnet = @{
    Name = 'vnet-1'
    ResourceGroupName = 'test-rg'
    Location = 'eastus2'
    AddressPrefix = '10.0.0.0/16'
}
$virtualNetwork = New-AzVirtualNetwork @vnet

O Azure implanta recursos em uma sub-rede em uma rede virtual. Use Add-AzVirtualNetworkSubnetConfig para criar uma configuração de sub-rede chamada subnet-1 com o prefixo de endereço 10.0.0.0/24:
```
$subnet = @{
    Name = 'subnet-1'
    VirtualNetwork = $virtualNetwork
    AddressPrefix = '10.0.0.0/24'
}
$subnetConfig = Add-AzVirtualNetworkSubnetConfig @subnet
```
Associe a configuração da sub-rede à rede virtual usando Set-AzVirtualNetwork:
```
$virtualNetwork | Set-AzVirtualNetwork
```

Implantar o Azure Bastion

O Azure Bastion usa seu navegador para se conectar a VMs em sua rede virtual por Secure Shell (SSH) ou Remote Desktop Protocol (RDP) usando 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 Bastion, consulte O que é o Azure Bastion?.

A tarifação por hora começa no momento em que o Bastion é implantado, independentemente do consumo de dados de saída. Para saber mais, confira Preços e SKUs. Se estiver implantando o Bastion como parte de um tutorial ou teste, recomendamos que você exclua esse recurso após terminar de usá-lo.

Configure uma sub-rede do Bastion para sua rede virtual. Essa sub-rede é reservada exclusivamente para recursos do Bastion e deve ser chamada AzureBastionSubnet.

$subnet = @{
    Name = 'AzureBastionSubnet'
    VirtualNetwork = $virtualNetwork
    AddressPrefix = '10.0.1.0/26'
}
$subnetConfig = Add-AzVirtualNetworkSubnetConfig @subnet

Defina a configuração:
```
$virtualNetwork | Set-AzVirtualNetwork
```

Crie um endereço IP público para o Bastion. O Bastion host usa o IP público para acessar SSH e RDP pela porta 443.

$ip = @{
        ResourceGroupName = 'test-rg'
        Name = 'public-ip'
        Location = 'eastus2'
        AllocationMethod = 'Static'
        Sku = 'Standard'
        Zone = 1,2,3
}
New-AzPublicIpAddress @ip

Use o comando New-AzBastion para criar um novo Bastion host de SKU Standard em AzureBastionSubnet:

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

A implantação dos recursos do Bastion leva cerca de 10 minutos. É possível criar VMs na próxima seção enquanto o Bastion é implantado na rede virtual.

Criar máquinas virtuais

Use New-AzVM para criar duas VMs chamadas vm-1 e vm-2 na sub-rede vm-2 da rede virtual. Quando as credenciais forem solicitadas, insira os nomes de usuário e as senhas das VMs.

Para criar a primeira VM, execute o seguinte código:

# 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 a network interface for the VM. ##
$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 VM. ##
$vm = @{
    ResourceGroupName = 'test-rg'
    Location = 'eastus2'
    VM = $vmConfig
}
New-AzVM @vm

Para criar a segunda VM, execute o seguinte código:

# 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 a network interface for the VM. ##
$nic = @{
    Name = "nic-2"
    ResourceGroupName = 'test-rg'
    Location = 'eastus2'
    Subnet = $vnet.Subnets[0]
}
$nicVM = New-AzNetworkInterface @nic

## Create a virtual machine configuration. ##
$vmsz = @{
    VMName = "vm-2"
    VMSize = 'Standard_DS1_v2'  
}
$vmos = @{
    ComputerName = "vm-2"
    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 VM. ##
$vm = @{
    ResourceGroupName = 'test-rg'
    Location = 'eastus2'
    VM = $vmConfig
}
New-AzVM @vm

Dica

Você pode usar a opção -AsJob para criar uma VM em segundo plano enquanto continua com as outras tarefas. Por exemplo, execute New-AzVM @vm1 -AsJob. Quando o Azure começa a criar a VM em segundo plano, você obtém algo como a seguinte saída:

Id     Name            PSJobTypeName   State         HasMoreData     Location             Command
--     ----            -------------   -----         -----------     --------             -------
1      Long Running... AzureLongRun... Running       True            localhost            New-AzVM

O Azure leva alguns minutos para criar as VMs. Quando o Azure termina de criar as VMs, ele retorna a saída para o PowerShell.

Observação

As VMs em uma rede virtual com um Bastion host não precisam de endereços IP públicos. O Bastion fornece o IP público e as VMs usam IPs privados para se comunicar dentro da rede. Você pode remover os IPs públicos de qualquer VM em redes virtuais hospedadas no Bastion. Para obter mais informações, veja Dissociar um endereço IP público de uma VM do Azure.

Observação

O IP de acesso de saída padrão é desabilitado quando um dos seguintes eventos acontece:

Um endereço IP público é atribuído à VM.
A VM é colocada no pool de back-end de um balanceador de carga padrão, com ou sem regras de saída.
Um recurso Azure NAT Gateway é atribuído à sub-rede da VM.

As VMs criadas por meio de conjuntos de escalonamento de máquinas virtuais no modo de orquestração flexível não têm acesso de saída padrão.

Para mais informações sobre conexões de saída no Azure, confira Acesso de saída padrão no Azure e Usar SNAT (conversão de endereços de rede de origem) para conexões de saída.

Criar um grupo de recursos

Use az group create para criar um grupo de recursos para hospedar a rede virtual. Execute o código a seguir para criar um grupo de recursos chamado test-rg na região eastus2 do Azure:

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

Criar a rede virtual e a sub-rede

Use az network vnet create para criar uma rede virtual chamada vnet-1 com uma sub-rede chamada subnet-1 no grupo de recursos test-rg:

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

Implantar o Azure Bastion

Use az network vnet subnet create para criar uma sub-rede do Bastion para sua rede virtual. Essa sub-rede é reservada exclusivamente para recursos do Bastion e deve ser chamada AzureBastionSubnet.
```
az network vnet subnet create \
    --name AzureBastionSubnet \
    --resource-group test-rg \
    --vnet-name vnet-1 \
    --address-prefix 10.0.1.0/26
```
Crie um endereço IP público para o Bastion. Esse endereço IP é usado para se conectar ao host do Bastion a partir do host da internet. Use az network public-ip create para criar um endereço IP público chamado public-ip no grupo de recursos test-rg:
```
az network public-ip create \
    --resource-group test-rg \
    --name public-ip \
    --sku Standard \
    --location eastus2 \
    --zone 1 2 3
```

Use az network bastion create para criar um host do Bastion em AzureBastionSubnet para a rede virtual:

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

A implantação dos recursos do Bastion leva cerca de 10 minutos. É possível criar VMs na próxima seção enquanto o Bastion é implantado na rede virtual.

Criar máquinas virtuais

Use az vm create para criar duas VMs chamadas vm-1 e vm-2 na sub-rede subnet-1 da rede virtual. Quando você for solicitado a fornecer credenciais, insira nomes de usuário e senhas para as VMs.

Para criar a primeira VM, use o seguinte comando:

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

Para criar a segunda VM, use o seguinte comando:

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

Dica

Você também pode usar a opção --no-wait para criar uma VM em segundo plano enquanto continua com as outras tarefas.

As VMs podem levar alguns minutos para serem criadas. Depois que o Azure cria cada VM, a CLI do Azure retorna uma saída semelhante à seguinte mensagem:

    {
      "fqdns": "",
      "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Compute/virtualMachines/vm-2",
      "location": "eastus2",
      "macAddress": "00-0D-3A-23-9A-49",
      "powerState": "VM running",
      "privateIpAddress": "10.0.0.5",
      "publicIpAddress": "",
      "resourceGroup": "test-rg"
      "zones": ""
    }

Observação

O IP de acesso de saída padrão é desabilitado quando um dos seguintes eventos acontece:

Um endereço IP público é atribuído à VM.
A VM é colocada no pool de back-end de um balanceador de carga padrão, com ou sem regras de saída.
Um recurso Azure NAT Gateway é atribuído à sub-rede da VM.

As VMs criadas por meio de conjuntos de escalonamento de máquinas virtuais no modo de orquestração flexível não têm acesso de saída padrão.

Para mais informações sobre conexões de saída no Azure, confira Acesso de saída padrão no Azure e Usar SNAT (conversão de endereços de rede de origem) para conexões de saída.

Examinar o modelo

O modelo que você usa nesse início rápido é proveniente dos Modelos de Início Rápido do Azure.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.6.18.56646",
      "templateHash": "10806234693722113459"
    }
  },
  "parameters": {
    "vnetName": {
      "type": "string",
      "defaultValue": "VNet1",
      "metadata": {
        "description": "VNet name"
      }
    },
    "vnetAddressPrefix": {
      "type": "string",
      "defaultValue": "10.0.0.0/16",
      "metadata": {
        "description": "Address prefix"
      }
    },
    "subnet1Prefix": {
      "type": "string",
      "defaultValue": "10.0.0.0/24",
      "metadata": {
        "description": "Subnet 1 Prefix"
      }
    },
    "subnet1Name": {
      "type": "string",
      "defaultValue": "Subnet1",
      "metadata": {
        "description": "Subnet 1 Name"
      }
    },
    "subnet2Prefix": {
      "type": "string",
      "defaultValue": "10.0.1.0/24",
      "metadata": {
        "description": "Subnet 2 Prefix"
      }
    },
    "subnet2Name": {
      "type": "string",
      "defaultValue": "Subnet2",
      "metadata": {
        "description": "Subnet 2 Name"
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "Location for all resources."
      }
    }
  },
  "resources": [
    {
      "type": "Microsoft.Network/virtualNetworks",
      "apiVersion": "2021-08-01",
      "name": "[parameters('vnetName')]",
      "location": "[parameters('location')]",
      "properties": {
        "addressSpace": {
          "addressPrefixes": [
            "[parameters('vnetAddressPrefix')]"
          ]
        },
        "subnets": [
          {
            "name": "[parameters('subnet1Name')]",
            "properties": {
              "addressPrefix": "[parameters('subnet1Prefix')]"
            }
          },
          {
            "name": "[parameters('subnet2Name')]",
            "properties": {
              "addressPrefix": "[parameters('subnet2Prefix')]"
            }
          }
        ]
      }
    }
  ]
}

O modelo define os seguintes recursos do Azure:

Microsoft.Network/virtualNetworks: criar uma rede virtual.
Microsoft.Network/virtualNetworks/subnets: criar uma sub-rede.

Implantar o modelo

Implantar o modelo do Resource Manager no Azure:

Selecione Implantar no Azure para entrar no Azure e abrir o modelo. O modelo cria uma rede virtual com duas sub-redes.
No portal, na página Criar uma Rede Virtual com duas Sub-redes, insira ou selecione os seguintes valores:
- Grupo de recursos: selecione Criar novo, insira CreateVNetQS-rg no nome do grupo de recursos e selecione OK.
- Nome da Rede Virtual: insira um nome para a nova rede virtual.
Selecione Examinar + Criar e, em seguida, selecione Criar.
Quando a implantação for concluída, selecione o botão Ir para recurso para examinar os recursos implantados.

Examinar os recursos implantados

Explore os recursos criados com a rede virtual navegando pelas folhas de configurações da VNet1:

A guia Visão geral mostra o espaço de endereço definido de 10.0.0.0/16.
A guia Sub-redes, mostra as sub-redes implantadas de Subnet1 e Subnet2 com os valores apropriados do modelo.

Saiba mais sobre a sintaxe e as propriedades de JSON para uma rede virtual em um modelo em Microsoft.Network/virtualNetworks.

Criar a rede virtual e VMs

Esse início rápido utiliza o modelo do Bicep Duas VMs na VNET a partir dos Modelos de Início Rápido do Azure Resource Manager para criar a rede virtual, a sub-rede de recursos e as VMs. O modelo do Bicep define os recursos do Azure a seguir:

Microsoft.Network virtualNetworks: cria uma rede virtual do Azure.
Microsoft.Network virtualNetworks/subredes: cria uma sub-rede para as VMs.
Microsoft.Compute virtualMachines: cria as VMs.
Microsoft.Compute availabilitySets: cria um conjunto de disponibilidade.
Microsoft.Network networkInterfaces: cria os adaptador de rede.
Microsoft.Network loadBalancers: cria um balanceador de carga interno.
Microsoft.Storage storageAccounts: cria uma conta de armazenamento.

Revisar o arquivo Bicep:

@description('Admin username')
param adminUsername string

@description('Admin password')
@secure()
param adminPassword string

@description('Prefix to use for VM names')
param vmNamePrefix string = 'BackendVM'

@description('Location for all resources.')
param location string = resourceGroup().location

@description('Size of the virtual machines')
param vmSize string = 'Standard_D2s_v3'

var availabilitySetName = 'AvSet'
var storageAccountType = 'Standard_LRS'
var storageAccountName = uniqueString(resourceGroup().id)
var virtualNetworkName = 'vNet'
var subnetName = 'backendSubnet'
var loadBalancerName = 'ilb'
var networkInterfaceName = 'nic'
var subnetRef = resourceId('Microsoft.Network/virtualNetworks/subnets', virtualNetworkName, subnetName)
var numberOfInstances = 2

resource storageAccount 'Microsoft.Storage/storageAccounts@2023-01-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: storageAccountType
  }
  kind: 'StorageV2'
}

resource availabilitySet 'Microsoft.Compute/availabilitySets@2023-09-01' = {
  name: availabilitySetName
  location: location
  sku: {
    name: 'Aligned'
  }
  properties: {
    platformUpdateDomainCount: 2
    platformFaultDomainCount: 2
  }
}

resource virtualNetwork 'Microsoft.Network/virtualNetworks@2023-09-01' = {
  name: virtualNetworkName
  location: location
  properties: {
    addressSpace: {
      addressPrefixes: [
        '10.0.0.0/16'
      ]
    }
    subnets: [
      {
        name: subnetName
        properties: {
          addressPrefix: '10.0.2.0/24'
        }
      }
    ]
  }
}

resource networkInterface 'Microsoft.Network/networkInterfaces@2023-09-01' = [for i in range(0, numberOfInstances): {
  name: '${networkInterfaceName}${i}'
  location: location
  properties: {
    ipConfigurations: [
      {
        name: 'ipconfig1'
        properties: {
          privateIPAllocationMethod: 'Dynamic'
          subnet: {
            id: subnetRef
          }
          loadBalancerBackendAddressPools: [
            {
              id: resourceId('Microsoft.Network/loadBalancers/backendAddressPools', loadBalancerName, 'BackendPool1')
            }
          ]
        }
      }
    ]
  }
  dependsOn: [
    virtualNetwork
    loadBalancer
  ]
}]

resource loadBalancer 'Microsoft.Network/loadBalancers@2023-09-01' = {
  name: loadBalancerName
  location: location
  sku: {
    name: 'Standard'
  }
  properties: {
    frontendIPConfigurations: [
      {
        properties: {
          subnet: {
            id: subnetRef
          }
          privateIPAddress: '10.0.2.6'
          privateIPAllocationMethod: 'Static'
        }
        name: 'LoadBalancerFrontend'
      }
    ]
    backendAddressPools: [
      {
        name: 'BackendPool1'
      }
    ]
    loadBalancingRules: [
      {
        properties: {
          frontendIPConfiguration: {
            id: resourceId('Microsoft.Network/loadBalancers/frontendIpConfigurations', loadBalancerName, 'LoadBalancerFrontend')
          }
          backendAddressPool: {
            id: resourceId('Microsoft.Network/loadBalancers/backendAddressPools', loadBalancerName, 'BackendPool1')
          }
          probe: {
            id: resourceId('Microsoft.Network/loadBalancers/probes', loadBalancerName, 'lbprobe')
          }
          protocol: 'Tcp'
          frontendPort: 80
          backendPort: 80
          idleTimeoutInMinutes: 15
        }
        name: 'lbrule'
      }
    ]
    probes: [
      {
        properties: {
          protocol: 'Tcp'
          port: 80
          intervalInSeconds: 15
          numberOfProbes: 2
        }
        name: 'lbprobe'
      }
    ]
  }
  dependsOn: [
    virtualNetwork
  ]
}

resource vm 'Microsoft.Compute/virtualMachines@2023-09-01' = [for i in range(0, numberOfInstances): {
  name: '${vmNamePrefix}${i}'
  location: location
  properties: {
    availabilitySet: {
      id: availabilitySet.id
    }
    hardwareProfile: {
      vmSize: vmSize
    }
    osProfile: {
      computerName: '${vmNamePrefix}${i}'
      adminUsername: adminUsername
      adminPassword: adminPassword
    }
    storageProfile: {
      imageReference: {
        publisher: 'MicrosoftWindowsServer'
        offer: 'WindowsServer'
        sku: '2019-Datacenter'
        version: 'latest'
      }
      osDisk: {
        createOption: 'FromImage'
      }
    }
    networkProfile: {
      networkInterfaces: [
        {
          id: networkInterface[i].id
        }
      ]
    }
    diagnosticsProfile: {
      bootDiagnostics: {
        enabled: true
        storageUri: storageAccount.properties.primaryEndpoints.blob
      }
    }
  }
}]

output location string = location
output name string = loadBalancer.name
output resourceGroupName string = resourceGroup().name
output resourceId string = loadBalancer.id

Implantar o modelo do Bicep

Salve o arquivo Bicep ni seu computador local como main.bicep.

Implante o arquivo Bicep usando a CLI do Azure ou o Azure PowerShell:

CLI

az group create \
    --name TestRG \
    --location eastus

az deployment group create \
    --resource-group TestRG \
    --template-file main.bicep

PowerShell

 $rgParams = @{
     Name     = 'TestRG'
     Location = 'eastus'
 }
 New-AzResourceGroup @rgParams

 $deploymentParams = @{
     ResourceGroupName = 'TestRG'
     TemplateFile      = 'main.bicep'
 }
 New-AzResourceGroupDeployment @deploymentParams

Quando a implantação for concluída, uma mensagem indicará que a implantação foi bem-sucedida.

Implantar o Azure Bastion

O Bastion usa seu navegador para se conectar às VMs em sua rede virtual por meio do Secure Shell (SSH) ou do Protocolo de Área de Trabalho Remota (RDP) usando os respectivos 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 Bastion, consulte O que é o Azure Bastion?.

Observação

Use o modelo do Bicep Azure Bastion como Serviço a partir dos Modelos de Início Rápido do Azure Resource Manager para implantar e configurar o Bastion na sua rede virtual. Este modelo do Bicep define os recursos do Azure a seguir:

Microsoft.Network virtualNetworks/subnets: cria uma sub-rede AzureBastionSubnet.
Microsoft.Network bastionHosts: cria o Bastion host.
Microsoft.Network publicIPAddresses: cria um endereço IP público para o host do Bastion.
Microsoft Network networkSecurityGroups: controla as configurações dos grupos de segurança de rede.

Revisar o arquivo Bicep:

@description('Name of new or existing vnet to which Azure Bastion should be deployed')
param vnetName string = 'vnet01'

@description('IP prefix for available addresses in vnet address space')
param vnetIpPrefix string = '10.1.0.0/16'

@description('Specify whether to provision new vnet or deploy to existing vnet')
@allowed([
  'new'
  'existing'
])
param vnetNewOrExisting string = 'new'

@description('Bastion subnet IP prefix MUST be within vnet IP prefix address space')
param bastionSubnetIpPrefix string = '10.1.1.0/26'

@description('Name of Azure Bastion resource')
param bastionHostName string

@description('Azure region for Bastion and virtual network')
param location string = resourceGroup().location

var publicIpAddressName = '${bastionHostName}-pip'
var bastionSubnetName = 'AzureBastionSubnet'

resource publicIp 'Microsoft.Network/publicIPAddresses@2022-01-01' = {
  name: publicIpAddressName
  location: location
  sku: {
    name: 'Standard'
  }
  properties: {
    publicIPAllocationMethod: 'Static'
  }
}

// if vnetNewOrExisting == 'new', create a new vnet and subnet
resource newVirtualNetwork 'Microsoft.Network/virtualNetworks@2022-01-01' = if (vnetNewOrExisting == 'new') {
  name: vnetName
  location: location
  properties: {
    addressSpace: {
      addressPrefixes: [
        vnetIpPrefix
      ]
    }
    subnets: [
      {
        name: bastionSubnetName
        properties: {
          addressPrefix: bastionSubnetIpPrefix
        }
      }
    ]
  }
}

// if vnetNewOrExisting == 'existing', reference an existing vnet and create a new subnet under it
resource existingVirtualNetwork 'Microsoft.Network/virtualNetworks@2022-01-01' existing = if (vnetNewOrExisting == 'existing') {
  name: vnetName
}
resource subnet 'Microsoft.Network/virtualNetworks/subnets@2022-01-01' = if (vnetNewOrExisting == 'existing') {
  parent: existingVirtualNetwork
  name: bastionSubnetName
  properties: {
    addressPrefix: bastionSubnetIpPrefix
  }
}

resource bastionHost 'Microsoft.Network/bastionHosts@2022-01-01' = {
  name: bastionHostName
  location: location
  dependsOn: [
    newVirtualNetwork
    existingVirtualNetwork
  ]
  properties: {
    ipConfigurations: [
      {
        name: 'IpConf'
        properties: {
          subnet: {
            id: subnet.id
          }
          publicIPAddress: {
            id: publicIp.id
          }
        }
      }
    ]
  }
}

Implantar o modelo do Bicep

Salve o arquivo Bicep no seu computador local como bastion.bicep.

Utilize um editor de texto ou código para fazer as seguintes alterações no arquivo:

Linha 2: alterar param vnetName string de 'vnet01' para 'VNet'.
Linha 5: alterar param vnetIpPrefix string de '10.1.0.0/16' para '10.0.0.0/16'.
Linha 12: alterar param vnetNewOrExisting string de 'new' para 'existing'.
Linha 15: alterar param bastionSubnetIpPrefix string de '10.1.1.0/26' para '10.0.1.0/26'.
Linha 18: alterar de param bastionHostName string para param bastionHostName = 'VNet-bastion'.

As primeiras 18 linhas do seu arquivo Bicep agora devem se parecer com o seguinte:

@description('Name of new or existing vnet to which Azure Bastion should be deployed')
param vnetName string = 'VNet'

@description('IP prefix for available addresses in vnet address space')
param vnetIpPrefix string = '10.0.0.0/16'

@description('Specify whether to provision new vnet or deploy to existing vnet')
@allowed([
  'new'
  'existing'
])
param vnetNewOrExisting string = 'existing'

@description('Bastion subnet IP prefix MUST be within vnet IP prefix address space')
param bastionSubnetIpPrefix string = '10.0.1.0/26'

@description('Name of Azure Bastion resource')
param bastionHostName = 'VNet-bastion'

Salve o arquivo bastion.bicep.

Implante o arquivo Bicep usando a CLI do Azure ou o Azure PowerShell:

CLI

az deployment group create \
     --resource-group TestRG \
     --template-file bastion.bicep

PowerShell

$deploymentParams = @{
    ResourceGroupName = 'TestRG'
    TemplateFile      = 'bastion.bicep'
}
New-AzResourceGroupDeployment @deploymentParams

Quando a implantação for concluída, uma mensagem indicará que a implantação foi bem-sucedida.

Observação

Examinar os recursos implantados

Use a CLI do Azure, o Azure PowerShell ou o portal do Azure para revisar os recursos implantados:

CLI

az resource list --resource-group TestRG

PowerShell

Get-AzResource -ResourceGroupName TestRG

Portal

No portal do Azure, pesquise e selecione Grupos de Recursos. Na página Grupos de Recursos, selecione TestRG na lista de grupos de recursos.
Na página Visão Geral do TestRG, revise todos os recursos que você criou, incluindo a rede virtual, as duas VMs e o host do Bastion.
Selecione a rede virtual VNet. Na página Visão Geral da VNet, observe o espaço de endereço definido de 10.0.0.0/16.
No menu à esquerda,selecioneSub-redes. Na página Sub-redes, observe as sub-redes backendSubnet e AzureBastionSubnet implantadas com os valores atribuídos dos arquivos Bicep.

O script usa o provedor do Azure Resource Manager (azurerm) para interagir com os recursos do Azure. Ele usa o provedor Aleatório (random) para gerar nomes aleatórios de animais de estimação para os recursos.

O script cria os seguintes recursos:

Um grupo de recursos: um contêiner que contém recursos relacionados para uma solução do Azure.
Uma rede virtual: um bloco de construção fundamental para sua rede privada no Azure.
Duas sub-redes: segmentos do intervalo de endereços IP de uma rede virtual em que você pode colocar grupos de recursos isolados.

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.

Implementar o código do Terraform

Observação

O código de exemplo deste artigo está no repositório GitHub do Terraform do Azure. Você pode exibir o arquivo de log que contém os resultados do teste das versões atuais e anteriores do Terraform.

Para obter mais artigos e código de exemplo que mostram como usar o Terraform para gerenciar recursos do Azure, consulte a página de documentação do Terraform no Azure.

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

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"]
}

# Subnet 2
resource "azurerm_subnet" "my_terraform_subnet_2" {
  name                 = "subnet-2"
  resource_group_name  = azurerm_resource_group.rg.name
  virtual_network_name = azurerm_virtual_network.my_terraform_network.name
  address_prefixes     = ["10.0.1.0/24"]
}

resource "random_pet" "prefix" {
  prefix = var.resource_group_name_prefix
  length = 1
}

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 "subnet_name_2" {
  description = "The name of the created subnet 2."
  value       = azurerm_subnet.my_terraform_subnet_2.name
}

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

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~>3.0"
    }
  }
}

provider "azurerm" {
  features {}
}

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."
}

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 o comando terraform apply para aplicar o plano de execução à sua infraestrutura de nuvem.

terraform apply main.tfplan

Pontos principais:

O exemplo de comando do terraform apply pressupõe que você executou o 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.

Verifique os resultados

Obtenha o nome do grupo de recursos do Azure:

resource_group_name=$(terraform output -raw resource_group_name)

Obtenha o nome da rede virtual:

virtual_network_name=$(terraform output -raw virtual_network_name)

Use az network vnet show para exibir os detalhes da rede virtual recém-criada:

az network vnet show \
    --resource-group $resource_group_name \
    --name $virtual_network_name

Solucionar problemas do Terraform no Azure

Para obter informações sobre como solucionar problemas do Terraform, consulte Solucionar problemas comuns ao usar o Terraform no Azure.

Conectar-se a uma máquina virtual

No portal, pesquise e selecione Máquinas virtuais.
Na página Máquinas virtuais, selecione vm-1.
Nas informações Visão geral da vm-1, selecione Conectar.
Na página Conectar à máquina virtual, selecione a guia Bastion.
Selecione Usar Bastion.
Insira o nome de usuário e a senha criados quando vocês criou a máquina virtual e selecione Conectar.

Iniciar a comunicação entre as VMs

No prompt do Bash para vm-1, insira ping -c 4 vm-2.

Você recebe uma resposta semelhante à seguinte mensagem:

azureuser@vm-1:~$ ping -c 4 vm-2
PING vm-2.3bnkevn3313ujpr5l1kqop4n4d.cx.internal.cloudapp.net (10.0.0.5) 56(84) bytes of data.
64 bytes from vm-2.internal.cloudapp.net (10.0.0.5): icmp_seq=1 ttl=64 time=1.83 ms
64 bytes from vm-2.internal.cloudapp.net (10.0.0.5): icmp_seq=2 ttl=64 time=0.987 ms
64 bytes from vm-2.internal.cloudapp.net (10.0.0.5): icmp_seq=3 ttl=64 time=0.864 ms
64 bytes from vm-2.internal.cloudapp.net (10.0.0.5): icmp_seq=4 ttl=64 time=0.890 ms

Feche a conexão do Bastion para vm-1.
Repita as etapas em Conectar-se a uma máquina virtual para se conectar à vm-2.

No prompt do Bash para vm-2, insira ping -c 4 vm-1.

Você recebe uma resposta semelhante à seguinte mensagem:

azureuser@vm-2:~$ ping -c 4 vm-1
PING vm-1.3bnkevn3313ujpr5l1kqop4n4d.cx.internal.cloudapp.net (10.0.0.4) 56(84) bytes of data.
64 bytes from vm-1.internal.cloudapp.net (10.0.0.4): icmp_seq=1 ttl=64 time=0.695 ms
64 bytes from vm-1.internal.cloudapp.net (10.0.0.4): icmp_seq=2 ttl=64 time=0.896 ms
64 bytes from vm-1.internal.cloudapp.net (10.0.0.4): icmp_seq=3 ttl=64 time=3.43 ms
64 bytes from vm-1.internal.cloudapp.net (10.0.0.4): icmp_seq=4 ttl=64 time=0.780 ms

Feche a conexão do Bastion com a vm-2.

Limpar os recursos

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

No portal do Azure, pesquise e selecione grupos de recursos.
Na página Grupos de recursos, selecione o grupo de recursos test-rg.
Na página test-rg, selecione Excluir grupo de recursos .
Insira test-rg em Inserir o nome do grupo de recursos para confirmar a exclusão e, em seguida, selecione Excluir.

Quando terminar com a rede virtual e as VMs, use Remove-AzResourceGroup para remover o grupo de recursos e todos os seus recursos:

$rgParams = @{
    Name = 'test-rg'
    Force = $true
}
Remove-AzResourceGroup @rgParams

Quando terminar de usar a rede virtual e as VMs, use az group delete para remover o grupo de recursos e todos os seus recursos:

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

Quando não precisar mais dos recursos criados com a rede virtual, exclua o grupo de recursos. Essa ação remove a rede virtual e todos os recursos relacionados.

Para excluir o grupo de recursos, chame o cmdlet Remove-AzResourceGroup:

Remove-AzResourceGroup -Name <your resource group name>

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

Execute o comando terraform plan e especifique a flag 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.
Execute o comando terraform apply para aplicar o plano de execução.
```
terraform apply main.destroy.tfplan
```

Compartilhar via

Início Rápido: Criar uma Rede Virtual do Azure

Pré-requisitos

Entrar no Azure

Criar uma rede virtual e um host do Azure Bastion

Criar máquinas virtuais

Conectar-se a uma máquina virtual

Iniciar a comunicação entre as VMs

Limpar os recursos

Conteúdo relacionado

Comentários

Recursos adicionais