Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Création d'un canal conda à l'aide de S3
Si vos tâches doivent exécuter des applications non disponibles sur les [https://conda-forge.org/](https://conda-forge.org/)canaux [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, vous pouvez héberger un canal conda personnalisé pour diffuser vos propres packages. Lorsque vous créez une file d'attente dans la console AWS Deadline Cloud (Deadline Cloud), la console ajoute un environnement de file d'attente conda par défaut. Pour que vos packages soient disponibles pour les tâches, ajoutez le canal personnalisé à l'environnement de file d'attente.
Un canal conda est un contenu hébergé statique que vous pouvez héberger [de différentes manières](https://rattler-build.prefix.dev/latest/publish/), notamment sur un système de fichiers ou dans un bucket Amazon Simple Storage Service (Amazon S3). Si votre ferme Deadline Cloud utilise un système de fichiers partagé pour les ressources, vous pouvez utiliser n'importe quel chemin comme nom de canal. Vous pouvez héberger le canal dans un compartiment Amazon S3 pour un accès plus large à l'aide des autorisations Gestion des identités et des accès AWS (IAM).
Vous pouvez [créer et tester des packages localement](build-test-packages-locally.md), puis [les publier sur une chaîne](publish-packages-s3-channel.md). La création de packages localement est un moyen facile de commencer à itérer sur des recettes de construction de packages sans configuration d'infrastructure. Vous pouvez également utiliser une [file d'attente de création de packages](automate-package-builds.md) Deadline Cloud pour créer des packages et les publier sur une chaîne. Une file d'attente de création de packages simplifie la maintenance des packages pour plusieurs systèmes d'exploitation et configurations d'accélérateurs. Vous pouvez mettre à jour les versions et soumettre des ensembles complets de compilations de packages où que vous soyez.
Vous pouvez configurer les chaînes pour votre studio et votre ferme Deadline Cloud de différentes manières. Vous pouvez avoir un canal Amazon S3 et configurer tous vos postes de travail et hôtes de ferme pour qu'ils l'utilisent. Vous pouvez également avoir plusieurs canaux et configurer la mise en miroir avec AWS DataSync (DataSync). Par exemple, la file d'attente de création de votre package Deadline Cloud peut être publiée sur un canal Amazon S3 qui est reproduit sur site pour les postes de travail et les hôtes de ferme sur site.
**Topics**
+ [Créez et testez des packages localement](build-test-packages-locally.md)
+ [Publier des packages sur un canal conda Amazon S3](publish-packages-s3-channel.md)
+ [Configurer les autorisations de file d'attente de production pour les packages conda personnalisés](#s3-channel-configure-permissions)
+ [Ajouter un canal conda à un environnement de file d'attente](#s3-channel-add-channel)
+ [Création d'un package conda pour une application ou un plugin](conda-package.md)
+ [Créez une recette de construction de conda pour Blender](create-conda-recipe-blender.md)
+ [Créez une recette de construction de conda pour Autodesk Maya](create-conda-recipe-maya.md)
+ [Créez une recette de construction conda pour le plugin Autodesk Maya to Arnold (MtoA)](create-conda-recipe-mtoa-plugin.md)
+ [Automatisez la création de packages avec Deadline Cloud](automate-package-builds.md)
# Créez et testez des packages localement
Avant de publier des packages sur Amazon S3 ou de configurer CI/CD l'automatisation sur votre ferme Deadline Cloud, vous pouvez créer et tester des packages conda sur votre poste de travail à l'aide d'un canal de système de fichiers local. Cette approche vous permet d'itérer rapidement localement sur les recettes et de vérifier les packages.
La `rattler-build publish` commande crée une recette, copie le package obtenu sur un canal et indexe le canal en une seule étape. Lorsque vous ciblez un répertoire de système de fichiers local, `rattler-build` crée et initialise le canal automatiquement si le répertoire n'existe pas.
Les instructions suivantes utilisent l'exemple de recette Blender 4.5 provenant du référentiel d'[exemples de Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples) surGitHub. Vous pouvez remplacer une recette différente depuis le référentiel d'échantillons ou utiliser votre propre recette.
## Conditions préalables
Avant de commencer, installez les outils suivants sur votre poste de travail :
+ **pixi** — Un gestionnaire de paquets que vous utilisez pour installer `rattler-build` et tester des packages. Installez pixi depuis [pixi.sh](https://pixi.sh).
+ **rattler-build** — L'outil de création de packages utilisé par Deadline Cloud Conda Recipes. Après avoir installé Pixi, exécutez la commande suivante pour effectuer l'installation`rattler-build`.
```
pixi global install rattler-build
```
+ **git** — Nécessaire pour cloner le dépôt d'échantillons. WindowsActivé, [git for](https://gitforwindows.org/) fournit Windows également un `bash` shell, ce dont certains Windows exemples de recettes ont besoin.
## Création et publication d'un package sur une chaîne locale
Dans cette procédure, vous clonez le référentiel d'échantillons de Deadline Cloud et vous l'utilisez `rattler-build publish` pour créer et publier le package sur un canal de système de fichiers local.
**Pour créer et publier un package sur une chaîne locale**
1. Clonez le référentiel d'échantillons de Deadline Cloud.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Passez au répertoire `conda_recipes`.
```
cd deadline-cloud-samples/conda_recipes
```
1. Exécutez la commande suivante pour créer la recette Blender 4.5 et publier le package dans un répertoire de canaux local.
LinuxActivé macOS et exécutez la commande suivante.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to file://$HOME/my-conda-channel
```
Sur Windows (cmd), exécutez la commande suivante.
```
rattler-build publish blender-4.5/recipe/recipe.yaml ^
--to file://%USERPROFILE%/my-conda-channel
```
La `rattler-build publish` commande exécute les actions suivantes :
+ Construit le package à partir de la recette.
+ Crée le répertoire des chaînes s'il n'existe pas.
+ Copie le fichier du package sur le canal.
+ Indexe le canal afin que les gestionnaires de packages puissent le trouver.
Si la recette de votre package dépend de packages provenant d'un canal particulier, tel que [conda-forge](https://conda-forge.org/), ajoutez-le `-c conda-forge` à la commande.
Pour reconstruire le package après avoir apporté des modifications à la recette, ajoutez-le `--build-number=+1` pour incrémenter automatiquement le numéro de version.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to file://$HOME/my-conda-channel \
--build-number=+1
```
Pour plus d'informations`rattler-build publish`, consultez la documentation de publication de [Rattler-build](https://rattler-build.prefix.dev/latest/publish/).
## Débogage des versions
En cas d'échec d'une compilation, `rattler-build` préserve le répertoire de compilation afin que vous puissiez l'examiner. Exécutez la commande suivante pour ouvrir un shell interactif dans l'environnement de construction avec toutes les variables d'environnement configurées telles qu'elles étaient lors de la génération.
```
rattler-build debug shell
```
À partir du shell de débogage, vous pouvez modifier des fichiers, exécuter des commandes de compilation individuelles et ajouter des dépendances pour isoler le problème. Pour plus d'informations, consultez la section [Débogage des versions](https://rattler-build.prefix.dev/latest/debugging_builds/) dans la documentation de Rattler-build.
## Tester le package
Après avoir créé et publié le package, créez un projet pixi temporaire. Utilisez le projet pour installer le package depuis le canal local et vérifiez qu'il fonctionne correctement.
**Pour tester le package**
1. Créez un répertoire de test temporaire et initialisez un projet pixi avec le canal local.
LinuxActivez macOS et exécutez les commandes suivantes.
```
mkdir package-test-env
cd package-test-env
pixi init --channel file://$HOME/my-conda-channel
```
Sur Windows (cmd), exécutez les commandes suivantes.
```
mkdir package-test-env
cd package-test-env
pixi init --channel file://%USERPROFILE%/my-conda-channel
```
1. Ajoutez le package au projet.
```
pixi add blender=4.5
```
1. Vérifiez que le package fonctionne correctement.
```
pixi run blender --version
```
Lorsque vous êtes satisfait du package, vous pouvez le publier sur un canal conda Amazon S3 afin que les employés de Deadline Cloud puissent l'installer. Voir [Publier des packages sur un canal conda S3](publish-packages-s3-channel.md).
## Nettoyage
Après le test, vous pouvez supprimer le projet de test et le canal local.
**Pour nettoyer les ressources de test**
1. Supprimez le répertoire du projet de test.
LinuxActivé macOS et exécutez la commande suivante.
```
rm -rf package-test-env
```
Sur Windows (cmd), exécutez la commande suivante.
```
rmdir /s /q package-test-env
```
1. Supprimez le répertoire local des chaînes Conda.
LinuxActivé macOS et exécutez la commande suivante.
```
rm -rf $HOME/my-conda-channel
```
Sur Windows (cmd), exécutez la commande suivante.
```
rmdir /s /q %USERPROFILE%\my-conda-channel
```
1. (Facultatif) Supprimez le répertoire `rattler-build` de sortie qui contient le fichier de package créé.
LinuxActivé macOS et exécutez la commande suivante.
```
rm -rf deadline-cloud-samples/conda_recipes/output
```
Sur Windows (cmd), exécutez la commande suivante.
```
rmdir /s /q deadline-cloud-samples\conda_recipes\output
```
# Publier des packages sur un canal conda Amazon S3
Vous pouvez publier des packages conda dans un bucket Amazon Simple Storage Service (Amazon S3) afin AWS que les employés de Deadline Cloud (Deadline Cloud) puissent les installer pour exécuter des tâches. La `rattler-build publish` commande fonctionne avec Amazon S3 de la même manière qu'avec un canal de système de fichiers local. La commande peut créer une recette et publier le résultat, ou publier un fichier de package que vous avez déjà créé. Dans les deux cas, la commande télécharge le package dans le bucket et indexe le canal en une seule étape.
La `rattler-build publish` commande s'authentifie à AWS l'aide de la chaîne d'identification standard. Elle utilise donc votre AWS configuration comme n'importe quel AWS outil. Pour plus d'informations sur la configuration des informations d'identification, consultez [la section Configuration et paramètres du fichier d'informations d'identification](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) dans le *guide de l'utilisateur AWS Command Line Interface (AWS CLI)*.
## Conditions préalables
Avant de publier des packages sur Amazon S3, remplissez les conditions préalables suivantes :
+ **pixi et rattler-build** [— Installez pixi depuis pixi.sh, puis installez-le.](https://pixi.sh) `rattler-build`
```
pixi global install rattler-build
```
+ **git** — Nécessaire pour cloner le dépôt d'échantillons. WindowsActivé, [git for](https://gitforwindows.org/) fournit Windows également un `bash` shell, ce dont certains Windows exemples de recettes ont besoin.
+ Compartiment **Amazon S3** : compartiment Amazon S3 à utiliser comme canal conda. Vous pouvez utiliser le compartiment des pièces jointes à des tâches de votre ferme Deadline Cloud ou créer un compartiment distinct.
+ **AWS informations d'identification** — Configurez les informations d'identification sur votre poste de travail à l'aide de la `aws configure` commande ou de la `aws login` commande. Pour plus d'informations, consultez [Configuration de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-quickstart.html) dans le *Guide de l'utilisateur AWS Command Line Interface *.
+ **Autorisations IAM** — (Facultatif) Pour réduire l'étendue des autorisations dont disposent vos informations d'identification, vous pouvez utiliser une politique Gestion des identités et des accès AWS (IAM) qui n'accorde que les autorisations suivantes sur le compartiment Amazon S3 et le préfixe de canal que vous utilisez (par exemple,) : `/Conda/*`
+ `s3:GetObject`
+ `s3:PutObject`
+ `s3:DeleteObject`
+ `s3:ListBucket`
+ `s3:GetBucketLocation`
## Publication d'un package sur un canal Amazon S3
À utiliser `rattler-build publish` avec une `s3://` cible pour publier un package sur votre canal conda Amazon S3. Si le canal n'existe pas dans le compartiment, `rattler-build` initialise le canal automatiquement. Avant de commencer, assurez-vous d'avoir rempli les [prérequis](#publish-s3-prereqs).
L'exemple suivant publie l'exemple de recette Blender 4.5 à partir du référentiel d'[échantillons de Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples) surGitHub. Vous pouvez remplacer une recette différente depuis le référentiel d'échantillons ou utiliser votre propre recette.
**Pour publier un package sur un canal Amazon S3**
1. Clonez le référentiel d'échantillons de Deadline Cloud.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Passez au répertoire `conda_recipes`.
```
cd deadline-cloud-samples/conda_recipes
```
1. Exécutez la commande suivante. *amzn-s3-demo-bucket*Remplacez-le par le nom de votre compartiment.
LinuxActivé macOS et exécutez la commande suivante.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to s3://amzn-s3-demo-bucket/Conda/Default
```
Sur Windows (cmd), exécutez la commande suivante.
```
rattler-build publish blender-4.5/recipe/recipe.yaml ^
--to s3://amzn-s3-demo-bucket/Conda/Default
```
Le `/Conda/Default` préfixe organise le canal au sein du bucket. Vous pouvez utiliser un préfixe différent, mais celui-ci doit être cohérent dans toutes les commandes et configurations de file d'attente qui font référence au canal.
Pour reconstruire et publier un package mis à jour, ajoutez-le `--build-number=+1` pour incrémenter automatiquement le numéro de version.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to s3://amzn-s3-demo-bucket/Conda/Default \
--build-number=+1
```
Si la recette de votre package dépend de packages provenant d'un canal particulier, tel que [conda-forge](https://conda-forge.org/), ajoutez-le `-c conda-forge` à la commande.
Vous pouvez également publier un fichier de package que vous avez déjà créé, par exemple un `.conda` fichier issu d'une version locale. *amzn-s3-demo-bucket*Remplacez-le par le nom de votre compartiment.
```
rattler-build publish output/linux-64/blender-4.5.0-hb0f4dca_0.conda \
--to s3://amzn-s3-demo-bucket/Conda/Default
```
## Tester le package
Après avoir publié le package, créez un projet pixi temporaire pour vérifier que le package fonctionne correctement. Le projet installe le package depuis le canal Amazon S3.
**Pour tester le package**
1. Créez un répertoire de test temporaire et initialisez un projet pixi avec le canal Amazon S3. *amzn-s3-demo-bucket*Remplacez-le par le nom de votre compartiment.
```
mkdir package-test-env
cd package-test-env
pixi init --channel s3://amzn-s3-demo-bucket/Conda/Default
```
1. Ajoutez le package au projet.
```
pixi add blender=4.5
```
1. Vérifiez que le package fonctionne correctement.
```
pixi run blender --version
```
## Nettoyage
Après le test, supprimez le répertoire du projet de test.
**Pour nettoyer les ressources de test**
+ Supprimez le répertoire du projet de test.
LinuxActivé macOS et exécutez la commande suivante.
```
rm -rf package-test-env
```
Sur Windows (cmd), exécutez la commande suivante.
```
rmdir /s /q package-test-env
```
## Débogage des versions
En cas d'échec d'une compilation, `rattler-build` préserve le répertoire de compilation afin que vous puissiez l'examiner. Exécutez la commande suivante pour ouvrir un shell interactif dans l'environnement de construction avec toutes les variables d'environnement configurées telles qu'elles étaient lors de la génération.
```
rattler-build debug shell
```
À partir du shell de débogage, vous pouvez modifier des fichiers, exécuter des commandes de compilation individuelles et ajouter des dépendances pour isoler le problème. Pour plus d'informations, consultez la section [Débogage des versions](https://rattler-build.prefix.dev/latest/debugging_builds/) dans la documentation de Rattler-build.
## Création de packages pour d'autres plateformes
La `rattler-build publish` commande crée des packages pour le système d'exploitation du poste de travail sur lequel elle est exécutée. Si votre flotte Deadline Cloud utilise un système d'exploitation différent de celui de votre poste de travail, ou si votre package a d'autres exigences en matière d'hôte, vous disposez des options suivantes :
+ Exécutez `rattler-build publish` sur un hôte correspondant au système d'exploitation cible. Par exemple, utilisez une instance Amazon Elastic Compute Cloud (Amazon EC2) Linux exécutée pour créer des packages pour une flotte. Linux
+ Utilisez une file d'attente de création de packages Deadline Cloud pour automatiser les builds sur la plateforme cible. Voir [Création d'une file d'attente pour la création de packages](automate-package-builds.md#s3-channel-create-queue).
+ (Avancé) Utilisez la compilation croisée pour créer des packages pour une plate-forme différente de celle de votre poste de travail. Pour plus d'informations, consultez la section [Compilation croisée](https://rattler-build.prefix.dev/latest/compilers/#cross-compilation) dans la documentation de Rattler-build.
## Étapes suivantes
Après avoir publié des packages sur votre canal Amazon S3 Conda, configurez vos files d'attente Deadline Cloud pour utiliser le canal :
+ [Configurez les autorisations des files d'attente de production pour les packages conda personnalisés](configure-jobs-s3-channel.md#s3-channel-configure-permissions) : accordez à vos files d'attente de production un accès en lecture seule au canal conda Amazon S3.
+ [Ajouter un canal conda à un environnement de file d'attente : configurez l'environnement](configure-jobs-s3-channel.md#s3-channel-add-channel) de file d'attente pour installer des packages à partir du canal conda Amazon S3.
## Configurer les autorisations de file d'attente de production pour les packages conda personnalisés
Votre file d'attente de production a besoin d'autorisations en lecture seule sur le `/Conda` préfixe du compartiment S3 de la file d'attente. Ouvrez la page Gestion des identités et des accès AWS (IAM) du rôle associé à la file d'attente de production et modifiez la politique comme suit :
1. Ouvrez la console Deadline Cloud et accédez à la page de détails de la file d'attente de création du package.
1. Choisissez le rôle du service de file d'attente, puis choisissez **Modifier la file d'attente**.
1. Accédez à la section **Rôle du service de file d'attente**, puis choisissez **Afficher ce rôle dans la console IAM**.
1. Dans la liste des politiques d'autorisation, choisissez celle qui convient **AmazonDeadlineCloudQueuePolicy**à votre file d'attente.
1. Dans l'onglet **Autorisations**, choisissez **Modifier**.
1. Ajoutez une nouvelle section au rôle de service de file d'attente comme suit. Remplacez *amzn-s3-demo-bucket* et *111122223333* par votre propre bucket et votre propre compte.
```
{
"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"
}
}
},
```
## Ajouter un canal conda à un environnement de file d'attente
Pour utiliser le canal conda S3, vous devez ajouter l'emplacement du `s3://amzn-s3-demo-bucket/Conda/Default` canal au `CondaChannels` paramètre des tâches que vous soumettez à Deadline Cloud. Les émetteurs fournis avec Deadline Cloud fournissent des champs pour spécifier les canaux et les packages Conda personnalisés.
Vous pouvez éviter de modifier chaque tâche en modifiant l'environnement de file d'attente conda pour votre file d'attente de production. Utilisez la procédure suivante.
1. Ouvrez la console Deadline Cloud et accédez à la page de détails de la file d'attente de production.
1. Choisissez l'onglet Environnements.
1. Sélectionnez l'environnement de file d'attente **Conda**, puis choisissez **Modifier**.
1. Choisissez l'**éditeur JSON**, puis dans le script, recherchez la définition du paramètre pour`CondaChannels`.
1. Modifiez la ligne `default: "deadline-cloud"` pour qu'elle commence par le canal conda S3 nouvellement créé :
```
default: "s3://amzn-s3-demo-bucket/Conda/Default deadline-cloud"
```
Les flottes gérées par les services offrent par défaut une priorité de canal flexible à Conda. Pour une tâche demandant `blender=4.2` si la Blender version 4.2 figure à la fois dans la nouvelle chaîne et dans la `deadline-cloud` chaîne, le package sera extrait de la chaîne figurant en premier dans la liste des chaînes. Si aucune version de package spécifiée n'est trouvée dans le premier canal, les canaux suivants seront vérifiés dans l'ordre correspondant à la version du package.
Pour les flottes gérées par le client, vous pouvez activer l'utilisation de packages conda en utilisant l'un des exemples d'[environnement de file d'attente conda dans le référentiel d'exemples](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/README.md) de Deadline Cloud. GitHub
# Création d'un package conda pour une application ou un plugin
Un package conda est une archive compressée de logiciels écrits dans n'importe quelle langue. Conda prend en charge une variété de combinaisons de systèmes d'exploitation et d'architectures, de sorte que vous pouvez empaqueter des applications complètes telles que BlenderMaya, et Nuke parallèlement à des bibliothèques pour Python et d'autres langages. Pour plus d'informations sur les packages conda, consultez la section [Packages](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/packages.html) dans la documentation conda.
Pour utiliser un package conda, vous devez l'installer dans un environnement virtuel. Un environnement virtuel conda possède un *répertoire de préfixes dans* lequel les packages sont installés. L'installation d'un package utilise la création de liens physiques ou de reconnexion de fichiers lorsqu'elle est prise en charge. La création de plusieurs environnements avec les mêmes packages n'utilise donc pas beaucoup d'espace disque supplémentaire. Pour utiliser un environnement virtuel, vous devez l'activer pour définir des variables d'environnement. L'activation exécute les scripts fournis par les packages, donnant à chaque package la possibilité de modifier le PATH ou d'autres variables d'environnement. Les packages Conda contiennent généralement des applications ou des bibliothèques, mais leur activation flexible signifie qu'ils peuvent également pointer vers des applications installées sur un système de fichiers partagé.
La création d'un package personnalisé comporte trois étapes : une *recette* contient les instructions de construction, un *package* est l'artefact (`.conda`ou `.tar.bz2` fichier) généré et un *canal* héberge les packages à installer. La `rattler-build publish` commande gère les trois étapes : elle peut intégrer une recette dans un package et la publier sur une chaîne, ou elle peut utiliser un artefact de package directement pour la publier.
La communauté [conda-forge](https://conda-forge.org/) gère des recettes de packages pour un large éventail de logiciels open source et héberge des artefacts de packages dans la `conda-forge` chaîne. Vous pouvez configurer votre file d'attente pour l'inclure `conda-forge` en tant que source de package, puis créer des packages personnalisés qui dépendent de l'exécution des packages conda-forge. En effetLinux, conda-forge héberge une chaîne d'outils de compilation complète incluant le support CUDA, avec des options de compilation et de liaison cohérentes sélectionnées. Vous pouvez utiliser les packages conda-forge comme dépendances dans vos propres recettes ou les installer avec vos packages personnalisés dans le même environnement.
Vous pouvez combiner une application entière, y compris les dépendances, dans un package conda. Les packages fournis par Deadline Cloud dans le [canal Deadline-Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html#conda-queue-environment) pour les flottes gérées par des services utilisent cette approche de reconditionnement binaire. Cela permet d'organiser les mêmes fichiers qu'une installation pour les adapter à l'environnement virtuel de Conda.
**Note**
Les applications volumineuses peuvent nécessiter des dizaines de Go d'espace disque libre pour l'archive source, les fichiers extraits et la sortie de compilation. Assurez-vous d'utiliser un disque avec suffisamment d'espace disponible pour la sortie de génération du package.
## Package d'une application
Lorsque vous reconditionnez une application pour conda, vous avez deux objectifs :
+ La plupart des fichiers de l'application doivent être séparés de la structure principale de l'environnement virtuel Conda. Les environnements peuvent ensuite mélanger l'application avec des packages provenant d'autres sources telles que [conda-forge](https://conda-forge.org/).
+ Lorsqu'un environnement virtuel conda est activé, l'application doit être disponible à partir de la variable d'environnement PATH.
**Pour reconditionner une application pour conda**
1. Écrivez des recettes de construction conda qui installent l'application dans un sous-répertoire tel que. `$CONDA_PREFIX/opt/` Cela le sépare des répertoires de préfixes standard tels que `bin` et`lib`.
1. Ajoutez des liens symboliques ou lancez des scripts `$CONDA_PREFIX/bin` pour exécuter les fichiers binaires de l'application.
Vous pouvez également créer des scripts .d activés que la `conda activate` commande exécutera pour ajouter les répertoires binaires de l'application au PATH. Si Windows les liens symboliques ne sont pas pris en charge partout où des environnements peuvent être créés, utilisez plutôt des scripts de lancement ou d'activation d'applications.
1. Certaines applications dépendent de bibliothèques qui ne sont pas installées par défaut sur les flottes gérées par le service Deadline Cloud. Par exemple, le système de fenêtres X11 n'est généralement pas nécessaire pour les tâches non interactives, mais certaines applications nécessitent tout de même qu'il s'exécute sans interface graphique. Vous devez fournir ces dépendances dans le package que vous créez.
1. Si l'application prend en charge les plug-ins, indiquez une convention claire que les packages de plugins doivent suivre pour s'intégrer à l'application dans un environnement virtuel. Par exemple, l'[exemple de recette Maya 2026](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-2026#instructions-for-maya-plugin-packages) documente cette convention pour les Maya plugins.
1. Assurez-vous de respecter les droits d'auteur et les contrats de licence pour les applications que vous créez. Nous vous recommandons d'utiliser un compartiment Amazon S3 privé pour votre canal Conda afin de contrôler la distribution et de limiter l'accès aux packages à votre ferme.
Des exemples de recettes pour les packages de la `deadline-cloud` chaîne sont disponibles dans le référentiel d'[exemples de Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes#readme) surGitHub.
## Package d'un plugin
Les plugins d'application peuvent être empaquetés sous la forme de leurs propres packages conda. Lorsque vous créez un package de plug-in, suivez les instructions suivantes :
+ Incluez le package de l'application hôte en tant que dépendance de compilation et d'exécution dans la recette de génération`recipe.yaml`. Utilisez une contrainte de version afin que la recette de construction ne soit installée qu'avec des packages compatibles.
+ Respectez les conventions du package de l'application hôte pour enregistrer le plug-in.
## Packs d'adaptateurs
Certaines intégrations d'applications Deadline Cloud utilisent un *adaptateur* qui étend l'interface de l'application afin de simplifier la [rédaction de modèles de tâches](building-jobs.md). Un adaptateur est une interface de ligne de commande qui permet d'exécuter un démon en arrière-plan, de signaler l'état et d'appliquer le mappage de chemins. Pour plus d'informations, reportez-vous à la section [Open Job Description Adaptor Runtime](https://github.com/OpenJobDescription/openjd-adaptor-runtime-for-python#readme) surGitHub. Par exemple, [deadline-cloud-for-maya](https://github.com/aws-deadline/deadline-cloud-for-maya/)on GitHub inclut une interface graphique intégrée de soumission de tâches et un Maya adaptateur disponible sous forme de `maya-openjd` package sur les flottes gérées par des services.
Les soumissions de tâches depuis Deadline Cloud Submitter GUIs incluent une valeur de `CondaPackages` paramètre qui spécifie les packages conda à inclure dans un environnement virtuel pour exécuter la tâche. La valeur du `CondaPackages` paramètre pour ressemble Maya généralement à des entrées alternatives pour les packages de plugins `maya=2025.* maya-openjd=0.15.* maya-mtoa` et peut contenir ces entrées. Lorsque l'environnement de file d'attente configure un environnement virtuel conda pour exécuter le travail, il résout ces noms de packages et ces contraintes de version pour qu'ils soient compatibles et ajoute tous les packages de dépendance dont ils ont besoin pour s'exécuter. Chaque package d'adaptateur et de plugin indique ce avec quoi il est compatible, y compris les versions de PythonMaya, les versions de Python et les autres dépendances.
[Pour créer vos propres packages adaptateurs à l'aide de nos exemples tels que la [recette maya-openjd](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-openjd) onGitHub, vous pouvez utiliser les packages pour Python et d'autres dépendances fournis par conda-forge.](https://conda-forge.org/) Vous devrez peut-être d'abord créer la [date limite](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/deadline) et les [openjd-adaptor-runtime](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/openjd-adaptor-runtime)recettes pour satisfaire les dépendances.
# Créez une recette de construction de conda pour Blender
Vous pouvez utiliser différentes applications pour créer une recette de construction conda. Blenderest gratuit et facile à emballer avec conda. La Blender Fondation fournit des [archives d'applications](https://download.blender.org/release/Blender4.2/) pour plusieurs systèmes d'exploitation. Nous avons créé un exemple de recette de compilation de conda qui utilise les fichiers .zip pour Windows et .tar.xz pour Linux. Dans cette section, découvrez comment utiliser la [recette de construction de conda Blender 4.2](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2).
Le fichier [deadline-cloud.yaml](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2) spécifie les plateformes conda et les autres métadonnées permettant de soumettre des tâches de package à Deadline Cloud. Cette recette inclut des informations d'archives de sources locales pour montrer comment cela fonctionne. La plate-forme Conda Linux-64 est configurée pour intégrer une soumission de tâche par défaut correspondant à la configuration la plus courante. Le fichier deadline-cloud.yaml ressemble à ce qui suit :
```
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"'
```
Passez en revue les fichiers du `recipe` répertoire. Les métadonnées de la recette se trouvent dans [recipe/recipe.yaml](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2/recipe/recipe.yaml). Vous pouvez également lire la documentation [meta.yaml](https://docs.conda.io/projects/conda-build/en/latest/resources/define-metadata.html) de conda build pour en savoir plus, notamment en quoi le fichier est un modèle pour générer du YAML. Le modèle est utilisé pour spécifier le numéro de version une seule fois et pour fournir différentes valeurs en fonction du système d'exploitation.
Vous pouvez consulter les options de construction sélectionnées `meta.yaml` pour désactiver diverses vérifications de relocalisation binaire et de liaison d'objets partagés dynamiques (DSO). Ces options contrôlent le fonctionnement du package lorsqu'il est installé dans un environnement virtuel Conda, quel que soit le préfixe de répertoire. Les valeurs par défaut simplifient l'empaquetage de chaque bibliothèque de dépendances dans un package distinct, mais lors du reconditionnement binaire d'une application, vous devez les modifier.
Si l'application que vous empaquetez nécessite des bibliothèques de dépendances supplémentaires ou si vous empaquetez des plug-ins pour une application séparément, vous risquez de rencontrer des erreurs DSO. Ces erreurs se produisent lorsque la dépendance ne figure pas dans le chemin de recherche de la bibliothèque pour l'exécutable ou la bibliothèque qui en a besoin. Les applications reposent sur le fait que les bibliothèques se trouvent dans des chemins définis globalement`/usr/lib`, par exemple `/lib` ou lorsqu'elles sont installées sur un système. Cependant, comme les environnements virtuels conda peuvent être placés n'importe où, il n'y a pas de chemin absolu à utiliser. Conda utilise des fonctionnalités RPATH relatives, qui sont à la fois compatibles Linux et prises macOS en charge, pour gérer cela. Reportez-vous à la documentation de construction de conda sur la [relocalisation des packages pour plus d'informations](https://docs.conda.io/projects/conda-build/en/latest/resources/make-relocatable.html).
Blenderne nécessite aucun ajustement RPATH, car les archives de l'application ont été créées dans cette optique. Pour les applications qui en ont besoin, vous pouvez utiliser les mêmes outils que conda build : sur Linux et `patchelf` `install_name_tool` sur macOS d'autres.
Lors de la création du package, le 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) (appelé par`bld.bat`) s'exécute pour installer les fichiers dans un environnement préparé avec les dépendances du package. Ces scripts copient les fichiers d'installation, créent des liens symboliques à partir de `$PREFIX/bin` ceux-ci et configurent les scripts d'activation. WindowsActivé, il ne crée pas de liens symboliques mais ajoute le répertoire Blender au PATH dans le script d'activation.
Nous utilisons `bash` plutôt un fichier `cmd.exe` .bat pour la Windows partie de la recette de construction de conda, car cela permet une plus grande cohérence entre les scripts de construction. Consultez les recommandations du [guide du développeur de Deadline Cloud sur la](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/what-is-a-deadline-cloud-workload.html#workload-portability) portabilité de la charge de travail pour obtenir des conseils `bash` d'utilisationWindows. Si vous avez installé [git for Windows pour](https://gitforwindows.org/) cloner le dépôt [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/)git, vous y avez déjà accès`bash`.
La documentation des [variables d'environnement de construction de conda](https://docs.conda.io/projects/conda-build/en/latest/user-guide/environment-variables.html) répertorie les valeurs disponibles pour une utilisation dans le script de construction. Ces valeurs incluent `$SRC_DIR` les données d'archive source, `$PREFIX` le répertoire d'installation, l'accès `$RECIPE_DIR` à d'autres fichiers à partir de la recette, le nom `$PKG_NAME` et `$PKG_VERSION` la version du package, ainsi `$target_platform` que la plate-forme conda cible.
## Soumettre le package job Blender 4.2
Vous pouvez créer votre propre package conda Blender 4.2 pour générer des tâches, en téléchargeant l'Blenderarchive puis en soumettant une tâche à la file d'attente de création du package. La file d'attente envoie le travail à la flotte associée pour créer le package et réindexer le canal conda.
Ces instructions utilisent git depuis un shell compatible avec Bash pour obtenir une tâche de création de package OpenJD et des recettes de conda depuis le référentiel d'exemples de [Deadline](https://github.com/aws-deadline/deadline-cloud-samples) Cloud. GitHub Vous avez également besoin des éléments suivants :
+ Si vous l'utilisezWindows, une version de bash, git BASH, est installée lors de l'installation de git.
+ La [CLI Deadline Cloud](https://github.com/aws-deadline/deadline-cloud) doit être installée.
+ Vous devez être connecté au [moniteur Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/working-with-deadline-monitor.html).
1. Ouvrez l'interface graphique de configuration de Deadline Cloud à l'aide de la commande suivante et définissez le parc et la file d'attente par défaut sur la file d'attente de création de votre package.
```
deadline config gui
```
1. Utilisez la commande suivante pour cloner le GitHUb référentiel d'échantillons de Deadline Cloud.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Accédez au `conda_recipes` répertoire dans le `deadline-cloud-samples` répertoire.
```
cd deadline-cloud-samples/conda_recipes
```
1. Exécutez le script appelé`submit-package-job`. Le script fournit des instructions pour Blender le téléchargement lors de sa première exécution.
```
./submit-package-job blender-4.2/
```
1. Suivez les instructions de téléchargementBlender. Lorsque vous avez l'archive, réexécutez le `submit-package-job` script.
```
./submit-package-job blender-4.2/
```
Après avoir soumis la tâche, utilisez le moniteur Deadline Cloud pour voir la progression et le statut de la tâche au fur et à mesure de son exécution.
Le coin inférieur gauche de l'écran montre les deux étapes de la tâche, à savoir la création du package, puis la réindexation. Le coin inférieur droit indique les différentes étapes de chaque tâche. Dans cet exemple, chaque tâche comporte une étape.
![\[Le moniteur Deadline Cloud indiquant la progression et le statut d'une tâche de création du Blender package.\]](http://docs.aws.amazon.com/fr_fr/deadline-cloud/latest/developerguide/images/Conda-Figure3.png)
Dans le coin inférieur gauche du moniteur se trouvent les deux étapes du travail : créer le package puis réindexer le canal conda. En bas à droite se trouvent les tâches individuelles pour chaque étape. Dans cet exemple, il n'y a qu'une seule tâche pour chaque étape.
Lorsque vous cliquez avec le bouton droit sur la tâche correspondant à l'étape de création du package et que vous choisissez **Afficher les journaux**, le moniteur affiche une liste des actions de session indiquant comment la tâche est planifiée pour le travailleur. Les actions sont les suivantes :
+ **Synchroniser les pièces jointes** : cette action copie les pièces jointes d'entrée ou monte un système de fichiers virtuel, selon le paramètre utilisé pour le système de fichiers des pièces jointes aux tâches.
+ **Lancer Conda** — Cette action provient de l'environnement de file d'attente ajouté par défaut lors de la création de la file d'attente. La tâche ne spécifie aucun package conda, elle se termine donc rapidement et ne crée pas d'environnement virtuel conda.
+ **Launch CondaBuild Env** — Cette action crée un environnement virtuel Conda personnalisé qui inclut le logiciel nécessaire pour créer un package Conda et réindexer un canal. Il s'installe depuis le canal [conda-forge](https://conda-forge.org/).
+ **Exécution de la tâche** : cette action crée le Blender package et télécharge les résultats sur Amazon S3.
Au fur et à mesure que les actions s'exécutent, elles envoient des journaux dans un format structuré à Amazon CloudWatch. Lorsqu'une tâche est terminée, sélectionnez **Afficher les journaux de toutes les tâches pour** voir les journaux supplémentaires relatifs à la configuration et au démantèlement de l'environnement dans lequel la tâche s'exécute.
# Testez votre package avec une tâche de rendu Blender 4.2
Une fois le package Blender 4.2 créé et votre file d'attente de production configurée pour utiliser le canal conda S3, vous pouvez soumettre des tâches à afficher avec le package. Si vous n'avez pas de Blender scène, téléchargez la scène Blender 3.5 - Cozy Kitchen depuis la page [des fichiers de Blender démonstration](https://www.blender.org/download/demo-files).
Le GitHub référentiel d'exemples de Deadline Cloud que vous avez téléchargé précédemment contient un exemple de tâche permettant de rendre une Blender scène à l'aide des commandes suivantes :
```
deadline bundle submit blender_render \
-p CondaPackages=blender=4.2 \
-p BlenderSceneFile=/path/to/downloaded/blender-3.5-splash.blend \
-p Frames=1
```
Vous pouvez utiliser le moniteur Deadline Cloud pour suivre l'avancement de votre travail :
1. Sur le moniteur, sélectionnez la tâche correspondant au travail que vous avez soumis, puis sélectionnez l'option permettant d'afficher le journal.
1. Sur le côté droit de la vue du journal, sélectionnez l'action **Lancer la session Conda**.
Vous pouvez voir que l'action a recherché Blender 4.2 dans les deux canaux conda configurés pour l'environnement de file d'attente, et qu'elle a trouvé le package dans le canal S3.
# Créez une recette de construction de conda pour Autodesk Maya
Vous pouvez empaqueter des applications commerciales sous forme de packages conda. Dans [Create a conda build recipe for Blender](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/conda-package.html#create-conda-recipe-blender), vous avez appris à empaqueter une application disponible sous la forme d'un simple fichier d'archive relocalisable et selon les termes d'une licence open source. Les applications commerciales sont souvent distribuées par le biais d'installateurs et peuvent fonctionner avec un système de gestion des licences.
La liste suivante s'appuie sur les principes de base abordés dans la section [Créer un package conda pour une application ou un plugin](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/conda-package.html), avec les exigences généralement associées à l'empaquetage d'applications commerciales. Les détails figurant dans les sous-points illustrent la manière dont vous pouvez appliquer les directives à. Maya
+ Comprenez les droits de licence et les restrictions de l'application. Vous devrez peut-être configurer un système de gestion des licences. Lorsque l'application ne prévoit pas d'application, vous devrez configurer votre ferme conformément à vos droits.
+ Lisez la [FAQ sur les avantages de l'Autodeskabonnement concernant les droits](https://www.autodesk.com/support/technical/article/caas/sfdcarticles/sfdcarticles/Subscription-Benefits-FAQ-Cloud-Rights.html) liés au cloud pour comprendre quels droits liés au cloud peuvent Maya s'appliquer à vous. Configurez votre ferme Deadline Cloud selon vos besoins.
+ Autodeskles produits s'appuient sur un fichier appelé`ProductInformation.pit`. La plupart des configurations de ce fichier nécessitent un accès administrateur au système, ce qui n'est pas disponible sur les flottes gérées par des services. Les fonctionnalités du produit destinées aux clients légers constituent un moyen relocalisable de gérer ce problème. Consultez [Thin Client Licensing for Maya et MotionBuilder](https://www.autodesk.com/support/technical/article/caas/tsarticles/ts/2zqRBCuGDrcPZDzULJQ27p.html) pour en savoir plus.
+ Certaines applications dépendent de bibliothèques qui ne sont pas installées sur des hôtes de parc gérés par des services. Le package devra donc les fournir. Cela peut se trouver directement dans le package d'application ou placé dans un package de dépendance distinct.
+ Mayadépend d'un certain nombre de ces bibliothèques, notamment freetype et fontconfig. Lorsque ces bibliothèques sont disponibles dans le gestionnaire de packages système, par exemple dans `dnf` for AL2023, vous pouvez les utiliser comme source pour l'application. Comme ces packages RPM ne sont pas conçus pour être relocalisables, vous devrez utiliser des outils tels que pour vous `patchelf` assurer que les dépendances sont résolues dans le préfixe Maya d'installation.
+ L'installation peut nécessiter un accès administrateur. Étant donné que les flottes gérées par des services ne fournissent pas d'accès administrateur, vous devrez effectuer une installation sur un système doté de cet accès. Créez ensuite une archive des fichiers nécessaires à l'utilisation de la tâche de création du package.
+ Le Windows programme d'installation de Maya nécessite un accès administrateur. La création du package conda correspondant implique donc un processus manuel pour créer d'abord une telle archive.
+ La configuration de l'application, y compris la manière dont les plugins s'y enregistrent, peut être définie au niveau du système d'exploitation ou de l'utilisateur. Lorsqu'ils sont placés dans un environnement virtuel conda, les plugins ont besoin d'un moyen de s'intégrer à l'application de manière contenue et de ne jamais écrire de fichiers ou d'autres données en dehors du préfixe de l'environnement virtuel. Nous vous suggérons de le configurer à partir du package conda de l'application.
+ L'exemple de Maya package définit la variable d'environnement `MAYA_NO_HOME=1` pour l'isoler de la configuration au niveau de l'utilisateur, et ajoute des chemins de recherche de modules `MAYA_MODULE_PATH` afin que les plug-ins fournis séparément puissent s'intégrer depuis l'environnement virtuel. L'exemple de MtoA package place un fichier .mod dans l'un de ces répertoires pour le charger au Maya démarrage.
**Écrire les métadonnées de la recette**
1. Ouvrez le répertoire GitHub [ deadline-cloud-samples/conda\$1recipes/maya-2025](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-2025) dans votre navigateur ou dans un éditeur de texte de votre clone local du dépôt.
Le fichier `deadline-cloud.yaml` décrit les plateformes de construction conda pour lesquelles créer des packages et d'où obtenir l'application. L'exemple de recette spécifie à la fois Linux et Windows construit, et il n'Linuxest soumis que par défaut.
1. Téléchargez les programmes d'Mayainstallation complets depuis votre Autodesk identifiant. En Linux effet, la compilation du package peut utiliser l'archive directement, alors placez-la directement dans le `conda_recipes/archive_files` répertoire. En effetWindows, le programme d'installation nécessite un accès administrateur pour s'exécuter. Vous devrez exécuter le programme d'installation et collecter les fichiers nécessaires dans une archive pour la recette de package que vous souhaitez utiliser. Le fichier [README.md](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/README.md) de la recette décrit une procédure reproductible pour créer cet artefact. La procédure utilise une instance Amazon EC2 récemment lancée pour fournir un environnement propre pour l'installation, auquel vous pouvez ensuite mettre fin après avoir enregistré le résultat. Pour empaqueter d'autres applications nécessitant un accès administrateur, vous pouvez suivre une procédure similaire une fois que vous avez déterminé l'ensemble de fichiers dont l'application a besoin.
1. Ouvrez les fichiers [recipe/recipe.yaml et [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) pour revoir ou modifier les paramètres de rattler-build et de conda-build. Vous pouvez définir le nom et la version du package pour l'application que vous souhaitez empaqueter.
La section **source** inclut une référence aux archives, y compris le hachage sha256 des fichiers. Chaque fois que vous modifiez ces fichiers, par exemple pour une nouvelle version, vous devez calculer et mettre à jour ces valeurs.
La section **build** contient principalement des options pour désactiver les options de relocalisation binaire par défaut, car les mécanismes automatiques ne fonctionneront pas correctement pour la bibliothèque et les répertoires binaires spécifiques utilisés par le package.
Enfin, la section **À propos** vous permet de saisir des métadonnées sur l'application qui peuvent être utilisées lors de la navigation ou du traitement du contenu d'un canal conda.
**Écrire le script de construction du package**
1. Les scripts de construction de packages contenus dans l'Mayaexemple de recette de construction de conda incluent des commentaires expliquant les étapes effectuées par les scripts. Lisez les commentaires et les commandes pour découvrir ce qui suit :
+ Comment la recette gère le fichier RPM de Autodesk
+ Les modifications appliquées par la recette pour rendre l'installation relocalisable vers les environnements virtuels conda dans lesquels la recette est installée
+ Comment la recette définit les variables utilitaires telles `MAYA_VERSION` que `MAYA_LOCATION` et que votre logiciel peut utiliser pour comprendre son fonctionnement. Maya
1. PourLinux, ouvrez le fichier [recipe/build.sh](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/recipe/build.sh) pour consulter ou modifier le script de création du package.
PourWindows, ouvrez le fichier [recipe/build\$1win.sh](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/recipe/build_win.sh) pour consulter ou modifier le script de création du package.
**Soumettez une tâche qui crée les Maya packages**
1. Entrez le `conda_recipes` répertoire dans votre clone du GitHub [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples)référentiel.
1. Assurez-vous que votre ferme Deadline Cloud est configurée pour votre CLI Deadline Cloud. Si vous avez suivi les étapes de [création d'un canal conda à l'aide d'Amazon S3](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/configure-jobs-s3-channel.html), votre ferme doit être configurée pour votre CLI.
1. Exécutez la commande suivante pour soumettre une tâche qui génère à la fois des Windows packages Linux et des packages.
` ./submit-package-job maya-2025 --all-platforms`
# Créez une recette de construction conda pour le plugin Autodesk Maya to Arnold (MtoA)
Vous pouvez empaqueter des plugins pour des applications commerciales sous forme de packages conda. Les plugins sont des bibliothèques chargées dynamiquement qui utilisent une interface binaire d'application (ABI) fournie par une application pour étendre les fonctionnalités de cette application. Le Maya to Arnold (MtoA) plugin ajoute le Arnold moteur de rendu en tant qu'option. Maya
+ L'MtoAexemple de recette de construction dépend du **Maya**package et utilise une `==` contrainte pour la version.
+ Le Maya package configure un chemin de Maya module dans l'environnement virtuel`$PREFIX/usr/autodesk/maya$MAYA_VERSION/modules`, dans lequel le plugin doit placer un `.mod` fichier. L'MtoAexemple de recette de construction crée un fichier `mtoa.mod` dans ce répertoire.
**Écrire les métadonnées de la recette**
1. Ouvrez le répertoire GitHub [ deadline-cloud-samples/conda\$1recipes/maya-mtoa-2025](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-mtoa-2025) dans votre navigateur ou dans un éditeur de texte de votre clone local du dépôt.
La recette suit les mêmes modèles que la recette de construction de Maya conda et utilise les mêmes archives source pour installer le plugin.
1. Ouvrez les fichiers [recipe/recipe.yaml et [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) pour revoir ou modifier les paramètres de rattler-build et de conda-build. Ces fichiers spécifient une dépendance `maya` pendant la construction du package et lors de la création d'un environnement virtuel pour exécuter le plugin.
**Écrire le script de construction du package**
+ Les scripts de construction de packages contenus dans l'MtoAexemple de recette de construction de conda incluent des commentaires expliquant les étapes effectuées par les scripts. Lisez les commentaires et les commandes pour savoir comment la recette installe MtoA et crée un fichier `mtoa.mod` dans le répertoire spécifié par le Maya package.
Arnoldet Maya utilisez la même technologie de licence, de sorte que la recette de construction de Maya Conda inclut déjà les informations nécessaires àArnold.
Les différences entre les scripts Linux et Windows build sont similaires à celles de la recette Maya conda build.
**Soumettez une tâche qui crée les packages de Maya MtoA plugins**
1. Entrez le `conda_recipes` répertoire dans votre clone du GitHub [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples)référentiel.
1. Vérifiez que vous avez créé des packages pour l'application Maya hôte comme indiqué dans la section précédente.
1. Assurez-vous que votre ferme Deadline Cloud est configurée pour votre CLI Deadline Cloud. Si vous avez suivi les étapes de [création d'un canal conda à l'aide d'Amazon S3](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/configure-jobs-s3-channel.html), votre ferme doit être configurée pour votre CLI.
1. Exécutez la commande suivante pour soumettre une tâche qui génère à la fois des Windows packages Linux et des packages.
` ./submit-package-job maya-mtoa-2025 --all-platforms`
# Testez votre package avec une tâche Maya de rendu
Une fois que vous avez créé le Maya 2025 et les MtoA packages, vous pouvez soumettre des tâches à afficher avec le package. La [plaque tournante avec un](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/turntable_with_maya_arnold) échantillon de lots de Maya/Arnold tâches affiche une animation avec Maya et. Arnold Cet exemple permet également FFmpeg d'encoder une vidéo. Vous pouvez ajouter le canal conda-forge à la liste des canaux par défaut `CondaChannels` dans votre environnement de file d'attente conda afin de fournir une source pour le package. `ffmpeg`
Dans le `job_bundles` répertoire de votre clone git de [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples), exécutez la commande suivante.
```
deadline bundle submit turntable_with_maya_arnold
```
Vous pouvez utiliser le moniteur Deadline Cloud pour suivre l'avancement de votre travail :
1. Sur le moniteur, sélectionnez la tâche correspondant au travail que vous avez soumis, puis sélectionnez l'option permettant d'afficher le journal.
1. Sur le côté droit de la vue du journal, sélectionnez l'action **Lancer la session Conda**.
Vous pouvez voir que l'action a recherché maya et maya-mtoa dans les canaux conda configurés pour l'environnement de file d'attente, et qu'elle a trouvé les packages dans le canal S3.
# Automatisez la création de packages avec Deadline Cloud
Pour les CI/CD flux de travail ou lorsque vous devez créer des packages pour plusieurs systèmes d'exploitation, vous pouvez créer une file d'attente de création de packages Deadline Cloud. Les plannings des files d'attente créent des tâches sur votre flotte, qui crée les packages et les publie sur votre canal conda Amazon Simple Storage Service (Amazon S3). Cela simplifie la gestion continue des compilations de packages pour les versions logicielles dans toutes les configurations requises.
Vous pouvez créer une file d'attente de création de packages à l'aide d'un modèle AWS CloudFormation (CloudFormation) ou manuellement depuis la console Deadline Cloud. Le CloudFormation modèle déploie un parc complet avec une file d'attente de production et une file d'attente de création de packages déjà configurées. La création de la file d'attente depuis la console vous permet de mieux contrôler les paramètres individuels.
## Créez une file d'attente de création de packages avec CloudFormation
Vous pouvez utiliser un CloudFormation modèle pour créer une ferme Deadline Cloud qui inclut une file d'attente pour la création de packages. Le modèle configure une file d'attente de production et une file d'attente de création de packages avec un canal conda privé Amazon S3.
Avant de déployer le modèle, créez un compartiment Amazon S3 contenant les pièces jointes aux tâches et votre canal Conda. Vous pouvez créer un compartiment à partir de la [console Amazon S3](https://console.aws.amazon.com/s3/). Vous avez besoin du nom du compartiment lorsque vous déployez le modèle.
**Pour déployer le CloudFormation modèle**
1. Téléchargez le modèle [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) depuis le référentiel d'exemples de [Deadline](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/starter_farm) Cloud sur. GitHub
1. Dans la [CloudFormation console](https://console.aws.amazon.com/cloudformation/), choisissez **Create Stack**, puis **Avec de nouvelles ressources (standard)**.
1. Sélectionnez l'option permettant de télécharger un fichier modèle, puis téléversez le `deadline-cloud-starter-farm-template.yaml` fichier.
1. Entrez un nom pour la pile, par exemple**StarterFarm**, et fournissez le nom d'un compartiment Amazon S3 pour les pièces jointes aux tâches et le canal conda.
1. Suivez les étapes de CloudFormation la console pour terminer la création de la pile.
Pour plus d'informations sur les paramètres du modèle et les options de personnalisation, consultez le [fichier README de la ferme de démarrage](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/starter_farm) dans le référentiel d'exemples de Deadline Cloud surGitHub.
## Création d'une file d'attente pour la création de packages à partir de la console
Suivez les instructions de la section [Création d'une file d'attente](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue.html) dans le *guide de l'utilisateur de Deadline Cloud*. Effectuez les modifications suivantes :
+ À l'étape 5, choisissez un compartiment Amazon S3 existant. Spécifiez un nom de dossier racine, de **DeadlineCloudPackageBuild** manière à ce que les artefacts de build restent séparés de vos pièces jointes habituelles de Deadline Cloud.
+ À l'étape 6, vous pouvez associer la file d'attente de création de packages à une flotte existante, ou vous pouvez créer une toute nouvelle flotte si votre flotte actuelle n'est pas adaptée.
+ À l'étape 9, créez un nouveau rôle de service pour votre file d'attente de création de packages. Vous allez modifier les autorisations pour donner à la file d'attente les autorisations requises pour télécharger des packages et réindexer un canal conda.
### Configurer les autorisations de file d'attente de création du package
Pour permettre à la file d'attente de création du package d'accéder au `/Conda` préfixe du compartiment Amazon S3 de la file d'attente, vous devez modifier le rôle de la file d'attente pour lui donner read/write accès. Le rôle a besoin des autorisations suivantes pour que les tâches de création de packages puissent télécharger de nouveaux packages et réindexer le canal.
+ `s3:GetObject`
+ `s3:PutObject`
+ `s3:ListBucket`
+ `s3:GetBucketLocation`
+ `s3:DeleteObject`
1. Ouvrez la console Deadline Cloud et accédez à la page de détails de la file d'attente de création du package.
1. Choisissez le rôle du service de file d'attente, puis choisissez **Modifier la file d'attente**.
1. Accédez à la section **Rôle du service de file d'attente**, puis choisissez **Afficher ce rôle dans la console IAM**.
1. Dans la liste des politiques d'autorisation, choisissez celle qui convient **AmazonDeadlineCloudQueuePolicy**à votre file d'attente.
1. Dans l'onglet **Autorisations**, choisissez **Modifier**.
1. Ajoutez une nouvelle section au rôle de service de file d'attente comme suit. Remplacez *amzn-s3-demo-bucket* et *111122223333* par votre propre bucket et votre propre compte.
```
{
"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"
}
}
},
```
## Soumettre une tâche de création de package
Après avoir créé une file d'attente de création de packages et configuré les autorisations de file d'attente, vous pouvez soumettre des tâches pour créer des packages conda. Le `submit-package-job` script figurant dans le référentiel d'[exemples de Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes#readme) GitHub soumet une tâche de génération pour une recette de conda.
Vous avez besoin des éléments suivants :
+ La [CLI Deadline Cloud](https://github.com/aws-deadline/deadline-cloud) installée sur votre poste de travail.
+ Une session de connexion active AWS au [moniteur Deadline Cloud (moniteur Deadline Cloud)](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/working-with-deadline-monitor.html).
+ Un clone du référentiel d'[échantillons de Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples).
**Pour soumettre une tâche de création de package**
1. Ouvrez l'interface graphique de configuration de Deadline Cloud et définissez le parc et la file d'attente par défaut sur votre file d'attente de création de packages.
```
deadline config gui
```
1. Accédez au `conda_recipes` répertoire du référentiel d'échantillons.
```
cd deadline-cloud-samples/conda_recipes
```
1. Exécutez le `submit-package-job` script avec le répertoire des recettes. L'exemple suivant crée la recette Blender 4.5.
```
./submit-package-job blender-4.5/
```
Si la recette nécessite une archive source que vous n'avez pas encore téléchargée, le script fournit des instructions de téléchargement. Téléchargez l'archive et réexécutez le script.
Après avoir soumis la tâche, utilisez le moniteur Deadline Cloud pour voir la progression et le statut de la tâche.
![\[Le moniteur Deadline Cloud indiquant l'avancement et l'état d'avancement d'une tâche de création d'un package Conda.\]](http://docs.aws.amazon.com/fr_fr/deadline-cloud/latest/developerguide/images/Conda-Figure3.png)
Le moniteur montre les deux étapes de la tâche : créer le package, puis réindexer le canal Conda. Lorsque vous cliquez avec le bouton droit sur la tâche correspondant à l'étape de création du package et que vous choisissez **Afficher les journaux**, le moniteur affiche les actions de session :
+ **Synchroniser les pièces jointes** : copie les pièces jointes des tâches d'entrée ou monte un système de fichiers virtuel.
+ **Lancez Conda** — L'action relative à l'environnement de file d'attente. La tâche de construction ne spécifie pas les packages conda, cette action se termine donc rapidement.
+ **Launch CondaBuild Env** — Crée un environnement virtuel conda avec le logiciel nécessaire pour créer un package conda et réindexer un canal.
+ **Exécution de la tâche** — Construit le package et télécharge les résultats sur Amazon S3.
Au fur et à mesure que les actions s'exécutent, elles envoient des journaux à Amazon CloudWatch (CloudWatch). Lorsqu'une tâche est terminée, sélectionnez **Afficher les journaux de toutes les tâches pour** voir les journaux supplémentaires relatifs à la configuration et au démontage de l'environnement.