As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Docker visão geral do ambiente de filas
<a name="containers-queue-environment"></a>

O ambiente de Docker fila padrão declara as extensões `EXPR` e `WRAP_ACTIONS` OpenJD. Suas próprias ações de entrada e saída gerenciam o Docker daemon sem raiz e o contêiner de sessão no trabalhador. Três ações de encapsulamento substituem as ações de ambientes e tarefas internos enquanto o ambiente de fila está ativo.

O fluxo a seguir mostra como o ambiente de fila encapsula uma ação de tarefa:

1. O modelo de trabalho portátil fornece um `onRun` comando e seus argumentos.

1. O tempo de execução da sessão envolve a `onRun` ação original em `onWrapTaskRun` vez de executar o comando diretamente.

1. O gancho passa `WrappedAction.Command``WrappedAction.Args`, e `WrappedAction.Environment` para um script de encapsulamento estático como argumentos separados.

1. O script de encapsulamento é usado `docker container exec` para executar o comando e os argumentos originais dentro do contêiner de sessão sem raiz.

A `onEnter` ação do ambiente de empacotamento inicia o contêiner da sessão e sua `onExit` ação interrompe o contêiner. O contêiner bind-monta o diretório da sessão no mesmo caminho. Ele também pode vincular e montar armazenamento persistente para caches reutilizáveis.

![Um modelo de tarefa portátil passa sua ação OnRun original para o WrapTaskRun limite on. A ação passa para um script de encapsulamento estático como WrappedAction valores e é executada dentro de um contêiner de sessão sem raiz. O ambiente de fila inicia e interrompe o contêiner, que monta o diretório da sessão e o armazenamento persistente opcional.](https://docs.aws.amazon.com/pt_br/deadline-cloud/latest/developerguide/images/wrap-actions-flow.png)



| Ação do ambiente de fila | Funciona em | Finalidade | 
| --- | --- | --- | 
| onEnter | Operador | Inicia o daemon sem raiz, autentica no Amazon ECR, extrai a imagem e inicia o contêiner da sessão. | 
| onWrapEnvEnter | Contêiner | Executa a ação de entrada de um ambiente interno. | 
| onWrapTaskRun | Contêiner | Executa os comandos e argumentos do aplicativo de cada tarefa. | 
| onWrapEnvExit | Contêiner | Executa a ação de saída de um ambiente interno. | 
| onExit | Operador | Interrompe o contêiner da sessão, o daemon sem raiz e o gerenciador de usuários. | 

O ambiente de empacotamento deve definir todas as três ações de empacotamento. Cada gancho recebe a ação original por meio de `WrappedAction.Command``WrappedAction.Args`, `WrappedAction.Environment` e. O modelo parcial a seguir mostra como o ambiente padrão encaminha esses valores:

```
specificationVersion: "environment-2023-09"
extensions:
  - WRAP_ACTIONS
  - EXPR
environment:
  name: DockerContainer
  script:
    actions:
      onWrapEnvEnter:
        command: bash
        args:
          - "{{Env.File.Wrap}}"
          - "{{ flatten([['-e', e] for e in WrappedAction.Environment]) }}"
          - "--"
          - "{{WrappedAction.Command}}"
          - "{{WrappedAction.Args}}"
      onWrapTaskRun:
        command: bash
        args:
          - "{{Env.File.Wrap}}"
          - "{{ flatten([['-e', e] for e in WrappedAction.Environment]) }}"
          - "--"
          - "{{WrappedAction.Command}}"
          - "{{WrappedAction.Args}}"
      onWrapEnvExit:
        command: bash
        args:
          - "{{Env.File.Wrap}}"
          - "{{ flatten([['-e', e] for e in WrappedAction.Environment]) }}"
          - "--"
          - "{{WrappedAction.Command}}"
          - "{{WrappedAction.Args}}"
```

O script wrap recebe o comando como um vetor de argumento e executa a ação original dentro do rootless Docker como a identidade sem `job-user` privilégios. O script encaminha somente as variáveis de licença baseadas no uso conhecidas do host. Ele não encaminha as AWS credenciais para o contêiner.

O ambiente padrão monta o diretório de trabalho da sessão no mesmo caminho. Ele seleciona GPUs por meio da Container Device Interface (CDI) quando disponível e propaga o status de saída da ação encapsulada. Para obter detalhes sobre o compartilhamento de dados, consulte. [Compartilhe o diretório de trabalho da sessão](containers-share-session-directory.md)

## Personalize um Docker ambiente de filas
<a name="containers-queue-customize"></a>

O console cria um ambiente de Docker fila padrão. Você pode usar esse modelo como ponto de partida para montagens específicas do aplicativo, variáveis de ambiente, rede, seleção de imagens e opções de tempo de execução. Preserve o ciclo de vida do daemon sem raiz, a montagem do diretório de sessão e todos os três ganchos de encapsulamento ao personalizar o modelo.

A `EXPR` extensão oferece suporte a expressões condicionais. O exemplo de script de entrada parcial a seguir escolhe entre duas imagens e adiciona argumentos de GPU somente quando o `UseGpu` parâmetro é verdadeiro:

```
IMAGE={{ repr_sh(Param.GpuImage if Param.UseGpu else Param.CpuImage) }}
GPU_ARGS=({{ repr_sh(['--gpus', 'all'] if Param.UseGpu else []) }})

docker container run \
    --rm \
    --detach \
    "${GPU_ARGS[@]}" \
    --mount {{ repr_sh("type=bind,src=" + Session.WorkingDirectory + ",dst=" + Session.WorkingDirectory) }} \
    --workdir {{ repr_sh(Session.WorkingDirectory) }} \
    "$IMAGE"
```

Você também pode selecionar um script de wrapper condicionalmente em cada gancho. A ação parcial a seguir escolhe um encapsulador de contêiner ou um encapsulador de host a partir de um parâmetro de ambiente de fila:

```
onWrapTaskRun:
  command: bash
  args:
    - "{{ Env.File.WrapContainer if Param.RunInContainer else Env.File.WrapHost }}"
    - "{{ flatten([['-e', e] for e in WrappedAction.Environment]) }}"
    - "--"
    - "{{WrappedAction.Command}}"
    - "{{WrappedAction.Args}}"
```

Use a mesma condição de tempo de execução para `onWrapEnvEnter``onWrapTaskRun`, `onWrapEnvExit` e. Manter todas as fases do ciclo de vida no mesmo tempo de execução impede que um ambiente interno entre em um contexto e saia em outro. A `WRAP_ACTIONS` extensão requer todos os três ganchos, mesmo quando uma condição seleciona o invólucro hospedeiro.

Um wrapper de host deve ser aplicado`WrappedAction.Environment`, preservar os limites do argumento original e retornar o status de saída da ação encapsulada. Passe valores de comandos e argumentos como um vetor de argumentos. Não combine valores brutos em uma string para`bash -c`. Para regras de cotação, consulte[Comande a construção e a fuga](containers-security.md#containers-security-command-construction).

## Especificações do OpenJD
<a name="containers-openjd-references"></a>

A [proposta da linguagem de expressão OpenJD](https://github.com/OpenJobDescription/openjd-specifications/blob/mainline/rfcs/0005-expression-language.md) no GitHub site define avaliação de expressão, caminhos digitados e símbolos de sessão.

A [proposta da biblioteca de funções de expressão OpenJD](https://github.com/OpenJobDescription/openjd-specifications/blob/mainline/rfcs/0006-expression-function-library.md) no GitHub site define `flatten` as `repr_*` funções.

A [proposta de tipos de parâmetros estendidos do OpenJD](https://github.com/OpenJobDescription/openjd-specifications/blob/mainline/rfcs/0007-extend-parameter-types.md) no GitHub site define parâmetros com valor de lista que os modelos portáteis podem usar.

A [proposta de ações de encapsulamento do ambiente OpenJD](https://github.com/OpenJobDescription/openjd-specifications/blob/mainline/rfcs/0008-environment-wrap-actions.md) no GitHub site define os três ganchos e valores de encapsulamento. `WrappedAction.*`