Schnellstart: Erstellen eines internen Lastenausgleichs für VMs mithilfe einer ARM-Vorlage

In dieser Schnellstartanleitung erfahren Sie, wie Sie mithilfe einer ARM-Vorlage (Azure Resource Manager) einen internen Azure-Lastenausgleich erstellen. Der interne Lastenausgleich verteilt Datenverkehr an VMs in einem virtuellen Netzwerk, das sich im Back-End-Pool des Lastenausgleichs befindet. Zusammen mit dem internen Lastenausgleich erstellt diese Vorlage ein virtuelles Netzwerk, Netzwerkschnittstellen, ein NAT-Gateway und eine Azure Bastion-Instanz.

Bei Verwendung einer ARM-Vorlage werden im Vergleich zu anderen Bereitstellungsmethoden weniger Schritte benötigt.

Eine Azure Resource Manager-Vorlage ist eine JSON (JavaScript Object Notation)-Datei, welche die Infrastruktur und die Konfiguration für Ihr Projekt definiert. Die Vorlage verwendet eine deklarative Syntax. Sie beschreiben Ihre geplante Bereitstellung, ohne die Abfolge der Programmierbefehle zum Erstellen der Bereitstellung zu schreiben.

Wenn Ihre Umgebung die Voraussetzungen erfüllt und Sie mit der Verwendung von ARM-Vorlagen vertraut sind, klicken Sie auf die Schaltfläche In Azure bereitstellen. Die Vorlage wird im Azure-Portal geöffnet.

Voraussetzungen

Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

Überprüfen der Vorlage

Die in dieser Schnellstartanleitung verwendete Vorlage stammt aus den Azure-Schnellstartvorlagen.

@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

In der Vorlage wurden mehrere Azure-Ressourcen definiert:

• Microsoft.Network/virtualNetworks: Virtuelles Netzwerk für Lastenausgleich und VMs
• Microsoft.Network/networkInterfaces: Netzwerkschnittstellen für VMs
• Microsoft.Network/loadBalancers: Interner Lastenausgleich
• Microsoft.Network/natGateways
• Microsoft.Network/publicIPAddresses: öffentliche IP-Adressen für das NAT-Gateway und Azure Bastion.
• Microsoft.Compute/virtualMachines: VMs im Back-End-Pool.
• Microsoft.Network/bastionHosts: Azure Bastion-Instanz.
• Microsoft.Network/virtualNetworks/subnets: Subnetze für das virtuelle Netzwerk.
• Microsoft.Storage/storageAccounts: Speicherkonten für die VMs.

Weitere Vorlagen zum Azure Load Balancer finden Sie unter Azure-Schnellstartvorlagen.

Bereitstellen der Vorlage

In diesem Schritt stellen Sie die Vorlage mithilfe von Azure PowerShell mit dem Befehl [New-AzResourceGroupDeployment](/powershell/module/az.resources/new-azresourcegroupdeployment) bereit.

1. Wählen Sie Try it (Ausprobieren) im folgenden Codeblock aus, um Azure Cloud Shell zu öffnen. Folgen Sie dann den Anweisungen, um sich bei Azure anzumelden.

2. Stellen Sie die Bicep-Datei entweder mit Azure CLI oder mit Azure PowerShell bereit.

   BEFEHLSZEILENSCHNITTSTELLE (CLI)

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

   PowerShell

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

   Sie werden aufgefordert, die folgenden Werte einzugeben:

   • projectName: Wird zum Generieren von Ressourcennamen verwendet.
   • adminUsername: Benutzername des VM-Administrators.
   • adminPassword: Kennwort des VM-Administrators.

Das Bereitstellen der Vorlage dauert ungefähr 10 Minuten.

Azure PowerShell oder die Azure CLI wird zum Bereitstellen der Vorlage verwendet. Sie können auch das Azure-Portal und die REST-API verwenden. Informationen zu anderen Bereitstellungsmethoden finden Sie unter Bereitstellen von Vorlagen.

Überprüfen der bereitgestellten Ressourcen

Verwenden Sie die Azure CLI oder Azure PowerShell, um die bereitgestellten Ressourcen in der Ressourcengruppe mithilfe der folgenden Befehle aufzulisten:

BEFEHLSZEILENSCHNITTSTELLE (CLI)

az resource list --resource-group $resourceGroupName

PowerShell

Get-AzResource -ResourceGroupName $resourceGroupName

Bereinigen von Ressourcen

Wenn die Ressourcengruppe und ihre Ressourcen nicht mehr benötigt werden, löschen Sie sie über die Azure CLI oder Azure PowerShell mithilfe der folgenden Befehle:

BEFEHLSZEILENSCHNITTSTELLE (CLI)

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

PowerShell

Remove-AzResourceGroup -Name CreateIntLBQS-rg

Nächste Schritte

Ein Schritt-für-Schritt-Tutorial mit Anleitungen zum Erstellen einer Vorlage finden Sie unter folgendem Link:

Tutorial: Erstellen und Bereitstellen Ihrer ersten ARM-Vorlage