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.
# Jobs mithilfe von Warteschlangenumgebungen konfigurieren
AWS Deadline Cloud verwendet *Warteschlangenumgebungen*, um die Software auf Ihren Mitarbeitern zu konfigurieren. In einer Umgebung können Sie zeitaufwändige Aufgaben wie Einrichtung und Abbau einmal für alle Aufgaben in einer Sitzung ausführen. Sie definiert die Aktionen, die auf einem Worker ausgeführt werden, wenn eine Sitzung gestartet oder beendet wird. Sie können eine Umgebung für eine Warteschlange, Jobs, die in der Warteschlange ausgeführt werden, und die einzelnen Schritte für einen Job konfigurieren.
Sie definieren Umgebungen als Warteschlangenumgebungen oder Jobumgebungen. Erstellen Sie Warteschlangenumgebungen mit der Deadline Cloud-Konsole oder mit dem [Deadline: CreateQueueEnvironment](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateQueueEnvironment.html) -Betrieb und definieren Sie Jobumgebungen in den Jobvorlagen der Jobs, die Sie einreichen. Sie folgen der Open Job Description (OpenJD) -Spezifikation für Umgebungen. Einzelheiten finden Sie[https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment) in der OpenJD-Spezifikation unter. GitHub
Zusätzlich zu einem `name` und enthält jede Umgebung zwei Felder`description`, die die Umgebung auf dem Host definieren. Diese sind:
+ `script`— Die Aktion, die ergriffen wird, wenn diese Umgebung auf einem Worker ausgeführt wird.
+ `variables`— Eine Reihe von name/value Umgebungsvariablenpaaren, die beim Betreten der Umgebung festgelegt werden.
Sie müssen mindestens einen von `script` oder festlegen`variables`.
Sie können in Ihrer Jobvorlage mehr als eine Umgebung definieren. Jede Umgebung wird in der Reihenfolge angewendet, in der sie in der Vorlage aufgeführt ist. Sie können dies verwenden, um die Komplexität Ihrer Umgebungen zu bewältigen.
Die Standard-Warteschlangenumgebung für Deadline Cloud verwendet den Conda-Paketmanager, um Software in die Umgebung zu laden, aber Sie können auch andere Paketmanager verwenden. Die Standardumgebung definiert zwei Parameter, um die Software anzugeben, die geladen werden soll. Diese Variablen werden von den von Deadline Cloud bereitgestellten Einsendern festgelegt. Sie können sie jedoch auch in Ihren eigenen Skripten und Anwendungen festlegen, die die Standardumgebung verwenden. Diese sind:
+ `CondaPackages`— Eine durch Leerzeichen getrennte Liste von Conda-Paketen, die den Spezifikationen entsprechen, die für den Job installiert werden sollen. Zum Beispiel würde der Blender-Absender in Blender 3.6 zusätzliche Bilder `blender=3.6` zum Rendern hinzufügen.
+ `CondaChannels`— Eine durch Leerzeichen getrennte Liste von Conda-Kanälen, aus denen Pakete installiert werden sollen. Für vom Service verwaltete Flotten werden Pakete vom Channel aus installiert. `deadline-cloud` Sie können weitere Kanäle hinzufügen.
# Steuern Sie die Jobumgebung mit OpenJD-Warteschlangenumgebungen
Mithilfe von *Warteschlangenumgebungen* können Sie benutzerdefinierte Umgebungen für Ihre Renderaufträge definieren. Eine Warteschlangenumgebung ist eine Vorlage, die die Umgebungsvariablen, Dateizuordnungen und andere Einstellungen für Jobs steuert, die in einer bestimmten Warteschlange ausgeführt werden. Sie ermöglicht es Ihnen, die Ausführungsumgebung für die an eine Warteschlange eingereichten Jobs an die Anforderungen Ihrer Workloads anzupassen. AWS Deadline Cloud bietet drei verschachtelte Ebenen, auf die Sie [Open Job Description (OpenJD) -Umgebungen](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment) anwenden können: Queue, Job und Step. Durch die Definition von Warteschlangenumgebungen können Sie eine konsistente und optimierte Leistung für verschiedene Arten von Jobs sicherstellen, die Ressourcenzuweisung optimieren und die Warteschlangenverwaltung vereinfachen.
Die Warteschlangenumgebung ist eine Vorlage, die Sie über die AWS Verwaltungskonsole oder mithilfe der an eine Warteschlange in Ihrem AWS Konto anhängen. AWS CLI Sie können eine Umgebung für eine Warteschlange erstellen, oder Sie können mehrere Warteschlangenumgebungen erstellen, die angewendet wurden, um die Ausführungsumgebung zu erstellen. Dieser Ansatz ermöglicht es Ihnen, eine Umgebung schrittweise zu erstellen und zu testen, um sicherzustellen, dass sie für Ihre Jobs ordnungsgemäß funktioniert.
Job- und Step-Umgebungen sind in der Jobvorlage definiert, mit der Sie einen Job in Ihrer Warteschlange erstellen. Die OpenJD-Syntax ist in diesen verschiedenen Formen von Umgebungen dieselbe. In diesem Abschnitt werden wir sie innerhalb von Jobvorlagen zeigen.
**Topics**
+ [Legen Sie Umgebungsvariablen in einer Warteschlangenumgebung fest](set-environment-variables.md)
+ [Legen Sie den Pfad in einer Warteschlangenumgebung fest](set-the-path.md)
+ [Führen Sie einen Hintergrund-Daemon-Prozess in der Warteschlangenumgebung aus](run-a-background-daemon-process.md)
# Legen Sie Umgebungsvariablen in einer Warteschlangenumgebung fest
Viele Anwendungen und Frameworks verwenden Umgebungsvariablen, um Funktionseinstellungen, Protokollierungsebenen und die Anzeigekonfiguration zu steuern. Sie können [Open Job Description (OpenJD) -Umgebungen](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment) verwenden, um Umgebungsvariablen festzulegen, die jeder Taskbefehl innerhalb seines Gültigkeitsbereichs erbt.
## Gültigkeitsbereich der Umgebungsvariablen
AWS Deadline Cloud wendet Umgebungsvariablen aus Warteschlangenumgebungen an, die Sie an eine Warteschlange anhängen. Innerhalb einer Jobvorlage können Sie mithilfe von [OpenJD-Umgebungen](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#4-environment) auch Umgebungsvariablen auf Job- und Schrittebene definieren. Variablen, die in einem engeren Gültigkeitsbereich definiert sind, überschreiben Variablen mit demselben Namen aus einem breiteren Gültigkeitsbereich.
+ **Warteschlangenumgebung** — Eine Vorlage, die Sie an eine Warteschlange in Deadline Cloud anhängen. Variablen gelten für alle Jobs, die an die Warteschlange gesendet werden. Sie können Variablen mit einer `variables` Zuordnung für feste Werte festlegen oder Skripts für dynamische Werte verwenden.
+ **Arbeitsumgebung** — Definiert unter `jobEnvironments` in einer Jobvorlage. Variablen gelten für alle Schritte und Aufgaben im Job. Eine Variable auf Jobebene überschreibt eine Variable auf Warteschlangenebene mit demselben Namen.
+ **Schrittumgebung** — Definiert unter `stepEnvironments` in einer Jobvorlage. Variablen gelten nur für die Aufgaben in diesem Schritt. Eine Variable auf Schrittebene überschreibt eine Variable auf Job- oder Warteschlangenebene mit demselben Namen.
## Setzen von Variablen in einer Warteschlangenumgebung
Sie können Umgebungsvariablen in einer Warteschlangenumgebung mithilfe einer `variables` Map für feste Werte oder `script` mithilfe einer `onEnter` With-Aktion für dynamische Werte festlegen.
Die folgende Vorlage für die Warteschlangenumgebung verwendet eine `variables` Map, auf die die `QT_QPA_PLATFORM` Variable gesetzt wird`offscreen`, sodass Anwendungen, die das [Qt Framework](https://www.qt.io/product/framework) verwenden, auf Worker-Hosts ohne interaktive Anzeige ausgeführt werden können.
```
specificationVersion: 'environment-2023-09'
environment:
name: QtOffscreen
variables:
QT_QPA_PLATFORM: offscreen
```
Verwenden Sie für dynamische Werte, wie das Ändern `PATH` oder Aktivieren virtueller Umgebungen, ein Skript, das Zeilen im Format stdout `openjd_env: VAR=value` ausgibt. Das `openjd_env:` Präfix ist erforderlich. Durch die Verwendung von `echo``export`, oder anderen Shell-Mechanismen ohne das Präfix werden Variablen nicht an Jobs und Aufgaben weitergegeben.
Die folgende Vorlage für die Warteschlangenumgebung legt die `QT_QPA_PLATFORM` Variable mithilfe eines Skripts fest.
```
specificationVersion: 'environment-2023-09'
environment:
name: QtOffscreen
script:
actions:
onEnter:
command: bash
args:
- "{{Env.File.Enter}}"
embeddedFiles:
- name: Enter
type: TEXT
data: |
#!/bin/env bash
set -euo pipefail
echo "openjd_env: QT_QPA_PLATFORM=offscreen"
```
Um eine Warteschlangenumgebung an Ihre Warteschlange anzuhängen, verwenden Sie die Deadline Cloud-Konsole oder die AWS CLI. Weitere Informationen finden Sie unter [Erstellen einer Warteschlangenumgebung](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html) im AWS Deadline Cloud-Benutzerhandbuch. Der folgende AWS CLI Befehl erstellt eine Warteschlangenumgebung aus einer Vorlagendatei.
```
aws deadline create-queue-environment \
--farm-id FARM_ID \
--queue-id QUEUE_ID \
--priority 1 \
--template-type YAML \
--template file://my-queue-env.yaml
```
Komplexere Beispiele, wie das Erstellen und Aktivieren virtueller Conda-Umgebungen, finden Sie unter [Beispiele für Deadline Cloud-Warteschlangenumgebungen](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/queue_environments) unter GitHub.
## Variablen in einer Jobvorlage festlegen
Fügen Sie in einer Jobvorlage eine `variables` Map zu einem `jobEnvironments` `stepEnvironments` OR-Eintrag hinzu. Jeder Eintrag ist ein Schlüssel-Wert-Paar, wobei der Schlüssel der Variablenname und der Wert der Variablenwert ist.
Die folgende Jobvorlage setzt die `QT_QPA_PLATFORM` Umgebungsvariable auf`offscreen`, sodass Anwendungen, die das [Qt Framework](https://www.qt.io/product/framework) verwenden, auf Worker-Hosts ohne interaktive Anzeige ausgeführt werden können.
```
specificationVersion: 'jobtemplate-2023-09'
name: MyJob
jobEnvironments:
- name: JobEnv
variables:
QT_QPA_PLATFORM: offscreen
```
Sie können mehrere Variablen in einer einzigen Umgebungsdefinition festlegen.
```
jobEnvironments:
- name: JobEnv
variables:
JOB_VERBOSITY: MEDIUM
JOB_PROJECT_ID: my-project-id
JOB_ENDPOINT_URL: https://my-host-name/my/path
QT_QPA_PLATFORM: offscreen
```
Mithilfe der `{{Param.ParameterName}}` Syntax können Sie in Variablenwerten auf Jobparameter verweisen.
```
jobEnvironments:
- name: JobEnv
variables:
JOB_EXAMPLE_PARAM: "{{Param.ExampleParam}}"
```
Um eine Variable auf Jobebene für einen bestimmten Schritt zu überschreiben, definieren Sie einen `stepEnvironments` Eintrag mit demselben Variablennamen. Das folgende Beispiel definiert `JOB_PROJECT_ID` auf Auftragsebene mit dem Wert `project-12` und überschreibt dann den Wert auf Schrittebene mit. `step-project-12` Die Aufgaben im Schritt verwenden den Wert auf Schrittebene.
```
specificationVersion: 'jobtemplate-2023-09'
name: MyJob
jobEnvironments:
- name: JobEnv
variables:
JOB_PROJECT_ID: project-12
steps:
- name: MyStep
stepEnvironments:
- name: StepEnv
variables:
JOB_PROJECT_ID: step-project-12
```
## Probieren Sie es aus: Beispiel für die Umgebungsvariable ausführen
Das Deadline Cloud-Beispiel-Repository enthält ein [Job-Bundle, das das Setzen und Anzeigen von Umgebungsvariablen demonstriert](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_vars/template.yaml). Die Beispieljobvorlage definiert Variablen sowohl auf Auftrags- als auch auf Schrittebene und führt dann eine Aufgabe aus, die das zusammengeführte Ergebnis druckt. Gehen Sie wie folgt vor, um das Beispiel auszuführen und die Ergebnisse zu überprüfen.
### Voraussetzungen
1. Wenn Sie keine Deadline Cloud-Farm mit einer Warteschlange und der zugehörigen Linux-Flotte haben, folgen Sie der Anleitung zum Onboarding in der [Deadline Cloud-Konsole](https://console.aws.amazon.com/deadlinecloud/home), um eine Farm mit Standardeinstellungen zu erstellen.
1. Wenn Sie die Deadline Cloud-CLI und den AWS Deadline Cloud-Monitor nicht auf Ihrer Workstation haben, folgen Sie den Schritten unter [Deadline Cloud-Einreicher einrichten](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submitter.html).
1. Wird verwendet`git`, um das [Deadline GitHub Cloud-Beispiel-Repository](https://github.com/aws-deadline/deadline-cloud-samples) zu klonen.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
cd deadline-cloud-samples/job_bundles
```
### Ausführen des Beispiels
1. Verwenden Sie die Deadline Cloud-CLI, um das `job_env_vars` Beispiel einzureichen.
```
deadline bundle submit job_env_vars
```
1. Wählen Sie im Deadline Cloud-Monitor den neuen Job aus, um seinen Fortschritt zu überwachen. Sobald für die Linux Flotte, die der Warteschlange zugeordnet ist, ein Mitarbeiter verfügbar ist, ist der Job in wenigen Sekunden abgeschlossen. Wählen Sie die Aufgabe aus und wählen Sie dann im Menü oben rechts im Aufgabenbereich die Option **Protokolle anzeigen** aus.
### Vergleich von Sitzungsaktionen mit ihren Definitionen
In der Protokollansicht werden drei Sitzungsaktionen angezeigt. Öffnen Sie die Datei [job\$1env\$1vars/template.yaml](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_vars/template.yaml) in einem Texteditor, um jede Aktion mit ihrer Definition in der Jobvorlage zu vergleichen.
1. ** JobEnvWählen** Sie die Aktion Sitzung starten aus. Die Protokollausgabe zeigt, dass die Umgebungsvariablen auf Jobebene gesetzt wurden.
```
Setting: JOB_VERBOSITY=MEDIUM
Setting: JOB_EXAMPLE_PARAM=An example parameter value
Setting: JOB_PROJECT_ID=project-12
Setting: JOB_ENDPOINT_URL=https://internal-host-name/some/path
Setting: QT_QPA_PLATFORM=offscreen
```
Die folgenden Zeilen aus der Jobvorlage definieren diese Umgebung.
```
jobEnvironments:
- name: JobEnv
variables:
JOB_VERBOSITY: MEDIUM
JOB_EXAMPLE_PARAM: "{{Param.ExampleParam}}"
JOB_PROJECT_ID: project-12
JOB_ENDPOINT_URL: https://internal-host-name/some/path
QT_QPA_PLATFORM: offscreen
```
1. Wählen Sie die Aktion StepEnv Sitzung **starten** aus. Die Protokollausgabe zeigt die Variablen auf Schrittebene, einschließlich der überschriebenen Variablen. `JOB_PROJECT_ID`
```
Setting: STEP_VERBOSITY=HIGH
Setting: JOB_PROJECT_ID=step-project-12
```
Die folgenden Zeilen aus der Jobvorlage definieren diese Umgebung.
```
stepEnvironments:
- name: StepEnv
variables:
STEP_VERBOSITY: HIGH
JOB_PROJECT_ID: step-project-12
```
1. Wählen Sie **die Aktion Sitzung ausführen aus**. In der Protokollausgabe werden die zusammengeführten Umgebungsvariablen angezeigt, die für die Aufgabe verfügbar sind. Beachten Sie, dass der Wert auf Schrittebene `JOB_PROJECT_ID` verwendet wird. `step-project-12`
```
Environment variables starting with JOB_*:
JOB_ENDPOINT_URL=https://internal-host-name/some/path
JOB_EXAMPLE_PARAM='An example parameter value'
JOB_PROJECT_ID=step-project-12
JOB_VERBOSITY=MEDIUM
Environment variables starting with STEP_*:
STEP_VERBOSITY=HIGH
```
# Legen Sie den Pfad in einer Warteschlangenumgebung fest
Verwenden Sie OpenJD-Umgebungen, um neue Befehle in einer Umgebung bereitzustellen. Zuerst erstellen Sie ein Verzeichnis mit Skriptdateien und fügen dieses Verzeichnis dann zu den `PATH` Umgebungsvariablen hinzu, sodass die ausführbaren Dateien in Ihrem Skript sie ausführen können, ohne jedes Mal den Verzeichnispfad angeben zu müssen. Die Liste der Variablen in einer Umgebungsdefinition bietet keine Möglichkeit, die Variable zu ändern. Sie tun dies also, indem Sie stattdessen ein Skript ausführen. Nachdem das Skript die Dinge eingerichtet und geändert hat`PATH`, exportiert es die Variable mit dem Befehl in die OpenJD-Laufzeit. `echo "openjd_env: PATH=$PATH"`
## Voraussetzungen
Führen Sie die folgenden Schritte aus, um das [Beispiel-Job-Bundle mit Umgebungsvariablen](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_vars/template.yaml) aus dem Github-Repository für Beispiele von Deadline Cloud auszuführen.
1. Wenn Sie keine Deadline Cloud-Farm mit einer Warteschlange und der zugehörigen Linux-Flotte haben, folgen Sie der Anleitung zum Onboarding in der [Deadline Cloud-Konsole](https://console.aws.amazon.com/deadlinecloud/home), um eine Farm mit Standardeinstellungen zu erstellen.
1. Wenn Sie die Deadline Cloud-CLI und den Deadline Cloud-Monitor nicht auf Ihrer Workstation haben, folgen Sie den Schritten unter [Deadline Cloud-Einreicher einrichten](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submitter.html) im Benutzerhandbuch.
1. Wird verwendet`git`, um das [Deadline GitHub Cloud-Beispiel-Repository](https://github.com/aws-deadline/deadline-cloud-samples) zu klonen.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
Cloning into 'deadline-cloud-samples'...
...
cd deadline-cloud-samples/job_bundles
```
## Führen Sie das Pfadbeispiel aus
1. Verwenden Sie die Deadline Cloud-CLI, um das `job_env_with_new_command` Beispiel einzureichen.
```
$ deadline bundle submit job_env_with_new_command
Submitting to Queue: MySampleQueue
...
```
1. Im Deadline Cloud-Monitor sehen Sie den neuen Job und können seinen Fortschritt überwachen. Sobald für die Linux Flotte, die der Warteschlange zugeordnet ist, ein Mitarbeiter zur Verfügung steht, der die Aufgabe des Jobs ausführen kann, ist der Job in wenigen Sekunden abgeschlossen. Wählen Sie die Aufgabe aus und wählen Sie dann im Menü oben rechts im Aufgabenbereich die Option **Protokolle anzeigen**.
Auf der rechten Seite befinden sich zwei Sitzungsaktionen: **Starten RandomSleepCommand** und **Ausführen von Aufgaben**. Die Protokollanzeige in der Mitte des Fensters entspricht der ausgewählten Sitzungsaktion auf der rechten Seite.
## Vergleichen Sie die Sitzungsaktionen mit ihren Definitionen
In diesem Abschnitt verwenden Sie den Deadline Cloud-Monitor, um die Sitzungsaktionen mit der Position zu vergleichen, in der sie in der Jobvorlage definiert sind. Es geht weiter mit dem vorherigen Abschnitt.
Öffnen Sie die Datei [job\$1env\$1with\$1new\$1command/template.yaml in einem Texteditor](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_with_new_command/template.yaml). Vergleichen Sie die Sitzungsaktionen mit den Aktionen, in denen sie in der Jobvorlage definiert sind.
1. Wählen Sie im Deadline Cloud-Monitor die Aktion RandomSleepCommand Sitzung **starten** aus. Sie werden die Protokollausgabe wie folgt sehen.
```
2024/07/16 17:25:32-07:00
2024/07/16 17:25:32-07:00 ==============================================
2024/07/16 17:25:32-07:00 --------- Entering Environment: RandomSleepCommand
2024/07/16 17:25:32-07:00 ==============================================
2024/07/16 17:25:32-07:00 ----------------------------------------------
2024/07/16 17:25:32-07:00 Phase: Setup
2024/07/16 17:25:32-07:00 ----------------------------------------------
2024/07/16 17:25:32-07:00 Writing embedded files for Environment to disk.
2024/07/16 17:25:32-07:00 Mapping: Env.File.Enter -> /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/embedded_filesf3tq_1os/tmpbt8j_c3f
2024/07/16 17:25:32-07:00 Mapping: Env.File.SleepScript -> /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/embedded_filesf3tq_1os/tmperastlp4
2024/07/16 17:25:32-07:00 Wrote: Enter -> /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/embedded_filesf3tq_1os/tmpbt8j_c3f
2024/07/16 17:25:32-07:00 Wrote: SleepScript -> /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/embedded_filesf3tq_1os/tmperastlp4
2024/07/16 17:25:32-07:00 ----------------------------------------------
2024/07/16 17:25:32-07:00 Phase: Running action
2024/07/16 17:25:32-07:00 ----------------------------------------------
2024/07/16 17:25:32-07:00 Running command sudo -u job-user -i setsid -w /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/tmpbwrquq5u.sh
2024/07/16 17:25:32-07:00 Command started as pid: 2205
2024/07/16 17:25:32-07:00 Output:
2024/07/16 17:25:33-07:00 openjd_env: PATH=/sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/bin:/opt/conda/condabin:/home/job-user/.local/bin:/home/job-user/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/var/lib/snapd/snap/bin
No newer logs at this moment.
```
In den folgenden Zeilen aus der Jobvorlage wurde diese Aktion angegeben.
```
jobEnvironments:
- name: RandomSleepCommand
description: Adds a command 'random-sleep' to the environment.
script:
actions:
onEnter:
command: bash
args:
- "{{Env.File.Enter}}"
embeddedFiles:
- name: Enter
type: TEXT
data: |
#!/bin/env bash
set -euo pipefail
# Make a bin directory inside the session's working directory for providing new commands
mkdir -p '{{Session.WorkingDirectory}}/bin'
# If this bin directory is not already in the PATH, then add it
if ! [[ ":$PATH:" == *':{{Session.WorkingDirectory}}/bin:'* ]]; then
export "PATH={{Session.WorkingDirectory}}/bin:$PATH"
# This message to Open Job Description exports the new PATH value to the environment
echo "openjd_env: PATH=$PATH"
fi
# Copy the SleepScript embedded file into the bin directory
cp '{{Env.File.SleepScript}}' '{{Session.WorkingDirectory}}/bin/random-sleep'
chmod u+x '{{Session.WorkingDirectory}}/bin/random-sleep'
- name: SleepScript
type: TEXT
runnable: true
data: |
...
```
1. Wählen Sie im Deadline Cloud-Monitor die Aktion StepEnv Sitzung **starten** aus. Sie sehen die Protokollausgabe wie folgt.
```
2024/07/16 17:25:33-07:00
2024/07/16 17:25:33-07:00 ==============================================
2024/07/16 17:25:33-07:00 --------- Running Task
2024/07/16 17:25:33-07:00 ==============================================
2024/07/16 17:25:33-07:00 ----------------------------------------------
2024/07/16 17:25:33-07:00 Phase: Setup
2024/07/16 17:25:33-07:00 ----------------------------------------------
2024/07/16 17:25:33-07:00 Writing embedded files for Task to disk.
2024/07/16 17:25:33-07:00 Mapping: Task.File.Run -> /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/embedded_filesf3tq_1os/tmpdrwuehjf
2024/07/16 17:25:33-07:00 Wrote: Run -> /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/embedded_filesf3tq_1os/tmpdrwuehjf
2024/07/16 17:25:33-07:00 ----------------------------------------------
2024/07/16 17:25:33-07:00 Phase: Running action
2024/07/16 17:25:33-07:00 ----------------------------------------------
2024/07/16 17:25:33-07:00 Running command sudo -u job-user -i setsid -w /sessions/session-ab132a51b9b54d5da22cbe839dd946baaw1c8hk5/tmpz81iaqfw.sh
2024/07/16 17:25:33-07:00 Command started as pid: 2256
2024/07/16 17:25:33-07:00 Output:
2024/07/16 17:25:34-07:00 + random-sleep 12.5 27.5
2024/07/16 17:26:00-07:00 Sleeping for duration 26.90
2024/07/16 17:26:00-07:00 ----------------------------------------------
2024/07/16 17:26:00-07:00 Uploading output files to Job Attachments
2024/07/16 17:26:00-07:00 ----------------------------------------------
```
1. In den folgenden Zeilen aus der Jobvorlage wurde diese Aktion angegeben.
```
steps:
- name: EnvWithCommand
script:
actions:
onRun:
command: bash
args:
- '{{Task.File.Run}}'
embeddedFiles:
- name: Run
type: TEXT
data: |
set -xeuo pipefail
# Run the script installed into PATH by the job environment
random-sleep 12.5 27.5
hostRequirements:
attributes:
- name: attr.worker.os.family
anyOf:
- linux
```
# Führen Sie einen Hintergrund-Daemon-Prozess in der Warteschlangenumgebung aus
In vielen Anwendungsfällen beim Rendern kann das Laden der Anwendungs- und Szenendaten viel Zeit in Anspruch nehmen. Wenn ein Job sie für jeden Frame neu lädt, verbringt er die meiste Zeit mit Overhead. Es ist oft möglich, die Anwendung einmal als Hintergrund-Daemon-Prozess zu laden, sie die Szenendaten laden zu lassen und ihr dann Befehle über Interprozesskommunikation (IPC) zu senden, um die Renderings durchzuführen.
Viele der Open-Source-Integrationen von Deadline Cloud verwenden dieses Muster. Das Projekt Open Job Description stellt eine [Adapter-Laufzeitbibliothek](https://github.com/OpenJobDescription/openjd-adaptor-runtime-for-python) mit robusten IPC-Mustern auf allen unterstützten Betriebssystemen bereit.
Um dieses Muster zu demonstrieren, gibt es ein [eigenständiges Beispiel-Job-Paket](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_daemon_process/template.yaml), das Python- und Bash-Code verwendet, um einen Hintergrund-Daemon und den IPC für Aufgaben zur Kommunikation mit ihm zu implementieren. Der Daemon ist in Python implementiert und wartet auf ein SIGUSR1 POSIX-Signal, das angibt, wann eine Aufgabe bearbeitet werden muss. Die Aufgabendetails werden in einer bestimmten JSON-Datei an den Daemon übergeben, und die Ergebnisse der Ausführung der Aufgabe werden als weitere JSON-Datei zurückgegeben.
## Voraussetzungen
Führen Sie die folgenden Schritte aus, um das [Beispiel-Auftragspaket mit einem Daemon-Prozess](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_daemon_process/template.yaml) aus dem Github-Repository für Beispiele von Deadline Cloud auszuführen.
1. Wenn Sie keine Deadline Cloud-Farm mit einer Warteschlange und der zugehörigen Linux-Flotte haben, folgen Sie der Anleitung zum Onboarding in der [Deadline Cloud-Konsole](https://console.aws.amazon.com/deadlinecloud/home), um eine Farm mit Standardeinstellungen zu erstellen.
1. Wenn Sie die Deadline Cloud-CLI und den Deadline Cloud-Monitor nicht auf Ihrer Workstation haben, folgen Sie den Schritten unter [Deadline Cloud-Einreicher einrichten](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submitter.html) im Benutzerhandbuch.
1. Wird verwendet`git`, um das [Deadline GitHub Cloud-Beispiel-Repository](https://github.com/aws-deadline/deadline-cloud-samples) zu klonen.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
Cloning into 'deadline-cloud-samples'...
...
cd deadline-cloud-samples/job_bundles
```
## Führen Sie das Daemon-Beispiel aus
1. Verwenden Sie die Deadline Cloud-CLI, um das `job_env_daemon_process` Beispiel einzureichen.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
Cloning into 'deadline-cloud-samples'...
...
cd deadline-cloud-samples/job_bundles
```
1. In der Deadline Cloud-Monitoranwendung sehen Sie den neuen Job und können seinen Fortschritt überwachen. Sobald für die Linux Flotte, die der Warteschlange zugeordnet ist, ein Mitarbeiter zur Verfügung steht, der die Aufgabe des Auftrags ausführt, ist der Job in etwa einer Minute abgeschlossen. Wenn Sie eine der Aufgaben ausgewählt haben, wählen Sie im Menü oben rechts im Aufgabenbereich die Option **Protokolle anzeigen**.
Auf der rechten Seite befinden sich zwei Sitzungsaktionen: **Starten DaemonProcess** und **Ausführen von Aufgaben**. Die Protokollanzeige in der Mitte des Fensters entspricht der ausgewählten Sitzungsaktion auf der rechten Seite.
Wählen Sie die Option **Protokolle für alle Aufgaben anzeigen**. In der Zeitleiste werden die restlichen Aufgaben angezeigt, die im Rahmen der Sitzung ausgeführt wurden, sowie die `Shut down DaemonProcess` Aktion, die die Umgebung verlassen hat.
## Sehen Sie sich die Daemon-Protokolle an
1. In diesem Abschnitt verwenden Sie den Deadline Cloud-Monitor, um die Sitzungsaktionen mit denen zu vergleichen, in denen sie in der Jobvorlage definiert sind. Es geht weiter mit dem vorherigen Abschnitt.
Öffnen Sie die Datei [job\$1env\$1daemon\$1process/template.yaml in einem Texteditor](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/job_env_daemon_process/template.yaml). Vergleichen Sie die Sitzungsaktionen mit den Aktionen, in denen sie in der Jobvorlage definiert sind.
1. Wählen Sie die `Launch DaemonProcess` Sitzungsaktion im Deadline Cloud-Monitor aus. Sie werden die Protokollausgabe wie folgt sehen.
```
2024/07/17 16:27:20-07:00
2024/07/17 16:27:20-07:00 ==============================================
2024/07/17 16:27:20-07:00 --------- Entering Environment: DaemonProcess
2024/07/17 16:27:20-07:00 ==============================================
2024/07/17 16:27:20-07:00 ----------------------------------------------
2024/07/17 16:27:20-07:00 Phase: Setup
2024/07/17 16:27:20-07:00 ----------------------------------------------
2024/07/17 16:27:20-07:00 Writing embedded files for Environment to disk.
2024/07/17 16:27:20-07:00 Mapping: Env.File.Enter -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/enter-daemon-process-env.sh
2024/07/17 16:27:20-07:00 Mapping: Env.File.Exit -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/exit-daemon-process-env.sh
2024/07/17 16:27:20-07:00 Mapping: Env.File.DaemonScript -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/daemon-script.py
2024/07/17 16:27:20-07:00 Mapping: Env.File.DaemonHelperFunctions -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/daemon-helper-functions.sh
2024/07/17 16:27:20-07:00 Wrote: Enter -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/enter-daemon-process-env.sh
2024/07/17 16:27:20-07:00 Wrote: Exit -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/exit-daemon-process-env.sh
2024/07/17 16:27:20-07:00 Wrote: DaemonScript -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/daemon-script.py
2024/07/17 16:27:20-07:00 Wrote: DaemonHelperFunctions -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/daemon-helper-functions.sh
2024/07/17 16:27:20-07:00 ----------------------------------------------
2024/07/17 16:27:20-07:00 Phase: Running action
2024/07/17 16:27:20-07:00 ----------------------------------------------
2024/07/17 16:27:20-07:00 Running command sudo -u job-user -i setsid -w /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/tmp_u8slys3.sh
2024/07/17 16:27:20-07:00 Command started as pid: 2187
2024/07/17 16:27:20-07:00 Output:
2024/07/17 16:27:21-07:00 openjd_env: DAEMON_LOG=/sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/daemon.log
2024/07/17 16:27:21-07:00 openjd_env: DAEMON_PID=2223
2024/07/17 16:27:21-07:00 openjd_env: DAEMON_BASH_HELPER_SCRIPT=/sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/daemon-helper-functions.sh
```
In den folgenden Zeilen aus der Jobvorlage wurde diese Aktion angegeben.
```
stepEnvironments:
- name: DaemonProcess
description: Runs a daemon process for the step's tasks to share.
script:
actions:
onEnter:
command: bash
args:
- "{{Env.File.Enter}}"
onExit:
command: bash
args:
- "{{Env.File.Exit}}"
embeddedFiles:
- name: Enter
filename: enter-daemon-process-env.sh
type: TEXT
data: |
#!/bin/env bash
set -euo pipefail
DAEMON_LOG='{{Session.WorkingDirectory}}/daemon.log'
echo "openjd_env: DAEMON_LOG=$DAEMON_LOG"
nohup python {{Env.File.DaemonScript}} > $DAEMON_LOG 2>&1 &
echo "openjd_env: DAEMON_PID=$!"
echo "openjd_env: DAEMON_BASH_HELPER_SCRIPT={{Env.File.DaemonHelperFunctions}}"
echo 0 > 'daemon_log_cursor.txt'
...
```
1. Wählen Sie im Deadline Cloud-Monitor eine der Aktionen Task run: N session aus. Sie werden die Protokollausgabe wie folgt sehen.
```
2024/07/17 16:27:22-07:00
2024/07/17 16:27:22-07:00 ==============================================
2024/07/17 16:27:22-07:00 --------- Running Task
2024/07/17 16:27:22-07:00 ==============================================
2024/07/17 16:27:22-07:00 Parameter values:
2024/07/17 16:27:22-07:00 Frame(INT) = 2
2024/07/17 16:27:22-07:00 ----------------------------------------------
2024/07/17 16:27:22-07:00 Phase: Setup
2024/07/17 16:27:22-07:00 ----------------------------------------------
2024/07/17 16:27:22-07:00 Writing embedded files for Task to disk.
2024/07/17 16:27:22-07:00 Mapping: Task.File.Run -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/run-task.sh
2024/07/17 16:27:22-07:00 Wrote: Run -> /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/embedded_fileswy00x5ra/run-task.sh
2024/07/17 16:27:22-07:00 ----------------------------------------------
2024/07/17 16:27:22-07:00 Phase: Running action
2024/07/17 16:27:22-07:00 ----------------------------------------------
2024/07/17 16:27:22-07:00 Running command sudo -u job-user -i setsid -w /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/tmpv4obfkhn.sh
2024/07/17 16:27:22-07:00 Command started as pid: 2301
2024/07/17 16:27:22-07:00 Output:
2024/07/17 16:27:23-07:00 Daemon PID is 2223
2024/07/17 16:27:23-07:00 Daemon log file is /sessions/session-972e21d98dde45e59c7153bd9258a64dohwg4yg1/daemon.log
2024/07/17 16:27:23-07:00
2024/07/17 16:27:23-07:00 === Previous output from daemon
2024/07/17 16:27:23-07:00 ===
2024/07/17 16:27:23-07:00
2024/07/17 16:27:23-07:00 Sending command to daemon
2024/07/17 16:27:23-07:00 Received task result:
2024/07/17 16:27:23-07:00 {
2024/07/17 16:27:23-07:00 "result": "SUCCESS",
2024/07/17 16:27:23-07:00 "processedTaskCount": 1,
2024/07/17 16:27:23-07:00 "randomValue": 0.2578537967668988,
2024/07/17 16:27:23-07:00 "failureRate": 0.1
2024/07/17 16:27:23-07:00 }
2024/07/17 16:27:23-07:00
2024/07/17 16:27:23-07:00 === Daemon log from running the task
2024/07/17 16:27:23-07:00 Loading the task details file
2024/07/17 16:27:23-07:00 Received task details:
2024/07/17 16:27:23-07:00 {
2024/07/17 16:27:23-07:00 "pid": 2329,
2024/07/17 16:27:23-07:00 "frame": 2
2024/07/17 16:27:23-07:00 }
2024/07/17 16:27:23-07:00 Processing frame number 2
2024/07/17 16:27:23-07:00 Writing result
2024/07/17 16:27:23-07:00 Waiting until a USR1 signal is sent...
2024/07/17 16:27:23-07:00 ===
2024/07/17 16:27:23-07:00
2024/07/17 16:27:23-07:00 ----------------------------------------------
2024/07/17 16:27:23-07:00 Uploading output files to Job Attachments
2024/07/17 16:27:23-07:00 ----------------------------------------------
```
Die folgenden Zeilen aus der Job-Vorlage spezifizieren diese Aktion. ```Schritte:
```
steps:
- name: EnvWithDaemonProcess
parameterSpace:
taskParameterDefinitions:
- name: Frame
type: INT
range: "{{Param.Frames}}"
stepEnvironments:
...
script:
actions:
onRun:
timeout: 60
command: bash
args:
- '{{Task.File.Run}}'
embeddedFiles:
- name: Run
filename: run-task.sh
type: TEXT
data: |
# This bash script sends a task to the background daemon process,
# then waits for it to respond with the output result.
set -euo pipefail
source "$DAEMON_BASH_HELPER_SCRIPT"
echo "Daemon PID is $DAEMON_PID"
echo "Daemon log file is $DAEMON_LOG"
print_daemon_log "Previous output from daemon"
send_task_to_daemon "{\"pid\": $$, \"frame\": {{Task.Param.Frame}} }"
wait_for_daemon_task_result
echo Received task result:
echo "$TASK_RESULT" | jq .
print_daemon_log "Daemon log from running the task"
hostRequirements:
attributes:
- name: attr.worker.os.family
anyOf:
- linux
```
# Bewerben Sie sich für Ihre Jobs
Sie können eine Warteschlangenumgebung verwenden, um Anwendungen zur Verarbeitung Ihrer Jobs zu laden. Wenn Sie mithilfe der Deadline Cloud-Konsole eine vom Service verwaltete Flotte erstellen, haben Sie die Möglichkeit, eine Warteschlangenumgebung zu erstellen, die den Conda-Paketmanager zum Laden von Anwendungen verwendet.
Wenn Sie einen anderen Paketmanager verwenden möchten, können Sie eine Warteschlangenumgebung für diesen Manager erstellen. Ein Beispiel für die Verwendung von Rez finden Sie unter[Verwenden Sie einen anderen Paketmanager](#provide-applications-other-package).
Deadline Cloud bietet einen Conda-Kanal, über den Sie eine Auswahl von Rendering-Anwendungen in Ihre Umgebung laden können. Sie unterstützen die Einreicher, die Deadline Cloud für Anwendungen zur Erstellung digitaler Inhalte bereitstellt.
Sie können auch Software für Conda-Forge laden, um sie in Ihren Jobs zu verwenden. Die folgenden Beispiele zeigen Jobvorlagen, die die von Deadline Cloud bereitgestellte Warteschlangenumgebung verwenden, um Anwendungen vor der Ausführung des Jobs zu laden.
**Topics**
+ [Eine Anwendung von einem Conda-Kanal abrufen](#provide-applications-get-application)
+ [Verwenden Sie einen anderen Paketmanager](#provide-applications-other-package)
## Eine Anwendung von einem Conda-Kanal abrufen
Sie können eine benutzerdefinierte Warteschlangenumgebung für Ihre Deadline Cloud-Mitarbeiter erstellen, die die Software Ihrer Wahl installiert. Diese Beispiel-Warteschlangenumgebung hat dasselbe Verhalten wie die Umgebung, die von der Konsole für vom Service verwaltete Flotten verwendet wird. Sie führt Conda direkt aus, um die Umgebung zu erstellen.
Die Umgebung erstellt für jede Deadline Cloud-Sitzung, die auf einem Worker ausgeführt wird, eine neue virtuelle Conda-Umgebung und löscht die Umgebung, wenn sie fertig ist.
Conda speichert die heruntergeladenen Pakete im Cache, sodass sie nicht erneut heruntergeladen werden müssen. In jeder Sitzung müssen jedoch alle Pakete mit der Umgebung verknüpft werden.
Die Umgebung definiert drei Skripte, die ausgeführt werden, wenn Deadline Cloud eine Sitzung auf einem Worker startet. Das erste Skript wird ausgeführt, wenn die `onEnter` Aktion aufgerufen wird. Es ruft die anderen beiden auf, um Umgebungsvariablen einzurichten. Wenn die Ausführung des Skripts abgeschlossen ist, ist die Conda-Umgebung verfügbar, in der alle angegebenen Umgebungsvariablen gesetzt sind.
Die neueste Version des Beispiels finden Sie unter [conda\$1queue\$1env\$1console\$1equivalent.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/conda_queue_env_console_equivalent.yaml) im Repository unter. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline) GitHub
Wenn Sie eine Anwendung verwenden möchten, die im Conda-Channel nicht verfügbar ist, können Sie einen Conda-Channel in Amazon S3 erstellen und dann Ihre eigenen Pakete für diese Anwendung erstellen. Weitere Informationen hierzu finden Sie unter [Erstellen Sie einen Conda-Kanal mit S3](configure-jobs-s3-channel.md).
### Holen Sie sich Open-Source-Bibliotheken von Conda-Forge
In diesem Abschnitt wird beschrieben, wie Sie Open-Source-Bibliotheken aus dem `conda-forge` Kanal verwenden. Das folgende Beispiel ist eine Jobvorlage, die das `polars` Python-Paket verwendet.
Der Job legt die in der Warteschlangenumgebung definierten `CondaChannels` Parameter `CondaPackages` und fest, die Deadline Cloud mitteilen, wo das Paket abgerufen werden soll.
Der Abschnitt der Jobvorlage, der die Parameter festlegt, lautet:
```
- name: CondaPackages
description: A list of conda packages to install. The job expects a Queue Environment to handle this.
type: STRING
default: polars
- name: CondaChannels
description: A list of conda channels to get packages from. The job expects a Queue Environment to handle this.
type: STRING
default: conda-forge
```
Die neueste Version der vollständigen Beispiel-Jobvorlage finden Sie unter [stage\$11\$1self\$1contained\$1template/template.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/job_bundles/job_dev_progression/stage_1_self_contained_template/template.yaml). [Die neueste Version der Warteschlangenumgebung, die die Conda-Pakete lädt, finden Sie unter conda\$1queue\$1env\$1console\$1equivalent.yaml im Repository unter. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline)](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/conda_queue_env_console_equivalent.yaml) GitHub
### Rufen Sie den Deadline-Cloud-Kanal auf Blender
Das folgende Beispiel zeigt eine Jobvorlage, die Blender aus dem `deadline-cloud` Conda-Channel stammt. Dieser Kanal unterstützt die Einreicher, die Deadline Cloud für Software zur Erstellung digitaler Inhalte bereitstellt. Sie können jedoch denselben Kanal verwenden, um Software für Ihren eigenen Gebrauch zu laden.
Eine Liste der vom `deadline-cloud` Kanal bereitgestellten Software finden Sie unter [Standard-Warteschlangenumgebung](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue-environment.html#conda-queue-environment) im *AWS Deadline Cloud-Benutzerhandbuch*.
Dieser Job legt den in der Warteschlangenumgebung definierten `CondaPackages` Parameter fest, um Deadline Cloud anzuweisen, Blender in die Umgebung zu laden.
Der Abschnitt der Jobvorlage, der den Parameter festlegt, lautet:
```
- name: CondaPackages
type: STRING
userInterface:
control: LINE_EDIT
label: Conda Packages
groupLabel: Software Environment
default: blender
description: >
Tells the queue environment to install Blender from the deadline-cloud conda channel.
```
Die neueste Version der vollständigen Beispiel-Jobvorlage finden Sie unter [blender\$1render/template.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/job_bundles/blender_render/template.yaml). [Die neueste Version der Warteschlangenumgebung, die die Conda-Pakete lädt, finden Sie unter conda\$1queue\$1env\$1console\$1equivalent.yaml im Repository unter. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline)](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/conda_queue_env_console_equivalent.yaml)GitHub
## Verwenden Sie einen anderen Paketmanager
Der Standard-Paketmanager für Deadline Cloud ist conda. Wenn Sie einen anderen Paketmanager verwenden müssen, z. B. können Sie eine benutzerdefinierte Warteschlangenumgebung erstellenRez, die Skripts enthält, die stattdessen Ihren Paketmanager verwenden.
Diese Beispiel-Warteschlangenumgebung bietet dasselbe Verhalten wie die Umgebung, die von der Konsole für vom Service verwaltete Flotten verwendet wird. Sie ersetzt den Conda-Paketmanager durch. Rez
Die Umgebung definiert drei Skripte, die ausgeführt werden, wenn Deadline Cloud eine Sitzung auf einem Worker startet. Das erste Skript wird ausgeführt, wenn die `onEnter` Aktion aufgerufen wird. Es ruft die anderen beiden auf, um Umgebungsvariablen einzurichten. Wenn die Ausführung des Skripts abgeschlossen ist, ist die Rez Umgebung mit allen festgelegten Umgebungsvariablen verfügbar.
Das Beispiel geht davon aus, dass Sie über eine vom Kunden verwaltete Flotte verfügen, die ein gemeinsam genutztes Dateisystem für die Rez-Pakete verwendet.
Die neueste Version des Beispiels finden Sie unter [rez\$1queue\$1env.yaml](https://github.com/aws-deadline/deadline-cloud-samples/blob/mainline/queue_environments/rez_queue_env.yaml) im Repository unter. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline)GitHub