Snabbstart: Använda Python för att skapa en Batch-pool och köra ett jobb

Artikel
03/01/2024

Den här snabbstarten visar hur du kommer igång med Azure Batch genom att köra en app som använder Azure Batch-biblioteken för Python. Python-appen:

Laddar upp flera indatafiler till en Azure Storage-blobcontainer som ska användas för bearbetning av Batch-uppgifter.
Skapar en pool med två virtuella datorer eller beräkningsnoder som kör Ubuntu 20.04 LTS OS.
Skapar ett jobb och tre aktiviteter som ska köras på noderna. Varje uppgift bearbetar en av indatafilerna med hjälp av en Bash Shell-kommandorad.
Visar utdatafilerna som aktiviteterna returnerar.

När du har slutfört den här snabbstarten förstår du de viktigaste begreppen i Batch-tjänsten och är redo att använda Batch med mer realistiska arbetsbelastningar i större skala.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Om du inte har något skapar du ett konto kostnadsfritt.
Ett Batch-konto med ett länkat Azure Storage-konto. Du kan skapa kontona med någon av följande metoder: Azure CLI Azure Portal | | Bicep | ARM-mall | terraform.
Python version 3.8 eller senare, som innehåller pip-pakethanteraren .

Kör appen

För att slutföra den här snabbstarten laddar du ned eller klonar Python-appen, anger dina kontovärden, kör appen och verifierar utdata.

Ladda ned eller klona appen

Ladda ned eller klona Azure Batch Python-snabbstartsappen från GitHub. Använd följande kommando för att klona app-lagringsplatsen med en Git-klient:
```
git clone https://github.com/Azure-Samples/batch-python-quickstart.git
```
Växla till mappen batch-python-quickstart/src och installera de paket som krävs med hjälp pipav .
```
pip install -r requirements.txt
```

Ange kontoinformation

Python-appen måste använda dina Batch- och Storage-kontonamn, kontonyckelvärden och Batch-kontoslutpunkt. Du kan hämta den här informationen från Azure-portalen, Azure API:er eller kommandoradsverktyg.

Så här hämtar du kontoinformation från Azure-portalen:

I Azure Search-fältet söker du efter och väljer ditt Batch-kontonamn.
På sidan Batch-konto väljer du Nycklar i det vänstra navigeringsfältet.
På sidan Nycklar kopierar du följande värden:

Batch-konto
Kontoslutpunkt
Primär åtkomstnyckel
Namn på lagringskonto
Key1

I den nedladdade Python-appen redigerar du följande strängar i config.py-filen för att ange de värden som du kopierade.

BATCH_ACCOUNT_NAME = '<batch account>'
BATCH_ACCOUNT_KEY = '<primary access key>'
BATCH_ACCOUNT_URL = '<account endpoint>'
STORAGE_ACCOUNT_NAME = '<storage account name>'
STORAGE_ACCOUNT_KEY = '<key1>'

Viktigt!

Att exponera kontonycklar i appkällan rekommenderas inte för produktionsanvändning. Du bör begränsa åtkomsten till autentiseringsuppgifter och referera till dem i koden med hjälp av variabler eller en konfigurationsfil. Det är bäst att lagra Batch- och Storage-kontonycklar i Azure Key Vault.

Kör appen och visa utdata

Kör appen för att se batcharbetsflödet i praktiken.

python python_quickstart_client.py

Normal körningstid är cirka tre minuter. Den första konfigurationen av poolnoden tar mest tid.

Appen returnerar utdata som liknar följande exempel:

Sample start: 11/26/2012 4:02:54 PM

Uploading file taskdata0.txt to container [input]...
Uploading file taskdata1.txt to container [input]...
Uploading file taskdata2.txt to container [input]...
Creating pool [PythonQuickstartPool]...
Creating job [PythonQuickstartJob]...
Adding 3 tasks to job [PythonQuickstartJob]...
Monitoring all tasks for 'Completed' state, timeout in 00:30:00...

Det sker en paus när Monitoring all tasks for 'Completed' state, timeout in 00:30:00... poolens beräkningsnoder startar. När uppgifter skapas köar Batch dem för att köras i poolen. Så snart den första beräkningsnoden är tillgänglig körs den första aktiviteten på noden. Du kan övervaka nod-, aktivitets- och jobbstatus från batchkontosidan i Azure-portalen.

När varje uppgift har slutförts visas utdata som liknar följande exempel:

Printing task output...
Task: Task0
Node: tvm-2850684224_3-20171205t000401z
Standard output:
Batch processing began with mainframe computers and punch cards. Today it still plays a central role...

Granska koden

Granska koden för att förstå stegen i Azure Batch Python-snabbstarten.

Skapa tjänstklienter och ladda upp resursfiler

Appen skapar ett BlobServiceClient-objekt för att interagera med lagringskontot.

blob_service_client = BlobServiceClient(
        account_url=f"https://{config.STORAGE_ACCOUNT_NAME}.{config.STORAGE_ACCOUNT_DOMAIN}/",
        credential=config.STORAGE_ACCOUNT_KEY
    )

Appen använder referensen blob_service_client för att skapa en container i lagringskontot och ladda upp datafiler till containern. De lagrade filerna har definierats som Batch ResourceFile-objekt som Batch senare kan hämta till beräkningsnoder.

input_file_paths = [os.path.join(sys.path[0], 'taskdata0.txt'),
                    os.path.join(sys.path[0], 'taskdata1.txt'),
                    os.path.join(sys.path[0], 'taskdata2.txt')]

input_files = [
    upload_file_to_container(blob_service_client, input_container_name, file_path)
    for file_path in input_file_paths]

Appen skapar ett BatchServiceClient-objekt för att skapa och hantera pooler, jobb och uppgifter i Batch-kontot. Batch-klienten använder autentisering med delad nyckel. Batch stöder även Microsoft Entra-autentisering.
```
credentials = SharedKeyCredentials(config.BATCH_ACCOUNT_NAME,
        config.BATCH_ACCOUNT_KEY)

    batch_client = BatchServiceClient(
        credentials,
        batch_url=config.BATCH_ACCOUNT_URL)
```

Skapa en pool med beräkningsnoder

För att skapa en Batch-pool använder appen klassen PoolAddParameter för att ange antalet noder, VM-storlek och poolkonfiguration. Följande VirtualMachineConfiguration-objekt anger en ImageReference till en Ubuntu Server 20.04 LTS Azure Marketplace-avbildning. Batch stöder en mängd olika Linux- och Windows Server Marketplace-avbildningar och stöder även anpassade VM-avbildningar.

Och POOL_NODE_COUNT POOL_VM_SIZE definieras konstanter. Appen skapar en pool med två storlekar Standard_DS1_v2 noder. Den här storleken ger en bra balans mellan prestanda och kostnad för den här snabbstarten.

Metoden pool.add skickar poolen till Batch-tjänsten.

new_pool = batchmodels.PoolAddParameter(
        id=pool_id,
        virtual_machine_configuration=batchmodels.VirtualMachineConfiguration(
            image_reference=batchmodels.ImageReference(
                publisher="canonical",
                offer="0001-com-ubuntu-server-focal",
                sku="20_04-lts",
                version="latest"
            ),
            node_agent_sku_id="batch.node.ubuntu 20.04"),
        vm_size=config.POOL_VM_SIZE,
        target_dedicated_nodes=config.POOL_NODE_COUNT
    )
    batch_service_client.pool.add(new_pool)

Skapa ett Batch-jobb

Ett Batch-jobb är en logisk gruppering av en eller flera aktiviteter. Jobbet innehåller inställningar som är gemensamma för aktiviteterna, till exempel prioritet och poolen som aktiviteter ska köras på.

Appen använder klassen JobAddParameter för att skapa ett jobb i poolen. Metoden job.add lägger till jobbet i det angivna Batch-kontot. Från början har jobbet inga aktiviteter.

job = batchmodels.JobAddParameter(
    id=job_id,
    pool_info=batchmodels.PoolInformation(pool_id=pool_id))

batch_service_client.job.add(job)

Skapa uppgifter

Batch tillhandahåller flera sätt att distribuera appar och skript till beräkningsnoder. Den här appen skapar en lista över aktivitetsobjekt med hjälp av klassen TaskAddParameter . Varje uppgift bearbetar en indatafil med hjälp av en command_line parameter för att ange en app eller ett skript.

Följande skript bearbetar indataobjekten resource_files genom att köra Bash Shell-kommandot cat för att visa textfilerna. Appen använder sedan metoden task.add_collection för att lägga till varje uppgift i jobbet, som köar aktiviteterna som ska köras på beräkningsnoderna.

tasks = []

for idx, input_file in enumerate(resource_input_files):
    command = f"/bin/bash -c \"cat {input_file.file_path}\""
    tasks.append(batchmodels.TaskAddParameter(
        id=f'Task{idx}',
        command_line=command,
        resource_files=[input_file]
    )
    )

batch_service_client.task.add_collection(job_id, tasks)

Visa aktivitetens utdata

Appen övervakar aktivitetstillståndet för att säkerställa att aktiviteterna slutförs. När varje aktivitet körs skrivs aktivitetskommandot ut till filen stdout.txt . Appen visar sedan filen stdout.txt för varje slutförd uppgift.

tasks = batch_service_client.task.list(job_id)

for task in tasks:

    node_id = batch_service_client.task.get(job_id, task.id).node_info.node_id
    print(f"Task: {task.id}")
    print(f"Node: {node_id}")

    stream = batch_service_client.file.get_from_task(
        job_id, task.id, config.STANDARD_OUT_FILE_NAME)

    file_text = _read_stream_as_string(
        stream,
        text_encoding)

    if text_encoding is None:
        text_encoding = DEFAULT_ENCODING

    sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding = text_encoding)
    sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding = text_encoding)

    print("Standard output:")
    print(file_text)

Rensa resurser

Appen tar automatiskt bort den lagringscontainer den skapar och ger dig möjlighet att ta bort Batch-poolen och jobbet. Pooler och noder debiteras medan noderna körs, även om de inte kör jobb. Om du inte längre behöver poolen tar du bort den.

När du inte längre behöver dina Batch-resurser kan du ta bort den resursgrupp som innehåller dem. I Azure-portalen väljer du Ta bort resursgrupp överst på resursgruppssidan. På skärmen Ta bort en resursgrupp anger du resursgruppens namn och väljer sedan Ta bort.

Nästa steg

I den här snabbstarten körde du en app som använder Batch Python-API:et för att skapa en Batch-pool, noder, jobb och uppgifter. Jobbet laddade upp resursfiler till en lagringscontainer, körde uppgifter på noderna och visade utdata från noderna.

Nu när du förstår huvudbegreppen i Batch-tjänsten är du redo att använda Batch med mer realistiska arbetsbelastningar i större skala. Om du vill veta mer om Azure Batch och gå igenom en parallell arbetsbelastning med ett verkligt program kan du fortsätta till Självstudien om Batch Python.

Bearbeta en parallell arbetsbelastning med Python

Dela via