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

Azure DevOps narzędzia mogą automatyzować tworzenie i testowanie Azure Batch rozwiązań obliczeń o wysokiej wydajności (HPC). 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:

Organizacja Azure DevOps oraz projekt Azure DevOps z repozytorium Azure Repos utworzonym w organizacji. Musisz mieć przypisane role Administrator projektu, Administrator kompilacji, i Administrator wydania w projekcie Azure DevOps.
Aktywna subskrypcja Azure z rolą Owner lub inną rolą, która obejmuje możliwość przypisywania ról. Aby uzyskać więcej informacji, zobacz Zrozumienie przypisania ról w Azure.
Podstawowa wiedza na temat kontroli wersji i składni szablonów ARM.

Przygotowywanie rozwiązania

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

W tym przykładzie wdrożono oprogramowanie Windows na węzłach usługi Batch opartych na Windows. Azure Pipelines, szablony usługi ARM i usługa Batch również w pełni obsługują oprogramowanie i węzły systemu Linux.

Poznaj szablony ARM

Trzy szablony możliwości, podobne do jednostek lub modułów, implementują określone elementy funkcjonalności. Szablon kompleksowego rozwiązania następnie wdraża podstawowe szablony możliwości. Ta połączona struktura szablonu umożliwia poszczególnym szablonom możliwości indywidualne przetestowanie i ponowne użycie w różnych rozwiązaniach.

Diagram przedstawiający strukturę połączonych szablonów z użyciem szablonów ARM.

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

Szablon konta magazynu

Zapisz następujący kod jako plik o nazwie 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

Zapisz następujący kod jako plik o nazwie 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": {}
}

Szablon puli usługi Batch

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

Zapisz następujący kod jako plik o nazwie deployment.json. Ten ostatni szablon pełni rolę koordynatora w celu wdrożenia trzech podstawowych szablonów możliwości.

{
    "$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": {}
}

Konfigurowanie repozytorium

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

Prześlij cztery szablony ARM do folderu arm-templates w swoim repozytorium.
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.

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.
Folder pipelines zawierający plik definicji kompilacji w formacie YAML dla potoku Build.

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.

W swoim projekcie Azure DevOps wybierz Pipelines z lewego menu nawigacyjnego, a następnie wybierz Nowy pipeline.
Na ekranie Gdzie jest twój kod wybierz pozycję Azure Repos Git.
Na ekranie Wybór repozytorium wybierz swoje repozytorium.

Uwaga

Potok kompilacji można również utworzyć za pomocą projektanta graficznego. Na stronie Nowa linia wybierz Użyj klasycznego edytora. Szablon YAML można użyć w projektancie wizualizacji. Aby uzyskać więcej informacji, zobacz Define your Classic pipeline.
Na ekranie Skonfiguruj potok wybierz Istniejący plik YAML usługi Azure Pipelines.
Na ekranie Wybierz istniejący plik YAML wybierz plik hpc-app.build.yml z twojego repozytorium, a następnie wybierz Kontynuuj.
Na ekranie Przejrzyj swój pipeline YAML, przejrzyj konfigurację kompilacji, a następnie wybierz Run, lub wybierz strzałkę obok Run i wybierz Save. Ten szablon umożliwia ciągłą integrację, więc kompilacja jest automatycznie wyzwalana, gdy nowe zatwierdzenie w repozytorium spełnia warunki określone w kompilacji.
Możesz zobaczyć na żywo aktualizacje postępów kompilacji. Aby wyświetlić wyniki kompilacji, wybierz odpowiedni przebieg z definicji 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.

Utwórz potok wydania

Używasz potoku wydania usługi Azure Pipelines do wdrażania swojej aplikacji i podstawowej infrastruktury. Potoki wdrażania umożliwiają CD i automatyzują proces wdrażania. Istnieje kilka kroków wdrażania aplikacji i podstawowej infrastruktury.

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

W projekcie Azure DevOps wybierz pozycję Potoki>Wydania w lewym obszarze nawigacji.
Na następnym ekranie wybierz pozycję Nowy>potok wydania.
Na ekranie Wybieranie szablonu wybierz pozycję Puste zadanie, a następnie zamknij ekran Etap .
Wybierz Nową wersję potoku u góry strony i zmień nazwę potoku na coś adekwatnego, na przykład Deploy Azure Batch + Pool.
W sekcji Artefakty wybierz pozycję Dodaj.
Na ekranie Dodaj artefakt wybierz Buduj, a następnie wybierz swoją linię przetwarzania budowy, aby uzyskać wyniki dla aplikacji HPC.

Uwaga

Możesz utworzyć alias źródłowy lub zaakceptować wartość domyślną. Zwróć uwagę na wartość Alias źródła, ponieważ potrzebujesz jej do tworzenia zadań w definicji wydania.
Wybierz Dodaj.
Na stronie potoku wybierz Dodaj obok Artefakty, aby utworzyć link do innego artefaktu, Twojego repozytorium Azure Repos. To łącze jest wymagane, aby uzyskać dostęp do szablonów ARM w repozytorium. Szablony ARM nie wymagają kompilacji, więc nie trzeba ich przepuszczać przez potok kompilacji.

Uwaga

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

Wybierz kartę Zmienne. Utwórz następujące zmienne w swoim potoku, aby nie trzeba było ponownie wprowadzać tych samych informacji w wielu zadaniach.

Nazwa	Wartość
applicationStorageAccountName	Nazwa konta magazynu do przechowywania plików binarnych aplikacji HPC.
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>`. Zastąp symbol zastępczy `<subscriptionId>` identyfikatorem subskrypcji platformy Azure, a pozostałe symbole zastępcze wartościami ustawionymi dla pozostałych zmiennych z tej listy.
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.

Wybierz kartę Zadania, a następnie wybierz Praca agenta.
Na ekranie Agent job, pod Agent pool, wybierz Azure Pipelines.
Pod Specyfikacja Agenta wybierz windows-latest.

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:

Wybierz symbol + obok Agent job w lewym panelu.
Wyszukaj i wybierz określone zadanie w prawym panelu.
Dodaj lub wybierz właściwości, aby skonfigurować zadanie.
Wybierz Dodaj.

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

Wybierz zadanie Download Pipeline Artifacts i ustaw następujące właściwości:
- Display name: Wprowadź Pobierz pakiet aplikacji na agenta.
- Nazwa artefaktu: Wprowadź hpc-application.
- Folder docelowy: Wprowadź $(System.DefaultWorkingDirectory).
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:
- Nazwa wyświetlana: Wprowadź Konto magazynu wdrożenia dla szablonów ARM.
- Połączenie Azure Resource Manager: Wybierz odpowiednią subskrypcję Azure.
- Subscription: Wybierz odpowiednią subskrypcję Azure.
- Akcja: Wybierz Utwórz lub zaktualizuj grupę zasobów.
- Grupa zasobów: wprowadź $(resourceGroupName).
- Lokalizacja: Wprowadź $(location).
- Szablon: Wprowadź $(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).
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.
- Źródła: Wprowadź wartość $(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/. Zamień symbol zastępczy <AzureRepoArtifactSourceAlias> na alias źródła repozytorium, który zanotowałeś wcześniej.
- Subskrypcja Azure: Wybierz odpowiednią subskrypcję Azure.
- Typ miejsca docelowego: Wybierz Azure Blob.
- Konto magazynu RM: wprowadź $(storageAccountName).
- Nazwa kontenera: wprowadź szablony.
- Nazwa referencyjna: rozwiń Zmienne wyjściowe, a następnie wpisz ffmpeg.
Uwaga

Jeśli ten krok się nie powiedzie, upewnij się, że Twoja organizacja Azure DevOps ma rolę Storage Blob Contributor w koncie magazynowym.
Wdróż szablon ARM orkiestratora, aby utworzyć konto Batch i pulę. Ten szablon zawiera parametry dla URI kontenera konta Storage oraz token SAS. Zmienne wymagane w szablonie ARM znajdują się w sekcji zmiennych definicji wydania i zostały ustawione za pomocą zadania AzureBlob File Copy.

Wybierz zadanie Wdrożenie szablonu ARM: Zakres grupy zasobów i ustaw następujące właściwości:
- Nazwa wyświetlana: Wprowadź Wdróż usługę 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.
- Grupa zasobów: wprowadź $(resourceGroupName).
- Lokalizacja: Wprowadź $(location).
- Lokalizacja szablonu: wybierz adres URL pliku.
- Link do szablonu: Wprowadź wartość $(StorageContainerUri)arm-templates/deployment.json$(StorageContainerSasToken).
- Zmiana parametrów szablonu: Wprowadź -StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName).
Typowym rozwiązaniem jest użycie zadań Azure Key Vault. 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.
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.
- Połączenie z Azure Resource Manager: Wybierz odpowiednią subskrypcję Azure.
- Typ skryptu: wybierz pozycję PowerShell Core.
- Lokalizacja skryptu: wybierz pozycję Skrypt wbudowany.
- Wbudowany skrypt: Wpisz az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName).
Użyj Azure CLI, aby przesłać powiązane pakiety do aplikacji, w tym przypadku pliki ffmpeg.

Wybierz zadanie Azure CLI i ustaw następujące właściwości:
- Wyświetlana nazwa: Wpisz Przesyłanie pakietu do konta Azure Batch.
- Połączenie z Azure Resource Manager: Wybierz odpowiednią subskrypcję Azure.
- Typ skryptu: wybierz pozycję PowerShell Core.
- Lokalizacja skryptu: wybierz pozycję Skrypt wbudowany.
- Wbudowany skrypt: Wpisz 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

Numer wersji pakietu aplikacji jest ustawiony na zmienną. Zmienna umożliwia zastępowanie poprzednich wersji pakietu i umożliwia ręczne sterowanie wersją pakietu wypychaną do Azure Batch.

Tworzenie i uruchamianie wydania

Po zakończeniu tworzenia wszystkich kroków wybierz pozycję Zapisz u góry strony potoku, a następnie wybierz OK.
Wybierz pozycję Utwórz wydanie w górnej części strony.
Aby zobaczyć status aktualnej wersji, wybierz link na górze strony, który informuje, że wersja została utworzona.
Aby wyświetlić dane wyjściowe dziennika agenta, najedź kursorem na etap, a następnie wybierz przycisk Dzienniki.

Przetestuj środowisko

Po skonfigurowaniu środowiska upewnij się, że następujące testy zostały pomyślnie uruchomione. 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ń.

Zaloguj się do swojego konta Azure za pomocą az login i postępuj zgodnie z instrukcjami, aby się uwierzytelnić.
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.

Opinia

Czy ta strona była pomocna?

Last updated on 2026-06-17