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.
# Motor épico de Unreal
Unreal Engine es una herramienta de creación 3D en tiempo real que ofrece imágenes fotorrealistas y experiencias inmersivas. Unreal Engine es compatible con Deadline Cloud e incluye herramientas de envío, paquetes conda y un adaptador para aumentar el rendimiento de 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 varias máquinas.
## Descripción general del soporte
Unreal Engine es compatible con los siguientes componentes:
+ **Submitter**: complemento de envío integrado para enviar trabajos directamente 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**: un programa que se instala en los servidores de los trabajadores y que mantiene la aplicación cargada entre tareas para acelerar la renderización e informa sobre el progreso de la renderización.
+ **Cross-platform compatibilidad**: solo es compatible con Windows para remitentes y trabajadores.
+ **Integración de Movie Render Queue**: soporte para el sistema Movie Render Queue de Unreal.
## Compatibilidad entre versiones de Unreal Engine
La siguiente tabla muestra los niveles de soporte actuales para las versiones de Unreal Engine:
| Versión principal | Soporte para remitentes | Soporte de Conda |
| --- | --- | --- |
| 5.4 | Windows | Windows |
| 5.5 | Windows | Windows |
| 5.6 | Windows | Windows |
| 5.7 | Windows | Windows |
| 5.8 | Windows | Windows |
## Canal Deadline Cloud Conda
En la siguiente tabla se enumeran todos los paquetes de conda aplicables a Unreal Engine disponibles para Service-managed las flotas del canal conda: `deadline-cloud`
| SO | Package | Versión |
| --- | --- | --- |
| Windows | unreal-engine | 5.4 |
| Windows | motor irreal | 5.5 |
| Windows | motor irreal | 5.6 |
| Windows | motor irreal | 5.7 |
| Windows | motor irreal | 5.8 |
| 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 los servicios de GPU-enabled Windows o una flota gestionada por el cliente con Unreal Engine, el adaptador de Unreal Engine y la 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 |
| --- | --- | --- | --- |
| liberar | 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 en la que 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. Lanza una instancia de Amazon EC2 con un perfil de instancia válido. El perfil 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 Engine (de la 5.4 a la 5.8).
+ UE 5.5 tiene un error de bloqueo conocido cuando se ejecuta con el complemento DirectX 11 (consulta 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: siga 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 Windows, te recomendamos que habilites la compatibilidad con rutas largas de Windows. Para ello, sigue las instrucciones de la [ página de limitación ](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=registry) máxima de rutas de archivo, 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 viene configurada para admitir rutas largas de Windows. Cuando configures a tus trabajadores, sigue los pasos que se indican en el problema vinculado para que las rutas largas de Windows sean totalmente compatibles con las rutas largas hasta que se resuelva el problema.
### Instalación de herramientas de compilación
El complemento Unreal Submitter actualmente 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 las herramientas de compilación son compatibles con tu versión de Unreal consultando la tabla [ de compatibilidad de ](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) Epic.
1. En Componentes ** individuales**, asegúrate de que la versión de las herramientas de compilación de MSVC seleccionada (la «más reciente» 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 usa 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 Deadline Cloud se usa tanto para administrar tus credenciales para enviar trabajos a Deadline Cloud como para monitorear el estado de tus trabajos.
1. Siga 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á instalado) 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, en función 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
Un script auxiliar automatiza `scripts/build_plugin.py` opcionalmente los dos pasos siguientes. Intenta encontrar la versión más reciente de Unreal, crea las dependencias de Python y complementos 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 crear 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 instalado este script correctamente, puedes ir directamente a. [Crear una flota](#unreal-engine-create-fleet)
### Crea el plugin
Ajusta las dos primeras rutas que aparecen a continuación según el lugar en el que se encuentre tu instalación de Unreal y el lugar en el que la hayas instalado`deadline-cloud-for-unreal-engine`.
Desde la carpeta Batchfiles de instalación de Unreal (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 necesarias.
1. Si has creado e instalado el plugin desde la rama de lanzamiento 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 (siguiendo los pasos anteriores`C:\Program Files\Epic Games\UE_5.5\Engine\Plugins\UnrealDeadlineCloudService\UnrealDeadlineCloudService.uplugin`) 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 lo utilizas desde la línea principal, es posible que tengas dependencias de Python que aún no se hayan publicado en PyPI; tendrás que compilar e instalar tu copia local, lo que puedes hacer con hatch. Será necesario cambiar el `.whl` archivo para que refleje la versión generada por 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 del remitente puede instalar las dependencias de Python. Es posible que no estén actualizados con el código anterior de la rama principal o de la versión original, y este método no debería preferirse actualmente.
1. Descargue el instalador del remitente desde la pestaña de descargas de la consola AWS de Deadline Cloud o desde el monitor de Deadline Cloud, en Configuración de la estación de trabajo → Descargas.
1. Ejecute el instalador para todos los usuarios. La ubicación de instalación predeterminada es correcta.
1. Habilita el complemento Unreal Engine.
1. Asegúrate de que la ruta de instalación del complemento de Unreal Engine coincida con la ubicación en la que se copió el complemento (en particular, asegúrate de que tu versión de Unreal coincida).
### Notificaciones de actualización
El complemento de envío 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 que 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, puedes 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 tienes una flota de Windows y no necesitas configurar una nueva, puedes 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 [ administradas 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](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 que [Enviar un renderizado de prueba](#unreal-engine-test-render) se indica a continuación para enviar un trabajo de renderizado de prueba.
### Crear una flota gestionada por el cliente (CMF)
1. Siga [ Crear 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 la tiene.
**aviso**
Al asociar tu CMF a las colas, elimina el entorno de colas de conda predeterminado si no lo utilizas. Esta eliminación evita que se utilice el entorno de 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` las `CondaChannels` variables de la definición de ** parámetros que se ** anulan al enviar el trabajo.
1. Siga los pasos [ de instalación y configuración del host de trabajo ](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/worker-host.html) 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 usuario de los trabajos de Windows para su trabajador de CMF.
1. [Para instalar el software necesario para ejecutar los trabajos](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/install-software.html), siga Instalar y configurar el software necesario para ejecutar los trabajos.
1. Siga estos pasos [Configurar un trabajador de flota gestionado por el cliente (CMF)](#unreal-engine-cmf-worker-setup) para configurar su nodo de trabajo para ejecutar los trabajos de Unreal Engine.
## Enviar un renderizado de prueba
En este ejemplo, se usa 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. Crea un proyecto a partir de la demo de Meerkat y, a continuación, ábrelo.
1. En el ** menú ** Edición, selecciona ** Plugins**, búscalos y actívalos. ** UnrealDeadlineCloudService **
1. Reinicia Unreal si has activado el plugin por primera vez.
1. En ** Edición ** > Configuración ** del proyecto**, busca la ** sección ** Movie Render Pipeline.
+ Para ** Default Remote Executor**, selecciona ** MoviePipelineDeadlineCloudRemoteExecutor**.
+ Para el trabajo de ejecutor ** predeterminado**, seleccione. ** MoviePipelineDeadlineCloudExecutorJob **
+ En Clases de configuración de trabajo ** predeterminadas**, elija el icono de agregar 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 Configuración de la estación de trabajo de ** 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 en su granja.
+ En ** Granja**, asegúrate de que tu cola predeterminada sea una cola asociada a la flota que has configurado anteriormente.
1. Sal de la ventana de configuración del proyecto.
1. Elija ** Windows**, ** Cinematics**, ** Movie Render ** Queue.
+ Elija ** \+ Render 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, podrá cerrar esta ventana.
+ En el lado derecho del cuadro de diálogo, configure los ajustes del trabajo:
+ En Modificaciones ** predefinidas ** (es posible que necesite ampliar este cuadro de diálogo):
+ Amplíe la ** configuración de tareas compartidas: **
+ Establezca **Name (Nombre)** en `Unreal Test Job`.
+ Establezca el ** número máximo de ** reintentos en 2.
+ Amplíe los archivos adjuntos ** del ** trabajo:
+ En Archivos ** de entrada**, seleccione ** Mostrar Auto-Detected**.
+ Compruebe que la lista de archivos detectados automáticamente se complete correctamente.
+ En Anulaciones de plantillas de ** trabajo: **
+ Actualiza la versión de Unreal Engine ** CondaPackages ** si estás usando una versión diferente a la 5.6.
+ La detección automática de versiones de Unreal Engine estará disponible en una versión futura.
+ Selecciona ** Render (remoto). **
1. Puedes ir al monitor de Deadline Cloud y ver el progreso de tu trabajo.
## Configurar un trabajador de flota gestionado por el cliente (CMF)
En esta sección se explica cómo configurar una instancia de Amazon EC2 como un trabajador de CMF para Deadline Cloud con Unreal Engine.
### Descripción general de
Las siguientes son las diferencias clave entre CMF y SMF:
+ **CMF**: Instalación manual de Unreal Engine y del adaptador en los hosts de los trabajadores.
+ **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 |
| --- | --- | --- |
| liberar | 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 su remitente para evitar problemas de compatibilidad.
### Configuración de la instancia Amazon EC2
La siguiente es la configuración de instancia 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 ser compatible con Deadline Cloud.
**2. Instale los controladores NVIDIA GRID**:
+ Siga la guía de instalación del controlador [ AWS NVIDIA GRID](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
El complemento Unreal actualmente debe compilarse localmente.
1. Instale Visual Studio con el instalador [ de ](https://visualstudio.microsoft.com/) Visual Studio.
1. Comprueba que tu versión de Visual Studio y las herramientas de compilación son compatibles con tu versión de Unreal consultando la tabla [ de compatibilidad de ](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) Epic.
1. En Componentes ** individuales**, asegúrate de que la versión de las herramientas de compilación de MSVC seleccionada (la «más reciente» de forma predeterminada) coincida con la versión recomendada en la tabla.
1. En Componentes ** individuales**, seleccione 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 software Deadline Cloud
Clone o `deadline-cloud-for-unreal-engine` descárguelo 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 sus 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 los complementos y las dependencias con un script:
Existe un script auxiliar `scripts/build_plugin.py` que puede automatizar los pasos de instalación restantes. Intenta encontrar la última versión de Unreal, crear las dependencias de plugins y 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 crear e instalar tu copia actual de `deadline-cloud-for-unreal-engine` as a worker 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 según la versión del remitente que se utilice. Si está utilizando la versión del remitente de la rama de lanzamiento GitHub, simplemente puede instalarlo con pip:
```
python -m pip install deadline-cloud-for-unreal-engine
```
Si utilizas la versión principal del remitente o una versión personalizada en desarrollo, 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 versión de tu remitente:
```
pip install hatch
hatch build
python -m pip install dist\my-built-wheel.whl
```
### Creando el complemento
Ajusta las dos primeras rutas que aparecen a continuación según el lugar en el que se encuentre tu instalación de Unreal y el lugar en el que la hayas instalado`deadline-cloud-for-unreal-engine`.
Desde la carpeta Batchfiles de instalación de Unreal (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 con 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 su instancia de trabajador de CMF:
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 ](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/worker-host.html#worker-agent-config) CMF.
1. Si el estado del servicio no es actualmente «En ejecución», haz clic con el botón derecho en él y selecciona ** Iniciar**.
1. Si el DeadlineWorker servicio no se inicia, comprueba los registros de inicio del agente de trabajo en estas ubicaciones:
+ `C:\ProgramData\Amazon\Deadline\Logs\worker-agent.log`
+ `C:\ProgramData\Amazon\Deadline\Logs\queue-\session-.log`
## Impulse la administración de credenciales
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 (Gestor de secretos) | Alto | SMF \+ CMF | Producción (recomendado) |
| 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 de CMF antiguas |
| Pre-configured usuario administrador | Medio | Solo CMF | Configuraciones de CMF simplificadas |
**importante**
Utilice Secrets Manager para entornos de producción. Proporciona un almacenamiento de credenciales centralizado y cifrado 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 la siguiente prioridad:
1. Parámetros de conexión en cualquier marco para 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 las implementaciones 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 o registros de los trabajos.
+ **Rotación automática**: admite la rotación de credenciales sin necesidad de reconfigurar los trabajos.
+ **Registros de auditoría**: realice un seguimiento del acceso y el uso de las credenciales.
+ **Soporte universal**: funciona con las implementaciones de CMF y SMF.
+ **Redacción de registros**: las credenciales de conexión se redactan automáticamente en los registros de trabajos.
#### Paso 1: Crea un secreto en Secrets Manager
Crea un secreto que contenga tus parámetros de conexión de Perforce.
**Pares clave-valor requeridos: **
+ `P4PORT`- La URL y el puerto del servidor obligatoriamente.
+ `P4USER`- Nombre de usuario forzoso.
+ `P4PASSWD`- Impulsar la contraseña.
**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 que aparecen 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 cuando se [ administran los secretos de usuario 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 del Gestor de secretos 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úyala 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 P4. Consulte [Crear un trabajo de renderizado de Perforce](#unreal-engine-perforce-render-job) para conocer los pasos siguientes.
### Variables de entorno de los trabajos
**aviso**
Este enfoque no se recomienda para la producción, ya que expone las credenciales en las configuraciones y registros de los trabajos. Utilice Secrets Manager para entornos de producción.
Puede transferir las credenciales de conexión desde el 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](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) También puedes crear una nueva plantilla de entorno y añadirla a tu 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 están visibles en las configuraciones de trabajo.
+ Las contraseñas pueden aparecer en los registros (no se redactan automáticamente).
+ Sin 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 las configuraciones de cola. Utilice Secrets Manager para gestionar las credenciales de forma segura.
Según la guía del usuario de [ Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html), puede utilizar los entornos de cola para proporcionar aplicaciones de software, variables de entorno y otros recursos a los trabajos en cola. Puedes encontrar ejemplos de entornos de cola en la carpeta [ queue\_environments de deadline-cloud-samples. ](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/queue_environments)
#### Agregue 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. Diríjase a la granja y a la cola con las que está trabajando.
1. Seleccione la pestaña ** Entornos de cola. **
1. Selecciona ** Acción ** y selecciona ** Crear nuevo con ** YAML.
1. Añada lo siguiente y guarde:
```
specificationVersion: environment-2023-09
environment:
name: P4Credentials
variables:
P4PORT: ssl:my-perforce.com:1666
P4USER: j.doe
P4PASSWD: MyVeRyS3cretP4ssW0rd
```
#### Agregue un entorno de colas mediante la 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 puede configurar los hosts de trabajo directamente. Para las implementaciones de SMF, utilice Secrets Manager.
El registro de Windows proporciona un 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`(ajustes específicos 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 en CMF)
**importante**
Esta solución solo es adecuada para CMF, donde puede configurar directamente los hosts de los trabajadores. Para las implementaciones de SMF, utilice Secrets Manager.
Cree un usuario P4 dedicado para los nodos de renderizado con una conexión que no caduque para eliminar la necesidad de transmitir datos secretos, como nombres de usuario y contraseñas. En este caso, se puede usar un único usuario P4 dedicado para conectarse a todos los servidores P4, incluidos los servidores Commit (Master) y Edge, donde se puede acceder al almacén de proyectos.
Por lo tanto, solo es necesario pasar el puerto al que conectarse, si el puerto predeterminado no está configurado para los trabajadores. Puede pasar el puerto añadiendo lo siguiente en el entorno de trabajo o en el entorno de cola, de forma similar a los pasos documentados anteriormente:
```
name: P4Sync
variables:
P4PORT: ssl:my-perforce.com:1666
```
## Crear un trabajo de renderizado de Perforce
En esta sección se explica cómo configurar los activos de datos de los trabajos de Perforce-integrated renderizado para que puedas 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.
+ Verifica que la conexión de Perforce esté establecida y que hayas iniciado sesión.
**Configuración ** de Deadline Cloud:
+ Complete la [Instalación del remitente](#unreal-engine-installation).
+ Configure [Impulse la administración de credenciales](#unreal-engine-perforce-credentials) para los trabajadores.
**Requisitos ** forzosos:
+ Espacio de trabajo de Perforce válido con archivos de proyecto.
+ Permisos de Perforce adecuados para las operaciones de sincronización.
### Arquitectura de trabajos de renderizado forzoso
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**: Proteja la solicitud de credenciales de Perforce desde Secrets Manager.
+ **Sincronización de repositorios**: entorno de sincronización adicional de Perforce para la administración del espacio de trabajo.
+ **Resolución de rutas**: las variables de entorno hacen referencia a las rutas del espacio de trabajo de Perforce.
+ **Recopilación de dependencias**: recopilación y sincronización automáticas de Perforce-tracked los activos.
### Cómo se adapta Perforce Sync a los proyectos de producción
Los proyectos de producción de Unreal Engine pueden alcanzar cientos de gigabytes en decenas de miles de archivos. La Perforce integración mantiene el tiempo de sincronización proporcional a los cambios y no al tamaño del proyecto:
Los trabajos están anclados a una lista de cambios
Al enviarlos, el remitente establece el parámetro del trabajo en la lista de cambios que tu espacio de `PerforceChangelistNumber` trabajo ha sincronizado. Todas las tareas del trabajo se renderizan con la misma revisión, por lo que tu trabajo se puede reproducir incluso cuando los artistas envían nuevos cambios mientras se ejecuta. Los trabajadores solo pueden iniciar una tarea después de que la lista de cambios anclada esté disponible en el servidor desde el Perforce que se sincronizan.
Los trabajadores reutilizan el espacio de trabajo estable de un cliente
Cada trabajador crea su espacio de trabajo de Perforce cliente en un directorio raíz persistente. Registra el emparejamiento en un archivo de `workspace_info.json` registro almacenado junto con el espacio de trabajo. Un trabajador de reemplazo que recibe el mismo almacenamiento lee el registro y reutiliza el cliente existente. No crea un nuevo espacio de trabajo. Como Perforce rastrea la lista de archivos guardados en el servidor con el nombre del cliente, una sincronización normal descarga solo las revisiones de archivos que hayan cambiado desde el último trabajo.
Para aprovechar la reutilización del espacio de trabajo de los clientes en una flota gestionada por servicios, habilite el almacenamiento [ persistente ](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/volumes.html) para que el volumen que contiene el espacio de trabajo sincronizado se vuelva a conectar a los futuros trabajadores.
Si la ruta de red entre la región de la flota y el Perforce servidor tiene un rendimiento bajo o una latencia alta, un servidor Perforce periférico de la región de la flota puede actuar como caché regional para los datos del almacén. Para obtener más información, consulte el control de código fuente de [ Perforce ](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/architecture-guidance.html#perforce-asset-access) en la guía para desarrolladores de * Deadline Cloud. *
### 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 el 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 redactan 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:
+ Ingresa el nombre secreto de tu credencial de Perforce en ** AWS\_SECRET\_P 4INFO. **
+ El valor debe coincidir con el nombre secreto creado en. [Impulse la administración de credenciales](#unreal-engine-perforce-credentials)
#### 2. Cree un activo de datos del entorno Perforce Sync
Configure un entorno OpenJD para crear un espacio de trabajo de 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 una flota gestionada por servicios (SMF).
+ **P4SyncCMFEnv**para una 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:
+ Ingresa el nombre secreto de tu credencial de Perforce en ** AWS\_SECRET\_P 4INFO. **
+ Debe coincidir con el secreto del paso 1.
#### 3. Cree el activo de datos ambientales de 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 el activo de datos de pasos de renderizado 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 al enviar el trabajo.
+ **Parámetros manuales**: revise los valores predeterminados y ajústelos en función de sus requisitos específicos.
+ **ShotsPerTask**: Empieza con 1, aumenta para obtener un mejor rendimiento con disparos sencillos.
1. **Configure los entornos ** (en este orden exacto):
[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 la resolución de las dependencias y el flujo de credenciales adecuados.
1. **Añadir paso de renderizado**: añada "P4RenderStep" a la sección de pasos.
### Enviar los resultados de renderizado a Perforce
De forma predeterminada, un trabajo de Perforce renderizado carga los resultados únicamente a través de los archivos adjuntos del trabajo. En su Perforce lugar, el parámetro de `SubmitMode` trabajo opta por insertar los resultados renderizados, de modo que los fotogramas terminados se guardan en el almacén junto con el proyecto.
| Valor de `SubmitMode` | Comportamiento |
| --- | --- |
| '' (predeterminado) | Solo archivos adjuntos de trabajo. No Perforce se produce ninguna escritura. Los trabajos existentes se comportan sin cambios. |
| submit | Cada tarea de renderizado archiva los archivos que ha producido. Una vez finalizada cada tarea, un AssembleShelves paso combina todos los estantes de tareas en una única lista de cambios agregada y la envía. El registro de trabajos registra el número final de la lista de cambios. |
| shelve | Es la misma agregaciónsubmit, pero la lista de cambios agregada final se archiva en lugar de enviarse, por lo que una persona puede revisar la agregación antes de confirmarla. |
Solo los archivos que han cambiado desde la última sincronización terminan en la lista de cambios. Cada tarea reconcilia los archivos exactos que generó y la integración revierte los archivos cuyo contenido es idéntico al de la revisión del almacén, por lo que volver a renderizar un marco sin cambios no produce ninguna entrada en la lista de cambios.
**nota**
Cuando `SubmitMode` es `submit` o`shelve`, el trabajo no carga los resultados de renderización en Amazon S3 a través de los archivos adjuntos del trabajo. Perforcese convierte en la única ruta de entrega de los marcos. La función de salida de descarga del monitor Deadline Cloud no encuentra los marcos, y los trabajos posteriores que consumen los resultados a través de archivos adjuntos de trabajo no los ven. Los archivos adjuntos de entrada se siguen cargando a través de archivos adjuntos de trabajo de la forma habitual.
Configure a sus trabajadores para que se autentiquen con el Perforce mismo Perforce usuario en todas las tareas de un trabajo, ya que en la etapa de agregación se encuentran las listas de tareas por propietario. La configuración de credenciales recomendada[Impulse la administración de credenciales](#unreal-engine-perforce-credentials), un único secreto compartido en Secrets Manager, ya cumple ese requisito.
### Prácticas recomendadas
#### Pre-submission lista de verificación
+ **Credenciales**: Impulse las credenciales correctamente configuradas (consulte[Impulse la administración de credenciales](#unreal-engine-perforce-credentials)).
+ **Espacio de trabajo**: la especificación incluye todas las asignaciones de vistas necesarias.
+ **Pruebas**: realice una prueba con una pequeña tarea de renderizado antes de enviar trabajos de gran tamaño.
+ **Dependencias**: verifica 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
En la tabla siguiente se muestra cómo afecta la `ShotsPerTask` configuración al rendimiento:
| Disparos por tarea | 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 |
| De 4 a 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 | Rendimiento máximo, gastos generales mínimos |
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**: comprueba 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**: realiza un seguimiento de los tiempos de sincronización y del 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 | Verifique 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; verifique las especificaciones del espacio de trabajo; asegúrese de que existe la lista de cambios |
| Faltan dependencias | Fallos de renderizado, activos faltantes | ReviseMrqJobDependenciesDescriptor, compruebe la recopilación de referencias blandas y verifique todos los activos de Perforce |
| Problemas de resolución de rutas | Errores en el archivo no encontrado | Verificar la P4\_CLIENT\_DIRECTORY variable; comprobar el orden del entorno; validar las rutas raíz del espacio de trabajo |
#### Pasos de depuración
1. **Revise los registros de trabajos**: consulte los registros del entorno de sincronización de Perforce para ver los mensajes de error detallados.
1. **Valide 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 remitente.
1. **Verifica los permisos**: confirma que las funciones de los trabajadores tengan acceso secreto (si utilizas Secrets Manager).
## Requisitos de host personalizados
En esta sección se describe cómo crear y usar los requisitos de host personalizados para el renderizado de Deadline Cloud en Unreal Engine.
### Descripción general de
Los requisitos del anfitrión 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 un hardware específico |
| Requisitos de cantidad personalizados | Nombre \+ min/max valores | Requerir niveles de recursos numéricos (licencias, fichas, cuotas) |
| Requisitos de atributos personalizados | Lista de atributos \+ valores | Se requieren atributos personalizados en las flotas para ejecutar el paso |
**nota**
Si se oculta un requisito mediante el icono con forma de ojo, solo se oculta en la interfaz de usuario de MRQ Submit. El requisito sigue siendo válido al enviar el trabajo.
**importante**
`Attribute`Los valores `Name` y utilizados para los requisitos de cantidad y atributos personalizados deben coincidir estrictamente con los identificadores válidos definidos en la documentación oficial sobre la descripción del puesto vacante: Especificaciones [ del puesto ](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#33-hostrequirements) vacante.
### Paso 1: Crea el activo de requisitos del anfitrión
1. Abre el navegador de contenido en Unreal Engine.
1. Cree un nuevo activo: ** Agregar ** → ** Varios → 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, localiza el campo ** Ruta a la plantilla**.
1. Seleccione la plantilla predeterminada:`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 |
| CPU virtuales (mínimo) | 16 |
| GPU (mínimo) | 1 |
Si Max = 0, entonces no hay un límite superior para ese requisito.
### Paso 4: Agregue requisitos de cantidad personalizados
Se utiliza cuando el requisito es numérico (por ejemplo, el número de licencias, los límites de simultaneidad).
1. Busque la sección Requisitos de importe ** personalizados. **
1. Agregue una nueva entrada y establezca un nombre, por ejemplo:`amount.custom.license`.
1. Establezca los valores mínimos y máximos:
+ Mín: 1.
+ Máximo: 0 (0 significa ilimitado).
### Paso 5: Añadir requisitos de atributos personalizados
Se usa 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 coincidente:
+ **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 de requisito tiene un icono con forma de ojo.
| Ojo | Comportamiento |
| --- | --- |
| Visible | El requisito se muestra en la interfaz de usuario de MRQ Submit |
| Oculto | El requisito está oculto pero se sigue incluyendo al enviar el trabajo |
Esta configuración es útil para simplificar la interfaz de usuario para los artistas y, al mismo tiempo, preservar las restricciones técnicas.
### Paso 7: Adjunte los requisitos a un paso de renderizado
1. Abra el `DeadlineCloudRenderStep` activo correspondiente.
1. Busque el ** campo Requisitos del ** anfitrión.
1. Asigne el activo creado (por ejemplo,`MyHostRequirements`).
Todos los envíos de MRQ que utilicen este paso ahora aplican su lógica de selección de anfitriones.
### Resumen
Con el recurso relativo a los 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 y mantenga 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 la renderización se realice en el hardware correcto.
## Configuraciones avanzadas
### Service-managed Flotas frente a flotas administradas 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 cola predeterminado. Esta configuración proporciona la experiencia más sencilla.
#### Customer-managed flotas (CMF)
En el caso de las flotas administradas por los clientes, 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 trabajador de flota gestionado por el cliente (CMF)](#unreal-engine-cmf-worker-setup).
## Funciones de renderizado de Unreal Engine
El sistema de renderizado de Unreal Engine brinda soporte integral para:
| Característica | Description (Descripción) | Notas |
| --- | --- | --- |
| Movie Render Queue | High-quality renderizado sin conexión | Integración con la presentación de trabajos |
| Secuenciador | Timeline-based sistema de animación | Detección y procesamiento automáticos de disparos |
| Plugins de proyecto | Soporte de complementos personalizados | Detección e inclusión automáticas |
| Dependencias de activos | Administración de archivos de contenido | Seguimiento integral de los activos |
| Renderización fija | Persistencia de la aplicación entre tomas | Rendimiento mejorado para secuencias de varias tomas |
El remitente integrado de Unreal Engine detecta y configura automáticamente todas las funciones de renderizado. El adaptador mantiene una gestión adecuada de las dependencias y admite una renderización 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)