Usar o Azure Batch para executar cargas de trabalho de contentor

O Azure Batch permite executar e dimensionar um grande número de trabalhos de computação em lote no Azure. As tarefas do Batch podem ser executadas diretamente em máquinas virtuais (nós) num pool do Batch, mas também é possível configurar um pool do Batch para executar tarefas em contentores compatíveis com Docker nos nós. Este artigo mostra como criar um conjunto de nós de computação que suporta a execução de tarefas de contentor e, em seguida, executar tarefas de contentor no conjunto.

Os exemplos de código aqui usam os SDKs Batch .NET e Python. Também pode utilizar outros SDKs e ferramentas do Batch, incluindo o portal do Azure, para criar pools do Batch compatíveis com contentores, bem como para executar tarefas em contentor.

Porquê utilizar contentores?

Os contêineres fornecem uma maneira fácil de executar tarefas em lote sem ter que gerenciar um ambiente e dependências para executar aplicativos. Os contêineres implantam aplicativos como unidades leves, portáteis e autossuficientes que podem ser executadas em vários ambientes diferentes. Por exemplo, crie e teste um contêiner localmente e, em seguida, carregue a imagem do contêiner em um registro no Azure ou em outro lugar. O modelo de implantação de contêiner garante que o ambiente de tempo de execução do seu aplicativo esteja sempre instalado e configurado corretamente onde quer que você hospede o aplicativo. As tarefas baseadas em contêiner no Batch também podem tirar proveito dos recursos de tarefas que não são de contêiner, incluindo pacotes de aplicativos e gerenciamento de arquivos de recursos e arquivos de saída.

Pré-requisitos

Você deve estar familiarizado com os conceitos de contêiner e como criar um pool de lotes e trabalho.

• Versões do SDK: Os SDKs de lote suportam imagens de contêiner a partir das seguintes versões:

  • Batch REST API versão 2017-09-01.6.0
  • Batch .NET SDK versão 8.0.0
  • Batch Python SDK versão 4.0
  • Batch Java SDK versão 3.0
  • Batch Node.js SDK versão 3.0

• Contas: na sua subscrição do Azure, tem de criar uma conta do Batch e, opcionalmente, uma conta de Armazenamento do Azure.

• Uma imagem de máquina virtual (VM) suportada: os contêineres só são suportados em pools criados com a Configuração da Máquina Virtual, a partir de uma imagem suportada (listada na próxima seção). Se você fornecer uma imagem personalizada, consulte as considerações na seção a seguir e os requisitos em Usar uma imagem gerenciada para criar um pool de imagens personalizadas.

Atualmente, o containerConfiguration requer que a propriedade Type seja passada e os valores suportados são: ContainerType.DockerCompatible e ContainerType.CriCompatible.

Tenha em mente as seguintes limitações:

• O Batch fornece suporte a RDMA (acesso remoto direto à memória) apenas para contêineres executados em pools Linux.
• Para cargas de trabalho de contêiner do Windows, você deve escolher um tamanho de VM multicore para seu pool.

Imagens de VM suportadas

Use uma das seguintes imagens suportadas do Windows ou Linux para criar um pool de nós de computação de VM para cargas de trabalho de contêiner. Para obter mais informações sobre imagens do Marketplace compatíveis com o Batch, consulte Lista de imagens de máquina virtual.

Suporte do Windows

O Batch suporta imagens de servidor Windows que têm designações de suporte de contêiner. A API para listar todas as imagens suportadas no Batch indica um DockerCompatible recurso se a imagem suportar contêineres do Docker. Batch permite, mas não suporta diretamente, imagens publicadas pela Mirantis com a capacidade assinalada como DockerCompatible. Essas imagens só podem ser implantadas em uma conta de lote do modo de alocação do pool de Assinaturas de Usuário.

Você também pode criar uma imagem personalizada para habilitar a funcionalidade de contêiner no Windows.

Suporte para Linux

Para cargas de trabalho de contêiner do Linux, o Batch atualmente dá suporte às seguintes imagens do Linux publicadas no Azure Marketplace sem a necessidade de uma imagem personalizada.

• Editora: microsoft-dsvm
  • Oferta: ubuntu-hpc
• Editora: almalinux
  • Oferta: 8-hpc-gen1
  • Oferta: 8-hpc-gen2

Opções de imagem alternativas

Atualmente, existem outras imagens publicadas por microsoft-azure-batch que suportam cargas de trabalho de contentor:

• Editora: microsoft-azure-batch
  • Oferta: ubuntu-server-container
  • Oferta: ubuntu-server-container-rdma (Para uso exclusivo em SKUs VM com Infiniband)

Notas

A raiz de dados do docker das imagens acima está em lugares diferentes:

• Para a imagem HPC, ou microsoft-dsvm (Oferta: ubuntu-hpc, etc.), a raiz de dados do docker permanece inalterada em relação ao padrão do Docker, que é /var/lib/docker no Linux e C:\ProgramData\Docker no Windows. Essas pastas estão localizadas no disco do sistema operacional.

Para imagens publicadas fora do Batch, o disco do sistema operativo corre o risco de ficar rapidamente cheio à medida que as imagens de contentor são transferidas.

Soluções potenciais para os clientes

Altere a raiz de dados do docker em uma tarefa inicial ao criar um pool no BatchExplorer. Aqui está um exemplo do comando Iniciar tarefa:

1)  sudo systemctl stop docker
2)  sudo vi /lib/systemd/system/docker.service
    +++
    FROM:
    ExecStart=/usr/bin/docker daemon -H fd://
    TO:
    ExecStart=/usr/bin/docker daemon -g /new/path/docker -H fd://
    +++
3)  sudo systemctl daemon-reload
4)  sudo systemctl start docker

Estas imagens só são suportadas para utilização em pools do Azure Batch e destinam-se à execução de contentores do Docker. Apresentam:

• Um motor de contentores Moby compatível com o Docker, pré-instalado.
• Drivers de GPU NVIDIA pré-instalados e tempo de execução de contêiner NVIDIA, para simplificar a implantação em VMs da série N do Azure.
• As imagens de VM com o sufixo -rdma são pré-configuradas com suporte para tamanhos de VM com RDMA InfiniBand. Estas imagens de VM não devem ser utilizadas com dimensões de VM que não tenham suporte a InfiniBand.

Você também pode criar imagens personalizadas compatíveis para contêineres Batch em uma das distribuições Linux compatíveis com Batch. Para ter suporte para Docker numa imagem personalizada, instale um runtime adequado compatível com Docker, como uma versão do Docker ou do Mirantis Container Runtime. Instalar apenas uma ferramenta compatível com Docker-CLI é insuficiente; é necessário um tempo de execução compatível com o Docker Engine.

Mais considerações para usar uma imagem Linux personalizada:

• Para tirar partido do desempenho da GPU dos tamanhos N-series do Azure ao usar uma imagem personalizada, instale previamente os controladores NVIDIA. Além disso, você precisa instalar o Docker Engine Utility para GPUs NVIDIA, NVIDIA Docker.
• Para acessar a rede RDMA do Azure, use um tamanho de VM compatível com RDMA. Os controladores RDMA necessários estão instalados nas imagens CentOS HPC e Ubuntu suportadas pelo Batch. Pode ser necessária uma configuração extra para executar cargas de trabalho MPI. Consulte Usar instâncias RDMA ou GPU num pool do Batch.

Configuração de contêiner para pool de lotes

Para permitir que um pool Batch execute cargas de trabalho de contentores, deve especificar as definições BatchVmContainerConfiguration no objeto BatchVmConfiguration do pool. Este artigo inclui ligações para a referência da API .NET do Batch. As configurações correspondentes encontram-se na API de Python Batch.

Pode criar um conjunto com suporte para contentores, com ou sem imagens de contentor pré-carregadas, tal como mostrado nos exemplos seguintes. O processo pull (ou prefetch) permite pré-carregar imagens de contêiner do Docker Hub ou de outro registro de contêiner na Internet. Para obter o melhor desempenho, use um Registro de Contêiner do Azure na mesma região da conta de lote.

A vantagem de pré-buscar imagens de contêiner é que, quando as tarefas começam a ser executadas pela primeira vez, elas não precisam esperar pelo download da imagem de contêiner. A configuração de contêiner extrai imagens de contêiner para as VMs quando o pool é criado. As tarefas executadas no pool podem fazer referência à lista de imagens de contêiner e opções de execução de contêiner.

Pool sem imagens de contêiner pré-buscadas

Para configurar um conjunto com contentores ativados sem imagens de contentor pré-carregadas, defina os objetos ContainerConfiguration e VirtualMachineConfiguration conforme ilustrado nos exemplos seguintes. Estes exemplos utilizam a imagem do Ubuntu Server para pools de contentores do Azure Batch disponível no Marketplace.

Nota: A versão do servidor Ubuntu usada no exemplo é para fins de ilustração. Sinta-se à vontade para alterar o node_agent_sku_id para a versão que você está usando.

image_ref_to_use = models.BatchVmImageReference(
    publisher='microsoft-dsvm',
    offer='ubuntu-hpc',
    sku='2204',
    version='latest')

"""
Specify container configuration. This is required even though there are no prefetched images.
"""

container_conf = models.BatchContainerConfiguration(type='dockerCompatible')

new_pool = models.BatchPoolCreateOptions(
    id=pool_id,
    virtual_machine_configuration=models.VirtualMachineConfiguration(
        image_reference=image_ref_to_use,
        container_configuration=container_conf,
        node_agent_sku_id='batch.node.ubuntu 22.04'),
    vm_size='STANDARD_D2S_V3',
    target_dedicated_nodes=1)
...

BatchImageReference imageReference = new BatchImageReference()
{
    Publisher = "microsoft-dsvm",
    Offer = "ubuntu-hpc",
    Sku = "2204",
    Version = "latest"
};

// Specify container configuration. This is required even though there are no prefetched images.
BatchVmContainerConfiguration containerConfig = new BatchVmContainerConfiguration("dockerCompatible");

// VM configuration
BatchVmConfiguration vmConfiguration = new BatchVmConfiguration(
    imageReference: imageReference,
    nodeAgentSkuId: "batch.node.ubuntu 22.04")
{
    ContainerConfiguration = containerConfig
};

BatchAccountPoolData poolData = new BatchAccountPoolData()
{
    VmSize = "STANDARD_D2S_V3",
    DeploymentConfiguration = new BatchDeploymentConfiguration() { VmConfiguration = vmConfiguration },
    ScaleSettings = new BatchAccountPoolScaleSettings()
    {
        FixedScale = new BatchAccountFixedScaleSettings() { TargetDedicatedNodes = 1 }
    }
};

await batchAccount.GetBatchAccountPools().CreateOrUpdateAsync(WaitUntil.Completed, poolId, poolData);

Pré-carregamento de imagens para a configuração de contentores

Para pré-buscar imagens de contêiner no pool, adicione a lista de imagens de contêiner (container_image_names em Python) ao ContainerConfiguration.

O seguinte exemplo básico de Python mostra como pré-carregar uma imagem padrão de contentor do Ubuntu a partir do Docker Hub.

image_ref_to_use = models.BatchVmImageReference(
    publisher='microsoft-dsvm',
    offer='ubuntu-hpc',
    sku='2204',
    version='latest')

"""
Specify container configuration, fetching the official Ubuntu container image from Docker Hub.
"""

container_conf = models.BatchContainerConfiguration(
    type='dockerCompatible',
    container_image_names=['ubuntu'])

new_pool = models.BatchPoolCreateOptions(
    id=pool_id,
    virtual_machine_configuration=models.VirtualMachineConfiguration(
        image_reference=image_ref_to_use,
        container_configuration=container_conf,
        node_agent_sku_id='batch.node.ubuntu 22.04'),
    vm_size='STANDARD_D2S_V3',
    target_dedicated_nodes=1)
...

O exemplo de C# a seguir pressupõe que você deseja pré-buscar uma imagem do TensorFlow do Docker Hub. Este exemplo inclui uma tarefa de início que é executada no host da VM nos nós do pool. Você pode executar uma tarefa de início no host, por exemplo, para montar um servidor de arquivos que possa ser acessado a partir dos contêineres.

BatchImageReference imageReference = new BatchImageReference()
{
    Publisher = "microsoft-dsvm",
    Offer = "ubuntu-hpc",
    Sku = "2204",
    Version = "latest"
};

BatchVmContainerRegistry containerRegistry = new BatchVmContainerRegistry()
{
    RegistryServer = "https://hub.docker.com",
    IdentityResourceId = new ResourceIdentifier("/subscriptions/SUB/resourceGroups/RG/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name")
};

// Specify container configuration, prefetching Docker images
BatchVmContainerConfiguration containerConfig = new BatchVmContainerConfiguration("dockerCompatible")
{
    ContainerImageNames = { "tensorflow/tensorflow:latest-gpu" },
    ContainerRegistries = { containerRegistry }
};

// VM configuration
BatchVmConfiguration vmConfiguration = new BatchVmConfiguration(
    imageReference: imageReference,
    nodeAgentSkuId: "batch.node.ubuntu 22.04")
{
    ContainerConfiguration = containerConfig
};

// Set a native host command line start task
BatchAccountPoolStartTask startTaskContainer = new BatchAccountPoolStartTask()
{
    CommandLine = "<native-host-command-line>"
};

BatchAccountPoolData poolData = new BatchAccountPoolData()
{
    VmSize = "Standard_NC6S_V3",
    DeploymentConfiguration = new BatchDeploymentConfiguration() { VmConfiguration = vmConfiguration },
    StartTask = startTaskContainer
};

await batchAccount.GetBatchAccountPools().CreateOrUpdateAsync(WaitUntil.Completed, poolId, poolData);

Pré-carregar imagens a partir de um registo privado de contentores

Também pode pré-carregar imagens de contentor ao autenticar-se num servidor de registo privado de contentores. Nos exemplos a seguir, os objetos ContainerConfiguration e VirtualMachineConfiguration pré-carregam uma imagem privada do TensorFlow de um Registo de Contentores do Azure privado. A referência de imagem é a mesma do exemplo anterior.

image_ref_to_use = models.BatchVmImageReference(
    publisher='microsoft-dsvm',
    offer='ubuntu-hpc',
    sku='2204',
    version='latest')

# Specify a container registry
subscription_id = "yyyy-yyy-yyy-yyy-yyy"
resource_group_name = "TestRG"
user_assigned_identity_name = "testUMI"
resource_id = f"/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{user_assigned_identity_name}"

container_registry = models.ContainerRegistryReference(
        registry_server="myRegistry.azurecr.io",
        identity_reference=models.BatchNodeIdentityReference(resource_id=resource_id))

# Create container configuration, prefetching Docker images from the container registry
container_conf = models.BatchContainerConfiguration(
        type='dockerCompatible',
        container_image_names=["myRegistry.azurecr.io/samples/myImage"],
        container_registries=[container_registry])

new_pool = models.BatchPoolCreateOptions(
            id="myPool",
            virtual_machine_configuration=models.VirtualMachineConfiguration(
                image_reference=image_ref_to_use,
                container_configuration=container_conf,
                node_agent_sku_id='batch.node.ubuntu 22.04'),
            vm_size='STANDARD_D2S_V3',
            target_dedicated_nodes=1)

// Specify a container registry
BatchVmContainerRegistry containerRegistry = new BatchVmContainerRegistry()
{
    RegistryServer = "myContainerRegistry.azurecr.io",
    IdentityResourceId = new ResourceIdentifier("/subscriptions/SUB/resourceGroups/RG/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name")
};

// Create container configuration, prefetching Docker images from the container registry
BatchVmContainerConfiguration containerConfig = new BatchVmContainerConfiguration("dockerCompatible")
{
    ContainerImageNames = { "myContainerRegistry.azurecr.io/tensorflow/tensorflow:latest-gpu" },
    ContainerRegistries = { containerRegistry }
};

// VM configuration
BatchVmConfiguration vmConfiguration = new BatchVmConfiguration(
    imageReference: imageReference,
    nodeAgentSkuId: "batch.node.ubuntu 22.04")
{
    ContainerConfiguration = containerConfig
};

BatchAccountPoolData poolData = new BatchAccountPoolData()
{
    VmSize = "Standard_NC6S_V3",
    DeploymentConfiguration = new BatchDeploymentConfiguration() { VmConfiguration = vmConfiguration },
    ScaleSettings = new BatchAccountPoolScaleSettings()
    {
        FixedScale = new BatchAccountFixedScaleSettings() { TargetDedicatedNodes = 2 }
    }
};

await batchAccount.GetBatchAccountPools().CreateOrUpdateAsync(WaitUntil.Completed, poolId, poolData);

Suporte de identidade gerenciada para ACR

Quando você acessa contêineres armazenados no Registro de Contêiner do Azure, uma identidade gerenciada pode ser usada para autenticar com o serviço. Para usar uma identidade gerenciada, primeiro verifique se a identidade foi atribuída ao pool e se a identidade tem a AcrPull função atribuída para o registro de contêiner que você deseja acessar. Em seguida, instrua Batch com qual identidade usar ao autenticar com ACR.

BatchVmContainerRegistry containerRegistry = new BatchVmContainerRegistry()
{
    RegistryServer = "myContainerRegistry.azurecr.io",
    IdentityResourceId = new ResourceIdentifier("/subscriptions/SUB/resourceGroups/RG/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity-name")
};

Configurações de contêiner para a tarefa

Para executar uma tarefa de contêiner em um pool habilitado para contêiner, especifique configurações específicas do contêiner. As configurações incluem a imagem a ser usada, o registro e as opções de execução do contêiner.

• Use a ContainerSettings propriedade das classes de tarefa para definir configurações específicas do contêiner. Estas definições são definidas pela classe BatchTaskContainerSettings . A opção de contentor --rm não requer outra opção --runtime, pois é tratada pelo Batch.

• Se executar tarefas em imagens de contentor, a tarefa BatchTask e a tarefa do gestor de trabalhos requerem definições de contentor. No entanto, a tarefa de arranque, a tarefa de preparação do trabalho e a tarefa de libertação do trabalho não requerem definições de contentor (ou seja, podem ser executadas num contexto de contentor ou diretamente no nó).

• Para Linux, o Batch mapeia a permissão de usuário/grupo para o contêiner. Se o acesso a qualquer pasta dentro do contêiner exigir permissão de administrador, talvez seja necessário executar a tarefa como escopo do pool com nível de elevação de administrador. Isto garante que o Batch executa a tarefa como utilizador root no contexto do contentor. Caso contrário, um usuário não administrador pode não ter acesso a essas pastas.

• Para pools de contêineres com hardware habilitado para GPU, o Batch habilita automaticamente a GPU para tarefas de contêiner, portanto, você não deve incluir o –gpus argumento.

Linha de comando da tarefa de contêiner

Quando você executa uma tarefa de contêiner, o Batch usa automaticamente o comando docker create para criar um contêiner usando a imagem especificada na tarefa. Depois, o Batch controla a execução da tarefa no contentor.

Assim como acontece com tarefas em lote não contêiner, você define uma linha de comando para uma tarefa de contêiner. Como o Batch cria automaticamente o contêiner, a linha de comando especifica apenas o comando ou comandos que são executados no contêiner.

A seguir estão os comportamentos padrão que o Batch aplica às tarefas de contêiner do Docker:

• O Batch executará o contentor com a linha de comandos da tarefa especificada como CMD.
• O Batch não interfere com o ENTRYPOINT especificado da imagem do contentor.
• Batch substitui o WORKDIR pelo diretório de trabalho da tarefa Batch.

Certifique-se de revisar a documentação do Docker entre ENTRYPOINT e CMD para entender os efeitos de interação que podem surgir quando as imagens de contêiner têm um ENTRYPOINT especificado e também especificar uma linha de comando de tarefa.

Se pretender substituir o ENTRYPOINT da imagem de contentor, pode especificar o argumento --entrypoint <args> como containerRunOption. Consulte o ContainerRunOptions opcional para ver os argumentos que pode fornecer ao comando docker create que o Batch utiliza para criar e executar o contentor. Por exemplo, para definir um diretório de trabalho para o contêiner, defina a --workdir <directory> opção.

Seguem-se alguns exemplos de imagem de contentor e de opções de contentor do Batch ou de linhas de comandos de tarefas, e os respetivos efeitos:

• A imagem de contêiner ENTRYPOINT não é especificada e a linha de comando da tarefa em lote é "/bin/sh -c python myscript.py".
  • O Batch cria o contêiner com a linha de comando da tarefa Batch conforme especificado e o executa no diretório de trabalho da tarefa Batch. Isso pode resultar em falha se "myscript.py" não estiver no diretório de trabalho da tarefa em lote.
  • Se a linha de comando da tarefa foi especificada como "/bin/sh -c python /path/to/script/myscript.py", então essa tarefa pode funcionar corretamente mesmo com o diretório de trabalho definido como o diretório de trabalho da tarefa em lote se todas as dependências do script forem satisfeitas.
• A imagem de contêiner ENTRYPOINT é especificada como "./myscript.sh" e a linha de comando da tarefa Batch está vazia.
  • O Batch cria o contentor com base no ENTRYPOINT e executa-o no diretório de trabalho da tarefa Batch. Esta tarefa pode falhar se o WORKDIR da imagem do contentor não for o mesmo que o diretório de trabalho da tarefa do Batch, o qual depende de vários fatores, como o sistema operativo, o ID do trabalho, o ID da tarefa, etc.
  • Se "--workdir /path/to/script" foi especificado como containerRunOption, então essa tarefa pode funcionar corretamente se todas as dependências do script forem satisfeitas.
• A imagem do contêiner ENTRYPOINT não é especificada, a linha de comando da tarefa em lote é "./myscript.sh" e WORKDIR é substituído em ContainerRunOptions como "--workdir /path/to/script".
  • Batch cria o contêiner com o diretório de trabalho para "/path/to/script" e executa a linha de comando "./myscript.sh", que é bem-sucedida quando o script é encontrado no diretório de trabalho especificado.

Diretório de trabalho da tarefa de contêiner

Uma tarefa de contentor do Batch é executada num diretório de trabalho no contentor, semelhante ao diretório que o Batch configura para uma tarefa normal (sem contentor). Este diretório de trabalho é diferente do WORKDIR se configurado na imagem ou do diretório de trabalho do contêiner padrão (C:\ em um contêiner do Windows ou / em um contêiner do Linux).

Para uma tarefa de contêiner em lote:

• Todos os diretórios localizados recursivamente sob AZ_BATCH_NODE_ROOT_DIR no nó anfitrião (a raiz dos diretórios do Azure Batch) são mapeados para o contentor.
• Todas as variáveis de ambiente de tarefa são mapeadas no contêiner.
• O diretório AZ_BATCH_TASK_WORKING_DIR de trabalho da tarefa no nó é definido da mesma forma que para uma tarefa normal e mapeado no contêiner.

Esses mapeamentos permitem que você trabalhe com tarefas de contêiner da mesma forma que tarefas sem contêiner. Por exemplo, instale aplicativos usando pacotes de aplicativos, acesse arquivos de recursos do Armazenamento do Azure, use configurações de ambiente de tarefas e persista arquivos de saída de tarefas depois que o contêiner parar.

Independentemente de como o WORKDIR é definido para uma imagem de contêiner, ambos stdout.txt e stderr.txt são capturados no AZ_BATCH_TASK_DIR.

Solucionar problemas de tarefas de contêiner

Se a tarefa de contêiner não for executada conforme o esperado, talvez seja necessário obter informações sobre a configuração WORKDIR ou ENTRYPOINT da imagem do contêiner. Para ver a configuração, execute o comando docker image inspect .

Se necessário, ajuste as configurações da tarefa de contêiner com base na imagem:

• Especifique um caminho absoluto na linha de comando da tarefa. Se o ENTRYPOINT padrão da imagem for usado para a linha de comando da tarefa, certifique-se de que um caminho absoluto esteja definido.
• Nas opções de execução do contêiner da tarefa, altere o diretório de trabalho para corresponder ao WORKDIR na imagem. Por exemplo, defina --workdir /app.

Exemplos de tarefas de contêiner

O trecho Python a seguir mostra uma linha de comando básica em execução em um contêiner criado a partir de uma imagem fictícia extraída do Docker Hub. Aqui, a opção --rm remove o contentor após a conclusão da tarefa, e a opção --workdir define um diretório de trabalho. A linha de comando substitui o contêiner ENTRYPOINT por um comando shell simples que grava um pequeno arquivo no diretório de trabalho da tarefa no host.

task_id = 'sampletask'
task_container_settings = models.BatchTaskContainerSettings(
    image_name='myimage',
    container_run_options='--rm --workdir /')
task = models.BatchTaskCreateOptions(
    id=task_id,
    command_line='/bin/sh -c \"echo \'hello world\' > $AZ_BATCH_TASK_WORKING_DIR/output.txt\"',
    container_settings=task_container_settings
)

O exemplo de C# a seguir mostra as configurações básicas de contêiner para uma tarefa na nuvem:

// Simple container task command
string cmdLine = @"c:\app\myApp.exe";

Azure.Compute.Batch.BatchTaskContainerSettings cmdContainerSettings = new Azure.Compute.Batch.BatchTaskContainerSettings("myimage")
{
    ContainerRunOptions = @"--rm --workdir c:\app"
};

BatchTaskCreateOptions containerTask = new BatchTaskCreateOptions(
    id: "Task1",
    commandLine: cmdLine)
{
    ContainerSettings = cmdContainerSettings
};

Próximos passos

• Para obter informações sobre como instalar e usar o Docker CE no Linux, consulte a documentação do Docker.
• Saiba como Usar uma imagem gerenciada para criar um pool de imagens personalizado.
• Saiba mais sobre o projeto Moby, uma estrutura para a criação de sistemas baseados em contêineres.