Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erstellen Sie einen Conda-Kanal mit S3
Wenn Ihre Jobs Anwendungen ausführen müssen, die auf den [https://conda-forge.org/](https://conda-forge.org/)Kanälen [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)oder nicht verfügbar sind, können Sie einen benutzerdefinierten Conda-Channel hosten, um Ihre eigenen Pakete bereitzustellen. Wenn Sie eine Warteschlange in der AWS Deadline Cloud (Deadline Cloud) -Konsole erstellen, fügt die Konsole standardmäßig eine Conda-Warteschlangenumgebung hinzu. Um Ihre Pakete für Jobs verfügbar zu machen, fügen Sie den benutzerdefinierten Channel zur Warteschlangenumgebung hinzu.
Ein Conda-Channel ist statischer gehosteter Inhalt, den Sie auf [verschiedene Arten hosten können, z. B. in einem](https://rattler-build.prefix.dev/latest/publish/) Dateisystem oder in einem Amazon Simple Storage Service (Amazon S3) -Bucket. Wenn Ihre Deadline Cloud-Farm ein gemeinsam genutztes Dateisystem für Assets verwendet, können Sie einen beliebigen Pfad darauf als Kanalnamen verwenden. Sie können den Channel in einem Amazon S3 S3-Bucket hosten, um mithilfe von AWS Identity and Access Management (IAM-) Berechtigungen einen breiteren Zugriff zu erhalten.
Sie können [Pakete lokal erstellen und testen und](build-test-packages-locally.md) [sie dann in einem Channel veröffentlichen](publish-packages-s3-channel.md). Das lokale Erstellen von Paketen ist eine einfache Möglichkeit, ohne die Einrichtung einer Infrastruktur mit der Iteration von Paketen zu beginnen. Sie können auch eine [Warteschlange zum Erstellen von Paketen](automate-package-builds.md) in der Deadline Cloud verwenden, um Pakete zu erstellen und sie in einem Channel zu veröffentlichen. Eine Warteschlange zur Paketerstellung vereinfacht die Verwaltung von Paketen für mehrere Betriebssysteme und Beschleunigerkonfigurationen. Sie können Versionen aktualisieren und vollständige Sätze von Paket-Builds von überall aus einreichen.
Sie können Kanäle für Ihr Studio und Ihre Deadline Cloud-Farm auf verschiedene Arten konfigurieren. Sie können einen Amazon S3 S3-Kanal haben und all Ihre Workstations und Farmhosts so konfigurieren, dass sie ihn verwenden. Sie können auch mehr als einen Kanal haben und die Spiegelung mit AWS DataSync () DataSync einrichten. Ihre Deadline Cloud-Warteschlange zum Erstellen von Paketen kann beispielsweise auf einem Amazon S3 S3-Channel veröffentlicht werden, der lokal für Workstations und lokale Farmhosts gespiegelt wird.
**Topics**
+ [Pakete lokal erstellen und testen](build-test-packages-locally.md)
+ [Veröffentlichen Sie Pakete in einem Amazon S3 S3-Conda-Kanal](publish-packages-s3-channel.md)
+ [Konfigurieren Sie die Berechtigungen für die Produktionswarteschlange für benutzerdefinierte Conda-Pakete](#s3-channel-configure-permissions)
+ [Fügen Sie einer Warteschlangenumgebung einen Conda-Kanal hinzu](#s3-channel-add-channel)
+ [Erstellen Sie ein Conda-Paket für eine Anwendung oder ein Plugin](conda-package.md)
+ [Erstellen Sie ein Conda-Build-Rezept für Blender](create-conda-recipe-blender.md)
+ [Erstellen Sie ein Conda-Build-Rezept für Autodesk Maya](create-conda-recipe-maya.md)
+ [Erstellen Sie ein Conda-Build-Rezept für das Plugin Autodesk Maya to Arnold (MtoA)](create-conda-recipe-mtoa-plugin.md)
+ [Automatisieren Sie Paketerstellungen mit Deadline Cloud](automate-package-builds.md)
# Pakete lokal erstellen und testen
Bevor Sie Pakete auf Amazon S3 veröffentlichen oder die CI/CD Automatisierung auf Ihrer Deadline Cloud-Farm einrichten, können Sie Conda-Pakete auf Ihrer Workstation mithilfe eines lokalen Dateisystemkanals erstellen und testen. Mit diesem Ansatz können Sie schnell lokal an Rezepten iterieren und Pakete verifizieren.
Der `rattler-build publish` Befehl erstellt ein Rezept, kopiert das resultierende Paket in einen Channel und indexiert den Channel in einem Schritt. Wenn Sie auf ein lokales Dateisystemverzeichnis abzielen, `rattler-build` wird der Kanal automatisch erstellt und initialisiert, falls das Verzeichnis nicht existiert.
Die folgenden Anweisungen verwenden das Blender 4.5-Beispielrezept aus dem [Deadline Cloud-Beispiel-Repository](https://github.com/aws-deadline/deadline-cloud-samples) auf. GitHub Sie können ein anderes Rezept aus dem Proben-Repository verwenden oder Ihr eigenes Rezept verwenden.
## Voraussetzungen
Bevor Sie beginnen, installieren Sie die folgenden Tools auf Ihrer Workstation:
+ **pixi** — Ein Paketmanager, den Sie zum Installieren `rattler-build` und Testen von Paketen verwenden. [Installiere Pixi aus pixi.sh.](https://pixi.sh)
+ **rattler-build** — Das Tool zur Paketerstellung, das von Deadline Cloud Conda Recipes verwendet wird. Führen Sie nach der Installation von Pixi den folgenden Befehl aus, um Pixi zu installieren. `rattler-build`
```
pixi global install rattler-build
```
+ **git** — Erforderlich, um das Beispiel-Repository zu klonen. OnWindows, [git for](https://gitforwindows.org/) bietet Windows auch eine `bash` Shell, die einige der Windows Beispielrezepte benötigen.
## Ein Paket erstellen und auf einem lokalen Channel veröffentlichen
In diesem Verfahren klonen Sie das Deadline Cloud-Beispiel-Repository und verwenden es`rattler-build publish`, um das Paket zu erstellen und in einem lokalen Dateisystemkanal zu veröffentlichen.
**Um ein Paket zu erstellen und in einem lokalen Channel zu veröffentlichen**
1. Klonen Sie das Deadline Cloud-Beispiel-Repository.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Wechseln Sie in das `conda_recipes`-Verzeichnis.
```
cd deadline-cloud-samples/conda_recipes
```
1. Führen Sie den folgenden Befehl aus, um das Blender 4.5-Rezept zu erstellen und das Paket in einem lokalen Channel-Verzeichnis zu veröffentlichen.
Führen Sie macOS unter Linux und den folgenden Befehl aus.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to file://$HOME/my-conda-channel
```
Führen Sie auf Windows (cmd) den folgenden Befehl aus.
```
rattler-build publish blender-4.5/recipe/recipe.yaml ^
--to file://%USERPROFILE%/my-conda-channel
```
Der `rattler-build publish` Befehl führt die folgenden Aktionen aus:
+ Erstellt das Paket aus dem Rezept.
+ Erzeugt das Kanalverzeichnis, falls das Verzeichnis nicht existiert.
+ Kopiert die Paketdatei in den Channel.
+ Indiziert den Kanal, sodass Paketmanager das Paket finden können.
Wenn Ihr Paketrezept von Paketen aus einem bestimmten Kanal abhängt, wie z. B. [conda-forge](https://conda-forge.org/), fügen Sie dem Befehl etwas `-c conda-forge` hinzu.
Um das Paket neu aufzubauen, nachdem Sie Änderungen am Rezept vorgenommen haben, fügen Sie hinzu, `--build-number=+1` um die Build-Nummer automatisch zu erhöhen.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to file://$HOME/my-conda-channel \
--build-number=+1
```
Weitere Informationen dazu finden Sie in der `rattler-build publish` Dokumentation zur Veröffentlichung von [Rattler-Build](https://rattler-build.prefix.dev/latest/publish/).
## Builds debuggen
Wenn ein Build fehlschlägt, wird `rattler-build` das Build-Verzeichnis beibehalten, sodass Sie es untersuchen können. Führen Sie den folgenden Befehl aus, um eine interaktive Shell in der Build-Umgebung zu öffnen, in der alle Umgebungsvariablen so eingerichtet sind, wie sie während des Builds waren.
```
rattler-build debug shell
```
In der Debug-Shell können Sie Dateien ändern, einzelne Build-Befehle ausführen und Abhängigkeiten hinzufügen, um das Problem zu isolieren. Weitere Informationen finden Sie unter [Debuggen von Builds in der Rattler-Build-Dokumentation](https://rattler-build.prefix.dev/latest/debugging_builds/).
## Das Paket testen
Nachdem Sie das Paket erstellt und veröffentlicht haben, erstellen Sie ein temporäres Pixi-Projekt. Verwenden Sie das Projekt, um das Paket vom lokalen Kanal aus zu installieren und zu überprüfen, ob es ordnungsgemäß funktioniert.
**Um das Paket zu testen**
1. Erstellen Sie ein temporäres Testverzeichnis und initialisieren Sie ein Pixi-Projekt mit dem lokalen Kanal.
Führen Sie unter Linux und macOS die folgenden Befehle aus.
```
mkdir package-test-env
cd package-test-env
pixi init --channel file://$HOME/my-conda-channel
```
Führen Sie auf Windows (cmd) die folgenden Befehle aus.
```
mkdir package-test-env
cd package-test-env
pixi init --channel file://%USERPROFILE%/my-conda-channel
```
1. Fügen Sie das Paket dem Projekt hinzu.
```
pixi add blender=4.5
```
1. Stellen Sie sicher, dass das Paket ordnungsgemäß funktioniert.
```
pixi run blender --version
```
Wenn Sie mit dem Paket zufrieden sind, können Sie das Paket in einem Amazon S3 S3-Conda-Kanal veröffentlichen, sodass Deadline Cloud-Mitarbeiter das Paket installieren können. Weitere Informationen finden Sie unter [Pakete in einem S3-Conda-Kanal veröffentlichen](publish-packages-s3-channel.md).
## Bereinigen
Nach dem Testen können Sie das Testprojekt und den lokalen Channel entfernen.
**Um Testressourcen zu bereinigen**
1. Entfernen Sie das Testprojektverzeichnis.
Führen Sie macOS unter Linux und den folgenden Befehl aus.
```
rm -rf package-test-env
```
Führen Sie auf Windows (cmd) den folgenden Befehl aus.
```
rmdir /s /q package-test-env
```
1. Entfernen Sie das lokale Conda-Kanalverzeichnis.
Führen Sie unter Linux macOS und den folgenden Befehl aus.
```
rm -rf $HOME/my-conda-channel
```
Führen Sie auf Windows (cmd) den folgenden Befehl aus.
```
rmdir /s /q %USERPROFILE%\my-conda-channel
```
1. (Optional) Entfernen Sie das `rattler-build` Ausgabeverzeichnis, das die erstellte Paketdatei enthält.
Führen Sie macOS unter Linux und den folgenden Befehl aus.
```
rm -rf deadline-cloud-samples/conda_recipes/output
```
Führen Sie auf Windows (cmd) den folgenden Befehl aus.
```
rmdir /s /q deadline-cloud-samples\conda_recipes\output
```
# Veröffentlichen Sie Pakete in einem Amazon S3 S3-Conda-Kanal
Sie können Conda-Pakete in einem Amazon Simple Storage Service (Amazon S3) -Bucket veröffentlichen, sodass AWS Deadline Cloud-Mitarbeiter (Deadline Cloud) sie für die Ausführung von Jobs installieren können. Der `rattler-build publish` Befehl funktioniert mit Amazon S3 genauso wie mit einem lokalen Dateisystemkanal. Der Befehl kann ein Rezept erstellen und das Ergebnis veröffentlichen oder eine Paketdatei veröffentlichen, die Sie bereits erstellt haben. In beiden Fällen lädt der Befehl das Paket in den Bucket hoch und indexiert den Channel in einem Schritt.
Der `rattler-build publish` Befehl authentifiziert sich AWS mithilfe der standardmäßigen Anmeldeinformationskette, sodass er Ihre AWS Konfiguration wie jedes andere Tool verwendet. AWS Weitere Informationen zur Konfiguration von Anmeldeinformationen finden Sie unter [Konfiguration und Einstellungen für Anmeldeinformationsdateien](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) im *AWS Command Line Interface (AWS CLI)* -Benutzerhandbuch.
## Voraussetzungen
Bevor Sie Pakete in Amazon S3 veröffentlichen, müssen Sie die folgenden Voraussetzungen erfüllen:
+ **pixi and rattler-build** [— Installieren Sie Pixi aus pixi.sh und installieren Sie es anschließend.](https://pixi.sh) `rattler-build`
```
pixi global install rattler-build
```
+ **git** — Erforderlich, um das Beispiel-Repository zu klonen. OnWindows, [git for](https://gitforwindows.org/) bietet Windows auch eine `bash` Shell, die einige der Windows Beispielrezepte benötigen.
+ **Amazon S3 S3-Bucket** — Ein Amazon S3 S3-Bucket, der als Conda-Kanal verwendet werden soll. Sie können den Bucket für Jobanhänge aus Ihrer Deadline Cloud-Farm verwenden oder einen separaten Bucket erstellen.
+ **AWS Anmeldeinformationen** — Konfigurieren Sie die Anmeldeinformationen auf Ihrer Workstation mithilfe des `aws configure` Befehls oder des `aws login` Befehls. Weitere Informationen finden Sie unter [Einrichten von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-quickstart.html) im *AWS Command Line Interface -Benutzerhandbuch*.
+ **IAM-Berechtigungen** — (Optional) Um den Umfang der Berechtigungen zu reduzieren, über die Ihre Anmeldeinformationen verfügen, können Sie eine AWS Identity and Access Management (IAM-) Richtlinie verwenden, die nur die folgenden Berechtigungen für den Amazon S3 S3-Bucket und das von Ihnen verwendete Kanalpräfix gewährt (z. B.`/Conda/*`):
+ `s3:GetObject`
+ `s3:PutObject`
+ `s3:DeleteObject`
+ `s3:ListBucket`
+ `s3:GetBucketLocation`
## Ein Paket auf einem Amazon S3 S3-Kanal veröffentlichen
Verwenden Sie `rattler-build publish` mit einem `s3://` Ziel, um ein Paket in Ihrem Amazon S3 S3-Conda-Kanal zu veröffentlichen. Wenn der Kanal nicht im Bucket vorhanden ist, wird der Kanal `rattler-build` automatisch initialisiert. [Bevor Sie beginnen, stellen Sie sicher, dass Sie die Voraussetzungen erfüllt haben.](#publish-s3-prereqs)
Im folgenden Beispiel wird das Blender 4.5-Beispielrezept aus dem [Deadline Cloud-Beispiel-Repository](https://github.com/aws-deadline/deadline-cloud-samples) am veröffentlichtGitHub. Sie können ein anderes Rezept aus dem Samples-Repository verwenden oder Ihr eigenes Rezept verwenden.
**Um ein Paket auf einem Amazon S3 S3-Kanal zu veröffentlichen**
1. Klonen Sie das Deadline Cloud-Beispiel-Repository.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Wechseln Sie in das `conda_recipes`-Verzeichnis.
```
cd deadline-cloud-samples/conda_recipes
```
1. Führen Sie den folgenden Befehl aus. *amzn-s3-demo-bucket*Ersetzen Sie es durch Ihren Bucket-Namen.
Führen Sie macOS unter Linux und den folgenden Befehl aus.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to s3://amzn-s3-demo-bucket/Conda/Default
```
Führen Sie auf Windows (cmd) den folgenden Befehl aus.
```
rattler-build publish blender-4.5/recipe/recipe.yaml ^
--to s3://amzn-s3-demo-bucket/Conda/Default
```
Das `/Conda/Default` Präfix organisiert den Kanal innerhalb des Buckets. Sie können ein anderes Präfix verwenden, aber das Präfix muss in allen Befehlen und Warteschlangenkonfigurationen, die auf den Kanal verweisen, konsistent sein.
Um ein aktualisiertes Paket neu zu erstellen und zu veröffentlichen, fügen Sie `--build-number=+1` die Build-Nummer hinzu, um sie automatisch zu erhöhen.
```
rattler-build publish blender-4.5/recipe/recipe.yaml \
--to s3://amzn-s3-demo-bucket/Conda/Default \
--build-number=+1
```
Wenn Ihr Paketrezept von Paketen aus einem bestimmten Channel abhängt, wie z. B. [conda-forge](https://conda-forge.org/), fügen Sie dem Befehl etwas `-c conda-forge` hinzu.
Sie können auch eine Paketdatei veröffentlichen, die Sie bereits erstellt haben, z. B. eine `.conda` Datei aus einem lokalen Build. *amzn-s3-demo-bucket*Ersetzen Sie es durch Ihren Bucket-Namen.
```
rattler-build publish output/linux-64/blender-4.5.0-hb0f4dca_0.conda \
--to s3://amzn-s3-demo-bucket/Conda/Default
```
## Das Paket testen
Nachdem Sie das Paket veröffentlicht haben, erstellen Sie ein temporäres Pixi-Projekt, um zu überprüfen, ob das Paket ordnungsgemäß funktioniert. Das Projekt installiert das Paket aus dem Amazon S3 S3-Channel.
**Um das Paket zu testen**
1. Erstellen Sie ein temporäres Testverzeichnis und initialisieren Sie ein Pixi-Projekt mit dem Amazon S3 S3-Kanal. Ersetzen Sie es *amzn-s3-demo-bucket* durch Ihren Bucket-Namen.
```
mkdir package-test-env
cd package-test-env
pixi init --channel s3://amzn-s3-demo-bucket/Conda/Default
```
1. Fügen Sie das Paket dem Projekt hinzu.
```
pixi add blender=4.5
```
1. Stellen Sie sicher, dass das Paket ordnungsgemäß funktioniert.
```
pixi run blender --version
```
## Bereinigen
Entfernen Sie nach dem Testen das Testprojektverzeichnis.
**Um Testressourcen zu bereinigen**
+ Entfernen Sie das Testprojektverzeichnis.
Führen Sie macOS unter Linux und den folgenden Befehl aus.
```
rm -rf package-test-env
```
Führen Sie auf Windows (cmd) den folgenden Befehl aus.
```
rmdir /s /q package-test-env
```
## Builds debuggen
Wenn ein Build fehlschlägt, wird `rattler-build` das Build-Verzeichnis beibehalten, sodass Sie es untersuchen können. Führen Sie den folgenden Befehl aus, um eine interaktive Shell in der Build-Umgebung zu öffnen, in der alle Umgebungsvariablen so eingerichtet sind, wie sie während des Builds waren.
```
rattler-build debug shell
```
In der Debug-Shell können Sie Dateien ändern, einzelne Build-Befehle ausführen und Abhängigkeiten hinzufügen, um das Problem zu isolieren. Weitere Informationen finden Sie unter [Debuggen von Builds in der Rattler-Build-Dokumentation](https://rattler-build.prefix.dev/latest/debugging_builds/).
## Pakete für andere Plattformen erstellen
Der `rattler-build publish` Befehl erstellt Pakete für das Betriebssystem der Workstation, auf der der Befehl ausgeführt wird. Wenn Ihre Deadline Cloud-Flotte ein anderes Betriebssystem als Ihre Workstation verwendet oder wenn Ihr Paket andere Hostanforderungen hat, haben Sie die folgenden Optionen:
+ `rattler-build publish`Auf einem Host ausführen, der dem Zielbetriebssystem entspricht. Verwenden Sie beispielsweise eine Amazon Elastic Compute Cloud (Amazon EC2) -Instance, die ausgeführt wirdLinux, um Pakete für eine Linux Flotte zu erstellen.
+ Verwenden Sie eine Deadline Cloud-Warteschlange zur Paketerstellung, um Builds auf der Zielplattform zu automatisieren. Weitere Informationen finden [Sie unter Erstellen einer Warteschlange zur Paketerstellung](automate-package-builds.md#s3-channel-create-queue).
+ (Fortgeschritten) Verwenden Sie Cross-Compilierung, um Pakete für eine andere Plattform als Ihre Workstation zu erstellen. Weitere Informationen finden Sie unter [Cross-Compilierung](https://rattler-build.prefix.dev/latest/compilers/#cross-compilation) in der Rattler-Build-Dokumentation.
## Nächste Schritte
Nachdem Sie Pakete in Ihrem Amazon S3 S3-Conda-Kanal veröffentlicht haben, konfigurieren Sie Ihre Deadline Cloud-Warteschlangen so, dass sie den Kanal verwenden:
+ [Konfigurieren Sie Produktionswarteschlangenberechtigungen für benutzerdefinierte Conda-Pakete](configure-jobs-s3-channel.md#s3-channel-configure-permissions) — Gewähren Sie Ihren Produktionswarteschlangen schreibgeschützten Zugriff auf den Amazon S3 S3-Conda-Kanal.
+ [Einen Conda-Kanal zu einer Warteschlangenumgebung hinzufügen — Konfigurieren Sie die Warteschlangenumgebung](configure-jobs-s3-channel.md#s3-channel-add-channel) so, dass Pakete aus dem Amazon S3 S3-Conda-Kanal installiert werden.
## Konfigurieren Sie die Berechtigungen für die Produktionswarteschlange für benutzerdefinierte Conda-Pakete
Ihre Produktionswarteschlange benötigt nur Leseberechtigungen für das `/Conda` Präfix im S3-Bucket der Warteschlange. Öffnen Sie die Seite AWS Identity and Access Management (IAM) für die Rolle, die der Produktionswarteschlange zugeordnet ist, und ändern Sie die Richtlinie wie folgt:
1. Öffnen Sie die Deadline Cloud-Konsole und navigieren Sie zur Seite mit den Warteschlangendetails für die Warteschlange zur Paketerstellung.
1. Wählen Sie die Warteschlangendienst-Rolle und anschließend **Warteschlange bearbeiten** aus.
1. Scrollen Sie zum Abschnitt **Warteschlangendienstrolle** und wählen Sie dann **Diese Rolle in der IAM-Konsole anzeigen** aus.
1. Wählen Sie aus der Liste der Berechtigungsrichtlinien die **AmazonDeadlineCloudQueuePolicy**für Ihre Warteschlange aus.
1. Wählen Sie auf der Registerkarte „**Berechtigungen**“ die Option **Bearbeiten** aus.
1. Fügen Sie der Warteschlangendienst-Rolle einen neuen Abschnitt wie den folgenden hinzu. Ersetzen Sie *amzn-s3-demo-bucket* und *111122223333* durch Ihren eigenen Bucket und Ihr eigenes Konto.
```
{
"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"
}
}
},
```
## Fügen Sie einer Warteschlangenumgebung einen Conda-Kanal hinzu
Um den S3-Conda-Kanal zu verwenden, müssen Sie den `s3://amzn-s3-demo-bucket/Conda/Default` Kanalstandort zum `CondaChannels` Parameter von Jobs hinzufügen, die Sie an Deadline Cloud senden. Die mit Deadline Cloud bereitgestellten Einreicher stellen Felder zur Verfügung, um benutzerdefinierte Conda-Kanäle und -Pakete anzugeben.
Sie können vermeiden, jeden Job zu ändern, indem Sie die Conda-Warteschlangenumgebung für Ihre Produktionswarteschlange bearbeiten. Führen Sie die folgenden Schritte aus:
1. Öffnen Sie die Deadline Cloud-Konsole und navigieren Sie zur Seite mit den Warteschlangendetails für die Produktionswarteschlange.
1. Wählen Sie den Tab Umgebungen.
1. Wählen Sie die **Conda-Warteschlangenumgebung** und dann **Bearbeiten** aus.
1. Wählen Sie den **JSON-Editor** und suchen Sie dann im Skript nach der Parameterdefinition für`CondaChannels`.
1. Bearbeiten Sie die Zeile `default: "deadline-cloud"` so, dass sie mit dem neu erstellten S3-Conda-Kanal beginnt:
```
default: "s3://amzn-s3-demo-bucket/Conda/Default deadline-cloud"
```
Serviceverwaltete Flotten ermöglichen standardmäßig eine flexible Kanalpriorität für Conda. Bei einem Job, der anfragt, `blender=4.2` ob Blender 4.2 sowohl im neuen Channel als auch im Channel enthalten ist, wird das Paket aus dem `deadline-cloud` Channel abgerufen, der zuerst in der Channel-Liste steht. Wenn eine angegebene Paketversion nicht im ersten Kanal gefunden wird, werden die nachfolgenden Kanäle auf die Paketversion überprüft.
Für vom Kunden verwaltete Flotten können Sie die Verwendung von Conda-Paketen aktivieren, indem Sie eines der [Conda-Warteschlangenumgebungsbeispiele](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/README.md) im Deadline Cloud-Beispiel-Repository verwenden. GitHub
# Erstellen Sie ein Conda-Paket für eine Anwendung oder ein Plugin
Ein Conda-Paket ist ein komprimiertes Archiv mit Software, die in einer beliebigen Sprache geschrieben wurde. Conda unterstützt eine Vielzahl von Betriebssystem- und Architekturkombinationen, sodass Sie vollständige Anwendungen wie BlenderMaya, und Nuke zusammen mit Bibliotheken für Python und andere Sprachen paketieren können. Weitere Informationen zu Conda-Paketen finden Sie unter [Pakete](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/packages.html) in der Conda-Dokumentation.
Um ein Conda-Paket zu verwenden, installieren Sie es in einer virtuellen Umgebung. Eine virtuelle Conda-Umgebung hat ein *Präfixverzeichnis*, in dem Pakete installiert werden. Bei der Installation eines Pakets werden Dateien fest verknüpft oder neu verlinkt, sofern dies unterstützt wird. Das Erstellen mehrerer Umgebungen mit denselben Paketen verbraucht also keinen nennenswerten zusätzlichen Festplattenspeicher. Um eine virtuelle Umgebung zu verwenden, aktivieren Sie sie, um Umgebungsvariablen festzulegen. Bei der Aktivierung werden von Paketen bereitgestellte Skripts ausgeführt, sodass jedes Paket die Möglichkeit hat, PATH oder andere Umgebungsvariablen zu ändern. Conda-Pakete enthalten normalerweise Anwendungen oder Bibliotheken, aber aufgrund der flexiblen Aktivierung können sie auch auf Anwendungen verweisen, die auf einem gemeinsam genutzten Dateisystem installiert sind.
Die Erstellung eines benutzerdefinierten Pakets umfasst drei Phasen: Ein *Rezept* enthält die Bauanweisungen, ein *Paket* ist das gebaute Artefakt (`.conda`oder die erstellte `.tar.bz2` Datei) und ein *Channel* hostet die Pakete für die Installation. Der `rattler-build publish` Befehl behandelt alle drei Schritte: Er kann ein Rezept in ein Paket einbauen und in einem Channel veröffentlichen, oder es kann direkt ein Paket-Artefakt verwenden, um es zu veröffentlichen.
Die [Conda-Forge-Community](https://conda-forge.org/) verwaltet Paketrezepte für eine breite Palette von Open-Source-Software und hostet Paket-Artefakte im Channel. `conda-forge` Sie können Ihre Warteschlange so konfigurieren, dass sie sie `conda-forge` als Paketquelle einschließt, und dann benutzerdefinierte Pakete erstellen, deren Ausführung von Conda-Forge-Paketen abhängt. Denn Linux Conda-Forge hostet eine vollständige Compiler-Toolchain einschließlich CUDA-Unterstützung, wobei konsistente Kompilierungs- und Linkoptionen ausgewählt sind. Sie können Conda-Forge-Pakete als Abhängigkeiten in Ihren eigenen Rezepten verwenden oder sie zusammen mit Ihren benutzerdefinierten Paketen in derselben Umgebung installieren.
Sie können eine gesamte Anwendung, einschließlich Abhängigkeiten, zu einem Conda-Paket kombinieren. Die Pakete, die Deadline Cloud im [Deadline-Cloud-Channel](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html#conda-queue-environment) für serviceverwaltete Flotten bereitstellt, verwenden diesen binären Repacking-Ansatz. Dadurch werden dieselben Dateien wie bei einer Installation so organisiert, dass sie zur virtuellen Conda-Umgebung passen.
**Anmerkung**
Große Anwendungen können Dutzende GB freien Festplattenspeicher für das Quellarchiv, die entpackten Dateien und die Build-Ausgabe benötigen. Stellen Sie sicher, dass Sie eine Festplatte mit ausreichend verfügbarem Speicherplatz für die Paketbauausgabe verwenden.
## Eine Anwendung verpacken
Beim Umpacken einer Anwendung für Conda gibt es zwei Ziele:
+ Die meisten Dateien für die Anwendung sollten von der primären Struktur der virtuellen Conda-Umgebung getrennt sein. Umgebungen können die Anwendung dann mit Paketen aus anderen Quellen wie [Conda-Forge](https://conda-forge.org/) mischen.
+ Wenn eine virtuelle Conda-Umgebung aktiviert ist, sollte die Anwendung über die Umgebungsvariable PATH verfügbar sein.
**Um eine Anwendung für Conda neu zu verpacken**
1. Schreiben Sie Conda-Build-Rezepte, die die Anwendung in ein Unterverzeichnis wie installieren. `$CONDA_PREFIX/opt/` Dies unterscheidet es von den Standardpräfixverzeichnissen wie `bin` und. `lib`
1. Fügen Sie Symlinks oder Startskripten hinzu, `$CONDA_PREFIX/bin` um die Anwendungsbinärdateien auszuführen.
Alternativ können Sie activate.d-Skripten erstellen, die der `conda activate` Befehl ausführt, um die Binärverzeichnisse der Anwendung zum PATH hinzuzufügen. Wenn Symlinks nicht überall unterstützt werdenWindows, wo Umgebungen erstellt werden können, verwenden Sie stattdessen die Skripten application launch oder activate.d.
1. Manche Anwendungen sind auf Bibliotheken angewiesen, die nicht standardmäßig auf den vom Service verwalteten Flotten von Deadline Cloud installiert sind. Beispielsweise ist das X11-Fenstersystem für nicht interaktive Jobs normalerweise nicht erforderlich, aber für einige Anwendungen muss es immer noch ohne grafische Oberfläche ausgeführt werden. Sie müssen diese Abhängigkeiten in dem Paket angeben, das Sie erstellen.
1. Wenn die Anwendung Plugins unterstützt, geben Sie eine klare Konvention an, nach der Plugin-Pakete bei der Integration in die Anwendung in einer virtuellen Umgebung funktionieren müssen. Zum Beispiel dokumentiert das [Maya2026-Beispielrezept](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-2026#instructions-for-maya-plugin-packages) diese Konvention für Maya Plugins.
1. Stellen Sie sicher, dass Sie die Urheber- und Lizenzvereinbarungen für die von Ihnen verpackten Anwendungen einhalten. Wir empfehlen, einen privaten Amazon S3 S3-Bucket für Ihren Conda-Kanal zu verwenden, um die Verteilung zu kontrollieren und den Paketzugriff auf Ihre Farm einzuschränken.
Beispielrezepte für die Pakete im `deadline-cloud` Channel sind im [Deadline Cloud-Beispiel-Repository](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes#readme) unter GitHub verfügbar.
## Ein Plugin verpacken
Anwendungs-Plugins können als eigene Conda-Pakete verpackt werden. Beachten Sie beim Erstellen eines Plugin-Pakets die folgenden Richtlinien:
+ Nehmen Sie das Host-Anwendungspaket sowohl als Build- als auch als Run-Abhängigkeit in das Build-Rezept auf`recipe.yaml`. Verwenden Sie eine Versionsbeschränkung, sodass das Build-Rezept nur mit kompatiblen Paketen installiert wird.
+ Halten Sie sich bei der Registrierung des Plug-ins an die Konventionen für Host-Anwendungspakete.
## Adapter-Pakete
Einige Anwendungsintegrationen von Deadline Cloud verwenden einen *Adapter*, der die Anwendungsschnittstelle erweitert, um das [Schreiben](building-jobs.md) von Jobvorlagen zu vereinfachen. Ein Adapter ist eine Befehlszeilenschnittstelle, die die Ausführung eines Hintergrund-Daemons, die Statusberichterstattung und die Pfadzuweisung unterstützt. Weitere Informationen finden Sie unter [Open Job Description Adaptor Runtime](https://github.com/OpenJobDescription/openjd-adaptor-runtime-for-python#readme) aufGitHub. Zum Beispiel GitHub enthält [deadline-cloud-for-maya](https://github.com/aws-deadline/deadline-cloud-for-maya/)on eine integrierte Benutzeroberfläche für die Auftragsübermittlung und einen Maya Adapter, der als `maya-openjd` Paket für vom Service verwaltete Flotten verfügbar ist.
Auftragsübermittlungen von Deadline Cloud Submitter GUIs enthalten einen `CondaPackages` Parameterwert, der die Conda-Pakete angibt, die in einer virtuellen Umgebung für die Ausführung des Jobs enthalten sein sollen. Der `CondaPackages` Parameterwert für sieht Maya normalerweise so aus `maya=2025.* maya-openjd=0.15.* maya-mtoa` und kann alternative Einträge für Plugin-Pakete enthalten. Wenn die Warteschlangenumgebung eine virtuelle Conda-Umgebung für die Ausführung des Jobs einrichtet, löst sie diese Paketnamen und Versionseinschränkungen auf, sodass sie kompatibel sind, und fügt alle Abhängigkeitspakete hinzu, die sie zur Ausführung benötigen. Jedes Adapter- und Plugin-Paket gibt an, womit es kompatibel ist, einschließlich welcher Versionen vonMaya, welchen Versionen von Python und anderer Abhängigkeiten.
[Um Ihre eigenen Adapterpakete mit unseren Beispielen wie dem [Maya-Openjd-Rezept](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-openjd) auf zu erstellenGitHub, können Sie auf den Paketen für Python und anderen Abhängigkeiten aufbauen, die von conda-forge bereitgestellt werden.](https://conda-forge.org/) Möglicherweise müssen Sie zuerst die [Frist](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/deadline) und [openjd-adaptor-runtime](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/openjd-adaptor-runtime)die Rezepte erstellen, um Abhängigkeiten zu erfüllen.
# Erstellen Sie ein Conda-Build-Rezept für Blender
Sie können verschiedene Anwendungen verwenden, um ein Conda-Build-Rezept zu erstellen. Blenderist kostenlos zu verwenden und lässt sich einfach mit Conda verpacken. Die Blender Foundation stellt [Anwendungsarchive](https://download.blender.org/release/Blender4.2/) für mehrere Betriebssysteme zur Verfügung. Wir haben ein Beispiel für ein Conda-Build-Rezept erstellt, das die Windows-Dateien .zip und .tar.xz für Linux verwendet. [In diesem Abschnitt erfahren Sie, wie Sie das Conda-Build-Rezept von 4.2 verwenden. Blender](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2)
Die Datei [deadline-cloud.yaml](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2) spezifiziert die Conda-Plattformen und andere Metadaten für die Übermittlung von Paketaufträgen an Deadline Cloud. Dieses Rezept enthält Informationen zum lokalen Quellarchiv, um zu demonstrieren, wie das funktioniert. Die Linux-64-Conda-Plattform ist so eingestellt, dass sie eine Standardkonfiguration für die Einreichung von Jobs einbaut, die der gängigsten Konfiguration entspricht. Die Datei deadline-cloud.yaml sieht etwa wie folgt aus:
```
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"'
```
Überprüfen Sie die Dateien im Verzeichnis. `recipe` Die Metadaten für das Rezept befinden sich in [recipe/recipe.yaml](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2/recipe/recipe.yaml). Sie können auch die Dokumentation conda build [meta.yaml lesen, um mehr zu erfahren, z. B. darüber, wie die Datei eine Vorlage zur Generierung von YAML](https://docs.conda.io/projects/conda-build/en/latest/resources/define-metadata.html) ist. Die Vorlage wird verwendet, um die Versionsnummer nur einmal anzugeben und je nach Betriebssystem unterschiedliche Werte bereitzustellen.
Sie können die unter ausgewählten Build-Optionen überprüfen`meta.yaml`, um verschiedene Prüfungen für die binäre Verlagerung und das Verknüpfen von dynamischen gemeinsamen Objekten (DSO) zu deaktivieren. Diese Optionen steuern, wie das Paket funktioniert, wenn es in einer virtuellen Conda-Umgebung unter einem beliebigen Verzeichnispräfix installiert wird. Die Standardwerte vereinfachen das Verpacken jeder Abhängigkeitsbibliothek in ein separates Paket, aber wenn Sie eine Anwendung binär neu verpacken, müssen Sie sie ändern.
Wenn für die Anwendung, die Sie verpacken, zusätzliche Abhängigkeitsbibliotheken erforderlich sind oder Sie Plugins für eine Anwendung separat verpacken, können DSO-Fehler auftreten. Diese Fehler treten auf, wenn sich die Abhängigkeit nicht im Bibliothekssuchpfad für die ausführbare Datei oder Bibliothek befindet, die sie benötigt. Anwendungen sind darauf angewiesen, dass sich Bibliotheken in global definierten Pfaden wie `/lib` oder befinden`/usr/lib`, wenn sie auf einem System installiert sind. Da virtuelle Conda-Umgebungen jedoch überall platziert werden können, gibt es keinen absoluten Pfad, der verwendet werden kann. Conda verwendet relative RPATH-Funktionen, die sowohl als auch macOS unterstützt werden, um Linux dies zu handhaben. Weitere Informationen finden Sie in der Conda-Build-Dokumentation unter [Pakete verschiebbar machen](https://docs.conda.io/projects/conda-build/en/latest/resources/make-relocatable.html).
Blendererfordert keine RPATH-Anpassung, da die Anwendungsarchive unter Berücksichtigung dieser Tatsache erstellt wurden. Für Anwendungen, die dies benötigen, können Sie dieselben Tools verwenden wie Conda Build: `patchelf` unter Linux und `install_name_tool` anderen. macOS
Während der Paketerstellung wird das Skript [build.sh](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2/recipe/build.sh) oder [build\$1win.sh](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/blender-4.2/recipe/build_win.sh) (aufgerufen von`bld.bat`) ausgeführt, um Dateien in einer Umgebung zu installieren, die mit den Paketabhängigkeiten vorbereitet ist. Diese Skripten kopieren die Installationsdateien, erstellen Symlinks von `$PREFIX/bin` ihnen und richten die Aktivierungsskripten ein. Bei aktivierter Option werden keine Symlinks erstelltWindows, sondern stattdessen das Blender-Verzeichnis zum PATH im Aktivierungsskript hinzugefügt.
Wir verwenden `bash` statt `cmd.exe` einer.bat-Datei für den Windows Teil des Conda-Build-Rezepts, da dies für mehr Konsistenz zwischen den Build-Skripten sorgt. Tipps zur Verwendung `bash` von finden Sie in der Empfehlung zur Workload-Portabilität im [Deadline Cloud-Entwicklerhandbuch](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/what-is-a-deadline-cloud-workload.html#workload-portability). Windows Wenn Sie [Git for](https://gitforwindows.org/) installiert habenWindows, um das [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/)Git-Repository zu klonen, haben Sie bereits Zugriff auf`bash`.
In der Dokumentation zu den [Conda-Build-Umgebungsvariablen](https://docs.conda.io/projects/conda-build/en/latest/user-guide/environment-variables.html) sind die Werte aufgeführt, die für die Verwendung im Build-Skript verfügbar sind. Zu diesen Werten gehören `$SRC_DIR` für die Quellarchivdaten, `$PREFIX` für das Installationsverzeichnis, für den `$RECIPE_DIR` Zugriff auf andere Dateien aus dem Rezept, `$PKG_NAME` `$PKG_VERSION` für den Paketnamen und die Version sowie `$target_platform` für die Ziel-Conda-Plattform.
## Reichen Sie den Blender 4.2-Paketjob ein
Sie können Ihr eigenes Blender 4.2-Conda-Paket erstellen, um Jobs zu rendern, indem Sie das Blender Archiv herunterladen und dann einen Job an die Paketbau-Warteschlange senden. Die Warteschlange sendet den Job an die zugehörige Flotte, um das Paket zu erstellen und den Conda-Kanal neu zu indizieren.
[Diese Anweisungen verwenden Git aus einer Bash-kompatiblen Shell, um einen OpenJD-Paketbaujob und einige Conda-Rezepte aus dem Deadline Cloud-Beispiel-Repository abzurufen. GitHub](https://github.com/aws-deadline/deadline-cloud-samples) Sie benötigen außerdem Folgendes:
+ Wenn Sie Git verwendenWindows, wird bei der Installation von Git eine Version von Bash, git BASH, installiert.
+ Sie müssen die [Deadline Cloud CLI](https://github.com/aws-deadline/deadline-cloud) installiert haben.
+ Sie müssen beim [Deadline Cloud-Monitor](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/working-with-deadline-monitor.html) angemeldet sein.
1. Öffnen Sie die Deadline Cloud-Konfigurations-GUI mit dem folgenden Befehl und legen Sie die Standardfarm und -warteschlange auf Ihre Paketerstellungswarteschlange fest.
```
deadline config gui
```
1. Verwenden Sie den folgenden Befehl, um das Deadline GitHUb Cloud-Beispiel-Repository zu klonen.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Wechseln Sie zu dem `conda_recipes` Verzeichnis im `deadline-cloud-samples` Verzeichnis.
```
cd deadline-cloud-samples/conda_recipes
```
1. Führen Sie das aufgerufene Skript aus`submit-package-job`. Das Skript enthält Anweisungen zum HerunterladenBlender, wenn Sie das Skript zum ersten Mal ausführen.
```
./submit-package-job blender-4.2/
```
1. Folgen Sie den Anweisungen zum HerunterladenBlender. Wenn Sie das Archiv haben, führen Sie das `submit-package-job` Skript erneut aus.
```
./submit-package-job blender-4.2/
```
Nachdem Sie den Job eingereicht haben, können Sie den Deadline Cloud-Monitor verwenden, um den Fortschritt und Status des Jobs während der Ausführung zu verfolgen.
In der unteren linken Ecke des Monitors werden die beiden Schritte des Jobs angezeigt: das Erstellen des Pakets und die anschließende Neuindizierung. Unten rechts werden die einzelnen Schritte für jede Aufgabe angezeigt. In diesem Beispiel gibt es für jede Aufgabe einen Schritt.
![\[Der Deadline Cloud-Monitor zeigt den Fortschritt und den Status eines Jobs, der das Blender Paket erstellt.\]](http://docs.aws.amazon.com/de_de/deadline-cloud/latest/developerguide/images/Conda-Figure3.png)
In der unteren linken Ecke des Monitors befinden sich die beiden Schritte des Jobs: das Erstellen des Pakets und das anschließende Neuindizieren des Conda-Kanals. Unten rechts befinden sich die einzelnen Aufgaben für jeden Schritt. In diesem Beispiel gibt es für jeden Schritt nur eine Aufgabe.
Wenn Sie mit der rechten Maustaste auf die Aufgabe für den Schritt zur Paketerstellung klicken und **Protokolle anzeigen** auswählen, zeigt der Monitor eine Liste von Sitzungsaktionen an, die zeigen, wie die Aufgabe für den Worker geplant ist. Die Aktionen sind:
+ **Anlagen synchronisieren** — Diese Aktion kopiert die Eingabe-Job-Anhänge oder mountet ein virtuelles Dateisystem, je nachdem, welche Einstellung für das Dateisystem mit den Job-Anhängen verwendet wurde.
+ **Conda starten** — Diese Aktion stammt aus der Warteschlangenumgebung, die standardmäßig hinzugefügt wurde, als Sie die Warteschlange erstellt haben. Der Job spezifiziert keine Conda-Pakete, sodass er schnell abgeschlossen wird und keine virtuelle Conda-Umgebung erstellt.
+ ** CondaBuild Env starten** — Diese Aktion erstellt eine benutzerdefinierte virtuelle Conda-Umgebung, die die Software enthält, die zum Erstellen eines Conda-Pakets und zur Neuindizierung eines Kanals erforderlich ist. [Sie wird über den Conda-Forge-Kanal installiert.](https://conda-forge.org/)
+ **Aufgabe ausführen** — Diese Aktion erstellt das Blender Paket und lädt die Ergebnisse auf Amazon S3 hoch.
Während die Aktionen ausgeführt werden, senden sie Protokolle in einem strukturierten Format an Amazon CloudWatch. Wenn ein Job abgeschlossen ist, wählen Sie **Protokolle für alle Aufgaben anzeigen** aus, um zusätzliche Protokolle über den Auf- und Abbau der Umgebung, in der der Job ausgeführt wird, einzusehen.
# Testen Sie Ihr Paket mit einem Blender 4.2-Renderjob
Nachdem Sie das Blender 4.2-Paket erstellt und Ihre Produktionswarteschlange für die Verwendung des S3-Conda-Kanals konfiguriert haben, können Sie Jobs zum Rendern mit dem Paket einreichen. Wenn Sie keine Szene haben, laden Sie die Blender Szene Blender 3.5 — Cozy Kitchen von der Seite mit den [BlenderDemo-Dateien](https://www.blender.org/download/demo-files) herunter.
Das Deadline GitHub Cloud-Beispiel-Repository, das Sie zuvor heruntergeladen haben, enthält einen Beispieljob zum Rendern einer Blender Szene mit den folgenden Befehlen:
```
deadline bundle submit blender_render \
-p CondaPackages=blender=4.2 \
-p BlenderSceneFile=/path/to/downloaded/blender-3.5-splash.blend \
-p Frames=1
```
Sie können den Deadline Cloud-Monitor verwenden, um den Fortschritt Ihres Jobs zu verfolgen:
1. Wählen Sie im Monitor die Aufgabe für den Job aus, den Sie eingereicht haben, und wählen Sie dann die Option, um das Protokoll anzuzeigen.
1. Wählen Sie auf der rechten Seite der Protokollansicht die Aktion **Conda-Sitzung starten** aus.
Sie können sehen, dass die Aktion in den beiden für die Warteschlangenumgebung konfigurierten Conda-Kanälen nach Blender 4.2 gesucht hat und dass sie das Paket im S3-Kanal gefunden hat.
# Erstellen Sie ein Conda-Build-Rezept für Autodesk Maya
Sie können kommerzielle Anwendungen als Conda-Pakete verpacken. In [Create a Conda build recipe for](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/conda-package.html#create-conda-recipe-blender) haben Sie gelerntBlender, wie Sie eine Anwendung verpacken, die als einfache, verschiebbare Archivdatei und unter Open-Source-Lizenzbedingungen verfügbar ist. Kommerzielle Anwendungen werden häufig über Installationsprogramme verteilt und verfügen möglicherweise über ein Lizenzverwaltungssystem, mit dem sie arbeiten können.
Die folgende Liste baut auf den Grundlagen auf, die unter [Erstellen eines Conda-Pakets für eine Anwendung oder ein Plug-In behandelt werden, und zwar](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/conda-package.html) mit den Anforderungen, die üblicherweise mit der Paketierung kommerzieller Anwendungen verbunden sind. Die Einzelheiten in den Unteraufzählungen veranschaulichen, wie Sie die Richtlinien anwenden können. Maya
+ Machen Sie sich mit den Lizenzrechten und Einschränkungen der Anwendung vertraut. Möglicherweise müssen Sie ein Lizenzverwaltungssystem konfigurieren. Wenn das Programm keine Durchsetzung vorsieht, müssen Sie Ihre Farm entsprechend Ihren Rechten konfigurieren.
+ Lesen Sie die [häufig gestellten Fragen zu Autodesk Abonnementvorteilen zu Cloud-Rechten](https://www.autodesk.com/support/technical/article/caas/sfdcarticles/sfdcarticles/Subscription-Benefits-FAQ-Cloud-Rights.html), um zu erfahrenMaya, welche Cloud-Rechte für Sie gelten könnten. Konfigurieren Sie Ihre Deadline Cloud-Farm nach Bedarf.
+ AutodeskProdukte basieren auf einer Datei namens`ProductInformation.pit`. Für die meisten Konfigurationen dieser Datei ist Administratorzugriff auf das System erforderlich. Dieser Zugriff ist für vom Service verwaltete Flotten nicht verfügbar. Produktfunktionen für Thin Clients bieten eine Möglichkeit, dieses Problem an einem anderen Ort zu lösen. Weitere Informationen finden Sie unter [Thin Client-Lizenzierung für Maya](https://www.autodesk.com/support/technical/article/caas/tsarticles/ts/2zqRBCuGDrcPZDzULJQ27p.html). MotionBuilder
+ Manche Anwendungen hängen von Bibliotheken ab, die nicht auf den vom Service verwalteten Fleet Worker-Hosts installiert sind, weshalb das Paket sie bereitstellen muss. Dies kann direkt im Anwendungspaket oder in einem separaten Abhängigkeitspaket enthalten sein.
+ Mayahängt von einer Reihe solcher Bibliotheken ab, darunter freetype und fontconfig. Wenn diese Bibliotheken im Systempaketmanager verfügbar sind, z. B. in `dnf` for AL2023, können Sie sie als Quelle für die Anwendung verwenden. Da diese RPM-Pakete nicht so konzipiert sind, dass sie verschoben werden können, müssen Sie Tools verwenden, die sicherstellen, dass Abhängigkeiten innerhalb des Maya Installationspräfixes aufgelöst werden. `patchelf`
+ Für die Installation ist möglicherweise Administratorzugriff erforderlich. Da vom Service verwaltete Flotten keinen Administratorzugriff bieten, müssen Sie eine Installation auf einem System mit diesem Zugriff durchführen. Erstellen Sie anschließend ein Archiv mit den Dateien, die für den Paketerstellungsauftrag benötigt werden.
+ Das Windows Installationsprogramm für Maya erfordert Administratorzugriff, daher erfordert das Erstellen des Conda-Pakets einen manuellen Prozess, um zunächst ein solches Archiv zu erstellen.
+ Die Anwendungskonfiguration, einschließlich der Art und Weise, wie sich Plugins bei der Anwendung registrieren, kann auf Betriebssystem- oder Benutzerebene definiert werden. Wenn Plugins in einer virtuellen Conda-Umgebung platziert werden, müssen sie so in die Anwendung integriert werden können, dass sie in sich geschlossen sind und niemals Dateien oder andere Daten außerhalb des Präfixes der virtuellen Umgebung schreiben. Wir empfehlen Ihnen, dies über das Conda-Paket der Anwendung einzurichten.
+ Das Maya Beispielpaket definiert die Umgebungsvariable, `MAYA_NO_HOME=1` um sie von der Konfiguration auf Benutzerebene zu isolieren, und fügt Modulsuchpfade hinzu, `MAYA_MODULE_PATH` sodass separat verpackte Plugins aus der virtuellen Umgebung heraus integriert werden können. Das MtoA Beispielpaket platziert eine .mod-Datei in einem dieser Verzeichnisse, die beim Maya Start geladen wird.
**Schreiben Sie die Rezept-Metadaten**
1. Öffnen Sie das Verzeichnis GitHub [ deadline-cloud-samples/conda\$1recipes/maya-2025](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-2025) in Ihrem Browser oder in einem Texteditor in Ihrem lokalen Klon des Repositorys.
Die Datei `deadline-cloud.yaml` beschreibt die Conda-Build-Plattformen, für die Pakete erstellt werden sollen, und wo die Anwendung herkommt. Das Rezeptbeispiel spezifiziert Linux sowohl als auch Windows Builds, und nur das Linux wird standardmäßig übermittelt.
1. Laden Sie die vollständigen Maya Installationsprogramme von Ihrem Autodesk Anmeldenamen herunter. Denn Linux der Paket-Build kann das Archiv direkt verwenden. Platzieren Sie es also direkt im `conda_recipes/archive_files` Verzeichnis. Denn Windows das Installationsprogramm benötigt Administratorzugriff, um ausgeführt zu werden. Sie müssen das Installationsprogramm ausführen und die erforderlichen Dateien in einem Archiv für das Paketrezept sammeln, das Sie verwenden möchten. Die Datei [README.md](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/README.md) im Rezept dokumentiert ein wiederholbares Verfahren zur Erstellung dieses Artefakts. Das Verfahren verwendet eine neu gestartete Amazon EC2 EC2-Instance, um eine saubere Umgebung für die Installation bereitzustellen, die Sie dann beenden können, nachdem Sie das Ergebnis gespeichert haben. Um andere Anwendungen zu verpacken, für die Administratorzugriff erforderlich ist, können Sie ein ähnliches Verfahren anwenden, sobald Sie den Satz von Dateien festgelegt haben, den die Anwendung benötigt.
1. Öffnen Sie die Dateien [recipe/recipe.yaml und [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), um die Einstellungen für Rattler-Build und Conda-Build zu überprüfen oder zu bearbeiten. Sie können den Paketnamen und die Version für die Anwendung festlegen, die Sie verpacken.
Der **Quellbereich** enthält einen Verweis auf die Archive, einschließlich des Sha256-Hashs der Dateien. Immer wenn Sie diese Dateien ändern, z. B. auf eine neue Version, müssen Sie diese Werte berechnen und aktualisieren.
Der **Build-Abschnitt** enthält hauptsächlich Optionen zum Ausschalten der standardmäßigen Binärverschiebungsoptionen, da die automatischen Mechanismen für die speziellen Bibliotheks- und Binärverzeichnisse, die das Paket verwendet, nicht richtig funktionieren.
Schließlich können Sie im Abschnitt „**Über**“ einige Metadaten über die Anwendung eingeben, die beim Durchsuchen oder Verarbeiten des Inhalts eines Conda-Kanals verwendet werden können.
**Schreiben Sie das Paketerstellungsskript**
1. Die Paketerstellungsskripten im Maya Conda-Beispielbaurezept enthalten Kommentare, in denen die Schritte erklärt werden, die die Skripts ausführen. Lesen Sie sich die Kommentare und Befehle durch, um Folgendes herauszufinden:
+ Wie das Rezept mit der RPM-Datei umgeht von Autodesk
+ Die Änderungen, die das Rezept vornimmt, damit die Installation in die virtuellen Conda-Umgebungen verlagert werden kann, in denen das Rezept installiert ist
+ Wie das Rezept Hilfsvariablen festlegt`MAYA_VERSION`, z. B. `MAYA_LOCATION` und anhand derer Ihre Software nachvollziehen kann, ob Maya sie ausgeführt wird.
1. Öffnen Sie zum Beispiel die Datei [recipe/build.sh Linux](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/recipe/build.sh), um das Paketerstellungsskript zu überprüfen oder zu bearbeiten.
Öffnen Sie für die Datei [recipe/build\$1win.sh Windows](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-2025/recipe/build_win.sh), um das Paketerstellungsskript zu überprüfen oder zu bearbeiten.
**Reichen Sie einen Job ein, der die Maya Pakete erstellt**
1. Geben Sie das `conda_recipes` Verzeichnis in Ihrem Klon des GitHub [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples)Repositorys ein.
1. Stellen Sie sicher, dass Ihre Deadline Cloud-Farm für Ihre Deadline Cloud-CLI konfiguriert ist. Wenn Sie die Schritte zum [Erstellen eines Conda-Kanals mit Amazon S3](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/configure-jobs-s3-channel.html) befolgt haben, sollte Ihre Farm für Ihre CLI konfiguriert sein.
1. Führen Sie den folgenden Befehl aus, um einen Job einzureichen, der Linux sowohl Windows Pakete als auch erstellt.
` ./submit-package-job maya-2025 --all-platforms`
# Erstellen Sie ein Conda-Build-Rezept für das Plugin Autodesk Maya to Arnold (MtoA)
Sie können Plugins für kommerzielle Anwendungen als Conda-Pakete verpacken. Plugins sind dynamisch geladene Bibliotheken, die eine von einer Anwendung bereitgestellte Anwendungsbinärschnittstelle (ABI) verwenden, um die Funktionalität dieser Anwendung zu erweitern. Das Maya to Arnold (MtoA) Plugin fügt den Arnold Renderer als Option hinzu. Maya
+ Das MtoA Beispiel-Build-Rezept hängt vom **Maya**Paket ab und verwendet eine `==` Einschränkung für die Version.
+ Das Maya Paket konfiguriert einen Maya Modulpfad in der virtuellen Umgebung`$PREFIX/usr/autodesk/maya$MAYA_VERSION/modules`, in dem das Plugin eine `.mod` Datei platzieren kann. Das MtoA Beispiel-Build-Rezept erstellt eine Datei `mtoa.mod` in diesem Verzeichnis.
**Schreiben Sie die Rezept-Metadaten**
1. Öffnen Sie das Verzeichnis GitHub [ deadline-cloud-samples/conda\$1recipes/maya-mtoa-2025](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes/maya-mtoa-2025) in Ihrem Browser oder in einem Texteditor in Ihrem lokalen Klon des Repositorys.
Das Rezept folgt den gleichen Mustern wie das Maya Conda-Build-Rezept und verwendet dieselben Quellarchive, um das Plugin zu installieren.
1. Öffnen Sie die Dateien [recipe/recipe.yaml und recipe/meta.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-mtoa-2025/recipe/recipe.yaml)[, um die Einstellungen für Rattler-Build](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/conda_recipes/maya-mtoa-2025/recipe/meta.yaml) und für Conda-Build zu überprüfen oder zu bearbeiten. Diese Dateien spezifizieren eine Abhängigkeit, von der während der Paketerstellung und beim Erstellen einer virtuellen Umgebung zur Ausführung des Plugins abhängig ist. `maya`
**Schreiben Sie das Paketerstellungsskript**
+ Die Paketerstellungsskripten im MtoA Conda-Beispielbaurezept enthalten Kommentare, in denen die Schritte erklärt werden, die die Skripts ausführen. Lesen Sie sich die Kommentare und Befehle durch, um zu erfahren, wie das Rezept eine Datei `mtoa.mod` in dem im Maya Paket angegebenen Verzeichnis installiert MtoA und erstellt.
Arnoldund Maya verwenden dieselbe Lizenzierungstechnologie, sodass das Maya Conda-Build-Rezept bereits die Informationen enthält, die von Arnold benötigt werden.
Die Unterschiede zwischen den Skripten Linux und den Windows Build-Skripten ähneln denen für das Maya Conda-Build-Rezept.
**Reichen Sie einen Job ein, der die Maya MtoA Plugin-Pakete erstellt**
1. Geben Sie das `conda_recipes` Verzeichnis in Ihrem Klon des GitHub [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples)Repositorys ein.
1. Stellen Sie sicher, dass Sie Pakete für die Maya Host-Anwendung aus dem vorherigen Abschnitt erstellt haben.
1. Stellen Sie sicher, dass Ihre Deadline Cloud-Farm für Ihre Deadline Cloud-CLI konfiguriert ist. Wenn Sie die Schritte zum [Erstellen eines Conda-Kanals mit Amazon S3](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/configure-jobs-s3-channel.html) befolgt haben, sollte Ihre Farm für Ihre CLI konfiguriert sein.
1. Führen Sie den folgenden Befehl aus, um einen Job einzureichen, der Linux sowohl Windows Pakete als auch erstellt.
` ./submit-package-job maya-mtoa-2025 --all-platforms`
# Testen Sie Ihr Paket mit einem Maya Renderjob
Nachdem Sie die Version Maya 2025 und die MtoA Pakete erstellt haben, können Sie Jobs zum Rendern mit dem Paket einreichen. Das Beispiel „[Turntable with Maya/Arnold](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/turntable_with_maya_arnold) Job Bundle“ rendert eine Animation mit Maya und. Arnold Dieses Beispiel wird auch FFmpeg zum Kodieren eines Videos verwendet. Sie können den Conda-Forge-Kanal zur Standardliste `CondaChannels` in Ihrer Conda-Warteschlangenumgebung hinzufügen, um eine Quelle für das Paket bereitzustellen. `ffmpeg`
Führen Sie im `job_bundles` Verzeichnis in Ihrem Git-Klon von den [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples)folgenden Befehl aus.
```
deadline bundle submit turntable_with_maya_arnold
```
Sie können den Deadline Cloud-Monitor verwenden, um den Fortschritt Ihres Jobs zu verfolgen:
1. Wählen Sie im Monitor die Aufgabe für den Job aus, den Sie eingereicht haben, und wählen Sie dann die Option, um das Protokoll anzuzeigen.
1. Wählen Sie auf der rechten Seite der Protokollansicht die Aktion **Conda-Sitzung starten** aus.
Sie können sehen, dass die Aktion nach maya und maya-mtoa in den für die Warteschlangenumgebung konfigurierten Conda-Kanälen gesucht hat und dass sie die Pakete im S3-Kanal gefunden hat.
# Automatisieren Sie Paketerstellungen mit Deadline Cloud
Für CI/CD Workflows oder wenn Sie Pakete für mehrere Betriebssysteme erstellen müssen, können Sie eine Deadline Cloud-Warteschlange zur Paketerstellung erstellen. Die Warteschlangenpläne erstellen Jobs in Ihrer Flotte, die die Pakete erstellen und sie in Ihrem Amazon Simple Storage Service (Amazon S3) Conda-Kanal veröffentlichen. Dies vereinfacht die Verwaltung kontinuierlicher Paket-Builds für Softwareversionen in all Ihren erforderlichen Konfigurationen.
Sie können eine Warteschlange zur Paketerstellung mithilfe einer Vorlage AWS CloudFormation (CloudFormation) oder manuell über die Deadline Cloud-Konsole erstellen. Die CloudFormation Vorlage stellt eine komplette Farm mit einer Produktionswarteschlange und einer Warteschlange zur Paketerstellung bereit, die bereits konfiguriert sind. Wenn Sie die Warteschlange von der Konsole aus erstellen, haben Sie mehr Kontrolle über einzelne Einstellungen.
## Erstellen Sie eine Warteschlange zum Erstellen von Paketen mit CloudFormation
Sie können eine CloudFormation Vorlage verwenden, um eine Deadline Cloud-Farm zu erstellen, die eine Warteschlange zur Paketerstellung enthält. Die Vorlage konfiguriert eine Produktionswarteschlange und eine Warteschlange zur Paketerstellung mit einem privaten Amazon S3 S3-Conda-Kanal.
Bevor Sie die Vorlage bereitstellen, erstellen Sie einen Amazon S3 S3-Bucket für Jobanhänge und Ihren Conda-Kanal. Sie können einen Bucket von der [Amazon S3 S3-Konsole](https://console.aws.amazon.com/s3/) aus erstellen. Sie benötigen den Bucket-Namen, wenn Sie die Vorlage bereitstellen.
**Um die CloudFormation Vorlage bereitzustellen**
1. Laden Sie die Vorlage [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) aus dem [Deadline Cloud-Beispiel-Repository](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/starter_farm) unter herunter. GitHub
1. Wählen Sie in der [CloudFormation Konsole](https://console.aws.amazon.com/cloudformation/) „**Stack erstellen**“ und dann „**Mit neuen Ressourcen**“ (Standard) aus.
1. Wählen Sie die Option zum Hochladen einer Vorlagendatei und laden Sie dann die `deadline-cloud-starter-farm-template.yaml` Datei hoch.
1. Geben Sie einen Namen für den Stack ein, z. B.**StarterFarm**, und geben Sie den Namen eines Amazon S3 S3-Buckets für Jobanhänge und den Conda-Kanal an.
1. Folgen Sie den Schritten auf der CloudFormation Konsole, um die Stack-Erstellung abzuschließen.
Weitere Informationen zu den Vorlagenparametern und Anpassungsoptionen finden Sie in der [README-Datei für die Starter-Farm im Deadline-Cloud-Beispiel-Repository](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/cloudformation/farm_templates/starter_farm) unterGitHub.
## Erstellen Sie von der Konsole aus eine Warteschlange zur Paketerstellung
Folgen Sie den Anweisungen unter [Eine Warteschlange erstellen](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue.html) im *Deadline Cloud-Benutzerhandbuch*. Nehmen Sie die folgenden Änderungen vor:
+ Wählen Sie in Schritt 5 einen vorhandenen Amazon S3 S3-Bucket aus. Geben Sie einen Namen für den Stammordner an, z. B. **DeadlineCloudPackageBuild** damit Build-Artefakte von Ihren normalen Deadline Cloud-Anhängen getrennt bleiben.
+ In Schritt 6 können Sie die Warteschlange zur Paketerstellung einer vorhandenen Flotte zuordnen oder eine völlig neue Flotte erstellen, falls Ihre aktuelle Flotte nicht geeignet ist.
+ Erstellen Sie in Schritt 9 eine neue Servicerolle für Ihre Paketbau-Warteschlange. Sie werden die Berechtigungen ändern, um der Warteschlange die Berechtigungen zu geben, die für das Hochladen von Paketen und die Neuindizierung eines Conda-Kanals erforderlich sind.
### Konfigurieren Sie die Berechtigungen für die Warteschlange zum Erstellen von Paketen
Damit die Warteschlange zur Paketerstellung auf das `/Conda` Präfix im Amazon S3 S3-Bucket der Warteschlange zugreifen kann, müssen Sie die Rolle der Warteschlange ändern, um ihr read/write Zugriff zu gewähren. Die Rolle benötigt die folgenden Berechtigungen, damit Paketerstellungsaufträge neue Pakete hochladen und den Channel neu indizieren können.
+ `s3:GetObject`
+ `s3:PutObject`
+ `s3:ListBucket`
+ `s3:GetBucketLocation`
+ `s3:DeleteObject`
1. Öffnen Sie die Deadline Cloud-Konsole und navigieren Sie zur Seite mit den Warteschlangendetails für die Warteschlange zur Paketerstellung.
1. Wählen Sie die Warteschlangendienst-Rolle und anschließend **Warteschlange bearbeiten** aus.
1. Scrollen Sie zum Abschnitt **Warteschlangendienstrolle** und wählen Sie dann **Diese Rolle in der IAM-Konsole anzeigen** aus.
1. Wählen Sie aus der Liste der Berechtigungsrichtlinien die **AmazonDeadlineCloudQueuePolicy**für Ihre Warteschlange aus.
1. Wählen Sie auf der Registerkarte „**Berechtigungen**“ die Option **Bearbeiten** aus.
1. Fügen Sie der Warteschlangendienst-Rolle einen neuen Abschnitt wie den folgenden hinzu. Ersetzen Sie *amzn-s3-demo-bucket* und *111122223333* durch Ihren eigenen Bucket und Ihr eigenes Konto.
```
{
"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"
}
}
},
```
## Reichen Sie einen Auftrag zur Paketerstellung ein
Nachdem Sie eine Warteschlange zum Erstellen von Paketen erstellt und die Warteschlangenberechtigungen konfiguriert haben, können Sie Aufträge zum Erstellen von Conda-Paketen einreichen. Das `submit-package-job` Skript im [Deadline Cloud-Beispiel-Repository](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/conda_recipes#readme) unter GitHub sendet einen Build-Job für ein Conda-Rezept.
Sie benötigen Folgendes:
+ Die [Deadline Cloud-CLI](https://github.com/aws-deadline/deadline-cloud) ist auf Ihrer Workstation installiert.
+ Eine aktive [AWS Anmeldesitzung für den Deadline Cloud-Monitor (Deadline Cloud-Monitor)](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/working-with-deadline-monitor.html).
+ Ein Klon des [Deadline Cloud-Beispiel-Repositorys](https://github.com/aws-deadline/deadline-cloud-samples).
**Um einen Auftrag zur Paketerstellung einzureichen**
1. Öffnen Sie die Deadline Cloud-Konfigurations-GUI und legen Sie die Standardfarm und -warteschlange auf Ihre Paketerstellungswarteschlange fest.
```
deadline config gui
```
1. Wechseln Sie in das `conda_recipes` Verzeichnis im Beispiel-Repository.
```
cd deadline-cloud-samples/conda_recipes
```
1. Führen Sie das `submit-package-job` Skript mit dem Rezeptverzeichnis aus. Das folgende Beispiel erstellt das Blender 4.5-Rezept.
```
./submit-package-job blender-4.5/
```
Wenn für das Rezept ein Quellarchiv erforderlich ist, das Sie noch nicht heruntergeladen haben, enthält das Skript Anweisungen zum Herunterladen. Laden Sie das Archiv herunter und führen Sie das Skript erneut aus.
Nachdem Sie den Job eingereicht haben, können Sie den Deadline Cloud-Monitor verwenden, um den Fortschritt und Status des Jobs zu überprüfen.
![\[Der Deadline Cloud-Monitor zeigt den Fortschritt und den Status eines Jobs, der ein Conda-Paket erstellt.\]](http://docs.aws.amazon.com/de_de/deadline-cloud/latest/developerguide/images/Conda-Figure3.png)
Der Monitor zeigt die beiden Schritte des Jobs: das Erstellen des Pakets und die anschließende Neuindizierung des Conda-Kanals. Wenn Sie mit der rechten Maustaste auf die Aufgabe für den Schritt zur Paketerstellung klicken und **Protokolle anzeigen** wählen, zeigt der Monitor die Sitzungsaktionen an:
+ **Anlagen synchronisieren** — Kopiert die Anlagen des Eingabeauftrags oder hängt ein virtuelles Dateisystem ein.
+ **Starten Sie Conda** — Die Aktion für die Warteschlangenumgebung. Der Build-Job spezifiziert keine Conda-Pakete, sodass diese Aktion schnell abgeschlossen wird.
+ **Launch CondaBuild Env** — Erstellt eine virtuelle Conda-Umgebung mit der Software, die zum Erstellen eines Conda-Pakets und zur Neuindizierung eines Kanals erforderlich ist.
+ **Task run** — Erstellt das Paket und lädt die Ergebnisse auf Amazon S3 hoch.
Während die Aktionen ausgeführt werden, senden sie Protokolle an Amazon CloudWatch (CloudWatch). Wenn ein Job abgeschlossen ist, wählen Sie **Protokolle für alle Aufgaben anzeigen** aus, um zusätzliche Protokolle über die Einrichtung und den Abbau der Umgebung einzusehen.