Megosztás a következőn keresztül:

Oktatóanyag: Párhuzamos számításifeladat-futtatás az Azure Batchben a .NET API használatával

  • Cikk

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égigvezeti egy, a Batch segítségével párhuzamos számításifeladat-futtatást bemutató C#-példán. 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.

  • Adjon hozzá egy alkalmazáscsomagot a Batch-fiókhoz.
  • Hitelesítés Batch- és Storage-fiókokkal.
  • Bemeneti fájlok feltöltése a Tárolóba.
  • Számítási csomópontok készletének létrehozása egy alkalmazás futtatásához.
  • Hozzon létre egy feladatot és feladatokat a bemeneti fájlok feldolgozásához.
  • Tevékenység végrehajtásának figyelése.
  • Kimeneti fájlok lekérése.

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 nem rendelkezik Azure-előfizetéssel, első lépésként hozzon létre egy ingyenes Azure-fiókot.

Előfeltételek

  • Visual Studio 2017 vagy újabb, illetve .NET Core SDK Linuxhoz, macOS-hez vagy Windowshoz.

  • Egy Batch-fiók és egy társított Azure Storage-fiók. A fiókok létrehozásához tekintse meg az Azure Portalhoz vagy az Azure CLI-hez készült Batch rövid útmutatóit.

  • Töltse le a használati esethez megfelelő ffmpeg-verziót a helyi számítógépre. Ez az oktatóanyag és a kapcsolódó mintaalkalmazás az ffmpeg 4.3.1 Windows 64 bites teljes buildű verzióját használja. Ebben az oktatóanyagban csak a zip-fájlra van szüksége. A fájlt nem kell sem kibontania, sem helyileg telepítenie.

Bejelentkezés az Azure-ba

Jelentkezzen be az Azure Portalra.

Alkalmazáscsomag hozzáadása

Adja hozzá az Azure Portal segítségével az ffmpeg-et a Batch-fiókjához alkalmazáscsomagként. Az alkalmazáscsomagok segítenek a tevékenységalkalmazások kezelésében, valamint a készlet számítási csomópontjain való üzembe helyezésükben.

  1. Az Azure Portalon kattintson a További szolgáltatások>Batch-fiókok elemre, és válassza ki a Batch-fiók nevét.

  2. Kattintson az Alkalmazások>Hozzáadás elemre.

    Képernyőkép a batch-fiók Alkalmazások szakaszáról.

  3. Írja be az ffmpeg értéket az Alkalmazásazonosító mezőbe, a Verzió mezőbe pedig a 4.3.1-es csomagverziót. Válassza ki a letöltött ffmpeg zip fájlt, majd válassza a Küldés lehetőséget. Ezzel hozzáadta az ffmpeg alkalmazáscsomagját a Batch-fiókjához.

    Képernyőkép az Alkalmazás hozzáadása szakaszban található azonosító- és verziómezőkről.

Fiók hitelesítő adatainak lekérése

Meg kell adnia például a Batch- és a Storage-fiók hitelesítő adatait. A szükséges hitelesítő adatokat például az Azure Portalon kérheti le egyszerűen. (A hitelesítő adatok az Azure API-k vagy parancssori eszközök használatával is lekérhetők.)

  1. Válassza az Összes szolgáltatás>Batch-fiókja lehetőséget, majd válassza ki a Batch-fiók nevét.

  2. A Batch hitelesítő adatainak megtekintéséhez válassza a Kulcsok lehetőséget. Másolja a Batch-fiók, az URL és az Elsődleges elérési kulcs mező értékét egy szövegszerkesztőbe.

  3. A Tárfiók nevének és kulcsainak megtekintéséhez válassza a Tárfiók lehetőséget. Másolja a Storage-fiók neve és az 1. kulcs mező értékét egy szövegszerkesztőbe.

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-dotnet-ffmpeg-tutorial.git

Lépjen a Visual Studio-megoldásfájlt BatchDotNetFfmpegTutorial.sln tartalmazó könyvtárra.

Győződjön meg arról is, hogy a megoldás ffmpeg alkalmazáscsomag-referenciája megegyezik a Batch-fiókba feltöltött ffmpeg-csomag azonosítójának és verziójának. Például: ffmpeg és 4.3.1.

const string appPackageId = "ffmpeg";
const string appPackageVersion = "4.3.1";

A mintaprojekt létrehozása és futtatása

Hozza létre és futtassa az alkalmazást a Visual Studióban vagy a parancssorban a dotnet build és a dotnet run paranccsal. Az alkalmazás futtatása után tekintse át a kódot annak megismerése érdekében, hogy mit csinálnak az alkalmazás egyes részei. Ha például a Visual Studióban:

  1. Kattintson a jobb gombbal a megoldásra a Megoldáskezelő, és válassza a Megoldás létrehozása lehetőséget.

  2. Erősítse meg a NuGet-csomagok visszaállítását, ha a rendszer erre kéri. Ha hiányzó csomagokat kell letöltenie, győződjön meg arról, hogy a NuGet-csomagkezelő telepítve van.

  3. Futtassa a megoldást. A mintaalkalmazás futtatásakor a konzol kimenete az alábbihoz hasonló lesz. A futtatás során szünet jelentkezhet a következőnél a készlet számítási csomópontjainak indításakor: Monitoring all tasks for 'Completed' state, timeout in 00:30:00....

Sample start: 11/19/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 [WinFFmpegPool]...
Creating job [WinFFmpegJob]...
Adding 5 tasks to job [WinFFmpegJob]...
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/19/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 meg szeretné jeleníteni a készlete számítási csomópontjainak hőtérképét, kattintson a Készletek>WinFFmpegPool elemre.

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

Képernyőkép a medence hőtérképéről az Azure Portalon.

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

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.

Kimeneti fájl letöltése

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 megoldásban Program.cs fájlt, mivel a minta nem minden kódsorát tárgyalja.

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

A társított tárfiókkal való interakcióhoz az alkalmazás az Azure.Storage.Blobs Library for .NET-et használja. A BlobServiceClient osztály használata, amely hivatkozik a fiók URI-jára, és hitelesíti a tokent, például a DefaultAzureCredentialt.

// TODO: Replace <storage-account-name> with your actual storage account name
Uri accountUri = new Uri("https://<storage-account-name>.blob.core.windows.net/");
BlobServiceClient blobClient = new BlobServiceClient(accountUri, new DefaultAzureCredential());

Az alkalmazás létrehoz egy hivatkozást a BatchAccountResource-ra a Resource Manager ArmClientén keresztül, hogy létrehozza a készletet a Batch szolgáltatásban. A mintában szereplő Arm-ügyfél DefaultAzureCredential hitelesítést használ.

ArmClient _armClient = new ArmClient(new DefaultAzureCredential());
var batchAccountIdentifier = ResourceIdentifier.Parse(BatchAccountResourceID);
BatchAccountResource batchAccount = await _armClient.GetBatchAccountResource(batchAccountIdentifier).GetAsync();

Az alkalmazás létrehoz egy BatchClient-objektumot a Batch szolgáltatásban való létrehozáshoz és feladatokhoz. A mintában szereplő Batch-ügyfél DefaultAzureCredential hitelesítést használ.

// TODO: Replace <batch-account-name> with your actual storage account name
Uri batchUri = new Uri("https://<batch-account-name>t.eastus.batch.azure.com");
BatchClient _batchClient = new BatchClient(batchUri, new DefaultAzureCredential());

Bemeneti fájlok feltöltése

Az alkalmazás továbbítja a CreateContainerIfNotExistc objektumot a blobServerClient metódusnak, hogy az létrehozzon egy Storage-tárolót a bemeneti MP4-fájlokhoz, valamint egy tárolót a tevékenység kimenetének.

CreateContainerIfNotExist(blobClient, inputContainerName);
CreateContainerIfNotExist(blobClient, outputContainerName);

Ezután a rendszer feltölti a fájlokat a bemeneti tárolóba a helyi InputFiles mappából. A tárolóban lévő fájlokat a rendszer a Batch által később a számítási csomópontra letölthető Batch ResourceFile-objektumként határozza meg.

Az Program.cs két metódusa vesz részt a fájlok feltöltésében:

  • UploadFilesToContainerAsync: Objektumgyűjteményt ResourceFile és belső hívásokat UploadResourceFileToContainerAsync ad vissza a paraméterben inputFilePaths átadott összes fájl feltöltéséhez.
  • UploadResourceFileToContainerAsync: Minden fájlt blobként tölt fel a bemeneti tárolóba. A fájl feltöltése után megkapja a blobhoz tartozó közös hozzáférésű jogosultságkódot (SAS), és visszaad egy ResourceFile objektumot, amely azt jelöli.
string inputPath = Path.Combine(Environment.CurrentDirectory, "InputFiles");

List<string> inputFilePaths = new List<string>(Directory.GetFileSystemEntries(inputPath, "*.mp4",
    SearchOption.TopDirectoryOnly));

List<ResourceFile> inputFiles = await UploadFilesToContainerAsync(
  blobClient,
  inputContainerName,
  inputFilePaths);

További részleteket a fájlok egy Storage-fiókba a .NET segítségével blobként történő feltöltéséről a blobok .NET segítségével való feltöltését, letöltését és listázását ismertető cikkben talál.

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

A következő lépésben a minta létrehozza a számítási csomópontok készletét a Batch-fiókban a CreatePoolIfNotExistAsync hívásával. Ez a definiált metódus a BatchAccountResource.GetBatchAccountPools() metódust használja. CreateOrUpdateAsync metódus a csomópontok számának, a virtuális gép méretének és a készletkonfigurációnak a beállításához. Itt egy BatchVmConfiguration objektum egy BatchImageReference-t ad meg az Azure Marketplace-en közzétett Windows Server-rendszerképhez. 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 kihasználatlan csomópontokat, és a készletekben vagy mindkettőt használhatja. A dedikált csomópontok a készlet számára vannak fenntartva. A kihasználatlan csomópontok alacsonyabb áron érhetők el az Azure-beli többlet virtuálisgép-kapacitásból. A kihasználatlan csomópontok elérhetetlenné válnak, ha az Azure nem rendelkezik elegendő kapacitással. A minta alapértelmezés szerint létrehoz egy készletet, amely csak 5 kihasználatlan csomópontot tartalmaz Standard_A1_v2 méretben.

Feljegyzés

Ellenőrizze a csomópontkvótákat. A Kvótakérelmek létrehozásáról a Batch szolgáltatás kvótái és korlátai című témakörben olvashat.

Az ffmpeg alkalmazás a számítási csomópontokon egy ApplicationPackageReference a készletkonfigurációhoz történő hozzáadásával lesz telepítve.

var credential = new DefaultAzureCredential();
ArmClient _armClient = new ArmClient(credential);

var batchAccountIdentifier = ResourceIdentifier.Parse(BatchAccountResourceID);
BatchAccountResource batchAccount = await _armClient.GetBatchAccountResource(batchAccountIdentifier).GetAsync();

BatchAccountPoolCollection collection = batchAccount.GetBatchAccountPools();
if (collection.Exists(poolId) == false)
{
    var poolName = poolId;
    var imageReference = new BatchImageReference()
    {
        Publisher = "MicrosoftWindowsServer",
        Offer = "WindowsServer",
        Sku = "2019-datacenter-smalldisk",
        Version = "latest"
    };
    string nodeAgentSku = "batch.node.windows amd64";


    ArmOperation<BatchAccountPoolResource> armOperation = await batchAccount.GetBatchAccountPools().CreateOrUpdateAsync(
        WaitUntil.Completed, poolName, new BatchAccountPoolData()
        {
            VmSize = "Standard_DS1_v2",
            DeploymentConfiguration = new BatchDeploymentConfiguration()
            {
                VmConfiguration = new BatchVmConfiguration(imageReference, nodeAgentSku)
            },
            ScaleSettings = new BatchAccountPoolScaleSettings()
            {
                FixedScale = new BatchAccountFixedScaleSettings()
                {
                    TargetDedicatedNodes = DedicatedNodeCount,
                    TargetLowPriorityNodes = LowPriorityNodeCount
                }
            },
            Identity = new ManagedServiceIdentity(ManagedServiceIdentityType.UserAssigned)
            {
                UserAssignedIdentities =
                {
                        [new ResourceIdentifier(ManagedIdentityId)] = new Azure.ResourceManager.Models.UserAssignedIdentity(),
                },
            },
            ApplicationPackages =
            {
                    new Azure.ResourceManager.Batch.Models.BatchApplicationPackageReference(new ResourceIdentifier(appPacakgeResourceID))
                    {
                        Version = appPackageVersion,
                    }
            },

        });
    BatchAccountPoolResource pool = armOperation.Value;

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 a CreateJobAsync hívásával létrehoz egy feladatot. Ez a definiált metódus a BatchClient.CreateJobAsync metódussal hoz létre feladatot a készleten.

 BatchJobCreateContent batchJobCreateContent = new BatchJobCreateContent(jobId, new BatchPoolInfo { PoolId = poolId });
 await batchClient.CreateJobAsync(batchJobCreateContent);

Feladatok létrehozása

A minta feladatokat hoz létre a metódus meghívásával AddTasksAsync , amely létrehozza a BatchTask-objektumok listáját. Minden BatchTask az ffmpeg futtatásával dolgoz fel egy bemeneti ResourceFile-objektumot egy CommandLine tulajdonság segítségével. 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. A rendszer az összes tevékenység kimeneti fájlját (ebben az esetben egyet) feltölti egy, a társított Storage-fiókban lévő tárolóba a tevékenység OutputFiles tulajdonsága segítségével. Figyelje meg az objektumon outputFile beállított feltételeket. A feladat kimeneti fájlja csak a feladat sikeres befejezése (OutputFileUploadCondition.TaskSuccess) után lesz feltöltve a tárolóba. További megvalósítási részletekért tekintse meg a GitHub teljes kódmintáját .

Ezután a minta a CreateTaskAsync metódussal hozzáadja a feladathoz a tevékenységeket, amelyek várólistára kerülnek a számítási csomópontokon való futtatáshoz.

Cserélje le a végrehajtható fájl elérési útját a letöltött verzió nevére. Ez a mintakód a példát ffmpeg-4.3.1-2020-11-08-full_buildhasználja.

// Create a collection to hold the tasks added to the job:
List<BatchTaskCreateContent> tasks = new List<BatchTaskCreateContent>();

for (int i = 0; i < inputFiles.Count; i++)
{
    // Assign a task ID for each iteration
    string taskId = String.Format("Task{0}", i);

    // Define task command line to convert the video format from MP4 to MP3 using ffmpeg.
    // Note that ffmpeg syntax specifies the format as the file extension of the input file
    // and the output file respectively. In this case inputs are MP4.
    string appPath = String.Format("%AZ_BATCH_APP_PACKAGE_{0}#{1}%", appPackageId, appPackageVersion);
    string inputMediaFile = inputFiles[i].StorageContainerUrl;
    string outputMediaFile = String.Format("{0}{1}",
        System.IO.Path.GetFileNameWithoutExtension(inputMediaFile),
        ".mp3");
    string taskCommandLine = String.Format("cmd /c {0}\\ffmpeg-4.3.1-2020-11-08-full_build\\bin\\ffmpeg.exe -i {1} {2}", appPath, inputMediaFile, outputMediaFile);

    // Create a batch task (with the task ID and command line) and add it to the task list

    BatchTaskCreateContent batchTaskCreateContent = new BatchTaskCreateContent(taskId, taskCommandLine);
    batchTaskCreateContent.ResourceFiles.Add(inputFiles[i]);

    // Task output file will be uploaded to the output container in Storage.
    // TODO: Replace <storage-account-name> with your actual storage account name
    OutputFileBlobContainerDestination outputContainer = new OutputFileBlobContainerDestination("https://<storage-account-name>.blob.core.windows.net/output/" + outputMediaFile)
    {
        IdentityReference = inputFiles[i].IdentityReference,
    };

    OutputFile outputFile = new OutputFile(outputMediaFile,
                                           new OutputFileDestination() { Container = outputContainer },
                                           new OutputFileUploadConfig(OutputFileUploadCondition.TaskSuccess));
    batchTaskCreateContent.OutputFiles.Add(outputFile);

    tasks.Add(batchTaskCreateContent);
}

// Call BatchClient.CreateTaskCollectionAsync() to add the tasks as a collection rather than making a
// separate call for each. Bulk task submission helps to ensure efficient underlying API
// calls to the Batch service. 

await batchClient.CreateTaskCollectionAsync(jobId, new BatchTaskGroup(tasks));

Az erőforrások eltávolí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. A BatchClient metódussal törölheti a DeleteJobAsync feladatot, és törölheti a készlet DeletePoolAsync készletét, amelyet a rendszer meghív, ha megerősíti a törlést. Bár magukért a feladatokért és tevékenységekért nem kell fizetnie, a számítási csomópontokért igen. Ezért ajánlott csak szükség szerint lefoglalni a készleteket. A készlet törlésekor a rendszer a csomópont összes tevékenységének kimenetét is törli. 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ókhoz tartozó erőforráscsoportot, és kattintson az Erőforráscsoport törlése elemre.

Következő lépések

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

  • Adjon hozzá egy alkalmazáscsomagot a Batch-fiókhoz.
  • Hitelesítés Batch- és Storage-fiókokkal.
  • Bemeneti fájlok feltöltése a Tárolóba.
  • Számítási csomópontok készletének létrehozása egy alkalmazás futtatásához.
  • Hozzon létre egy feladatot és feladatokat a bemeneti fájlok feldolgozásához.
  • Tevékenység végrehajtásának figyelése.
  • Kimeneti fájlok lekérése.

A .NET API-val a Batch számítási feladatainak ütemezésére és feldolgozására vonatkozó további példákért tekintse meg a Batch C# mintáit a GitHubon.