Självstudie: Skapa och använd en anpassad avbildning för VM-skalningsuppsättningar med Azure PowerShell

Gäller för: ✔️ Virtuella Linux-datorer:heavy_check_mark: Windows:heavy_check_mark: Uniform Scale Sets

När du skapar en skalningsuppsättning, kan du ange en avbildning som ska användas när de virtuella datorinstanserna distribueras. Om du vill minska antalet uppgifter när de virtuella datorinstanserna distribueras, kan du använda en anpassad virtuell datoravbildning. Den här anpassade virtuella datoravbildningen inkluderar alla nödvändiga programinstallationer eller konfigurationer. Alla virtuella datorinstanser som skapats i skalningsuppsättningen använder den anpassade virtuella datoravbildningen och är redo att hantera din programtrafik. I den här guiden får du lära du dig hur man:

Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.

Innan du börjar

Stegen nedan beskriver hur du tar en befintlig virtuell dator och omvandlar den till en återanvändningsbar anpassad avbildning som du kan använda för att skapa en skalningsuppsättning.

Du måste ha en befintlig virtuell dator för att kunna utföra exemplet i den här självstudiekursen. Om det behövs kan du se PowerShell-snabbstarten för att skapa en virtuell dator som ska användas för den här självstudien. När du går igenom självstudien ersätter du resursnamnen där det behövs.

Starta Azure Cloud Shell

Azure Cloud Shell är ett interaktivt gränssnitt som du kan använda för att utföra stegen i den här artikeln. Den har vanliga Azure-verktyg förinstallerat och har konfigurerats för användning med ditt konto.

Om du vill öppna Cloud Shell väljer du bara Prova från det övre högra hörnet i ett kodblock. Du kan också starta Cloud Shell på en separat webbläsarflik genom att gå till https://shell.azure.com/powershell . Kopiera kodblocket genom att välja Kopiera, klistra in det i Cloud Shell och kör det genom att trycka på RETUR.

Hämta den virtuella datorn

Du kan se en lista över virtuella datorer som är tillgängliga i en resursgrupp med hjälp av Get-AzVM. När du känner till namnet på den virtuella datorn och vilken resursgrupp kan du använda igen för att hämta VM-objektet och lagra det i en variabel Get-AzVM som du kan använda senare. Det här exemplet hämtar en virtuell dator med namnet sourceVM från resursgruppen "myResourceGroup" och tilldelar den till variabeln $vm.

$sourceVM = Get-AzVM `
   -Name sourceVM `
   -ResourceGroupName myResourceGroup

Skapa en resursgrupp

Skapa en resursgrupp med kommandot New-AzResourceGroup.

En Azure-resursgrupp är en logisk container där Azure-resurser distribueras och hanteras. I följande exempel skapas en resursgrupp med namnet myGalleryRG i regionen EastUS:

$resourceGroup = New-AzResourceGroup `
   -Name 'myGalleryRG' `
   -Location 'EastUS'

Skapa ett bildgalleri

Ett bildgalleri är den primära resurs som används för att aktivera bilddelning. Tillåtna tecken för gallerinamn är versaler eller gemener, siffror, punkter och punkter. Gallerinamnet får inte innehålla bindestreck. Gallerinamn måste vara unika i din prenumeration.

Skapa ett bildgalleri med New-AzGallery. I följande exempel skapas ett galleri med namnet myGallery i resursgruppen myGalleryRG.

$gallery = New-AzGallery `
   -GalleryName 'myGallery' `
   -ResourceGroupName $resourceGroup.ResourceGroupName `
   -Location $resourceGroup.Location `
   -Description 'Azure Compute Gallery for my organization' 

Skapa en avbildningsdefinition

Bilddefinitioner skapar en logisk gruppering för bilder. De används för att hantera information om de avbildningsversioner som skapas i dem. Bilddefinitionsnamn kan består av versaler eller gemener, siffror, punkter, bindestreck och punkter. Mer information om de värden som du kan ange för en bilddefinition finns i Bilddefinitioner.

Skapa avbildningsdefinitionen med New-AzGalleryImageDefinition. I det här exemplet heter galleriavbildningen myGalleryImage och skapas för en specialiserad avbildning.

$galleryImage = New-AzGalleryImageDefinition `
   -GalleryName $gallery.Name `
   -ResourceGroupName $resourceGroup.ResourceGroupName `
   -Location $gallery.Location `
   -Name 'myImageDefinition' `
   -OsState specialized `
   -OsType Windows `
   -Publisher 'myPublisher' `
   -Offer 'myOffer' `
   -Sku 'mySKU'

Skapa en avbildningsversion

Skapa en avbildningsversion från en virtuell dator med hjälp av New-AzGalleryImageVersion.

Tillåtna tecken för bildversion är siffror och punkter. Tal måste vara inom intervallet för ett 32-bitars heltal. Format: MajorVersion. MinorVersion. Korrigera.

I det här exemplet är avbildningsversionen 1.0.0 och replikeras till både datacenter för USA, östra och USA, södra centrala. När du väljer målregioner för replikering måste du inkludera källregionen som mål för replikering.

Om du vill skapa en avbildningsversion från den virtuella datorn $vm.Id.ToString() använder du för -Source .

$region1 = @{Name='South Central US';ReplicaCount=1}
$region2 = @{Name='East US';ReplicaCount=2}
$targetRegions = @($region1,$region2)

New-AzGalleryImageVersion `
   -GalleryImageDefinitionName $galleryImage.Name`
   -GalleryImageVersionName '1.0.0' `
   -GalleryName $gallery.Name `
   -ResourceGroupName $resourceGroup.ResourceGroupName `
   -Location $resourceGroup.Location `
   -TargetRegion $targetRegions  `
   -Source $sourceVM.Id.ToString() `
   -PublishingProfileEndOfLifeDate '2020-12-01'

Det kan ta en stund att replikera avbildningen till alla målregioner.

Skapa en skalningsuppsättning från avbildningen

Nu skapar du en skalningsuppsättning med New-AzVmss som använder sig av -ImageName-parametern för att definiera den anpassade virtuella datoravbildningen som skapades i föregående steg. För att distribuera trafik till flera virtuella datorinstanser så skapas även en lastbalanserare. Lastbalanseraren innehåller regler för att distribuera trafik på TCP-port 80 och för att tillåta trafik för fjärrskrivbordet på TCP-port 3389 och PowerShell-fjärrkommunikation på TCP-port 5985. När du uppmanas, anger du dina egna önskade administrativa autentiseringsuppgifter för de virtuella datorinstanserna i skalningsuppsättning:

# Define variables for the scale set
$resourceGroupName = "myVMSSRG3"
$scaleSetName = "myScaleSet3"
$location = "East US"

# Create a resource group
New-AzResourceGroup -ResourceGroupName $resourceGroupName -Location $location

# Create a networking pieces
$subnet = New-AzVirtualNetworkSubnetConfig `
  -Name "mySubnet" `
  -AddressPrefix 10.0.0.0/24
$vnet = New-AzVirtualNetwork `
  -ResourceGroupName $resourceGroupName `
  -Name "myVnet" `
  -Location $location `
  -AddressPrefix 10.0.0.0/16 `
  -Subnet $subnet
$publicIP = New-AzPublicIpAddress `
  -ResourceGroupName $resourceGroupName `
  -Location $location `
  -AllocationMethod Static `
  -Name "myPublicIP"
$frontendIP = New-AzLoadBalancerFrontendIpConfig `
  -Name "myFrontEndPool" `
  -PublicIpAddress $publicIP
$backendPool = New-AzLoadBalancerBackendAddressPoolConfig -Name "myBackEndPool"
$inboundNATPool = New-AzLoadBalancerInboundNatPoolConfig `
  -Name "myRDPRule" `
  -FrontendIpConfigurationId $frontendIP.Id `
  -Protocol TCP `
  -FrontendPortRangeStart 50001 `
  -FrontendPortRangeEnd 50010 `
  -BackendPort 3389
# Create the load balancer and health probe
$lb = New-AzLoadBalancer `
  -ResourceGroupName $resourceGroupName `
  -Name "myLoadBalancer" `
  -Location $location `
  -FrontendIpConfiguration $frontendIP `
  -BackendAddressPool $backendPool `
  -InboundNatPool $inboundNATPool
Add-AzLoadBalancerProbeConfig -Name "myHealthProbe" `
  -LoadBalancer $lb `
  -Protocol TCP `
  -Port 80 `
  -IntervalInSeconds 15 `
  -ProbeCount 2
Add-AzLoadBalancerRuleConfig `
  -Name "myLoadBalancerRule" `
  -LoadBalancer $lb `
  -FrontendIpConfiguration $lb.FrontendIpConfigurations[0] `
  -BackendAddressPool $lb.BackendAddressPools[0] `
  -Protocol TCP `
  -FrontendPort 80 `
  -BackendPort 80 `
  -Probe (Get-AzLoadBalancerProbeConfig -Name "myHealthProbe" -LoadBalancer $lb)
Set-AzLoadBalancer -LoadBalancer $lb

# Create IP address configurations
$ipConfig = New-AzVmssIpConfig `
  -Name "myIPConfig" `
  -LoadBalancerBackendAddressPoolsId $lb.BackendAddressPools[0].Id `
  -LoadBalancerInboundNatPoolsId $inboundNATPool.Id `
  -SubnetId $vnet.Subnets[0].Id

# Create a configuration 
$vmssConfig = New-AzVmssConfig `
    -Location $location `
    -SkuCapacity 2 `
    -SkuName "Standard_DS2" `
    -UpgradePolicyMode "Automatic"

# Reference the image version
Set-AzVmssStorageProfile $vmssConfig `
  -OsDiskCreateOption "FromImage" `
  -ImageReferenceId $galleryImage.Id

# Complete the configuration
 
Add-AzVmssNetworkInterfaceConfiguration `
  -VirtualMachineScaleSet $vmssConfig `
  -Name "network-config" `
  -Primary $true `
  -IPConfiguration $ipConfig 

# Create the scale set 
New-AzVmss `
  -ResourceGroupName $resourceGroupName `
  -Name $scaleSetName `
  -VirtualMachineScaleSet $vmssConfig

Det tar några minuter att skapa och konfigurera alla skalningsuppsättningsresurser och virtuella datorer.

Dela galleriet

Vi rekommenderar att du delar åtkomst på bildgallerinivå. Använd en e-postadress och cmdleten Get-AzADUser för att hämta användarens objekt-ID och använd sedan New-AzRoleAssignment för att ge dem åtkomst till galleriet. Ersätt e-postexempel alinne_montes@contoso.com i det här exemplet med din egen information.

# Get the object ID for the user
$user = Get-AzADUser -StartsWith alinne_montes@contoso.com
# Grant access to the user for our gallery
New-AzRoleAssignment `
   -ObjectId $user.Id `
   -RoleDefinitionName Reader `
   -ResourceName $gallery.Name `
   -ResourceType Microsoft.Compute/galleries `
   -ResourceGroupName $resourceGroup.ResourceGroupName

Rensa resurser

När resursgruppen inte längre behövs kan du använda cmdleten Remove-AzResourceGroup för att ta bort resursgruppen och alla relaterade resurser:

# Delete the gallery 
Remove-AzResourceGroup -Name myGalleryRG

# Delete the scale set resource group
Remove-AzResourceGroup -Name myResoureceGroup

Azure Image Builder

Azure erbjuder också en tjänst som bygger på Packer, Azure VM Image Builder. Beskriv bara dina anpassningar i en mall så hanterar det skapandet av avbildningen.

Nästa steg

I den här självstudien fick du läsa om hur du skapar och använder en anpassad virtuell datoravbildning för dina skalningsuppsättningar med Azure PowerShell:

Gå vidare till nästa självstudie för att lära dig hur du distribuerar program till din skalningsuppsättning.