Utilizar o Azure Pipelines para criar e implementar uma solução HPC
As ferramentas do Azure DevOps podem automatizar a criação e teste Azure Batch soluções de computação de alto desempenho (HPC). O Azure Pipelines fornece processos de integração contínua (CI) e implementação contínua (CD) modernos para criar, implementar, testar e monitorizar software. Estes processos aceleram a entrega de software, permitindo-lhe concentrar-se no seu código em vez de suportar a infraestrutura e as operações.
Este artigo mostra como configurar processos de CI/CD com o Azure Pipelines com modelos de Resource Manager do Azure (modelos arm) para implementar soluções HPC no Azure Batch. O exemplo cria um pipeline de compilação e versão para implementar uma infraestrutura Azure Batch e lançar um pacote de aplicações. O diagrama seguinte mostra o fluxo de implementação geral, partindo do princípio de que o código é desenvolvido localmente:
Pré-requisitos
Para seguir os passos neste artigo, precisa de:
Uma organização do Azure DevOps e um projeto do Azure DevOps com um repositório de Repositórios do Azure criado na organização. Tem de ter funções de Administrador de Projeto, Administrador de Compilação e Administrador de Versão no projeto de DevOps do Azure.
Uma subscrição ativa do Azure com o Proprietário ou outra função que inclua capacidades de atribuição de funções. Para obter mais informações, veja Compreender as atribuições de funções do Azure.
Uma compreensão básica do controlo de origem e da sintaxe do modelo do ARM.
Preparar a solução
O exemplo neste artigo utiliza vários modelos arm e uma aplicação de processamento de vídeo open source existente, FFmpeg. Pode copiar ou transferir estes recursos e enviá-los para o repositório de Repositórios do Azure.
Importante
Este exemplo implementa software Windows em nós do Batch baseados no Windows. Os Pipelines do Azure, os modelos arm e o Batch também suportam totalmente software e nós do Linux.
Compreender os modelos do ARM
Três modelos de capacidade, semelhantes a unidades ou módulos, implementam partes específicas da funcionalidade. Em seguida, um modelo de solução ponto a ponto implementa os modelos de capacidade subjacentes. Esta estrutura de modelos ligados permite que cada modelo de capacidade seja testado individualmente e reutilizado em várias soluções.
Para obter informações detalhadas sobre os modelos, veja o guia de referência de modelos Resource Manager para tipos de recursos Microsoft.Batch.
Modelo de conta de armazenamento
Guarde o seguinte código como um ficheiro com o nome storageAccount.json. Este modelo define uma conta de Armazenamento do Azure, que é necessária para implementar a aplicação na conta do 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'))]"
}
}
}
Modelo de conta do Batch
Guarde o seguinte código como um ficheiro com o nome batchAccount.json. Este modelo define uma conta do Batch. A conta do Batch funciona como uma plataforma para executar aplicações em conjuntos de nós.
{
"$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": {}
}
Modelo de conjunto do Batch
Guarde o seguinte código como um ficheiro com o nome batchAccountPool.json. Este modelo cria um conjunto de nós e nós na conta do 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": {}
}
Modelo do Orchestrator
Guarde o seguinte código como um ficheiro com o nome deployment.json. Este modelo final funciona como um orquestrador para implementar os três modelos de capacidade subjacentes.
{
"$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": {}
}
Configurar o seu repositório
Carregue os modelos arm, a aplicação FFmpeg e um ficheiro de definição de compilação YAML para o seu repositório de Repositórios do Azure.
Carregue os quatro modelos arm para uma pasta arm-templates no seu repositório.
Para o pacote de aplicações, transfira e extraia a versão de 64 bits do FFmpeg 4.3.1 do Windows e carregue-a para uma pasta hpc-application no seu repositório.
Para a definição de compilação, guarde a seguinte definição como um ficheiro com o nome hpc-app.build.yml e carregue-a para uma pasta de pipelines no seu repositório.
# 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'
Quando terminar de configurar o repositório, a estrutura de pastas deverá ter as seguintes secções principais:
- Uma pasta arm-templates que contém os modelos do ARM.
- Uma pasta hpc-application que contém ffmpeg.
- Uma pasta de pipelines que contém o ficheiro de definição de compilação YAML para o pipeline de compilação.
Nota
Esta estrutura de base de código de exemplo demonstra que pode armazenar código de aplicação, infraestrutura e pipeline no mesmo repositório.
Criar o pipeline do Azure
Depois de configurar o repositório de código fonte, utilize o Azure Pipelines para implementar um pipeline de compilação, teste e implementação para a sua aplicação. Nesta fase de um pipeline, normalmente executa testes para validar código e compilar partes do software. O número e os tipos de testes, bem como quaisquer outras tarefas que executar, dependem da sua estratégia geral de compilação e lançamento.
Criar o pipeline de compilação
Nesta secção, vai criar um pipeline de compilação YAML para trabalhar com o software ffmpeg que é executado na conta do Batch.
No projeto do Azure DevOps, selecione Pipelines no painel de navegação esquerdo e, em seguida, selecione Novo pipeline.
No ecrã Onde está o código , selecione Repositórios do Azure Git.
No ecrã Selecionar um repositório , selecione o seu repositório.
Nota
Também pode criar um pipeline de compilação com um estruturador visual. Na página Novo pipeline , selecione Utilizar o editor clássico. Pode utilizar um modelo YAML no estruturador visual. Para obter mais informações, veja Definir o pipeline Clássico.
No ecrã Configurar o pipeline, selecioneFicheiro YAML de Pipelines do Azure Existente.
No ecrã Selecionar um ficheiro YAML existente , selecione o ficheiro hpc-app.build.yml no seu repositório e, em seguida, selecione Continuar.
No ecrã Rever o YAML do pipeline , reveja a configuração da compilação e, em seguida, selecione Executar ou selecione o acento circunflexo pendente junto a Executar e selecione Guardar. Este modelo permite a integração contínua, pelo que a compilação é acionada automaticamente quando uma nova consolidação para o repositório cumpre as condições definidas na compilação.
Pode ver atualizações do progresso da compilação em direto. Para ver os resultados da compilação, selecione a execução adequada na definição de compilação no Azure Pipelines.
Nota
Se utilizar uma aplicação cliente para executar a sua solução de HPC, terá de criar uma definição de compilação separada para essa aplicação. Para obter guias de procedimentos, veja a documentação do Azure Pipelines .
Criar o pipeline de Versão
Utilize um pipeline de Versão dos Pipelines do Azure para implementar a sua aplicação e a infraestrutura subjacente. Os pipelines de versão ativam o CD e automatizam o processo de lançamento. Existem vários passos para implementar a aplicação e a infraestrutura subjacente.
Os modelos ligados para esta solução têm de estar acessíveis a partir de um ponto final HTTP ou HTTPS público. Este ponto final pode ser um repositório do GitHub, uma conta Armazenamento de Blobs do Azure ou outra localização de armazenamento. Para garantir que os artefactos de modelo carregados permanecem seguros, mantenha-os num modo privado, mas aceda aos mesmos através de algum tipo de token de assinatura de acesso partilhado (SAS).
O exemplo seguinte demonstra como implementar uma infraestrutura e uma aplicação com modelos de um blob de Armazenamento do Azure.
Configurar o pipeline
No projeto de DevOps do Azure, selecione Versões> dePipelines no painel de navegação esquerdo.
No ecrã seguinte, selecione Novo>pipeline de versão.
No ecrã Selecionar um modelo, selecioneTarefa vazia e, em seguida, feche o ecrã Fase .
Selecione Novo pipeline de versão na parte superior da página e mude o nome do pipeline para algo relevante para o pipeline, como Implementar Azure Batch + Conjunto.
Na secção Artefactos , selecione Adicionar.
No ecrã Adicionar um artefacto , selecione Compilar e, em seguida, selecione o pipeline de compilação para obter a saída da aplicação HPC.
Nota
Pode criar um alias de Origem ou aceitar a predefinição. Tome nota do valor do alias de Origem, uma vez que precisa dele para criar tarefas na definição de versão.
Selecione Adicionar.
Na página do pipeline, selecione Adicionar junto a Artefactos para criar uma ligação para outro artefacto, o repositório de Repositórios do Azure. Esta ligação é necessária para aceder aos modelos do ARM no seu repositório. Os modelos do ARM não precisam de compilação, pelo que não precisa de os emitir através de um pipeline de compilação.
Nota
Repare novamente no valor do alias de origem para utilizar mais tarde.
Selecione o separador Variáveis . Crie as seguintes variáveis no pipeline para não ter de reintroduzir as mesmas informações em várias tarefas.
Name Valor applicationStorageAccountName Nome da conta de armazenamento para conter os binários da aplicação HPC. batchAccountApplicationName Nome da aplicação na conta do Batch. batchAccountName Nome da conta do Batch. batchAccountPoolName Nome do conjunto de máquinas virtuais (VMs) para efetuar o processamento. batchApplicationId ID exclusivo para a aplicação Batch, do formulário: /subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^/providers/Microsoft.Batch/batchAccounts/<batchAccountName>^/applications/<batchAccountApplicationName>.
Substitua o<subscriptionId>marcador de posição pelo seu ID de subscrição do Azure e os outros marcadores de posição pelos valores que definiu para as outras variáveis nesta lista.batchApplicationVersion Versão semântica da sua aplicação Batch, neste caso 4.3.1. localização Região do Azure para os recursos a implementar. resourceGroupName Nome do grupo de recursos no qual implementar recursos. storageAccountName Nome da conta de armazenamento para conter os modelos do ARM ligados. StorageContainerSasToken $(<referenceName>.StorageContainerSasToken). Substitua o<referenceNamemarcador de posição pelo valor de Nome de referência que configurar na secção Variáveis de Saída do seguinte passo cópia de ficheiros do Azure .StorageContainerUri $(<referenceName>.StorageContainerUri). Substitua o<referenceName>marcador de posição pelo valor nome de referência que configurar na secção Variáveis de Saída do passo Cópia de Ficheiros do Azure.
Selecione o separador Tarefas e, em seguida, selecione Tarefa do agente.
No ecrã Tarefa do agente , em Conjunto de agentes, selecione Pipelines do Azure.
Em Especificação do Agente, selecione windows-latest.
Adicionar tarefas
Crie seis tarefas para:
- Transfira os ficheiros ffmpeg zipados.
- Implemente uma conta de armazenamento para alojar os modelos aninhados do ARM.
- Copie os modelos do ARM para a conta de armazenamento.
- Implemente a conta do Batch e as dependências necessárias.
- Crie uma aplicação na conta do Batch.
- Carregue o pacote de aplicação para a conta do Batch.
Para cada nova tarefa que os seguintes passos especificam:
Selecione o + símbolo junto a Tarefa do agente no painel esquerdo.
Procure e selecione a tarefa especificada no painel direito.
Adicione ou selecione as propriedades para configurar a tarefa.
Selecione Adicionar.
Crie as tarefas da seguinte forma:
Selecione a tarefa Transferir Artefactos de Pipeline e defina as seguintes propriedades:
- Nome a apresentar: introduza Transferir ApplicationPackage para o Agente.
- Nome do artefacto: introduza hpc-application.
- Diretório de destino: introduza
$(System.DefaultWorkingDirectory).
Crie uma conta de Armazenamento do Azure para armazenar os seus modelos do ARM. Pode utilizar uma conta de armazenamento existente, mas para suportar este exemplo autónomo e isolamento de conteúdo, crie uma conta de armazenamento dedicada.
Selecione a tarefa implementação do Modelo arm: Âmbito do Grupo de Recursos e defina as seguintes propriedades:
- Nome a apresentar: Introduza Implementar conta de armazenamento para modelos arm.
- Ligação Resource Manager do Azure: selecione a subscrição do Azure adequada.
- Subscrição: Selecione a subscrição do Azure adequada.
- Ação: selecione Criar ou atualizar grupo de recursos.
- Grupo de recursos: introduza
$(resourceGroupName). - Localização: introduza
$(location). - Modelo: introduza
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.json. Substitua o<AzureRepoArtifactSourceAlias>marcador de posição pelo alias de Origem do repositório que anotou anteriormente. - Substituir parâmetros de modelo: introduza
-accountName $(storageAccountName).
Carregue os artefactos do controlo de origem para a conta de armazenamento. Parte desta tarefa de Cópia de Ficheiros do Azure produz o URI e o token de SAS do contentor da conta de armazenamento para uma variável, para que possam ser reutilizados em passos posteriores.
Selecione a tarefa Cópia de Ficheiros do Azure e defina as seguintes propriedades:
- Nome a apresentar: Introduza Cópia de Ficheiro do AzureBlob.
- Origem: Introduza
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/. Substitua o<AzureRepoArtifactSourceAlias>marcador de posição pelo alias de Origem do repositório que anotou anteriormente. - Subscrição do Azure: Selecione a subscrição do Azure adequada.
- Tipo de Destino: selecione Blob do Azure.
- Conta de Armazenamento RM: introduza
$(storageAccountName). - Nome do Contentor: introduza modelos.
- Nome da referência: expanda Variáveis de Saída e, em seguida, introduza ffmpeg.
Nota
Se este passo falhar, certifique-se de que a sua organização do Azure DevOps tem a função Contribuidor de Blobs de Armazenamento na conta de armazenamento.
Implemente o modelo arm do orquestrador para criar a conta e o conjunto do Batch. Este modelo inclui parâmetros para o URI de contentor da conta de armazenamento e o token de SAS. As variáveis necessárias no modelo do ARM são mantidas na secção de variáveis da definição de versão e foram definidas a partir da tarefa AzureBlob File Copy.
Selecione a tarefa implementação do Modelo arm: Âmbito do Grupo de Recursos e defina as seguintes propriedades:
- Nome a apresentar: Introduza Implementar Azure Batch.
- Ligação Resource Manager do Azure: selecione a subscrição do Azure adequada.
- Subscrição: Selecione a subscrição do Azure adequada.
- Ação: selecione Criar ou atualizar grupo de recursos.
- Grupo de recursos: introduza
$(resourceGroupName). - Localização: introduza
$(location). - Localização do modelo: selecione o URL do ficheiro.
- Ligação do modelo: Introduza
$(StorageContainerUri)arm-templates/deployment.json$(StorageContainerSasToken). - Substituir parâmetros de modelo: introduza
-StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName).
Uma prática comum é utilizar tarefas do Azure Key Vault. Se o principal de serviço ligado à sua subscrição do Azure tiver um conjunto de políticas de acesso adequado, pode transferir segredos de Key Vault e ser utilizado como uma variável no pipeline. O nome do segredo é definido com o valor associado. Por exemplo, pode referenciar um segredo de sshPassword com $(sshPassword) na definição de versão.
Chame a CLI do Azure para criar uma aplicação no Azure Batch.
Selecione a tarefa da CLI do Azure e defina as seguintes propriedades:
- Nome a apresentar: Introduza Criar aplicação na conta Azure Batch.
- Ligação Resource Manager do Azure: selecione a subscrição adequada do Azure.
- Tipo de Script: selecione PowerShell Core.
- Localização do Script: selecione Script inline.
- Script Inline: introduza
az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName).
Chame a CLI do Azure para carregar pacotes associados para a aplicação, neste caso, os ficheiros ffmpeg.
Selecione a tarefa da CLI do Azure e defina as seguintes propriedades:
- Nome a apresentar: Introduza Carregar pacote para Azure Batch conta.
- Ligação Resource Manager do Azure: selecione a subscrição adequada do Azure.
- Tipo de Script: selecione PowerShell Core.
- Localização do Script: selecione Script inline.
- Script Inline: introduza
az batch application package create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName) --version $(batchApplicationVersion) --package-file=$(System.DefaultWorkingDirectory)/$(Release.Artifacts.<AzureBuildArtifactSourceAlias>.BuildId).zip. Substitua o<AzureBuildArtifactSourceAlias>marcador de posição pelo alias de Origem de Compilação que anotou anteriormente.
Nota
O número da versão do pacote de aplicação está definido como uma variável. A variável permite substituir versões anteriores do pacote e permite-lhe controlar manualmente a versão do pacote enviada para Azure Batch.
Criar e executar a versão
Quando terminar de criar todos os passos, selecione Guardar na parte superior da página do pipeline e, em seguida, selecione OK.
Selecione Criar versão na parte superior da página.
Para ver o estado da versão em direto, selecione a ligação na parte superior da página que indica que a versão foi criada.
Para ver a saída de registo do agente, paire o cursor sobre o palco e, em seguida, selecione o botão Registos .
Testar o ambiente
Assim que o ambiente estiver configurado, confirme se os seguintes testes são executados com êxito. Substitua os marcadores de posição pelos valores do grupo de recursos e da conta do Batch.
Ligar à conta do Batch
Ligue-se à nova conta do Batch com a CLI do Azure a partir de uma linha de comandos.
- Inicie sessão na sua conta do Azure com
az logine siga as instruções para autenticar. - Autenticar a conta do Batch com
az batch account login -g <resourceGroup> -n <batchAccount>.
Listar as aplicações disponíveis
az batch application list -g <resourceGroup> -n <batchAccount>
Verifique se o conjunto é válido
az batch pool list
Na saída do comando, tenha em atenção o valor de currentDedicatedNodes a ajustar no próximo teste.
Redimensionar o conjunto
Execute o seguinte comando para redimensionar o conjunto para que existam nós de computação disponíveis para testes de tarefas e tarefas. Substitua o <poolName> marcador de posição pelo valor do nome do conjunto e o <targetNumber> marcador de posição por um número maior do que o currentDedicatedNodes da saída do comando anterior. Verifique o estado ao executar o az batch pool list comando até que o redimensionamento seja concluído e mostre o número de nós de destino.
az batch pool resize --pool-id <poolname> --target-dedicated-nodes <target number>
Passos seguintes
Veja estes tutoriais para saber como interagir com uma conta do Batch através de uma aplicação simples.