Udostępnij za pośrednictwem

Użyj Azure Pipelines, aby zbudować i wdrożyć rozwiązanie HPC

Azure DevOps tools can automate building and testing Azure Batch high performance computing (HPC) solutions. Azure Pipelines oferuje nowoczesne procesy ciągłej integracji (CI) i ciągłego wdrażania (CD) do budowania, wdrażania, testowania i monitorowania oprogramowania. Procesy te przyspieszają dostarczanie oprogramowania, pozwalając skupić się na kodzie, zamiast na infrastrukturze wsparcia i operacjach.

Ten artykuł pokazuje, jak skonfigurować procesy CI/CD przy użyciu Azure Pipelines z szablonami Azure Resource Manager (szablonami ARM), aby wdrażać rozwiązania HPC na Azure Batch. Przykład tworzy potok kompilacji i wydania, aby wdrożyć infrastrukturę Azure Batch i wypuścić pakiet aplikacji. Następujący diagram przedstawia ogólny przepływ wdrażania, zakładając, że kod jest rozwijany lokalnie.

Diagram pokazujący przepływ wdrożenia w pipeline.

Wymagania wstępne

Aby wykonać kroki opisane w tym artykule, potrzebujesz:

Prepare the solution

Przykład w tym artykule wykorzystuje kilka szablonów ARM oraz istniejącą open-source'ową aplikację do przetwarzania wideo, FFmpeg. Możesz skopiować lub pobrać te zasoby i przesłać je do swojego repozytorium Azure Repos.

Ważne

This example deploys Windows software on Windows-based Batch nodes. Azure Pipelines, ARM templates, and Batch also fully support Linux software and nodes.

Understand the ARM templates

Three capability templates, similar to units or modules, implement specific pieces of functionality. Szablon kompleksowego rozwiązania następnie wdraża podstawowe szablony możliwości. This linked template structure allows each capability template to be individually tested and reused across solutions.

Diagram showing a linked template structure using ARM templates.

Aby uzyskać szczegółowe informacje o szablonach, zobacz przewodnik referencyjny dotyczący szablonów Resource Manager dla typów zasobów Microsoft.Batch.

Storage account template

Save the following code as a file named storageAccount.json. Ten szablon definiuje konto magazynu Azure, które jest wymagane do wdrożenia aplikacji na konto Batch.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "accountName": {
            "type": "string",
            "metadata": {
                 "description": "Name of the Azure Storage Account"
             }
         }
    },
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Storage/storageAccounts",
            "name": "[parameters('accountName')]",
            "sku": {
                "name": "Standard_LRS"
            },
            "apiVersion": "2018-02-01",
            "location": "[resourceGroup().location]",
            "properties": {}
        }
    ],
    "outputs": {
        "blobEndpoint": {
          "type": "string",
          "value": "[reference(resourceId('Microsoft.Storage/storageAccounts', parameters('accountName'))).primaryEndpoints.blob]"
        },
        "resourceId": {
          "type": "string",
          "value": "[resourceId('Microsoft.Storage/storageAccounts', parameters('accountName'))]"
        }
    }
}

Szablon konta wsadowego

Save the following code as a file named batchAccount.json. Ten szablon określa Batch account. Konto Batch działa jako platforma do uruchamiania aplikacji na różnych pulach węzłów.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "batchAccountName": {
           "type": "string",
           "metadata": {
                "description": "Name of the Azure Batch Account"
            }
        },
        "storageAccountId": {
           "type": "string",
           "metadata": {
                "description": "ID of the Azure Storage Account"
            }
        }
    },
    "variables": {},
    "resources": [
        {
            "name": "[parameters('batchAccountName')]",
            "type": "Microsoft.Batch/batchAccounts",
            "apiVersion": "2017-09-01",
            "location": "[resourceGroup().location]",
            "properties": {
              "poolAllocationMode": "BatchService",
              "autoStorage": {
                  "storageAccountId": "[parameters('storageAccountId')]"
              }
            }
          }
    ],
    "outputs": {}
}

Batch pool template

Zapisz poniższy kod jako plik o nazwie batchAccountPool.json. Ten szablon tworzy pulę węzłów i węzły w koncie Batch.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "batchAccountName": {
           "type": "string",
           "metadata": {
                "description": "Name of the Azure Batch Account"
           }
        },
        "batchAccountPoolName": {
            "type": "string",
            "metadata": {
                 "description": "Name of the Azure Batch Account Pool"
             }
         }
    },
    "variables": {},
    "resources": [
        {
            "name": "[concat(parameters('batchAccountName'),'/', parameters('batchAccountPoolName'))]",
            "type": "Microsoft.Batch/batchAccounts/pools",
            "apiVersion": "2017-09-01",
            "properties": {
                "deploymentConfiguration": {
                    "virtualMachineConfiguration": {
                        "imageReference": {
                            "publisher": "MicrosoftWindowsServer",
                            "offer": "WindowsServer",
                            "sku": "2022-datacenter",
                            "version": "latest"
                        },
                        "nodeAgentSkuId": "batch.node.windows amd64"
                    }
                },
                "vmSize": "Standard_D2s_v3"
            }
          }
    ],
    "outputs": {}
}

Szablon Orchestrator

Save the following code as a file named deployment.json. This final template acts as an orchestrator to deploy the three underlying capability templates.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "StorageContainerUri": {
           "type": "string",
           "metadata": {
                "description": "URI of the Blob Storage Container containing the Azure Resource Manager templates"
            }
        },
        "StorageContainerSasToken": {
           "type": "string",
           "metadata": {
                "description": "The SAS token of the container containing the Azure Resource Manager templates"
            }
        },
        "applicationStorageAccountName": {
            "type": "string",
            "metadata": {
                 "description": "Name of the Azure Storage Account"
            }
         },
        "batchAccountName": {
            "type": "string",
            "metadata": {
                 "description": "Name of the Azure Batch Account"
            }
         },
         "batchAccountPoolName": {
             "type": "string",
             "metadata": {
                  "description": "Name of the Azure Batch Account Pool"
              }
          }
    },
    "variables": {},
    "resources": [
        {
            "apiVersion": "2017-05-10",
            "name": "storageAccountDeployment",
            "type": "Microsoft.Resources/deployments",
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                  "uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/storageAccount.json', parameters('StorageContainerSasToken'))]",
                  "contentVersion": "1.0.0.0"
                },
                "parameters": {
                    "accountName": {"value": "[parameters('applicationStorageAccountName')]"}
                }
            }
        },
        {
            "apiVersion": "2017-05-10",
            "name": "batchAccountDeployment",
            "type": "Microsoft.Resources/deployments",
            "dependsOn": [
                "storageAccountDeployment"
            ],
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                  "uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/batchAccount.json', parameters('StorageContainerSasToken'))]",
                  "contentVersion": "1.0.0.0"
                },
                "parameters": {
                    "batchAccountName": {"value": "[parameters('batchAccountName')]"},
                    "storageAccountId": {"value": "[reference('storageAccountDeployment').outputs.resourceId.value]"}
                }
            }
        },
        {
            "apiVersion": "2017-05-10",
            "name": "poolDeployment",
            "type": "Microsoft.Resources/deployments",
            "dependsOn": [
                "batchAccountDeployment"
            ],
            "properties": {
                "mode": "Incremental",
                "templateLink": {
                  "uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/batchAccountPool.json', parameters('StorageContainerSasToken'))]",
                  "contentVersion": "1.0.0.0"
                },
                "parameters": {
                    "batchAccountName": {"value": "[parameters('batchAccountName')]"},
                    "batchAccountPoolName": {"value": "[parameters('batchAccountPoolName')]"}
                }
            }
        }
    ],
    "outputs": {}
}

Set up your repository

Prześlij szablony ARM, aplikację FFmpeg oraz plik definicji budowy YAML do swojego repozytorium Azure Repos.

  1. Prześlij cztery szablony ARM do folderu arm-templates w swoim repozytorium.

  2. Aby uzyskać pakiet aplikacji, pobierz i rozpakuj wersję 64-bitową FFmpeg 4.3.1 dla systemu Windows, a następnie prześlij ją do folderu hpc-application w swoim repozytorium.

  3. Dla definicji kompilacji zapisz poniższą definicję jako plik o nazwie hpc-app.build.yml i prześlij ją do folderu pipelines w swoim repozytorium.

    # To publish an application into Batch, you need to
# first zip the file, and then publish an artifact, so
# you can take the necessary steps in your release pipeline.
steps:
# First, zip up the files required in the Batch account.
# For this instance, those are the ffmpeg files.
- task: ArchiveFiles@2
  displayName: 'Archive applications'
  inputs:
    rootFolderOrFile: hpc-application
    includeRootFolder: false
    archiveFile: '$(Build.ArtifactStagingDirectory)/package/$(Build.BuildId).zip'
# Publish the zip file, so you can use it as part
# of your Release pipeline later.
- task: PublishPipelineArtifact@0
  inputs:
    artifactName: 'hpc-application'
    targetPath: '$(Build.ArtifactStagingDirectory)/package'

Gdy skończysz konfigurować swoje repozytorium, struktura folderów powinna zawierać następujące główne sekcje:

  • Folder arm-templates zawierający szablony ARM.
  • Folder hpc-application, który zawiera ffmpeg.
  • A pipelines folder that contains the YAML build definition file for the Build pipeline.

Zrzut ekranu struktury repozytorium.

Uwaga

Ta przykładowa struktura bazy kodu pokazuje, że możesz przechowywać kod aplikacji, infrastruktury i pipeline'u w tym samym repozytorium.

Utwórz potok Azure

Po skonfigurowaniu repozytorium kodu źródłowego użyj Azure Pipelines, aby zaimplementować proces kompilacji, testowania i wdrażania dla swojej aplikacji. Na tym etapie rurociągu zazwyczaj przeprowadzasz testy w celu walidacji kodu i budowy części oprogramowania. Liczba i rodzaje testów oraz wszelkie inne zadania, które wykonujesz, zależą od ogólnej strategii budowania i wydawania.

Utwórz kanał kompilacji

W tej sekcji tworzysz potok budowania YAML, aby współpracować z oprogramowaniem ffmpeg, które działa w koncie usługi Batch.

  1. W swoim projekcie Azure DevOps wybierz Pipelines z lewego menu nawigacyjnego, a następnie wybierz Nowy pipeline.

  2. On the Where is your code screen, select Azure Repos Git.

    Zrzut ekranu nowego ekranu potoku.

  3. On the Select a repository screen, select your repository.

    Uwaga

    You can also create a build pipeline by using a visual designer. Na stronie Nowa linia wybierz Użyj klasycznego edytora. You can use a YAML template in the visual designer. Aby uzyskać więcej informacji, zobacz Define your Classic pipeline.

  4. On the Configure your pipeline screen, select Existing Azure Pipelines YAML file.

  5. Na ekranie Wybierz istniejący plik YAML wybierz plik hpc-app.build.yml z twojego repozytorium, a następnie wybierz Kontynuuj.

  6. Na ekranie Przejrzyj swój pipeline YAML, przejrzyj konfigurację kompilacji, a następnie wybierz Run, lub wybierz strzałkę obok Run i wybierz Save. This template enables continuous integration, so the build automatically triggers when a new commit to the repository meets the conditions set in the build.

    Screenshot of an existing Build pipeline.

  7. Możesz zobaczyć na żywo aktualizacje postępów kompilacji. To see build outcomes, select the appropriate run from your build definition in Azure Pipelines.

    Zrzut ekranu z wynikami na żywo z kompilacji w Azure Pipelines.

Uwaga

Jeśli używasz aplikacji klienckiej do uruchomienia swojego rozwiązania HPC, musisz utworzyć osobną definicję kompilacji dla tej aplikacji. Aby uzyskać przewodniki instruktażowe, zobacz dokumentację Azure Pipelines.

Create the Release pipeline

Używasz potoku wydania usługi Azure Pipelines do wdrażania swojej aplikacji i podstawowej infrastruktury. Release pipelines enable CD and automate your release process. There are several steps to deploy your application and underlying infrastructure.

Szablony powiązane z tym rozwiązaniem muszą być dostępne z publicznego punktu końcowego HTTP lub HTTPS. Ten punkt końcowy może być repozytorium GitHub, kontem Azure Blob Storage lub inną lokalizacją magazynowania. Aby zapewnić bezpieczeństwo przesłanych artefaktów szablonu, przechowuj je w trybie prywatnym, ale uzyskuj do nich dostęp, używając pewnej formy tokenu SAS (sygnatura dostępu).

Poniższy przykład pokazuje, jak wdrożyć infrastrukturę i aplikację, używając szablonów z obiektu blob w Azure Storage.

Skonfiguruj potok

  1. In your Azure DevOps project, select Pipelines>Releases in the left navigation.

  2. On the next screen, select New>New release pipeline.

  3. On the Select a template screen, select Empty job, and then close the Stage screen.

  4. Wybierz Nową wersję potoku u góry strony i zmień nazwę potoku na coś adekwatnego, na przykład Deploy Azure Batch + Pool.

    Screenshot of the initial release pipeline.

  5. In the Artifacts section, select Add.

  6. Na ekranie Dodaj artefakt wybierz Buduj, a następnie wybierz swoją linię przetwarzania budowy, aby uzyskać wyniki dla aplikacji HPC.

    Uwaga

    You can create a Source alias or accept the default. Zwróć uwagę na wartość Alias źródła, ponieważ potrzebujesz jej do tworzenia zadań w definicji wydania.

    Zrzut ekranu pokazujący link do artefaktu w pakiecie hpc-application w linii produkcyjnej.

  7. Wybierz Dodaj.

  8. Na stronie potoku wybierz Dodaj obok Artefakty, aby utworzyć link do innego artefaktu, Twojego repozytorium Azure Repos. This link is required to access the ARM templates in your repository. ARM templates don't need compilation, so you don't need to push them through a build pipeline.

    Uwaga

    Ponownie zanotuj wartość aliasu źródła do późniejszego użycia.

    Zrzut ekranu pokazujący link do artefaktu w repozytorium Azure Repos.

  9. Select the Variables tab. Create the following variables in your pipeline so you don't have to reenter the same information into multiple tasks.

    Nazwa Wartość
    applicationStorageAccountName Name for the storage account to hold the HPC application binaries.
    batchAccountApplicationName Nazwa aplikacji w koncie Batch.
    batchAccountName Nazwa dla konta Batch.
    batchAccountPoolName Nazwa puli maszyn wirtualnych (VM) do przetwarzania.
    batchApplicationId Unikalny identyfikator dla aplikacji Batch, w formie:
    /subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^
    /providers/Microsoft.Batch/batchAccounts/<batchAccountName>^
    /applications/<batchAccountApplicationName>.

    Replace the <subscriptionId> placeholder with your Azure subscription ID, and the other placeholders with the values you set for the other variables in this list.
    batchApplicationVersion Semantyczna wersja twojej aplikacji Batch, w tym przypadku 4.3.1.
    lokalizacja Region Azure dla zasobów do wdrożenia.
    resourceGroupName Nazwa grupy zasobów, do której wdrażane są zasoby.
    storageAccountName Nazwa konta magazynu do przechowywania połączonych szablonów ARM.
    StorageContainerSasToken $(<referenceName>.StorageContainerSasToken). Zastąp <referenceName symbolem wartości Reference name, którą skonfigurowałeś w sekcji Zmienne wynikowe następnego kroku Azure File Copy.
    StorageContainerUri $(<referenceName>.StorageContainerUri). Zastąp symbol zastępczy <referenceName> wartością Nazwa referencyjna, którą skonfigurujesz w sekcji Zmienne wynikowe kroku Azure File Copy.

    Zrzut ekranu pokazujący zmienne ustawione dla wydania Azure Pipelines.

  10. Wybierz kartę Zadania, a następnie wybierz Praca agenta.

  11. Na ekranie Agent job, pod Agent pool, wybierz Azure Pipelines.

  12. Pod Specyfikacja Agenta wybierz windows-latest.

    Screenshot showing the Agent job settings.

Dodawanie zadań

Utwórz sześć zadań do:

  • Pobierz pliki ffmpeg w formacie zip.
  • Utwórz konto magazynowe, aby hostować zagnieżdżone szablony ARM.
  • Skopiuj szablony ARM do konta magazynowego.
  • Wdróż konto Batch oraz wymagane zależności.
  • Utwórz aplikację w ramach konta Batch.
  • Prześlij pakiet aplikacji do konta Batch.

Dla każdego nowego zadania, które określają poniższe kroki:

  1. Wybierz symbol + obok Agent job w lewym panelu.

  2. Wyszukaj i wybierz określone zadanie w prawym panelu.

  3. Dodaj lub wybierz właściwości, aby skonfigurować zadanie.

  4. Wybierz Dodaj.

    Zrzut ekranu pokazujący zadania używane do wydania aplikacji HPC na Azure Batch.

Utwórz zadania w następujący sposób:

  1. Wybierz zadanie Download Pipeline Artifacts i ustaw następujące właściwości:

    • Display name: Wprowadź Pobierz pakiet aplikacji na agenta.
    • Artifact name: Enter hpc-application.
    • Destination directory: Enter $(System.DefaultWorkingDirectory).

  2. Utwórz konto Azure Storage, aby przechowywać swoje szablony ARM. Możesz użyć istniejącego konta magazynu, ale aby wesprzeć ten samodzielny przykład i zapewnić izolację treści, stwórz dedykowane konto magazynu.

    Wybierz zadanie Wdrożenie szablonu ARM: Zakres grupy zasobów i ustaw następujące właściwości:

    • Display name: Enter Deploy storage account for ARM templates.
    • Połączenie Azure Resource Manager: Wybierz odpowiednią subskrypcję Azure.
    • Subscription: Wybierz odpowiednią subskrypcję Azure.
    • Akcja: Wybierz Utwórz lub zaktualizuj grupę zasobów.
    • Resource group: Enter $(resourceGroupName).
    • Location: Enter $(location).
    • Template: Enter $(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.json. Zamień symbol zastępczy <AzureRepoArtifactSourceAlias> na alias źródła repozytorium, który zanotowałeś wcześniej.
    • Zmiana parametrów szablonu: Wprowadź -accountName $(storageAccountName).

  3. Prześlij artefakty z kontroli źródła na konto magazynowe. Część tego zadania Azure File Copy wyprowadza URI kontenera konta magazynu i token SAS do zmiennej, aby można je było ponownie wykorzystać w kolejnych krokach.

    Wybierz zadanie Azure File Copy i ustaw następujące właściwości:

    • Wyświetlana nazwa: Wpisz AzureBlob File Copy.
    • Source: Enter $(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/. Zastąp <AzureRepoArtifactSourceAlias> alias Źródła repozytorium, który zanotowałeś wcześniej.
    • Subskrypcja Azure: Wybierz odpowiednią subskrypcję Azure.
    • Destination Type: Select Azure Blob.
    • RM Storage Account: Enter $(storageAccountName).
    • Container Name: Enter templates.
    • Reference name: Expand Output Variables, then enter ffmpeg.

    Uwaga

    Jeśli ten krok się nie powiedzie, upewnij się, że Twoja organizacja Azure DevOps ma rolę Storage Blob Contributor w koncie magazynowym.

  4. Wdróż szablon ARM orkiestratora, aby utworzyć konto Batch i pulę. Ten szablon zawiera parametry dla URI kontenera konta Storage oraz token SAS. The variables required in the ARM template are held in the variables section of the release definition and were set from the AzureBlob File Copy task.

    Select the ARM Template deployment: Resource Group scope task, and set the following properties:

    • Display name: Enter Deploy Azure Batch.
    • Połączenie z Azure Resource Manager: Wybierz odpowiednią subskrypcję Azure.
    • Subscription: Wybierz odpowiednią subskrypcję Azure.
    • Akcja: Wybierz Utwórz lub zaktualizuj grupę zasobów.
    • Resource group: Enter $(resourceGroupName).
    • Location: Enter $(location).
    • Template location: Select URL of the file.
    • Template link: Enter $(StorageContainerUri)arm-templates/deployment.json$(StorageContainerSasToken).
    • Nadpisz parametry szablonu: Enter -StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName).

    A common practice is to use Azure Key Vault tasks. Jeśli główny użytkownik usługi połączony z subskrypcją Azure ma ustawioną odpowiednią politykę dostępu, może pobierać tajemnice z Key Vault i być używany jako zmienna w twoim potoku. Nazwa tajemnicy jest ustawiana z przypisanym wartością. Na przykład, możesz odwołać się do tajnego hasła sshPassword używając $(sshPassword) w definicji wydania.

  5. Użyj Azure CLI, aby utworzyć aplikację w Azure Batch.

    Wybierz zadanie Azure CLI i ustaw następujące właściwości:

    • Nazwa wyświetlana: Wprowadź Utwórz aplikację w koncie Azure Batch.
    • Azure Resource Manager connection: Select the appropriate Azure subscription.
    • Script Type: Select PowerShell Core.
    • Script Location: Select Inline script.
    • Inline Script: Enter az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName).

  6. Użyj Azure CLI, aby przesłać powiązane pakiety do aplikacji, w tym przypadku pliki ffmpeg.

    Select the Azure CLI task, and set the following properties:

    • Wyświetlana nazwa: Wpisz Przesyłanie pakietu do konta Azure Batch.
    • Azure Resource Manager connection: Wybierz odpowiednią subskrypcję Azure.
    • Script Type: Select PowerShell Core.
    • Script Location: Select Inline script.
    • Inline Script: Enter az batch application package create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName) --version $(batchApplicationVersion) --package-file=$(System.DefaultWorkingDirectory)/$(Release.Artifacts.<AzureBuildArtifactSourceAlias>.BuildId).zip. Zamień symbol zastępczy <AzureBuildArtifactSourceAlias> na alias źródła kompilacji, który wcześniej zanotowałeś.

    Uwaga

    The version number of the application package is set to a variable. The variable allows overwriting previous versions of the package and lets you manually control the package version pushed to Azure Batch.

Create and run the release

  1. When you finish creating all the steps, select Save at the top of the pipeline page, and then select OK.

  2. Select Create release at the top of the page.

  3. Aby zobaczyć status aktualnej wersji, wybierz link na górze strony, który informuje, że wersja została utworzona.

  4. Aby wyświetlić dane wyjściowe dziennika agenta, najedź kursorem na etap, a następnie wybierz przycisk Dzienniki.

    Zrzut ekranu pokazujący status wydania.

Przetestuj środowisko

Po skonfigurowaniu środowiska potwierdź, że poniższe testy uruchamiają się pomyślnie. Zamień zastępniki na wartości swojej grupy zasobów i konta Batch.

Połącz się z kontem Batch

Połącz się z nowym kontem Batch, używając Azure CLI z wiersza poleceń.

  1. Zaloguj się do swojego konta Azure za pomocą az login i postępuj zgodnie z instrukcjami, aby się uwierzytelnić.
  2. Uwierzytelnij konto Batch używając az batch account login -g <resourceGroup> -n <batchAccount>.

Wymień dostępne aplikacje

az batch application list -g <resourceGroup> -n <batchAccount>

Sprawdź, czy basen jest ważny.

az batch pool list

W wynikach poleceń zanotuj wartość currentDedicatedNodes, aby dostosować ją w następnym teście.

Zmień rozmiar puli

Uruchom następujące polecenie, aby zmienić rozmiar puli, tak aby były dostępne węzły obliczeniowe do testowania zadań i procesów. Zamień <poolName> na nazwę swojej puli, a <targetNumber> na liczbę większą niż currentDedicatedNodes z wyniku poprzedniego polecenia. Sprawdź status, uruchamiając polecenie az batch pool list do czasu zakończenia zmiany rozmiaru i pokazania docelowej liczby węzłów.

az batch pool resize --pool-id <poolname> --target-dedicated-nodes <target number>

Następne kroki

Zobacz te samouczki, aby nauczyć się, jak korzystać z konta Batch za pomocą prostej aplikacji.