Szybki start: tworzenie wewnętrznego modułu równoważenia obciążenia w celu równoważenia obciążenia maszyn wirtualnych przy użyciu Bicep

Z tego przewodnika Szybki start dowiesz się, jak utworzyć wewnętrzny moduł równoważenia obciążenia platformy Azure za pomocą pliku Bicep. Wewnętrzny moduł równoważenia obciążenia dystrybuuje ruch do maszyn wirtualnych w sieci wirtualnej znajdującej się w puli zaplecza modułu równoważenia obciążenia. Wraz z wewnętrznym równoważnikiem obciążenia ten szablon tworzy sieć wirtualną, interfejsy sieciowe, bramę NAT i wystąpienie usługi Azure Bastion.

Bicep to język specyficzny dla domeny (DSL), który używa składni deklaratywnej do wdrażania zasobów platformy Azure. Zapewnia zwięzłą składnię, niezawodne bezpieczeństwo typów i obsługę ponownego użycia kodu. Bicep oferuje najlepsze środowisko tworzenia rozwiązań infrastruktury jako kodu na platformie Azure.

Wymagania wstępne

Jeśli nie masz subskrypcji Azure, przed rozpoczęciem utwórz darmowe konto.

Przejrzyj plik programu Bicep

Plik Bicep używany w tym przewodniku szybkiego startu pochodzi z szablonów szybkiego startu 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

W pliku Bicep zdefiniowano wiele zasobów platformy Azure:

Microsoft.Network/virtualNetworks: sieć wirtualna dla modułu równoważenia obciążenia i maszyn wirtualnych.
Microsoft.Network/networkInterfaces: interfejsy sieciowe dla maszyn wirtualnych.
Microsoft.Network/loadBalancers: wewnętrzny moduł równoważenia obciążenia.
Microsoft.Network/natGateways
Microsoft.Network/publicIPAddresses: publiczne adresy IP dla bramy NAT oraz usługi Azure Bastion.
Microsoft.Compute/virtualMachines: maszyny wirtualne w puli zapleczowej.
Microsoft.Network/bastionHosts: wystąpienie usługi Azure Bastion.
Microsoft.Network/virtualNetworks/subnets: Podsieci dla sieci wirtualnej.
Microsoft.Storage/storageAccounts: konto magazynu dla maszyn wirtualnych.

Wdróż plik Bicep

Zapisz plik Bicep jako main.bicep na komputerze lokalnym.
Wdróż plik Bicep przy użyciu interfejsu wiersza polecenia platformy Azure lub programu Azure PowerShell.
- CLI
- PowerShell
```
az group create --name CreateIntLBQS-rg --location eastus
az deployment group create --resource-group CreateIntLBQS-rg --template-file main.bicep --parameters adminUsername=AzureAdmin
```
```
New-AzResourceGroup -Name CreateIntLBQS-rg -Location eastus
New-AzResourceGroupDeployment -ResourceGroupName CreateIntLBQS-rg -TemplateFile ./main.bicep -adminUsername "<admin-user>"
```
Uwaga / Notatka

Zastąp wartość <admin-user> nazwą użytkownika administratora. Zostanie również wyświetlony monit o wprowadzenie adminPassword.

Po zakończeniu wdrażania powinien zostać wyświetlony komunikat informujący o pomyślnym wdrożeniu.

Przeglądanie wdrożonych zasobów

Użyj witryny Azure Portal, interfejsu wiersza polecenia platformy Azure lub programu Azure PowerShell, aby wyświetlić listę wdrożonych zasobów w grupie zasobów.

CLI
PowerShell

az resource list --resource-group CreateIntLBQS-rg

Get-AzResource -ResourceGroupName CreateIntLBQS-rg

Uprzątnij zasoby

Gdy grupa zasobów i jej zasoby nie będą już potrzebne, użyj witryny Azure Portal, interfejsu wiersza polecenia platformy Azure lub programu Azure PowerShell.

CLI
PowerShell

az group delete --name CreateIntLBQS-rg

Remove-AzResourceGroup -Name CreateIntLBQS-rg

Dalsze kroki

Aby zapoznać się z samouczkiem krok po kroku, który przeprowadzi Cię przez proces tworzenia pliku Bicep, zobacz:

Szybki start: tworzenie plików Bicep za pomocą programu Visual Studio Code

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-05-29