Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Configure los trabajos mediante entornos de colas
AWS Deadline Cloud utiliza *entornos de colas* para configurar el software de sus trabajadores. Un entorno le permite realizar tareas que requieren mucho tiempo, como la configuración y el desmontaje, de una sola vez para todas las tareas de una sesión. Define las acciones que debe ejecutar un trabajador al iniciar o detener una sesión. Puede configurar un entorno para una cola, los trabajos que se ejecutan en la cola y los pasos individuales de un trabajo.
Los entornos se definen como entornos de colas o entornos de trabajo. Cree entornos de colas con la consola de Deadline Cloud o con la [fecha límite: CreateQueueEnvironment](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateQueueEnvironment.html) opere y defina los entornos de trabajo en las plantillas de trabajo de los trabajos que envíe. Siguen la especificación Open Job Description (OpenJD) para los entornos. Para obtener más información, consulte[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) la especificación de OpenJD sobre. GitHub
Además de una `name` y`description`, cada entorno contiene dos campos que definen el entorno del host. Son los siguientes:
+ `script`— La acción que se lleva a cabo cuando este entorno se ejecuta en un trabajador.
+ `variables`— Un conjunto de name/value pares de variables de entorno que se establecen al entrar en el entorno.
Debe establecer al menos uno de los siguientes valores: `script` o`variables`.
Puede definir más de un entorno en su plantilla de trabajo. Cada entorno se aplica en el orden en que aparecen en la plantilla. Puede usarlo para ayudar a gestionar la complejidad de sus entornos.
El entorno de colas predeterminado de Deadline Cloud usa el administrador de paquetes conda para cargar el software en el entorno, pero puedes usar otros administradores de paquetes. El entorno predeterminado define dos parámetros para especificar el software que se debe cargar. Estas variables las configuran los remitentes proporcionados por Deadline Cloud, aunque puedes configurarlas en tus propios scripts y aplicaciones que utilizan el entorno predeterminado. Son los siguientes:
+ `CondaPackages`— Una lista separada por espacios de los paquetes conda que coinciden con las especificaciones que se deben instalar para el trabajo. Por ejemplo, el remitente de Blender añadiría fotogramas `blender=3.6` para renderizar en Blender 3.6.
+ `CondaChannels`— Una lista de canales conda separados por espacios desde los que instalar paquetes. En el caso de las flotas gestionadas por servicios, los paquetes se instalan desde el canal. `deadline-cloud` Puede añadir otros canales.
# Controle el entorno de trabajo con los entornos de colas de OpenJD
Puede definir entornos personalizados para sus trabajos de renderizado mediante *entornos de cola.* Un entorno de colas es una plantilla que controla las variables de entorno, las asignaciones de archivos y otros ajustes de los trabajos que se ejecutan en una cola específica. Le permite adaptar el entorno de ejecución de los trabajos enviados a una cola en función de los requisitos de sus cargas de trabajo. AWS Deadline Cloud ofrece tres niveles anidados en los que puede aplicar [entornos de Open Job Description (OpenJD)](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment): cola, trabajo y paso. Al definir los entornos de colas, puedes garantizar un rendimiento uniforme y optimizado para los distintos tipos de trabajos, agilizar la asignación de recursos y simplificar la gestión de las colas.
El entorno de colas es una plantilla que se adjunta a una cola de la AWS cuenta desde la consola de AWS administración o mediante la. AWS CLI Puede crear un entorno para una cola o puede crear varios entornos de cola que se apliquen para crear el entorno de ejecución. Este enfoque le permite crear y probar un entorno por pasos para garantizar que funcione correctamente en sus trabajos.
Los entornos de trabajos y pasos se definen en la plantilla de trabajo que se utiliza para crear un trabajo en la cola. La sintaxis de OpenJD es la misma en estos distintos tipos de entornos. En esta sección, las mostraremos dentro de las plantillas de trabajo.
**Topics**
+ [Establezca las variables de entorno en un entorno de colas](set-environment-variables.md)
+ [Establezca la ruta en un entorno de cola](set-the-path.md)
+ [Ejecute un proceso daemon en segundo plano desde el entorno de colas](run-a-background-daemon-process.md)
# Establezca las variables de entorno en un entorno de colas
Muchas aplicaciones y marcos utilizan variables de entorno para controlar la configuración de las funciones, los niveles de registro y la configuración de la pantalla. Puede usar los [entornos Open Job Description (OpenJD)](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment) para establecer variables de entorno que herede cada comando de tarea dentro de su ámbito.
## Ámbito de la variable de entorno
AWS Deadline Cloud aplica variables de entorno de los entornos de colas que se adjuntan a una cola. Dentro de una plantilla de trabajo, también puede definir variables de entorno a nivel de trabajo y paso mediante entornos de [OpenJD](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment). Las variables definidas en un ámbito más limitado anulan las variables con el mismo nombre de un ámbito más amplio.
+ **Entorno de colas**: plantilla que se adjunta a una cola en Deadline Cloud. Las variables se aplican a todos los trabajos enviados a la cola. Puede configurar las variables con un `variables` mapa para valores fijos o utilizar scripts para valores dinámicos.
+ **Entorno laboral**: se define `jobEnvironments` en una plantilla de trabajo. Las variables se aplican a todos los pasos y tareas del trabajo. Una variable de nivel de trabajo anula una variable de nivel de cola con el mismo nombre.
+ **Entorno escalonado**: se define en una plantilla de trabajo. `stepEnvironments` Las variables se aplican solo a las tareas de ese paso. Una variable de nivel de paso anula una variable de nivel de trabajo o de cola con el mismo nombre.
## Establecer variables en un entorno de colas
Puede configurar las variables de entorno en un entorno de colas mediante un `variables` mapa para valores fijos o mediante una `script` `onEnter` acción para valores dinámicos.
La siguiente plantilla de entorno de colas utiliza un `variables` mapa para establecer la `QT_QPA_PLATFORM` variable`offscreen`, lo que permite que las aplicaciones que utilizan [Qt Framework](https://www.qt.io/product/framework) se ejecuten en hosts de trabajo sin una pantalla interactiva.
```
specificationVersion: 'environment-2023-09'
environment:
name: QtOffscreen
variables:
QT_QPA_PLATFORM: offscreen
```
Para valores dinámicos, como modificar `PATH` o activar entornos virtuales, utilice un script que imprima las líneas en formato `openjd_env: VAR=value` stdout. El `openjd_env:` prefijo es obligatorio. El uso de `echo``export`, u otros mecanismos de shell sin el prefijo no propaga las variables a los trabajos y tareas.
La siguiente plantilla de entorno de colas establece la `QT_QPA_PLATFORM` variable mediante un 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 adjuntar un entorno de colas a su cola, utilice la consola de Deadline Cloud o la. AWS CLI Para obtener más información, consulte [Crear un entorno de colas](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html) en la Guía del usuario de AWS Deadline Cloud. El siguiente AWS CLI comando crea un entorno de colas a partir de un archivo de plantilla.
```
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 ver ejemplos más complejos, como la creación y activación de entornos virtuales de conda, consulte los ejemplos del [entorno de colas de Deadline Cloud en](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/queue_environments). GitHub
## Establecer variables en una plantilla de trabajo
En una plantilla de trabajo, añada un `variables` mapa a una `stepEnvironments` entrada `jobEnvironments` o. Cada entrada es un par clave-valor en el que la clave es el nombre de la variable y el valor es el valor de la variable.
La siguiente plantilla de trabajo establece la variable de `QT_QPA_PLATFORM` entorno en`offscreen`, lo que permite que las aplicaciones que utilizan [Qt Framework](https://www.qt.io/product/framework) se ejecuten en hosts de trabajo sin una pantalla interactiva.
```
specificationVersion: 'jobtemplate-2023-09'
name: MyJob
jobEnvironments:
- name: JobEnv
variables:
QT_QPA_PLATFORM: offscreen
```
Puede establecer múltiples variables en una sola definición de entorno.
```
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
```
Puede hacer referencia a los parámetros del trabajo en valores variables mediante la `{{Param.ParameterName}}` sintaxis.
```
jobEnvironments:
- name: JobEnv
variables:
JOB_EXAMPLE_PARAM: "{{Param.ExampleParam}}"
```
Para anular una variable de nivel de trabajo para un paso específico, defina una `stepEnvironments` entrada con el mismo nombre de variable. En el siguiente ejemplo, se define `JOB_PROJECT_ID` en el nivel de trabajo con el valor y`project-12`, a continuación, se reemplaza el valor en el nivel de paso con. `step-project-12` Las tareas del paso utilizan el valor del nivel de paso.
```
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
```
## Pruébelo: ejecute el ejemplo de la variable de entorno
El repositorio de muestras de Deadline Cloud incluye un [paquete de trabajos que muestra la configuración y visualización de las variables de entorno](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_vars/template.yaml). La plantilla de trabajo de muestra define las variables tanto a nivel de trabajo como de paso y, a continuación, ejecuta una tarea que imprime el resultado combinado. Utilice el siguiente procedimiento para ejecutar la muestra e inspeccionar los resultados.
### Requisitos previos
1. Si no tiene una granja de Deadline Cloud con una cola y una flota Linux asociada, siga la experiencia de incorporación guiada en la [consola de Deadline Cloud](https://console.aws.amazon.com/deadlinecloud/home) para crear una con la configuración predeterminada.
1. Si no tiene la CLI de Deadline Cloud ni el monitor de AWS Deadline Cloud en su estación de trabajo, siga los pasos de [Configurar los remitentes de Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submitter.html).
1. Úselo `git` para clonar el repositorio de [muestras GitHub de 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
```
### Ejecución del ejemplo
1. Utilice la CLI de Deadline Cloud para enviar la `job_env_vars` muestra.
```
deadline bundle submit job_env_vars
```
1. En el monitor de Deadline Cloud, selecciona el nuevo trabajo para supervisar su progreso. Cuando la Linux flota asociada a la cola tenga un trabajador disponible, el trabajo se completará en unos segundos. Seleccione la tarea y, a continuación, elija **Ver registros** en el menú superior derecho del panel de tareas.
### Comparar las acciones de la sesión con sus definiciones
La vista de registro muestra tres acciones de la sesión. Abra el archivo [job\$1env\$1vars/template.yaml](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_vars/template.yaml) en un editor de texto para comparar cada acción con su definición en la plantilla de trabajo.
1. ** JobEnvSeleccione** la acción Iniciar sesión. El resultado del registro muestra las variables de entorno a nivel de trabajo que se están configurando.
```
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
```
Las siguientes líneas de la plantilla de trabajo definen este entorno.
```
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. Seleccione la acción **Iniciar StepEnv** sesión. El resultado del registro muestra las variables a nivel de paso, incluidas las anuladas`JOB_PROJECT_ID`.
```
Setting: STEP_VERBOSITY=HIGH
Setting: JOB_PROJECT_ID=step-project-12
```
Las siguientes líneas de la plantilla de trabajo definen este entorno.
```
stepEnvironments:
- name: StepEnv
variables:
STEP_VERBOSITY: HIGH
JOB_PROJECT_ID: step-project-12
```
1. Seleccione la acción **Tarea ejecutar** sesión. El resultado del registro muestra las variables de entorno combinadas disponibles para la tarea. Observe que `JOB_PROJECT_ID` utiliza el valor `step-project-12` de nivel escalonado.
```
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
```
# Establezca la ruta en un entorno de cola
Utilice los entornos OpenJD para proporcionar nuevos comandos en un entorno. Primero, cree un directorio que contenga los archivos de script y, a continuación, añada ese directorio a las variables de `PATH` entorno para que los ejecutables del script puedan ejecutarlos sin necesidad de especificar la ruta del directorio cada vez. La lista de variables de una definición de entorno no proporciona una forma de modificar la variable, por lo que, en su lugar, se ejecuta un script. Una vez que el script configura las cosas y las modifica`PATH`, exporta la variable al motor de ejecución de OpenJD con el comando. `echo "openjd_env: PATH=$PATH"`
## Requisitos previos
Realice los siguientes pasos para ejecutar el [paquete de trabajos de muestra con variables de entorno](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_vars/template.yaml) del repositorio de muestras de Deadline Cloud en GitHub.
1. Si no tienes una granja de Deadline Cloud con una cola y una flota Linux asociada, sigue la experiencia de incorporación guiada en la [consola de Deadline Cloud](https://console.aws.amazon.com/deadlinecloud/home) para crear una con la configuración predeterminada.
1. Si no tiene la CLI de Deadline Cloud ni el monitor de Deadline Cloud en su estación de trabajo, siga los pasos de [Configurar los remitentes de Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submitter.html) de la guía del usuario.
1. Úselo `git` para clonar el repositorio de [muestras GitHub de 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
```
## Ejecute el ejemplo de ruta
1. Utilice la CLI de Deadline Cloud para enviar la `job_env_with_new_command` muestra.
```
$ deadline bundle submit job_env_with_new_command
Submitting to Queue: MySampleQueue
...
```
1. En el monitor de Deadline Cloud, verá el nuevo trabajo y podrá supervisar su progreso. Una vez que la Linux flota asociada a la cola tenga un trabajador disponible para ejecutar la tarea, ésta se completará en unos segundos. Seleccione la tarea y, a continuación, elija la opción **Ver registros** en el menú superior derecho del panel de tareas.
A la derecha hay dos acciones de sesión: **Iniciar RandomSleepCommand** y **ejecutar una tarea**. El visor de registros en el centro de la ventana corresponde a la acción de sesión seleccionada a la derecha.
## Compare las acciones de la sesión con sus definiciones
En esta sección, utiliza el monitor de Deadline Cloud para comparar las acciones de la sesión con el lugar en el que están definidas en la plantilla de trabajo. Es la continuación de la sección anterior.
Abre el archivo [job\$1env\$1with\$1new\$1command/template.yaml en un editor de texto](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_with_new_command/template.yaml). Compare las acciones de la sesión con el lugar donde están definidas en la plantilla de trabajo.
1. Seleccione la acción **Iniciar RandomSleepCommand** sesión en el monitor de Deadline Cloud. Verá el resultado del registro de la siguiente manera.
```
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.
```
Las siguientes líneas de la plantilla de trabajo especifican esta acción.
```
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. Seleccione la acción **Iniciar StepEnv** sesión en el monitor de Deadline Cloud. El resultado del registro se muestra de la siguiente manera.
```
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. Las siguientes líneas de la plantilla de trabajo especificaban esta acción.
```
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
```
# Ejecute un proceso daemon en segundo plano desde el entorno de colas
En muchos casos de uso del renderizado, cargar los datos de la aplicación y de la escena puede llevar un tiempo considerable. Si un trabajo los vuelve a cargar para cada fotograma, pasará la mayor parte del tiempo sobrecargado. A menudo es posible cargar la aplicación una vez como un proceso daemon en segundo plano, hacer que cargue los datos de la escena y, a continuación, enviarle comandos mediante la comunicación entre procesos (IPC) para realizar los renderizados.
Muchas de las integraciones de código abierto de Deadline Cloud utilizan este patrón. El proyecto Open Job Description proporciona una [biblioteca de tiempo de ejecución de adaptadores](https://github.com/OpenJobDescription/openjd-adaptor-runtime-for-python) con patrones de IPC sólidos en todos los sistemas operativos compatibles.
Para demostrar este patrón, hay un [paquete de trabajos de muestra autónomo](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_daemon_process/template.yaml) que utiliza Python y código bash para implementar un daemon en segundo plano y el IPC para que las tareas se comuniquen con él. El daemon está implementado en Python y escucha una SIGUSR1 señal POSIX para saber cuándo procesar una tarea. Los detalles de la tarea se pasan al daemon en un archivo JSON específico y los resultados de la ejecución de la tarea se devuelven como otro archivo JSON.
## Requisitos previos
Realice los siguientes pasos para ejecutar el [paquete de trabajos de muestra con un proceso daemon](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_daemon_process/template.yaml) del repositorio de muestras de Deadline Cloud en GitHub.
1. Si no tienes una granja de Deadline Cloud con una cola y una flota Linux asociada, sigue la experiencia de incorporación guiada en la [consola de Deadline Cloud](https://console.aws.amazon.com/deadlinecloud/home) para crear una con la configuración predeterminada.
1. Si no tiene la CLI de Deadline Cloud ni el monitor de Deadline Cloud en su estación de trabajo, siga los pasos de [Configurar los remitentes de Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submitter.html) de la guía del usuario.
1. Úselo `git` para clonar el repositorio de [muestras GitHub de 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
```
## Ejecute el ejemplo del daemon
1. Utilice la CLI de Deadline Cloud para enviar la `job_env_daemon_process` muestra.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
Cloning into 'deadline-cloud-samples'...
...
cd deadline-cloud-samples/job_bundles
```
1. En la aplicación de monitoreo de Deadline Cloud, verá el nuevo trabajo y podrá monitorear su progreso. Una vez que la Linux flota asociada a la cola tenga un trabajador disponible para ejecutar la tarea, la tarea se completará en aproximadamente un minuto. Con una de las tareas seleccionada, selecciona la opción **Ver registros** en el menú superior derecho del panel de tareas.
A la derecha hay dos acciones de sesión: **Iniciar DaemonProcess** y **Ejecutar tareas**. El visor de registros en el centro de la ventana corresponde a la acción de sesión seleccionada a la derecha.
Seleccione la opción **Ver los registros de todas las tareas**. La cronología muestra el resto de las tareas que se ejecutaron como parte de la sesión y la `Shut down DaemonProcess` acción que salió del entorno.
## Vea los registros del daemon
1. En esta sección, utiliza el monitor de Deadline Cloud para comparar las acciones de la sesión con el lugar en el que están definidas en la plantilla de trabajo. Es la continuación de la sección anterior.
Abre el archivo [job\$1env\$1daemon\$1process/template.yaml](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_daemon_process/template.yaml) en un editor de texto. Compare las acciones de la sesión con el lugar donde están definidas en la plantilla de trabajo.
1. Seleccione la acción de la `Launch DaemonProcess` sesión en el monitor de Deadline Cloud. Verá el resultado del registro de la siguiente manera.
```
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
```
Las siguientes líneas de la plantilla de trabajo especifican esta acción.
```
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. Seleccione una de las acciones de sesión Ejecutar: N de la tarea en el monitor de Deadline Cloud. Verá el resultado del registro de la siguiente manera.
```
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 ----------------------------------------------
```
Las siguientes líneas de la plantilla de trabajo son las que especifican esta acción. ```pasos:
```
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
```
# Proporcione solicitudes para sus puestos de trabajo
Puede utilizar un entorno de colas para cargar aplicaciones y procesar sus trabajos. Al crear una flota gestionada por un servicio mediante la consola de Deadline Cloud, tiene la opción de crear un entorno de colas que utilice el administrador de paquetes conda para cargar las aplicaciones.
Si desea utilizar un administrador de paquetes diferente, puede crear un entorno de colas para ese administrador. Para ver un ejemplo del uso de Rez, consulte[Usa un administrador de paquetes diferente](#provide-applications-other-package).
Deadline Cloud proporciona un canal conda para cargar una selección de aplicaciones de renderizado en su entorno. Apoyan a los remitentes que Deadline Cloud proporciona para las solicitudes de creación de contenido digital.
También puede cargar software para que conda-forge lo utilice en sus trabajos. Los siguientes ejemplos muestran plantillas de trabajos que utilizan el entorno de colas proporcionado por Deadline Cloud para cargar las aplicaciones antes de ejecutar el trabajo.
**Topics**
+ [Obtener una solicitud de un canal conda](#provide-applications-get-application)
+ [Usa un administrador de paquetes diferente](#provide-applications-other-package)
## Obtener una solicitud de un canal conda
Puedes crear un entorno de colas personalizado para tus trabajadores de Deadline Cloud e instalar el software que prefieras. Este ejemplo de entorno de colas tiene el mismo comportamiento que el entorno utilizado por la consola para las flotas gestionadas por el servicio. Ejecuta conda directamente para crear el entorno.
El entorno crea un nuevo entorno virtual de conda para cada sesión de Deadline Cloud que se ejecute en un trabajador y, a continuación, elimina el entorno cuando finaliza.
Conda almacena en caché los paquetes descargados para que no sea necesario volver a descargarlos, pero cada sesión debe vincular todos los paquetes al entorno.
El entorno define tres scripts que se ejecutan cuando Deadline Cloud inicia una sesión con un trabajador. El primer script se ejecuta cuando se `onEnter` invoca la acción. Llama a los otros dos para configurar las variables de entorno. Cuando el script termina de ejecutarse, el entorno conda está disponible con todas las variables de entorno especificadas configuradas.
Para ver la última versión del ejemplo, consulta [conda\$1queue\$1env\$1console\$1equivalent.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/conda_queue_env_console_equivalent.yaml) en el repositorio de. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline) GitHub
Si desea utilizar una aplicación que no está disponible en el canal conda, puede crear un canal conda en Amazon S3 y, a continuación, crear sus propios paquetes para esa aplicación. Consulte [Cree un canal conda con S3](configure-jobs-s3-channel.md) para obtener más información.
### Obtenga bibliotecas de código abierto de conda-forge
En esta sección se describe cómo utilizar las bibliotecas de código abierto del `conda-forge` canal. El siguiente ejemplo es una plantilla de trabajo que usa el paquete `polars` Python.
El trabajo establece los `CondaChannels` parámetros `CondaPackages` y parámetros definidos en el entorno de colas que indican a Deadline Cloud dónde obtener el paquete.
La sección de la plantilla de trabajo que establece los parámetros es:
```
- 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 la versión más reciente de la plantilla de trabajo de ejemplo completa, 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 ver la versión más reciente del entorno de colas que carga los paquetes conda, consulta conda\$1queue\$1env\$1console\$1equivalent.yaml en el repositorio de. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline)](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/conda_queue_env_console_equivalent.yaml) GitHub
### Sal Blender del canal deadline-cloud
El siguiente ejemplo muestra una plantilla de trabajo que Blender proviene del canal `deadline-cloud` conda. Este canal admite los remitentes que Deadline Cloud proporciona para el software de creación de contenido digital, aunque puedes usar el mismo canal para cargar software para tu propio uso.
Para ver una lista del software ofrecido por el `deadline-cloud` canal, consulta el [entorno de colas predeterminado](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html#conda-queue-environment) en la Guía del *usuario de AWS Deadline Cloud*.
Este trabajo establece el `CondaPackages` parámetro definido en el entorno de colas para indicar a Deadline Cloud que cargue Blender en el entorno.
La sección de la plantilla de trabajo que establece el parámetro es:
```
- 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 la versión más reciente de la plantilla de trabajo de ejemplo completa, consulta [blender\$1render/template.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/job_bundles/blender_render/template.yaml). [Para ver la versión más reciente del entorno de colas que carga los paquetes conda, consulta conda\$1queue\$1env\$1console\$1equivalent.yaml en el repositorio de. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline)](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/conda_queue_env_console_equivalent.yaml)GitHub
## Usa un administrador de paquetes diferente
El administrador de paquetes predeterminado para Deadline Cloud es conda. Si necesitas usar un administrador de paquetes diferente, por ejemploRez, puedes crear un entorno de colas personalizado que contenga scripts que usen tu administrador de paquetes en su lugar.
Este ejemplo de entorno de colas proporciona el mismo comportamiento que el entorno utilizado por la consola para las flotas gestionadas por el servicio. Sustituye al administrador de paquetes conda por. Rez
El entorno define tres scripts que se ejecutan cuando Deadline Cloud inicia una sesión con un trabajador. El primer script se ejecuta cuando se `onEnter` invoca la acción. Llama a los otros dos para configurar las variables de entorno. Cuando el script termina de ejecutarse, el Rez entorno está disponible con todas las variables de entorno especificadas configuradas.
En el ejemplo se supone que tiene una flota gestionada por el cliente que utiliza un sistema de archivos compartido para los paquetes Rez.
Para ver la versión más reciente del ejemplo, consulta [rez\$1queue\$1env.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/rez_queue_env.yaml) en el repositorio de. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline)GitHub