Inicio rápido: Creación de un equilibrador de carga interno para equilibrar la carga de las máquinas virtuales mediante una plantilla de ARM

En esta guía de inicio rápido aprenderá a usar una plantilla de Azure Resource Manager (plantilla de ARM) para crear un equilibrador de carga interno de Azure. El equilibrador de carga interno distribuye el tráfico a las máquinas virtuales de una red virtual ubicada en el grupo de back-end del equilibrador de carga. Junto con el equilibrador de carga interno, esta plantilla crea una red virtual, interfaces de red, una NAT Gateway y una instancia de Azure Bastion.

El uso de una plantilla de Resource Manager requiere menos pasos que otros métodos de implementación.

Una plantilla de Azure Resource Manager es un archivo de notación de objetos JavaScript (JSON) que define tanto la infraestructura como la configuración de un proyecto. La plantilla usa sintaxis declarativa. Se describe la implementación deseada sin escribir la secuencia de comandos de programación para crear la implementación.

Si su entorno cumple los requisitos previos y está familiarizado con el uso de plantillas de Resource Manager, seleccione el botón Implementar en Azure. La plantilla se abre en Azure Portal.

Requisitos previos

Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

Revisión de la plantilla

La plantilla utilizada en esta guía de inicio rápido forma parte de las plantillas de inicio rápido de 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

En la plantilla se han definido varios recursos de Azure:

Microsoft.Network/virtualNetworks: red virtual para el equilibrador de carga y las máquinas virtuales.
Microsoft.Network/networkInterfaces: interfaces de red para las máquinas virtuales.
Microsoft.Network/loadBalancers: Equilibrador de carga interno.
Microsoft.Network/natGateways
Microsoft.Network/publicIPAddresses: direcciones IP públicas para NAT Gateway y Azure Bastion.
Microsoft.Compute/virtualMachines: máquinas virtuales del grupo de back-end.
Microsoft.Network/bastionHosts: instancia de Azure Bastion.
Microsoft.Network/virtualNetworks/subnets: subredes para la red virtual.
Microsoft.Storage/storageAccounts: cuenta de almacenamiento para las máquinas virtuales.

Para encontrar más plantillas relacionadas con Azure Load Balancer, consulte Plantillas de inicio rápido de Azure.

Implementación de la plantilla

En este paso, implementará la plantilla mediante Azure PowerShell con el comando [New-AzResourceGroupDeployment](/powershell/module/az.resources/new-azresourcegroupdeployment).

Seleccione Try It (Probarlo) en el bloque de código siguiente para abrir Azure Cloud Shell y siga las instrucciones para iniciar sesión en Azure.

Implemente el archivo de Bicep mediante la CLI de Azure 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."

Se le pedirá que escriba los siguientes valores:

projectName: se usa para generar nombres de recursos.
adminUsername: el nombre de usuario del administrador de la máquina virtual.
adminPassword: la contraseña del administrador de la máquina virtual.

Tardará unos 10 minutos en implementar la plantilla.

Se usan Azure PowerShell o la CLI de Azure para implementar la plantilla. También es posible usar Azure Portal y la API de REST. Para obtener información sobre otros métodos de implementación, consulte Implementación de plantillas.

Revisión de los recursos implementados

Use la CLI de Azure o Azure PowerShell para enumerar los recursos implementados en el grupo de recursos con los comandos siguientes:

CLI
PowerShell

az resource list --resource-group $resourceGroupName

Get-AzResource -ResourceGroupName $resourceGroupName

Limpieza de recursos

Cuando ya no los necesite, use la CLI de Azure o Azure PowerShell para eliminar el grupo de recursos y sus recursos con los comandos siguientes:

CLI
PowerShell

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

Remove-AzResourceGroup -Name CreateIntLBQS-rg

Pasos siguientes

Para obtener un tutorial paso a paso que le guíe en el proceso de creación de una plantilla, consulte:

Tutorial: Creación e implementación de su primera plantilla de Resource Manager

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2024-05-18