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á.
# Configurar trabalhos usando ambientes de fila
AWS O Deadline Cloud usa *ambientes de fila* para configurar o software em seus trabalhadores. Um ambiente permite que você execute tarefas demoradas, como configurar e desmontar, uma vez para todas as tarefas em uma sessão. Ele define as ações a serem executadas em um trabalhador ao iniciar ou interromper uma sessão. Você pode configurar um ambiente para uma fila, trabalhos que são executados na fila e as etapas individuais para um trabalho.
Você define ambientes como ambientes de fila ou ambientes de trabalho. Crie ambientes de fila com o console Deadline Cloud ou com a CreateQueueEnvironment operação [Deadline:](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateQueueEnvironment.html) e defina ambientes de trabalho nos modelos de trabalho dos trabalhos que você envia. Eles seguem a especificação Open Job Description (OpenJD) para ambientes. Para obter detalhes, consulte a especificação do OpenJD[https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment) em. GitHub
Além de um `name` e`description`, cada ambiente contém dois campos que definem o ambiente no host. Eles são:
+ `script`— A ação tomada quando esse ambiente é executado em um trabalhador.
+ `variables`— Um conjunto de name/value pares de variáveis de ambiente que são definidos ao entrar no ambiente.
Você deve definir pelo menos um dos `script` ou`variables`.
Você pode definir mais de um ambiente em seu modelo de trabalho. Cada ambiente é aplicado na ordem em que estão listados no modelo. Você pode usar isso para ajudar a gerenciar a complexidade de seus ambientes.
O ambiente de fila padrão do Deadline Cloud usa o gerenciador de pacotes conda para carregar software no ambiente, mas você pode usar outros gerenciadores de pacotes. O ambiente padrão define dois parâmetros para especificar o software que deve ser carregado. Essas variáveis são definidas pelos remetentes fornecidas pelo Deadline Cloud, embora você possa defini-las em seus próprios scripts e aplicativos que usam o ambiente padrão. Eles são:
+ `CondaPackages`— Uma lista separada por espaço do pacote conda corresponde às especificações a serem instaladas para o trabalho. Por exemplo, o remetente do Blender adicionaria quadros `blender=3.6` para renderizar no Blender 3.6.
+ `CondaChannels`— Uma lista separada por espaços de canais conda para instalar pacotes. Para frotas gerenciadas por serviços, os pacotes são instalados a partir do canal. `deadline-cloud` Você pode adicionar outros canais.
# Controle o ambiente de trabalho com ambientes de fila do OpenJD
Você pode definir ambientes personalizados para seus trabalhos de renderização usando ambientes de *fila*. Um ambiente de fila é um modelo que controla as variáveis de ambiente, mapeamentos de arquivos e outras configurações para trabalhos executados em uma fila específica. Ele permite que você adapte o ambiente de execução dos trabalhos enviados a uma fila de acordo com os requisitos de suas cargas de trabalho. AWS O Deadline Cloud fornece três níveis agrupados nos quais você pode aplicar [ambientes Open Job Description (OpenJD)](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment): fila, tarefa e etapa. Ao definir ambientes de filas, você pode garantir um desempenho consistente e otimizado para diferentes tipos de trabalhos, agilizar a alocação de recursos e simplificar o gerenciamento de filas.
O ambiente de fila é um modelo que você anexa a uma fila em sua AWS conta a partir do console de AWS gerenciamento ou usando o. AWS CLI Você pode criar um ambiente para uma fila ou criar vários ambientes de fila aplicados para criar o ambiente de execução. Essa abordagem permite criar e testar um ambiente em etapas para ajudar a garantir que ele funcione corretamente para seus trabalhos.
Os ambientes de trabalho e etapas são definidos no modelo de trabalho que você usa para criar um trabalho na sua fila. A sintaxe do OpenJD é a mesma nessas diferentes formas de ambientes. Nesta seção, mostraremos eles dentro dos modelos de trabalho.
**Topics**
+ [Definir variáveis de ambiente em um ambiente de fila](set-environment-variables.md)
+ [Definir o caminho em um ambiente de fila](set-the-path.md)
+ [Execute um processo daemon em segundo plano a partir do ambiente de fila](run-a-background-daemon-process.md)
# Definir variáveis de ambiente em um ambiente de fila
Muitos aplicativos e estruturas usam variáveis de ambiente para controlar as configurações de recursos, os níveis de registro e a configuração de exibição. Você pode usar [ambientes Open Job Description (OpenJD)](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment) para definir variáveis de ambiente que cada comando de tarefa dentro de seu escopo herda.
## Escopo da variável de ambiente
AWS O Deadline Cloud aplica variáveis de ambiente de ambientes de fila que você anexa a uma fila. Em um modelo de trabalho, você também pode definir variáveis de ambiente nos níveis de tarefa e etapa usando ambientes [OpenJD.](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment) Variáveis definidas em um escopo mais restrito substituem variáveis com o mesmo nome de um escopo mais amplo.
+ **Ambiente de fila** — Um modelo que você anexa a uma fila no Deadline Cloud. As variáveis se aplicam a todos os trabalhos enviados à fila. Você pode definir variáveis com um `variables` mapa para valores fixos ou usar scripts para valores dinâmicos.
+ **Ambiente de trabalho** — Definido abaixo `jobEnvironments` em um modelo de trabalho. As variáveis se aplicam a todas as etapas e tarefas do trabalho. Uma variável no nível do trabalho substitui uma variável no nível da fila com o mesmo nome.
+ **Ambiente de etapas** — definido abaixo `stepEnvironments` em um modelo de trabalho. As variáveis se aplicam somente às tarefas dessa etapa. Uma variável de nível de etapa substitui uma variável de nível de trabalho ou de fila com o mesmo nome.
## Configurando variáveis em um ambiente de fila
Você pode definir variáveis de ambiente em um ambiente de fila usando um `variables` mapa para valores fixos ou usando um `script` com uma `onEnter` ação para valores dinâmicos.
O modelo de ambiente de fila a seguir usa um `variables` mapa para definir a `QT_QPA_PLATFORM` variável`offscreen`, o que permite que aplicativos que usam o [Qt Framework](https://www.qt.io/product/framework) sejam executados em hosts de trabalho sem uma exibição interativa.
```
specificationVersion: 'environment-2023-09'
environment:
name: QtOffscreen
variables:
QT_QPA_PLATFORM: offscreen
```
Para valores dinâmicos, como modificar `PATH` ou ativar ambientes virtuais, use um script que imprima linhas no formato `openjd_env: VAR=value` em stdout. O `openjd_env:` prefixo é obrigatório. Usar`echo`,`export`, ou outros mecanismos de shell sem o prefixo não propaga variáveis para trabalhos e tarefas.
O modelo de ambiente de fila a seguir define a `QT_QPA_PLATFORM` variável usando um script.
```
specificationVersion: 'environment-2023-09'
environment:
name: QtOffscreen
script:
actions:
onEnter:
command: bash
args:
- "{{Env.File.Enter}}"
embeddedFiles:
- name: Enter
type: TEXT
data: |
#!/bin/env bash
set -euo pipefail
echo "openjd_env: QT_QPA_PLATFORM=offscreen"
```
Para anexar um ambiente de fila à sua fila, use o console do Deadline Cloud ou o. AWS CLI Para obter mais informações, consulte [Criar um ambiente de fila](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html) no Guia do usuário do AWS Deadline Cloud. O AWS CLI comando a seguir cria um ambiente de fila a partir de um arquivo de modelo.
```
aws deadline create-queue-environment \
--farm-id FARM_ID \
--queue-id QUEUE_ID \
--priority 1 \
--template-type YAML \
--template file://my-queue-env.yaml
```
Para exemplos mais complexos, como criar e ativar ambientes virtuais conda, consulte os exemplos do [ambiente de filas do Deadline Cloud em](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/queue_environments). GitHub
## Definindo variáveis em um modelo de trabalho
Em um modelo de trabalho, adicione um `variables` mapa a uma `stepEnvironments` entrada `jobEnvironments` or. Cada entrada é um par de valores-chave em que a chave é o nome da variável e o valor é o valor da variável.
O modelo de trabalho a seguir define a variável de `QT_QPA_PLATFORM` ambiente como`offscreen`, o que permite que aplicativos que usam o [Qt Framework](https://www.qt.io/product/framework) sejam executados em hosts de trabalho sem uma exibição interativa.
```
specificationVersion: 'jobtemplate-2023-09'
name: MyJob
jobEnvironments:
- name: JobEnv
variables:
QT_QPA_PLATFORM: offscreen
```
Você pode definir várias variáveis em uma única definição de ambiente.
```
jobEnvironments:
- name: JobEnv
variables:
JOB_VERBOSITY: MEDIUM
JOB_PROJECT_ID: my-project-id
JOB_ENDPOINT_URL: https://my-host-name/my/path
QT_QPA_PLATFORM: offscreen
```
Você pode referenciar os parâmetros do trabalho em valores variáveis usando a `{{Param.ParameterName}}` sintaxe.
```
jobEnvironments:
- name: JobEnv
variables:
JOB_EXAMPLE_PARAM: "{{Param.ExampleParam}}"
```
Para substituir uma variável de nível de trabalho para uma etapa específica, defina uma `stepEnvironments` entrada com o mesmo nome de variável. O exemplo a seguir define `JOB_PROJECT_ID` no nível do trabalho com o valor e`project-12`, em seguida, substitui o valor no nível da etapa com. `step-project-12` As tarefas na etapa usam o valor no nível da etapa.
```
specificationVersion: 'jobtemplate-2023-09'
name: MyJob
jobEnvironments:
- name: JobEnv
variables:
JOB_PROJECT_ID: project-12
steps:
- name: MyStep
stepEnvironments:
- name: StepEnv
variables:
JOB_PROJECT_ID: step-project-12
```
## Experimente: Executando a amostra da variável de ambiente
O repositório de amostras do Deadline Cloud inclui um [pacote de tarefas que demonstra a configuração e a visualização](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_vars/template.yaml) de variáveis de ambiente. O modelo de trabalho de amostra define variáveis nos níveis do trabalho e da etapa e, em seguida, executa uma tarefa que imprime o resultado mesclado. Use o procedimento a seguir para executar a amostra e inspecionar os resultados.
### Pré-requisitos
1. Se você não tiver um farm do Deadline Cloud com uma fila e uma frota Linux associada, siga a experiência de integração guiada no [console do Deadline Cloud](https://console.aws.amazon.com/deadlinecloud/home) para criar um com as configurações padrão.
1. Se você não tiver a CLI do Deadline Cloud e o monitor do AWS Deadline Cloud em sua estação de trabalho, siga as etapas em [Configurar os remetentes do Deadline](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submitter.html) Cloud.
1. Use `git` para clonar o [ GitHubrepositório de amostras do Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples).
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
cd deadline-cloud-samples/job_bundles
```
### Executar o exemplo
1. Use a CLI do Deadline Cloud para enviar a `job_env_vars` amostra.
```
deadline bundle submit job_env_vars
```
1. No monitor do Deadline Cloud, selecione o novo trabalho para monitorar seu progresso. Depois que a Linux frota associada à fila tiver um trabalhador disponível, o trabalho será concluído em alguns segundos. Selecione a tarefa e escolha **Exibir registros** no menu superior direito do painel de tarefas.
### Comparando as ações da sessão com suas definições
A visualização do registro mostra três ações da sessão. Abra o arquivo [job\$1env\$1vars/template.yaml](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_vars/template.yaml) em um editor de texto para comparar cada ação com sua definição no modelo de trabalho.
1. Selecione a ação **Iniciar JobEnv** sessão. A saída do log mostra as variáveis de ambiente no nível do trabalho que estão sendo definidas.
```
Setting: JOB_VERBOSITY=MEDIUM
Setting: JOB_EXAMPLE_PARAM=An example parameter value
Setting: JOB_PROJECT_ID=project-12
Setting: JOB_ENDPOINT_URL=https://internal-host-name/some/path
Setting: QT_QPA_PLATFORM=offscreen
```
As linhas a seguir do modelo de trabalho definem esse ambiente.
```
jobEnvironments:
- name: JobEnv
variables:
JOB_VERBOSITY: MEDIUM
JOB_EXAMPLE_PARAM: "{{Param.ExampleParam}}"
JOB_PROJECT_ID: project-12
JOB_ENDPOINT_URL: https://internal-host-name/some/path
QT_QPA_PLATFORM: offscreen
```
1. Selecione a ação **Iniciar StepEnv** sessão. A saída do log mostra as variáveis em nível de etapa, incluindo as substituídas. `JOB_PROJECT_ID`
```
Setting: STEP_VERBOSITY=HIGH
Setting: JOB_PROJECT_ID=step-project-12
```
As linhas a seguir do modelo de trabalho definem esse ambiente.
```
stepEnvironments:
- name: StepEnv
variables:
STEP_VERBOSITY: HIGH
JOB_PROJECT_ID: step-project-12
```
1. Selecione a ação **Tarefa executar** sessão. A saída do log mostra as variáveis de ambiente mescladas disponíveis para a tarefa. Observe que `JOB_PROJECT_ID` usa o valor em nível de etapa. `step-project-12`
```
Environment variables starting with JOB_*:
JOB_ENDPOINT_URL=https://internal-host-name/some/path
JOB_EXAMPLE_PARAM='An example parameter value'
JOB_PROJECT_ID=step-project-12
JOB_VERBOSITY=MEDIUM
Environment variables starting with STEP_*:
STEP_VERBOSITY=HIGH
```
# Definir o caminho em um ambiente de fila
Use ambientes OpenJD para fornecer novos comandos em um ambiente. Primeiro, você cria um diretório contendo arquivos de script e, em seguida, adiciona esse diretório às variáveis de `PATH` ambiente para que os executáveis em seu script possam executá-los sem precisar especificar o caminho do diretório a cada vez. A lista de variáveis em uma definição de ambiente não fornece uma maneira de modificar a variável, então você faz isso executando um script em vez disso. Depois que o script configura e modifica o`PATH`, ele exporta a variável para o tempo de execução do OpenJD com o comando. `echo "openjd_env: PATH=$PATH"`
## Pré-requisitos
Execute as etapas a seguir para executar o [pacote de tarefas de amostra com variáveis de ambiente](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_vars/template.yaml) do repositório github de amostras do Deadline Cloud.
1. Se você não tiver um farm do Deadline Cloud com uma fila e uma frota Linux associada, siga a experiência de integração guiada no [console do Deadline Cloud](https://console.aws.amazon.com/deadlinecloud/home) para criar um com as configurações padrão.
1. Se você não tiver a CLI do Deadline Cloud e o monitor do Deadline Cloud em sua estação de trabalho, siga as etapas em [Configurar os remetentes do Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submitter.html) no guia do usuário.
1. Use `git` para clonar o [ GitHubrepositório de amostras do Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples).
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
Cloning into 'deadline-cloud-samples'...
...
cd deadline-cloud-samples/job_bundles
```
## Execute a amostra do caminho
1. Use a CLI do Deadline Cloud para enviar a `job_env_with_new_command` amostra.
```
$ deadline bundle submit job_env_with_new_command
Submitting to Queue: MySampleQueue
...
```
1. No monitor do Deadline Cloud, você verá o novo trabalho e poderá monitorar seu progresso. Quando a Linux frota associada à fila tiver um trabalhador disponível para executar a tarefa do trabalho, o trabalho será concluído em alguns segundos. Selecione a tarefa e, em seguida, escolha a opção **Exibir registros** no menu superior direito do painel de tarefas.
À direita estão duas ações de sessão, **Iniciar RandomSleepCommand** e **Executar tarefa**. O visualizador de registros no centro da janela corresponde à ação de sessão selecionada à direita.
## Compare as ações da sessão com suas definições
Nesta seção, você usa o monitor Deadline Cloud para comparar as ações da sessão com o local em que elas estão definidas no modelo de trabalho. Ela continua a partir da seção anterior.
Abra o arquivo [job\$1env\$1with\$1new\$1command/template.yaml em um editor](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_with_new_command/template.yaml) de texto. Compare as ações da sessão com o local em que elas estão definidas no modelo de trabalho.
1. Selecione a ação **Iniciar RandomSleepCommand** sessão no monitor do Deadline Cloud. Você verá a saída do log da seguinte forma.
```
2024/07/16 17:25:32-07:00
2024/07/16 17:25:32-07:00 ==============================================
2024/07/16 17:25:32-07:00 --------- Entering Environment: RandomSleepCommand
2024/07/16 17:25:32-07:00 ==============================================
2024/07/16 17:25:32-07:00 ----------------------------------------------
2024/07/16 17:25:32-07:00 Phase: Setup
2024/07/16 17:25:32-07:00 ----------------------------------------------
2024/07/16 17:25:32-07:00 Writing embedded files for Environment to disk.
2024/07/16 17:25:32-07:00 Mapping: Env.File.Enter -> /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/embedded_filesf3tq_1os/tmpbt8j_c3f
2024/07/16 17:25:32-07:00 Mapping: Env.File.SleepScript -> /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/embedded_filesf3tq_1os/tmperastlp4
2024/07/16 17:25:32-07:00 Wrote: Enter -> /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/embedded_filesf3tq_1os/tmpbt8j_c3f
2024/07/16 17:25:32-07:00 Wrote: SleepScript -> /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/embedded_filesf3tq_1os/tmperastlp4
2024/07/16 17:25:32-07:00 ----------------------------------------------
2024/07/16 17:25:32-07:00 Phase: Running action
2024/07/16 17:25:32-07:00 ----------------------------------------------
2024/07/16 17:25:32-07:00 Running command sudo -u job-user -i setsid -w /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/tmpbwrquq5u.sh
2024/07/16 17:25:32-07:00 Command started as pid: 2205
2024/07/16 17:25:32-07:00 Output:
2024/07/16 17:25:33-07:00 openjd_env: PATH=/sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/bin:/opt/conda/condabin:/home/job-user/.local/bin:/home/job-user/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/var/lib/snapd/snap/bin
No newer logs at this moment.
```
As linhas a seguir do modelo de trabalho especificaram essa ação.
```
jobEnvironments:
- name: RandomSleepCommand
description: Adds a command 'random-sleep' to the environment.
script:
actions:
onEnter:
command: bash
args:
- "{{Env.File.Enter}}"
embeddedFiles:
- name: Enter
type: TEXT
data: |
#!/bin/env bash
set -euo pipefail
# Make a bin directory inside the session's working directory for providing new commands
mkdir -p '{{Session.WorkingDirectory}}/bin'
# If this bin directory is not already in the PATH, then add it
if ! [[ ":$PATH:" == *':{{Session.WorkingDirectory}}/bin:'* ]]; then
export "PATH={{Session.WorkingDirectory}}/bin:$PATH"
# This message to Open Job Description exports the new PATH value to the environment
echo "openjd_env: PATH=$PATH"
fi
# Copy the SleepScript embedded file into the bin directory
cp '{{Env.File.SleepScript}}' '{{Session.WorkingDirectory}}/bin/random-sleep'
chmod u+x '{{Session.WorkingDirectory}}/bin/random-sleep'
- name: SleepScript
type: TEXT
runnable: true
data: |
...
```
1. Selecione a ação **Iniciar StepEnv** sessão no monitor do Deadline Cloud. Você vê a saída do log da seguinte forma.
```
2024/07/16 17:25:33-07:00
2024/07/16 17:25:33-07:00 ==============================================
2024/07/16 17:25:33-07:00 --------- Running Task
2024/07/16 17:25:33-07:00 ==============================================
2024/07/16 17:25:33-07:00 ----------------------------------------------
2024/07/16 17:25:33-07:00 Phase: Setup
2024/07/16 17:25:33-07:00 ----------------------------------------------
2024/07/16 17:25:33-07:00 Writing embedded files for Task to disk.
2024/07/16 17:25:33-07:00 Mapping: Task.File.Run -> /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/embedded_filesf3tq_1os/tmpdrwuehjf
2024/07/16 17:25:33-07:00 Wrote: Run -> /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/embedded_filesf3tq_1os/tmpdrwuehjf
2024/07/16 17:25:33-07:00 ----------------------------------------------
2024/07/16 17:25:33-07:00 Phase: Running action
2024/07/16 17:25:33-07:00 ----------------------------------------------
2024/07/16 17:25:33-07:00 Running command sudo -u job-user -i setsid -w /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/tmpz81iaqfw.sh
2024/07/16 17:25:33-07:00 Command started as pid: 2256
2024/07/16 17:25:33-07:00 Output:
2024/07/16 17:25:34-07:00 + random-sleep 12.5 27.5
2024/07/16 17:26:00-07:00 Sleeping for duration 26.90
2024/07/16 17:26:00-07:00 ----------------------------------------------
2024/07/16 17:26:00-07:00 Uploading output files to Job Attachments
2024/07/16 17:26:00-07:00 ----------------------------------------------
```
1. As linhas a seguir do modelo de trabalho especificaram essa ação.
```
steps:
- name: EnvWithCommand
script:
actions:
onRun:
command: bash
args:
- '{{Task.File.Run}}'
embeddedFiles:
- name: Run
type: TEXT
data: |
set -xeuo pipefail
# Run the script installed into PATH by the job environment
random-sleep 12.5 27.5
hostRequirements:
attributes:
- name: attr.worker.os.family
anyOf:
- linux
```
# Execute um processo daemon em segundo plano a partir do ambiente de fila
Em muitos casos de uso de renderização, carregar os dados do aplicativo e da cena pode levar um tempo significativo. Se um trabalho os recarregar para cada quadro, ele passará a maior parte do tempo sobrecarregando. Geralmente, é possível carregar o aplicativo uma vez como um processo daemon em segundo plano, fazer com que ele carregue os dados da cena e, em seguida, envie comandos via comunicação entre processos (IPC) para realizar as renderizações.
Muitas das integrações de código aberto do Deadline Cloud usam esse padrão. O projeto Open Job Description fornece uma [biblioteca de tempo de execução de adaptadores](https://github.com/OpenJobDescription/openjd-adaptor-runtime-for-python) com padrões robustos de IPC em todos os sistemas operacionais compatíveis.
Para demonstrar esse padrão, há um [pacote de tarefas de amostra independente](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_daemon_process/template.yaml) que usa Python e código bash para implementar um daemon em segundo plano e o IPC para tarefas de comunicação com ele. O daemon é implementado em Python e escuta um SIGUSR1 sinal POSIX para saber quando processar uma tarefa. Os detalhes da tarefa são passados para o daemon em um arquivo JSON específico e os resultados da execução da tarefa são retornados como outro arquivo JSON.
## Pré-requisitos
Execute as etapas a seguir para executar o [pacote de tarefas de amostra com um processo daemon](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_daemon_process/template.yaml) do repositório github de amostras do Deadline Cloud.
1. Se você não tiver um farm do Deadline Cloud com uma fila e uma frota Linux associada, siga a experiência de integração guiada no [console do Deadline Cloud](https://console.aws.amazon.com/deadlinecloud/home) para criar um com as configurações padrão.
1. Se você não tiver a CLI do Deadline Cloud e o monitor do Deadline Cloud em sua estação de trabalho, siga as etapas em [Configurar os remetentes do Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submitter.html) no guia do usuário.
1. Use `git` para clonar o [ GitHubrepositório de amostras do Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples).
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
Cloning into 'deadline-cloud-samples'...
...
cd deadline-cloud-samples/job_bundles
```
## Execute a amostra do daemon
1. Use a CLI do Deadline Cloud para enviar a `job_env_daemon_process` amostra.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
Cloning into 'deadline-cloud-samples'...
...
cd deadline-cloud-samples/job_bundles
```
1. No aplicativo de monitoramento Deadline Cloud, você verá o novo trabalho e poderá monitorar seu progresso. Quando a Linux frota associada à fila tiver um trabalhador disponível para executar a tarefa, ela será concluída em cerca de um minuto. Com uma das tarefas selecionadas, escolha a opção **Exibir registros** no menu superior direito do painel de tarefas.
À direita, há duas ações de sessão, **Iniciar DaemonProcess** e **Executar tarefa**. O visualizador de registros no centro da janela corresponde à ação de sessão selecionada à direita.
Selecione a opção **Exibir registros de todas as tarefas**. A linha do tempo mostra o restante das tarefas executadas como parte da sessão e a `Shut down DaemonProcess` ação que saiu do ambiente.
## Exibir os registros do daemon
1. Nesta seção, você usa o monitor Deadline Cloud para comparar as ações da sessão com o local em que elas estão definidas no modelo de trabalho. Ela continua a partir da seção anterior.
Abra o arquivo [job\$1env\$1daemon\$1process/template.yaml em um editor](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_daemon_process/template.yaml) de texto. Compare as ações da sessão com o local em que elas estão definidas no modelo de trabalho.
1. Selecione a ação da `Launch DaemonProcess` sessão no monitor do Deadline Cloud. Você verá a saída do log da seguinte forma.
```
2024/07/17 16:27:20-07:00
2024/07/17 16:27:20-07:00 ==============================================
2024/07/17 16:27:20-07:00 --------- Entering Environment: DaemonProcess
2024/07/17 16:27:20-07:00 ==============================================
2024/07/17 16:27:20-07:00 ----------------------------------------------
2024/07/17 16:27:20-07:00 Phase: Setup
2024/07/17 16:27:20-07:00 ----------------------------------------------
2024/07/17 16:27:20-07:00 Writing embedded files for Environment to disk.
2024/07/17 16:27:20-07:00 Mapping: Env.File.Enter -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/enter-daemon-process-env.sh
2024/07/17 16:27:20-07:00 Mapping: Env.File.Exit -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/exit-daemon-process-env.sh
2024/07/17 16:27:20-07:00 Mapping: Env.File.DaemonScript -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/daemon-script.py
2024/07/17 16:27:20-07:00 Mapping: Env.File.DaemonHelperFunctions -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/daemon-helper-functions.sh
2024/07/17 16:27:20-07:00 Wrote: Enter -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/enter-daemon-process-env.sh
2024/07/17 16:27:20-07:00 Wrote: Exit -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/exit-daemon-process-env.sh
2024/07/17 16:27:20-07:00 Wrote: DaemonScript -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/daemon-script.py
2024/07/17 16:27:20-07:00 Wrote: DaemonHelperFunctions -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/daemon-helper-functions.sh
2024/07/17 16:27:20-07:00 ----------------------------------------------
2024/07/17 16:27:20-07:00 Phase: Running action
2024/07/17 16:27:20-07:00 ----------------------------------------------
2024/07/17 16:27:20-07:00 Running command sudo -u job-user -i setsid -w /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/tmp_u8slys3.sh
2024/07/17 16:27:20-07:00 Command started as pid: 2187
2024/07/17 16:27:20-07:00 Output:
2024/07/17 16:27:21-07:00 openjd_env: DAEMON_LOG=/sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/daemon.log
2024/07/17 16:27:21-07:00 openjd_env: DAEMON_PID=2223
2024/07/17 16:27:21-07:00 openjd_env: DAEMON_BASH_HELPER_SCRIPT=/sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/daemon-helper-functions.sh
```
As linhas a seguir do modelo de trabalho especificaram essa ação.
```
stepEnvironments:
- name: DaemonProcess
description: Runs a daemon process for the step's tasks to share.
script:
actions:
onEnter:
command: bash
args:
- "{{Env.File.Enter}}"
onExit:
command: bash
args:
- "{{Env.File.Exit}}"
embeddedFiles:
- name: Enter
filename: enter-daemon-process-env.sh
type: TEXT
data: |
#!/bin/env bash
set -euo pipefail
DAEMON_LOG='{{Session.WorkingDirectory}}/daemon.log'
echo "openjd_env: DAEMON_LOG=$DAEMON_LOG"
nohup python {{Env.File.DaemonScript}} > $DAEMON_LOG 2>&1 &
echo "openjd_env: DAEMON_PID=$!"
echo "openjd_env: DAEMON_BASH_HELPER_SCRIPT={{Env.File.DaemonHelperFunctions}}"
echo 0 > 'daemon_log_cursor.txt'
...
```
1. Selecione uma das ações de sessão Tarefa Executar: N no monitor do Deadline Cloud. Você verá a saída do log da seguinte forma.
```
2024/07/17 16:27:22-07:00
2024/07/17 16:27:22-07:00 ==============================================
2024/07/17 16:27:22-07:00 --------- Running Task
2024/07/17 16:27:22-07:00 ==============================================
2024/07/17 16:27:22-07:00 Parameter values:
2024/07/17 16:27:22-07:00 Frame(INT) = 2
2024/07/17 16:27:22-07:00 ----------------------------------------------
2024/07/17 16:27:22-07:00 Phase: Setup
2024/07/17 16:27:22-07:00 ----------------------------------------------
2024/07/17 16:27:22-07:00 Writing embedded files for Task to disk.
2024/07/17 16:27:22-07:00 Mapping: Task.File.Run -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/run-task.sh
2024/07/17 16:27:22-07:00 Wrote: Run -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/run-task.sh
2024/07/17 16:27:22-07:00 ----------------------------------------------
2024/07/17 16:27:22-07:00 Phase: Running action
2024/07/17 16:27:22-07:00 ----------------------------------------------
2024/07/17 16:27:22-07:00 Running command sudo -u job-user -i setsid -w /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/tmpv4obfkhn.sh
2024/07/17 16:27:22-07:00 Command started as pid: 2301
2024/07/17 16:27:22-07:00 Output:
2024/07/17 16:27:23-07:00 Daemon PID is 2223
2024/07/17 16:27:23-07:00 Daemon log file is /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/daemon.log
2024/07/17 16:27:23-07:00
2024/07/17 16:27:23-07:00 === Previous output from daemon
2024/07/17 16:27:23-07:00 ===
2024/07/17 16:27:23-07:00
2024/07/17 16:27:23-07:00 Sending command to daemon
2024/07/17 16:27:23-07:00 Received task result:
2024/07/17 16:27:23-07:00 {
2024/07/17 16:27:23-07:00 "result": "SUCCESS",
2024/07/17 16:27:23-07:00 "processedTaskCount": 1,
2024/07/17 16:27:23-07:00 "randomValue": 0.2578537967668988,
2024/07/17 16:27:23-07:00 "failureRate": 0.1
2024/07/17 16:27:23-07:00 }
2024/07/17 16:27:23-07:00
2024/07/17 16:27:23-07:00 === Daemon log from running the task
2024/07/17 16:27:23-07:00 Loading the task details file
2024/07/17 16:27:23-07:00 Received task details:
2024/07/17 16:27:23-07:00 {
2024/07/17 16:27:23-07:00 "pid": 2329,
2024/07/17 16:27:23-07:00 "frame": 2
2024/07/17 16:27:23-07:00 }
2024/07/17 16:27:23-07:00 Processing frame number 2
2024/07/17 16:27:23-07:00 Writing result
2024/07/17 16:27:23-07:00 Waiting until a USR1 signal is sent...
2024/07/17 16:27:23-07:00 ===
2024/07/17 16:27:23-07:00
2024/07/17 16:27:23-07:00 ----------------------------------------------
2024/07/17 16:27:23-07:00 Uploading output files to Job Attachments
2024/07/17 16:27:23-07:00 ----------------------------------------------
```
As seguintes linhas do modelo de trabalho são as que especificaram essa ação. ```etapas:
```
steps:
- name: EnvWithDaemonProcess
parameterSpace:
taskParameterDefinitions:
- name: Frame
type: INT
range: "{{Param.Frames}}"
stepEnvironments:
...
script:
actions:
onRun:
timeout: 60
command: bash
args:
- '{{Task.File.Run}}'
embeddedFiles:
- name: Run
filename: run-task.sh
type: TEXT
data: |
# This bash script sends a task to the background daemon process,
# then waits for it to respond with the output result.
set -euo pipefail
source "$DAEMON_BASH_HELPER_SCRIPT"
echo "Daemon PID is $DAEMON_PID"
echo "Daemon log file is $DAEMON_LOG"
print_daemon_log "Previous output from daemon"
send_task_to_daemon "{\"pid\": $$, \"frame\": {{Task.Param.Frame}} }"
wait_for_daemon_task_result
echo Received task result:
echo "$TASK_RESULT" | jq .
print_daemon_log "Daemon log from running the task"
hostRequirements:
attributes:
- name: attr.worker.os.family
anyOf:
- linux
```
# Forneça inscrições para seus empregos
Você pode usar um ambiente de fila para carregar aplicativos e processar seus trabalhos. Ao criar uma frota gerenciada por serviços usando o console do Deadline Cloud, você tem a opção de criar um ambiente de fila que usa o gerenciador de pacotes conda para carregar aplicativos.
Se quiser usar um gerenciador de pacotes diferente, você pode criar um ambiente de fila para esse gerenciador. Para obter um exemplo de uso do Rez, consulte[Use um gerenciador de pacotes diferente](#provide-applications-other-package).
O Deadline Cloud fornece um canal conda para carregar uma seleção de aplicativos de renderização em seu ambiente. Eles apoiam os remetentes que o Deadline Cloud fornece para aplicativos de criação de conteúdo digital.
Você também pode carregar software para o conda-forge usar em seus trabalhos. Os exemplos a seguir mostram modelos de trabalho usando o ambiente de fila fornecido pelo Deadline Cloud para carregar aplicativos antes de executar o trabalho.
**Topics**
+ [Obtendo um aplicativo de um canal conda](#provide-applications-get-application)
+ [Use um gerenciador de pacotes diferente](#provide-applications-other-package)
## Obtendo um aplicativo de um canal conda
Você pode criar um ambiente de fila personalizado para seus funcionários do Deadline Cloud que instala o software de sua escolha. Esse exemplo de ambiente de fila tem o mesmo comportamento do ambiente usado pelo console para frotas gerenciadas por serviços. Ele executa o conda diretamente para criar o ambiente.
O ambiente cria um novo ambiente virtual conda para cada sessão do Deadline Cloud que é executada em um trabalhador e, em seguida, exclui o ambiente quando termina.
O Conda armazena em cache os pacotes baixados para que eles não precisem ser baixados novamente, mas cada sessão deve vincular todos os pacotes ao ambiente.
O ambiente define três scripts que são executados quando o Deadline Cloud inicia uma sessão em um trabalhador. O primeiro script é executado quando a `onEnter` ação é chamada. Ele chama os outros dois para configurar variáveis de ambiente. Quando o script termina de ser executado, o ambiente conda fica disponível com todas as variáveis de ambiente especificadas definidas.
Para ver a versão mais recente do exemplo, consulte [conda\$1queue\$1env\$1console\$1equivalent.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/conda_queue_env_console_equivalent.yaml) no repositório em. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline) GitHub
Se você quiser usar um aplicativo que não está disponível no canal conda, você pode criar um canal conda no Amazon S3 e, em seguida, criar seus próprios pacotes para esse aplicativo. Para saber mais, consulte [Crie um canal conda usando o S3](configure-jobs-s3-channel.md).
### Obtenha bibliotecas de código aberto do conda-forge
Esta seção descreve como usar bibliotecas de código aberto do `conda-forge` canal. O exemplo a seguir é um modelo de trabalho que usa o `polars` pacote Python.
O trabalho define os `CondaChannels` parâmetros `CondaPackages` e definidos no ambiente de fila que informam ao Deadline Cloud onde obter o pacote.
A seção do modelo de trabalho que define os parâmetros é:
```
- name: CondaPackages
description: A list of conda packages to install. The job expects a Queue Environment to handle this.
type: STRING
default: polars
- name: CondaChannels
description: A list of conda channels to get packages from. The job expects a Queue Environment to handle this.
type: STRING
default: conda-forge
```
Para ver a versão mais recente do exemplo completo do modelo de trabalho, consulte [stage\$11\$1self\$1contained\$1template/template.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/job_bundles/job_dev_progression/stage_1_self_contained_template/template.yaml). Para a versão mais recente do ambiente de filas que carrega os pacotes conda, consulte [conda\$1queue\$1env\$1console\$1equivalent.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/conda_queue_env_console_equivalent.yaml) no repositório em. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline) GitHub
### Obtenha a Blender partir do canal Deadline-Cloud
O exemplo a seguir mostra um modelo de trabalho que Blender vem do canal `deadline-cloud` conda. Esse canal oferece suporte aos remetentes que o Deadline Cloud fornece para software de criação de conteúdo digital, embora você possa usar o mesmo canal para carregar o software para seu próprio uso.
Para ver uma lista do software fornecido pelo `deadline-cloud` canal, consulte [Ambiente de fila padrão](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html#conda-queue-environment) no *Guia do usuário do AWS Deadline Cloud*.
Esse trabalho define o `CondaPackages` parâmetro definido no ambiente de fila para fazer com que o Deadline Cloud seja carregado Blender no ambiente.
A seção do modelo de trabalho que define o parâmetro é:
```
- name: CondaPackages
type: STRING
userInterface:
control: LINE_EDIT
label: Conda Packages
groupLabel: Software Environment
default: blender
description: >
Tells the queue environment to install Blender from the deadline-cloud conda channel.
```
Para ver a versão mais recente do exemplo completo do modelo de trabalho, consulte [blender\$1render/template.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/job_bundles/blender_render/template.yaml). Para a versão mais recente do ambiente de filas que carrega os pacotes conda, consulte [conda\$1queue\$1env\$1console\$1equivalent.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/conda_queue_env_console_equivalent.yaml) no repositório em. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline)GitHub
## Use um gerenciador de pacotes diferente
O gerenciador de pacotes padrão do Deadline Cloud é o conda. Se você precisar usar um gerenciador de pacotes diferente, comoRez, você pode criar um ambiente de fila personalizado que contém scripts que usam seu gerenciador de pacotes em vez disso.
Esse exemplo de ambiente de fila fornece o mesmo comportamento do ambiente usado pelo console para frotas gerenciadas por serviços. Ele substitui o gerenciador de pacotes conda por. Rez
O ambiente define três scripts que são executados quando o Deadline Cloud inicia uma sessão em um trabalhador. O primeiro script é executado quando a `onEnter` ação é chamada. Ele chama os outros dois para configurar variáveis de ambiente. Quando a execução do script termina, o Rez ambiente fica disponível com todas as variáveis de ambiente especificadas definidas.
O exemplo pressupõe que você tenha uma frota gerenciada pelo cliente que usa um sistema de arquivos compartilhado para os pacotes Rez.
Para ver a versão mais recente do exemplo, consulte [rez\$1queue\$1env.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/rez_queue_env.yaml) no repositório em. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline)GitHub