Oktatóanyag: Párhuzamos számítási feladat futtatása az Azure Batchtel a Python API használatával

Az Azure Batch használatával hatékonyan futtathat nagy méretű párhuzamos és nagy teljesítményű feldolgozási (high-performance computing, HPC) Batch-feladatokat az Azure-ban. Ez az oktatóanyag végigvezet egy Python-példán, amely egy párhuzamos számítási feladatot futtat a Batch használatával. Megismerheti a Batch-alkalmazások általános munkafolyamatát, valamint azt, hogyan kommunikálhat programkódon keresztül a Batch- és Storage-erőforrásokkal.

Ebben az oktatóanyagban mp4-médiafájlokat konvertál mp3 formátumba, párhuzamosan az ffmpeg nyílt forráskódú eszközzel.

Ha még nem rendelkezik Azure-fiókkal, első lépésként hozzon létre egy ingyenes fiókot.

Előfeltételek

• Python 3.8-es vagy újabb verzió

• pip csomagkezelő

• Egy Azure Batch-fiók és egy társított Azure Storage-fiók. A fiókok létrehozásához lásd az Azure portal vagy az Azure CLI Batch rövid útmutatóit.

Hozzáférés biztosítása a Batch és Storage fiókokhoz

Ez az oktatóanyag bemutatja, hogyan autentikálhatunk Azure Batch-re és Azure Storage-re a Microsoft Entra ID használatával a DefaultAzureCredential segítségével. Az alkalmazás nem használ fiókkulcsokat. Az alkalmazás futtatása előtt győződj meg róla, hogy a használt azonosító mindkét fióknál megvan a szükséges szerep.

1. Jelentkezz be az Azure CLI-val. DefaultAzureCredential automatikusan felveszi ezt a bejelentkezést:

   az login
   

2. Rendelj hozzá a felhasználói fiókodhoz egy olyan szerepet, amely lehetővé teszi adatsík műveleteket a Batch fiókon, például az Azure Batch Data Contributor-t. Ez a szerep szükséges a poolok, munkahelyek és feladatok létrehozásához. A szerepet a Batch fiók hozzáférési vezérlési (IAM) oldalán rendelheted meg az Azure portálon, vagy használhatod az Azure CLI-t:

   az role assignment create \
       --assignee "<your-user-principal-name>" \
       --role "Azure Batch Data Contributor" \
       --scope "/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Batch/batchAccounts/<batch-account-name>"
   

3. Rendeld hozzá a felhasználói fiókodhoz a Storage Blob Data Contributor szerepkört a tárfiókhoz. Ez a szerep szükséges a konténerek létrehozásához, a bemeneti fájlok feltöltéséhez, valamint a felhasználói delegációs kulcs kéréséhez, amely aláírja a közös hozzáférési aláírás (SAS) URL-eket, amelyeket a feladatok használnak:

   az role assignment create \
       --assignee "<your-user-principal-name>" \
       --role "Storage Blob Data Contributor" \
       --scope "/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account-name>"
   

4. Figyeld meg a következő értékeket, amelyeket a minta config.py fájljához adsz hozzá a következő szakaszban. Ezeket megtalálhatod az egyes fiókok Áttekintés oldalán az Azure portálon:

   • Csomagszámla név
   • A Batch-fiók URL-címe, például https://mybatchaccount.westus2.batch.azure.com
   • Tárolási fiók neve

A mintaalkalmazás letöltése és futtatása

A mintaalkalmazás letöltése

Töltse le vagy klónozza a mintaalkalmazást a GitHubról. A mintaalkalmazás adattárának Git-ügyféllel történő klónozásához használja az alábbi parancsot:

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

Keresse meg a batch_python_tutorial_ffmpeg.py fájlt tartalmazó könyvtárat.

A Python-környezetben a pip használatával telepítse a szükséges csomagokat.

pip install -r requirements.txt

Kódszerkesztővel nyissa meg a fájl config.py. Frissítse a Batch- és a tárfiók értékeit a fiókjaihoz egyedi nevekre. A minta a DefaultAzureCredential függvényt használja a hitelesítéshez, így a fiókkulcsok már nem szükségesek. Például:

_BATCH_ACCOUNT_NAME = 'yourbatchaccount'
_BATCH_ACCOUNT_URL = 'https://yourbatchaccount.yourbatchregion.batch.azure.com'
_STORAGE_ACCOUNT_NAME = 'mystorageaccount'

Győződj meg arról, hogy be vagy jelentkezve a az login használatával, és hogy az identitásod rendelkezik a Hozzáférés biztosítása a Batch- és Storage-fiókjaidhoz című részben ismertetett szerepkörökkel. DefaultAzureCredentialmás hitelesítési forrásokat is felfedezhet, például menedzselt identitást, Visual Studio Code-ot vagy környezeti változókat.

Az alkalmazás futtatása

A szkript futtatásához:

python batch_python_tutorial_ffmpeg.py

A mintaalkalmazás futtatásakor a konzol kimenete az alábbihoz hasonló lesz. A futtatás során szünetet tapasztalhat Monitoring all tasks for 'Completed' state, timeout in 00:30:00...-nál, miközben a készlet számítási csomópontjai elindulnak.

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 reached the 'Completed' state within the specified timeout period.
Deleting container [input]....

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

A készlet, a számítási csomópontok, a feladat és a tevékenységek monitorozásához lépjen az Azure Portalon a Batch-fiókjába. Ha például látni szeretné a készlet számítási csomópontjainak hőtérképét, válassza a Készletek>LinuxFFmpegPool lehetőséget.

A tevékenységek futásakor a hőtérkép az alábbihoz hasonló:

A végrehajtási idő általában körülbelül 5 perc , amikor az alkalmazást az alapértelmezett konfigurációban futtatja. A legtöbb időt a tár létrehozása veszi igénybe.

Kimeneti fájlok lekérése

Az Azure Portallal letöltheti az ffmpeg tevékenységek által létrehozott kimenti MP3-fájlokat.

1. Kattintson a Minden szolgáltatás>Storage-fiókok lehetőségre, majd kattintson a Storage-fiók nevére.
2. Kattintson a Blobok>Kimenet elemre.
3. Kattintson a jobb gombbal az egyik kimeneti MP3-fájlra, majd kattintson a Letöltés gombra. Kövesse a böngészőben megjelenő utasításokat a fájl megnyitásához vagy mentéséhez.

Bár ebben a mintában nem látható, programozott módon is letöltheti a fájlokat a számítási csomópontokról vagy a Storage-tárolóból.

A kód áttekintése

A következő szakaszok a mintaalkalmazást felosztják azokra a lépésekre, amelyeket az alkalmazás végrehajt a számítási feladatok a Batch szolgáltatásban történő feldolgozásához. A cikk további részeinek elolvasása közben tekintse meg a Python-kódot, mivel a minta nem minden kódsorát tárgyalja.

Blob- és Batch-ügyfelek hitelesítése

A minta a azure-identity csomagból származó DefaultAzureCredential használatával a Storage és a Batch szolgáltatásnál is hitelesít. DefaultAzureCredential több hitelesítő adattípust próbál meg sorrendben (környezeti változók, felügyelt identitás, Azure CLI bejelentkezés stb.), így ugyanaz a kód működik a helyi fejlesztésben és éles környezetben a fiókkulcsok tárolása nélkül.

A tárfiókok használatához az alkalmazás az azure-storage-blobcsomag használatával hoz létre egy BlobServiceClient objektumot, amely a hitelesítő adatokat használja.

A minta importálja az alábbi azonosító és tárolótípusokat, és felolvassa a config.py számlaneveit:

import config
from azure.identity import DefaultAzureCredential
from azure.storage.blob import (
    BlobServiceClient,
    BlobSasPermissions,
    ContainerSasPermissions,
    generate_blob_sas,
    generate_container_sas,
)

credential = DefaultAzureCredential()

blob_service_client = BlobServiceClient(
    account_url=f"https://{config._STORAGE_ACCOUNT_NAME}.blob.core.windows.net/",
    credential=credential)

Az alkalmazás létrehoz egy BatchClient-objektumot , amely készleteket, feladatokat és feladatokat hoz létre és kezel a Batch szolgáltatásban. A Batch-ügyfélprogram ugyanazt a DefaultAzureCredential használja a Microsoft Entra ID-n keresztüli hitelesítésre Microsoft Entra ID.

batch_client = BatchClient(
    endpoint=config._BATCH_ACCOUNT_URL,
    credential=credential)

A batch számítási csomópontok a bemeneti és kimeneti konténerekhez a megosztott hozzáférési aláírás (SAS) URL-ek használatával érik el a hozzáférést. Mivel az alkalmazás nem használja a tárolófiók kulcsot, nem tudja aláírni a SAS tokeneket vele. Ehelyett az alkalmazás egy felhasználói delegációs kulcsot kér a Blob szolgáltatástól, amelyet az alkalmazás Microsoft Entra hitelesítő adataival írnak alá, és ezt a kulcsot használja a SAS tokenek generálásához. További információ: Felhasználói delegálási SAS létrehozása.

start = datetime.datetime.now(datetime.timezone.utc)
expiry = start + datetime.timedelta(hours=4)
user_delegation_key = blob_service_client.get_user_delegation_key(
    key_start_time=start, key_expiry_time=expiry)

# Sign the SAS tokens with the same expiry as the user delegation key.
sas_expiry = expiry

Bemeneti fájlok feltöltése

Miután létrehozta a bemeneti és kimeneti konténereket , blob_service_clientaz alkalmazás feltölti az InputFiles mappában lévő helyi MP4 fájlokat a bemeneti konténerbe. A következő upload_file_to_container segítő egyetlen fájlt tölt fel, létrehoz egy csak olvasható SAS tokent, amelyet a felhasználói delegációs kulmilla írnak alá, és visszaad egy Batch ResourceFile objektumot, amelynek URL-je tartalmazza a SAS tokent, így a Batch később letöltheti a fájlt egy számítási csomópontra. Az alkalmazás egyszer hívja ezt a segítőt minden bemeneti fájlhoz:

def upload_file_to_container(blob_service_client, user_delegation_key,
                             sas_expiry, container_name, file_path):
    blob_name = os.path.basename(file_path)
    blob_client = blob_service_client.get_blob_client(container_name, blob_name)

    with open(file_path, "rb") as data:
        blob_client.upload_blob(data, overwrite=True)

    sas_token = generate_blob_sas(
        account_name=config._STORAGE_ACCOUNT_NAME,
        container_name=container_name,
        blob_name=blob_name,
        user_delegation_key=user_delegation_key,
        permission=BlobSasPermissions(read=True),
        expiry=sas_expiry)

    sas_url = f"{blob_client.url}?{sas_token}"

    return models.ResourceFile(http_url=sas_url, file_path=blob_name)

Az alkalmazás SAS URL-t is generál a kimeneti konténerhez, amely írási jogot biztosít. A feladatok ezt az URL-t használják a kimeneti fájlok feltöltésére a tárolóba:

sas_token = generate_container_sas(
    account_name=config._STORAGE_ACCOUNT_NAME,
    container_name=output_container_name,
    user_delegation_key=user_delegation_key,
    permission=ContainerSasPermissions(write=True, create=True, list=True),
    expiry=sas_expiry)

output_container_sas_url = (
    f"https://{config._STORAGE_ACCOUNT_NAME}.blob.core.windows.net/"
    f"{output_container_name}?{sas_token}")

Számításicsomópont-készlet létrehozása

Ezután a minta létrehoz egy számítási csomópontokból álló készletet a Batch-fiókban a(z) create_pool meghívásával. Ez a definiált függvény a Batch BatchPoolCreateOptions osztály használatával állítja be a csomópontok számát, a virtuális gép méretét és a készletkonfigurációt. Ebben a konfigurációban egy VirtualMachineConfiguration objektum megad egy BatchVmImageReference egy Ubuntu Server 22.04 LTS képre, amely az Azure Marketplace-en publikált. A Batch az Azure Marketplace virtuálisgép-rendszerképeinek széles választékát támogatja, de egyéni rendszerképeket is használhat.

A csomópontok száma és a virtuális gépek mérete meghatározott állandókkal van megadva. A Batch támogatja a dedikált csomópontokat és a Spot csomópontokat, és vagy mindkettőt használhatja a készletekben. A dedikált csomópontok ki vannak jelölve a készlet számára. A spot csomópontok alacsonyabb áron érhetők el a többlet virtuálisgép-kapacitásból az Azure-ban. A kihasználatlan csomópontok elérhetetlenné válnak, ha az Azure nem rendelkezik elegendő kapacitással. A minta alapértelmezés szerint egy készletet hoz létre, amely csak öt darab, Standard_A1_v2 méretű Spot csomópontot tartalmaz.

A fizikai csomópont tulajdonságai mellett ez a készletkonfiguráció egy BatchStartTask objektumot is tartalmaz. A BatchStartTask minden csomóponton fut, amikor a csomópont csatlakozik a készlethez, és minden alkalommal, amikor egy csomópont újraindul. Ebben a példában a BatchStartTask Bash-rendszerhéj-parancsokat futtat az ffmpeg-csomag és a csomópontok függőségeinek telepítéséhez.

A create_pool metódus elküldi a készletet a Batch szolgáltatásnak.

new_pool = models.BatchPoolCreateOptions(
    id=pool_id,
    virtual_machine_configuration=models.VirtualMachineConfiguration(
        image_reference=models.BatchVmImageReference(
            publisher="canonical",
            offer="0001-com-ubuntu-server-jammy",
            sku="22_04-lts",
            version="latest"
        ),
        node_agent_sku_id="batch.node.ubuntu 22.04"),
    vm_size=_POOL_VM_SIZE,
    target_dedicated_nodes=_DEDICATED_POOL_NODE_COUNT,
    target_low_priority_nodes=_LOW_PRIORITY_POOL_NODE_COUNT,
    start_task=models.BatchStartTask(
        command_line="/bin/bash -c \"apt-get update && apt-get install -y ffmpeg\"",
        wait_for_success=True,
        user_identity=models.UserIdentity(
            auto_user=models.AutoUserSpecification(
                scope=models.AutoUserScope.POOL,
                elevation_level=models.ElevationLevel.ADMIN)),
    )
)
batch_client.create_pool(pool=new_pool)

Feladat létrehozása

Egy Batch-feladat meghatároz egy készletet, amelyen futtathatók tevékenységek, valamint opcionális beállításokat, például a prioritást és az ütemezést a munkához. A minta létrehoz egy feladatot azzal, hogy meghívja create_job-t. Ez a definiált függvény a BatchJobCreateOptions osztály használatával hoz létre feladatot a készleten. A create_job módszer a munkát a Batch szolgáltatásnak adja be. A feladat kezdetben nem rendelkezik feladatokkal.

job = models.BatchJobCreateOptions(
    id=job_id,
    pool_info=models.BatchPoolInfo(pool_id=pool_id))

batch_client.create_job(job=job)

Feladatok létrehozása

Az alkalmazás feladatokat hoz létre a munkában egy hívással add_tasks. Ez a definiált függvény létrehozza a tevékenységobjektumok listáját a BatchTaskCreateOptions osztály használatával. Minden tevékenység ffmpeg futtatásával feldolgoz egy bemeneti resource_files objektumot egy command_line paraméter használatával. Az ffmpeg már korábban, a készlet létrehozásakor telepítve lett minden egyes csomóponton. Itt a parancssor az ffmpeg futtatásával konvertálja az egyes bemeneti MP4-videofájlokat MP3-hangfájllá.

A minta a parancssor futtatása után létrehoz egy OutputFile objektumot az MP3-fájlhoz. Az egyes tevékenységek kimeneti fájljai (ebben az esetben az egyik) a csatolt tárfiók egyik tárolójába kerülnek a tevékenység tulajdonságának output_files használatával.

Ezután az alkalmazás hozzáadja a feladathoz a create_tasks metódust, amely várólistára állítja őket a számítási csomópontokon való futtatáshoz.

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(models.BatchTaskCreateOptions(
        id='Task{}'.format(idx),
        command_line=command,
        resource_files=[input_file],
        output_files=[models.OutputFile(
            file_pattern=output_file_path,
            destination=models.OutputFileDestination(
                container=models.OutputFileBlobContainerDestination(
                    container_url=output_container_sas_url)),
            upload_options=models.OutputFileUploadConfiguration(
                upload_condition=models.OutputFileUploadCondition.TASK_SUCCESS))]
    )
    )
batch_client.create_tasks(job_id=job_id, task_collection=tasks)

Tevékenységek figyelése

Amikor tevékenységeket ad hozzá egy feladathoz, a Batch automatikusan várólistára állítja és ütemezi őket a kapcsolódó készlet számítási csomópontjain való végrehajtásra. A megadott beállítások alapján a Batch kezeli az összes feladatsorolást, ütemezést, újrapróbálkozást és egyéb feladatfelügyeleti feladatot.

A feladatvégrehajtás monitorozásának számos módszere van. A wait_for_tasks_to_complete jelen példában szereplő függvény a BatchTaskState objektummal figyeli egy adott állapot tevékenységeit, ebben az esetben a befejezett állapotot egy időkorláton belül.

while datetime.datetime.now() < timeout_expiration:
    print('.', end='')
    sys.stdout.flush()
    tasks = batch_client.list_tasks(job_id=job_id)

    incomplete_tasks = [task for task in tasks if
                        task.state != models.BatchTaskState.COMPLETED]
    if not incomplete_tasks:
        print()
        return True
    else:
        time.sleep(5)
...

Erőforrások tisztítása

A tevékenységek futtatása után az alkalmazás automatikusan törli a létrehozott bemeneti Storage-tárolót, és felkínálja a Batch-készlet és -feladat törlésének lehetőségét. Az osztály begin_delete_job és begin_delete_pool módszerei BatchClient mindkettő elindítja a megfelelő törlési műveletet, amikor megerősíted a promptot. Bár magukért a munkákért és feladatokért nem számítanak fel díjat, a számítási csomópontokért igen. Ezért csak szükség esetén oszd el a medencéket. Amikor a készletet törli, a csomópontokon lévő összes feladat kimenete is törlődik. A kimeneti fájlok azonban megmaradnak a Storage-fiókban.

Ha már nincs rájuk szükség, törölje az erőforráscsoportot, a Batch-fiókot és a Storage-fiókot. Ehhez az Azure Portalon válassza ki a Batch-fiók erőforráscsoportját, és válassza az Erőforráscsoport törlése lehetőséget.

Következő lépések

Ez az oktatóanyag bemutatta, hogyan végezheti el az alábbi műveleteket:

A Batch-számítási feladatok ütemezésére és feldolgozására a Python API használatával kapcsolatos további példákért tekintse meg a Batch Python-mintákat a GitHubon.