Partilhar via


Usar modelos de CLI do Azure Batch e transferência de arquivos

Advertência

A extensão Batch Azure CLI será desativada em 30 de setembro de 2024. Desinstale a extensão com o comando az extension remove --name azure-batch-cli-extensions.

Usando uma extensão de lote para a CLI do Azure, os usuários podem executar trabalhos em lote sem escrever código.

Crie e use arquivos de modelo JSON com a CLI do Azure para criar pools de lotes, trabalhos e tarefas. Use os comandos de extensão da CLI para carregar facilmente arquivos de entrada de trabalho para a conta de armazenamento associada à conta em lote e baixar arquivos de saída de trabalho.

Observação

Os ficheiros JSON não suportam a mesma funcionalidade que os modelos do Azure Resource Manager. Eles devem ser formatados como o corpo de solicitação REST original. A extensão CLI não altera nenhum comando existente, mas tem uma opção de modelo semelhante que adiciona funcionalidade parcial de modelo do Azure Resource Manager. Consulte Extensões da CLI do Azure Batch para Windows, Mac e Linux.

Visão geral

Uma extensão para a CLI do Azure permite que o Batch seja usado de ponta a ponta por usuários que não são desenvolvedores. Com apenas comandos da CLI, você pode criar um pool, carregar dados de entrada, criar trabalhos e tarefas associadas e baixar os dados de saída resultantes. Nenhum código adicional é necessário. Execute os comandos da CLI diretamente ou integre-os em scripts.

Os modelos de lote se baseiam no suporte de lote existente na CLI do Azure para arquivos JSON para especificar valores de propriedade ao criar pools, trabalhos, tarefas e outros itens. Os modelos de lote adicionam os seguintes recursos:

  • Os parâmetros podem ser definidos. Quando o modelo é usado, somente os valores de parâmetro são especificados para criar o item, com outros valores de propriedade de item especificados no corpo do modelo. Um usuário que entende Batch e os aplicativos a serem executados por Batch pode criar modelos, especificando valores de propriedade pool, job e task. Um usuário menos familiarizado com Batch e/ou os aplicativos só precisa especificar os valores para os parâmetros definidos.

  • As fábricas de tarefas de trabalho criam uma ou mais tarefas associadas a um trabalho, evitando a necessidade de muitas definições de tarefas a serem criadas e simplificando significativamente o envio de trabalho.

Os trabalhos normalmente usam arquivos de dados de entrada e produzem arquivos de dados de saída. Uma conta de armazenamento é associada, por padrão, a cada conta de lote. Você pode transferir arquivos de e para essa conta de armazenamento usando a CLI do Azure, sem codificação e sem credenciais de armazenamento.

Por exemplo, ffmpeg é um aplicativo popular que processa arquivos de áudio e vídeo. Usando a extensão CLI do Azure Batch, você pode tornar mais fácil para um usuário invocar ffmpeg para transcodificar arquivos de vídeo de origem para resoluções diferentes. O processo pode ter esta aparência:

  • Crie um modelo de pool. O usuário que cria o modelo sabe como chamar o aplicativo ffmpeg e seus requisitos; eles especificam o sistema operacional apropriado, o tamanho da VM, como o ffmpeg é instalado (de um pacote de aplicativo ou usando um gerenciador de pacotes, por exemplo) e outros valores de propriedade de pool. Os parâmetros são criados para que, quando o modelo é usado, apenas o ID do pool e o número de VMs precisem ser especificados.
  • Crie um modelo de trabalho. O usuário que cria o modelo sabe como ffmpeg precisa ser invocado para transcodificar o vídeo de origem para uma resolução diferente e especifica a linha de comando da tarefa; Eles também sabem que há uma pasta contendo os arquivos de vídeo de origem, com uma tarefa necessária por arquivo de entrada.
  • Um usuário final com um conjunto de arquivos de vídeo para transcodificar primeiro cria um pool usando o modelo de pool, especificando apenas o ID do pool e o número de VMs necessárias. Eles podem então carregar os arquivos de origem para transcodificar. Um trabalho pode ser enviado usando o modelo de trabalho, especificando apenas o ID do pool e o local dos arquivos de origem carregados. O trabalho em lote é criado, com uma tarefa por arquivo de entrada sendo gerada. Finalmente, os arquivos de saída transcodificados podem ser baixados.

Instalação

Para instalar a extensão da CLI do Azure Batch, primeiro Instale a CLI do Azure 2.0 ou execute a CLI do Azure no Azure Cloud Shell.

Instale a versão mais recente da extensão Batch usando o seguinte comando da CLI do Azure:

az extension add --name azure-batch-cli-extensions

Para obter mais informações sobre a extensão Batch CLI e opções de instalação adicionais, consulte o repositório GitHub.

Para utilizar as funcionalidades de extensão da CLI, é necessário ter uma conta Azure Batch e, para os comandos que transferem ficheiros de e para o armazenamento, uma conta de armazenamento associada.

Para fazer logon em uma conta de lote com a CLI do Azure, consulte Gerenciar recursos em lote com a CLI do Azure.

Modelos

Os modelos do Azure Batch são semelhantes aos modelos do Azure Resource Manager, em funcionalidade e sintaxe. Eles são arquivos JSON que contêm nomes de propriedade de item e valores, mas adicionam os seguintes conceitos principais:

  • Parâmetros: Permite que os valores de propriedade sejam especificados em uma seção de corpo, com apenas valores de parâmetro precisando ser fornecidos quando o modelo é usado. Por exemplo, a definição completa para um pool pode ser colocada no corpo e apenas um parâmetro definido para poolId, portanto, apenas uma string de ID de pool precisa ser fornecida para criar um pool. O corpo do modelo pode ser criado por alguém com conhecimento do Batch e dos aplicativos a serem executados pelo Batch; Somente valores para os parâmetros definidos pelo autor devem ser fornecidos quando o modelo é usado. Isso permite que utilizadores sem qualquer conhecimento aprofundado de lote e/ou aplicação usem os modelos.
  • Variáveis: permitem que valores de parâmetros simples ou complexos sejam especificados em um lugar e usados em um ou mais locais no corpo do modelo. As variáveis podem simplificar e reduzir o tamanho do modelo, bem como torná-lo mais fácil de manter, tendo um local para alterar as propriedades.
  • Construções de nível superior: Algumas construções de nível superior estão disponíveis no modelo que ainda não estão disponíveis nas APIs de lote. Por exemplo, uma fábrica de tarefas pode ser definida em um modelo de trabalho que cria várias tarefas para o trabalho, usando uma definição de tarefa comum. Essas construções evitam a necessidade de codificar para criar dinamicamente vários arquivos JSON, como um arquivo por tarefa, bem como criar arquivos de script para instalar aplicativos por meio de um gerenciador de pacotes.

Pool templates

Os modelos de pool suportam os recursos de modelo padrão de parâmetros e variáveis. Eles também suportam referências de pacote, que opcionalmente permitem que o software seja copiado para nós de pool usando gerenciadores de pacotes. O gerenciador de pacotes e a ID do pacote são especificados na referência do pacote. Ao declarar um ou mais pacotes, você evita criar um script que obtém os pacotes necessários, instalar o script e executá-lo em cada nó do pool.

A seguir está um exemplo de um modelo que cria um pool de VMs Linux com ffmpeg instalado. Para usá-lo, forneça apenas uma cadeia de caracteres de ID do pool e o número de VMs no pool:

{
    "parameters": {
        "nodeCount": {
            "type": "int",
            "metadata": {
                "description": "The number of pool nodes"
            }
        },
        "poolId": {
            "type": "string",
            "metadata": {
                "description": "The pool ID "
            }
        }
    },
    "pool": {
        "type": "Microsoft.Batch/batchAccounts/pools",
        "apiVersion": "2016-12-01",
        "properties": {
            "id": "[parameters('poolId')]",
            "virtualMachineConfiguration": {
                "imageReference": {
                    "publisher": "Canonical",
                    "offer": "UbuntuServer",
                    "sku": "20.04-LTS",
                    "version": "latest"
                },
                "nodeAgentSKUId": "batch.node.ubuntu 20.04"
            },
            "vmSize": "STANDARD_D3_V2",
            "targetDedicatedNodes": "[parameters('nodeCount')]",
            "enableAutoScale": false,
            "taskSlotsPerNode": 1,
            "packageReferences": [
                {
                    "type": "aptPackage",
                    "id": "ffmpeg"
                }
            ]
        }
    }
}

Se o arquivo de modelo foi nomeado pool-ffmpeg.json, invoque o modelo da seguinte maneira:

az batch pool create --template pool-ffmpeg.json

A CLI solicita que você forneça valores para os poolId parâmetros e nodeCount . Você também pode fornecer os parâmetros em um arquivo JSON. Por exemplo:

{
  "poolId": {
    "value": "mypool"
  },
  "nodeCount": {
    "value": 2
  }
}

Se o arquivo JSON de parâmetros foi nomeado pool-parameters.json, invoque o modelo da seguinte maneira:

az batch pool create --template pool-ffmpeg.json --parameters pool-parameters.json

Modelos de trabalho

Os modelos de trabalho suportam os recursos de modelo padrão de parâmetros e variáveis. Eles também suportam a construção da fábrica de tarefas , que cria várias tarefas para um trabalho a partir de uma definição de tarefa. Há suporte para três tipos de fábrica de tarefas: varredura paramétrica, tarefa por ficheiro e coleção de tarefas.

A seguir está um exemplo de um modelo que cria um trabalho para transcodificar arquivos de vídeo MP4 com ffmpeg para uma das duas resoluções mais baixas. Cria uma tarefa por ficheiro de vídeo de origem. Consulte Grupos de arquivos e transferência de arquivos para obter mais informações sobre grupos de arquivos para entrada e saída de tarefas.

{
    "parameters": {
        "poolId": {
            "type": "string",
            "metadata": {
                "description": "The name of Azure Batch pool which runs the job"
            }
        },
        "jobId": {
            "type": "string",
            "metadata": {
                "description": "The name of Azure Batch job"
            }
        },
        "resolution": {
            "type": "string",
            "defaultValue": "428x240",
            "allowedValues": [
                "428x240",
                "854x480"
            ],
            "metadata": {
                "description": "Target video resolution"
            }
        }
    },
    "job": {
        "type": "Microsoft.Batch/batchAccounts/jobs",
        "apiVersion": "2016-12-01",
        "properties": {
            "id": "[parameters('jobId')]",
            "constraints": {
                "maxWallClockTime": "PT5H",
                "maxTaskRetryCount": 1
            },
            "poolInfo": {
                "poolId": "[parameters('poolId')]"
            },
            "taskFactory": {
                "type": "taskPerFile",
                "source": {
                    "fileGroup": "ffmpeg-input"
                },
                "repeatTask": {
                    "commandLine": "ffmpeg -i {fileName} -y -s [parameters('resolution')] -strict -2 {fileNameWithoutExtension}_[parameters('resolution')].mp4",
                    "resourceFiles": [
                        {
                            "blobSource": "{url}",
                            "filePath": "{fileName}"
                        }
                    ],
                    "outputFiles": [
                        {
                            "filePattern": "{fileNameWithoutExtension}_[parameters('resolution')].mp4",
                            "destination": {
                                "autoStorage": {
                                    "path": "{fileNameWithoutExtension}_[parameters('resolution')].mp4",
                                    "fileGroup": "ffmpeg-output"
                                }
                            },
                            "uploadOptions": {
                                "uploadCondition": "TaskSuccess"
                            }
                        }
                    ]
                }
            },
            "onAllTasksComplete": "terminatejob"
        }
    }
}

Se o arquivo de modelo foi nomeado job-ffmpeg.json, invoque o modelo da seguinte maneira:

az batch job create --template job-ffmpeg.json

Como antes, a CLI solicita que você forneça valores para os parâmetros. Você também pode fornecer os parâmetros em um arquivo JSON.

Use templates in Batch Explorer

Você pode carregar um modelo de CLI de Batch para o aplicativo de desktop Batch Explorer para criar um pool ou trabalho de Batch. Você também pode selecionar entre modelos de pool e trabalho predefinidos na Galeria do Batch Explorer.

Para carregar um modelo:

  1. No Batch Explorer, selecione Galeria>Modelos locais.
  2. Selecione, ou arraste e solte, um pool local ou modelo de trabalho.
  3. Selecione Usar este modelo e siga as instruções na tela.

Grupos de ficheiros e transferência de ficheiros

A maioria dos trabalhos e tarefas requer arquivos de entrada e produz arquivos de saída. Usually, input files and output files are transferred, either from the client to the node, or from the node to the client. A extensão CLI do Azure Batch abstrai a transferência de arquivos e utiliza a conta de armazenamento que você pode associar a cada conta Batch.

Um grupo de arquivos equivale a um contêiner criado na conta de armazenamento do Azure. O grupo de arquivos pode ter subpastas.

A extensão Batch CLI fornece comandos para carregar arquivos do cliente para um grupo de arquivos especificado e baixar arquivos do grupo de arquivos especificado para um cliente.

az batch file upload --local-path c:\source_videos\*.mp4
    --file-group ffmpeg-input

az batch file download --file-group ffmpeg-output --local-path
    c:\output_lowres_videos

Pool and job templates allow files stored in file groups to be specified for copy onto pool nodes or off pool nodes back to a file group. Por exemplo, no modelo de trabalho especificado anteriormente, o grupo de arquivos ffmpeg-input é especificado para o gerador de tarefas como o local dos arquivos de vídeo de origem copiados para baixo para o nó para transcodificação. O grupo de arquivos ffmpeg-output é o local onde os arquivos de saída transcodificados são copiados do nó que executa cada tarefa.

Resumo

Atualmente, o suporte a transferência de modelos e arquivos foi adicionado apenas à CLI do Azure. O objetivo é expandir o público que pode usar o Batch para usuários que não precisam desenvolver código usando as APIs do Batch, como pesquisadores e usuários de TI. Sem codificação, os usuários com conhecimento do Azure, do Batch e dos aplicativos a serem executados pelo Batch podem criar modelos para pool e criação de trabalho. Com os parâmetros do modelo, os usuários sem conhecimento detalhado do Batch e dos aplicativos podem usar os modelos.

Experimente a extensão Batch para a CLI do Azure e forneça-nos quaisquer comentários ou sugestões, seja nos comentários deste artigo ou através do repositório da Comunidade Batch.

Próximos passos