Använda Azure Compute för att skapa en anpassad avbildningspool

När du skapar en Azure Batch-pool med vm-konfigurationen anger du en VM-avbildning som tillhandahåller operativsystemet för varje beräkningsnod i poolen. Du kan skapa en pool med virtuella datorer med en Azure Marketplace avbildning eller skapa en anpassad avbildning med en Azure Compute galleriavbildning.

Fördelar med Azure Compute galleriet

När du använder Azure Compute-galleriet för din anpassade avbildning har du kontroll över typ av operativsystem och konfiguration samt typ av datadiskar. Din delade avbildning kan innehålla program och referensdata som blir tillgängliga på alla Batch-poolnoder så snart de har etablerats.

Du kan också ha flera versioner av en avbildning efter behov för din miljö. När du använder en avbildningsversion för att skapa en virtuell dator används avbildningsversionen för att skapa nya diskar för den virtuella datorn.

Med hjälp av en delad avbildning sparar du tid när du förbereder poolens beräkningsnoder för att köra Batch-arbetsbelastningen. Det går att använda en Azure Marketplace och installera programvara på varje beräkningsnod efter etableringen, men det är vanligtvis effektivare att använda en delad avbildning. Dessutom kan du ange flera repliker för den delade avbildningen, så när du skapar pooler med många virtuella datorer (fler än 600 virtuella datorer) sparar du tid när poolen skapas.

Att använda en delad avbildning som konfigurerats för ditt scenario kan ge flera fördelar:

• Använd samma avbildningar i regionerna. Du kan skapa delade bildrepliker i olika regioner så att alla pooler använder samma avbildning.
• Konfigurera operativsystemet (OS). Du kan anpassa konfigurationen av avbildningens operativsystemdisk.
• Förinstallera program. Att förinstallera program på OS-disken är mer effektivt och mindre felbenäget än att installera program efter etablering av beräkningsnoderna med en startaktivitet.
• Kopiera stora mängder data en gång. Gör statiska data till en del av den hanterade delade avbildningen genom att kopiera dem till en hanterad avbildnings datadiskar. Detta behöver bara göras en gång och göra data tillgängliga för varje nod i poolen.
• Utöka pooler till större storlekar. Med Azure Compute-galleriet kan du skapa större pooler med dina anpassade avbildningar tillsammans med fler delade bildrepliker.
• Bättre prestanda än att bara använda en hanterad avbildning som en anpassad avbildning. För en anpassad avbildningspool med delad avbildning är tiden för att nå det stabila tillståndet upp till 25 % snabbare och svarstiden för den virtuella datorns inaktivitet är upp till 30 % kortare.
• Versionshantering och gruppering av avbildningar för enklare hantering. Definitionen för avbildningsgrupp innehåller information om varför avbildningen skapades, vilket operativsystem den är till för och information om hur du använder avbildningen. Genom att gruppera avbildningar blir det enklare att hantera avbildningar. Mer information finns i Bilddefinitioner.

Förutsättningar

• Ett Azure Batch-konto. Information om hur du skapar ett Batch-konto finns i Batch-snabbstarter med hjälp Azure Portal eller Azure CLI.

• en Azure Compute galleriavbildning. Om du vill skapa en delad avbildning måste du ha eller skapa en hanterad avbildningsresurs. Avbildningen ska skapas från ögonblicksbilder av den virtuella datorns OS-disk och eventuella anslutna datadiskar.

Om du använder ett Azure AD-program för att skapa en anpassad avbildningspool med en Azure Compute-galleriavbildning måste programmet ha beviljats en inbyggd Azure-roll som ger den åtkomst till den delade avbildningen. Du kan bevilja den här åtkomsten i Azure Portal genom att gå till den delade avbildningen, välja Åtkomstkontroll (IAM) och lägga till en rolltilldelning för programmet.

Förbereda en delad avbildning

I Azure kan du förbereda en delad avbildning från en hanterad avbildning som kan skapas från:

• Ögonblicksbilder av en virtuell Azure-dators operativsystem och datadiskar
• En generaliserad virtuell Azure-dator med hanterade diskar
• En generaliserad lokal virtuell hårddisk som laddats upp till molnet

Följande steg visar hur du förbereder en virtuell dator, tar en ögonblicksbild och skapar en avbildning från ögonblicksbilden.

Förbereda en virtuell dator

Om du skapar en ny virtuell dator för avbildningen använder du en förstapartsavbildning Azure Marketplace som stöds av Batch som basavbildning för den hanterade avbildningen. Endast avbildningar från första part kan användas som en basavbildning. En fullständig lista över de Azure Marketplace avbildningsreferenser som stöds av Azure Batch finns i åtgärden Lista nodagent-SKU:er.

Följ dessa riktlinjer när du skapar virtuella datorer:

• Se till att den virtuella datorn har skapats med en hanterad disk. Det här är standardinställningen för lagring när du skapar en virtuell dator.
• Installera inte Azure-tillägg, till exempel tillägget för anpassat skript, på den virtuella datorn. Om avbildningen innehåller ett förinstallerat tillägg kan Azure stöta på problem när du distribuerar Batch-poolen.
• När du använder anslutna datadiskar måste du montera och formatera diskarna från en virtuell dator för att använda dem.
• Se till att basoperativsystemavbildningen som du anger använder den temporära standardenheten. Batch-nodagenten förväntar sig för närvarande den temporära standardenheten.
• Kontrollera att OS-disken inte är krypterad.
• När den virtuella datorn körs ansluter du till den via RDP (för Windows) eller SSH (för Linux). Installera nödvändig programvara eller kopiera önskade data.
• För snabbare pooletablering använder du inställningen ReadWrite disk cache för den virtuella datorns OS-disk.

Skapa en ögonblicksbild av en virtuell dator

En ögonblicksbild är en fullständig, skrivskyddad kopia av en virtuell hårddisk. Om du vill skapa en ögonblicksbild av en virtuell dators operativsystem eller datadiskar kan du använda Azure Portal eller kommandoradsverktyg. Anvisningar och alternativ för att skapa en ögonblicksbild finns i vägledningen för virtuella datorer.

Skapa en avbildning från en eller flera ögonblicksbilder

Om du vill skapa en hanterad avbildning från en ögonblicksbild använder du Kommandoradsverktyg i Azure, till exempel kommandot az image create. Skapa en avbildning genom att ange en os-diskögonblicksbild och eventuellt en eller flera ögonblicksbilder av datadisken.

Skapa ett Azure Compute galleri

När du har skapat den hanterade avbildningen måste du skapa ett Azure Compute-galleriet för att göra din anpassade avbildning tillgänglig. Information om hur du skapar ett Azure Compute-galleri för dina bilder finns i Skapa ett Azure Compute-galleri.

Skapa en pool från en delad avbildning med hjälp av Azure CLI

Om du vill skapa en pool från din delade avbildning med hjälp av Azure CLI använder du az batch pool create kommandot . Ange ID för delad avbildning i --image fältet. Kontrollera att OS-typen och SKU:n matchar de versioner som anges av --node-agent-sku-id

az batch pool create \
    --id mypool --vm-size Standard_A1_v2 \
    --target-dedicated-nodes 2 \
    --image "/subscriptions/{sub id}/resourceGroups/{resource group name}/providers/Microsoft.Compute/galleries/{gallery name}/images/{image definition name}/versions/{version id}" \
    --node-agent-sku-id "batch.node.ubuntu 16.04"

Skapa en pool från en delad avbildning med C

Du kan också skapa en pool från en delad avbildning med hjälp av C# SDK.

private static VirtualMachineConfiguration CreateVirtualMachineConfiguration(ImageReference imageReference)
{
    return new VirtualMachineConfiguration(
        imageReference: imageReference,
        nodeAgentSkuId: "batch.node.windows amd64");
}

private static ImageReference CreateImageReference()
{
    return new ImageReference(
        virtualMachineImageId: "/subscriptions/{sub id}/resourceGroups/{resource group name}/providers/Microsoft.Compute/galleries/{gallery name}/images/{image definition name}/versions/{version id}");
}

private static void CreateBatchPool(BatchClient batchClient, VirtualMachineConfiguration vmConfiguration)
{
    try
    {
        CloudPool pool = batchClient.PoolOperations.CreatePool(
            poolId: PoolId,
            targetDedicatedComputeNodes: PoolNodeCount,
            virtualMachineSize: PoolVMSize,
            virtualMachineConfiguration: vmConfiguration);

        pool.Commit();
    }
    ...
}

Skapa en pool från en delad avbildning med Python

Du kan också skapa en pool från en delad avbildning med hjälp av Python SDK:

# Import the required modules from the
# Azure Batch Client Library for Python
import azure.batch as batch
import azure.batch.models as batchmodels
from azure.common.credentials import ServicePrincipalCredentials

# Specify Batch account and service principal account credentials
account = "{batch-account-name}"
batch_url = "{batch-account-url}"
ad_client_id = "{sp-client-id}"
ad_tenant = "{tenant-id}"
ad_secret = "{sp-secret}"

# Pool settings
pool_id = "LinuxNodesSamplePoolPython"
vm_size = "STANDARD_D2_V3"
node_count = 1

# Initialize the Batch client with Azure AD authentication
creds = ServicePrincipalCredentials(
    client_id=ad_client_id,
    secret=ad_secret,
    tenant=ad_tenant,
    resource="https://batch.core.windows.net/"
)
client = batch.BatchServiceClient(creds, batch_url)

# Configure the start task for the pool
start_task = batchmodels.StartTask(
    command_line="printenv AZ_BATCH_NODE_STARTUP_DIR"
)
start_task.run_elevated = True

# Create an ImageReference which specifies the image from
# Azure Compute Gallery to install on the nodes.
ir = batchmodels.ImageReference(
    virtual_machine_image_id="/subscriptions/{sub id}/resourceGroups/{resource group name}/providers/Microsoft.Compute/galleries/{gallery name}/images/{image definition name}/versions/{version id}"
)

# Create the VirtualMachineConfiguration, specifying
# the VM image reference and the Batch node agent to
# be installed on the node.
vmc = batchmodels.VirtualMachineConfiguration(
    image_reference=ir,
    node_agent_sku_id="batch.node.ubuntu 18.04"
)

# Create the unbound pool
new_pool = batchmodels.PoolAddParameter(
    id=pool_id,
    vm_size=vm_size,
    target_dedicated_nodes=node_count,
    virtual_machine_configuration=vmc,
    start_task=start_task
)

# Create pool in the Batch service
client.pool.add(new_pool)

Skapa en pool från en delad avbildning med hjälp av Azure Portal

Använd följande steg för att skapa en pool från en delad avbildning i Azure Portal.

1. Öppna Azure-portalen.
2. Gå till Batch-konton och välj ditt konto.
3. Välj Pooler och sedan Lägg till för att skapa en ny pool.
4. I avsnittet Avbildningstyp väljer du Azure Compute Galleri.
5. Fyll i de återstående avsnitten med information om den hanterade avbildningen.
6. Välj OK.

Överväganden för stora pooler

Om du planerar att skapa en pool med hundratals eller tusentals virtuella datorer eller fler med hjälp av en delad avbildning använder du följande riktlinjer.

• Azure Compute gallerirepliknummer. För varje pool med upp till 300 instanser rekommenderar vi att du behåller minst en replik. Om du till exempel skapar en pool med 3 000 virtuella datorer bör du behålla minst 10 repliker av avbildningen. Vi rekommenderar alltid att du behåller fler repliker än minimikraven för bättre prestanda.

• Ändra storlek på timeout. Om poolen innehåller ett fast antal noder (om det inte skalas automatiskt) ökar du poolens egenskap resizeTimeout beroende på poolens storlek. För varje 1 000 virtuella datorer är den rekommenderade tidsgränsen för storleksändring minst 15 minuter. Till exempel är den rekommenderade tidsgränsen för storleksändring för en pool med 2 000 virtuella datorer minst 30 minuter.

Nästa steg

• En detaljerad översikt över Batch finns i Batch-tjänstens arbetsflöde och resurser.
• Läs mer om Azure Compute Gallery.