Verwenden von Azure Pipelines zum Erstellen und Bereitstellen einer HPC-Lösung

Azure DevOps Tools können das Erstellen und Testen Azure Batch HPC-Lösungen (High Performance Computing) automatisieren. Azure Pipelines bietet moderne, kontinuierliche Integration (CI) und kontinuierliche Bereitstellungsprozesse (CD) zum Erstellen, Bereitstellen, Testen und Überwachen von Software. Diese Prozesse beschleunigen die Softwarebereitstellung, sodass Sie sich nicht auf Infrastruktur und Betrieb, sondern auf Ihren Code konzentrieren können.

In diesem Artikel wird gezeigt, wie CI/CD-Prozesse mithilfe von Azure Pipelines mit Azure Resource Manager Vorlagen (ARM-Vorlagen) eingerichtet werden, um HPC-Lösungen auf Azure Batch bereitzustellen. Im Beispiel wird eine Build- und Releasepipeline erstellt, um eine Azure Batch Infrastruktur bereitzustellen und ein Anwendungspaket freizugeben. Das folgende Diagramm zeigt den allgemeinen Bereitstellungsfluss, vorausgesetzt, der Code wird lokal entwickelt:

Diagramm, das den Bereitstellungsfluss in der Pipeline zeigt.

Voraussetzungen

Um die Schritte in diesem Artikel auszuführen, benötigen Sie Folgendes:

Vorbereiten der Lösung

Im Beispiel in diesem Artikel werden mehrere ARM-Vorlagen und eine vorhandene Open-Source-Videoverarbeitungsanwendung FFmpeg verwendet. Sie können diese Ressourcen kopieren oder herunterladen und an Ihr Azure Repos Repository übertragen.

Important

In diesem Beispiel wird eine Windows-Software auf Windows-basierten Batchknoten bereitgestellt. Azure Pipelines, ARM-Vorlagen und Batch unterstützen auch Linux-Software und -Knoten vollständig.

Grundlegendes zu den ARM-Vorlagen

Drei Funktionsvorlagen, ähnlich wie Einheiten oder Module, implementieren bestimmte Funktionen. Eine End-to-End-Lösungsvorlage stellt dann die zugrunde liegenden Funktionsvorlagen bereit. Diese verknüpfte Vorlagenstruktur ermöglicht es jeder Funktionsvorlage, einzeln getestet und in allen Lösungen wiederverwendet zu werden.

Diagramm mit einer verknüpften Vorlagenstruktur mithilfe von ARM-Vorlagen.

Ausführliche Informationen zu den Vorlagen finden Sie im Referenzhandbuch für Resource Manager-Vorlagen für Microsoft.Batch-Ressourcentypen.

Speicherkontovorlage

Speichern Sie den folgenden Code als Datei mit dem Namen storageAccount.json. Diese Vorlage definiert ein Azure Storage Konto, das zum Bereitstellen der Anwendung im Batchkonto erforderlich ist.

{
    "$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'))]"
        }
    }
}

Batchkontovorlage

Speichern Sie den folgenden Code als Datei mit dem Namen batchAccount.json. Diese Vorlage definiert ein Batchkonto. Das Batchkonto fungiert als Plattform zum Ausführen von Anwendungen über Knotenpools hinweg.

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

Vorlage für Batchpools

Speichern Sie den folgenden Code als Datei mit dem Namen batchAccountPool.json. Diese Vorlage erstellt einen Knotenpool und Knoten im Batchkonto.

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

Orchestrator-Vorlage

Speichern Sie den folgenden Code als Datei mit dem Namen deployment.json. Diese endgültige Vorlage dient als Orchestrator zur Bereitstellung der drei zugrunde liegenden Funktionsvorlagen.

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

Einrichten Ihres Repositorys

Laden Sie die ARM-Vorlagen, die FFmpeg-App und eine YAML-Builddefinitionsdatei in Ihr Azure Repos Repository hoch.

  1. Laden Sie die vier ARM-Vorlagen in einen Ordner mit Armvorlagen in Ihr Repository hoch.

  2. Laden Sie das Anwendungspaket herunter, und extrahieren Sie die Windows 64-Bit-Version von FFmpeg 4.3.1, und laden Sie es in einen HPC-Anwendungsordner in Ihrem Repository hoch.

  3. Speichern Sie für die Builddefinition die folgende Definition als Datei mit dem Namen hpc-app.build.yml, und laden Sie sie in einen Pipelineordner in Ihr Repository hoch.

    # 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'

Wenn Sie mit dem Einrichten Ihres Repositorys fertig sind, sollte die Ordnerstruktur die folgenden Hauptabschnitte aufweisen:

  • Ein Ordner arm-templates, der die ARM-Vorlagen enthält.
  • Ein HPC-Anwendungsordner , der ffmpeg enthält.
  • Ein Pipelineordner , der die YAML-Builddefinitionsdatei für die Buildpipeline enthält.

Screenshot der Repositorystruktur.

Hinweis

In dieser Beispielcodebasisstruktur wird veranschaulicht, dass Sie Anwendungs-, Infrastruktur- und Pipelinecode im selben Repository speichern können.

Erstellen der Azure Pipeline

Nachdem Sie das Quellcode-Repository eingerichtet haben, verwenden Sie Azure Pipelines, um eine Build-, Test- und Bereitstellungspipeline für Ihre Anwendung zu implementieren. In dieser Phase einer Pipeline führen Sie in der Regel Tests aus, um Code zu überprüfen und Teile der Software zu erstellen. Die Anzahl und die Arten von Tests sowie alle anderen ausgeführten Aufgaben hängen von Ihrer allgemeinen Build- und Releasestrategie ab.

Erstellen der Buildpipeline

In diesem Abschnitt erstellen Sie eine YAML-Buildpipeline , um mit der ffmpeg-Software zu arbeiten, die im Batchkonto ausgeführt wird.

  1. Wählen Sie in Ihrem Azure DevOps Projekt "Pipelines" aus der linken Navigation und dann "Neue Pipeline" aus.

  2. Wählen Sie auf dem Bildschirm Wo ist Ihr Code?Azure Repos Git aus.

    Screenshot des Bildschirms „Neue Pipeline“.

  3. Wählen Sie auf dem Bildschirm " Repository auswählen " Ihr Repository aus.

    Hinweis

    Sie können auch eine Buildpipeline mithilfe eines visuellen Designers erstellen. Wählen Sie auf der Seite "Neue Pipeline"die Option "Klassischen Editor verwenden" aus. Sie können eine YAML-Vorlage im visuellen Designer verwenden. Weitere Informationen finden Sie unter Define your Classic pipeline.

  4. Wählen Sie auf dem Bildschirm "Pipeline konfigurieren" die Option "Vorhandene Azure Pipelines YAML-Datei" aus.

  5. Wählen Sie auf dem Bildschirm "Vorhandene YAML-Datei auswählen " die hpc-app.build.yml Datei aus Ihrem Repository aus, und wählen Sie dann "Weiter" aus.

  6. Überprüfen Sie auf dem Bildschirm Ihre Pipeline-YAML überprüfen die Buildkonfiguration, und wählen Sie dann Ausführen aus, oder wählen Sie den Dropdownpfeil neben Ausführen und Speichern aus. Diese Vorlage ermöglicht eine kontinuierliche Integration, sodass der Build automatisch ausgelöst wird, wenn ein neuer Commit für das Repository die im Build festgelegten Bedingungen erfüllt.

    Screenshot einer vorhandenen Buildpipeline.

  7. Sie können Aktualisierungen zum Build-Fortschritt in Echtzeit anzeigen. Um Buildergebnisse anzuzeigen, wählen Sie in Azure Pipelines die entsprechende Ausführung aus Ihrer Builddefinition aus.

    Screenshot der Live-Ausgaben eines Builds in Azure Pipelines.

Hinweis

Wenn Sie eine Clientanwendung verwenden, um Ihre HPC-Lösung auszuführen, müssen Sie eine separate Builddefinition für diese Anwendung erstellen. Anleitungen finden Sie in der Azure Pipelines Dokumentation.

Erstellen der Releasepipeline

Sie verwenden eine Azure Pipelines Releasepipeline, um Ihre Anwendung und zugrunde liegende Infrastruktur bereitzustellen. Releasepipelines ermöglichen CD und automatisieren Ihren Veröffentlichungsprozess. Es gibt mehrere Schritte zum Bereitstellen Ihrer Anwendung und der zugrunde liegenden Infrastruktur.

Auf die verknüpften Vorlagen für diese Lösung muss über einen öffentlichen HTTP- oder HTTPS-Endpunkt zugegriffen werden kann. Dieser Endpunkt kann ein GitHub Repository, ein Azure Blob Storage Konto oder ein anderer Speicherort sein. Um sicherzustellen, dass die hochgeladenen Vorlagenartefakte sicher bleiben, halten Sie sie im privaten Modus, greifen aber mithilfe eines SAS-Tokens (Shared Access Signature) darauf zu.

Im folgenden Beispiel wird veranschaulicht, wie Sie eine Infrastruktur und Anwendung mithilfe von Vorlagen aus einem Azure Storage Blob bereitstellen.

Einrichten der Pipeline

  1. Wählen Sie in Ihrem Azure DevOps Projekt pipelines>Releases in der linken Navigation aus.

  2. Wählen Sie auf dem nächsten Bildschirm Neu>Neue Releasepipeline aus.

  3. Wählen Sie auf dem Bildschirm „Vorlage auswählen“ die Option „Leerer Auftrag“ aus, und schließen Sie dann den Stage-Bildschirm.

  4. Wählen Sie oben auf der Seite Neue Releasepipeline aus, und benennen Sie die Pipeline in einen für sie passenden Namen um, z. B. Azure Batch + Pool bereitstellen.

    Screenshot der ursprünglichen Releasepipeline.

  5. Wählen Sie im Abschnitt "Artefakte" die Option "Hinzufügen" aus.

  6. Wählen Sie auf dem Bildschirm „Artefakt hinzufügen“„Build“ aus, und wählen Sie dann Ihre Build-Pipeline aus, um die Ausgabe für die HPC-Anwendung zu erhalten.

    Hinweis

    Sie können einen Quellalias erstellen oder die Standardeinstellung akzeptieren. Notieren Sie sich den Wert des Quellalias, da Sie ihn zum Erstellen von Aufgaben in der Releasedefinition benötigen.

    Screenshot einer Artefaktverknüpfung zum HPC-Anwendungspaket in der Buildpipeline.

  7. Wählen Sie Hinzufügen aus.

  8. Wählen Sie auf der Pipeline-Seite Hinzufügen neben Artefakte aus, um einen Link zu einem anderen Artefakt, Ihrem Azure-Repos-Repository, zu erstellen. Dieser Link ist erforderlich, um auf die ARM-Vorlagen in Ihrem Repository zuzugreifen. ARM-Vorlagen benötigen keine Kompilierung, daher müssen Sie sie nicht über eine Buildpipeline übertragen.

    Hinweis

    Notieren Sie sich erneut den Quellaliaswert , der später verwendet werden soll.

    Screenshot mit einem Link zum Artefakt im Azure-Repos-Repository.

  9. Wählen Sie die Registerkarte "Variablen" aus . Erstellen Sie die folgenden Variablen in Ihrer Pipeline, damit Sie nicht dieselben Informationen in mehrere Aufgaben erneut eingeben müssen.

    Name Wert
    applicationStorageAccountName Name für das Speicherkonto, das die HPC-Anwendungsbinärdateien enthält.
    batchAccountApplicationName Name für die Anwendung im Batchkonto.
    batchAccountName Name des Batch-Kontos.
    batchAccountPoolName Name für den Pool virtueller Computer (VMs), um die Verarbeitung zu erledigen.
    batchApplicationId Eindeutige ID für die Batch-Anwendung im Format:
    /subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^
    /providers/Microsoft.Batch/batchAccounts/<batchAccountName>^
    /applications/<batchAccountApplicationName>.

    Ersetzen Sie den <subscriptionId> Platzhalter durch Ihre Azure-Abonnement-ID und die anderen Platzhalter durch die Werte, die Sie für die anderen Variablen in dieser Liste festgelegt haben.
    batchApplicationVersion Semantische Version Ihrer Batchanwendung in diesem Fall 4.3.1.
    Standort. Azure Region für die zu bereitstellenden Ressourcen.
    resourceGroupName Name für die Ressourcengruppe, in der Ressourcen bereitgestellt werden sollen.
    SpeicherkontoName Name für das Speicherkonto, das die verknüpften ARM-Vorlagen enthält.
    StorageContainerSasToken $(<referenceName>.StorageContainerSasToken). Ersetzen Sie den Platzhalter <referenceName durch den Wert „Verweisname“, den Sie im Abschnitt „Ausgabevariablen“ des folgenden Schritts Azure File Copy konfigurieren.
    StorageContainerUri $(<referenceName>.StorageContainerUri). Ersetzen Sie den Platzhalter <referenceName> durch den Wert Referenzname, den Sie im Abschnitt Output Variables des Schritts Azure File Copy konfigurieren.

    Screenshot mit Variablen, die für die Azure Pipelines Version festgelegt sind.

  10. Wählen Sie die Registerkarte "Aufgaben " und dann " Agent-Auftrag" aus.

  11. Wählen Sie auf dem Bildschirm „Agent-Auftrag“ unter „Agentpool“ die Option Azure Pipelines aus.

  12. Wählen Sie unter "Agentspezifikation" die Option "windows-latest" aus.

    Screenshot der Einstellungen für den Agent-Auftrag.

Hinzufügen von Aufgaben

Erstellen Sie sechs Aufgaben, um:

  • Laden Sie die gezippten ffmpeg-Dateien herunter.
  • Stellen Sie ein Speicherkonto bereit, um die geschachtelten ARM-Vorlagen zu hosten.
  • Kopieren Sie die ARM-Vorlagen in das Speicherkonto.
  • Stellen Sie das Batchkonto und die erforderlichen Abhängigkeiten bereit.
  • Erstellen Sie eine Anwendung im Batchkonto.
  • Laden Sie das Anwendungspaket in das Batchkonto hoch.

Für jeden neuen Vorgang, den die folgenden Schritte angeben:

  1. Wählen Sie im linken Bereich das +-Symbol neben dem Agent-Auftrag aus.

  2. Suchen Sie im rechten Bereich nach der angegebenen Aufgabe, und wählen Sie sie aus.

  3. Fügen Sie die Eigenschaften hinzu, oder wählen Sie sie aus, um die Aufgabe zu konfigurieren.

  4. Wählen Sie Hinzufügen aus.

    Screenshot der Aufgaben, die zum Freigeben der HPC-Anwendung für Azure Batch verwendet werden.

Erstellen Sie die Aufgaben wie folgt:

  1. Wählen Sie die Aufgabe "Pipelineartefakte herunterladen " aus, und legen Sie die folgenden Eigenschaften fest:

    • Anzeigename: Geben Sie "ApplicationPackage herunterladen" in den Agent ein.
    • Artefaktname: Geben Sie hpc-application ein.
    • Zielverzeichnis: Geben Sie $(System.DefaultWorkingDirectory) ein.

  2. Erstellen Sie ein Azure Storage Konto, um Ihre ARM-Vorlagen zu speichern. Sie können ein vorhandenes Speicherkonto verwenden, aber um dieses eigenständige Beispiel und die Isolierung von Inhalten zu unterstützen, erstellen Sie ein dediziertes Speicherkonto.

    Wählen Sie die ARM-Vorlagenbereitstellung aus: Ressourcengruppenbereichsaufgabe , und legen Sie die folgenden Eigenschaften fest:

    • Anzeigename: Geben Sie das Bereitstellungsspeicherkonto für ARM-Vorlagen ein.
    • Azure Resource Manager Verbindung: Wählen Sie das entsprechende Azure-Abonnement aus.
    • Abonnement: Wählen Sie das entsprechende Azure Abonnement aus.
    • Aktion: Wählen Sie " Ressourcengruppe erstellen" oder "Aktualisieren" aus.
    • Ressourcengruppe: Geben Sie $(resourceGroupName)ein.
    • Ort: Geben Sie $(location)ein.
    • Vorlage: Geben Sie $(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.jsonein. Ersetzen Sie den Platzhalter <AzureRepoArtifactSourceAlias> durch den zuvor notierten Source-Alias des Repositorys.
    • Parameter der Vorlage außer Kraft setzen: Geben Sie -accountName $(storageAccountName)ein.

  3. Laden Sie die Artefakte aus der Quellcodeverwaltung in das Speicherkonto hoch. Ein Teil dieser Azure File Copy-Aufgabe schreibt die Container-URI des Speicherkontos und das SAS-Token in eine Variable, sodass sie in späteren Schritten wiederverwendet werden können.

    Wählen Sie die Aufgabe Azure Dateikopie aus, und legen Sie die folgenden Eigenschaften fest:

    • Anzeigename: Geben Sie AzureBlob File Copy ein.
    • Quelle: Geben Sie $(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/ein. Ersetzen Sie den Platzhalter <AzureRepoArtifactSourceAlias> durch den Quellalias des Repositorys, den Sie zuvor notiert haben.
    • Azure Abonnement: Wählen Sie das entsprechende Azure Abonnement aus.
    • Zieltyp: Wählen Sie Azure Blob aus.
    • RM-Speicherkonto: Geben Sie $(storageAccountName)ein.
    • Container Name: Geben Sie templates ein.
    • Verweisname: Erweitern Sie Ausgabevariablen, und geben Sie dann ffmpeg ein.

    Hinweis

    Wenn dieser Schritt fehlschlägt, stellen Sie sicher, dass Ihre Azure DevOps Organisation über die Rolle "Storage Blob Contributor" im Speicherkonto verfügt.

  4. Stellen Sie die Orchestrator ARM-Vorlage bereit, um das Batchkonto und den Pool zu erstellen. Diese Vorlage enthält Parameter für den Speicherkontocontainer-URI und das SAS-Token. Die in der ARM-Vorlage erforderlichen Variablen werden im Variablenabschnitt der Releasedefinition gespeichert und aus der AzureBlob-Dateikopie-Aufgabe festgelegt.

    Wählen Sie die Aufgabe ARM-Vorlagenbereitstellung: Bereich „Ressourcengruppe“ aus und legen Sie die folgenden Eigenschaften fest:

    • Anzeigename: Geben Sie Azure Batch bereitstellen ein.
    • Azure Resource Manager Verbindung: Wählen Sie das entsprechende Azure-Abonnement aus.
    • Abonnement: Wählen Sie das entsprechende Azure Abonnement aus.
    • Aktion: Wählen Sie " Ressourcengruppe erstellen" oder "Aktualisieren" aus.
    • Ressourcengruppe: Geben Sie $(resourceGroupName)ein.
    • Ort: Geben Sie $(location)ein.
    • Vorlagenspeicherort: Wählen Sie die URL der Datei aus.
    • Vorlagenlink: Geben Sie $(StorageContainerUri)arm-templates/deployment.json$(StorageContainerSasToken)ein.
    • Parameter der Vorlage außer Kraft setzen: Geben Sie -StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName)ein.

    Es wird üblich, Azure Key Vault Aufgaben zu verwenden. Wenn der Dienstprinzipal, der mit Ihrem Azure-Abonnement verbunden ist, über einen geeigneten Zugriffsrichtliniensatz verfügt, können geheime Schlüssel aus Key Vault heruntergeladen und als Variable in Ihrer Pipeline verwendet werden. Der Name des geheimen Schlüssels wird mit dem zugeordneten Wert festgelegt. Beispielsweise könnten Sie in der Releasedefinition auf einen geheimen Schlüssel von sshPassword mit $(sshPassword) verweisen.

  5. Rufen Sie Azure CLI auf, um eine Anwendung in Azure Batch zu erstellen.

    Wählen Sie die Azure CLI Aufgabe aus, und legen Sie die folgenden Eigenschaften fest:

    • Anzeigename: Geben Sie "Anwendung erstellen" in Azure Batch Konto ein.
    • Azure Resource Manager Verbindung: Wählen Sie das entsprechende Azure-Abonnement aus.
    • Skripttyp: Wählen Sie PowerShell Core aus.
    • Skriptspeicherort: Wählen Sie Inlineskript aus.
    • Inlineskript: Geben Sie az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName)ein.

  6. Rufen Sie Azure CLI auf, um zugeordnete Pakete in die Anwendung hochzuladen, in diesem Fall die ffmpeg-Dateien.

    Wählen Sie die Azure CLI Aufgabe aus, und legen Sie die folgenden Eigenschaften fest:

    • Anzeigename: Geben Sie das Upload-Paket in Azure Batch Konto ein.
    • Azure Resource Manager Verbindung: Wählen Sie das entsprechende Azure-Abonnement aus.
    • Skripttyp: Wählen Sie PowerShell Core aus.
    • Skriptspeicherort: Wählen Sie Inline-Skript aus.
    • Inlineskript: Geben Sie az batch application package create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName) --version $(batchApplicationVersion) --package-file=$(System.DefaultWorkingDirectory)/$(Release.Artifacts.<AzureBuildArtifactSourceAlias>.BuildId).zipein. Ersetzen Sie den Platzhalter <AzureBuildArtifactSourceAlias> durch den Alias der Buildquelle, den Sie zuvor notiert haben.

    Hinweis

    Die Versionsnummer des Anwendungspakets wird auf eine Variable festgelegt. Die Variable ermöglicht das Überschreiben früherer Versionen des Pakets und ermöglicht es Ihnen, die Paketversion manuell zu steuern, die an Azure Batch verschoben wurde.

Release erstellen und ausführen

  1. Wenn Sie alle Schritte erstellt haben, wählen Sie oben auf der Pipelineseite "Speichern" und dann "OK" aus.

  2. Wählen Sie oben auf der Seite " Release erstellen " aus.

  3. Um den Liveversionsstatus anzuzeigen, wählen Sie oben auf der Seite den Link aus, der besagt, dass die Version erstellt wurde.

  4. Um die Protokollausgabe des Agenten anzuzeigen, bewegen Sie den Mauszeiger auf die Phase, und wählen Sie dann die Schaltfläche Logs aus.

    Screenshot, der den Status der Version zeigt.

Testen der Umgebung

Vergewissern Sie sich nach der Einrichtung der Umgebung, dass die folgenden Tests erfolgreich ausgeführt werden. Ersetzen Sie die Platzhalter durch die Werte Ihrer Ressourcengruppe und Ihres Batch-Kontos.

Mit dem Batchkonto verbinden

Stellen Sie mithilfe von Azure CLI über eine Eingabeaufforderung eine Verbindung mit dem neuen Batchkonto her.

  1. Melden Sie sich mit az login bei Ihrem Azure-Konto an und folgen Sie den Anweisungen, um sich zu authentifizieren.
  2. Authentifizieren Sie das Batchkonto mit az batch account login -g <resourceGroup> -n <batchAccount>.

Auflisten der verfügbaren Anwendungen

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

Überprüfen, ob der Pool gültig ist

az batch pool list

Notieren Sie sich in der Befehlsausgabe den Wert von currentDedicatedNodes, um ihn im nächsten Test anzupassen.

Ändern der Größe des Pools

Führen Sie den folgenden Befehl aus, um die Größe des Pools zu ändern, sodass Computeknoten für Auftrags- und Aufgabentests verfügbar sind. Ersetzen Sie den Platzhalter <poolName> durch den Wert Ihres Poolnamens und den Platzhalter <targetNumber> durch eine Zahl, die größer ist als der Wert currentDedicatedNodes aus der vorherigen Befehlsausgabe. Überprüfen Sie den Status, indem Sie den Befehl az batch pool list ausführen, bis die Größenänderung abgeschlossen ist und die Zielanzahl der Knoten angezeigt wird.

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

Nächste Schritte

In diesen Lernprogrammen erfahren Sie, wie Sie mit einem Batchkonto über eine einfache Anwendung interagieren.

  • Last updated on