Verwenden von Azure Pipelines zum Erstellen und Bereitstellen einer HPC-Lösung
Azure DevOps-Tools können das Erstellen und Testen von HPC-Lösungen (High Performance Computing) von Azure Batch automatisieren. Azure Pipelines bietet moderne Continuous Integration- (CI) und Continuous Deployment-Prozesse (CD) zum Erstellen, Bereitstellen, Testen und Überwachen von Software. Diese Prozesse beschleunigen die Auslieferung Ihrer Software, sodass Sie sich auf den Code konzentrieren können, anstatt sich um die Infrastruktur und sonstige Abläufe kümmern zu müssen.
In diesem Artikel wird gezeigt, wie Sie CI/CD-Prozesse mithilfe von Azure Pipelines mit Azure Resource Manager-Vorlagen (ARM-Vorlagen) zur Bereitstellung von HPC-Lösungen in Azure Batch einrichten. Das Beispiel erstellt eine Build- und Releasepipeline, um eine Azure Batch-Infrastruktur bereitzustellen und ein Anwendungspaket zu veröffentlichen. Das folgende Diagramm zeigt den allgemeinen Bereitstellungsablauf, sofern der Code lokal entwickelt wird:
Voraussetzungen
Damit Sie den Schritten in diesem Artikel folgen können, benötigen Sie Folgendes:
Eine Azure DevOps-Organisation und ein Azure DevOps-Projekt mit einem in der Organisation erstellten Azure Repos-Repository. Sie müssen über die Rollen Projektadministrator, Buildadministrator und Releaseadministrator im Azure DevOps-Projekt verfügen.
Ein aktives Azure-Abonnement mit der Rolle Besitzer oder einer anderen Rolle, die Funktionen zur Rollenzuweisung umfasst. Weitere Informationen finden Sie unter Grundlegendes zu Azure-Rollenzuweisungen.
Ein grundlegendes Verständnis der Quellcodeverwaltung und ARM-Vorlagensyntax.
Vorbereiten der Lösung
Das Beispiel in diesem Artikel verwendet mehrere ARM-Vorlagen und eine bestehende Open-Source-Anwendung zur Videoverarbeitung, FFmpeg. Sie können diese Ressourcen kopieren oder herunterladen und in Ihr Azure Repos-Repository pushen.
Wichtig
In diesem Beispiel wird Windows-Software auf Windows-basierten Batch-Knoten bereitgestellt. Azure Pipelines, ARM-Vorlagen und Batch unterstützen auch Linux-Software und -Knoten vollständig.
Grundlegendes zu ARM-Vorlagen
Drei Funktionsvorlagen, die Einheiten oder Modulen ähneln, implementieren bestimmte Funktionseinheiten. Eine End-to-End-Lösungsvorlage stellt dann die zugrunde liegenden Funktionsvorlagen bereit. Mit dieser verknüpften Vorlagenstruktur kann jede Funktionsvorlage einzeln getestet und in allen Lösungen wieder verwendet werden.
Ausführliche Informationen zu Vorlagen finden Sie im Referenzhandbuch für Resource Manager-Vorlagen für Microsoft.Batch-Ressourcentypen.
Speicherkontovorlage
Speichern Sie den folgenden Code in einer Datei namens storageAccount.json. Diese Vorlage definiert ein Azure Storage-Konto, das erforderlich ist, um die Anwendung für das Batch-Konto bereitzustellen.
{
"$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'))]"
}
}
}
Batch-Kontovorlage
Speichern Sie den folgenden Code in einer Datei namens batchAccount.json. Diese Vorlage definiert ein Batch-Konto. Das Azure Batch-Konto fungiert als Plattform zum Ausführen 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": {}
}
Batch-Poolvorlage
Speichern Sie den folgenden Code in einer Datei namens batchAccountPool.json. Mit dieser Vorlage werden ein Knotenpool und Knoten im Batch-Konto erstellt.
{
"$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": {}
}
Orchestratorvorlage
Speichern Sie den folgenden Code in einer Datei namens deployment.json. Diese letzte Vorlage dient als Orchestrator für die 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 Definitionsdatei für den YAML-Build in Ihr Azure Repos-Repository hoch.
Laden Sie die vier ARM-Vorlagen in einen arm-templates-Ordner in Ihrem Repository hoch.
Für das Anwendungspaket laden Sie die Windows 64-Bit-Version von FFmpeg 4.3.1 herunter, extrahieren sie und laden sie in einen hpc-application-Ordner in Ihrem Repository hoch.
Für die Builddefinition speichern Sie die folgende Definition als Datei namens hpc-app.build.yml, und laden Sie sie in einen pipelines-Ordner in Ihrem 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 das Einrichten Ihres Repositorys abgeschlossen haben, sollte die Ordnerstruktur die folgenden Hauptabschnitte enthalten:
- Ein arm-templates-Ordner, der die ARM-Vorlagen enthält.
- Ein hpc-application-Ordner, der ffmpeg enthält.
- Ein pipelines-Ordner, der die Definitionsdatei für den YAML-Build für die Buildpipeline enthält.
Hinweis
Dieses Beispiel für eine Codebasisstruktur zeigt, dass Sie Anwendung, Infrastruktur und Pipelinecode im selben Repository speichern können.
Erstellen der Azure-Pipeline
Nachdem Sie das Quellcoderepository 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 normalerweise Tests aus, um den Code zu überprüfen und Teile der Software zu erstellen. Die Anzahl und die Art der Tests sowie alle anderen Aufgaben, die Sie ausführen, hängen von Ihrer Gesamtstrategie für Build und Release ab.
Erstellen der Buildpipeline
In diesem Abschnitt erstellen Sie eine YAML-Buildpipeline für die Arbeit mit der ffmpeg-Software, die über das Batch-Konto ausgeführt wird.
Wählen Sie im linken Navigationsbereich Ihres Azure DevOps-Projekts Pipelines und anschließend Neue Pipeline aus.
Wählen Sie auf dem Bildschirm Wo befindet sich Ihr Code? die Option Azure Repos Git aus.
Wählen Sie auf dem Bildschirm Repository auswählen Ihr Repository aus.
Hinweis
Sie können eine Buildpipeline auch 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 Definieren Ihrer klassischen Pipeline.
Wählen Sie auf dem Bildschirm Pipeline konfigurieren die Option Vorhandene Azure Pipelines-YAML-Datei aus.
Wählen Sie auf dem Bildschirm Vorhandene YAML-Datei auswählen die Datei hpc-app.build.yml aus Ihrem Repository und dann Weiter aus.
Überprüfen Sie auf dem Bildschirm Pipeline-YAML überprüfen die Buildkonfiguration, und wählen Sie dann Ausführen oder das Dropdownsymbol neben Ausführen sowie die Option Speichern aus. Diese Vorlage ermöglicht Continuous Integration, sodass der Build automatisch ausgelöst wird, wenn ein neuer Commit für das Repository die im Build festgelegten Bedingungen erfüllt.
Sie können Live-Updates für den Buildstatus anzeigen. Um Buildergebnisse anzuzeigen, wählen Sie die entsprechende Ausführung aus Ihrer Builddefinition in Azure Pipelines aus.
Hinweis
Wenn Sie eine Clientanwendung zum Ausführen der HPC-Lösung verwenden, müssen Sie eine separate Builddefinition für diese Anwendung erstellen. Schrittanleitungen finden Sie in der Dokumentation zu Azure Pipelines.
Erstellen der Releasepipeline
Sie verwenden eine Releasepipeline von Azure Pipelines, um Ihre Anwendung und die zugrunde liegende Infrastruktur bereitzustellen. Releasepipelines ermöglichen CD (Continuous Deployment) und automatisieren Ihren Releaseprozess. Es gibt mehrere Schritte zum Bereitstellen Ihrer Anwendung und der zugrunde liegenden Infrastruktur.
Die verknüpften Vorlagen für diese Lösung müssen über einen öffentlichen HTTP- oder HTTPS-Endpunkt zugänglich sein. Dieser Endpunkt könnte ein GitHub-Repository, ein Azure Blob Storage-Konto oder ein anderer Speicherort sein. Um sicherzustellen, dass die hochgeladenen Vorlagenartefakte sicher bleiben, halten Sie sie in einem privaten Modus, aber verwenden Sie für den Zugriff eine Art SAS-Token (Shared Access Signature).
Das folgende Beispiel veranschaulicht die Bereitstellung einer Infrastruktur und Anwendung mit Vorlagen aus einem Azure Storage-Blob.
Einrichten der Pipeline
Wählen Sie in Ihrem Azure DevOps-Projekt im linken Navigationsbereich Pipelines>Releases aus.
Wählen Sie auf dem nächsten Bildschirm Neu>Neue Releasepipeline aus.
Wählen Sie auf dem Bildschirm Vorlage auswählen die Option Leerer Auftrag aus, und schließen Sie dann den Bildschirm Stage.
Wählen Sie Neue Releasepipeline oben auf der Seite, und benennen Sie die Pipeline in etwas, das für Ihre Pipeline relevant ist, z. B. Azure Batch und Pool bereitstellen.
Wählen Sie im Abschnitt Artefakte die Option Hinzufügen aus.
Wählen Sie auf dem Bildschirm Artefakt hinzufügen die Option Build und dann Ihre Buildpipeline aus, um die Ausgabe für die HPC-Anwendung zu erhalten.
Hinweis
Sie können einen Quellalias erstellen oder den Standardwert akzeptieren. Notieren Sie sich den Wert für Quellalias, da Sie ihn zum Erstellen von Aufgaben in der Releasedefinition benötigen.
Wählen Sie Hinzufügen.
Wählen Sie auf der Pipelineseite Hinzufügen neben Artefakte aus, um einen Link zu einem weiteren Artefakt, Ihrem Azure Repos-Repository, zu erstellen. Dieser Link ist erforderlich, um auf die ARM-Vorlagen in Ihrem Repository zuzugreifen. ARM-Vorlagen müssen nicht kompiliert werden, sodass Sie sie nicht durch eine Buildpipeline pushen müssen.
Hinweis
Notieren Sie sich auch hier den Wert für Quellalias, den Sie später verwenden werden.
Wählen Sie die Registerkarte Variablen aus. Erstellen Sie die folgenden Variablen in Ihrer Pipeline, damit Sie die gleichen Informationen nicht in mehreren Aufgaben erneut eingeben müssen.
Name Wert applicationStorageAccountName Name für das Speicherkonto, das die Binärdateien der HPC-Anwendung enthält. batchAccountApplicationName Name für die Anwendung im Batch-Konto. batchAccountName Name für das Batch-Konto. batchAccountPoolName Name für den Pool von virtuellen Computern (VMs), der die Verarbeitung durchführen soll. batchApplicationId Eindeutige ID für die Batch-Anwendung im Format: /subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^/providers/Microsoft.Batch/batchAccounts/<batchAccountName>^/applications/<batchAccountApplicationName>.
Ersetzen Sie den Platzhalter<subscriptionId>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 Batch-Anwendung, in diesem Fall 4.3.1. location Azure-Region für die bereitzustellenden Ressourcen. resourceGroupName Name für die Ressourcengruppe, in der Ressourcen bereitgestellt werden sollen. storageAccountName Name des Speicherkontos, in dem die verknüpften ARM-Vorlagen gespeichert werden. StorageContainerSasToken $(<referenceName>.StorageContainerSasToken). Ersetzen Sie den Platzhalter<referenceNamedurch den Wert für Referenzname, den Sie im Abschnitt Ausgabevariablen des folgenden Schritts Azure-Dateikopiervorgang konfigurieren.StorageContainerUri $(<referenceName>.StorageContainerUri). Ersetzen Sie den Platzhalter<referenceName>durch den Wert für Referenzname, den Sie im Abschnitt Ausgabevariablen des Schritts „Azure-Dateikopiervorgang“ konfigurieren.
Wählen Sie die Registerkarte Aufgaben und dann Agent-Auftrag aus.
Wählen Sie auf dem Bildschirm Agent-Auftrag unter Agent-Pool die Option Azure Pipelines aus.
Wählen Sie unter Agent-Spezifikation die Option windows-latest aus.
Hinzufügen von Aufgaben
Erstellen Sie sechs Aufgaben für Folgendes:
- 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 Batch-Konto und die erforderlichen Abhängigkeiten bereit.
- Erstellen Sie eine Anwendung im Batch-Konto.
- Laden Sie das Paket mit der Anwendung in das Batch-Konto hoch.
Für jede neue Aufgabe, die durch die folgenden Schritten angegeben werden:
Wählen Sie das Symbol + neben Agent-Auftrag im linken Bereich aus.
Suchen Sie im rechten Bereich nach der angegebenen Aufgabe und wählen Sie diese aus.
Fügen Sie die Eigenschaften hinzu oder wählen Sie sie aus, um die Aufgabe zu konfigurieren.
Wählen Sie Hinzufügen.
Erstellen Sie die Aufgaben wie folgt:
Wählen Sie die Aufgabe Pipelineartefakt herunterladen aus, und legen Sie die folgenden Eigenschaften fest:
- Anzeigename: Geben Sie ApplicationPackage auf Agent herunterladen ein.
- Artefaktname: Geben Sie hpc-application ein.
- Zielverzeichnis: Geben Sie
$(System.DefaultWorkingDirectory)ein.
Erstellen Sie ein Azure Storage-Konto, um Ihre ARM-Vorlagen zu speichern. Sie könnten ein bestehendes Speicherkonto verwenden, aber um dieses eigenständige Beispiel und die Isolation der Inhalte zu unterstützen, erstellen Sie ein dediziertes Speicherkonto.
Wählen Sie die Aufgabe ARM-Vorlagenbereitstellung: Ressourcengruppenbereich aus, und legen Sie die folgenden Eigenschaften fest:
- Anzeigename: Geben Sie Speicherkonto für ARM-Vorlagen 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. - Speicherort: Geben Sie
$(location)ein. - Vorlage: Geben Sie
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.jsonein. Ersetzen Sie den Platzhalter<AzureRepoArtifactSourceAlias>durch den Quellalias für das Repository, den Sie zuvor notiert haben. - Vorlagenparameter überschreiben: Geben Sie
-accountName $(storageAccountName)ein.
Laden Sie die Artefakte aus der Quellcodeverwaltung in das Speicherkonto hoch. Ein Teil dieser Azure-Dateikopiervorgang-Aufgabe gibt den Container-URI des Speicherkontos und das SAS-Token in einer Variablen aus, sodass sie in späteren Schritten wiederverwendet werden können.
Wählen Sie die Azure-Dateikopiervorgang-Aufgabe aus, und legen Sie die folgenden Eigenschaften fest:
- Anzeigename: Geben Sie AzureBlob-Dateikopie ein.
- Quelle: Geben Sie
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/ein. Ersetzen Sie den Platzhalter<AzureRepoArtifactSourceAlias>durch den Quellalias für das Repository, 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. - Containername: Geben Sie Vorlagen ein.
- Referenzname: Erweitern Sie Ausgabevariablen, und geben Sie dann ffmpeg ein.
Hinweis
Wenn dieser Schritt fehlerhaft ist, stellen Sie sicher, dass Ihre Azure DevOps-Organisation die Rolle Mitwirkender an Storage-Blob im Speicherkonto aufweist.
Stellen Sie die ARM-Vorlage des Orchestrators bereit, um das Batch-Konto und den Pool zu erstellen. Diese Vorlage enthält Parameter für den Storage-Kontocontainer-URI und das SAS-Token. Die in der ARM-Vorlage benötigten Variablen befinden sich im Abschnitt „Variablen“ der Releasedefinition und wurden von der Aufgabe „AzureBlob-Dateikopie“ festgelegt.
Wählen Sie die Aufgabe ARM-Vorlagenbereitstellung: Ressourcengruppenbereich 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. - Speicherort: Geben Sie
$(location)ein. - Speicherort der Vorlage: Wählen Sie URL der Datei aus.
- Vorlagenlink: Geben Sie
$(StorageContainerUri)arm-templates/deployment.json$(StorageContainerSasToken)ein. - Vorlagenparameter überschreiben: Geben Sie
-StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName)ein.
Eine gängige Praxis ist die Verwendung von Azure Key Vault-Aufgaben. Wenn für den mit Ihrem Azure-Abonnement verbundenen Dienstprinzipal eine entsprechende Zugriffsrichtlinie festgelegt ist, kann er Geheimnisse aus Key Vault herunterladen und als Variable in Ihrer Pipeline verwenden. Der Name des Geheimnisses wird mit dem zugeordneten Wert festgelegt. Beispielsweise könnten Sie auf ein Geheimnis von sshPassword mit $(sshPassword) in der Releasedefinition verweisen.
Rufen Sie die 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 im Azure Batch-Konto erstellen 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.
Rufen Sie die Azure CLI auf, um zugehörige 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 Paket in das Azure Batch-Konto hochladen 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 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 Quellalias für den Build, den Sie zuvor notiert haben.
Hinweis
Die Versionsnummer des Anwendungspakets wird auf eine Variable festgelegt. Mit dieser Variable können Sie frühere Versionen des Pakets überschreiben und die Version des Pakets, die zu Azure Batch gepusht wird, manuell steuern.
Erstellen und Ausführen des Release
Wenn Sie alle Schritte erstellt haben, wählen Sie Speichern oben auf der Pipelineseite und dann OK aus.
Wählen Sie Release erstellen oben auf der Seite aus.
Um den Livestatus für das Release anzuzeigen, klicken Sie auf den Link oben auf der Seite, der besagt, dass das Release erstellt wurde.
Um die Protokollausgabe des Agents anzuzeigen, bewegen Sie den Mauszeiger über die Stage, und wählen Sie dann die Schaltfläche Protokolle aus.
Testen der Umgebung
Sobald die Umgebung eingerichtet ist, stellen Sie sicher, dass die folgenden Tests erfolgreich ausgeführt werden. Ersetzen Sie die Platzhalter durch die Werte Ihrer Ressourcengruppe und Ihres Batch-Kontos.
Herstellen einer Verbindung mit dem Batch-Konto
Stellen Sie mithilfe der Azure CLI über eine Eingabeaufforderung eine Verbindung mit dem neuen Batch-Konto her.
- Melden Sie sich mit
az loginbei Ihrem Azure-Konto an, und führen Sie die Anweisungen aus, um sich zu authentifizieren. - Authentifizieren Sie das Batch-Konto mit
az batch account login -g <resourceGroup> -n <batchAccount>:
Auflisten der verfügbaren Anwendungen
az batch application list -g <resourceGroup> -n <batchAccount>
Überprüfen Sie, ob der Pool gültig ist.
az batch pool list
Notieren Sie in der Befehlsausgabe den Wert von currentDedicatedNodes, den Sie im nächsten Test anpassen müssen.
Ä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 das Testen von Aufträgen und Aufgaben zur Verfügung stehen. Ersetzen Sie den Platzhalter <poolName> durch den Wert Ihres Poolnamens und den Platzhalter <targetNumber> durch eine Zahl, die größer ist als die 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 Tutorials finden Sie weitere Informationen zur Interaktion mit einem Batch-Konto über eine einfache Anwendung.