Zelfstudie: Een parallelle workload uitvoeren met Azure Batch met behulp van de Python-API

Met Azure Batch kunt u grootschalige parallelle en high-performance computing (HPC) batchtaken efficiënt uitvoeren in Azure. In deze zelfstudie wordt een Python-voorbeeld beschreven van het uitvoeren van een parallelle workload met behulp van Batch. U leert een gangbare Batch-toepassingswerkstroom en leert hoe u via programmacode werkt met Batch- en Storage-bronnen.

In deze zelfstudie converteert u MP4-mediabestanden naar mp3-indeling, parallel met behulp van het opensource-hulpprogramma ffmpeg .

Als u geen Azure-account hebt, maak dan een gratis account aan voordat u begint.

Vereiste voorwaarden

• Python-versie 3.8 of hoger

• pip package manager

• Een Azure Batch-account en een gekoppeld Azure Storage-account. Als u deze accounts wilt maken, raadpleegt u de Batch-quickstartgidsen voor Azure Portal of Azure CLI.

Aanmelden bij Azure

Meld u aan bij het Azure-portaal.

Accountgegevens ophalen

In dit voorbeeld moet u referenties opgeven voor uw Batch- en Storage-accounts. U kunt de benodigde referenties eenvoudig ophalen in de Azure portal. (U kunt deze referenties ook ophalen met de Azure-API's of de commando-regelhulpmiddelen.)

1. Selecteer Alle services>Batch-accounts en selecteer vervolgens de naam van uw Batch-account.

2. Selecteer Sleutels om de Batch-referenties te zien. Kopieer de waarden van Batch-account, URL en Primaire toegangssleutel in een teksteditor.

3. Selecteer Opslagaccount als u de naam en sleutels van het opslagaccount wilt zien. Kopieer de waarden van Naam van opslagaccount en Key1 in een teksteditor.

De voorbeeld-app downloaden en uitvoeren

De voorbeeld-app downloaden

Download of kloon de voorbeeld-app vanuit GitHub. Als u de opslagplaats van de voorbeeld-app wilt klonen met een Git-client, gebruikt u de volgende opdracht:

git clone https://github.com/Azure-Samples/batch-python-ffmpeg-tutorial.git

Navigeer naar de map met het bestand batch_python_tutorial_ffmpeg.py.

Installeer in uw Python-omgeving de vereiste pakketten met behulp van pip.

pip install -r requirements.txt

Gebruik een code-editor om het bestand te openen config.py. Werk de referentiereeksen van het Batch- en opslagaccount bij met de waarden die uniek zijn voor uw accounts. Voorbeeld:

_BATCH_ACCOUNT_NAME = 'yourbatchaccount'
_BATCH_ACCOUNT_KEY = 'xxxxxxxxxxxxxxxxE+yXrRvJAqT9BlXwwo1CwF+SwAYOxxxxxxxxxxxxxxxx43pXi/gdiATkvbpLRl3x14pcEQ=='
_BATCH_ACCOUNT_URL = 'https://yourbatchaccount.yourbatchregion.batch.azure.com'
_STORAGE_ACCOUNT_NAME = 'mystorageaccount'
_STORAGE_ACCOUNT_KEY = 'xxxxxxxxxxxxxxxxy4/xxxxxxxxxxxxxxxxfwpbIC5aAWA8wDu+AFXZB827Mt9lybZB1nUcQbQiUrkPtilK5BQ=='

De app uitvoeren

Het script uitvoeren:

python batch_python_tutorial_ffmpeg.py

Wanneer u de voorbeeldtoepassing uitvoert, ziet de uitvoer van de console er ongeveer als volgt uit. Tijdens de uitvoering merk je een onderbreking bij Monitoring all tasks for 'Completed' state, timeout in 00:30:00... terwijl de rekenknooppunten van de pool worden gestart.

Sample start: 11/28/2018 3:20:21 PM

Container [input] created.
Container [output] created.
Uploading file LowPriVMs-1.mp4 to container [input]...
Uploading file LowPriVMs-2.mp4 to container [input]...
Uploading file LowPriVMs-3.mp4 to container [input]...
Uploading file LowPriVMs-4.mp4 to container [input]...
Uploading file LowPriVMs-5.mp4 to container [input]...
Creating pool [LinuxFFmpegPool]...
Creating job [LinuxFFmpegJob]...
Adding 5 tasks to job [LinuxFFmpegJob]...
Monitoring all tasks for 'Completed' state, timeout in 00:30:00...
Success! All tasks completed successfully within the specified timeout period.
Deleting container [input]....

Sample end: 11/28/2018 3:29:36 PM
Elapsed time: 00:09:14.3418742

Ga naar uw Batch-account in de Azure Portal om de pool, rekenknooppunten, job en taken te controleren. Als u bijvoorbeeld een heatmap van de rekenknooppunten in uw pool wilt zien, selecteert u Pools>LinuxFFmpegPool.

Wanneer taken worden uitgevoerd, ziet de heatmap er bijvoorbeeld als volgt uit:

De gebruikelijke uitvoeringstijd is ongeveer 5 minuten wanneer u de toepassing uitvoert in de standaardconfiguratie. Het aanmaken van de pool kost de meeste tijd.

Uitvoerbestanden ophalen

U kunt in Azure Portal de MP3-uitvoerbestanden downloaden die in de ffmpeg-taken zijn gegenereerd.

1. Klik op Alle services>Opslagaccounts en klik vervolgens op de naam van uw opslagaccount.
2. Klik op Blobs>uitvoer.
3. Klik met de rechtermuisknop op een van de MP3-uitvoerbestanden en klik vervolgens op Downloaden. Volg de aanwijzingen in de browser om het bestand te openen of op te slaan.

Hoewel dit niet in dit voorbeeld wordt getoond, kunt u de bestanden ook programmatisch downloaden in de rekenknooppunten of in de opslagcontainer.

De code bekijken

In de volgende secties wordt de voorbeeldtoepassing uitgesplitst in de stappen die ermee worden uitgevoerd om een workload in de Batch-service te verwerken. Raadpleeg de Python-code terwijl u de rest van dit artikel leest, omdat niet elke regel code in het voorbeeld wordt besproken.

Blob- en Batch-clients authenticeren

Voor interactie met een opslagaccount gebruikt de app het azure-storage-blob-pakket om een BlockBlobService-object te maken.

blob_client = azureblob.BlockBlobService(
    account_name=_STORAGE_ACCOUNT_NAME,
    account_key=_STORAGE_ACCOUNT_KEY)

De app maakt een BatchServiceClient-object voor het maken en beheren van pools, taken en taken in de Batch-service. De Batch-client in het voorbeeld maakt gebruik van gedeelde sleutelverificatie. Batch ondersteunt ook verificatie via Microsoft Entra-id om afzonderlijke gebruikers of een toepassing zonder toezicht te verifiëren.

credentials = batchauth.SharedKeyCredentials(_BATCH_ACCOUNT_NAME,
                                             _BATCH_ACCOUNT_KEY)

batch_client = batch.BatchServiceClient(
    credentials,
    base_url=_BATCH_ACCOUNT_URL)

Invoerbestanden uploaden

De app gebruikt de blob_client verwijzing om een opslagcontainer te maken voor de MP4-invoerbestanden en een container voor de taakuitvoer. Vervolgens roept het de upload_file_to_container-functie aan om MP4-bestanden in de lokale InputFiles-map naar de container te uploaden. De bestanden in de opslag zijn gedefinieerd als Batch ResourceFile-objecten die later met Batch kunnen worden gedownload op rekenknooppunten.

blob_client.create_container(input_container_name, fail_on_exist=False)
blob_client.create_container(output_container_name, fail_on_exist=False)
input_file_paths = []

for folder, subs, files in os.walk(os.path.join(sys.path[0], './InputFiles/')):
    for filename in files:
        if filename.endswith(".mp4"):
            input_file_paths.append(os.path.abspath(
                os.path.join(folder, filename)))

# Upload the input files. This is the collection of files that are to be processed by the tasks.
input_files = [
    upload_file_to_container(blob_client, input_container_name, file_path)
    for file_path in input_file_paths]

Een pool met rekenknooppunten maken

Daarna wordt in het voorbeeld met behulp van een aanroep naar create_pool een pool van rekenknooppunten in het Batch-account gemaakt. Deze gedefinieerde functie maakt gebruik van de klasse Batch PoolAddParameter om het aantal knooppunten, de VM-grootte en een poolconfiguratie in te stellen. Hier geeft een VirtualMachineConfiguration-object een ImageReference op naar een Ubuntu Server 20.04 LTS-installatiekopie die is gepubliceerd in Azure Marketplace. Batch ondersteunt diverse VM-installatiekopieën in de Azure Marketplace, evenals aangepaste VM-installatiekopieën.

Het aantal knooppunten en de VM-grootte worden ingesteld met behulp van gedefinieerde constanten. Batch ondersteunt toegewezen knooppunten en Spot-knooppunten. U kunt beide of beide in uw pools gebruiken. Toegewezen knooppunten zijn gereserveerd voor uw pool. Spot-knooppunten worden aangeboden tegen een gereduceerde prijs uit overtollige VM-capaciteit in Azure. Spot-knooppunten zijn niet beschikbaar als Azure niet voldoende capaciteit heeft. In het voorbeeld wordt standaard een pool gemaakt met slechts vijf spot-knooppunten in grootte Standard_A1_v2.

Naast de eigenschappen van fysieke knooppunten bevat deze poolconfiguratie een StartTask-object . De StartTask wordt uitgevoerd op elk knooppunt terwijl dat knooppunt lid wordt van de pool en telkens wanneer een knooppunt opnieuw wordt opgestart. In dit voorbeeld voert de StartTask Bash-shellopdrachten uit om het ffmpeg-pakket en afhankelijkheden op de knooppunten te installeren.

De methode pool.add verzendt de pool naar de Batch-service.

new_pool = batch.models.PoolAddParameter(
    id=pool_id,
    virtual_machine_configuration=batchmodels.VirtualMachineConfiguration(
        image_reference=batchmodels.ImageReference(
            publisher="Canonical",
            offer="UbuntuServer",
            sku="20.04-LTS",
            version="latest"
        ),
        node_agent_sku_id="batch.node.ubuntu 20.04"),
    vm_size=_POOL_VM_SIZE,
    target_dedicated_nodes=_DEDICATED_POOL_NODE_COUNT,
    target_low_priority_nodes=_LOW_PRIORITY_POOL_NODE_COUNT,
    start_task=batchmodels.StartTask(
        command_line="/bin/bash -c \"apt-get update && apt-get install -y ffmpeg\"",
        wait_for_success=True,
        user_identity=batchmodels.UserIdentity(
            auto_user=batchmodels.AutoUserSpecification(
                scope=batchmodels.AutoUserScope.pool,
                elevation_level=batchmodels.ElevationLevel.admin)),
    )
)
batch_service_client.pool.add(new_pool)

Een taak maken

Een batchtaak specificeert een pool om taken op uit te voeren en bevat optionele instellingen, zoals prioriteit en schema voor het werk. In het voorbeeld wordt een job gemaakt met een aanroep naar create_job. Deze gedefinieerde functie maakt gebruik van de klasse JobAddParameter om een taak in uw pool te maken. De methode job.add verzendt de pool naar de Batch-service. In eerste instantie heeft de taak geen taken.

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

batch_service_client.job.add(job)

Taken aanmaken

De app creëert taken in het werk met een aanroep naar add_tasks. Met deze gedefinieerde functie maakt u een lijst met taakobjecten met behulp van de klasse TaskAddParameter . Elke taak voert ffmpeg uit om een invoerobject resource_files te verwerken met behulp van een command_line parameter. ffmpeg is eerder op elk knooppunt geïnstalleerd toen de pool werd gemaakt. Hier voert de opdrachtregel ffmpeg uit om elk MP4-invoerbestand (video) te converteren naar een MP3-bestand (audio).

Het voorbeeld maakt een OutputFile-object voor het MP3-bestand nadat de opdrachtregel is uitgevoerd. De uitvoerbestanden van elke taak (één in dit geval) worden geüpload naar een container in het gekoppelde opslagaccount met behulp van de eigenschap van output_files de taak.

Vervolgens voegt de app taken toe aan de taak met de task.add_collection methode, waarmee ze in de wachtrij worden geplaatst voor uitvoering op de rekenknooppunten.

tasks = list()

for idx, input_file in enumerate(input_files):
    input_file_path = input_file.file_path
    output_file_path = "".join((input_file_path).split('.')[:-1]) + '.mp3'
    command = "/bin/bash -c \"ffmpeg -i {} {} \"".format(
        input_file_path, output_file_path)
    tasks.append(batch.models.TaskAddParameter(
        id='Task{}'.format(idx),
        command_line=command,
        resource_files=[input_file],
        output_files=[batchmodels.OutputFile(
            file_pattern=output_file_path,
            destination=batchmodels.OutputFileDestination(
                container=batchmodels.OutputFileBlobContainerDestination(
                    container_url=output_container_sas_url)),
            upload_options=batchmodels.OutputFileUploadOptions(
                upload_condition=batchmodels.OutputFileUploadCondition.task_success))]
    )
    )
batch_service_client.task.add_collection(job_id, tasks)

Taken bewaken

Wanneer taken worden toegevoegd aan een taak, worden deze in Batch automatisch in de wachtrij geplaatst en gepland voor uitvoering op rekenknooppunten in de gekoppelde pool. Op basis van de instellingen die u opgeeft, verwerkt Batch alle taakwachtrijen, de planning van taken, het opnieuw proberen en andere taken op het gebied van taakbeheer.

Er zijn veel benaderingen voor het bewaken van taakuitvoering. De wait_for_tasks_to_complete functie in dit voorbeeld gebruikt het TaskState-object om taken voor een bepaalde status te bewaken, in dit geval de voltooide status, binnen een tijdslimiet.

while datetime.datetime.now() < timeout_expiration:
    print('.', end='')
    sys.stdout.flush()
    tasks = batch_service_client.task.list(job_id)

    incomplete_tasks = [task for task in tasks if
                        task.state != batchmodels.TaskState.completed]
    if not incomplete_tasks:
        print()
        return True
    else:
        time.sleep(1)
...

De hulpbronnen opschonen

Nadat de taken zijn uitgevoerd, verwijdert de app automatisch de gemaakte invoeropslagcontainer en biedt u de mogelijkheid de Batch-pool en -taak te verwijderen. De klassen JobOperations en PoolOperations van BatchClient hebben beide verwijdermethoden, die worden aangeroepen als u de verwijdering bevestigt. Hoewel jobs en taken zelf niet in rekening worden gebracht, moet je wel betalen voor rekenknooppunten. Daarom is het raadzaam om pools alleen toe te wijzen als dat nodig is. Wanneer u de pool verwijdert, wordt ook alle taakuitvoer op de knooppunten verwijderd. De invoer- en uitvoerbestanden blijven echter aanwezig in het opslagaccount.

Verwijder de resourcegroep, het Batch-account en het opslagaccount wanneer u deze niet meer nodig hebt. Als u dit wilt doen in Azure Portal, selecteert u de resourcegroep voor het Batch-account en kiest u Resourcegroep verwijderen.

Volgende stappen

In deze zelfstudie hebt u het volgende geleerd:

Zie de Batch Python-voorbeelden op GitHub voor meer voorbeelden van het gebruik van de Python-API om Batch-workloads te plannen en te verwerken.