Guia de início rápido: criar um balanceador de carga interno para balancear a carga de VMs usando um modelo ARM

Neste início rápido, você aprende a usar um modelo do Azure Resource Manager (modelo ARM) para criar um balanceador de carga interno do Azure. O balanceador de carga interno distribui o tráfego para máquinas virtuais em uma rede virtual localizada no pool de back-end do balanceador de carga. Junto com o balanceador de carga interno, esse modelo cria uma rede virtual, interfaces de rede, um Gateway NAT e uma instância do Azure Bastion.

O uso de um modelo ARM leva menos etapas em comparação com outros métodos de implantaçã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 utiliza 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.

Pré-requisitos

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

Rever o modelo

O modelo usado neste início rápido é dos Modelos de Início Rápido do Azure.


@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 VM')
param vmSize string = 'Standard_D2s_v3'

@description('Virtual network address prefix')
param vNetAddressPrefix string = '10.0.0.0/16'

@description('Backend subnet address prefix')
param vNetSubnetAddressPrefix string = '10.0.0.0/24'

@description('Bastion subnet address prefix')
param vNetBastionSubnetAddressPrefix string = '10.0.2.0/24'

@description('Frontend IP address of load balancer')
param lbFrontendIPAddress string = '10.0.0.6'

var natGatewayName = 'lb-nat-gateway'
var natGatewayPublicIPAddressName = 'lb-nat-gateway-ip'
var vNetName = 'lb-vnet'
var vNetSubnetName = 'backend-subnet'
var storageAccountType = 'Standard_LRS'
var storageAccountName = uniqueString(resourceGroup().id)
var loadBalancerName = 'internal-lb'
var networkInterfaceName = 'lb-nic'
var numberOfInstances = 2
var lbSkuName = 'Standard'
var bastionName = 'lb-bastion'
var bastionSubnetName = 'AzureBastionSubnet'
var bastionPublicIPAddressName = 'lb-bastion-ip'

resource natGateway 'Microsoft.Network/natGateways@2023-09-01' = {
  name: natGatewayName
  location: location
  sku: {
    name: 'Standard'
  }
  properties: {
    idleTimeoutInMinutes: 4
    publicIpAddresses: [
      {
        id: natGatewayPublicIPAddress.id
      }
    ]
  }
}

resource natGatewayPublicIPAddress 'Microsoft.Network/publicIPAddresses@2023-09-01' = {
  name: natGatewayPublicIPAddressName
  location: location
  sku: {
    name: 'Standard'
  }
  properties: {
    publicIPAddressVersion: 'IPv4'
    publicIPAllocationMethod: 'Static'
    idleTimeoutInMinutes: 4
  }
}

resource vNet 'Microsoft.Network/virtualNetworks@2023-09-01' = {
  name: vNetName
  location: location
  properties: {
    addressSpace: {
      addressPrefixes: [
        vNetAddressPrefix
      ]
    }
  }
}

resource vNetName_bastionSubnet 'Microsoft.Network/virtualNetworks/subnets@2023-09-01' = {
  parent: vNet
  name: bastionSubnetName
  properties: {
    addressPrefix: vNetBastionSubnetAddressPrefix
  }
}

resource vNetName_vNetSubnetName 'Microsoft.Network/virtualNetworks/subnets@2023-09-01' = {
  parent: vNet
  name: vNetSubnetName
  properties: {
    addressPrefix: vNetSubnetAddressPrefix
    natGateway: {
      id: natGateway.id
    }
  }
}

resource bastion 'Microsoft.Network/bastionHosts@2023-09-01' = {
  name: bastionName
  location: location
  properties: {
    ipConfigurations: [
      {
        name: 'IpConf'
        properties: {
          privateIPAllocationMethod: 'Dynamic'
          publicIPAddress: {
            id: bastionPublicIPAddress.id
          }
          subnet: {
            id: vNetName_bastionSubnet.id
          }
        }
      }
    ]
  }
}

resource bastionPublicIPAddress 'Microsoft.Network/publicIPAddresses@2023-09-01' = {
  name: bastionPublicIPAddressName
  location: location
  sku: {
    name: lbSkuName
  }
  properties: {
    publicIPAddressVersion: 'IPv4'
    publicIPAllocationMethod: 'Static'
  }
}

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: vNetName_vNetSubnetName.id
          }
          loadBalancerBackendAddressPools: [
            {
              id: resourceId('Microsoft.Network/loadBalancers/backendAddressPools', loadBalancerName, 'BackendPool1')
            }
          ]
        }
      }
    ]
  }
  dependsOn: [
    vNet
    loadBalancer
  ]
}]

resource loadBalancer 'Microsoft.Network/loadBalancers@2023-09-01' = {
  name: loadBalancerName
  location: location
  sku: {
    name: 'Standard'
  }
  properties: {
    frontendIPConfigurations: [
      {
        properties: {
          subnet: {
            id: vNetName_vNetSubnetName.id
          }
          privateIPAddress: lbFrontendIPAddress
          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'
      }
    ]
  }
}

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

resource vm 'Microsoft.Compute/virtualMachines@2023-09-01' = [for i in range(0, numberOfInstances): {
  name: '${vmNamePrefix}${i}'
  location: location
  properties: {
    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

Vários recursos do Azure foram definidos no modelo:

Microsoft.Network/virtualNetworks: Rede virtual para balanceador de carga e máquinas virtuais.
Microsoft.Network/networkInterfaces: Interfaces de rede para máquinas virtuais.
Microsoft.Network/loadBalancers: Balanceador de carga interno.
Microsoft.Network/natGateways
Microsoft.Network/publicIPAddresses: endereços IP públicos para o Gateway NAT e o Azure Bastion.
Microsoft.Compute/virtualMachines: Máquinas virtuais no pool de back-end.
Microsoft.Network/bastionHosts: instância do Azure Bastion.
Microsoft.Network/virtualNetworks/subnets: Sub-redes para a rede virtual.
Microsoft.Storage/storageAccounts: Conta de armazenamento para as máquinas virtuais.

Para encontrar mais modelos relacionados ao Balanceador de Carga do Azure, consulte Modelos de início rápido do Azure.

Implementar o modelo

Nesta etapa, você implanta o modelo usando o Azure PowerShell com o [New-AzResourceGroupDeployment](/powershell/module/az.resources/new-azresourcegroupdeployment) comando.

Selecione Experimente no bloco de código a seguir para abrir o Azure Cloud Shell e siga as instruções para entrar no Azure.

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

CLI
PowerShell

 echo "Enter a project name with 12 or less letters or numbers that is used to generate Azure resource names"
 read projectName
 echo "Enter the location (i.e. centralus)"
 read location

 resourceGroupName="${projectName}rg"
 templateUri="https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/quickstarts/microsoft.network/internal-loadbalancer-create/azuredeploy.json"

 az group create --name $resourceGroupName --location $location
 az deployment group create --resource-group $resourceGroupName --template-uri $templateUri --name $projectName --parameters location=$location

 read -p "Press [ENTER] to continue."

$projectName = Read-Host -Prompt "Enter a project name with 12 or less letters or numbers that is used to generate Azure resource names"
$location = Read-Host -Prompt "Enter the location (i.e. centralus)"

$resourceGroupName = "${projectName}rg"
$templateUri = "https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/quickstarts/microsoft.network/internal-loadbalancer-create/azuredeploy.json"

New-AzResourceGroup -Name $resourceGroupName -Location $location
New-AzResourceGroupDeployment -ResourceGroupName $resourceGroupName -TemplateUri $templateUri -Name $projectName -location $location

Write-Host "Press [ENTER] to continue."

Você será solicitado a inserir os seguintes valores:

projectName: usado para gerar nomes de recursos.
adminUsername: nome de usuário do administrador da máquina virtual.
adminPassword: senha de administrador da máquina virtual.

Leva cerca de 10 minutos para implantar o modelo.

O Azure PowerShell ou a CLI do Azure é usada para implantar o modelo. Você também pode usar o portal do Azure e a API REST. Para aprender outros métodos de implantação, consulte Implantar modelos.

Revisar os recursos implementados

Use a CLI do Azure ou o Azure PowerShell para listar os recursos implantados no grupo de recursos com os seguintes comandos:

CLI
PowerShell

az resource list --resource-group $resourceGroupName

Get-AzResource -ResourceGroupName $resourceGroupName

Limpar recursos

Quando não for mais necessário, use a CLI do Azure ou o Azure PowerShell para excluir o grupo de recursos e seus recursos com os seguintes comandos:

CLI
PowerShell

Remove-AzResourceGroup -Name "${projectName}rg"

Remove-AzResourceGroup -Name CreateIntLBQS-rg

Próximos passos

Para obter um tutorial passo a passo que o orienta pelo processo de criação de um modelo, consulte:

Tutorial: Criar e implantar seu primeiro modelo ARM

Feedback

Esta página foi útil?

Last updated on 2024-05-17