Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Crea un canale conda usando S3
Se i tuoi lavori devono eseguire applicazioni non disponibili sui [https://conda-forge.org/](https://conda-forge.org/)canali [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, puoi ospitare un canale conda personalizzato per fornire i tuoi pacchetti. Quando crei una coda nella console AWS Deadline Cloud (Deadline Cloud), la console aggiunge un ambiente di coda conda per impostazione predefinita. Per rendere i pacchetti disponibili per i lavori, aggiungi il canale personalizzato all'ambiente di coda.
Un canale conda è un contenuto statico ospitato che puoi ospitare in [vari modi](https://rattler-build.prefix.dev/latest/publish/), ad esempio su un file system o in un bucket Amazon Simple Storage Service (Amazon S3). Se la tua farm Deadline Cloud utilizza un file system condiviso per le risorse, puoi utilizzare qualsiasi percorso su di esso come nome del canale. Puoi ospitare il canale in un bucket Amazon S3 per un accesso più ampio utilizzando le autorizzazioni AWS Identity and Access Management (IAM).
Puoi [creare e testare pacchetti localmente](build-test-packages-locally.md), quindi [pubblicarli su](publish-packages-s3-channel.md) un canale. La creazione di pacchetti localmente è un modo semplice per iniziare a iterare sulle ricette di compilazione dei pacchetti senza configurare l'infrastruttura. Puoi anche utilizzare una [coda di creazione di pacchetti](automate-package-builds.md) Deadline Cloud per creare pacchetti e pubblicarli su un canale. Una coda per la creazione di pacchetti semplifica la manutenzione dei pacchetti per più sistemi operativi e configurazioni di acceleratori. Puoi aggiornare le versioni e inviare set completi di build di pacchetti da qualsiasi luogo.
Puoi configurare i canali per il tuo studio e la tua Deadline Cloud farm in diversi modi. Puoi avere un canale Amazon S3 e configurare tutte le workstation e gli host della farm per utilizzarlo. Puoi anche avere più di un canale e configurare il mirroring con AWS DataSync (). DataSync Ad esempio, la coda di creazione dei pacchetti Deadline Cloud può essere pubblicata su un canale Amazon S3 di cui viene eseguito il mirroring in locale per workstation e host di farm locali.
**Topics**
+ [Compila e testa i pacchetti localmente](build-test-packages-locally.md)
+ [Pubblica pacchetti su un canale conda Amazon S3](publish-packages-s3-channel.md)
+ [Configura le autorizzazioni per la coda di produzione per pacchetti conda personalizzati](#s3-channel-configure-permissions)
+ [Aggiungi un canale conda a un ambiente di coda](#s3-channel-add-channel)
+ [Crea un pacchetto conda per un'applicazione o un plug-in](conda-package.md)
+ [Crea una ricetta di costruzione di conda per Blender](create-conda-recipe-blender.md)
+ [Crea una ricetta di compilazione di conda per Autodesk Maya](create-conda-recipe-maya.md)
+ [Crea una ricetta di compilazione conda per il plugin Autodesk Maya to Arnold (MtoA)](create-conda-recipe-mtoa-plugin.md)
+ [Automatizza la creazione di pacchetti con Deadline Cloud](automate-package-builds.md)
# Compila e testa i pacchetti localmente
Prima di pubblicare pacchetti su Amazon S3 o configurare CI/CD l'automazione nella tua farm Deadline Cloud, puoi creare e testare pacchetti conda sulla tua workstation utilizzando un canale di file system locale. Questo approccio consente di iterare rapidamente a livello locale sulle ricette e verificare i pacchetti.
Il `rattler-build publish` comando crea una ricetta, copia il pacchetto risultante su un canale e indicizza il canale in un unico passaggio. Quando si sceglie come destinazione una directory del filesystem locale, `rattler-build` crea e inizializza automaticamente il canale se la directory non esiste.
Le seguenti istruzioni utilizzano la ricetta di esempio Blender 4.5 contenuta nell'archivio degli esempi di [Deadline](https://github.com/aws-deadline/deadline-cloud-samples) Cloud. GitHub Puoi sostituire una ricetta diversa dall'archivio degli esempi o utilizzare la tua ricetta.
## Prerequisiti
Prima di iniziare, installa i seguenti strumenti sulla tua workstation:
+ **pixi** — Un gestore di pacchetti utilizzato per installare `rattler-build` e testare i pacchetti. [Installa pixi da pixi.sh.](https://pixi.sh)
+ **rattler-build** — Lo strumento per la creazione di pacchetti utilizzato dalle ricette conda di Deadline Cloud. Dopo aver installato pixi, esegui il seguente comando per l'installazione. `rattler-build`
```
pixi global install rattler-build
```
+ **git** — Necessario per clonare il repository degli esempi. OnWindows, [git for](https://gitforwindows.org/) fornisce Windows anche una `bash` shell, richiesta da alcune ricette di Windows esempio.
## Creazione e pubblicazione di un pacchetto su un canale locale
In questa procedura, cloni il repository di esempi di Deadline Cloud e lo usi `rattler-build publish` per creare e pubblicare il pacchetto su un canale di filesystem locale.
**Per creare e pubblicare un pacchetto su un canale locale**
1. Clona il repository di esempi di Deadline Cloud.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Passare alla directory `conda_recipes`.
```
cd deadline-cloud-samples/conda_recipes
```
1. Esegui il comando seguente per creare la ricetta Blender 4.5 e pubblicare il pacchetto in una directory di canale locale.
Su Linux emacOS, esegui il seguente comando.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to file://$HOME/my-conda-channel
```
Su Windows (cmd), esegui il comando seguente.
```
rattler-build publish blender-4.5/recipe/recipe.yaml ^
--to file://%USERPROFILE%/my-conda-channel
```
Il `rattler-build publish` comando esegue le seguenti azioni:
+ Crea il pacchetto a partire dalla ricetta.
+ Crea la directory dei canali se la directory non esiste.
+ Copia il file del pacchetto sul canale.
+ Indicizza il canale in modo che i gestori di pacchetti possano trovare il pacchetto.
Se la ricetta del pacchetto dipende dai pacchetti di un canale particolare, come [conda-forge](https://conda-forge.org/), aggiungila al comando. `-c conda-forge`
Per ricostruire il pacchetto dopo aver apportato modifiche alla ricetta, aggiungi per `--build-number=+1` incrementare automaticamente il numero di build.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to file://$HOME/my-conda-channel \
--build-number=+1
```
Per ulteriori informazioni in merito`rattler-build publish`, consulta la documentazione di [rattler-build](https://rattler-build.prefix.dev/latest/publish/) publish.
## Compilazioni di debug
Se una compilazione fallisce, `rattler-build` conserva la directory di compilazione in modo da poter indagare. Esegui il comando seguente per aprire una shell interattiva nell'ambiente di compilazione con tutte le variabili di ambiente impostate com'erano durante la compilazione.
```
rattler-build debug shell
```
Dalla shell di debug, puoi modificare i file, eseguire singoli comandi di compilazione e aggiungere dipendenze per isolare il problema. Per ulteriori informazioni, consulta [Debugging](https://rattler-build.prefix.dev/latest/debugging_builds/) build nella documentazione di rattler-build.
## Test del pacchetto
Dopo aver creato e pubblicato il pacchetto, create un progetto pixi temporaneo. Utilizzate il progetto per installare il pacchetto dal canale locale e verificare che funzioni correttamente.
**Per testare il pacchetto**
1. Crea una directory di test temporanea e inizializza un progetto pixi con il canale locale.
Su Linux emacOS, esegui i seguenti comandi.
```
mkdir package-test-env
cd package-test-env
pixi init --channel file://$HOME/my-conda-channel
```
Su Windows (cmd), esegui i seguenti comandi.
```
mkdir package-test-env
cd package-test-env
pixi init --channel file://%USERPROFILE%/my-conda-channel
```
1. Aggiungi il pacchetto al progetto.
```
pixi add blender=4.5
```
1. Verifica che il pacchetto funzioni correttamente.
```
pixi run blender --version
```
Quando sei soddisfatto del pacchetto, puoi pubblicarlo su un canale conda di Amazon S3 in modo che gli operatori di Deadline Cloud possano installare il pacchetto. Vedi [Pubblicare pacchetti su un canale conda S3](publish-packages-s3-channel.md).
## Pulizia
Dopo il test, puoi rimuovere il progetto di test e il canale locale.
**Per ripulire le risorse di test**
1. Rimuovi la directory del progetto di test.
Su Linux emacOS, esegui il seguente comando.
```
rm -rf package-test-env
```
Su Windows (cmd), esegui il comando seguente.
```
rmdir /s /q package-test-env
```
1. Rimuovi la directory del canale conda locale.
Su Linux emacOS, esegui il seguente comando.
```
rm -rf $HOME/my-conda-channel
```
Su Windows (cmd), esegui il comando seguente.
```
rmdir /s /q %USERPROFILE%\my-conda-channel
```
1. (Facoltativo) Rimuove la directory `rattler-build` di output che contiene il file del pacchetto creato.
Su Linux emacOS, esegui il comando seguente.
```
rm -rf deadline-cloud-samples/conda_recipes/output
```
Su Windows (cmd), esegui il comando seguente.
```
rmdir /s /q deadline-cloud-samples\conda_recipes\output
```
# Pubblica pacchetti su un canale conda Amazon S3
Puoi pubblicare pacchetti conda su un bucket Amazon Simple Storage Service (Amazon S3) in modo che gli operatori di AWS Deadline Cloud (Deadline Cloud) possano installarli per eseguire lavori. Il `rattler-build publish` comando funziona con Amazon S3 allo stesso modo di un canale di filesystem locale. Il comando può creare una ricetta e pubblicare il risultato oppure pubblicare un file di pacchetto già creato. In entrambi i casi, il comando carica il pacchetto nel bucket e indicizza il canale in un unico passaggio.
Il `rattler-build publish` comando si autentica AWS utilizzando la catena di credenziali standard, quindi utilizza la configurazione come qualsiasi altro strumento. AWS AWS *Per ulteriori informazioni sulla configurazione delle credenziali, consultate Configurazione [e impostazioni dei file di credenziali](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) nella Guida per l'utente ().AWS Command Line Interface AWS CLI*
## Prerequisiti
Prima di pubblicare pacchetti su Amazon S3, completa i seguenti prerequisiti:
+ **pixi e rattler-build**[: installa pixi da pixi.sh, quindi installa.](https://pixi.sh) `rattler-build`
```
pixi global install rattler-build
```
+ **git** — Necessario per clonare il repository degli esempi. OnWindows, [git for](https://gitforwindows.org/) fornisce Windows anche una `bash` shell, richiesta da alcune ricette di Windows esempio.
+ Bucket **Amazon S3: un bucket** Amazon S3 da utilizzare come canale conda. Puoi utilizzare il bucket Job Attachments della tua Deadline Cloud farm o creare un bucket separato.
+ **AWS credenziali**: configura le credenziali sulla tua workstation utilizzando il comando o il comando. `aws configure` `aws login` Per ulteriori informazioni, consulta [Configurazione della AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-quickstart.html) nella *Guida per l'utente di AWS Command Line Interface *.
+ **Autorizzazioni IAM** — (Facoltativo) Per ridurre l'ambito delle autorizzazioni a disposizione delle tue credenziali, puoi utilizzare una policy AWS Identity and Access Management (IAM) che concede solo le seguenti autorizzazioni sul bucket Amazon S3 e sul prefisso del canale che utilizzi (ad esempio,): `/Conda/*`
+ `s3:GetObject`
+ `s3:PutObject`
+ `s3:DeleteObject`
+ `s3:ListBucket`
+ `s3:GetBucketLocation`
## Pubblicazione di un pacchetto su un canale Amazon S3
Usalo `rattler-build publish` con un `s3://` target per pubblicare un pacchetto sul tuo canale Amazon S3 conda. Se il canale non esiste nel bucket, `rattler-build` inizializza automaticamente il canale. [Prima di iniziare, assicuratevi di aver completato i prerequisiti.](#publish-s3-prereqs)
L'esempio seguente pubblica la ricetta di esempio Blender 4.5 dal repository di [esempi di Deadline Cloud su](https://github.com/aws-deadline/deadline-cloud-samples). GitHub È possibile sostituire una ricetta diversa dall'archivio degli esempi o utilizzare una ricetta personalizzata.
**Per pubblicare un pacchetto su un canale Amazon S3**
1. Clona l'archivio di esempi di Deadline Cloud.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Passare alla directory `conda_recipes`.
```
cd deadline-cloud-samples/conda_recipes
```
1. Eseguire il seguente comando seguente. Sostituiscilo *amzn-s3-demo-bucket* con il nome del tuo bucket.
Su Linux emacOS, esegui il seguente comando.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to s3://amzn-s3-demo-bucket/Conda/Default
```
Su Windows (cmd), esegui il comando seguente.
```
rattler-build publish blender-4.5/recipe/recipe.yaml ^
--to s3://amzn-s3-demo-bucket/Conda/Default
```
Il `/Conda/Default` prefisso organizza il canale all'interno del bucket. È possibile utilizzare un prefisso diverso, ma il prefisso deve essere coerente in tutti i comandi e le configurazioni di coda che fanno riferimento al canale.
Per ricostruire e pubblicare un pacchetto aggiornato, aggiungilo `--build-number=+1` per incrementare automaticamente il numero di build.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to s3://amzn-s3-demo-bucket/Conda/Default \
--build-number=+1
```
Se la ricetta del pacchetto dipende dai pacchetti di un canale particolare, come [conda-forge](https://conda-forge.org/), aggiungila al comando. `-c conda-forge`
Puoi anche pubblicare un file di pacchetto che hai già creato, ad esempio un `.conda` file da una build locale. *amzn-s3-demo-bucket*Sostituiscilo con il nome del tuo bucket.
```
rattler-build publish output/linux-64/blender-4.5.0-hb0f4dca_0.conda \
--to s3://amzn-s3-demo-bucket/Conda/Default
```
## Test del pacchetto
Dopo aver pubblicato il pacchetto, create un progetto pixi temporaneo per verificare che il pacchetto funzioni correttamente. Il progetto installa il pacchetto dal canale Amazon S3.
**Per testare il pacchetto**
1. Crea una directory di test temporanea e inizializza un progetto pixi con il canale Amazon S3. Sostituiscilo *amzn-s3-demo-bucket* con il nome del tuo bucket.
```
mkdir package-test-env
cd package-test-env
pixi init --channel s3://amzn-s3-demo-bucket/Conda/Default
```
1. Aggiungi il pacchetto al progetto.
```
pixi add blender=4.5
```
1. Verifica che il pacchetto funzioni correttamente.
```
pixi run blender --version
```
## Pulizia
Dopo il test, rimuovi la directory del progetto di test.
**Per ripulire le risorse di test**
+ Rimuovi la directory del progetto di test.
Su Linux emacOS, esegui il seguente comando.
```
rm -rf package-test-env
```
Su Windows (cmd), esegui il comando seguente.
```
rmdir /s /q package-test-env
```
## Compilazioni di debug
Se una compilazione fallisce, `rattler-build` conserva la directory di compilazione in modo da poter indagare. Esegui il comando seguente per aprire una shell interattiva nell'ambiente di compilazione con tutte le variabili di ambiente impostate com'erano durante la compilazione.
```
rattler-build debug shell
```
Dalla shell di debug, puoi modificare i file, eseguire singoli comandi di compilazione e aggiungere dipendenze per isolare il problema. Per ulteriori informazioni, consulta [Debugging](https://rattler-build.prefix.dev/latest/debugging_builds/) build nella documentazione di rattler-build.
## Creazione di pacchetti per altre piattaforme
Il `rattler-build publish` comando crea pacchetti per il sistema operativo della workstation su cui viene eseguito il comando. Se la tua flotta Deadline Cloud utilizza un sistema operativo diverso da quello della tua workstation o se il tuo pacchetto ha altri requisiti di host, hai le seguenti opzioni:
+ Esegui `rattler-build publish` su un host che corrisponde al sistema operativo di destinazione. Ad esempio, usa un'istanza Amazon Elastic Compute Cloud (Amazon EC2) in Linux esecuzione per creare pacchetti per una flotta. Linux
+ Usa una coda di creazione di pacchetti Deadline Cloud per automatizzare le build sulla piattaforma di destinazione. Vedi [Creare una coda per la creazione di pacchetti](automate-package-builds.md#s3-channel-create-queue).
+ (Avanzato) Usa la compilazione incrociata per creare pacchetti per una piattaforma diversa dalla tua workstation. Per ulteriori informazioni, consulta la [compilazione incrociata](https://rattler-build.prefix.dev/latest/compilers/#cross-compilation) nella documentazione di rattler-build.
## Fasi successive
Dopo aver pubblicato i pacchetti sul tuo canale Amazon S3 conda, configura le code di Deadline Cloud per utilizzare il canale:
+ [Configura le autorizzazioni della coda di produzione per pacchetti conda personalizzati](configure-jobs-s3-channel.md#s3-channel-configure-permissions): concedi alle tue code di produzione l'accesso in sola lettura al canale conda di Amazon S3.
+ [Aggiungi un canale conda a un ambiente di coda: configura l'ambiente](configure-jobs-s3-channel.md#s3-channel-add-channel) di coda per installare i pacchetti dal canale conda di Amazon S3.
## Configura le autorizzazioni per la coda di produzione per pacchetti conda personalizzati
La tua coda di produzione richiede autorizzazioni di sola lettura per il `/Conda` prefisso nel bucket S3 della coda. Apri la pagina AWS Identity and Access Management (IAM) per il ruolo associato alla coda di produzione e modifica la policy con quanto segue:
1. Apri la console Deadline Cloud e vai alla pagina dei dettagli della coda per la coda di compilazione del pacchetto.
1. **Scegli il ruolo del servizio di coda, quindi scegli Modifica coda.**
1. Scorri fino alla sezione **Queue service role**, quindi scegli **Visualizza questo ruolo nella console** IAM.
1. Dall'elenco delle politiche di autorizzazione, scegli quella **AmazonDeadlineCloudQueuePolicy**per la tua coda.
1. **Dalla scheda **Autorizzazioni**, scegli Modifica.**
1. Aggiungi una nuova sezione al ruolo del servizio di coda come segue. Sostituisci *amzn-s3-demo-bucket* e *111122223333* con il tuo bucket e il tuo account.
```
{
"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"
}
}
},
```
## Aggiungi un canale conda a un ambiente di coda
Per utilizzare il canale S3 conda, devi aggiungere la posizione del `s3://amzn-s3-demo-bucket/Conda/Default` canale al `CondaChannels` parametro dei lavori che invii a Deadline Cloud. I mittenti forniti con Deadline Cloud forniscono campi per specificare canali e pacchetti conda personalizzati.
Puoi evitare di modificare ogni lavoro modificando l'ambiente di coda conda per la tua coda di produzione. Attenersi alla seguente procedura:
1. Apri la console Deadline Cloud e vai alla pagina dei dettagli della coda per la coda di produzione.
1. Scegli la scheda Ambienti.
1. **Seleziona l'ambiente di coda **Conda**, quindi scegli Modifica.**
1. Scegli l'**editor JSON**, quindi nello script, trova la definizione del parametro per. `CondaChannels`
1. Modifica la riga `default: "deadline-cloud"` in modo che inizi con il canale conda S3 appena creato:
```
default: "s3://amzn-s3-demo-bucket/Conda/Default deadline-cloud"
```
Le flotte gestite dai servizi consentono una priorità flessibile dei canali per conda per impostazione predefinita. Per una richiesta di lavoro `blender=4.2` se Blender 4.2 è presente sia nel nuovo canale che nel canale, il pacchetto verrà estratto dal `deadline-cloud` canale che si trova per primo nell'elenco dei canali. Se una versione del pacchetto specificata non viene trovata nel primo canale, i canali successivi verranno controllati in ordine per verificare la versione del pacchetto.
Per le flotte gestite dai clienti, puoi abilitare l'uso dei pacchetti conda utilizzando uno degli esempi di [ambiente conda queue nel repository di esempi](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/README.md) di Deadline Cloud. GitHub
# Crea un pacchetto conda per un'applicazione o un plug-in
Un pacchetto conda è un archivio compresso di software scritto in qualsiasi lingua. Conda supporta una varietà di combinazioni di sistemi operativi e architetture, quindi puoi impacchettare applicazioni complete come Blender e Nuke insieme a librerie per Python e altri linguaggi. Maya Per ulteriori informazioni sui pacchetti conda, vedere [Pacchetti](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/packages.html) nella documentazione di conda.
Per utilizzare un pacchetto conda, lo si installa in un ambiente virtuale. Un ambiente virtuale conda ha una *directory di prefissi* in cui sono installati i pacchetti. L'installazione di un pacchetto utilizza il collegamento fisico o il reflink dei file quando è supportata, quindi la creazione di più ambienti con gli stessi pacchetti non utilizza molto spazio aggiuntivo su disco. Per utilizzare un ambiente virtuale, è necessario attivarlo per impostare le variabili di ambiente. L'attivazione esegue gli script forniti dai pacchetti, dando a ciascun pacchetto l'opportunità di modificare PATH o altre variabili di ambiente. I pacchetti Conda in genere contengono applicazioni o librerie, ma l'attivazione flessibile significa che possono anche indirizzare ad applicazioni installate su un file system condiviso.
*La creazione di un pacchetto personalizzato prevede tre fasi: una *ricetta* contiene le istruzioni di compilazione, un *pacchetto* è l'elemento (`.conda`o `.tar.bz2` file) creato e un canale ospita i pacchetti per l'installazione.* Il `rattler-build publish` comando gestisce tutti e tre i passaggi: può creare una ricetta in un pacchetto e pubblicarla su un canale, oppure può richiedere direttamente un elemento del pacchetto per pubblicarla.
La comunità [conda-forge](https://conda-forge.org/) gestisce le ricette dei pacchetti per un'ampia gamma di software open source e ospita gli elementi dei pacchetti nel canale. `conda-forge` È possibile configurare la coda per includerla `conda-forge` come sorgente del pacchetto e quindi creare pacchetti personalizzati che dipendono dall'esecuzione dei pacchetti conda-forge. InfattiLinux, conda-forge ospita una toolchain completa di compilatori che include il supporto CUDA, con opzioni di compilazione e collegamento coerenti selezionate. È possibile utilizzare i pacchetti conda-forge come dipendenze nelle proprie ricette o installarli insieme ai pacchetti personalizzati nello stesso ambiente.
È possibile combinare un'intera applicazione, comprese le dipendenze, in un pacchetto conda. I pacchetti che Deadline Cloud fornisce nel [canale deadline-cloud per le flotte gestite](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html#conda-queue-environment) dai servizi utilizzano questo approccio di riconfezionamento binario. Questo organizza gli stessi file di un'installazione per adattarli all'ambiente virtuale conda.
**Nota**
Le applicazioni di grandi dimensioni possono richiedere decine di GB di spazio libero su disco per l'archivio di origine, i file estratti e l'output di compilazione. Assicurati di utilizzare un disco con spazio disponibile sufficiente per l'output di compilazione del pacchetto.
## Package di un'applicazione
Quando si riconfeziona un'applicazione per conda, ci sono due obiettivi:
+ La maggior parte dei file dell'applicazione deve essere separata dalla struttura principale dell'ambiente virtuale conda. Gli ambienti possono quindi mescolare l'applicazione con pacchetti provenienti da altre fonti come [conda-forge](https://conda-forge.org/).
+ Quando viene attivato un ambiente virtuale conda, l'applicazione dovrebbe essere disponibile dalla variabile di ambiente PATH.
**Per riconfezionare un'applicazione per conda**
1. Scrivi ricette di compilazione conda che installano l'applicazione in una sottodirectory come. `$CONDA_PREFIX/opt/` Questo lo separa dalle directory di prefissi standard come e. `bin` `lib`
1. Aggiungi collegamenti simbolici o avvia script per `$CONDA_PREFIX/bin` eseguire i binari dell'applicazione.
In alternativa, create degli script.d attivati che il `conda activate` comando eseguirà per aggiungere le directory binarie dell'applicazione al PATH. NoWindows, dove i collegamenti simbolici non sono supportati ovunque sia possibile creare ambienti, utilizzate invece gli script di avvio dell'applicazione o activate.d.
1. Alcune applicazioni dipendono da librerie non installate di default sulle flotte gestite dai servizi Deadline Cloud. Ad esempio, il sistema a finestre X11 di solito non è necessario per lavori non interattivi, ma alcune applicazioni richiedono comunque che venga eseguito senza un'interfaccia grafica. È necessario fornire tali dipendenze all'interno del pacchetto creato.
1. Se l'applicazione supporta i plugin, fornite una convenzione chiara che i pacchetti di plugin devono seguire per integrarsi con l'applicazione in un ambiente virtuale. Ad esempio, la [ricetta di esempio del Maya 2026](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-2026#instructions-for-maya-plugin-packages) documenta questa convenzione per Maya i plugin.
1. Assicurati di rispettare gli accordi di copyright e licenza per le applicazioni che includi. Ti consigliamo di utilizzare un bucket Amazon S3 privato per il tuo canale conda per controllare la distribuzione e limitare l'accesso dei pacchetti alla tua farm.
Le ricette di esempio per i pacchetti del `deadline-cloud` canale sono disponibili nell'archivio di esempi di [Deadline Cloud su](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes#readme). GitHub
## Package di un plugin
I plugin delle applicazioni possono essere impacchettati come pacchetti conda propri. Quando crei un pacchetto di plugin, segui queste linee guida:
+ Includi il pacchetto dell'applicazione host sia come dipendenza di compilazione che di esecuzione nella ricetta `recipe.yaml` di compilazione. Utilizzate un vincolo di versione in modo che la ricetta di compilazione venga installata solo con pacchetti compatibili.
+ Segui le convenzioni del pacchetto dell'applicazione host per la registrazione del plug-in.
## Pacchetti adattatori
[Alcune integrazioni di applicazioni Deadline Cloud utilizzano un *adattatore* che estende l'interfaccia dell'applicazione per semplificare la scrittura di modelli di lavoro.](building-jobs.md) Un adattatore è un'interfaccia a riga di comando con supporto per l'esecuzione di un demone in background, la segnalazione dello stato e l'applicazione della mappatura dei percorsi. Per ulteriori informazioni, vedere [Open Job Description Adaptor Runtime](https://github.com/OpenJobDescription/openjd-adaptor-runtime-for-python#readme) suGitHub. Ad esempio, [deadline-cloud-for-maya](https://github.com/aws-deadline/deadline-cloud-for-maya/)on GitHub include una GUI integrata per l'invio dei lavori e un Maya adattatore disponibile come `maya-openjd` pacchetto nelle flotte gestite dai servizi.
Gli invii di lavoro da Deadline Cloud submitter GUIs includono un valore di `CondaPackages` parametro che specifica i pacchetti conda da includere in un ambiente virtuale per l'esecuzione del lavoro. Il valore del `CondaPackages` parametro per Maya in genere è simile `maya=2025.* maya-openjd=0.15.* maya-mtoa` e potrebbe contenere voci alternative per i pacchetti di plug-in. Quando l'ambiente di coda configura un ambiente virtuale conda per l'esecuzione del job, risolve questi nomi di pacchetto e vincoli di versione in modo che siano compatibili e aggiunge tutti i pacchetti di dipendenza necessari per l'esecuzione. Ogni pacchetto di adattatori e plugin specifica con cosa è compatibile, incluse le versioni, le versioni di Maya Python e altre dipendenze.
[Per creare i tuoi pacchetti adattatori usando i nostri esempi come la [ricetta maya-openjd](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-openjd) onGitHub, puoi basarti sui pacchetti per Python e altre dipendenze fornite da conda-forge.](https://conda-forge.org/) [Potrebbe essere necessario prima definire la scadenza e le ricette per soddisfare le dipendenze. [openjd-adaptor-runtime](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/openjd-adaptor-runtime)](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/deadline)
# Crea una ricetta di costruzione di conda per Blender
È possibile utilizzare diverse applicazioni per creare una ricetta di compilazione di conda. Blenderè gratuito da usare ed è semplice da impacchettare con conda. La Blender Foundation fornisce [archivi di applicazioni](https://download.blender.org/release/Blender4.2/) per più sistemi operativi. Abbiamo creato una ricetta di compilazione conda di esempio che utilizza i file Windows .zip e Linux .tar.xz. [In questa sezione, scopri come usare la ricetta di build conda 4.2. Blender](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2)
Il file [deadline-cloud.yaml](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2) specifica le piattaforme conda e altri metadati per l'invio di pacchetti a Deadline Cloud. Questa ricetta include informazioni sull'archivio di origine locale per dimostrarne il funzionamento. La piattaforma conda linux-64 è impostata per incorporare un invio di job predefinito che corrisponda alla configurazione più comune. Il file deadline-cloud.yaml ha un aspetto simile al seguente:
```
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"'
```
Esamina i file nella directory. `recipe` I metadati per la ricetta si trovano in [recipe/recipe.yaml](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2/recipe/recipe.yaml). Puoi anche leggere la documentazione di conda build [meta.yaml per saperne di più, ad esempio come il file sia un modello per generare YAML](https://docs.conda.io/projects/conda-build/en/latest/resources/define-metadata.html). Il modello viene utilizzato per specificare il numero di versione solo una volta e per fornire valori diversi in base al sistema operativo.
È possibile esaminare le opzioni di compilazione selezionate in `meta.yaml` per disattivare vari controlli di rilocazione binaria e collegamento di oggetti condivisi dinamici (DSO). Queste opzioni controllano il funzionamento del pacchetto quando viene installato in un ambiente virtuale conda con qualsiasi prefisso di directory. I valori predefiniti semplificano il pacchetto di ogni libreria di dipendenze in un pacchetto separato, ma quando si riconfeziona un'applicazione in formato binario, è necessario modificarli.
Se l'applicazione che state impacchettando richiede librerie di dipendenze aggiuntive o state impacchettando i plugin per un'applicazione separatamente, potreste riscontrare errori DSO. Questi errori si verificano quando la dipendenza non si trova nel percorso di ricerca della libreria per l'eseguibile o la libreria che ne ha bisogno. Le applicazioni si basano sul fatto che le librerie si trovino in percorsi definiti a livello globale`/usr/lib`, come `/lib` o, se installate su un sistema. Tuttavia, poiché gli ambienti virtuali conda possono essere posizionati ovunque, non esiste un percorso assoluto da utilizzare. Conda utilizza le funzionalità RPATH relative, che entrambi Linux macOS supportano, per gestire questo problema. Per ulteriori informazioni, consulta la documentazione di conda build su [Making packages relocatable](https://docs.conda.io/projects/conda-build/en/latest/resources/make-relocatable.html).
Blendernon richiede alcuna regolazione RPATH, poiché gli archivi dell'applicazione sono stati creati pensando a questo. Per le applicazioni che lo richiedono, puoi utilizzare gli stessi strumenti di conda build: `patchelf` su Linux e `install_name_tool` su. macOS
Durante la compilazione del pacchetto, lo script [build.sh](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2/recipe/build.sh) o [build\$1win.sh](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2/recipe/build_win.sh) (chiamato da`bld.bat`) viene eseguito per installare i file in un ambiente preparato con le dipendenze del pacchetto. Questi script copiano i file di installazione, creano collegamenti simbolici e configurano `$PREFIX/bin` gli script di attivazione. AttivoWindows, non crea collegamenti simbolici ma aggiunge invece la directory Blender al PATH nello script di attivazione.
Utilizziamo `bash` invece di un `cmd.exe` file.bat per la Windows parte della ricetta di compilazione di conda, in quanto ciò fornisce una maggiore coerenza tra gli script di compilazione. Consulta i consigli della [guida per sviluppatori di Deadline Cloud sulla portabilità del](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/what-is-a-deadline-cloud-workload.html#workload-portability) carico di lavoro per suggerimenti sull'utilizzo di. `bash` Windows Se hai installato [git per Windows](https://gitforwindows.org/) clonare il repository [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/)git, hai già accesso a. `bash`
La documentazione delle [variabili di ambiente di compilazione di conda](https://docs.conda.io/projects/conda-build/en/latest/user-guide/environment-variables.html) elenca i valori disponibili per l'uso nello script di compilazione. Questi valori includono `$SRC_DIR` i dati di archivio di origine, `$PREFIX` la directory di installazione, l'accesso `$RECIPE_DIR` ad altri file dalla ricetta, il nome `$PKG_NAME` e `$PKG_VERSION` la versione del pacchetto e `$target_platform` la piattaforma conda di destinazione.
## Invia il processo del pacchetto Blender 4.2
È possibile creare il proprio pacchetto conda Blender 4.2 per eseguire il rendering dei lavori, scaricando l'Blenderarchivio e quindi inviando un lavoro alla coda di creazione dei pacchetti. La coda invia il lavoro alla flotta associata per creare il pacchetto e reindicizzare il canale conda.
[Queste istruzioni usano git da una shell compatibile con bash per ottenere un processo di compilazione del pacchetto OpenJD e alcune ricette conda dal repository di esempi di Deadline Cloud. GitHub](https://github.com/aws-deadline/deadline-cloud-samples) Devi disporre anche dei seguenti elementi:
+ Se si utilizzaWindows, una versione di bash, git BASH, viene installata quando si installa git.
+ È necessario che sia installata la [CLI di Deadline Cloud](https://github.com/aws-deadline/deadline-cloud).
+ Devi aver effettuato l'accesso al monitor [Deadline](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/working-with-deadline-monitor.html) Cloud.
1. Apri la GUI di configurazione di Deadline Cloud utilizzando il seguente comando e imposta la farm e la coda predefinite nella coda di creazione dei pacchetti.
```
deadline config gui
```
1. Usa il seguente comando per clonare l'archivio di esempi di Deadline Cloud. GitHUb
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Passa alla `conda_recipes` directory nella directory. `deadline-cloud-samples`
```
cd deadline-cloud-samples/conda_recipes
```
1. Esegui lo script chiamato`submit-package-job`. Lo script fornisce istruzioni per Blender il download la prima volta che si esegue lo script.
```
./submit-package-job blender-4.2/
```
1. Segui le istruzioni per il downloadBlender. Quando hai l'archivio, esegui nuovamente `submit-package-job` lo script.
```
./submit-package-job blender-4.2/
```
Dopo aver inviato il lavoro, utilizza il monitor Deadline Cloud per visualizzare l'avanzamento e lo stato del lavoro mentre viene eseguito.
La parte inferiore sinistra del monitor mostra le due fasi del lavoro, la creazione del pacchetto e la reindicizzazione. La parte inferiore destra mostra i singoli passaggi per ogni attività. In questo esempio, c'è un passaggio per ogni attività.
![\[Il monitor Deadline Cloud mostra l'avanzamento e lo stato di un lavoro durante la creazione del Blender pacchetto.\]](http://docs.aws.amazon.com/it_it/deadline-cloud/latest/developerguide/images/Conda-Figure3.png)
Nella parte inferiore sinistra del monitor ci sono le due fasi del lavoro, la creazione del pacchetto e la reindicizzazione del canale conda. In basso a destra ci sono le singole attività per ogni fase. In questo esempio esiste una sola attività per ogni fase.
Quando si fa clic con il pulsante destro del mouse sull'attività per la fase di creazione del pacchetto e si sceglie **Visualizza registri**, il monitor mostra un elenco di azioni della sessione che mostrano come l'attività è pianificata sul lavoratore. Le azioni sono:
+ **Sincronizza allegati**: questa azione copia gli allegati del lavoro di input o installa un file system virtuale, a seconda dell'impostazione utilizzata per il file system degli allegati del lavoro.
+ **Avvia Conda**: questa azione proviene dall'ambiente di coda aggiunto di default quando hai creato la coda. Il lavoro non specifica alcun pacchetto conda, quindi termina rapidamente e non crea un ambiente virtuale conda.
+ **Launch CondaBuild Env**: questa azione crea un ambiente virtuale conda personalizzato che include il software necessario per creare un pacchetto conda e reindicizzare un canale. [Si installa dal canale conda-forge.](https://conda-forge.org/)
+ **Task run**: questa azione crea il Blender pacchetto e carica i risultati su Amazon S3.
Man mano che le azioni vengono eseguite, inviano i log in un formato strutturato ad Amazon CloudWatch. Quando un processo è completo, seleziona **Visualizza i registri di tutte le attività per** visualizzare altri registri sulla configurazione e la rimozione dell'ambiente in cui viene eseguito il lavoro.
# Testa il tuo pacchetto con un render job 4.2 Blender
Dopo aver creato il pacchetto Blender 4.2 e aver configurato la coda di produzione per utilizzare il canale conda S3, puoi inviare lavori da renderizzare con il pacchetto. Se non avete una Blender scena, scaricate la scena Blender 3.5 - Cozy Kitchen dalla pagina dei file [Blenderdimostrativi](https://www.blender.org/download/demo-files).
L'GitHubarchivio di esempi di Deadline Cloud che hai scaricato in precedenza contiene un processo di esempio per il rendering di una Blender scena utilizzando i seguenti comandi:
```
deadline bundle submit blender_render \
-p CondaPackages=blender=4.2 \
-p BlenderSceneFile=/path/to/downloaded/blender-3.5-splash.blend \
-p Frames=1
```
Puoi utilizzare il monitor Deadline Cloud per monitorare lo stato di avanzamento del tuo lavoro:
1. Nel monitor, seleziona l'attività per il lavoro che hai inviato, quindi seleziona l'opzione per visualizzare il registro.
1. Sul lato destro della visualizzazione del registro, seleziona l'azione **Avvia sessione Conda**.
Puoi vedere che l'azione ha cercato Blender 4.2 nei due canali conda configurati per l'ambiente di coda e che ha trovato il pacchetto nel canale S3.
# Crea una ricetta di compilazione di conda per Autodesk Maya
È possibile impacchettare applicazioni commerciali come pacchetti conda. In [Create a conda build recipe for Blender](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/conda-package.html#create-conda-recipe-blender), hai imparato a impacchettare un'applicazione disponibile come semplice file di archivio rilocabile e secondo i termini di licenza open source. Le applicazioni commerciali sono spesso distribuite tramite programmi di installazione e possono avere un sistema di gestione delle licenze con cui lavorare.
L'elenco seguente si basa sulle nozioni di base trattate in [Creare un pacchetto conda per un'applicazione o un plug-in](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/conda-package.html) con requisiti comunemente associati alla creazione di pacchetti di applicazioni commerciali. I dettagli nei punti secondari illustrano come applicare le linee guida a. Maya
+ Comprendi i diritti e le restrizioni di licenza dell'applicazione. Potrebbe essere necessario configurare un sistema di gestione delle licenze. Laddove l'applicazione non preveda l'applicazione dell'applicazione, sarà necessario configurare la farm in base ai propri diritti.
+ Leggi le [domande frequenti sui vantaggi dell'Autodeskabbonamento](https://www.autodesk.com/support/technical/article/caas/sfdcarticles/sfdcarticles/Subscription-Benefits-FAQ-Cloud-Rights.html) relative a Cloud Rights per capire quali diritti cloud Maya potrebbero interessarti. Se necessario, configura la tua Deadline Cloud farm.
+ Autodeski prodotti si basano su un file chiamato`ProductInformation.pit`. La maggior parte della configurazione di questo file richiede l'accesso dell'amministratore al sistema, che non è disponibile nelle flotte gestite dai servizi. Le funzionalità del prodotto per i thin client offrono un modo trasferibile per gestire questo problema. Per ulteriori informazioni, consulta [Thin Client Licensing for Maya](https://www.autodesk.com/support/technical/article/caas/tsarticles/ts/2zqRBCuGDrcPZDzULJQ27p.html). MotionBuilder
+ Alcune applicazioni dipendono da librerie non installate su host Fleet Worker gestiti dai servizi, quindi il pacchetto dovrà fornirle. Questo potrebbe trovarsi direttamente nel pacchetto dell'applicazione o inserito in un pacchetto di dipendenze separato.
+ Mayadipende da un certo numero di librerie di questo tipo, tra cui freetype e fontconfig. Quando queste librerie sono disponibili nel gestore di pacchetti di sistema, come in `dnf` for AL2023, puoi usarle come sorgente per l'applicazione. Poiché questi pacchetti RPM non sono progettati per essere rilocabili, sarà necessario utilizzare strumenti che garantiscano la risoluzione delle dipendenze `patchelf` all'interno del prefisso di installazione. Maya
+ L'installazione potrebbe richiedere l'accesso dell'amministratore. Poiché le flotte gestite dai servizi non forniscono l'accesso come amministratore, sarà necessario eseguire un'installazione su un sistema con tale accesso. Quindi, create un archivio dei file necessari per l'utilizzo del processo di compilazione del pacchetto.
+ Il Windows programma di installazione Maya richiede l'accesso da amministratore, quindi la creazione del relativo pacchetto conda richiede un processo manuale per creare prima un archivio di questo tipo.
+ La configurazione dell'applicazione, inclusa la modalità di registrazione dei plugin, può essere definita a livello di sistema operativo o utente. Se collocati in un ambiente virtuale conda, i plugin necessitano di un modo per integrarsi con l'applicazione in modo da essere contenuti e non scrivere mai file o altri dati al di fuori del prefisso dell'ambiente virtuale. Ti suggeriamo di configurarlo dal pacchetto conda dell'applicazione.
+ Il Maya pacchetto di esempio definisce la variabile di ambiente `MAYA_NO_HOME=1` per isolarla dalla configurazione a livello utente e aggiunge percorsi di ricerca dei moduli in `MAYA_MODULE_PATH` modo che i plug-in impacchettati separatamente possano integrarsi dall'interno dell'ambiente virtuale. Il MtoA pacchetto di esempio inserisce un file.mod in una di queste directory per caricarlo all'avvio. Maya
**Scrivi i metadati della ricetta**
1. Apri la directory GitHub [ deadline-cloud-samples/conda\$1recipes/maya-2025](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-2025) nel tuo browser o in un editor di testo nel clone locale del repository.
Il file `deadline-cloud.yaml` descrive le piattaforme di compilazione conda per cui creare pacchetti e da dove ottenere l'applicazione. L'esempio di ricetta specifica entrambe le Windows build Linux e solo quella Linux viene inviata per impostazione predefinita.
1. Scarica i programmi di Maya installazione completi dal tuo login. Autodesk InfattiLinux, la build del pacchetto può usare direttamente l'archivio, quindi inseriscilo direttamente nella `conda_recipes/archive_files` directory. InfattiWindows, il programma di installazione richiede l'accesso di amministratore per essere eseguito. È necessario eseguire il programma di installazione e raccogliere i file necessari in un archivio per la ricetta del pacchetto che si desidera utilizzare. Il file [README.md](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/README.md) nella ricetta documenta una procedura ripetibile per creare questo artefatto. La procedura utilizza un'istanza Amazon EC2 appena lanciata per fornire un ambiente pulito per l'installazione che puoi quindi terminare dopo aver salvato il risultato. Per impacchettare altre applicazioni che richiedono l'accesso da amministratore, puoi seguire una procedura simile una volta determinato il set di file necessario all'applicazione.
1. Aprite i file [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) per rivedere o modificare le impostazioni per rattler-build e per conda-build. È possibile impostare il nome e la versione del pacchetto per l'applicazione che si sta impacchettando.
La sezione dei **sorgenti** include un riferimento agli archivi, incluso l'hash sha256 dei file. Ogni volta che modifichi questi file, ad esempio con una nuova versione, dovrai calcolare e aggiornare questi valori.
La sezione **build** contiene principalmente opzioni per disattivare le opzioni di riposizionamento binario predefinite, poiché i meccanismi automatici non funzioneranno correttamente per la particolare libreria e le directory binarie utilizzate dal pacchetto.
Infine, la sezione **about** consente di inserire alcuni metadati sull'applicazione che possono essere utilizzati durante la navigazione o l'elaborazione dei contenuti di un canale conda.
**Scrivi lo script di compilazione del pacchetto**
1. Gli script di compilazione del pacchetto nella ricetta di compilazione conda di Maya esempio includono commenti che spiegano i passaggi eseguiti dagli script. Leggi i commenti e i comandi per scoprire quanto segue:
+ In che modo la ricetta gestisce il file RPM da Autodesk
+ Le modifiche applicate dalla ricetta per rendere l'installazione rilocabile negli ambienti virtuali conda in cui è installata la ricetta
+ In che modo la ricetta imposta variabili di utilità come `MAYA_LOCATION` e `MAYA_VERSION` che il software può utilizzare per capire se è in esecuzione. Maya
1. Per esempioLinux, aprite il file [recipe/build.sh](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/recipe/build.sh) per rivedere o modificare lo script di compilazione del pacchetto.
WindowsIn alternativa, aprite il file [recipe/build\$1win.sh](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/recipe/build_win.sh) per rivedere o modificare lo script di creazione del pacchetto.
**Invia un lavoro che crei i pacchetti Maya**
1. Inserisci la `conda_recipes` directory nel tuo clone del GitHub [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples)repository.
1. Assicurati che la tua cloud farm di Deadline sia configurata per la CLI di Deadline Cloud. Se hai seguito i passaggi per [creare un canale conda utilizzando Amazon](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/configure-jobs-s3-channel.html) S3, la tua farm dovrebbe essere configurata per la tua CLI.
1. Esegui il comando seguente per inviare un lavoro che compili sia pacchetti che. Linux Windows
` ./submit-package-job maya-2025 --all-platforms`
# Crea una ricetta di compilazione conda per il plugin Autodesk Maya to Arnold (MtoA)
È possibile impacchettare plugin per applicazioni commerciali come pacchetti conda. I plugin sono librerie caricate dinamicamente che utilizzano un'interfaccia binaria dell'applicazione (ABI) fornita da un'applicazione per estendere le funzionalità di tale applicazione. Il Maya to Arnold (MtoA) plugin aggiunge il Arnold renderer come opzione all'interno. Maya
+ La ricetta MtoA di compilazione di esempio dipende dal **Maya**pacchetto e utilizza un `==` vincolo per la versione.
+ Il Maya pacchetto configura un percorso del Maya modulo nell'ambiente virtuale`$PREFIX/usr/autodesk/maya$MAYA_VERSION/modules`, in cui il plugin può inserire un `.mod` file. La ricetta MtoA di build di esempio crea un file `mtoa.mod` in questa directory.
**Scrivi i metadati della ricetta**
1. Apri la directory GitHub [ deadline-cloud-samples/conda\$1recipes/maya-mtoa-2025](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-mtoa-2025) nel tuo browser o in un editor di testo nel clone locale del repository.
La ricetta segue gli stessi schemi della ricetta conda build e utilizza gli stessi archivi di origine per installare il pluginMaya.
1. Apri i file [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) per rivedere o modificare le impostazioni per rattler-build e per conda-build. Questi file `maya` specificano una dipendenza durante la compilazione del pacchetto e durante la creazione di un ambiente virtuale per l'esecuzione del plugin.
**Scrivi lo script di compilazione del pacchetto**
+ Gli script di compilazione del pacchetto nella ricetta di compilazione conda di MtoA esempio includono commenti che spiegano i passaggi eseguiti dagli script. Leggi i commenti e i comandi per scoprire come la ricetta installa MtoA e crea un file `mtoa.mod` nella directory specificata dal pacchetto. Maya
Arnolde Maya utilizzano la stessa tecnologia di licenza, quindi la ricetta di costruzione di Maya conda include già le informazioni necessarie da. Arnold
Le differenze tra gli script Linux e di Windows compilazione sono simili alle differenze per la ricetta di compilazione di Maya conda.
**Invia un lavoro che crei i pacchetti del plugin Maya MtoA**
1. Inserisci la `conda_recipes` directory nel tuo clone del GitHub [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples)repository.
1. Assicurati di aver creato i pacchetti per l'applicazione Maya host utilizzando la sezione precedente.
1. Assicurati che la tua cloud farm di Deadline sia configurata per la CLI di Deadline Cloud. Se hai seguito i passaggi per [creare un canale conda utilizzando Amazon](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/configure-jobs-s3-channel.html) S3, la tua farm dovrebbe essere configurata per la tua CLI.
1. Esegui il comando seguente per inviare un lavoro che compili sia pacchetti che. Linux Windows
` ./submit-package-job maya-mtoa-2025 --all-platforms`
# Testa il tuo pacchetto con un Maya render job
Dopo aver completato il Maya 2025 e MtoA i pacchetti, puoi inviare lavori da renderizzare con il pacchetto. L'esempio del [giradischi con Maya/Arnold](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/turntable_with_maya_arnold) job bundle esegue il rendering di un'animazione con and. Maya Arnold Questo esempio viene utilizzato anche FFmpeg per codificare un video. Puoi aggiungere il canale conda-forge all'elenco di quelli predefiniti `CondaChannels` nel tuo ambiente di coda conda per fornire una fonte per il pacchetto. `ffmpeg`
Dalla `job_bundles` directory del tuo git clone of [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples), esegui il seguente comando.
```
deadline bundle submit turntable_with_maya_arnold
```
Puoi utilizzare il monitor Deadline Cloud per monitorare lo stato di avanzamento del tuo lavoro:
1. Nel monitor, seleziona l'attività per il lavoro che hai inviato, quindi seleziona l'opzione per visualizzare il registro.
1. Sul lato destro della visualizzazione del registro, seleziona l'azione **Avvia sessione Conda**.
Puoi vedere che l'azione cercata maya e maya-mtoa nei canali conda configurati per l'ambiente di coda e che ha trovato i pacchetti nel canale S3.
# Automatizza la creazione di pacchetti con Deadline Cloud
Per i CI/CD flussi di lavoro o quando devi creare pacchetti per più sistemi operativi, puoi creare una coda per la creazione di pacchetti Deadline Cloud. Le pianificazioni delle code creano lavori sulla tua flotta, che creano i pacchetti e li pubblicano sul tuo canale conda Amazon Simple Storage Service (Amazon S3). Ciò semplifica il mantenimento di build continue di pacchetti per le versioni software in tutte le configurazioni richieste.
Puoi creare una coda per la creazione di pacchetti utilizzando un modello AWS CloudFormation (CloudFormation) o manualmente dalla console Deadline Cloud. Il CloudFormation modello implementa una farm completa con una coda di produzione e una coda di creazione di pacchetti già configurate. La creazione della coda dalla console offre un maggiore controllo sulle singole impostazioni.
## Crea una coda per la creazione di pacchetti con CloudFormation
Puoi utilizzare un CloudFormation modello per creare una Deadline Cloud farm che includa una coda per la creazione di pacchetti. Il modello configura una coda di produzione e una coda di creazione di pacchetti con un canale conda privato Amazon S3.
Prima di distribuire il modello, crea un bucket Amazon S3 per contenere gli allegati dei lavori e il tuo canale conda. Puoi creare un bucket dalla console [Amazon S3](https://console.aws.amazon.com/s3/). È necessario il nome del bucket quando si distribuisce il modello.
**Per distribuire il modello CloudFormation**
1. [Scarica il [deadline-cloud-starter-farmmodello -template.yaml](https://github.com/aws-deadline/deadline-cloud-samples/raw/mainline/cloudformation/farm_templates/starter_farm/deadline-cloud-starter-farm-template.yaml) dal repository degli esempi di Deadline Cloud su.](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/starter_farm) GitHub
1. **Dalla [CloudFormation console, scegli **Create Stack**](https://console.aws.amazon.com/cloudformation/), quindi Con nuove risorse (standard).**
1. Seleziona l'opzione per caricare un file modello, quindi carica il `deadline-cloud-starter-farm-template.yaml` file.
1. Inserisci un nome per lo stack, ad esempio**StarterFarm**, e fornisci il nome di un bucket Amazon S3 per gli allegati dei lavori e il canale conda.
1. Segui i passaggi della CloudFormation console per completare la creazione dello stack.
Per ulteriori informazioni sui parametri del modello e sulle opzioni di personalizzazione, consulta lo [starter farm README](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/starter_farm) nell'archivio degli esempi di Deadline Cloud su. GitHub
## Crea una coda per la creazione di pacchetti dalla console
Segui le istruzioni riportate in [Creare una coda](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue.html) nella Guida per l'utente di *Deadline Cloud*. Apporta le seguenti modifiche:
+ Nel passaggio 5, scegli un bucket Amazon S3 esistente. Specificate il nome della cartella principale **DeadlineCloudPackageBuild** in modo che gli artefatti della build rimangano separati dai normali allegati di Deadline Cloud.
+ Nella fase 6, puoi associare la coda per la creazione dei pacchetti a una flotta esistente oppure puoi creare una flotta completamente nuova se la flotta attuale non è adatta.
+ Nella fase 9, create un nuovo ruolo di servizio per la coda di creazione dei pacchetti. Modificherai le autorizzazioni per fornire alla coda le autorizzazioni necessarie per caricare pacchetti e reindicizzare un canale conda.
### Configura i permessi di creazione della coda del pacchetto
Per consentire alla coda di creazione dei pacchetti di accedere al `/Conda` prefisso nel bucket Amazon S3 della coda, devi modificare il ruolo della coda per consentirle l'accesso. read/write Il ruolo richiede le seguenti autorizzazioni in modo che i processi di creazione dei pacchetti possano caricare nuovi pacchetti e reindicizzare il canale.
+ `s3:GetObject`
+ `s3:PutObject`
+ `s3:ListBucket`
+ `s3:GetBucketLocation`
+ `s3:DeleteObject`
1. Apri la console Deadline Cloud e vai alla pagina dei dettagli della coda per la coda di compilazione del pacchetto.
1. **Scegli il ruolo del servizio di coda, quindi scegli Modifica coda.**
1. Scorri fino alla sezione **Queue service role**, quindi scegli **Visualizza questo ruolo nella console** IAM.
1. Dall'elenco delle politiche di autorizzazione, scegli quella **AmazonDeadlineCloudQueuePolicy**per la tua coda.
1. **Dalla scheda **Autorizzazioni**, scegli Modifica.**
1. Aggiungi una nuova sezione al ruolo del servizio di coda come segue. Sostituisci *amzn-s3-demo-bucket* e *111122223333* con il tuo bucket e il tuo account.
```
{
"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"
}
}
},
```
## Invia un processo di compilazione del pacchetto
Dopo aver creato una coda per la creazione di pacchetti e configurato i permessi di coda, puoi inviare lavori per creare pacchetti conda. Lo `submit-package-job` script nel repository di [esempi di Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes#readme) GitHub invia un lavoro di compilazione per una ricetta conda.
È necessario quanto segue:
+ La CLI [Deadline Cloud](https://github.com/aws-deadline/deadline-cloud) installata sulla tua workstation.
+ Una sessione di accesso attiva di [AWS Deadline Cloud monitor (Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/working-with-deadline-monitor.html) monitor).
+ Un clone del repository di esempi di [Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples).
**Per inviare un pacchetto, costruisci un processo**
1. Apri la GUI di configurazione di Deadline Cloud e imposta la farm e la coda predefinite nella coda di creazione dei pacchetti.
```
deadline config gui
```
1. Passa alla `conda_recipes` directory nel repository degli esempi.
```
cd deadline-cloud-samples/conda_recipes
```
1. Esegui lo `submit-package-job` script con la directory delle ricette. L'esempio seguente crea la ricetta Blender 4.5.
```
./submit-package-job blender-4.5/
```
Se la ricetta richiede un archivio sorgente che non è stato ancora scaricato, lo script fornisce le istruzioni per il download. Scaricate l'archivio ed eseguite nuovamente lo script.
Dopo aver inviato il lavoro, utilizza il monitor Deadline Cloud per visualizzare l'avanzamento e lo stato del lavoro.
![\[Il monitor Deadline Cloud mostra l'avanzamento e lo stato di un lavoro che crea un pacchetto conda.\]](http://docs.aws.amazon.com/it_it/deadline-cloud/latest/developerguide/images/Conda-Figure3.png)
Il monitor mostra le due fasi del lavoro: la creazione del pacchetto e la reindicizzazione del canale conda. Quando fai clic con il pulsante destro del mouse sull'attività per la fase di creazione del pacchetto e scegli **Visualizza registri**, il monitor mostra le azioni della sessione:
+ **Sincronizzazione degli allegati**: copia gli allegati del processo di input o installa un file system virtuale.
+ **Avvia Conda** — The Queue Environment Action. Il processo di compilazione non specifica i pacchetti conda, quindi questa azione termina rapidamente.
+ **Launch CondaBuild Env**: crea un ambiente virtuale conda con il software necessario per creare un pacchetto conda e reindicizzare un canale.
+ **Task run**: crea il pacchetto e carica i risultati su Amazon S3.
Man mano che le azioni vengono eseguite, inviano i log ad Amazon CloudWatch (CloudWatch). Quando un lavoro è completo, seleziona **Visualizza i registri di tutte le attività per** visualizzare registri aggiuntivi sulla configurazione e lo smontaggio dell'ambiente.