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

• 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.

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

• Utilize o ambiente Bash no Azure Cloud Shell. Para obter mais informações, confira Introdução ao Azure Cloud Shell.

  

• Se preferir executar os comandos de referência da CLI localmente, instale a CLI do Azure. Se você estiver executando no Windows ou no macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, confira 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 as etapas exibidas em seu terminal. Para obter outras opções de entrada, consulte Autenticar no Azure usando a CLI do Azure.

  • Quando solicitado, instale a extensão da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar e gerenciar extensões com a CLI do Azure.

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

• Este artigo exige a versão 2.0.28 ou posterior da CLI do Azure. Se estiver usando o Azure Cloud Shell, a versão mais recente já está instalada.

Se você estiver executando a CLI do Azure localmente, use a CLI do Azure versão 2.0.31 ou posterior.

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

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 a sintaxe declarativa. Você descreve a implantação pretendida sem escrever a sequência de comandos de programação para criar a implantação.

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

• Para implantar os arquivos Bicep, é necessário ter a CLI do Azure ou o Azure PowerShell instalados.

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

• Instalação e configuração do Terraform.

Criar um grupo de recursos

1. Entre no portal do Azure com sua conta do Azure.

2. Na caixa de pesquisa na parte superior do portal, insira Grupo de recursos. Selecione Grupos de recursos nos resultados da pesquisa.

3. Selecione + Criar.

4. Na guia Noções básicas de Criar um grupo de recursos, insira ou selecione as seguintes informações:

   Configurações	Valor
   Subscrição	Selecione sua assinatura.
   Grupo de recursos	Insira test-rg.
   Região	Selecione Leste dos EUA 2.

5. Selecione Examinar + criar.

6. Selecione Criar.

Criar uma rede virtual

1. Na caixa de pesquisa na parte superior do portal, insira Rede virtual. Selecione redes virtuais nos resultados da pesquisa.

2. Selecione + Criar.

3. 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 test-rg.
   Detalhes da instância
   Nome	Insira vnet-1.
   Região	Selecione Leste dos EUA 2.

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

5. Selecione Avançar para prosseguir para a guia Endereços IP.

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

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

   Configurações	Valor
   Detalhes da sub-rede
   Modelo de sub-rede	Deixe a configuração padrão Default.
   Nome	Digite subnet-1.
   Endereço inicial	Deixe o padrão de 10.0.0.0.
   Tamanho da sub-rede	Deixe o padrão de /24 (256 endereços).

8. Clique em Salvar.

9. Selecione Examinar + criar na parte inferior da tela e, quando a validação for aprovada, selecione Criar.

Implantar o Azure Bastion

O Azure Bastion usa seu navegador para se conectar a VMs (máquinas virtuais) em sua rede virtual por SSH (secure shell) ou rdp (protocolo de área de trabalho remota) usando seus endereços IP privados. As máquinas virtuais não precisam de endereços IP públicos, software cliente ou configuração especial. Para obter mais informações sobre o Azure Bastion, confira Azure Bastion.

1. Na caixa de pesquisa na parte superior do portal, insira Bastion. Selecione Bastions nos resultados da pesquisa.

2. Selecione + Criar.

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

   Configurações	Valor
   Detalhes do projeto
   Subscrição	Selecione sua assinatura.
   Grupo de recursos	Selecione test-rg.
   Detalhes da instância
   Nome	Insira bastion.
   Região	Selecione Leste dos EUA 2.
   Camada	Selecione Desenvolvedor.
   Configurar redes virtuais
   Rede virtual	Selecione vnet-1.

4. Selecione Examinar + criar.

5. Selecione Criar.

Criar máquinas virtuais

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

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

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

3. 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 Chave pública SSH.
   Nome de usuário	insira azureuser.
   Origem de chave pública SSH	Selecione Gerar novo par de chaves.
   Nome do par de chaves	Insira vm-1-key.
   Regras do porto de entrada
   Portas de entrada públicas	Selecione Nenhum.

4. 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 subnet-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.

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

6. Examine as configurações e selecione Criar.

7. 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.
   Origem de chave pública SSH	Selecione Gerar novo par de chaves.
   Nome do par de chaves	Insira vm-2-key.
   Rede virtual	Selecione vnet-1.
   Sub-rede	Selecione subnet-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.

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

1. 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
   

2. 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
   

3. 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 máquinas virtuais em sua rede virtual por SSH (Secure Shell) ou RDP (Protocolo de Área de Trabalho Remota) usando seus endereços IP privados. As máquinas virtuais 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 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.

1. 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
   

2. Defina a configuração:

   $virtualNetwork | Set-AzVirtualNetwork
   

3. 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
   

4. Use o comando New-AzBastion para criar um novo host básico do SKU Bastion no 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. Você pode criar máquinas virtuais na próxima seção enquanto o Bastion é implantado em sua rede virtual.

Criar máquinas virtuais

Criar a primeira máquina virtual

Crie uma máquina virtual com New-AzVM. O exemplo a seguir cria uma máquina virtual chamada vm-1 na rede virtual vnet-1 .

# Create a credential object
$cred = Get-Credential

# Define the virtual machine parameters
$vmParams = @{
    ResourceGroupName = "test-rg"
    Location = "eastus2"
    Name = "vm-1"
    Image = "Ubuntu2204"
    Size = "Standard_DS1_v2"
    Credential = $cred
    VirtualNetworkName = "vnet-1"
    SubnetName = "subnet-1"
    PublicIpAddressName = ""  # No public IP address
    SshKeyName = "vm-1-ssh-key"
    GenerateSshKey = $true
}

# Create the virtual machine
New-AzVM @vmParams

Criar a segunda máquina virtual

# Create a credential object
$cred = Get-Credential

# Define the virtual machine parameters
$vmParams = @{
    ResourceGroupName = "test-rg"
    Location = "eastus2"
    Name = "vm-2"
    Image = "Ubuntu2204"
    Size = "Standard_DS1_v2"
    Credential = $cred
    VirtualNetworkName = "vnet-1"
    SubnetName = "subnet-1"
    PublicIpAddressName = ""  # No public IP address
    SshKeyName = "vm-2-ssh-key"
    GenerateSshKey = $true
}

# Create the virtual machine
New-AzVM @vmParams

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

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

O Azure Bastion usa seu navegador para se conectar a máquinas virtuais em sua rede virtual por SSH (Secure Shell) ou RDP (Protocolo de Área de Trabalho Remota) usando seus endereços IP privados. As máquinas virtuais não precisam de endereços IP públicos, software cliente ou configuração especial.

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. Para obter mais informações sobre o Azure Bastion, consulte o que é o Azure Bastion?.

1. 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
   

2. 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
   

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 \
       --sku Basic
   

A implantação dos recursos do Bastion leva cerca de 10 minutos. Você pode criar máquinas virtuais na próxima seção enquanto o Bastion é implantado em sua rede virtual.

Criar máquinas virtuais

Criar a primeira máquina virtual

Crie uma máquina virtual com az vm create. O exemplo a seguir cria uma máquina virtual chamada vm-1 na rede virtual vnet-1 . Se as chaves SSH ainda não existirem em uma localização de chave padrão, o comando as criará. A --no-wait opção cria a máquina virtual em segundo plano, para que você possa continuar para a próxima etapa.

az vm create \
    --resource-group test-rg \
    --name vm-1 \
    --image Ubuntu2204 \
    --vnet-name vnet-1 \
    --subnet subnet-1 \
    --public-ip-address "" \
    --admin-username azureuser \
    --generate-ssh-keys \
    --no-wait

Criar a segunda máquina virtual

Crie uma máquina virtual chamada vm-2 na rede virtual vnet-1 .

az vm create \
    --resource-group test-rg \
    --name vm-2 \
    --image Ubuntu2204 \
    --vnet-name vnet-1 \
    --subnet subnet-1 \
    --public-ip-address "" \
    --admin-username azureuser \
    --generate-ssh-keys

A máquina virtual leva alguns minutos para ser criada.

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: cria uma rede virtual.
• Microsoft.Network/virtualNetworks/subnets: Cria uma sub-rede.

Implantar o modelo

Implantar o modelo do Resource Manager no Azure:

1. Selecione Implantar no Azure para entrar no Azure e abrir o modelo. O modelo cria uma rede virtual com duas sub-redes.

   

2. 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.

3. Selecione Examinar + Criar e, em seguida, selecione Criar.

4. 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 as máquinas virtuais

Este início rápido usa o modelo do Bicep Duas VMs na VNet dos Modelos de Início Rápido do Azure Resource Manager para criar a rede virtual, a sub-rede de recursos e as máquinas virtuais. O modelo do Bicep define os recursos do Azure a seguir:

• Microsoft.Network virtualNetworks: cria uma rede virtual do Azure.
• Microsoft.Network virtualNetworks/subnets: Cria uma sub-rede para as máquinas virtuais.
• Microsoft.Compute virtualMachines: cria as máquinas virtuais.
• 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

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

2. 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 é concluída, uma mensagem indica que a implantação foi bem-sucedida.

Implantar o Azure Bastion

O Bastion usa seu navegador para se conectar a máquinas virtuais em sua rede virtual por SSH (Secure Shell) ou RDP (Protocolo de Área de Trabalho Remota) usando seus endereços IP privados. As máquinas virtuais não precisam de endereços IP públicos, software cliente ou configuração especial. Para obter mais informações sobre o Azure Bastion, confira O que é o Azure Bastion?

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 para 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

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

2. 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'
   
   

3. Salve o arquivo bastion.bicep.

4. 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 é concluída, uma mensagem indica que a implantação foi bem-sucedida.

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

1. No portal do Azure, pesquise e selecione Grupos de Recursos. Na página Grupos de Recursos, selecione TestRG na lista de grupos de recursos.

2. Na página Visão geral do TestRG, examine todos os recursos que você criou, incluindo a rede virtual, as duas máquinas virtuais e o host bastion.

3. 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.

4. 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

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

2. Crie um arquivo chamado main.tf 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
   }
   

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

4. 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 {}
   }
   

5. 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

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

   resource_group_name=$(terraform output -raw resource_group_name)
   

2. Obtenha o nome da rede virtual:

   virtual_network_name=$(terraform output -raw virtual_network_name)
   

3. Use az network vnet show para mostrar os detalhes da sua 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.

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

1. No portal do Azure, pesquise 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. Insira test-rg em Inserir o nome do grupo de recursos para confirmar a exclusão e, em seguida, selecione Excluir.

Quando terminar de usar a rede virtual e as máquinas virtuais, 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 máquinas virtuais, 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>

1. No portal do Azure, na página Grupos de recursos, selecione o grupo de recursos TestRG.

2. Na parte superior da página TestRG, selecione Excluir o grupo de recursos .

3. Na página Excluir um grupo de recursos, em Inserir nome do grupo de recursos para confirmar a exclusão, insira TestRG e, em seguida, selecione Excluir.

4. Selecione Delete novamente.

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

1. 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.

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

   terraform apply main.destroy.tfplan