As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Motor Epic Unreal
O Unreal Engine é uma ferramenta de criação 3D em tempo real para visuais fotorreais e experiências imersivas. O Unreal Engine é compatível com o Deadline Cloud com remetentes, pacotes conda e um adaptador para maior desempenho de renderização. Este guia fornece instruções passo a passo para usar o Deadline Cloud com o Unreal Engine para renderizar seus projetos do Movie Render Queue mais rapidamente, distribuindo tarefas de renderização em várias máquinas.
## Visão geral do Support
O Unreal Engine é compatível com os seguintes componentes:
+ **Remetente**: plug-in de envio integrado para envio direto de trabalhos do Unreal Engine com detecção automática de cenas e ativos.
+ **Pacotes Conda**: Deadline Cloud para instalação automática em frotas gerenciadas por serviços.
+ **Adaptador**: Middleware para renderização eficiente com sessões fixas e monitoramento adicional.
+ **Cross-platform compatibilidade**: suporte ao remetente e ao trabalhador somente para Windows.
+ **Integração do Movie Render Queue**: Suporte ao sistema Movie Render Queue da Unreal.
## Compatibilidade da versão do Unreal Engine
A tabela a seguir mostra os níveis de suporte atuais para as versões do Unreal Engine:
| Versão principal | Support ao remetente | Suporte da Conda |
| --- | --- | --- |
| 5.4 | Windows | Windows |
| 5.5 | Windows | Windows |
| 5.6 | Windows | Windows |
| 5.7 | Windows | Windows |
## Canal Deadline Cloud Conda
A tabela a seguir lista todos os pacotes conda aplicáveis ao Unreal Engine disponíveis para Service-managed frotas no canal conda`deadline-cloud`:
| SO | Pacote | Versão |
| --- | --- | --- |
| Windows | motor irreal | 5.4 |
| Windows | motor irreal | 5.5 |
| Windows | motor irreal | 5.6 |
| Windows | motor irreal | 5.7 |
| Windows | unreal-engine-openjd | |
## Introdução
### Pré-requisitos
Antes de instalar o remetente do Unreal Engine, verifique se você tem o seguinte:
+ Estação de trabalho Windows (Windows 10 ou posterior)
+ Versão compatível do Unreal Engine instalada
+ Monitor Deadline Cloud instalado ([baixe aqui](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/monitor-onboarding.html))
+ Acesso a uma fazenda Deadline Cloud com uma frota gerenciada por serviços GPU-enabled do Windows ou uma frota gerenciada pelo cliente com o Unreal Engine, o adaptador Unreal Engine e a configuração de licenciamento
## Instalando o remetente
O remetente do Unreal Engine adiciona a funcionalidade do Deadline Cloud como um plug-in ao Unreal Engine, permitindo que você envie seus trabalhos do Movie Render Queue diretamente para o Deadline Cloud para renderização.
### Escolhendo sua filial
Selecione a ramificação apropriada para sua implantação:
| Ramificação | Estabilidade | Caso de uso | Recomendado para |
| --- | --- | --- | --- |
| soltar | Stable | Produção | A maioria dos usuários |
| linha principal | Atributos mais recentes | Desenvolvimento e testes | Usuários avançados |
**dica**
Use a ramificação de **lançamento** para ambientes de produção para garantir a estabilidade.
### Criação de uma nova instância do Windows Amazon EC2 para instalar o Unreal (opcional)
Se você estiver configurando uma nova instância do Windows Amazon Elastic Compute Cloud (Amazon EC2) como remetente, uma instância g5.2xlarge com 200 GB de armazenamento é o mínimo razoável:
1. Execute uma instância do Amazon EC2 com um perfil de instância válido. Isso é necessário para baixar os drivers NVIDIA GRID conforme as instruções abaixo.
1. Baixe o Epic Installer e instale uma versão compatível do Unreal (5.4 - 5.7).
+ O UE 5.5 tem um bug de falha conhecido ao ser executado com o plugin DirectX 11 (consulte o número UE-276282 do problema do UE). Se precisar de suporte para DirectX no UE 5.5, use o DirectX 12 ou posterior.
1. Drivers NVIDIA GRID - Siga as [instruções de instalação do Windows](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-nvidia-driver.html#nvidia-GRID-driver).
### Caminhos longos do Windows
Muitas das etapas abaixo podem criar arquivos que excedam o tamanho máximo padrão do caminho do Windows. Antes de criar e instalar o remetente ou adaptador do Deadline Cloud for Unreal Engine em uma máquina Windows, recomendamos que você habilite o suporte a caminhos longos do Windows. Para fazer isso, siga as instruções na página [Limitação máxima do caminho do arquivo](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=registry), por exemplo, executando o [PowerShell comando](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=powershell#tabpanel_1_powershell).
Também há um [problema aberto no agente de trabalho](https://github.com/aws-deadline/deadline-cloud-worker-agent/issues/520) causado por uma dependência que não é fornecida configurada para oferecer suporte a caminhos longos do Windows. Ao configurar seus trabalhadores, siga as etapas de solução alternativa no problema vinculado para oferecer suporte total aos caminhos longos do Windows até que o problema seja resolvido.
### Instalando ferramentas de compilação
Atualmente, o plug-in Unreal submitter deve ser compilado localmente.
1. Instale o Visual Studio usando o [Visual Studio Installer](https://visualstudio.microsoft.com/).
1. Verifique se a versão do Visual Studio e das ferramentas de compilação são compatíveis com sua versão do Unreal verificando a [tabela de compatibilidade da 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. Em **Componentes individuais**, certifique-se de que a versão das ferramentas de compilação do MSVC selecionada (“Mais recente” por padrão) corresponda à versão recomendada na tabela. Embora a orientação de compatibilidade possa sugerir uma versão “ou posterior”, às vezes ocorrem erros de compilação ao usar uma versão mais recente do que a listada como “recomendada”.
1. Em **Componentes individuais**, selecione um SDK recente do.NET Framework (4.6.1 e 4.8.1 foram verificados).
1. Em **Cargas de trabalho**, selecione **Desenvolvimento de desktop com C\+\+**.
### Instalando o monitor Deadline Cloud
O monitor Deadline Cloud é usado para gerenciar suas credenciais para enviar trabalhos para o Deadline Cloud e monitorar o status de seus trabalhos.
1. Siga as [instruções de instalação do monitor Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submitter.html#install-deadline-cloud-monitor).
1. Login.
### Configuração do ambiente
1. (Se ainda não estiver instalado) Instale uma versão recente do Python para todos os usuários (verificada com a versão 3.12).
1. Certifique-se de que suas variáveis de ambiente estejam definidas corretamente. Em Variáveis de ambiente do sistema, seu PATH deve incluir:
+ O caminho para sua instalação do Python (por exemplo,`C:\Program Files\Python312`).
+ O caminho para sua pasta Python Scripts (por exemplo,`C:\Program Files\Python312\scripts`).
+ O caminho para seus binários Unreal (por exemplo,`C:\Program Files\Epic Games\UE_5.5\Engine\Binaries\Win64`).
### Instalação do software Deadline Cloud
Clone ou baixe `deadline-cloud-for-unreal-engine` da ramificação de lançamento ou da linha principal, dependendo se você deseja a versão testada mais recente ou todos os commits mais recentes.
```
git clone https://github.com/aws-deadline/deadline-cloud-for-unreal-engine.git
cd deadline-cloud-for-unreal-engine
git switch release
```
### Opcional - Crie e instale o plug-in com script
`scripts/build_plugin.py`Opcionalmente, um script auxiliar automatiza as próximas duas etapas. Ele tenta encontrar a versão mais recente do Unreal, cria seu plug-in e dependências do Python e os instala nos locais corretos. Você pode substituir configurações como a versão Unreal. Para ver a lista de ajuda completa, execute:
```
python scripts/build_plugin.py -h
```
Para criar e instalar sua cópia atual de `deadline-cloud-for-unreal-engine` como remetente com a instalação mais recente do Unreal Engine, execute:
```
python scripts/build_plugin.py --install
```
Se você instalou esse script com sucesso, pode pular para[Criação de uma frota](#unreal-engine-create-fleet).
### Crie o plug-in
Ajuste os dois primeiros caminhos abaixo com base em onde está sua instalação do Unreal e onde você instalou`deadline-cloud-for-unreal-engine`.
Na pasta Unreal Install Batchfiles (o `package` parâmetro pode ser qualquer novo diretório, mas você desejará que ele seja chamado `UnrealDeadlineCloudService` posteriormente):
```
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"
```
Copie a pasta “package” acima para a pasta Plugins da instalação do Unreal (por exemplo,`C:\Program Files\Epic Games\UE_5.5\Engine\Plugins\UnrealDeadlineCloudService`).
### Dependências do Python
Há 4 maneiras de instalar as dependências necessárias do Python.
1. Se você construiu e instalou o plug-in a partir da ramificação de lançamento acima, você pode instalar a partir do pip. Use o seguinte comando de instalação, ajustando os caminhos para sua instalação do 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, em seu `.uplugin` arquivo (nas etapas acima, isso existiria`C:\Program Files\Epic Games\UE_5.5\Engine\Plugins\UnrealDeadlineCloudService\UnrealDeadlineCloudService.uplugin`), você pode adicionar uma `PythonRequirements` seção que corresponda à versão mais recente do `deadline-cloud-for-unreal-engine` in GitHub/PyPI, por exemplo:
```
"PythonRequirements":
[
{
"Platform": "All",
"Requirements":
[
"deadline-cloud-for-unreal-engine>=0.5.0"
]
}
]
```
Talvez você queira desativar o recurso de “hash estrito” nas configurações de Python da Unreal ou adicionar configurações de hash para versões específicas de bibliotecas e dependências que você deseja consumir.
3. Se você estiver usando a linha principal, pode ter dependências do Python que ainda não foram lançadas para o PyPI - você precisará criar e instalar sua cópia local, o que pode ser feito com o hatch. O `.whl` arquivo precisará ser alterado para refletir a versão gerada pelo 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 fim, as dependências do Python podem ser instaladas pelo instalador remetente. Eles podem estar desatualizados com o código acima na versão ou na ramificação principal, e esse método não deve ser preferido no momento.
1. Faça o download do instalador remetente na guia Downloads do console AWS do Deadline Cloud ou no monitor do Deadline Cloud em Configuração da estação de trabalho → Downloads.
1. Execute o instalador para todos os usuários. O local de instalação padrão é bom.
1. Ative o plug-in Unreal Engine.
1. Certifique-se de que o caminho de instalação do plug-in Unreal Engine corresponda ao local para o qual seu plug-in foi copiado (em particular, certifique-se de que sua versão do Unreal corresponda).
### Notificações de atualização
O plug-in do remetente verifica automaticamente as versões mais recentes GitHub quando o Unreal Editor é iniciado. Se uma atualização estiver disponível, uma caixa de diálogo solicitará que você visite a página de lançamento.
**Para desativar as notificações de atualização, desmarque **Mostrar notificações de atualização do remetente** em Configurações **gerais no painel de configurações** do Deadline Cloud (**Editar** > Configurações do **projeto** > **Plugins** > Deadline Cloud).**
Como alternativa, você pode usar a CLI:
```
deadline config set settings.submitter_update_notification false
```
Para reativar:
```
deadline config set settings.submitter_update_notification true
```
## Criação de uma frota
Se você já tem uma frota do Windows e não precisa configurar uma nova frota, pode pular para[Enviando uma renderização de teste](#unreal-engine-test-render).
### Criação de uma frota gerenciada por serviços (SMF)
Siga o [guia do usuário de frotas gerenciadas por serviços](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/smf-manage.html) para criar um SMF, caso ainda não tenha um. [Em [frotas gerenciadas por serviços (SMFs)](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/smf-manage.html), o Unreal Engine e o adaptador estão automaticamente disponíveis usando o canal `deadline-cloud` conda com o ambiente de fila padrão.](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html#conda-queue-environment) Você está pronto para começar a renderizar. Continue com o [Enviando uma renderização de teste](#unreal-engine-test-render) texto abaixo para enviar um trabalho de renderização de teste.
### Criação de uma frota gerenciada pelo cliente (CMF)
1. Siga [Crie uma frota gerenciada pelo cliente](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/create-a-cmf.html) para criar um CMF, se você ainda não tiver um.
**Atenção**
Ao associar seu CMF às filas, remova o ambiente padrão da fila conda se você não o usar. Isso evitará que o ambiente conda seja usado e acidentalmente use as SMF-specific variáveis padrão para trabalhos enviados ao seu CMF. Se você usa conda em seu CMF, lembre-se de atualizar `CondaPackages` `CondaChannels` as variáveis em **Parameter Definition Overrides** durante o envio do trabalho.
1. Siga a [configuração e configuração do host de trabalho](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/worker-host.html) para configurar um host de trabalho.
1. Siga [Gerenciar acesso aos segredos do usuário do trabalho do Windows](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/manage-access-windows-secrets.html) para configurar os segredos do usuário do trabalho do Windows para seu trabalhador CMF.
1. Siga [Instalar e configurar o software necessário para trabalhos](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/install-software.html) para instalar o software necessário para executar trabalhos.
1. Siga [Configurando um trabalhador de frota gerenciada pelo cliente (CMF)](#unreal-engine-cmf-worker-setup) para configurar seu nó de trabalho para executar trabalhos do Unreal Engine.
## Enviando uma renderização de teste
Este exemplo usa o Meerkat Demo do Unreal Marketplace:
1. Inicie o Epic Games Launcher.
1. **Instale a demonstração do Meerkat na guia Amostras.**
1. Crie um projeto a partir da Demonstração do Meerkat e abra-o.
1. No menu **Editar**, selecione **Plugins**, pesquise e ative **UnrealDeadlineCloudService**.
1. Reinicie o Unreal se você ativou o plug-in pela primeira vez.
1. Em **Editar** > **Configurações do projeto**, procure a seção **Movie Render Pipeline**.
+ Em **Default Remote Executor**, selecione **MoviePipelineDeadlineCloudRemoteExecutor**.
+ Em **Default Executor Job**, selecione **MoviePipelineDeadlineCloudExecutorJob**.
+ Em **Default Job Settings Classes**, escolha o ícone Adicionar e adicione **DeadlineCloudRenderStepSetting**.
1. Pesquise as configurações **do Deadline Cloud** e verifique a autenticação:
+ Certifique-se de que seu status mostre “AUTENTICADO” e a Deadline Cloud API mostre “AUTORIZADO”.
+ Se não aparecer, primeiro tente usar o botão **Login**. Se isso não funcionar, abra o monitor do Deadline Cloud e verifique se você está logado.
+ Na seção **Deadline Cloud Workstation Configuration**:
+ Em **Configurações globais**, certifique-se de que seu perfil da AWS esteja configurado corretamente para seu perfil de monitor do Deadline Cloud.
+ Em **Perfil**, certifique-se de que sua fazenda padrão esteja definida como sua fazenda.
+ Em **Fazenda**, certifique-se de que sua fila padrão esteja definida como uma fila associada à frota que você configurou acima.
1. Saia da janela Configurações do projeto.
1. Escolha **Windows**, **Cinemática, Fila de** **renderização de filmes**.
+ Escolha **\+ Renderizar** e selecione **Main\_SEQ**.
+ Escolha **UnsavedConfig**na coluna de configurações.
+ Na janela pop-up, você deve ver as configurações do Deadline Cloud à esquerda. Essa janela pode então ser fechada.
+ No lado direito da caixa de diálogo, defina as configurações do trabalho:
+ Em **Substituições predefinidas** (talvez seja necessário ampliar essa caixa de diálogo):
+ Expanda **as configurações do Job Shared**:
+ Defina **Name (Nome)** como `Unreal Test Job`.
+ Defina **o máximo de tentativas** como 2.
+ Expandir **Job Attachments**:
+ Em **Arquivos de entrada**, selecione **Mostrar Auto-Detected**.
+ Verifique se a lista de arquivos detectados automaticamente está preenchida corretamente.
+ Em **Job Template Overrides**:
+ Atualize a versão do Unreal Engine **CondaPackages**se você estiver usando uma versão diferente da 5.6.
+ A detecção automática da versão do Unreal Engine será lançada em uma versão futura.
+ Escolha **Renderizar (Remoto)**.
1. Você pode acessar o monitor do Deadline Cloud e observar o progresso do seu trabalho.
## Configurando um trabalhador de frota gerenciada pelo cliente (CMF)
Esta seção mostra como configurar uma instância do Amazon EC2 como um trabalhador CMF para o Deadline Cloud com o Unreal Engine.
### Visão geral do
A seguir estão as principais diferenças entre CMF e SMF:
+ **CMF**: instalação manual do Unreal Engine e do adaptador em hosts de trabalho.
+ **SMF**: disponibilidade automática por meio do canal `deadline-cloud` conda.
### Escolhendo sua filial
Selecione a ramificação apropriada para sua implantação:
| Ramificação | Estabilidade | Caso de uso |
| --- | --- | --- |
| soltar | Stable | Implantações de produção |
| linha principal | Mais recente | Desenvolvimento e testes |
**Importante**
Certifique-se de que sua versão de trabalho corresponda à versão do remetente para evitar problemas de compatibilidade.
### Configuração da instância do Amazon EC2
Veja a seguir a configuração de instância recomendada:
+ **Tipo de instância**: g5.2xlarge ou superior.
+ **Armazenamento**: mínimo de 200 GB.
+ **Sistema operacional**: Windows Server 2019/2022.
#### Instalação de software
**1. Instale o Unreal Engine**:
1. Baixe o Epic Games Launcher.
1. Instale o Unreal Engine 5.4 ou superior.
**nota**
O Unreal Engine 5.4\+ é necessário para compatibilidade com o Deadline Cloud.
**2. Instale os drivers NVIDIA GRID**:
+ Siga o [guia de instalação do driver AWS NVIDIA GRID](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-nvidia-driver.html#nvidia-GRID-driver).
+ Necessário para GPU-accelerated renderização em instâncias do Amazon EC2.
### Instalando ferramentas de compilação
Atualmente, o plug-in Unreal deve ser compilado localmente.
1. Instale o Visual Studio usando o [Visual Studio Installer](https://visualstudio.microsoft.com/).
1. Verifique se a versão do Visual Studio e das ferramentas de compilação são compatíveis com sua versão do Unreal verificando a [tabela de compatibilidade da 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. Em **Componentes individuais**, certifique-se de que a versão das ferramentas de compilação do MSVC selecionada (“Mais recente” por padrão) corresponda à versão recomendada na tabela.
1. Em **Componentes individuais**, selecione um SDK recente do.NET Framework (4.6.1 e 4.8.1 foram verificados).
1. Em **Cargas de trabalho**, selecione **Desenvolvimento de desktop com C\+\+**.
### Instalação do software Deadline Cloud
Clone ou baixe `deadline-cloud-for-unreal-engine` da ramificação de lançamento ou da linha principal. Certifique-se de que sua versão de trabalho das bibliotecas seja compatível com a versão que está sendo usada por seus remetentes.
```
git clone https://github.com/aws-deadline/deadline-cloud-for-unreal-engine.git
cd deadline-cloud-for-unreal-engine
git switch release
```
Opcional - Crie e instale plug-ins e dependências com script:
Existe um script auxiliar `scripts/build_plugin.py` que pode automatizar as etapas restantes da instalação. Ele tenta encontrar a versão mais recente do Unreal, criar suas dependências de plug-in e python e instalá-las nos locais corretos. Configurações como a versão Unreal a ser usada podem ser substituídas. Para ver a lista de ajuda completa, execute:
```
python scripts/build_plugin.py -h
```
Para criar e instalar sua cópia atual do `deadline-cloud-for-unreal-engine` as a worker com a instalação mais recente do Unreal Engine, execute:
```
python scripts/build_plugin.py --install --worker
```
Configure o agente de trabalho do Deadline Cloud executando:
```
install-deadline-worker ^
--farm-id FARM_ID ^
--fleet-id FLEET_ID ^
--region REGION ^
--allow-shutdown
```
Se você instalou com esse script e configurou o agente de trabalho com êxito, pode pular para[Iniciando o serviço Deadline Cloud Worker Agent](#unreal-engine-cmf-start-agent).
```
python -m pip install deadline-cloud-worker-agent
```
A versão correta do adaptador deve ser instalada dependendo da versão do remetente que está sendo usada. Se você estiver usando a versão do remetente da ramificação de lançamento em GitHub, basta instalar com pip:
```
python -m pip install deadline-cloud-for-unreal-engine
```
Se você estiver usando a linha principal ou uma versão personalizada em desenvolvimento do remetente, para evitar problemas de compatibilidade, recomendamos que você crie e instale a partir da mesma versão do código ou transfira o `.whl` arquivo da compilação do remetente:
```
pip install hatch
hatch build
python -m pip install dist\my-built-wheel.whl
```
### Construindo o plugin
Ajuste os dois primeiros caminhos abaixo com base em onde está sua instalação do Unreal e onde você instalou`deadline-cloud-for-unreal-engine`.
Na pasta Unreal Install Batchfiles (o `package` parâmetro pode ser qualquer novo diretório, mas você desejará que ele seja chamado `UnrealDeadlineCloudService` posteriormente):
```
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"
```
Copie a pasta “package” acima para a pasta Plugins da instalação do Unreal (por exemplo,`C:\Program Files\Epic Games\UE_5.5\Engine\Plugins\UnrealDeadlineCloudService`).
### pywin32
A versão do Python da Unreal precisará do pywin32. Instale o Pip usando uma cópia da instalação Python de terceiros da Unreal:
```
"C:\Program Files\Epic Games\UE_5.5\Engine\Binaries\ThirdParty\Python3\Win64\python" -m pip install pywin32
```
### Iniciando o serviço Deadline Cloud Worker Agent
Na sua instância de trabalho do CMF:
1. Abra o **Gerenciador de tarefas**.
1. Escolha a guia **Serviços** à direita.
1. Encontre **DeadlineWorker**.
+ Se você não o vê listado, provavelmente perdeu as etapas (`install-deadline-worker`em particular) das [etapas de configuração do host CMF](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/worker-host.html#worker-agent-config).
1. Se o status do serviço não for “Em execução” no momento, clique com o botão direito nele e selecione **Iniciar**.
1. Se seu DeadlineWorker serviço não estiver iniciando, verifique os registros de lançamento do agente de trabalho nos seguintes locais:
+ `C:\ProgramData\Amazon\Deadline\Logs\worker-agent.log`
+ `C:\ProgramData\Amazon\Deadline\Logs\queue-\session-.log`
## Gerenciamento de credenciais Perforce
Esta seção aborda o gerenciamento seguro de credenciais para integrar o Perforce aos trabalhadores do Deadline Cloud.
### Visão geral do
Há várias abordagens para configurar as credenciais do Perforce para funcionários do Deadline Cloud. Cada método tem implicações de segurança e casos de uso diferentes:
| Método | Nível de segurança | Suporte de implantação | Uso recomendado |
| --- | --- | --- | --- |
| AWS Secrets Manager (Secrets Manager) | Alto | SMF \+ CMF | Produção (recomendada) |
| Variáveis de ambiente de trabalho | Baixo | SMF \+ CMF | Somente desenvolvimento e teste |
| Variáveis de ambiente de fila | Baixo | SMF \+ CMF | Somente desenvolvimento e teste |
| Registro do Windows | Médio | Somente CMF | Configurações CMF antigas |
| Pre-configured usuário administrador | Médio | Somente CMF | Configurações simplificadas de CMF |
**Importante**
Use o Secrets Manager para ambientes de produção. Ele fornece armazenamento centralizado e criptografado de credenciais com trilhas de auditoria e funciona com implantações de SMF e CMF.
### Noções básicas sobre credenciais P4
Para recuperar as configurações de conexão, incluindo URL e porta do servidor Perforce, nome de usuário e senha, o Perforce segue a seguinte prioridade:
1. Parâmetros de conexão em qualquer estrutura para Perforce (P4) (`p4python.P4`por exemplo).
1. User/system variáveis de ambiente:`P4PORT`,`P4USER`,`P4CLIENT`,`P4PASSWD`.
1. Registro do Windows: `HKEY_LOCAL_MACHINE\SOFTWARE\Perforce\Environment` (configurações de todo o sistema) ou `HKEY_CURRENT_USER\SOFTWARE\Perforce\Environment` (configurações específicas do usuário).
Com essas prioridades, se você tiver a seguinte configuração:
+ O parâmetro de conexão `password` é `password.from.connection`
+ A variável de ambiente `%P4PORT%` é `ssl:perforce.from.env:1666`
+ O registro do Windows `HKEY_CURRENT_USER\SOFTWARE\Perforce\Environment:P4PORT` é `ssl:perforce.from.registry:1666`
+ O registro do Windows `HKEY_CURRENT_USER\SOFTWARE\Perforce\Environment:P4USER` é `user.from.registry`
+ O registro do Windows `HKEY_CURRENT_USER\SOFTWARE\Perforce\Environment:P4PASSWD` é `password.from.registry`
A conexão Perforce resultante será:
```
Port = ssl:perforce.from.env:1666
User = user.from.registry
Password = password.from.connection
```
### Secrets Manager (recomendado)
O Secrets Manager fornece a solução mais segura e escalável para implantações de CMF e SMF.
Essa abordagem oferece os seguintes benefícios:
+ **Segurança centralizada**: armazene todas as credenciais P4 em um local criptografado.
+ **Sem exposição de credenciais**: as credenciais nunca aparecem nas configurações ou registros do trabalho.
+ **Rotação automática**: Support a rotação de credenciais sem reconfiguração do trabalho.
+ **Trilhas de auditoria**: acompanhe o acesso e o uso das credenciais.
+ **Suporte universal**: funciona com implantações CMF e SMF.
+ **Redação do registro**: as credenciais de conexão são editadas automaticamente nos registros de tarefas.
#### Etapa 1: criar um segredo no Secrets Manager
Crie um segredo contendo seus parâmetros de conexão do Perforce.
Pares de **valores-chave necessários**:
+ `P4PORT`- Por favor, URL e porta do servidor.
+ `P4USER`- Nome de usuário Perforce.
+ `P4PASSWD`- Por favor, senha.
**Importante**
Os nomes das chaves devem corresponder exatamente aos parâmetros de conexão P4 para trabalhar com `deadline-cloud-for-unreal-engine` eles.
**Exemplo de segredo**:
```
{
"P4PORT": "ssl:your-perforce-server.com:1666",
"P4USER": "your-perforce-username",
"P4PASSWD": "your-perforce-password"
}
```
**Para criar o segredo**:
1. Abra o console do Secrets Manager.
1. Escolha “Armazenar um novo segredo”.
1. Selecione “Outro tipo de segredo”.
1. Insira os pares de valores-chave acima.
1. Dê um nome ao seu segredo (por exemplo,`deadline-cloud-p4-credentials`).
1. Conclua o processo de criação.
#### Etapa 2: conceder ao trabalhador acesso ao segredo
Os trabalhadores precisam de `secretsmanager:GetSecretValue` permissão para acessar o segredo. Isso segue o mesmo padrão do [gerenciamento de segredos de usuário de tarefas do Windows](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/manage-access-windows-secrets.html#grant-access).
**Para conceder acesso**:
1. Abra o console do Secrets Manager e navegue até seu segredo.
1. Na seção “Permissões de recursos”, adicione esta política:
```
{
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "QUEUE_ROLE_ARN"
},
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": "*"
}
]
}
```
1. `QUEUE_ROLE_ARN`Substitua pelo ARN real da função de fila.
1. Salve a política.
**nota**
Salve o nome secreto - você precisará dele ao configurar trabalhos de renderização P4. Veja [Criação de um trabalho de renderização do Perforce](#unreal-engine-perforce-render-job) as próximas etapas.
### Variáveis de ambiente de trabalho
**Atenção**
Essa abordagem não é recomendada para produção, pois expõe as credenciais nas configurações e registros do trabalho. Use o Secrets Manager para ambientes de produção.
[Você pode passar credenciais de conexão no ambiente de trabalho em que a criação do espaço de trabalho acontece, por exemplo, em [p4\_sync\_smf\_environment, ugs\_sync\_smf\_environment ou ambientes semelhantes](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) 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, crie um novo modelo de ambiente e adicione-o ao seu trabalho.
```
name: P4Credentials
variables:
P4PORT: ssl:my-perforce.com:1666
P4USER: j.doe
P4PASSWD: MyVeRyS3cretP4ssW0rd
```
Essa abordagem tem os seguintes riscos de segurança:
+ As credenciais são visíveis nas configurações do trabalho.
+ As senhas podem aparecer nos registros (não são editadas automaticamente).
+ Sem gerenciamento centralizado de credenciais.
+ É difícil alternar as credenciais.
### Variáveis de ambiente de fila
**Atenção**
Essa abordagem não é recomendada para produção, pois armazena credenciais em configurações de fila. Use o Secrets Manager para gerenciamento seguro de credenciais.
De acordo com o [guia do usuário do Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html), você pode usar ambientes de fila para fornecer aplicativos de software, variáveis de ambiente e outros recursos para trabalhos na fila. Amostras do ambiente de fila podem ser encontradas na pasta [queue\_environments](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/queue_environments) em deadline-cloud-samples.
#### Adicione um ambiente de fila usando o monitor ou console do Deadline Cloud
1. Monitor de nuvem Open Deadline ou o console da AWS.
1. Navegue até a fazenda e a fila com as quais você está trabalhando.
1. Selecione a guia **Ambientes de fila**.
1. Escolha **Ação** e selecione **Criar novo com YAML.**
1. Adicione o seguinte e salve:
```
specificationVersion: environment-2023-09
name: P4Credentials
variables:
P4PORT: ssl:my-perforce.com:1666
P4USER: j.doe
P4PASSWD: MyVeRyS3cretP4ssW0rd
```
#### Adicionar ambiente de fila usando CLI
1. Crie um `p4_credentials.yaml` arquivo com a amostra acima.
1. Execute o seguinte comando da CLI:
```
aws deadline create-queue-environment \
--farm-id FARM_ID \
--queue-id QUEUE_ID \
--priority 1 \
--template-type YAML \
--template file://p4_credentials.yaml
```
### Registro do Windows (somente CMF)
**Importante**
Essa solução é adequada apenas para CMF, onde você pode configurar os hosts de trabalho diretamente. Para implantações SMF, use o Secrets Manager.
O registro do Windows fornece armazenamento local de credenciais em máquinas de trabalho. Esse método usa o sistema de prioridade Perforce padrão, no qual as credenciais são armazenadas em:
+ `HKEY_LOCAL_MACHINE\SOFTWARE\Perforce\Environment`(configurações de todo o sistema).
+ `HKEY_CURRENT_USER\SOFTWARE\Perforce\Environment`(configurações específicas do usuário).
Essa abordagem só é adequada para implantações de CMF nas quais você tem acesso direto para configurar máquinas de trabalho.
### Pre-configured usuário administrador (somente CMF)
**Importante**
Essa solução é adequada apenas para CMF, onde você pode configurar os hosts de trabalho diretamente. Para implantações SMF, use o Secrets Manager.
Crie um usuário P4 dedicado para renderizar nós com uma conexão que não expira para eliminar a necessidade de transmitir dados secretos, como nomes de usuário e senhas. Nesse caso, um único usuário P4 dedicado pode ser usado para se conectar a todos os servidores P4, incluindo os servidores Commit (Master) e Edge, onde o depósito do projeto está acessível.
Portanto, você só precisa passar a porta à qual se conectar, se o padrão não estiver configurado em trabalhadores. Isso pode ser feito adicionando o seguinte em um ambiente de trabalho ou em um ambiente de fila semelhante às etapas documentadas acima:
```
name: P4Sync
variables:
P4PORT: ssl:my-perforce.com:1666
```
## Criação de um trabalho de renderização do Perforce
Esta seção mostra como configurar os ativos de dados do trabalho de Perforce-integrated renderização para que você possa enviar trabalhos de Perforce-integrated renderização do Unreal Engine para o Deadline Cloud.
### Pré-requisitos
Antes de enviar um trabalho do Movie Render Queue (MRQ) do Unreal Engine em um repositório Perforce:
**Configuração do projeto Unreal**:
+ O projeto deve estar dentro do espaço de trabalho do Perforce.
+ Verifique se a conexão do Perforce foi estabelecida e se você está logado.
**Configuração do Deadline Cloud**:
+ Completa [Instalando o remetente](#unreal-engine-installation).
+ Configure [Gerenciamento de credenciais Perforce](#unreal-engine-perforce-credentials) para trabalhadores.
**Requisitos do Perforce**:
+ Espaço de trabalho válido do Perforce com arquivos de projeto.
+ Permissões apropriadas do Perforce para operações de sincronização.
### Arquitetura de trabalho de renderização Perforce
Os trabalhos de renderização P4 estendem o trabalho de renderização padrão com os recursos de sincronização do 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
```
**Principais diferenças em relação aos trabalhos padrão**:
+ **Gerenciamento de credenciais**: aplicativo de credenciais Secure Perforce do Secrets Manager.
+ **Sincronização do repositório**: ambiente adicional de sincronização Perforce para gerenciamento do espaço de trabalho.
+ **Resolução do caminho**: as variáveis de ambiente fazem referência aos caminhos do espaço de trabalho do Perforce.
+ **Coleta de dependências**: coleta e sincronização automáticas de Perforce-tracked ativos.
### Configurando os componentes do trabalho de renderização do Perforce
Siga estas etapas para criar os ativos de dados necessários para trabalhos de Perforce-integrated renderização.
#### 1. Crie um ativo de dados Apply Perforce Credentials
Configure um ambiente OpenJD para recuperar as credenciais do Perforce do Secrets Manager e aplicá-las à conexão do Perforce.
**nota**
As variáveis de ambiente aparecem nos registros com o `openjd_env` prefixo, mas os dados confidenciais (porta, usuário, senha) são automaticamente editados por motivos de segurança.
**Etapas de configuração**:
1. Crie um novo ativo de dados **do Deadline Cloud Perforce Environment**.
1. Nomeie o ativo de dados de forma descritiva (por exemplo, "ApplyP4SecretEnv“).
1. Selecione o `p4_apply_secrets_environment.yml` modelo de`Content/Python/openjd_templates/p4/`.
1. Configure a referência secreta:
+ **Insira o nome secreto da sua credencial Perforce no AWS\_SECRET\_P 4INFO.**
+ Isso deve corresponder ao nome secreto criado em[Gerenciamento de credenciais Perforce](#unreal-engine-perforce-credentials).
#### 2. Crie um ativo de dados do ambiente de sincronização Perforce
Configure um ambiente OpenJD para criar um espaço de trabalho Perforce, sincronizar arquivos do servidor Perforce e limpar o espaço de trabalho após a renderização.
**Etapas de configuração**:
1. Crie um novo ativo de dados **do Deadline Cloud Perforce Environment**.
1. Nomeie o ativo de dados com base no tipo de sua frota:
+ **P4SyncSMFEnv**para frota gerenciada por serviços (SMF).
+ **P4SyncCMFEnv**para frota gerenciada pelo cliente (CMF).
1. Selecione o modelo apropriado em`Content/Python/openjd_templates/p4/`:
+ **SMF**:`p4_sync_smf_environment.yml`.
+ **CMF**:`p4_sync_cmf_environment.yml`.
1. Configure a referência secreta:
+ **Insira o nome secreto da sua credencial Perforce no AWS\_SECRET\_P 4INFO.**
+ Deve corresponder ao segredo da etapa 1.
#### 3. Crie um ativo de dados do ambiente Perforce Launch UE
Configure um ambiente OpenJD para lançar o Unreal Engine com integração com Perforce. Isso faz referência automaticamente ao espaço de trabalho do Perforce criado pelo ambiente de sincronização.
**Etapas de configuração**:
1. Crie um novo ativo de dados **do Deadline Cloud Environment**.
1. Nomeie o ativo de dados de forma descritiva (por exemplo, "P4LaunchUEEnv“).
1. Selecione o `p4_launch_ue_environment.yml` modelo de`Content/Python/openjd_templates/p4/`.
1. Defina as configurações do ambiente:
+ Defina **REMOTE\_EXECUTION** como. `True`
+ Essa configuração ativa recursos de renderização remota.
#### 4. Crie um ativo de dados da etapa de renderização Perforce
Configure uma etapa de renderização do OpenJD para executar o processo de renderização.
**Etapas de configuração**:
1. Crie um novo ativo de dados **do Deadline Cloud Render Step**.
1. Nomeie o ativo de dados de forma descritiva (por exemplo, "P4RenderStep“).
1. Selecione o `p4_render_step.yml` modelo de`Content/Python/openjd_templates/p4/`.
#### 5. Crie um ativo de dados de trabalho de renderização Perforce
Configure um trabalho de renderização do OpenJD que orquestre todo o fluxo de trabalho de renderização.
**Etapas de configuração**:
1. Crie um novo ativo de dados **do Deadline Cloud Render Job**.
1. Nomeie o ativo de dados de forma descritiva (por exemplo, "P4RenderJob“).
1. Selecione o `p4_render_job.yml` modelo de`Content/Python/openjd_templates/p4/`.
1. **Revise as definições de parâmetros**: o modelo inclui esses parâmetros com seus comportamentos padrão:
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/deadline-cloud/latest/userguide/epic-unreal-engine.html)
**Diretrizes de configuração de parâmetros**:
+ **Auto-populated parâmetros**: deixe-os vazios - eles são preenchidos automaticamente durante o envio do trabalho.
+ **Parâmetros manuais**: revise os padrões e ajuste-os com base em seus requisitos específicos.
+ **ChunkSize**: Comece com 1, aumente para obter um melhor desempenho com fotos simples.
1. **Configure ambientes** (nesta ordem exata):
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/deadline-cloud/latest/userguide/epic-unreal-engine.html)
**Importante**
A ordem do ambiente é essencial para a resolução adequada de dependências e o fluxo de credenciais.
1. **Adicionar etapa de renderização**: adicione "P4RenderStep" à seção Etapas.
### Práticas recomendadas
#### Pre-submission lista de verificação
+ **Credenciais**: force as credenciais configuradas corretamente (consulte). [Gerenciamento de credenciais Perforce](#unreal-engine-perforce-credentials)
+ **Espaço de trabalho**: a especificação inclui todos os mapeamentos de visualização necessários.
+ **Teste**: teste com uma pequena tarefa de renderização antes de envios de trabalhos grandes.
+ **Dependências**: verifique se todas as dependências do projeto estão no Perforce e estão acessíveis.
+ **Permissões**: confirme se as funções dos trabalhadores têm acesso ao Secrets Manager.
#### Otimização de desempenho
**Configuração do tamanho do fragmento**:
| Tamanho do bloco | Caso de uso | Impacto no desempenho |
| --- | --- | --- |
| 1-2 tiros | Fotos complexas, análise detalhada necessária | Menor produtividade, maior controle de qualidade |
| 4-8 tiros | Carga de trabalho equilibrada, projetos típicos | Equilíbrio ideal entre velocidade e capacidade de gerenciamento |
| Mais de 10 tiros | Fotos simples, processamento em lote | Rendimento máximo, sobrecarga mínima |
Considere as seguintes otimizações adicionais:
+ **Dependências**: minimize dependências desnecessárias de ativos para reduzir o tempo de sincronização.
+ **Visualizações do espaço de trabalho**: otimize as visualizações do espaço de trabalho do Perforce para sincronizar somente os arquivos necessários.
#### Monitoramento e depuração
+ **Registros de trabalhos**: monitore o processo de sincronização do Perforce nos registros de execução de trabalhos.
+ **Status do espaço de trabalho**: verifique a criação do espaço de trabalho e a conclusão da sincronização.
+ **Coleta de dependências**: verifique se todos os ativos necessários foram capturados.
+ **Métricas de desempenho**: acompanhe os tempos de sincronização e o desempenho da renderização.
### Solução de problemas
#### Problemas e soluções comuns de
| Problema | Sintomas | Solução |
| --- | --- | --- |
| Falhas na conexão P4 | Erros de autenticação, tempo limite | Verifique as credenciais do Perforce; verifique a conectividade de rede; valide a acessibilidade do servidor Perforce |
| Erros de sincronização do espaço de trabalho | Falhas de sincronização, permissão negada | Verifique as permissões de usuário do Perforce; verifique a especificação do espaço de trabalho; garanta que a lista de alterações exista |
| Dependências ausentes | Falhas de renderização, ativos ausentes | ReviseMrqJobDependenciesDescriptor; verifique a coleção de referências eletrônicas; verifique todos os ativos no Perforce |
| Problemas de resolução de caminhos | Erros de arquivo não encontrado | Verifique a P4\_CLIENT\_DIRECTORY variável; verifique a ordem do ambiente; valide os caminhos raiz do espaço de trabalho |
#### Etapas de depuração
1. **Verifique os registros de tarefas**: revise os registros do ambiente de sincronização do Perforce para obter mensagens de erro detalhadas.
1. **Validar o espaço de trabalho**: verifique se a especificação do espaço de trabalho do Perforce está correta.
1. **Teste localmente**: verifique se as operações do Perforce funcionam na máquina remetente.
1. **Verifique as permissões**: confirme se as funções dos trabalhadores têm acesso secreto (se estiver usando o Secrets Manager).
## Requisitos de host personalizados
Esta seção descreve como criar e usar requisitos de host personalizados para renderização do Deadline Cloud no Unreal Engine.
### Visão geral do
Os requisitos do host definem qual frota está qualificada para executar uma etapa de renderização específica. Eles são armazenados dentro de um `UDeadlineCloudHostRequirements` ativo, que é então referenciado por um `DeadlineCloudRenderStep` ativo.
| Tipo de requisito | Local de configuração | Caso de uso |
| --- | --- | --- |
| Requisitos básicos do sistema | Campos de CPU/RAM/GPU | Restrinja a renderização a máquinas com hardware específico |
| Requisitos de quantidade personalizados | Nome \+ min/max valores | Exigir níveis de recursos numéricos (licenças, tokens, cotas) |
| Requisitos de atributos personalizados | Lista de atributos \+ valores | Atributos personalizados necessários nas frotas para executar a etapa |
**nota**
Ocultar um requisito usando o ícone de olho só o oculta na interface de usuário do MRQ Submit. O requisito ainda se aplica ao enviar o trabalho.
**Importante**
`Attribute`Os valores `Name` e usados para requisitos de valor personalizados e requisitos de atributos personalizados devem corresponder estritamente aos identificadores válidos definidos na documentação oficial da Open Job Description: [Open Job Specifications](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#33-hostrequirements).
### Etapa 1: criar o ativo de requisitos do host
1. Abra o Navegador de conteúdo no Unreal Engine.
1. **Crie um novo ativo: **Adicionar** → **Diversos → Ativo de dados** →. **DeadlineCloudHostRequirements****
1. Nomeie o ativo, por exemplo,`MyHostRequirements`.
### Etapa 2: carregar o modelo YAML padrão
1. No painel de detalhes do ativo, localize o campo **Caminho para o modelo**.
1. Selecione o modelo padrão:`Plugins/UnrealDeadlineCloudService/Content/Python/openjd_templates/host_requirements.yml`.
Isso carrega requisitos básicos, como CPU, memória, GPU, sistema operacional e arquitetura.
**nota**
Os requisitos básicos não podem ser removidos; somente seus valores podem ser alterados.
### Etapa 3: Configurar os requisitos básicos (do sistema)
| Configuração | Exemplo |
| --- | --- |
| Sistema operacional | windows |
| Arquitetura de CPU | x86\_64 |
| vCPUs (mín.) | 16 |
| GPUs (mín.) | 1 |
Se Max = 0, então não há limite superior para esse requisito.
### Etapa 4: adicionar requisitos de valor personalizados
Usado quando o requisito é numérico (por exemplo, número de licenças, limites de simultaneidade).
1. Encontre a seção **Requisitos de quantidade personalizada**.
1. Adicione uma nova entrada e defina um nome, por exemplo:`amount.custom.license`.
1. Defina os valores mínimo e máximo:
+ Mín: 1.
+ Máximo: 0 (0 significa ilimitado).
### Etapa 5: adicionar requisitos de atributos personalizados
Usado para filtrar trabalhadores com base em etiquetas e rótulos.
1. Encontre a seção **Requisitos de atributos personalizados**.
1. Adicione um novo nome de atributo, por exemplo:`attr.custom.gpu.vendor`.
1. Escolha a regra de correspondência:
+ **AllOf**- todos os valores devem corresponder.
+ **AnyOf**- pelo menos um deve corresponder.
1. Insira valores de atributos separados por espaços, por exemplo:`nvidia amd`.
### Etapa 6: Visibilidade no MRQ (opcional)
Cada entrada de requisito tem um ícone de olho.
| Olho | Comportamento |
| --- | --- |
| Visible (Visível) | O requisito é mostrado na interface de usuário do MRQ Submit |
| Oculto | O requisito está oculto, mas ainda está incluído ao enviar o trabalho |
Essa configuração é útil para simplificar a interface do usuário para artistas e, ao mesmo tempo, preservar as restrições técnicas.
### Etapa 7: anexar os requisitos a uma etapa de renderização
1. Abra o `DeadlineCloudRenderStep` ativo relevante.
1. Encontre o campo **Requisitos do host**.
1. Atribua seu ativo criado (por exemplo,`MyHostRequirements`).
Todos os envios de MRQ usando essa etapa agora aplicam sua lógica de seleção de anfitriões.
### Resumo
Usando o ativo de requisitos do host, você pode:
+ Controle quais máquinas de trabalho executam seus trabalhos de renderização.
+ Especifique os níveis mínimos de recursos.
+ Segmente grupos de trabalhadores específicos usando a correspondência de atributos.
+ Simplifique a interface do usuário enquanto mantém as regras técnicas intactas.
+ Reutilize as configurações em várias etapas do MRQ.
Essa configuração melhora a consistência do roteamento de trabalhos e garante que a renderização ocorra no hardware correto.
## Configurações avançadas
### Service-managed frotas versus frotas gerenciadas pelo cliente
#### Service-managed frotas (SMF)
Em frotas gerenciadas por serviços, o Unreal Engine e o adaptador estão automaticamente disponíveis usando o canal `deadline-cloud` conda com o ambiente de fila padrão. Essa configuração fornece a experiência mais fácil.
#### Customer-managed frotas (CMF)
Para frotas gerenciadas pelo cliente, o Unreal Engine e o adaptador devem ser instalados manualmente nos hosts dos trabalhadores. Essa configuração fornece mais controle e oferece suporte a recursos adicionais, como a integração com o Perforce. Para obter instruções detalhadas, consulte [Configurando um trabalhador de frota gerenciada pelo cliente (CMF)](#unreal-engine-cmf-worker-setup).
## Recursos de renderização do Unreal Engine
O sistema de renderização do Unreal Engine fornece suporte abrangente para:
| Recurso | Description | Observações |
| --- | --- | --- |
| Fila de renderização de filmes | High-quality renderização offline | Integração com o envio de trabalhos |
| Sequenciador | Timeline-based sistema de animação | Detecção e processamento automáticos de disparos |
| Plugins de projeto | Suporte a plug-ins personalizados | Detecção e inclusão automáticas |
| Dependências de ativos | Gerenciamento de arquivos de conteúdo | Rastreamento abrangente de ativos |
| Renderização pegajosa | Persistência do aplicativo entre as fotos | Desempenho aprimorado para sequências de várias tomadas |
Todos os recursos de renderização são detectados e configurados automaticamente pelo remetente integrado do Unreal Engine. O adaptador mantém o tratamento adequado de dependências e oferece suporte à renderização eficiente de várias tomadas sem reiniciar o Unreal Engine.
## Recursos de código aberto
O remetente e o adaptador são de código aberto e estão disponíveis em: GitHub
+ [Deadline Cloud para Unreal Engine](https://github.com/aws-deadline/deadline-cloud-for-unreal-engine)