Usar o Azure Pipelines para compilar e implantar uma solução de HPC
As ferramentas do Azure DevOps podem automatizar a criação e o teste de soluções de computação de alto desempenho (HPC) do Lote do Azure. O Azure Pipelines fornece uma variedade de processos modernos de integração contínua (CI) e implantação contínua (CD) para criar, implantar, testar e monitorar software. Esses processos aceleram sua entrega de software, permitindo que você se concentre no código em vez de oferecer suporte à infraestrutura e às operações.
Este artigo mostra como configurar processos de CI/CD usando o Azure Pipelines com modelos do Azure Resource Manager (ARM) para implantar soluções de HPC no Lote do Azure. Neste exemplo, você criará um pipeline de build e lançamento para implantar uma infraestrutura do Lote do Azure e lançar um pacote de aplicativos. O diagrama a seguir mostra o fluxo de implantação geral, supondo que o código seja desenvolvido localmente:
Pré-requisitos
Para seguir as etapas deste artigo, você precisa ter:
Uma organização do Azure DevOps e um projeto do Azure DevOps com um repositório do Azure Repos criado na organização. Você deve ter funções de Administrador do Projeto, Administrador de Build e Administrador de Versão no projeto do Azure DevOps.
Uma assinatura ativa do Azure com a função Proprietário ou outra função que inclua habilidades de atribuição de função. Para obter mais informações, confira Entendendo as atribuições de função do Azure.
Uma compreensão básica do controle do código-fonte e da sintaxe de modelo do ARM.
Preparar a solução
O exemplo neste artigo usa vários modelos do ARM e um aplicativo de processamento de vídeo de software livre existente, FFmpeg. Você pode copiar ou baixar esses recursos e efetuar push deles para o seu repositório Azure Repos.
Importante
Este exemplo implanta software do Windows em nós em lote baseados no Windows. O Azure Pipelines, os modelos do ARM e o Lote também dão suporte total ao software e aos nós do Linux.
Entenda os modelos de ARM
Três modelos de funcionalidade, semelhantes a unidades ou módulos, implementam partes específicas da funcionalidade. Um modelo de solução de ponta a ponta implanta os modelos de funcionalidade subjacentes. Esta estrutura de modelo vinculada permite que cada modelo de funcionalidade seja testado e reutilizado individualmente em todas as soluções.
Para obter informações detalhadas sobre os modelos, confira o Guia de referência do modelo do Resource Manager para tipos de recurso do Microsoft.Batch.
Modelo de conta de armazenamento
Salve o seguinte código como um arquivo de nome storageAccount.json. Este modelo define uma conta de Armazenamento do Microsoft Azure, que é necessária para implantar o aplicativo na conta do Lote.
{
"$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 da conta do Lote
Salve o seguinte código como um arquivo de nome batchAccount.json. Este modelo define uma conta do Lote. A conta do Lote atua como uma plataforma para executar aplicativos em pools de nó.
{
"$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 pool do Lote
Salve o seguinte código como um arquivo de nome batchAccountPool.json. Este modelo cria um pool de nós e nós na conta do Lote.
{
"$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
Salve o código a seguir como um arquivo chamado deployment.json. Este modelo final atua como um orquestrador para implantar os três modelos de funcionalidade 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 seu repositório
Carregue os modelos do ARM, o aplicativo FFmpeg e um arquivo de definição de build YAML no repositório Azure Repos.
Carregue os quatro modelos do ARM em uma pasta arm-templates no repositório.
Para o pacote de aplicativos, baixe e extraia a versão do Windows de 64 bits do FFmpeg 4.3.1 e carregue-a em uma pasta hpc-application no repositório.
Para a definição de build, salve a definição a seguir como um arquivo chamado hpc-app.build.yml e carregue-a em uma pasta de pipelines em 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 seções principais:
- Uma pasta arm-templates que contém os modelos do ARM.
- Uma pasta hpc-application que contém ffmpeg.
- Uma pasta pipelines que contém o arquivo de definição de build YAML para o pipeline de build.
Observação
Este exemplo de estrutura de base de código demonstra que você pode armazenar o aplicativo, a infraestrutura e o código do pipeline no mesmo repositório.
Criar o pipeline do Azure
Depois de configurar o repositório de código-fonte, use o Azure Pipelines para implementar um pipeline de build, teste e implantação para o seu aplicativo. Neste estágio de um pipeline, você normalmente executa testes para validar o código e compilar partes do software. O número e os tipos de testes e outras tarefas que você executar dependerão da sua estratégia de build e lançamento geral.
Criar o pipeline de build
Nesta seção, você criará um pipeline de build YAML para trabalhar com o software ffmpeg executado na conta do Lote.
No seu projeto Azure DevOps, selecione Pipelines na navegação à esquerda e escolha Novo pipeline.
Na tela Onde está o seu código?, selecione Azure Repos Git .
Na tela Selecionar um repositório, selecione o seu repositório.
Observação
Você também pode criar um pipeline de build usando um designer visual. Na página Novo pipeline, selecione Usar o editor clássico. Você pode usar um modelo YAML no designer visual. Para obter mais informações, confira Definir seu pipeline Clássico.
Na tela Configurar o pipeline, selecione Arquivo YAML existente do Azure Pipelines.
Na tela Selecionar um arquivo YAML existente, selecione o arquivo hpc-app.build.yml no repositório e selecione Continuar.
Na tela Examinar o YAML do pipeline, examine a configuração de build e selecione Executar ou selecione o cursor suspenso ao lado de Executar e selecione Salvar. Este modelo permite a integração contínua, portanto, o build é disparado automaticamente quando uma nova confirmação no repositório atende às condições definidas no build.
Você pode exibir atualizações de progresso do build em tempo real. Para ver os resultados de build, selecione a execução apropriada na definição de build no Azure Pipelines.
Observação
Se você usar um aplicativo cliente para executar a sua solução de HPC, será necessário criar uma definição de build separada para esse aplicativo. Para obter guias de instruções, confira a documentação do Azure Pipelines.
Criar o pipeline de lançamento
Você usa um pipeline de lançamento do Azure Pipelines para implantar seu aplicativo e a infraestrutura subjacente. Os pipelines de lançamento habilitam o CD e automatizam o processo de lançamento. Há várias etapas para implantar seu aplicativo e a infraestrutura subjacente.
Os modelos vinculados para essa solução devem estar acessíveis de um ponto de extremidade HTTP ou HTTPS público. Esse ponto de extremidade pode ser um repositório no GitHub, uma conta de Armazenamento de Blobs do Azure ou outro local de armazenamento. Para garantir que os artefatos de modelo carregados permaneçam seguros, mantenha-os em um modo privado, mas acesse-os usando alguma forma de token SAS (assinatura de acesso compartilhado).
O exemplo a seguir demonstra como implantar uma infraestrutura e aplicativo usando modelos do Blob de Armazenamento do Microsoft Azure.
Configurar o pipeline
No projeto do Azure DevOps, selecione Pipelines>Lançamentos na navegação esquerda.
Na próxima tela, selecione Novo>Novo pipeline de lançamento.
Na tela Selecionar um modelo, selecione Trabalho vazio e feche a tela Estágio.
Selecione Novo pipeline de lançamento na parte superior da página e renomeie o pipeline para algo relevante para o seu pipeline, como Implantar Lote do Azure + Pool.
Na seção Artefatos, selecione Adicionar.
Na tela Adicionar um artefato, selecione Build e, em seguida, selecione o pipeline de Build para obter a saída para o aplicativo HPC.
Observação
Você pode criar um Alias de origem ou aceitar o padrão. Anote o valor do Alias de origem, pois você precisa dele para criar tarefas na definição de versão.
Selecione Adicionar.
Na página do pipeline, selecione Adicionar ao lado de Artefatos para criar um link para outro artefato, seu repositório Azure Repos. Esse link é necessário para acessar os modelos do ARM em seu repositório. Os modelos do ARM não precisam de compilação, portanto, você não precisa efetuar push deles por meio de um pipeline de build.
Observação
Observe novamente o valor do Alias de origem a ser usado posteriormente.
Selecione a guia Variáveis. Crie as variáveis a seguir em seu pipeline para que você não precise inserir novamente as mesmas informações em várias tarefas.
Nome Valor applicationStorageAccountName Nome da conta de armazenamento para armazenar os binários do aplicativo HPC. batchAccountApplicationName Nome do aplicativo na conta do Lote. batchAccountName Nome da conta do Lote. batchAccountPoolName Nome do pool de VMs (máquinas virtuais) para fazer o processamento. batchApplicationId ID exclusiva para o aplicativo do Lote, do formulário: /subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^/providers/Microsoft.Batch/batchAccounts/<batchAccountName>^
/applications/<batchAccountApplicationName>.
Substitua o espaço reservado<subscriptionId>pela ID da assinatura do Azure e os outros espaços reservados pelos valores definidos para as outras variáveis nesta lista.batchApplicationVersion Versão semântica do aplicativo do Lote, neste caso 4.3.1. local Região do Azure para implantar os recursos. resourceGroupName Nome do grupo de recursos no qual implantar os recursos. storageAccountName Nome da conta de armazenamento para conter os modelos do ARM vinculados. StorageContainerSasToken $(<referenceName>.StorageContainerSasToken). Substitua o espaço reservado<referenceNamepelo valor Nome de referência configurado na seção Variáveis de Saída da etapa de Cópia de Arquivo do Azure a seguir.StorageContainerUri $(<referenceName>.StorageContainerUri). Substitua o espaço reservado<referenceName>pelo valor Nome de referência configurado na seção Variáveis de Saída da etapa Cópia de Arquivo do Azure.
Selecione a guia Tarefas e, em seguida, selecione Trabalho do agente.
Na tela Trabalho do agente, em Pool de agentes, selecione Azure Pipelines.
Em Especificação do Agente, selecione windows-latest.
Adicionar tarefas
Crie seis tarefas para:
- Baixe os arquivos ffmpeg compactados.
- Implante uma conta de armazenamento para hospedar os modelos aninhados do ARM.
- Copie os modelos do ARM para a conta de armazenamento.
- Implante a conta do Lote e as dependências necessárias.
- Crie um aplicativo na conta do Lote.
- Carregue o pacote de aplicativos na conta do Lote.
Para cada nova tarefa que as seguintes etapas especificam:
Selecione o símbolo + ao lado do Trabalho do agente no painel esquerdo.
Pesquise e selecione a tarefa especificada no painel direito.
Adicione ou selecione as propriedades para configurar a tarefa.
Selecione Adicionar.
Crie as tarefas da seguinte maneira:
Selecione a tarefa Baixar o Pipeline Artifacts e defina as seguintes propriedades:
- Nome de exibição: Insira Download ApplicationPackage to Agent.
- Nome do artefato: insira hpc-application.
-
Diretório de destino: Insira
$(System.DefaultWorkingDirectory).
Crie uma conta de Armazenamento do Microsoft Azure para armazenar seus modelos do ARM. Você poderia usar uma conta de armazenamento existente, mas, para dar suporte a esse exemplo autocontido e ao isolamento de conteúdo, crie uma conta de armazenamento dedicada.
Selecione a tarefa Implantação de modelo do ARM: escopo do Grupo de Recursos e defina as seguintes propriedades:
- Nome de exibição: Insira Implantar conta de armazenamento para modelos do ARM.
- Conexão do Azure Resource Manager: selecione a assinatura apropriada do Azure.
- Assinatura: selecione a assinatura do Azure apropriada
- Ação: selecione Criar ou Atualizar Grupo de Recursos.
-
Grupo de recursos: insira
$(resourceGroupName). -
Local: insira
$(location). -
Modelo: insira
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.json. Substitua o espaço reservado<AzureRepoArtifactSourceAlias>pelo alias de origem do repositório que você viu anteriormente. -
Substituir parâmetros de modelo: digite
-accountName $(storageAccountName).
Carregue os artefatos do controle do código-fonte na conta de armazenamento. Parte dessa tarefa de Cópia de Arquivo do Azure gera o URI do contêiner da conta de armazenamento e o token SAS para uma variável, para que eles possam ser reutilizados em etapas posteriores.
Adicione a tarefa Cópia de Arquivos do Azure e defina as seguintes propriedades:
- Nome de exibição: Insira Cópia de Arquivo do AzureBlob.
-
Origem: Insira
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/. Substitua o espaço reservado<AzureRepoArtifactSourceAlias>pelo alias de origem do repositório que você viu anteriormente. - Assinatura do Azure: selecione a assinatura do Azure apropriada.
- Tipo de Destino: escolha Blob do Azure.
-
Conta de Armazenamento do RM: Insira
$(storageAccountName). - Nome do Contêiner: Insira modelos.
- Nome da referência: Expanda Variáveis de Saída e insira ffmpeg.
Observação
Se essa etapa falhar, verifique se sua organização do Azure DevOps tem a função Colaborador de Blob de Armazenamento na conta de armazenamento.
Implante o modelo do ARM do orquestrador para criar a conta e o pool do Lote. Este modelo inclui parâmetros para o URI do contêiner da Conta de armazenamento e o token SAS. As variáveis necessárias no modelo do ARM são mantidas na seção variáveis da definição de versão e foram definidas da tarefa Cópia de Arquivo do AzureBlob.
Selecione a tarefa Implantação de modelo do ARM: escopo do Grupo de Recursos e defina as seguintes propriedades:
- Nome de exibição: Insira Implantar Lote do Azure.
- Conexão do Azure Resource Manager: selecione a assinatura apropriada do Azure.
- Assinatura: selecione a assinatura do Azure apropriada
- Ação: selecione Criar ou Atualizar Grupo de Recursos.
-
Grupo de recursos: insira
$(resourceGroupName). -
Local: insira
$(location). - Local do modelo: selecione a URL do arquivo.
-
Link do modelo: Insira
$(StorageContainerUri)arm-templates/deployment.json$(StorageContainerSasToken). -
Substituir parâmetros de modelo: digite
-StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName).
Uma prática comum é usar tarefas do Azure Key Vault. Se a entidade de serviço conectada com a sua Assinatura do Azure tiver uma política de acesso apropriada definida, ela poderá baixar segredos de um Azure Key Vault e ser usada como uma variável no seu pipeline. O nome do segredo será definido com o valor associado. Por exemplo, você poderia referenciar um segredo de sshPassword com $(sshPassword) na definição da versão.
Chame a CLI do Azure para criar um aplicativo no Lote do Azure.
Adicione a tarefa CLI do Azure e defina as propriedades a seguir:
- Nome de exibição: insira Criar o aplicativo na conta do Lote do Azure.
- Conexão do Azure Resource Manager: selecione a assinatura apropriada do Azure.
- Tipo de script: selecione PowerShell Core.
- Local do script: selecione Script embutido.
-
Script embutido: insira
az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName).
Chame a CLI do Azure para carregar pacotes associados ao aplicativo, neste caso, os arquivos ffmpeg.
Adicione a tarefa CLI do Azure e defina as propriedades a seguir:
- Nome de exibição: insira Carregar o pacote na conta do Lote do Azure.
- Conexão do Azure Resource Manager: selecione a assinatura apropriada do Azure.
- Tipo de script: selecione PowerShell Core.
- Local do script: selecione Script embutido.
-
Script embutido: insira
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 espaço reservado<AzureBuildArtifactSourceAlias>pelo alias de origem do build que você viu anteriormente.
Observação
O número de versão do pacote de aplicativos é definido como uma variável. A variável permite a substituição de versões anteriores do pacote e permite controlar manualmente a versão do pacote enviado por push para o Lote do Azure.
Criar e executar a versão
Ao concluir a criação de todas as etapas, selecione Salvar na parte superior da página do pipeline e selecione OK.
Selecione Criar versão na parte superior da página.
Para exibir o status da versão em tempo real, selecione o link na parte superior da página que diz que a versão foi criada.
Para exibir a saída de log do agente, passe o mouse sobre o estágio e selecione o botão Logs.
Testar o ambiente
Assim que o ambiente estiver configurado, confirme se os testes a seguir podem ser concluídos com êxito. Substitua os espaços reservados pelo nome do seu grupo de recursos e conta do Lote.
Conectar-se à conta do Lote
Conecte-se à nova conta do Lote usando a CLI do Azure com um prompt de comando.
- Entre na sua conta do Azure com
az logine siga as instruções para autenticar. - Agora autentique a conta do Lote com
az batch account login -g <resourceGroup> -n <batchAccount>.
Listar os aplicativos disponíveis
az batch application list -g <resourceGroup> -n <batchAccount>
Verifique se o pool é válido
az batch pool list
Na saída do comando, observe o valor de currentDedicatedNodes para ajustar no próximo teste.
Redimensionar o pool
Execute o comando a seguir para redimensionar o pool para que haja nós de computação disponíveis para teste de trabalho e tarefa. Substitua o espaço reservado <poolName> pelo valor do nome do pool, e o espaço reservado <targetNumber> por um número maior que o currentDedicatedNodes da saída do comando anterior. Verifique status executando o comando az batch pool list 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>
Próximas etapas
Confira estes tutoriais para saber mais sobre como interagir com uma conta do Lote por meio de um aplicativo simples.