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á.
# Crie um canal conda usando o S3
Se seus trabalhos precisarem executar aplicativos não disponíveis nos [https://conda-forge.org/](https://conda-forge.org/)canais [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)or, você pode hospedar um canal conda personalizado para servir seus próprios pacotes. Quando você cria uma fila no console do AWS Deadline Cloud (Deadline Cloud), o console adiciona um ambiente de fila conda por padrão. Para disponibilizar seus pacotes para trabalhos, adicione o canal personalizado ao ambiente de fila.
Um canal conda é um conteúdo hospedado estático que você pode hospedar [de várias maneiras, inclusive em um](https://rattler-build.prefix.dev/latest/publish/) sistema de arquivos ou em um bucket do Amazon Simple Storage Service (Amazon S3). Se o seu farm do Deadline Cloud usa um sistema de arquivos compartilhado para ativos, você pode usar qualquer caminho nele como nome do canal. Você pode hospedar o canal em um bucket do Amazon S3 para um acesso mais amplo usando permissões AWS Identity and Access Management (IAM).
Você pode [criar e testar pacotes localmente](build-test-packages-locally.md) e depois [publicá-los em um canal](publish-packages-s3-channel.md). Construir pacotes localmente é uma maneira fácil de começar a iterar em receitas de compilação de pacotes sem configuração de infraestrutura. Você também pode usar uma [fila de criação de pacotes do](automate-package-builds.md) Deadline Cloud para criar pacotes e publicá-los em um canal. Uma fila de criação de pacotes simplifica a manutenção de pacotes para vários sistemas operacionais e configurações de aceleradores. Você pode atualizar versões e enviar conjuntos completos de compilações de pacotes de qualquer lugar.
Você pode configurar canais para seu estúdio e sua fazenda do Deadline Cloud de várias maneiras. Você pode ter um canal Amazon S3 e configurar todas as suas estações de trabalho e hosts de farm para usá-lo. Você também pode ter mais de um canal e configurar o espelhamento com AWS DataSync (DataSync). Por exemplo, sua fila de criação de pacotes do Deadline Cloud pode ser publicada em um canal do Amazon S3 que é espelhado localmente para estações de trabalho e hosts agrícolas locais.
**Topics**
+ [Crie e teste pacotes localmente](build-test-packages-locally.md)
+ [Publique pacotes em um canal conda do Amazon S3](publish-packages-s3-channel.md)
+ [Configurar permissões de fila de produção para pacotes conda personalizados](#s3-channel-configure-permissions)
+ [Adicionar um canal conda a um ambiente de fila](#s3-channel-add-channel)
+ [Crie um pacote conda para um aplicativo ou plug-in](conda-package.md)
+ [Crie uma receita de conda build para Blender](create-conda-recipe-blender.md)
+ [Crie uma receita de conda build para Autodesk Maya](create-conda-recipe-maya.md)
+ [Crie uma receita de compilação de conda para o plugin Autodesk Maya to Arnold (MtoA)](create-conda-recipe-mtoa-plugin.md)
+ [Automatize a criação de pacotes com o Deadline Cloud](automate-package-builds.md)
# Crie e teste pacotes localmente
Antes de publicar pacotes no Amazon S3 ou configurar a CI/CD automação em seu farm Deadline Cloud, você pode criar e testar pacotes conda em sua estação de trabalho usando um canal de sistema de arquivos local. Essa abordagem permite que você itere rapidamente as receitas localmente e verifique os pacotes.
O `rattler-build publish` comando cria uma receita, copia o pacote resultante em um canal e indexa o canal em uma única etapa. Quando você direciona um diretório do sistema de arquivos local, `rattler-build` cria e inicializa o canal automaticamente se o diretório não existir.
As instruções a seguir usam a receita de amostra Blender 4.5 do repositório de [amostras do Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples) emGitHub. Você pode substituir uma receita diferente do repositório de amostras ou usar sua própria receita.
## Pré-requisitos
Antes de começar, instale as seguintes ferramentas em sua estação de trabalho:
+ **pixi** — Um gerenciador de pacotes que você usa para instalar `rattler-build` e testar pacotes. Instale o pixi a partir do [pixi.sh](https://pixi.sh).
+ **rattler-build** — A ferramenta de criação de pacotes usada pelas receitas do Deadline Cloud conda. Depois de instalar o pixi, execute o seguinte comando para instalar`rattler-build`.
```
pixi global install rattler-build
```
+ **git — Necessário** para clonar o repositório de amostras. WindowsAtivado, [o git for Windows](https://gitforwindows.org/) também fornece um `bash` shell, exigido por algumas das receitas de Windows amostra.
## Criando e publicando um pacote em um canal local
Neste procedimento, você clona o repositório de amostras do Deadline Cloud e o usa `rattler-build publish` para criar e publicar o pacote em um canal de sistema de arquivos local.
**Para criar e publicar um pacote em um canal local**
1. Clone o repositório de amostras do Deadline Cloud.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Mude para o diretório `conda_recipes`.
```
cd deadline-cloud-samples/conda_recipes
```
1. Execute o comando a seguir para criar a receita Blender 4.5 e publicar o pacote em um diretório de canal local.
Em Linux emacOS, execute o comando a seguir.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to file://$HOME/my-conda-channel
```
Em Windows (cmd), execute o comando a seguir.
```
rattler-build publish blender-4.5/recipe/recipe.yaml ^
--to file://%USERPROFILE%/my-conda-channel
```
O `rattler-build publish` comando executa as seguintes ações:
+ Cria o pacote a partir da receita.
+ Cria o diretório do canal se o diretório não existir.
+ Copia o arquivo do pacote para o canal.
+ Indexa o canal para que os gerenciadores de pacotes possam encontrar o pacote.
Se a receita do pacote depender de pacotes de um canal específico, como [conda-forge](https://conda-forge.org/), adicione `-c conda-forge` ao comando.
Para reconstruir o pacote depois de fazer alterações na receita, adicione `--build-number=+1` para incrementar automaticamente o número da compilação.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to file://$HOME/my-conda-channel \
--build-number=+1
```
Para obter mais informações sobre`rattler-build publish`, consulte a documentação de publicação do [rattler-build](https://rattler-build.prefix.dev/latest/publish/).
## Compilações de depuração
Se uma compilação falhar, `rattler-build` preserva o diretório de compilação para que você possa investigar. Execute o comando a seguir para abrir um shell interativo no ambiente de compilação com todas as variáveis de ambiente configuradas como estavam durante a compilação.
```
rattler-build debug shell
```
No shell de depuração, você pode modificar arquivos, executar comandos de compilação individuais e adicionar dependências para isolar o problema. Para obter mais informações, consulte [Depuração de compilações na documentação do rattler-build](https://rattler-build.prefix.dev/latest/debugging_builds/).
## Testando o pacote
Depois de criar e publicar o pacote, crie um projeto pixi temporário. Use o projeto para instalar o pacote a partir do canal local e verificar se ele funciona corretamente.
**Para testar o pacote**
1. Crie um diretório de teste temporário e inicialize um projeto pixi com o canal local.
LinuxAtivado emacOS, execute os seguintes comandos.
```
mkdir package-test-env
cd package-test-env
pixi init --channel file://$HOME/my-conda-channel
```
Em Windows (cmd), execute os seguintes comandos.
```
mkdir package-test-env
cd package-test-env
pixi init --channel file://%USERPROFILE%/my-conda-channel
```
1. Adicione o pacote ao projeto.
```
pixi add blender=4.5
```
1. Verifique se o pacote funciona corretamente.
```
pixi run blender --version
```
Quando estiver satisfeito com o pacote, você pode publicá-lo em um canal conda do Amazon S3 para que os funcionários do Deadline Cloud possam instalar o pacote. Consulte [Publicar pacotes em um canal conda do S3](publish-packages-s3-channel.md).
## Limpeza
Após o teste, você pode remover o projeto de teste e o canal local.
**Para limpar os recursos de teste**
1. Remova o diretório do projeto de teste.
Em Linux emacOS, execute o comando a seguir.
```
rm -rf package-test-env
```
Em Windows (cmd), execute o comando a seguir.
```
rmdir /s /q package-test-env
```
1. Remova o diretório local do canal conda.
Em Linux emacOS, execute o comando a seguir.
```
rm -rf $HOME/my-conda-channel
```
Em Windows (cmd), execute o comando a seguir.
```
rmdir /s /q %USERPROFILE%\my-conda-channel
```
1. (Opcional) Remova o diretório `rattler-build` de saída que contém o arquivo do pacote criado.
Em Linux emacOS, execute o comando a seguir.
```
rm -rf deadline-cloud-samples/conda_recipes/output
```
Em Windows (cmd), execute o comando a seguir.
```
rmdir /s /q deadline-cloud-samples\conda_recipes\output
```
# Publique pacotes em um canal conda do Amazon S3
Você pode publicar pacotes conda em um bucket do Amazon Simple Storage Service (Amazon S3) para que os funcionários do AWS Deadline Cloud (Deadline Cloud) possam instalá-los para executar trabalhos. O `rattler-build publish` comando funciona com o Amazon S3 da mesma forma que com um canal de sistema de arquivos local. O comando pode criar uma receita e publicar o resultado, ou publicar um arquivo de pacote que você já criou. Em ambos os casos, o comando carrega o pacote no bucket e indexa o canal em uma única etapa.
O `rattler-build publish` comando é autenticado AWS usando a cadeia de credenciais padrão, portanto, ele usa sua AWS configuração como qualquer AWS ferramenta. Para obter mais informações sobre a configuração de credenciais, consulte [Configuração e configurações do arquivo de credenciais no Guia](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) do Usuário *AWS Command Line Interface (AWS CLI)*.
## Pré-requisitos
Antes de publicar pacotes no Amazon S3, preencha os seguintes pré-requisitos:
+ **pixi e rattler-build** [— Instale o pixi do pixi.sh e, em seguida, instale.](https://pixi.sh) `rattler-build`
```
pixi global install rattler-build
```
+ **git — Necessário** para clonar o repositório de amostras. WindowsAtivado, [o git for Windows](https://gitforwindows.org/) também fornece um `bash` shell, exigido por algumas das receitas de Windows amostra.
+ Bucket **Amazon S3 — Um bucket** Amazon S3 para usar como canal conda. Você pode usar o repositório de anexos de tarefas do seu farm do Deadline Cloud ou criar um intervalo separado.
+ **AWS credenciais** — Configure as credenciais em sua estação de trabalho usando o `aws configure` comando ou o comando. `aws login` Para obter mais informações, consulte [Configuração do AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-quickstart.html) no *Guia do usuário do AWS Command Line Interface *.
+ **Permissões do IAM** — (opcional) Para reduzir o escopo das permissões que suas credenciais têm, você pode usar uma política AWS Identity and Access Management (IAM) que concede somente as seguintes permissões no bucket do Amazon S3 e no prefixo do canal que você usa (por exemplo,): `/Conda/*`
+ `s3:GetObject`
+ `s3:PutObject`
+ `s3:DeleteObject`
+ `s3:ListBucket`
+ `s3:GetBucketLocation`
## Publicar um pacote em um canal do Amazon S3
Use `rattler-build publish` com um `s3://` destino para publicar um pacote em seu canal conda do Amazon S3. Se o canal não existir no bucket, `rattler-build` inicializará o canal automaticamente. Antes de começar, verifique se você concluiu os [pré-requisitos](#publish-s3-prereqs).
O exemplo a seguir publica a receita de amostra Blender 4.5 do repositório de [amostras do Deadline Cloud em](https://github.com/aws-deadline/deadline-cloud-samples). GitHub Você pode substituir uma receita diferente do repositório de amostras ou usar sua própria receita.
**Para publicar um pacote em um canal do Amazon S3**
1. Clone o repositório de amostras do Deadline Cloud.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Mude para o diretório `conda_recipes`.
```
cd deadline-cloud-samples/conda_recipes
```
1. Execute o comando a seguir. Substitua *amzn-s3-demo-bucket* pelo nome do seu bucket.
Em Linux emacOS, execute o comando a seguir.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to s3://amzn-s3-demo-bucket/Conda/Default
```
Em Windows (cmd), execute o comando a seguir.
```
rattler-build publish blender-4.5/recipe/recipe.yaml ^
--to s3://amzn-s3-demo-bucket/Conda/Default
```
O `/Conda/Default` prefixo organiza o canal dentro do bucket. Você pode usar um prefixo diferente, mas o prefixo deve ser consistente em todos os comandos e configurações de fila que fazem referência ao canal.
Para recriar e publicar um pacote atualizado, adicione `--build-number=+1` para incrementar automaticamente o número da compilação.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to s3://amzn-s3-demo-bucket/Conda/Default \
--build-number=+1
```
Se a receita do pacote depender de pacotes de um canal específico, como [conda-forge](https://conda-forge.org/), adicione `-c conda-forge` ao comando.
Você também pode publicar um arquivo de pacote que você já criou, por exemplo, um `.conda` arquivo de uma compilação local. Substitua *amzn-s3-demo-bucket* pelo nome do seu bucket.
```
rattler-build publish output/linux-64/blender-4.5.0-hb0f4dca_0.conda \
--to s3://amzn-s3-demo-bucket/Conda/Default
```
## Testando o pacote
Depois de publicar o pacote, crie um projeto pixi temporário para verificar se o pacote funciona corretamente. O projeto instala o pacote a partir do canal Amazon S3.
**Para testar o pacote**
1. Crie um diretório de teste temporário e inicialize um projeto pixi com o canal Amazon S3. Substitua *amzn-s3-demo-bucket* pelo nome do seu bucket.
```
mkdir package-test-env
cd package-test-env
pixi init --channel s3://amzn-s3-demo-bucket/Conda/Default
```
1. Adicione o pacote ao projeto.
```
pixi add blender=4.5
```
1. Verifique se o pacote funciona corretamente.
```
pixi run blender --version
```
## Limpeza
Após o teste, remova o diretório do projeto de teste.
**Para limpar os recursos de teste**
+ Remova o diretório do projeto de teste.
Em Linux emacOS, execute o comando a seguir.
```
rm -rf package-test-env
```
Em Windows (cmd), execute o comando a seguir.
```
rmdir /s /q package-test-env
```
## Compilações de depuração
Se uma compilação falhar, `rattler-build` preserva o diretório de compilação para que você possa investigar. Execute o comando a seguir para abrir um shell interativo no ambiente de compilação com todas as variáveis de ambiente configuradas como estavam durante a compilação.
```
rattler-build debug shell
```
No shell de depuração, você pode modificar arquivos, executar comandos de compilação individuais e adicionar dependências para isolar o problema. Para obter mais informações, consulte [Depuração de compilações na documentação do rattler-build](https://rattler-build.prefix.dev/latest/debugging_builds/).
## Construindo pacotes para outras plataformas
O `rattler-build publish` comando cria pacotes para o sistema operacional da estação de trabalho em que o comando é executado. Se sua frota do Deadline Cloud usa um sistema operacional diferente da sua estação de trabalho ou se seu pacote tem outros requisitos de hospedagem, você tem as seguintes opções:
+ Execute `rattler-build publish` em um host que corresponda ao sistema operacional de destino. Por exemplo, use uma instância do Amazon Elastic Compute Cloud (Amazon EC2) em Linux execução para criar pacotes para uma frota. Linux
+ Use uma fila de criação de pacotes do Deadline Cloud para automatizar compilações na plataforma de destino. Consulte [Criar uma fila de criação de pacotes](automate-package-builds.md#s3-channel-create-queue).
+ (Avançado) Use a compilação cruzada para criar pacotes para uma plataforma diferente da sua estação de trabalho. Para obter mais informações, consulte [Compilação cruzada](https://rattler-build.prefix.dev/latest/compilers/#cross-compilation) na documentação do rattler-build.
## Próximas etapas
Depois de publicar pacotes em seu canal conda do Amazon S3, configure suas filas do Deadline Cloud para usar o canal:
+ [Configure permissões de fila de produção para pacotes conda personalizados — Conceda](configure-jobs-s3-channel.md#s3-channel-configure-permissions) às suas filas de produção acesso somente de leitura ao canal conda do Amazon S3.
+ [Adicionar um canal conda a um ambiente de fila — Configure o ambiente](configure-jobs-s3-channel.md#s3-channel-add-channel) de fila para instalar pacotes do canal conda do Amazon S3.
## Configurar permissões de fila de produção para pacotes conda personalizados
Sua fila de produção precisa de permissões somente de leitura para o `/Conda` prefixo no bucket S3 da fila. Abra a página AWS Identity and Access Management (IAM) da função associada à fila de produção e modifique a política com o seguinte:
1. Abra o console do Deadline Cloud e navegue até a página de detalhes da fila de criação de pacotes.
1. Escolha a função de serviço de fila e, em seguida, escolha **Editar fila**.
1. Role até a seção **Função de serviço de fila** e escolha **Visualizar essa função no console do IAM**.
1. Na lista de políticas de permissão, escolha a **AmazonDeadlineCloudQueuePolicy**para sua fila.
1. Na guia **Permissões**, escolha **Editar**.
1. Adicione uma nova seção à função de serviço de fila, como a seguir. *111122223333*Substitua *amzn-s3-demo-bucket* e por seu próprio bucket e conta.
```
{
"Effect": "Allow",
"Sid": "CustomCondaChannelReadOnly",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/Conda/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "111122223333"
}
}
},
```
## Adicionar um canal conda a um ambiente de fila
Para usar o canal conda do S3, você precisa adicionar a localização do `s3://amzn-s3-demo-bucket/Conda/Default` canal ao `CondaChannels` parâmetro dos trabalhos que você envia para o Deadline Cloud. Os remetentes fornecidos com o Deadline Cloud fornecem campos para especificar canais e pacotes personalizados de conda.
Você pode evitar a modificação de cada trabalho editando o ambiente da fila conda para sua fila de produção. Use o procedimento a seguir:
1. Abra o console do Deadline Cloud e navegue até a página de detalhes da fila de produção.
1. Escolha a guia de ambientes.
1. **Selecione o ambiente **da fila Conda** e, em seguida, escolha Editar.**
1. Escolha o **editor JSON** e, em seguida, no script, encontre a definição do parâmetro para`CondaChannels`.
1. Edite a linha `default: "deadline-cloud"` para que ela comece com o canal conda S3 recém-criado:
```
default: "s3://amzn-s3-demo-bucket/Conda/Default deadline-cloud"
```
Por padrão, frotas gerenciadas por serviços permitem prioridade de canal flexível para conda. Para um trabalho solicitando `blender=4.2` se o Blender 4.2 está no novo canal e no `deadline-cloud` canal, o pacote será retirado do canal que estiver primeiro na lista de canais. Se uma versão de pacote especificada não for encontrada no primeiro canal, os canais subsequentes serão verificados em ordem para a versão do pacote.
Para frotas gerenciadas pelo cliente, você pode habilitar o uso de pacotes conda usando uma das amostras do [ambiente conda queue no repositório de amostras](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/README.md) do Deadline Cloud. GitHub
# Crie um pacote conda para um aplicativo ou plug-in
Um pacote conda é um arquivo compactado de software escrito em qualquer idioma. O Conda oferece suporte a uma variedade de combinações de sistemas operacionais e arquiteturas, para que você possa empacotar aplicativos completosBlender, comoMaya, e Nuke junto com bibliotecas para Python e outras linguagens. Para obter mais informações sobre pacotes conda, consulte [Pacotes](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/packages.html) na documentação do conda.
Para usar um pacote conda, você o instala em um ambiente virtual. Um ambiente virtual conda tem um *diretório de prefixo* onde os pacotes são instalados. A instalação de um pacote usa vinculação direta ou revinculação de arquivos quando há suporte, portanto, a criação de vários ambientes com os mesmos pacotes não usa espaço adicional em disco significativo. Para usar um ambiente virtual, você o ativa para definir variáveis de ambiente. A ativação executa scripts fornecidos pelos pacotes, dando a cada pacote a oportunidade de modificar o PATH ou outras variáveis de ambiente. Os pacotes Conda normalmente contêm aplicativos ou bibliotecas, mas a ativação flexível significa que eles também podem apontar para aplicativos instalados em um sistema de arquivos compartilhado.
A criação de um pacote personalizado envolve três etapas: uma *receita* contém as instruções de construção, um *pacote* é o artefato (`.conda`ou `.tar.bz2` arquivo) construído e um *canal* hospeda pacotes para instalação. O `rattler-build publish` comando executa todas as três etapas: ele pode criar uma receita em um pacote e publicá-la em um canal, ou pode usar um artefato de pacote diretamente para publicá-la.
A comunidade [conda-forge](https://conda-forge.org/) mantém receitas de pacotes para um amplo conjunto de software de código aberto e hospeda artefatos de pacotes no canal. `conda-forge` Você pode configurar sua fila para incluir `conda-forge` como fonte de pacote e, em seguida, criar pacotes personalizados que dependam dos pacotes conda-forge para serem executados. PoisLinux, o conda-forge hospeda uma cadeia de ferramentas de compilação completa, incluindo suporte a CUDA, com opções consistentes de compilação e vinculação selecionadas. Você pode usar pacotes conda-forge como dependências em suas próprias receitas ou instalá-los junto com seus pacotes personalizados no mesmo ambiente.
Você pode combinar um aplicativo inteiro, incluindo dependências, em um pacote conda. Os pacotes que o Deadline Cloud fornece no [canal de nuvem de prazos](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html#conda-queue-environment) para frotas gerenciadas por serviços usam essa abordagem de reempacotamento binário. Isso organiza os mesmos arquivos de uma instalação para se adequar ao ambiente virtual conda.
**nota**
Aplicativos grandes podem exigir dezenas de GB de espaço livre em disco para o arquivamento de origem, arquivos extraídos e saída de compilação. Certifique-se de usar um disco com espaço disponível suficiente para a saída da compilação do pacote.
## Package um aplicativo
Ao reempacotar um aplicativo para conda, há dois objetivos:
+ A maioria dos arquivos do aplicativo deve ser separada da estrutura primária do ambiente virtual conda. Os ambientes podem então misturar o aplicativo com pacotes de outras fontes, como [conda-forge](https://conda-forge.org/).
+ Quando um ambiente virtual conda é ativado, o aplicativo deve estar disponível na variável de ambiente PATH.
**Para reempacotar um aplicativo para conda**
1. Escreva receitas de compilação do conda que instalem o aplicativo em um subdiretório como. `$CONDA_PREFIX/opt/` Isso o separa dos diretórios de prefixo padrão, como e. `bin` `lib`
1. Adicione links simbólicos ou scripts de inicialização `$CONDA_PREFIX/bin` para executar os binários do aplicativo.
Como alternativa, crie scripts activate.d que o `conda activate` comando executará para adicionar os diretórios binários do aplicativo ao PATH. AtivadoWindows, onde os links simbólicos não são suportados em todos os lugares em que os ambientes podem ser criados, use scripts de inicialização do aplicativo ou ativados.d.
1. Alguns aplicativos dependem de bibliotecas não instaladas por padrão nas frotas gerenciadas pelo serviço Deadline Cloud. Por exemplo, o sistema de janelas X11 geralmente é desnecessário para trabalhos não interativos, mas alguns aplicativos ainda exigem que ele seja executado sem uma interface gráfica. Você deve fornecer essas dependências dentro do pacote que você cria.
1. Se o aplicativo oferecer suporte a plug-ins, forneça uma convenção clara que os pacotes de plug-ins devem seguir para se integrarem ao aplicativo em um ambiente virtual. Por exemplo, a [receita de amostra de Maya 2026](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-2026#instructions-for-maya-plugin-packages) documenta essa convenção para Maya plug-ins.
1. Certifique-se de seguir os contratos de direitos autorais e de licença dos aplicativos que você empacota. Recomendamos usar um bucket Amazon S3 privado para seu canal conda para controlar a distribuição e limitar o acesso de pacotes à sua fazenda.
As receitas de amostra dos pacotes no `deadline-cloud` canal estão disponíveis no repositório de [amostras do Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes#readme) emGitHub.
## Package um plugin
Os plug-ins de aplicativos podem ser empacotados como seus próprios pacotes conda. Ao criar um pacote de plug-ins, siga estas diretrizes:
+ Inclua o pacote do aplicativo host como dependência de compilação e execução na receita `recipe.yaml` de compilação. Use uma restrição de versão para que a receita de compilação seja instalada somente com pacotes compatíveis.
+ Siga as convenções do pacote do aplicativo host para registrar o plug-in.
## Pacotes de adaptadores
Algumas integrações de aplicativos do Deadline Cloud usam um *adaptador* que estende a interface do aplicativo para simplificar a [criação de modelos de trabalho](building-jobs.md). Um adaptador é uma interface de linha de comando com suporte para executar um daemon em segundo plano, relatar status e aplicar mapeamento de caminhos. Para obter mais informações, consulte o [Open Job Description Adaptor Runtime](https://github.com/OpenJobDescription/openjd-adaptor-runtime-for-python#readme) emGitHub. Por exemplo, o [deadline-cloud-for-maya](https://github.com/aws-deadline/deadline-cloud-for-maya/)on GitHub inclui uma interface gráfica de envio de tarefas integrada e um Maya adaptador que está disponível como `maya-openjd` pacote em frotas gerenciadas por serviços.
Os envios de trabalhos do remetente do Deadline Cloud GUIs incluem um valor de `CondaPackages` parâmetro que especifica os pacotes conda a serem incluídos em um ambiente virtual para execução do trabalho. O valor do `CondaPackages` parâmetro para Maya normalmente se parece `maya=2025.* maya-openjd=0.15.* maya-mtoa` e pode conter entradas alternativas para pacotes de plug-ins. Quando o ambiente de fila configura um ambiente virtual conda para executar o trabalho, ele resolve esses nomes de pacotes e restrições de versão para serem compatíveis e adiciona todos os pacotes de dependência que eles precisam executar. Cada pacote de adaptador e plug-in especifica com o que é compatível, incluindo quais versõesMaya, quais versões do Python e outras dependências.
[Para criar seus próprios pacotes de adaptadores usando nossos exemplos, como a [receita maya-openjd](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-openjd) emGitHub, você pode criar os pacotes para Python e outras dependências fornecidas pelo conda-forge.](https://conda-forge.org/) Talvez seja necessário criar primeiro o [prazo](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/deadline) e [openjd-adaptor-runtime](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/openjd-adaptor-runtime)as receitas para satisfazer as dependências.
# Crie uma receita de conda build para Blender
Você pode usar aplicativos diferentes para criar uma receita de construção de conda. Blenderé de uso gratuito e simples de empacotar com o conda. A Blender Fundação fornece [arquivos de aplicativos](https://download.blender.org/release/Blender4.2/) para vários sistemas operacionais. Criamos um exemplo de receita do conda build que usa os arquivos .zip do Windows e os arquivos .tar.xz do Linux. Nesta seção, aprenda a usar a [receita Blender 4.2 conda build](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2).
O arquivo [deadline-cloud.yaml](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2) especifica as plataformas conda e outros metadados para o envio de pacotes de trabalhos para o Deadline Cloud. Essa receita inclui informações de arquivo de origem local para demonstrar como isso funciona. A plataforma linux-64 conda está configurada para criar um envio de trabalho padrão para corresponder à configuração mais comum. O deadline-cloud.yaml é semelhante ao seguinte:
```
condaPlatforms:
- platform: linux-64
defaultSubmit: true
sourceArchiveFilename: blender-4.2.1-linux-x64.tar.xz
sourceDownloadInstructions: 'Run "curl -LO https://download.blender.org/release/Blender4.2/blender-4.2.1-linux-x64.tar.xz"'
- platform: win-64
defaultSubmit: false
sourceArchiveFilename: blender-4.2.1-windows-x64.zip
sourceDownloadInstructions: 'Run "curl -LO https://download.blender.org/release/Blender4.2/blender-4.2.1-windows-x64.zip"'
```
Revise os arquivos no `recipe` diretório. Os metadados da receita estão em [recipe/recipe.yaml](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2/recipe/recipe.yaml). Você também pode ler a documentação do conda build [meta.yaml](https://docs.conda.io/projects/conda-build/en/latest/resources/define-metadata.html) para saber mais, por exemplo, como o arquivo é um modelo para gerar YAML. O modelo é usado para especificar o número da versão apenas uma vez e fornecer valores diferentes com base no sistema operacional.
Você pode revisar as opções de criação selecionadas em `meta.yaml` para desativar várias verificações de realocação binária e vinculação dinâmica de objetos compartilhados (DSO). Essas opções controlam como o pacote funciona quando instalado em um ambiente virtual conda em qualquer prefixo de diretório. Os valores padrão simplificam o empacotamento de cada biblioteca de dependências em um pacote separado, mas ao reempacotar binariamente um aplicativo, você precisa alterá-los.
Se o aplicativo que você está empacotando exigir bibliotecas de dependências adicionais ou se você estiver empacotando plug-ins para um aplicativo separadamente, você poderá encontrar erros de DSO. Esses erros ocorrem quando a dependência não está no caminho de pesquisa da biblioteca para o executável ou a biblioteca que precisa dela. Os aplicativos dependem de bibliotecas estarem em caminhos definidos globalmente, como `/lib` ou`/usr/lib`, quando instaladas em um sistema. No entanto, como os ambientes virtuais conda podem ser colocados em qualquer lugar, não há um caminho absoluto a ser usado. O Conda usa recursos relativos do RPATH, que são macOS compatíveis Linux e compatíveis, para lidar com isso. Consulte a documentação do conda build em [Tornando pacotes realocáveis para obter](https://docs.conda.io/projects/conda-build/en/latest/resources/make-relocatable.html) mais informações.
Blendernão requer nenhum ajuste de RPATH, pois os arquivos do aplicativo foram criados com isso em mente. Para aplicativos que exigem isso, você pode usar as mesmas ferramentas que o conda build usa: `patchelf` no Linux e em `install_name_tool` diantemacOS.
Durante a compilação do pacote, o script [build.sh](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2/recipe/build.sh) ou [build\$1win.sh](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2/recipe/build_win.sh) (chamado por`bld.bat`) é executado para instalar arquivos em um ambiente preparado com as dependências do pacote. Esses scripts copiam os arquivos de instalação, criam links simbólicos e configuram os scripts de ativação. `$PREFIX/bin` AtivadoWindows, ele não cria links simbólicos, mas adiciona o diretório do Blender ao PATH no script de ativação.
Usamos `bash` em vez de um `cmd.exe` arquivo.bat como Windows parte da receita de compilação do conda, pois isso fornece mais consistência nos scripts de construção. Consulte a recomendação do [guia do desenvolvedor do Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/what-is-a-deadline-cloud-workload.html#workload-portability) sobre portabilidade da carga de trabalho para obter dicas sobre como usar o`bash`. Windows Se você instalou o [git Windows para](https://gitforwindows.org/) clonar o repositório [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/)git, você já tem acesso a. `bash`
A documentação das [variáveis de ambiente do conda build](https://docs.conda.io/projects/conda-build/en/latest/user-guide/environment-variables.html) lista os valores disponíveis para uso no script de construção. Esses valores incluem `$SRC_DIR` os dados do arquivo de origem, `$PREFIX` o diretório de instalação, o acesso `$RECIPE_DIR` a outros arquivos da receita, o nome `$PKG_NAME` e `$PKG_VERSION` a versão do pacote e `$target_platform` a plataforma conda de destino.
## Envie o trabalho do pacote Blender 4.2
Você pode criar seu próprio pacote Blender 4.2 conda para renderizar trabalhos, baixando o Blender arquivo e enviando um trabalho para a fila de criação de pacotes. A fila envia o trabalho para a frota associada para criar o pacote e reindexar o canal conda.
[Essas instruções usam o git de um shell compatível com bash para obter um trabalho de construção de pacotes do OpenJD e algumas receitas de conda do repositório de amostras do Deadline Cloud. GitHub](https://github.com/aws-deadline/deadline-cloud-samples) Você precisará dos seguintes itens:
+ Se você estiver usandoWindows, uma versão do bash, git BASH, é instalada quando você instala o git.
+ Você deve ter a [CLI do Deadline Cloud](https://github.com/aws-deadline/deadline-cloud) instalada.
+ Você deve estar logado no [monitor do Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/working-with-deadline-monitor.html).
1. Abra a GUI de configuração do Deadline Cloud usando o comando a seguir e defina a fazenda e a fila padrão para sua fila de criação de pacotes.
```
deadline config gui
```
1. Use o comando a seguir para clonar o GitHUb repositório de amostras do Deadline Cloud.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Mude para o `conda_recipes` diretório no `deadline-cloud-samples` diretório.
```
cd deadline-cloud-samples/conda_recipes
```
1. Execute o script chamado`submit-package-job`. O script fornece instruções para fazer o download Blender na primeira vez em que você executa o script.
```
./submit-package-job blender-4.2/
```
1. Siga as instruções para fazer o downloadBlender. Quando você tiver o arquivamento, execute o `submit-package-job` script novamente.
```
./submit-package-job blender-4.2/
```
Depois de enviar o trabalho, use o monitor do Deadline Cloud para ver o progresso e o status do trabalho à medida que ele é executado.
O canto inferior esquerdo do monitor mostra as duas etapas do trabalho, criando o pacote e depois reindexando. O canto inferior direito mostra as etapas individuais de cada tarefa. Neste exemplo, há uma etapa para cada tarefa.
![\[O monitor Deadline Cloud mostra o progresso e o status de um trabalho de criação do Blender pacote.\]](http://docs.aws.amazon.com/pt_br/deadline-cloud/latest/developerguide/images/Conda-Figure3.png)
No canto inferior esquerdo do monitor estão as duas etapas do trabalho: criar o pacote e, em seguida, reindexar o canal conda. No canto inferior direito estão as tarefas individuais de cada etapa. Neste exemplo, há somente uma tarefa para cada etapa.
Quando você clica com o botão direito do mouse na tarefa da etapa de criação do pacote e escolhe **Exibir registros**, o monitor mostra uma lista de ações da sessão que mostram como a tarefa é agendada para o trabalhador. As ações são:
+ **Sincronizar anexos** — Essa ação copia os anexos da tarefa de entrada ou monta um sistema de arquivos virtual, dependendo da configuração usada para o sistema de arquivos de anexos da tarefa.
+ **Iniciar Conda** — Essa ação é do ambiente de fila adicionado por padrão quando você criou a fila. O trabalho não especifica nenhum pacote conda, então ele termina rapidamente e não cria um ambiente virtual conda.
+ **Launch CondaBuild Env** — Essa ação cria um ambiente virtual conda personalizado que inclui o software necessário para criar um pacote conda e reindexar um canal. Ele é instalado a partir do canal [conda-forge](https://conda-forge.org/).
+ **Execução da tarefa** — Essa ação cria o Blender pacote e carrega os resultados para o Amazon S3.
À medida que as ações são executadas, elas enviam registros em um formato estruturado para a Amazon CloudWatch. Quando um trabalho for concluído, selecione **Exibir registros de todas as tarefas** para ver registros adicionais sobre a configuração e desmontagem do ambiente em que o trabalho é executado.
# Teste seu pacote com um trabalho de renderização Blender 4.2
Depois de criar o pacote Blender 4.2 e configurar sua fila de produção para usar o canal conda do S3, você pode enviar trabalhos para renderizar com o pacote. Se você não tiver uma Blender cena, baixe a cena Blender 3.5 - Cozy Kitchen na página de [arquivos de Blender demonstração](https://www.blender.org/download/demo-files).
O GitHub repositório de amostras do Deadline Cloud que você baixou anteriormente contém um trabalho de amostra para renderizar uma Blender cena usando os seguintes comandos:
```
deadline bundle submit blender_render \
-p CondaPackages=blender=4.2 \
-p BlenderSceneFile=/path/to/downloaded/blender-3.5-splash.blend \
-p Frames=1
```
Você pode usar o monitor Deadline Cloud para acompanhar o progresso do seu trabalho:
1. No monitor, selecione a tarefa para o trabalho que você enviou e, em seguida, selecione a opção para visualizar o registro.
1. No lado direito da visualização do log, selecione a ação **Launch Conda** session.
Você pode ver que a ação procurou o Blender 4.2 nos dois canais conda configurados para o ambiente de fila e que encontrou o pacote no canal S3.
# Crie uma receita de conda build para Autodesk Maya
Você pode empacotar aplicativos comerciais como pacotes conda. Em [Create a conda build recipe for Blender](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/conda-package.html#create-conda-recipe-blender), você aprendeu como empacotar um aplicativo que está disponível como um simples arquivo de arquivamento realocável e sob termos de licença de código aberto. Os aplicativos comerciais geralmente são distribuídos por meio de instaladores e podem ter um sistema de gerenciamento de licenças com o qual trabalhar.
A lista a seguir se baseia nos conceitos básicos abordados em [Criar um pacote conda para um aplicativo ou plug-in](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/conda-package.html) com requisitos comumente envolvidos no empacotamento de aplicativos comerciais. Os detalhes nos submarcadores ilustram como você pode aplicar as diretrizes a. Maya
+ Entenda os direitos de licenciamento e as restrições do aplicativo. Talvez seja necessário configurar um sistema de gerenciamento de licenças. Quando o aplicativo não incluir fiscalização, você precisará configurar sua fazenda de acordo com seus direitos.
+ Leia as [perguntas frequentes sobre os benefícios da Autodesk assinatura sobre os direitos](https://www.autodesk.com/support/technical/article/caas/sfdcarticles/sfdcarticles/Subscription-Benefits-FAQ-Cloud-Rights.html) da nuvem para entender os direitos da nuvem Maya que podem se aplicar a você. Configure sua fazenda Deadline Cloud conforme necessário.
+ Autodeskos produtos dependem de um arquivo chamado`ProductInformation.pit`. A maioria das configurações desse arquivo requer acesso de administrador ao sistema, o que não está disponível em frotas gerenciadas por serviços. Os recursos do produto para thin clients fornecem uma maneira realocável de lidar com isso. Consulte [Licenciamento Thin Client para Maya e MotionBuilder](https://www.autodesk.com/support/technical/article/caas/tsarticles/ts/2zqRBCuGDrcPZDzULJQ27p.html) saiba mais.
+ Alguns aplicativos dependem de bibliotecas não instaladas em hosts de trabalhadores de frota gerenciados por serviços, portanto, o pacote precisará fornecê-las. Isso pode estar diretamente no pacote do aplicativo ou colocado em um pacote de dependência separado.
+ Mayadepende de várias dessas bibliotecas, incluindo freetype e fontconfig. Quando essas bibliotecas estão disponíveis no gerenciador de pacotes do sistema, como em `dnf` for AL2023, você pode usá-las como fonte para o aplicativo. Como esses pacotes RPM não foram criados para serem realocáveis, você precisará usar ferramentas para garantir que as `patchelf` dependências sejam resolvidas dentro do prefixo de instalação. Maya
+ A instalação pode exigir acesso de administrador. Como as frotas gerenciadas por serviços não fornecem acesso de administrador, você precisará realizar uma instalação em um sistema com esse acesso. Em seguida, crie um arquivo dos arquivos necessários para o trabalho de compilação do pacote ser usado.
+ O Windows instalador do Maya requer acesso de administrador, portanto, criar o pacote conda envolve um processo manual para criar primeiro esse arquivo.
+ A configuração do aplicativo, incluindo como os plug-ins se registram nele, pode ser definida no nível do sistema operacional ou do usuário. Quando colocados em um ambiente virtual conda, os plug-ins precisam de uma forma de se integrar ao aplicativo de uma forma que esteja contida e nunca grave arquivos ou outros dados fora do prefixo do ambiente virtual. Sugerimos que você configure isso a partir do pacote conda do aplicativo.
+ O Maya pacote de amostra define a variável de ambiente `MAYA_NO_HOME=1` para isolá-la da configuração em nível de usuário e adiciona caminhos de pesquisa de módulos para `MAYA_MODULE_PATH` que os plug-ins empacotados separadamente possam ser integrados de dentro do ambiente virtual. O MtoA pacote de amostra coloca um arquivo.mod em um desses diretórios para carregar na Maya inicialização.
**Escreva os metadados da receita**
1. Abra o diretório GitHub [ deadline-cloud-samples/conda\$1recipes/maya-2025](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-2025) em seu navegador ou em um editor de texto em seu clone local do repositório.
O arquivo `deadline-cloud.yaml` descreve as plataformas de compilação conda para criar pacotes e de onde obter o aplicativo. A amostra da receita especifica ambas Linux e Windows compilações, e isso só Linux é enviado por padrão.
1. Baixe os Maya instaladores completos a partir do seu Autodesk login. PoisLinux, a compilação do pacote pode usar o arquivo diretamente, então coloque-o diretamente no `conda_recipes/archive_files` diretório. PoisWindows, o instalador requer acesso de administrador para ser executado. Você precisará executar o instalador e coletar os arquivos necessários em um arquivo para a receita do pacote que deseja usar. O arquivo [README.md](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/README.md) na receita documenta um procedimento repetível para criar esse artefato. O procedimento usa uma instância recém-lançada do Amazon EC2 para fornecer um ambiente limpo para instalação que você pode encerrar depois de salvar o resultado. Para empacotar outros aplicativos que exigem acesso de administrador, você pode seguir um procedimento semelhante depois de determinar o conjunto de arquivos de que o aplicativo precisa.
1. Abra os arquivos [recipe/recipe.yaml e [recipe/meta.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/recipe/meta.yaml)](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/recipe/recipe.yaml) para revisar ou editar as configurações do rattler-build e do conda-build. Você pode definir o nome e a versão do pacote para o aplicativo que você está empacotando.
A seção de **origem** inclui uma referência aos arquivos, incluindo o hash sha256 dos arquivos. Sempre que você alterar esses arquivos, por exemplo, para uma nova versão, precisará calcular e atualizar esses valores.
A seção de **construção** contém principalmente opções para desativar as opções de realocação binária padrão, pois os mecanismos automáticos não funcionarão corretamente para a biblioteca e os diretórios binários específicos que o pacote usa.
Finalmente, a seção **sobre** permite inserir alguns metadados sobre o aplicativo que podem ser usados ao navegar ou processar o conteúdo de um canal conda.
**Escreva o script de construção do pacote**
1. Os scripts de construção de pacotes no Maya exemplo de receita de compilação do conda incluem comentários explicando as etapas que os scripts executam. Leia os comentários e os comandos para descobrir o seguinte:
+ Como a receita manipula o arquivo RPM de Autodesk
+ As alterações que a receita aplica para tornar a instalação realocável para os ambientes virtuais conda em que a receita está instalada
+ Como a receita define variáveis utilitárias, como `MAYA_LOCATION` e `MAYA_VERSION` que seu software pode usar para entender Maya se está sendo executado.
1. ParaLinux, abra o arquivo [recipe/build.sh](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/recipe/build.sh) para revisar ou editar o script de criação do pacote.
ParaWindows, abra o arquivo [recipe/build\$1win.sh](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/recipe/build_win.sh) para revisar ou editar o script de criação do pacote.
**Envie um trabalho que crie os pacotes Maya**
1. Insira o `conda_recipes` diretório no seu clone do GitHub [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples)repositório.
1. Certifique-se de que seu farm do Deadline Cloud esteja configurado para sua CLI do Deadline Cloud. Se você seguiu as etapas para [criar um canal conda usando o Amazon](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/configure-jobs-s3-channel.html) S3, sua fazenda deve estar configurada para sua CLI.
1. Execute o comando a seguir para enviar um trabalho que compila Linux e Windows empacota.
` ./submit-package-job maya-2025 --all-platforms`
# Crie uma receita de compilação de conda para o plugin Autodesk Maya to Arnold (MtoA)
Você pode empacotar plug-ins para aplicativos comerciais como pacotes conda. Os plug-ins são bibliotecas carregadas dinamicamente que usam uma interface binária de aplicativo (ABI) fornecida por um aplicativo para estender a funcionalidade desse aplicativo. O Maya to Arnold (MtoA) plug-in adiciona o Arnold renderizador como uma opção internaMaya.
+ O MtoA exemplo de receita de compilação depende do **Maya**pacote e usa uma `==` restrição para a versão.
+ O Maya pacote configura um caminho de Maya módulo no ambiente virtual,`$PREFIX/usr/autodesk/maya$MAYA_VERSION/modules`, para o plug-in colocar um `.mod` arquivo. O MtoA exemplo de receita de compilação cria um arquivo `mtoa.mod` nesse diretório.
**Escreva os metadados da receita**
1. Abra o diretório GitHub [ deadline-cloud-samples/conda\$1recipes/maya-mtoa-2025](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-mtoa-2025) em seu navegador ou em um editor de texto em seu clone local do repositório.
A receita segue os mesmos padrões da receita do Maya conda build e usa os mesmos arquivos de origem para instalar o plug-in.
1. Abra os arquivos [recipe/recipe.yaml e [recipe/meta.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-mtoa-2025/recipe/meta.yaml)](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-mtoa-2025/recipe/recipe.yaml) para revisar ou editar as configurações do rattler-build e do conda-build. Esses arquivos especificam uma dependência `maya` durante a compilação do pacote e ao criar um ambiente virtual para executar o plug-in.
**Escreva o script de construção do pacote**
+ Os scripts de construção de pacotes no MtoA exemplo de receita de compilação do conda incluem comentários explicando as etapas que os scripts executam. Leia os comentários e os comandos para saber como a receita instala MtoA e cria um arquivo `mtoa.mod` no diretório especificado pelo Maya pacote.
Arnolde Maya use a mesma tecnologia de licenciamento, então a receita do Maya conda build já inclui as informações necessárias para. Arnold
As diferenças entre os scripts de Windows construção Linux e de construção são semelhantes às diferenças da receita de construção do Maya conda.
**Envie um trabalho que crie os pacotes de Maya MtoA plug-ins**
1. Insira o `conda_recipes` diretório no seu clone do GitHub [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples)repositório.
1. Certifique-se de ter criado pacotes para o aplicativo Maya host da seção anterior.
1. Certifique-se de que seu farm do Deadline Cloud esteja configurado para sua CLI do Deadline Cloud. Se você seguiu as etapas para [criar um canal conda usando o Amazon](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/configure-jobs-s3-channel.html) S3, sua fazenda deve estar configurada para sua CLI.
1. Execute o comando a seguir para enviar um trabalho que compila Linux e Windows empacota.
` ./submit-package-job maya-mtoa-2025 --all-platforms`
# Teste seu pacote com um trabalho de Maya renderização
Depois de criar o Maya 2025 e MtoA os pacotes, você pode enviar trabalhos para renderizar com o pacote. O [toca-discos com](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/turntable_with_maya_arnold) amostra de pacote de Maya/Arnold tarefas renderiza uma animação com e. Maya Arnold Essa amostra também é usada FFmpeg para codificar um vídeo. Você pode adicionar o canal conda-forge à lista de padrões `CondaChannels` em seu ambiente de fila conda para fornecer uma fonte para o pacote. `ffmpeg`
No `job_bundles` diretório em seu clone git do [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples), execute o comando a seguir.
```
deadline bundle submit turntable_with_maya_arnold
```
Você pode usar o monitor Deadline Cloud para acompanhar o progresso do seu trabalho:
1. No monitor, selecione a tarefa para o trabalho que você enviou e, em seguida, selecione a opção para visualizar o registro.
1. No lado direito da visualização do log, selecione a ação **Launch Conda** session.
Você pode ver que a ação procurou maya e maya-mtoa nos canais conda configurados para o ambiente de fila e que encontrou os pacotes no canal S3.
# Automatize a criação de pacotes com o Deadline Cloud
Para CI/CD fluxos de trabalho ou quando você precisa criar pacotes para vários sistemas operacionais, você pode criar uma fila de criação de pacotes do Deadline Cloud. A fila agenda trabalhos de criação em sua frota, que criam os pacotes e os publicam em seu canal conda do Amazon Simple Storage Service (Amazon S3). Isso simplifica a manutenção de compilações contínuas de pacotes para versões de software em todas as configurações necessárias.
Você pode criar uma fila de criação de pacotes usando um modelo AWS CloudFormation (CloudFormation) ou manualmente no console do Deadline Cloud. O CloudFormation modelo implanta uma fazenda completa com uma fila de produção e uma fila de criação de pacotes já configuradas. Criar a fila a partir do console oferece mais controle sobre as configurações individuais.
## Crie uma fila de criação de pacotes com CloudFormation
Você pode usar um CloudFormation modelo para criar um farm do Deadline Cloud que inclui uma fila de criação de pacotes. O modelo configura uma fila de produção e uma fila de criação de pacotes com um canal conda privado do Amazon S3.
Antes de implantar o modelo, crie um bucket do Amazon S3 para armazenar os anexos do trabalho e seu canal conda. Você pode criar um bucket a partir do console do [Amazon S3](https://console.aws.amazon.com/s3/). Você precisa do nome do bucket ao implantar o modelo.
**Para implantar o CloudFormation modelo**
1. Baixe o modelo [deadline-cloud-starter-farm-template.yaml](https://github.com/aws-deadline/deadline-cloud-samples/raw/mainline/cloudformation/farm_templates/starter_farm/deadline-cloud-starter-farm-template.yaml) do repositório de amostras do [Deadline](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/starter_farm) Cloud em. GitHub
1. No [CloudFormation console](https://console.aws.amazon.com/cloudformation/), escolha **Criar pilha** e, em seguida, **Com novos recursos (padrão)**.
1. Selecione a opção de fazer upload de um arquivo de modelo e, em seguida, faça o upload do `deadline-cloud-starter-farm-template.yaml` arquivo.
1. Insira um nome para a pilha, como**StarterFarm**, e forneça o nome de um bucket do Amazon S3 para anexos de tarefas e o canal conda.
1. Siga as etapas do CloudFormation console para concluir a criação da pilha.
Para obter mais informações sobre os parâmetros do modelo e as opções de personalização, consulte o [README do starter farm](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/starter_farm) no repositório de amostras do Deadline Cloud em. GitHub
## Crie uma fila de criação de pacotes a partir do console
Siga as instruções em [Criar uma fila](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue.html) no *Guia do usuário do Deadline Cloud*. Faça as seguintes alterações em:
+ Na etapa 5, escolha um bucket Amazon S3 existente. Especifique um nome de pasta raiz, **DeadlineCloudPackageBuild** para que os artefatos de construção permaneçam separados dos anexos normais do Deadline Cloud.
+ Na etapa 6, você pode associar a fila de criação de pacotes a uma frota existente ou criar uma frota totalmente nova se sua frota atual não for adequada.
+ Na etapa 9, crie uma nova função de serviço para sua fila de criação de pacotes. Você modificará as permissões para dar à fila as permissões necessárias para carregar pacotes e reindexar um canal conda.
### Configurar as permissões da fila de criação de pacotes
Para permitir que a fila de criação de pacotes acesse o `/Conda` prefixo no bucket Amazon S3 da fila, você deve modificar a função da fila para conceder acesso. read/write A função precisa das seguintes permissões para que os trabalhos de criação de pacotes possam carregar novos pacotes e reindexar o canal.
+ `s3:GetObject`
+ `s3:PutObject`
+ `s3:ListBucket`
+ `s3:GetBucketLocation`
+ `s3:DeleteObject`
1. Abra o console do Deadline Cloud e navegue até a página de detalhes da fila de criação de pacotes.
1. Escolha a função de serviço de fila e, em seguida, escolha **Editar fila**.
1. Role até a seção **Função de serviço de fila** e escolha **Visualizar essa função no console do IAM**.
1. Na lista de políticas de permissão, escolha a **AmazonDeadlineCloudQueuePolicy**para sua fila.
1. Na guia **Permissões**, escolha **Editar**.
1. Adicione uma nova seção à função de serviço de fila, como a seguir. *111122223333*Substitua *amzn-s3-demo-bucket* e por seu próprio bucket e conta.
```
{
"Effect": "Allow",
"Sid": "CustomCondaChannelReadWrite",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject",
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/Conda/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "111122223333"
}
}
},
```
## Envie um trabalho de criação de pacotes
Depois de criar uma fila de criação de pacotes e configurar as permissões da fila, você pode enviar trabalhos para criar pacotes conda. O `submit-package-job` script no repositório de [amostras do Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes#readme) em GitHub envia um trabalho de construção para uma receita de conda.
Você precisará do seguinte:
+ A [CLI do Deadline Cloud](https://github.com/aws-deadline/deadline-cloud) instalada em sua estação de trabalho.
+ Uma sessão ativa de login do [AWS Deadline Cloud Monitor (Deadline Cloud monitor)](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/working-with-deadline-monitor.html).
+ Um clone do repositório de [amostras do Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples).
**Para enviar um trabalho de criação de pacotes**
1. Abra a GUI de configuração do Deadline Cloud e defina a fazenda e a fila padrão para sua fila de criação de pacotes.
```
deadline config gui
```
1. Mude para o `conda_recipes` diretório no repositório de amostras.
```
cd deadline-cloud-samples/conda_recipes
```
1. Execute o `submit-package-job` script com o diretório de receitas. O exemplo a seguir cria a receita Blender 4.5.
```
./submit-package-job blender-4.5/
```
Se a receita exigir um arquivo de origem que você ainda não baixou, o script fornecerá instruções de download. Baixe o arquivo e execute o script novamente.
Depois de enviar o trabalho, use o monitor do Deadline Cloud para ver o progresso e o status do trabalho.
![\[O monitor Deadline Cloud mostra o progresso e o status de um trabalho de criação de um pacote conda.\]](http://docs.aws.amazon.com/pt_br/deadline-cloud/latest/developerguide/images/Conda-Figure3.png)
O monitor mostra as duas etapas do trabalho: criar o pacote e depois reindexar o canal conda. Quando você clica com o botão direito do mouse na tarefa da etapa de criação do pacote e escolhe **Exibir registros**, o monitor mostra as ações da sessão:
+ **Sincronizar anexos** — copia os anexos da tarefa de entrada ou monta um sistema de arquivos virtual.
+ **Inicie o Conda** — A ação do ambiente de fila. O trabalho de construção não especifica pacotes conda, então essa ação termina rapidamente.
+ **Launch CondaBuild Env** — Cria um ambiente virtual conda com o software necessário para criar um pacote conda e reindexar um canal.
+ **Execução da tarefa** — Cria o pacote e carrega os resultados para o Amazon S3.
Conforme as ações são executadas, elas enviam registros para a Amazon CloudWatch (CloudWatch). Quando um trabalho for concluído, selecione **Exibir registros de todas as tarefas** para ver registros adicionais sobre a configuração e a desmontagem do ambiente.