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.
# Epic Unreal Engine
Unreal Engine es una herramienta de creación 3D en tiempo real para imágenes fotorrealistas y experiencias inmersivas. Deadline Cloud es compatible con Unreal Engine e incluye remitentes, paquetes conda y un adaptador para aumentar el rendimiento del renderizado. Esta guía proporciona instrucciones paso a paso para usar Deadline Cloud con Unreal Engine para renderizar tus proyectos de Movie Render Queue de forma más rápida distribuyendo las tareas de renderizado entre varios equipos.
## Descripción general de Support
Unreal Engine es compatible con los siguientes componentes:
+ **Presentador**: complemento de envío integrado para el envío directo de trabajos desde Unreal Engine con detección automática de escenas y activos.
+ **Paquetes Conda**: Deadline Cloud para la instalación automática en flotas gestionadas por servicios.
+ **Adaptador**: middleware para un renderizado eficiente con sesiones fijas y supervisión adicional.
+ **Cross-platform compatibilidad**: soporte para remitentes y trabajadores únicamente para Windows.
+ **Integración de Movie Render Queue**: Support para el sistema Movie Render Queue de Unreal.
## Compatibilidad con las versiones de Unreal Engine
La siguiente tabla muestra los niveles de soporte actuales para las versiones de Unreal Engine:
| Versión principal | Submitter Support | Soporte de Conda |
| --- | --- | --- |
| 5.4 | Windows | Windows |
| 5.5 | Windows | Windows |
| 5.6 | Windows | Windows |
| 5.7 | Windows | Windows |
## Canal Deadline Cloud Conda
La siguiente tabla muestra todos los paquetes conda aplicables a Unreal Engine disponibles para Service-managed las flotas del canal conda: `deadline-cloud`
| SO | Package | Versión |
| --- | --- | --- |
| Windows | motor irreal | 5.4 |
| Windows | motor irreal | 5.5 |
| Windows | motor irreal | 5.6 |
| Windows | motor irreal | 5.7 |
| Windows | unreal-engine-openjd | |
## Introducción
### Requisitos previos
Antes de instalar el remitente de Unreal Engine, asegúrate de tener lo siguiente:
+ Estación de trabajo Windows (Windows 10 o posterior)
+ Se ha instalado una versión compatible de Unreal Engine
+ Se ha instalado el monitor Deadline Cloud ([descárguelo aquí](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/monitor-onboarding.html))
+ Acceda a una granja de Deadline Cloud con una flota gestionada por el servicio de GPU-enabled Windows o una flota gestionada por el cliente con Unreal Engine, el adaptador de Unreal Engine y una configuración de licencias
## Instalación del remitente
El remitente de Unreal Engine añade la funcionalidad de Deadline Cloud como complemento a Unreal Engine, lo que te permite enviar tus trabajos de Movie Render Queue directamente a Deadline Cloud para su renderización.
### ¿Cómo elegir tu sucursal?
Seleccione la sucursal adecuada para su implementación:
| Rama | Stability | Caso de uso | Recomendado para |
| --- | --- | --- | --- |
| lanzamiento | Stable | Producción | La mayoría de los usuarios |
| línea principal | Funcionalidades más recientes | Desarrollo y pruebas | Usuarios avanzados |
**sugerencia**
Utilice la rama **de versiones** para los entornos de producción a fin de garantizar la estabilidad.
### Crear una nueva instancia Amazon EC2 de Windows para instalar Unreal (opcional)
Si estás configurando una instancia nueva de Windows Amazon Elastic Compute Cloud (Amazon EC2) como remitente, una instancia g5.2xlarge con 200 GB de almacenamiento es un mínimo razonable:
1. Lance una instancia de Amazon EC2 con un perfil de instancia válido. Esto es necesario para descargar los controladores NVIDIA GRID tal y como se indica a continuación.
1. Descarga el instalador de Epic e instala una versión compatible de Unreal (5.4 - 5.7).
+ El UE 5.5 tiene un error de bloqueo conocido cuando se ejecuta con el complemento DirectX 11 (consulte el número de problema de UE). UE-276282 Si necesitas compatibilidad con DirectX en UE 5.5, usa DirectX 12 o una versión posterior.
1. Controladores NVIDIA GRID: sigue las instrucciones de [instalación de Windows.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-nvidia-driver.html#nvidia-GRID-driver)
### Rutas largas de Windows
Muchos de los pasos que se indican a continuación pueden crear archivos que superen la longitud de ruta máxima predeterminada de Windows. Antes de crear e instalar el remitente o adaptador de Deadline Cloud para Unreal Engine en un equipo con Windows, le recomendamos que habilite la compatibilidad con Windows long Path. [Para ello, sigue las instrucciones de la página [Limitación máxima de rutas de archivo](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=registry), por ejemplo, ejecutando el PowerShell comando.](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=powershell#tabpanel_1_powershell)
También hay un [problema pendiente en el agente de trabajo](https://github.com/aws-deadline/deadline-cloud-worker-agent/issues/520) causado por una dependencia que no se envía configurada para admitir rutas largas de Windows. Cuando configure sus trabajadores, siga los pasos de solución alternativa del problema vinculado para que sean totalmente compatibles con las rutas largas de Windows hasta que se resuelva el problema.
### Instalación de herramientas de compilación
Actualmente, el complemento de envío de Unreal debe compilarse localmente.
1. Instale Visual Studio con el instalador de [Visual Studio](https://visualstudio.microsoft.com/).
1. Comprueba que tu versión de Visual Studio y de las herramientas de compilación es compatible con tu versión de Unreal consultando la [tabla de compatibilidad de Epic](https://dev.epicgames.com/documentation/en-us/unreal-engine/setting-up-visual-studio-development-environment-for-cplusplus-projects-in-unreal-engine?application_version=5.5).
1. En **Componentes individuales**, asegúrate de que la versión de las herramientas de compilación de MSVC seleccionada («Última» de forma predeterminada) coincida con la versión recomendada en la tabla. Aunque la guía de compatibilidad puede sugerir una versión «o posterior», a veces se producen errores de compilación cuando se utiliza una versión más reciente que la que aparece como «recomendada».
1. En **Componentes individuales**, selecciona un SDK de .NET Framework reciente (se han verificado las versiones 4.6.1 y 4.8.1).
1. En **Cargas de trabajo**, selecciona **Desarrollo de escritorio** con C\+\+.
### Instalación del monitor Deadline Cloud
El monitor de Deadline Cloud se usa tanto para administrar sus credenciales para enviar trabajos a Deadline Cloud como para monitorear el estado de sus trabajos.
1. Sigue las [instrucciones de instalación del monitor Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submitter.html#install-deadline-cloud-monitor).
1. Iniciar sesión
### Configuración del entorno
1. (Si aún no está instalada) Instale una versión reciente de Python para todos los usuarios (verificada con la versión 3.12).
1. Asegúrese de que las variables de entorno estén configuradas correctamente. En las variables de entorno del sistema, su PATH debe incluir:
+ La ruta a la instalación de Python (por ejemplo,`C:\Program Files\Python312`).
+ La ruta a la carpeta de scripts de Python (por ejemplo,`C:\Program Files\Python312\scripts`).
+ La ruta a tus archivos binarios de Unreal (por ejemplo,`C:\Program Files\Epic Games\UE_5.5\Engine\Binaries\Win64`).
### Instalación del software Deadline Cloud
Clona o descarga `deadline-cloud-for-unreal-engine` desde la rama de lanzamiento o desde la línea principal, dependiendo de si quieres la versión probada más reciente o todas las confirmaciones más recientes.
```
git clone https://github.com/aws-deadline/deadline-cloud-for-unreal-engine.git
cd deadline-cloud-for-unreal-engine
git switch release
```
### Opcional: crea e instala el plugin con un script
`scripts/build_plugin.py`Opcionalmente, un script auxiliar automatiza los dos pasos siguientes. Intenta encontrar la última versión de Unreal, crea tu complemento y las dependencias de Python y las instala en las ubicaciones correctas. Puedes anular ajustes como la versión de Unreal. Para ver la lista de ayuda completa, ejecuta:
```
python scripts/build_plugin.py -h
```
Para compilar e instalar tu copia actual de `deadline-cloud-for-unreal-engine` como remitente con la última instalación de Unreal Engine, ejecuta:
```
python scripts/build_plugin.py --install
```
Si has realizado la instalación con este script correctamente, puedes pasar a. [Crear una flota](#unreal-engine-create-fleet)
### Crea el complemento
Ajusta las dos primeras rutas que aparecen a continuación en función de dónde se encuentre tu instalación de Unreal y dónde la hayas instalado`deadline-cloud-for-unreal-engine`.
Desde la carpeta Unreal Install Batchfiles (el `package` parámetro puede ser cualquier directorio nuevo, pero querrás que se llame más adelante): `UnrealDeadlineCloudService`
```
cd C:\Program Files\Epic Games\UE_5.5\Engine\Build\BatchFiles
runuat.bat BuildPlugin -plugin="C:\deadline\deadline-cloud-for-unreal-engine\src\unreal_plugin\UnrealDeadlineCloudService.uplugin" -package="C:\UnrealDeadlineCloudService"
```
Copia la carpeta «paquete» de arriba a la carpeta de complementos de tu instalación de Unreal (por ejemplo,). `C:\Program Files\Epic Games\UE_5.5\Engine\Plugins\UnrealDeadlineCloudService`
### Dependencias de Python
Hay 4 formas de instalar las dependencias de Python requeridas.
1. Si has creado e instalado el plugin desde la rama de versiones anterior, puedes instalarlo desde pip. Usa el siguiente comando de instalación para ajustar las rutas a tu instalación de Unreal:
```
"C:\Program Files\Epic Games\UE_5.5\Engine\Binaries\ThirdParty\Python3\Win64\python" -m pip install deadline-cloud-for-unreal-engine --target "C:\Program Files\Epic Games\UE_5.5\Engine\Plugins\UnrealDeadlineCloudService\Content\Python\libraries"
```
2. Como alternativa, en tu `.uplugin` archivo (en los pasos anteriores se ubicaría `C:\Program Files\Epic Games\UE_5.5\Engine\Plugins\UnrealDeadlineCloudService\UnrealDeadlineCloudService.uplugin` aquí) puedes añadir una `PythonRequirements` sección que coincida con la última versión de `deadline-cloud-for-unreal-engine` in GitHub/PyPI, por ejemplo:
```
"PythonRequirements":
[
{
"Platform": "All",
"Requirements":
[
"deadline-cloud-for-unreal-engine>=0.5.0"
]
}
]
```
Es posible que desees desactivar la función de «hash estricto» en la configuración de Python de Unreal o añadir una configuración de hash para las versiones específicas de bibliotecas y dependencias que desees consumir.
3. Si utilizas la versión principal, es posible que tengas dependencias de Python que aún no estén disponibles en PyPI; tendrás que crear e instalar tu copia local, lo que se puede hacer con hatch. Será necesario cambiar el `.whl` archivo para que refleje la versión que genera hatch build:
```
pip install hatch
hatch build
"C:\Program Files\Epic Games\UE_5.5\Engine\Binaries\ThirdParty\Python3\Win64\python" -m pip install dist\deadline_cloud_for_unreal_engine-0.2.2.post21-py3-none-any.whl --target "C:\Program Files\Epic Games\UE_5.5\Engine\Plugins\UnrealDeadlineCloudService\Content\Python\libraries"
```
4. Por último, el instalador remitente puede instalar las dependencias de Python. Es posible que no estén actualizados con el código anterior de la versión o de la rama principal, y actualmente no debería preferirse este método.
1. Descargue el instalador remitente desde la pestaña Descargas de la consola AWS de Deadline Cloud o desde el monitor de Deadline Cloud, en Configuración de estación de trabajo → Descargas.
1. Ejecute el instalador para todos los usuarios. La ubicación de instalación predeterminada está bien.
1. Activa el complemento Unreal Engine.
1. Asegúrese de que la ruta de instalación del complemento de Unreal Engine coincida con el lugar en el que se copió el complemento (en particular, asegúrese de que su versión de Unreal coincida).
### Actualiza las notificaciones
El complemento remitente comprueba automáticamente si hay versiones más recientes GitHub cuando se inicia Unreal Editor. Si hay una actualización disponible, aparecerá un cuadro de diálogo en el que se te pedirá que visites la página de lanzamiento.
Para desactivar las notificaciones de actualización, desmarca **Mostrar las notificaciones de actualización del remitente en la sección** **Configuración general del panel de configuración** de Deadline Cloud (**Edición** > **Configuración del proyecto** > **Plugins** > **Deadline** Cloud).
Como alternativa, puede usar la CLI:
```
deadline config set settings.submitter_update_notification false
```
Para volver a habilitarla:
```
deadline config set settings.submitter_update_notification true
```
## Crear una flota
Si ya tiene una flota de Windows y no necesita configurar una nueva, puede ir directamente a[Enviar un renderizado de prueba](#unreal-engine-test-render).
### Crear una flota gestionada por servicios (SMF)
Sigue la [guía del usuario de flotas gestionadas por servicios](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/smf-manage.html) para crear una SMF si aún no tienes una. [En las [flotas gestionadas por servicios (SMF)](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/smf-manage.html), el Unreal Engine y el adaptador están disponibles automáticamente mediante el canal conda con el entorno de colas predeterminado. `deadline-cloud`](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html#conda-queue-environment) Ya está listo para empezar a renderizar. Continúe con lo [Enviar un renderizado de prueba](#unreal-engine-test-render) siguiente para enviar un trabajo de renderizado de prueba.
### Creación de una flota gestionada por el cliente (CMF)
1. Siga [Cree una flota gestionada por el cliente](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/create-a-cmf.html) para crear una CMF si aún no tiene una.
**aviso**
Al asociar su CMF a las colas, elimine el entorno de colas predeterminado de Conda si no lo utiliza. Esto evitará que se utilice el entorno conda y se utilicen accidentalmente las SMF-specific variables predeterminadas para los trabajos enviados a su CMF. Si usa conda en su CMF, recuerde actualizar `CondaPackages` y **anular `CondaChannels` las variables de la definición de parámetros durante el envío** del trabajo.
1. Siga los pasos [de instalación y configuración del host](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/worker-host.html) de trabajo para configurar un host de trabajo.
1. Siga [Administrar el acceso a los secretos de usuario de los trabajos de Windows](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/manage-access-windows-secrets.html) para configurar los secretos de los usuarios de los trabajos de Windows para su trabajador de CMF.
1. Siga [Instalar y configurar el software necesario para los trabajos para](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/install-software.html) instalar el software necesario para ejecutar los trabajos.
1. Siga este [Configurar un empleado de una flota gestionada por el cliente (CMF)](#unreal-engine-cmf-worker-setup) procedimiento para configurar su nodo de trabajo para ejecutar los trabajos de Unreal Engine.
## Enviar un renderizado de prueba
En este ejemplo se utiliza la demo de Meerkat de Unreal Marketplace:
1. Inicia el lanzador de Epic Games.
1. **Instala la demo de Meerkat desde la pestaña de muestras.**
1. Cree un proyecto a partir de la demostración de Meerkat y ábralo.
1. En el menú **Edición**, selecciona **Plugins**, busca y actívalos. **UnrealDeadlineCloudService**
1. Reinicia Unreal si has activado el plugin por primera vez.
1. En **Edición** > **Ajustes del proyecto**, busca la sección **Movie Render Pipeline**.
+ En **Ejecutor remoto predeterminado**, seleccione **MoviePipelineDeadlineCloudRemoteExecutor**.
+ En **Default Executor Job**, seleccione **MoviePipelineDeadlineCloudExecutorJob**.
+ En **Clases de configuración de trabajo predeterminadas**, elija el icono de añadir y añada **DeadlineCloudRenderStepSetting**.
1. Busque la configuración de **Deadline Cloud** y verifique la autenticación:
+ Asegúrese de que su estado muestre «AUTENTICADO» y que la API de Deadline Cloud muestre «AUTORIZADO».
+ Si no aparece, primero intenta usar el botón de **inicio de sesión**. Si eso no funciona, abre el monitor de Deadline Cloud y asegúrate de haber iniciado sesión.
+ En la sección de **configuración de la estación de trabajo Deadline Cloud**:
+ En **Configuración global**, asegúrese de que su perfil de AWS esté configurado correctamente con su perfil de monitor de Deadline Cloud.
+ En **Perfil**, asegúrese de que su granja predeterminada esté configurada como la suya.
+ En **Granja**, asegúrate de que tu cola predeterminada esté configurada como una cola asociada a la flota que configuraste anteriormente.
1. Sal de la ventana de configuración del proyecto.
1. Seleccione **Windows**, **Cinematics** o **Movie Render Queue**.
+ Elija **\+ Renderizar** y seleccione. **Main\_SEQ**
+ Elija **UnsavedConfig**en la columna de ajustes.
+ En la ventana emergente, deberías ver la configuración de Deadline Cloud a la izquierda. A continuación, se puede cerrar esta ventana.
+ En la parte derecha del cuadro de diálogo, configure los ajustes del trabajo:
+ En **Modificaciones predefinidas** (puede que necesite ampliar este cuadro de diálogo):
+ Amplíe la **configuración compartida del trabajo**:
+ Establezca **Name (Nombre)** en `Unreal Test Job`.
+ Establezca el **número máximo de reintentos** en 2.
+ Amplíe **los adjuntos de trabajo**:
+ En **Archivos de entrada**, seleccione **Mostrar Auto-Detected**.
+ Compruebe que la lista de archivos detectados automáticamente se complete correctamente.
+ En **Modificaciones de plantillas de trabajo:**
+ Actualice la versión de Unreal Engine **CondaPackages**si está utilizando una versión diferente a la 5.6.
+ La detección automática de la versión de Unreal Engine llegará en una versión futura.
+ Elige **Renderizar (remoto)**.
1. Puedes ir al monitor de Deadline Cloud y ver el progreso de tu trabajo.
## Configurar un empleado de una flota gestionada por el cliente (CMF)
En esta sección, se explica cómo configurar una instancia de Amazon EC2 como servidor de CMF para Deadline Cloud con Unreal Engine.
### Descripción general de
Las principales diferencias entre CMF y SMF son las siguientes:
+ **CMF**: Instalación manual de Unreal Engine y del adaptador en servidores de trabajo.
+ **SMF**: disponibilidad automática a través del canal conda. `deadline-cloud`
### ¿Cómo elegir tu sucursal
Seleccione la sucursal adecuada para su implementación:
| Rama | Stability | Caso de uso |
| --- | --- | --- |
| lanzamiento | Stable | Implementaciones de producción |
| línea principal | La más reciente | Desarrollo y pruebas |
**importante**
Asegúrese de que su versión de trabajo coincida con la versión de origen para evitar problemas de compatibilidad.
### Configuración de instancias de Amazon EC2
La siguiente es la configuración de instancias recomendada:
+ **Tipo de instancia**: g5.2xlarge o superior.
+ **Almacenamiento**: 200 GB como mínimo.
+ **Sistema operativo**: Windows Server 2019/2022.
#### Instalar el software
**1. Instale Unreal Engine**:
1. Descarga el lanzador de Epic Games.
1. Instala Unreal Engine 5.4 o una versión superior.
**nota**
Se requiere Unreal Engine 5.4\+ para la compatibilidad con Deadline Cloud.
**2. Instale los controladores NVIDIA GRID**:
+ Siga la [guía de instalación del controlador NVIDIA GRID de AWS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-nvidia-driver.html#nvidia-GRID-driver).
+ Necesario para GPU-accelerated renderizar en instancias de Amazon EC2.
### Instalación de herramientas de compilación
Actualmente, el complemento Unreal debe compilarse localmente.
1. Instale Visual Studio con el [instalador de Visual Studio](https://visualstudio.microsoft.com/).
1. Comprueba que tu versión de Visual Studio y de las herramientas de compilación es compatible con tu versión de Unreal consultando la [tabla de compatibilidad de Epic](https://dev.epicgames.com/documentation/en-us/unreal-engine/setting-up-visual-studio-development-environment-for-cplusplus-projects-in-unreal-engine?application_version=5.5).
1. En **Componentes individuales**, asegúrate de que la versión de las herramientas de compilación de MSVC seleccionada («Última» de forma predeterminada) coincida con la versión recomendada en la tabla.
1. En **Componentes individuales**, selecciona un SDK reciente de .NET Framework (se han verificado las versiones 4.6.1 y 4.8.1).
1. En **Cargas de trabajo**, selecciona **Desarrollo de escritorio** con C\+\+.
### Instalación del software Deadline Cloud
Clona o descarga `deadline-cloud-for-unreal-engine` desde la rama de lanzamiento o desde la línea principal. Asegúrese de que su versión de trabajo de las bibliotecas sea compatible con la versión que utilizan los remitentes.
```
git clone https://github.com/aws-deadline/deadline-cloud-for-unreal-engine.git
cd deadline-cloud-for-unreal-engine
git switch release
```
Opcional: crea e instala el complemento y las dependencias con un script:
Existe un script auxiliar `scripts/build_plugin.py` que puede automatizar el resto de los pasos de instalación. Intenta encontrar la última versión de Unreal, crear tu complemento y las dependencias de Python e instalarlas en las ubicaciones correctas. Se pueden anular ajustes como la versión de Unreal que se va a utilizar. Para ver la lista de ayuda completa, ejecuta:
```
python scripts/build_plugin.py -h
```
Para compilar e instalar tu copia actual de `deadline-cloud-for-unreal-engine` como usuario con la última instalación de Unreal Engine, ejecuta:
```
python scripts/build_plugin.py --install --worker
```
Configura el agente de trabajo de Deadline Cloud ejecutando:
```
install-deadline-worker ^
--farm-id FARM_ID ^
--fleet-id FLEET_ID ^
--region REGION ^
--allow-shutdown
```
Si lo instalaste con este script y configuraste el agente de trabajo correctamente, puedes pasar a[Inicio del servicio de agentes de trabajo de Deadline Cloud](#unreal-engine-cmf-start-agent).
```
python -m pip install deadline-cloud-worker-agent
```
Se debe instalar la versión correcta del adaptador en función de la versión del remitente que se utilice. Si está utilizando la versión del remitente de la rama de lanzamiento de GitHub, simplemente puede instalarla con pip:
```
python -m pip install deadline-cloud-for-unreal-engine
```
Si utilizas la versión principal o una versión personalizada en desarrollo del remitente, para evitar problemas de compatibilidad, te recomendamos que compiles e instales desde la misma versión de código o que transfieras el `.whl` archivo desde la compilación del remitente:
```
pip install hatch
hatch build
python -m pip install dist\my-built-wheel.whl
```
### Compilando el complemento
Ajusta las dos primeras rutas que aparecen a continuación en función de dónde se encuentre tu instalación de Unreal y dónde la hayas instalado`deadline-cloud-for-unreal-engine`.
Desde la carpeta Unreal Install Batchfiles (el `package` parámetro puede ser cualquier directorio nuevo, pero querrás que se llame más adelante): `UnrealDeadlineCloudService`
```
cd C:\Program Files\Epic Games\UE_5.5\Engine\Build\BatchFiles
runuat.bat BuildPlugin -plugin="C:\deadline\deadline-cloud-for-unreal-engine\src\unreal_plugin\UnrealDeadlineCloudService.uplugin" -package="C:\UnrealDeadlineCloudService"
```
Copia la carpeta «paquete» de arriba a la carpeta de complementos de tu instalación de Unreal (por ejemplo,). `C:\Program Files\Epic Games\UE_5.5\Engine\Plugins\UnrealDeadlineCloudService`
### pywin32
La versión de Python de Unreal necesitará pywin32. Instalación de Pip mediante una copia de la instalación de Python de terceros de Unreal:
```
"C:\Program Files\Epic Games\UE_5.5\Engine\Binaries\ThirdParty\Python3\Win64\python" -m pip install pywin32
```
### Inicio del servicio de agentes de trabajo de Deadline Cloud
En tu instancia de CMF Worker:
1. Abre el **Administrador de tareas**.
1. Selecciona la pestaña **Servicios** de la derecha.
1. Encuentra **DeadlineWorker**.
+ Si no lo ve en la lista, es probable que haya omitido algunos pasos (`install-deadline-worker`en particular) de los [pasos de configuración del host CMF](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/worker-host.html#worker-agent-config).
1. Si el estado del servicio no es «En ejecución», haga clic con el botón derecho en él y seleccione **Iniciar**.
1. Si el DeadlineWorker servicio no se está iniciando, consulta los registros de inicio del agente de trabajo en las siguientes ubicaciones:
+ `C:\ProgramData\Amazon\Deadline\Logs\worker-agent.log`
+ `C:\ProgramData\Amazon\Deadline\Logs\queue-\session-.log`
## Administración de credenciales de Perforce
Esta sección trata sobre la gestión segura de credenciales para integrar Perforce con los trabajadores de Deadline Cloud.
### Descripción general de
Existen varios enfoques para configurar las credenciales de Perforce para los trabajadores de Deadline Cloud. Cada método tiene diferentes implicaciones de seguridad y casos de uso:
| Método | Nivel de seguridad | Soporte de despliegue | Uso recomendado |
| --- | --- | --- | --- |
| AWS Secrets Manager (Secrets Manager) | Alto | SMF \+ CMF | Producción (recomendada) |
| Variables de entorno de los trabajos | Bajo | SMF \+ CMF | Solo desarrollo y pruebas |
| Variables de entorno de cola | Bajo | SMF \+ CMF | Solo desarrollo y pruebas |
| Registro de Windows | Medio | Solo CMF | Configuraciones CMF antiguas |
| Pre-configured usuario administrador | Medio | Solo CMF | Configuraciones CMF simplificadas |
**importante**
Utilice Secrets Manager para entornos de producción. Proporciona un almacenamiento de credenciales cifrado y centralizado con registros de auditoría y funciona con despliegues de SMF y CMF.
### Conceptos básicos sobre las credenciales P4
Para recuperar la configuración de conexión, incluidos la URL y el puerto del servidor Perforce, el nombre de usuario y la contraseña, Perforce sigue las siguientes prioridades:
1. Parámetros de conexión en cualquier marco de Perforce (P4) (`p4python.P4`por ejemplo).
1. User/system variables de entorno:`P4PORT`,,`P4USER`,`P4CLIENT`. `P4PASSWD`
1. Registro de Windows: `HKEY_LOCAL_MACHINE\SOFTWARE\Perforce\Environment` (configuración de todo el sistema) o `HKEY_CURRENT_USER\SOFTWARE\Perforce\Environment` (configuración específica del usuario).
Con estas prioridades, si tiene la siguiente configuración:
+ El parámetro de conexión `password` es `password.from.connection`
+ La variable de entorno `%P4PORT%` es `ssl:perforce.from.env:1666`
+ El registro de Windows `HKEY_CURRENT_USER\SOFTWARE\Perforce\Environment:P4PORT` es `ssl:perforce.from.registry:1666`
+ El registro de Windows `HKEY_CURRENT_USER\SOFTWARE\Perforce\Environment:P4USER` es `user.from.registry`
+ El registro de Windows `HKEY_CURRENT_USER\SOFTWARE\Perforce\Environment:P4PASSWD` es `password.from.registry`
La conexión Perforce resultante será:
```
Port = ssl:perforce.from.env:1666
User = user.from.registry
Password = password.from.connection
```
### Secrets Manager (recomendado)
Secrets Manager proporciona la solución más segura y escalable para despliegues de CMF y SMF.
A continuación, se enumeran las ventajas de este enfoque:
+ **Seguridad centralizada**: almacene todas las credenciales P4 en una ubicación cifrada.
+ **Sin exposición de credenciales**: las credenciales nunca aparecen en las configuraciones ni en los registros de los trabajos.
+ **Rotación automática: Support la rotación** de credenciales sin necesidad de reconfigurar el trabajo.
+ **Registros de auditoría**: realice un seguimiento del acceso y el uso de las credenciales.
+ **Soporte universal**: funciona con despliegues de CMF y SMF.
+ **Redacción de registros**: las credenciales de conexión se redactan automáticamente en los registros de trabajos.
#### Paso 1: Crear un secreto en Secrets Manager
Cree un secreto que contenga los parámetros de conexión de Perforce.
**Pares clave-valor necesarios**:
+ `P4PORT`- URL y puerto del servidor Perforce.
+ `P4USER`- Nombre de usuario de Perforce.
+ `P4PASSWD`- Contraseña de Perforce.
**importante**
Para poder trabajar con ellos, los nombres de las claves deben coincidir exactamente con los parámetros de conexión P4. `deadline-cloud-for-unreal-engine`
**Ejemplo de secreto**:
```
{
"P4PORT": "ssl:your-perforce-server.com:1666",
"P4USER": "your-perforce-username",
"P4PASSWD": "your-perforce-password"
}
```
**Para crear el secreto**:
1. Abra la consola de Secrets Manager.
1. Selecciona «Guardar un secreto nuevo».
1. Selecciona «Otro tipo de secreto».
1. Introduzca los pares clave-valor de arriba.
1. Indique su secreto (por ejemplo,`deadline-cloud-p4-credentials`).
1. Completar el proceso de creación.
#### Paso 2: Otorgue al trabajador acceso al secreto
Los trabajadores necesitan `secretsmanager:GetSecretValue` permiso para acceder al secreto. Esto sigue el mismo patrón que la [administración de los secretos de los usuarios de los trabajos de Windows](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/manage-access-windows-secrets.html#grant-access).
**Para conceder el acceso**:
1. Abre la consola de Secrets Manager y navega hasta tu secreto.
1. En la sección «Permisos de recursos», agrega esta política:
```
{
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "QUEUE_ROLE_ARN"
},
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": "*"
}
]
}
```
1. `QUEUE_ROLE_ARN`Sustitúyalo por el ARN de tu rol de cola actual.
1. Guarde la política.
**nota**
Guarde el nombre secreto: lo necesitará al configurar los trabajos de renderizado de P4. Consulte [Crear un trabajo de renderizado Perforce](#unreal-engine-perforce-render-job) los siguientes pasos.
### Variables de entorno de los trabajos
**aviso**
No se recomienda este enfoque para la producción, ya que expone las credenciales en las configuraciones y los registros de los trabajos. Utilice Secrets Manager para entornos de producción.
[Puede transferir las credenciales de conexión al entorno de trabajo en el que se crea el espacio de trabajo, por ejemplo, en [p4\_sync\_smf\_environment, ugs\_sync\_smf\_environment](https://github.com/aws-deadline/deadline-cloud-for-unreal-engine/blob/mainline/src/unreal_plugin/Content/Python/openjd_templates/p4/p4_sync_smf_environment.yml) o entornos similares para CMF.](https://github.com/aws-deadline/deadline-cloud-for-unreal-engine/blob/mainline/src/unreal_plugin/Content/Python/openjd_templates/ugs/ugs_sync_smf_environment.yml) Como alternativa, cree una nueva plantilla de entorno y añádala a su trabajo.
```
name: P4Credentials
variables:
P4PORT: ssl:my-perforce.com:1666
P4USER: j.doe
P4PASSWD: MyVeRyS3cretP4ssW0rd
```
Este enfoque presenta los siguientes riesgos de seguridad:
+ Las credenciales son visibles en las configuraciones de trabajo.
+ Las contraseñas pueden aparecer en los registros (no se redactan automáticamente).
+ No hay administración centralizada de credenciales.
+ Es difícil rotar las credenciales.
### Variables de entorno de cola
**aviso**
Este enfoque no se recomienda para la producción, ya que almacena las credenciales en configuraciones de cola. Use Secrets Manager para una administración segura de credenciales.
Según la [guía del usuario de Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html), puede usar entornos de colas para proporcionar aplicaciones de software, variables de entorno y otros recursos a los trabajos en cola. Puedes encontrar ejemplos de entornos de colas en la carpeta [queue\_environments](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/queue_environments) de deadline-cloud-samples.
#### Añada un entorno de colas mediante el monitor o la consola de Deadline Cloud
1. Abra el monitor Deadline Cloud o la consola de AWS.
1. Navegue hasta la granja y la cola con las que está trabajando.
1. Selecciona la pestaña **Entornos de cola.**
1. Elige **Acción** y selecciona **Crear nuevo con YAML**.
1. Agrega lo siguiente y guarda:
```
specificationVersion: environment-2023-09
name: P4Credentials
variables:
P4PORT: ssl:my-perforce.com:1666
P4USER: j.doe
P4PASSWD: MyVeRyS3cretP4ssW0rd
```
#### Agregar un entorno de colas mediante CLI
1. Cree un `p4_credentials.yaml` archivo con el ejemplo anterior.
1. Ejecute el comando de CLI siguiente:
```
aws deadline create-queue-environment \
--farm-id FARM_ID \
--queue-id QUEUE_ID \
--priority 1 \
--template-type YAML \
--template file://p4_credentials.yaml
```
### Registro de Windows (solo CMF)
**importante**
Esta solución solo es adecuada para CMF, donde se pueden configurar los hosts de trabajo directamente. Para las implementaciones de SMF, utilice Secrets Manager.
El registro de Windows proporciona almacenamiento local de credenciales en las máquinas de trabajo. Este método utiliza el sistema de prioridades estándar de Perforce, en el que las credenciales se almacenan en:
+ `HKEY_LOCAL_MACHINE\SOFTWARE\Perforce\Environment`(configuración de todo el sistema).
+ `HKEY_CURRENT_USER\SOFTWARE\Perforce\Environment`(configuración específica del usuario).
Este enfoque solo es adecuado para las implementaciones de CMF en las que se tiene acceso directo para configurar las máquinas de trabajo.
### Pre-configured usuario administrador (solo CMF)
**importante**
Esta solución solo es adecuada para CMF, donde puede configurar los hosts de trabajo directamente. Para las implementaciones de SMF, utilice Secrets Manager.
Cree un usuario de P4 dedicado a los nodos de renderización con una conexión que no caduque para eliminar la necesidad de pasar datos secretos, como nombres de usuario y contraseñas. En este caso, se puede utilizar un único usuario P4 dedicado para conectarse a todos los servidores P4, incluidos los servidores Commit (Master) y Edge, donde se puede acceder al depósito del proyecto.
Por lo tanto, solo tendrá que pasar por el puerto al que conectarse si el puerto predeterminado no está configurado para los trabajadores. Esto se puede lograr añadiendo lo siguiente en el entorno de trabajo o en el entorno de colas, de forma similar a los pasos descritos anteriormente:
```
name: P4Sync
variables:
P4PORT: ssl:my-perforce.com:1666
```
## Crear un trabajo de renderizado Perforce
En esta sección se explica cómo configurar los activos de datos de los trabajos de Perforce-integrated renderizado para que pueda enviar los trabajos de Perforce-integrated renderizado a Deadline Cloud desde Unreal Engine.
### Requisitos previos
Antes de enviar un trabajo de Movie Render Queue (MRQ) desde Unreal Engine a un repositorio de Perforce:
**Configuración del proyecto Unreal:**
+ El proyecto debe estar dentro del espacio de trabajo de Perforce.
+ Compruebe que la conexión con Perforce esté establecida y que haya iniciado sesión.
**Configuración de Deadline Cloud**:
+ Complete la [Instalación del remitente](#unreal-engine-installation).
+ Configure [Administración de credenciales de Perforce](#unreal-engine-perforce-credentials) para los trabajadores.
**Requisitos de Perforce**:
+ Espacio de trabajo Perforce válido con archivos de proyecto.
+ Permisos de Perforce adecuados para las operaciones de sincronización.
### Arquitectura de trabajos de renderizado de Perforce
Los trabajos de renderizado P4 amplían el trabajo de renderizado estándar con las capacidades de sincronización de Perforce:
```
Deadline Cloud Perforce render job
├── Environments
│ ├── Apply Perforce Credentials from Secrets Manager
│ ├── Sync Perforce Environment (CMF/SMF)
│ │ └── Initializes Perforce workspace and syncs repository on workers
│ └── Launch UE Environment
│ └── Starts Unreal Engine with Perforce workspace paths
└── Steps
└── Render Step
└── Executes Movie Render Queue process
```
**Diferencias clave con respecto a los trabajos estándar**:
+ **Administración de credenciales**: solicitud de credenciales Secure Perforce de Secrets Manager.
+ **Sincronización de repositorios**: entorno de sincronización Perforce adicional para la gestión del espacio de trabajo.
+ **Resolución de rutas**: las variables de entorno hacen referencia a las rutas de los espacios de trabajo de Perforce.
+ **Recopilación de dependencias**: recopilación y sincronización automáticas de Perforce-tracked activos.
### Configuración de los componentes del trabajo de renderizado de Perforce
Siga estos pasos para crear los activos de datos necesarios para los trabajos de Perforce-integrated renderizado.
#### 1. Cree un activo de datos de Apply Perforce Credentials
Configure un entorno OpenJD para recuperar las credenciales de Perforce de Secrets Manager y aplicarlas a la conexión de Perforce.
**nota**
Las variables de entorno aparecen en los registros con el `openjd_env` prefijo, pero los datos confidenciales (puerto, usuario, contraseña) se ocultan automáticamente por motivos de seguridad.
**Pasos de configuración**:
1. Cree un nuevo activo de datos de **Deadline Cloud Perforce Environment**.
1. Asigne un nombre descriptivo al activo de datos (por ejemplo, "ApplyP4SecretEnv«).
1. Seleccione la `p4_apply_secrets_environment.yml` plantilla de`Content/Python/openjd_templates/p4/`.
1. Configure la referencia secreta:
+ **Introduzca el nombre secreto de su credencial de Perforce en AWS\_SECRET\_P 4INFO.**
+ Debe coincidir con el nombre secreto creado en. [Administración de credenciales de Perforce](#unreal-engine-perforce-credentials)
#### 2. Cree un activo de datos del entorno de sincronización Perforce
Configure un entorno OpenJD para crear un espacio de trabajo Perforce, sincronizar los archivos del servidor Perforce y limpiar el espacio de trabajo después del renderizado.
Pasos de **configuración**:
1. Cree un nuevo activo de datos de **Deadline Cloud Perforce Environment**.
1. Asigne un nombre al activo de datos en función del tipo de flota:
+ **P4SyncSMFEnv**para flota gestionada por servicios (SMF).
+ **P4SyncCMFEnv**para flota gestionada por el cliente (CMF).
1. Seleccione la plantilla adecuada de entre: `Content/Python/openjd_templates/p4/`
+ **SMF**:`p4_sync_smf_environment.yml`.
+ **CMF**:. `p4_sync_cmf_environment.yml`
1. Configure la referencia secreta:
+ **Introduzca el nombre secreto de su credencial de Perforce en AWS\_SECRET\_P 4INFO.**
+ Debe coincidir con el secreto del paso 1.
#### 3. Cree un activo de datos del entorno Perforce Launch UE
Configure un entorno OpenJD para lanzar Unreal Engine con la integración de Perforce. Esto hace referencia automáticamente al espacio de trabajo de Perforce creado por el entorno de sincronización.
**Pasos de configuración:**
1. Cree un nuevo activo de datos de **Deadline Cloud Environment**.
1. Asigne un nombre descriptivo al activo de datos (por ejemplo, "P4LaunchUEEnv«).
1. Seleccione la `p4_launch_ue_environment.yml` plantilla de`Content/Python/openjd_templates/p4/`.
1. Configure los ajustes del entorno:
+ Establezca **REMOTE\_EXECUTION** en. `True`
+ Esta configuración habilita las capacidades de renderizado remoto.
#### 4. Cree un activo de datos escalonado de Perforce
Configure un paso de renderizado de OpenJD para ejecutar el proceso de renderizado.
**Pasos de configuración:**
1. Cree un nuevo activo de datos de **Deadline Cloud Render Step**.
1. Asigne un nombre descriptivo al activo de datos (por ejemplo, "P4RenderStep«).
1. Seleccione la `p4_render_step.yml` plantilla de`Content/Python/openjd_templates/p4/`.
#### 5. Cree un activo de datos de trabajos de renderizado de Perforce
Configure un trabajo de renderizado de OpenJD que organice todo el flujo de trabajo de renderizado.
**Pasos de configuración**:
1. Cree un nuevo activo de datos de **Deadline Cloud Render Job**.
1. Asigne un nombre descriptivo al activo de datos (por ejemplo, "P4RenderJob«).
1. Seleccione la `p4_render_job.yml` plantilla de`Content/Python/openjd_templates/p4/`.
1. **Revise las definiciones de los parámetros**: la plantilla incluye estos parámetros con sus comportamientos predeterminados:
[See the AWS documentation website for more details](http://docs.aws.amazon.com/es_es/deadline-cloud/latest/userguide/epic-unreal-engine.html)
**Pautas de configuración de parámetros**:
+ **Auto-populated parámetros**: déjelos vacíos; se rellenan automáticamente durante el envío del trabajo.
+ **Parámetros manuales**: revise los valores predeterminados y ajústelos en función de sus requisitos específicos.
+ **ChunkSize**: Comience con 1 y aumente para obtener un mejor rendimiento con tomas sencillas.
1. **Configure los entornos** (exactamente en este orden):
[See the AWS documentation website for more details](http://docs.aws.amazon.com/es_es/deadline-cloud/latest/userguide/epic-unreal-engine.html)
**importante**
El orden del entorno es esencial para una resolución de dependencias y un flujo de credenciales adecuados.
1. **Añadir paso de renderizado**: añada "P4RenderStep" a la sección de pasos.
### Prácticas recomendadas
#### Pre-submission lista de verificación
+ **Credenciales: credenciales** de Perforce correctamente configuradas (consulte[Administración de credenciales de Perforce](#unreal-engine-perforce-credentials)).
+ **Espacio de trabajo**: la especificación incluye todos los mapeos de vista necesarios.
+ **Pruebas**: pruebe con una tarea de renderizado pequeña antes de enviar trabajos grandes.
+ **Dependencias**: compruebe que todas las dependencias del proyecto estén en Perforce y sean accesibles.
+ **Permisos**: confirme que las funciones de los trabajadores tengan acceso a Secrets Manager.
#### Optimización del rendimiento
**Configuración del tamaño del fragmento:**
| Tamaño del fragmento | Caso de uso | Impacto en el rendimiento |
| --- | --- | --- |
| 1-2 disparos | Fotografías complejas, se necesita una revisión detallada | Menor rendimiento, mayor control de calidad |
| 4-8 disparos | Carga de trabajo equilibrada, proyectos típicos | Equilibrio óptimo entre velocidad y capacidad de administración |
| Más de 10 disparos | Fotografías sencillas, procesamiento por lotes | Máximo rendimiento, mínima sobrecarga |
Tenga en cuenta las siguientes optimizaciones adicionales:
+ **Dependencias: minimice las** dependencias innecesarias de los activos para reducir el tiempo de sincronización.
+ **Vistas del espacio** de trabajo: optimice las vistas del espacio de trabajo de Perforce para sincronizar solo los archivos necesarios.
#### Monitoreo y depuración
+ **Registros de trabajos**: supervise el proceso de sincronización de Perforce en los registros de ejecución de trabajos.
+ **Estado del espacio de trabajo**: compruebe la creación del espacio de trabajo y la finalización de la sincronización.
+ **Recopilación de dependencias**: compruebe que se hayan capturado todos los activos necesarios.
+ **Métricas de rendimiento**: realice un seguimiento de los tiempos de sincronización y el rendimiento del renderizado.
### Resolución de problemas
#### Problemas y soluciones comunes de
| Problema | Síntomas | Solución |
| --- | --- | --- |
| Fallos de conexión P4 | Errores de autenticación, tiempo de espera | Compruebe las credenciales de Perforce; compruebe la conectividad de la red; valide la accesibilidad del servidor Perforce |
| Errores de sincronización del espacio de trabajo | Fallos de sincronización, permiso denegado | Compruebe los permisos de usuario de Perforce, compruebe las especificaciones del espacio de trabajo y asegúrese de que existe una lista de cambios |
| Faltan dependencias | Fallos de renderizado, activos faltantes | ReviseMrqJobDependenciesDescriptor; compruebe la colección de referencias blandas; verifique todos los activos de Perforce |
| Problemas de resolución de rutas | Errores en el archivo no encontrados | Compruebe la P4\_CLIENT\_DIRECTORY variable; compruebe el orden del entorno; valide las rutas raíz del espacio de trabajo |
#### Pasos de depuración
1. **Compruebe los registros de trabajos**: revise los registros del entorno de sincronización de Perforce para ver los mensajes de error detallados.
1. **Validar el espacio de trabajo**: asegúrese de que la especificación del espacio de trabajo de Perforce sea correcta.
1. **Realice una prueba local**: compruebe que las operaciones de Perforce funcionan desde la máquina emisora.
1. **Verifica los permisos**: confirma que las funciones de los trabajadores tengan acceso secreto (si usas Secrets Manager).
## Requisitos de host personalizados
En esta sección se describe cómo crear y usar requisitos de host personalizados para el renderizado de Deadline Cloud en Unreal Engine.
### Descripción general de
Los requisitos de alojamiento definen qué flota es apta para ejecutar un paso de renderizado en particular. Se almacenan dentro de un `UDeadlineCloudHostRequirements` activo, al que luego hace referencia un `DeadlineCloudRenderStep` activo.
| Tipo de requisito | Ubicación de configuración | Caso de uso |
| --- | --- | --- |
| Requisitos básicos del sistema | Campos de CPU, RAM y GPU | Restrinja el renderizado a máquinas con hardware específico |
| Requisitos de cantidad personalizados | Nombre y min/max valores | Requieren niveles de recursos numéricos (licencias, fichas, cuotas) |
| Requisitos de atributos personalizados | Lista de atributos y valores | Se requieren atributos personalizados en las flotas para ejecutar el paso |
**nota**
Si se oculta un requisito mediante el icono en forma de ojo, solo se oculta en la interfaz de usuario de MRQ Submit. El requisito sigue siendo aplicable al enviar el trabajo.
**importante**
`Attribute`Los valores `Name` y utilizados para los requisitos de importe personalizados y los requisitos de atributos personalizados deben coincidir estrictamente con los identificadores válidos definidos en la documentación oficial de Open Job Description: [Open Job Specifications](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#33-hostrequirements).
### Paso 1: Crear el activo de requisitos del anfitrión
1. Abre el navegador de contenido en Unreal Engine.
1. **Cree un nuevo activo: **Agregar** → **Miscelánea → Activo de datos** →. **DeadlineCloudHostRequirements****
1. Asigne un nombre al activo, por ejemplo,. `MyHostRequirements`
### Paso 2: carga la plantilla YAML predeterminada
1. En el panel de detalles del activo, localice el campo **Ruta a la plantilla**.
1. Seleccione la plantilla por defecto:`Plugins/UnrealDeadlineCloudService/Content/Python/openjd_templates/host_requirements.yml`.
Esto carga los requisitos básicos como la CPU, la memoria, la GPU, el sistema operativo y la arquitectura.
**nota**
Los requisitos básicos no se pueden eliminar; solo se pueden cambiar sus valores.
### Paso 3: Configurar los requisitos básicos (del sistema)
| Opción | Ejemplo |
| --- | --- |
| Sistema operativo | windows |
| Arquitectura de CPU | x86\_64 |
| VCPUs (mínimo) | 16 |
| GPU (mínimo) | 1 |
Si Max = 0, entonces no hay límite superior para ese requisito.
### Paso 4: Añadir requisitos de importe personalizados
Se utiliza cuando el requisito es numérico (por ejemplo, número de licencias, límites de simultaneidad).
1. Busque la sección **Requisitos de montos personalizados**.
1. Agregue una nueva entrada y establezca un nombre, por ejemplo:`amount.custom.license`.
1. Establezca los valores mínimo y máximo:
+ Mínimo: 1.
+ Máximo: 0 (0 significa ilimitado).
### Paso 5: Añadir requisitos de atributos personalizados
Se utiliza para filtrar a los trabajadores en función de etiquetas y rótulos.
1. Busque la sección **Requisitos de atributos personalizados**.
1. Agregue un nuevo nombre de atributo, por ejemplo:`attr.custom.gpu.vendor`.
1. Elija la regla de coincidencia:
+ **AllOf**- todos los valores deben coincidir.
+ **AnyOf**- al menos uno debe coincidir.
1. Introduzca los valores de los atributos separados por espacios, por ejemplo:`nvidia amd`.
### Paso 6: Visibilidad en MRQ (opcional)
Cada entrada obligatoria tiene un icono en forma de ojo.
| Ojo | Comportamiento |
| --- | --- |
| Visible | El requisito se muestra en la interfaz de usuario de MRQ Submit |
| Oculto | El requisito está oculto pero aún se incluye al enviar el trabajo |
Esta configuración es útil para simplificar la interfaz de usuario para los artistas y, al mismo tiempo, preservar las limitaciones técnicas.
### Paso 7: Adjunte los requisitos a un paso de renderizado
1. Abre el `DeadlineCloudRenderStep` activo correspondiente.
1. Busque el campo **Requisitos del anfitrión**.
1. Asigne el activo que ha creado (por ejemplo,`MyHostRequirements`).
Todos los envíos de MRQ que utilizan este paso ahora aplican tu lógica de selección de anfitriones.
### Resumen
Con el recurso de requisitos del anfitrión, puede:
+ Controle qué máquinas de trabajo ejecutan sus trabajos de renderizado.
+ Especifique los niveles mínimos de recursos.
+ Diríjase a grupos de trabajadores específicos mediante la coincidencia de atributos.
+ Simplifique la interfaz de usuario manteniendo intactas las reglas técnicas.
+ Reutilice la configuración en varios pasos del MRQ.
Esta configuración mejora la coherencia del enrutamiento de los trabajos y garantiza que el renderizado se realice en el hardware correcto.
## Configuraciones avanzadas
### Service-managed flotas frente a flotas gestionadas por el cliente
#### Service-managed flotas (SMF)
En las flotas gestionadas por servicios, el Unreal Engine y el adaptador están disponibles automáticamente mediante el canal `deadline-cloud` conda con el entorno de colas predeterminado. Esta configuración proporciona la experiencia más sencilla.
#### Customer-managed flotas (CMF)
En el caso de las flotas gestionadas por el cliente, Unreal Engine y el adaptador deben instalarse manualmente en los hosts de los trabajadores. Esta configuración proporciona más control y admite funciones adicionales, como la integración con Perforce. Para obtener instrucciones detalladas, consulte [Configurar un empleado de una flota gestionada por el cliente (CMF)](#unreal-engine-cmf-worker-setup).
## Funciones de renderizado de Unreal Engine
El sistema de renderizado de Unreal Engine ofrece un soporte integral para:
| Característica | Description (Descripción) | Notas |
| --- | --- | --- |
| Cola de renderización de películas | High-quality renderización sin conexión | Integración con el envío de trabajos |
| Secuenciador | Timeline-based sistema de animación | Detección y procesamiento automáticos de disparos |
| Plugins de proyectos | Soporte de complementos personalizados | Detección e inclusión automáticas |
| Dependencias de activos | Administración de archivos de contenido | Seguimiento integral de activos |
| Renderizado fijo | Persistencia de la aplicación entre tomas | Rendimiento mejorado para secuencias de múltiples tomas |
El remitente integrado de Unreal Engine detecta y configura automáticamente todas las funciones de renderizado. El adaptador mantiene un manejo adecuado de las dependencias y permite un renderizado eficiente de múltiples tomas sin necesidad de reiniciar Unreal Engine.
## Recursos de código abierto
El remitente y el adaptador son de código abierto y están disponibles en: GitHub
+ [Deadline Cloud para Unreal Engine](https://github.com/aws-deadline/deadline-cloud-for-unreal-engine)