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.
# Erste Schritte mit Deadline Cloud-Ressourcen
Um mit der Erstellung benutzerdefinierter Lösungen für AWS Deadline Cloud zu beginnen, müssen Sie Ihre Ressourcen einrichten. Dazu gehören eine Farm, mindestens eine Warteschlange für die Farm und mindestens eine Arbeiterflotte zur Bedienung der Warteschlange. Sie können Ihre Ressourcen mit der Deadline Cloud-Konsole erstellen, oder Sie können die verwenden AWS Command Line Interface.
In diesem Tutorial werden Sie verwenden, AWS CloudShell um eine einfache Entwicklerfarm zu erstellen und den Worker-Agent auszuführen. Anschließend können Sie einen einfachen Job mit Parametern und Anhängen einreichen und ausführen, eine vom Service verwaltete Flotte hinzufügen und Ihre Farmressourcen bereinigen, wenn Sie fertig sind.
In den folgenden Abschnitten lernen Sie die verschiedenen Funktionen von Deadline Cloud kennen und erfahren, wie sie funktionieren und zusammenarbeiten. Das Befolgen dieser Schritte ist nützlich, um neue Workloads und Anpassungen zu entwickeln und zu testen.
Anweisungen zum Einrichten Ihrer Farm mithilfe der Konsole finden Sie unter [Erste Schritte](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/getting-started.html) im *Deadline Cloud-Benutzerhandbuch*.
**Topics**
+ [Erstellen Sie eine Deadline Cloud-Farm](create-a-farm.md)
+ [Führen Sie den Deadline Cloud Worker Agent aus](run-worker.md)
+ [Mit Deadline Cloud einreichen](submit-a-job.md)
+ [Jobs mit Stellenanhängen in Deadline Cloud einreichen](run-jobs-job-attachments.md)
+ [Fügen Sie Ihrer Entwicklerfarm in Deadline Cloud eine vom Service verwaltete Flotte hinzu](service-managed-fleet.md)
+ [Bereinigen Sie Ihre Farmressourcen in Deadline Cloud](cleaning-up.md)
# Erstellen Sie eine Deadline Cloud-Farm
Verwenden Sie die AWS Command Line Interface (AWS CLI), wie im folgenden Verfahren gezeigt, um Ihre Entwicklerfarm und Warteschlangenressourcen in AWS Deadline Cloud zu erstellen. Außerdem erstellen Sie eine AWS Identity and Access Management (IAM) -Rolle und eine vom Kunden verwaltete Flotte (CMF) und ordnen die Flotte Ihrer Warteschlange zu. Anschließend können Sie das konfigurieren AWS CLI und sicherstellen, dass Ihre Farm wie angegeben eingerichtet ist und funktioniert.
Sie können diese Farm verwenden, um die Funktionen von Deadline Cloud zu erkunden und anschließend neue Workloads, Anpassungen und Pipeline-Integrationen zu entwickeln und zu testen.
**Um eine Farm zu erstellen**
1. [Öffnen Sie eine AWS CloudShell Sitzung](https://console.aws.amazon.com/cloudshell/home?region=us-west-2). Sie verwenden das CloudShell Fenster, um Befehle AWS Command Line Interface (AWS CLI) einzugeben, um die Beispiele in diesem Tutorial auszuführen. Lassen Sie das CloudShell Fenster geöffnet, während Sie fortfahren.
1. Erstellen Sie einen Namen für Ihre Farm und fügen Sie diesen Farmnamen hinzu`~/.bashrc`. Dadurch wird es für andere Terminalsitzungen verfügbar.
```
echo "DEV_FARM_NAME=DeveloperFarm" >> ~/.bashrc
source ~/.bashrc
```
1. Erstellen Sie die Farmressource und fügen Sie ihre Farm-ID hinzu`~/.bashrc`.
```
aws deadline create-farm \
--display-name "$DEV_FARM_NAME"
echo "DEV_FARM_ID=\$(aws deadline list-farms \
--query \"farms[?displayName=='\$DEV_FARM_NAME'].farmId \
| [0]\" --output text)" >> ~/.bashrc
source ~/.bashrc
```
1. Erstellen Sie die Warteschlangenressource und fügen Sie ihre Warteschlangen-ID hinzu `~/.bashrc.`
```
aws deadline create-queue \
--farm-id $DEV_FARM_ID \
--display-name "$DEV_FARM_NAME Queue" \
--job-run-as-user '{"posix": {"user": "job-user", "group": "job-group"}, "runAs":"QUEUE_CONFIGURED_USER"}'
echo "DEV_QUEUE_ID=\$(aws deadline list-queues \
--farm-id \$DEV_FARM_ID \
--query \"queues[?displayName=='\$DEV_FARM_NAME Queue'].queueId \
| [0]\" --output text)" >> ~/.bashrc
source ~/.bashrc
```
1. Erstellen Sie eine IAM-Rolle für die Flotte. Diese Rolle bietet Worker-Hosts in Ihrer Flotte die erforderlichen Sicherheitsanmeldedaten, um Jobs aus Ihrer Warteschlange auszuführen.
```
aws iam create-role \
--role-name "${DEV_FARM_NAME}FleetRole" \
--assume-role-policy-document \
'{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.deadline.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
aws iam put-role-policy \
--role-name "${DEV_FARM_NAME}FleetRole" \
--policy-name WorkerPermissions \
--policy-document \
'{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"deadline:AssumeFleetRoleForWorker",
"deadline:UpdateWorker",
"deadline:DeleteWorker",
"deadline:UpdateWorkerSchedule",
"deadline:BatchGetJobEntity",
"deadline:AssumeQueueRoleForWorker"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:PrincipalAccount": "${aws:ResourceAccount}"
}
}
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream"
],
"Resource": "arn:aws:logs:*:*:*:/aws/deadline/*",
"Condition": {
"StringEquals": {
"aws:PrincipalAccount": "${aws:ResourceAccount}"
}
}
},
{
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:GetLogEvents"
],
"Resource": "arn:aws:logs:*:*:*:/aws/deadline/*",
"Condition": {
"StringEquals": {
"aws:PrincipalAccount": "${aws:ResourceAccount}"
}
}
}
]
}'
```
1. Erstellen Sie die vom Kunden verwaltete Flotte (CMF) und fügen Sie deren Flotten-ID hinzu. `~/.bashrc`
```
FLEET_ROLE_ARN="arn:aws:iam::$(aws sts get-caller-identity \
--query "Account" --output text):role/${DEV_FARM_NAME}FleetRole"
aws deadline create-fleet \
--farm-id $DEV_FARM_ID \
--display-name "$DEV_FARM_NAME CMF" \
--role-arn $FLEET_ROLE_ARN \
--max-worker-count 5 \
--configuration \
'{
"customerManaged": {
"mode": "NO_SCALING",
"workerCapabilities": {
"vCpuCount": {"min": 1},
"memoryMiB": {"min": 512},
"osFamily": "linux",
"cpuArchitectureType": "x86_64"
}
}
}'
echo "DEV_CMF_ID=\$(aws deadline list-fleets \
--farm-id \$DEV_FARM_ID \
--query \"fleets[?displayName=='\$DEV_FARM_NAME CMF'].fleetId \
| [0]\" --output text)" >> ~/.bashrc
source ~/.bashrc
```
1. Ordnen Sie das CMF Ihrer Warteschlange zu.
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_CMF_ID
```
1. Installieren Sie die Deadline Cloud-Befehlszeilenschnittstelle.
```
pip install deadline
```
1. Verwenden Sie den folgenden Befehl, um die Standardfarm auf die Farm-ID und die Warteschlange auf die Warteschlangen-ID festzulegen, die Sie zuvor erstellt haben.
```
deadline config set defaults.farm_id $DEV_FARM_ID
deadline config set defaults.queue_id $DEV_QUEUE_ID
```
1. (Optional) Verwenden Sie die folgenden Befehle, um zu überprüfen, ob Ihre Farm gemäß Ihren Spezifikationen eingerichtet wurde:
+ Alle Farmen auflisten — **deadline farm list**
+ Alle Warteschlangen in der Standardfarm auflisten — **deadline queue list**
+ Alle Flotten in der Standardfarm auflisten — **deadline fleet list**
+ Holen Sie sich die Standardfarm — **deadline farm get**
+ Holen Sie sich die Standardwarteschlange — **deadline queue get**
+ Ruft alle Flotten ab, die der Standardwarteschlange zugeordnet sind — **deadline fleet get**
## Nächste Schritte
Nachdem Sie Ihre Farm erstellt haben, können Sie den Deadline Cloud-Worker-Agent auf den Hosts in Ihrer Flotte ausführen, um Jobs zu verarbeiten. Siehe [Führen Sie den Deadline Cloud Worker Agent aus](run-worker.md).
# Führen Sie den Deadline Cloud Worker Agent aus
Bevor Sie die Jobs, die Sie an die Warteschlange auf Ihrer Entwicklerfarm einreichen, ausführen können, müssen Sie den AWS Deadline Cloud-Worker-Agent im Entwicklermodus auf einem Worker-Host ausführen.
Im weiteren Verlauf dieses Tutorials führen Sie mithilfe von zwei AWS CloudShell Tabs AWS CLI Operationen auf Ihrer Entwicklerfarm durch. Auf der ersten Registerkarte können Sie Jobs einreichen. Auf der zweiten Registerkarte können Sie den Worker Agent ausführen.
**Anmerkung**
Wenn Sie Ihre CloudShell Sitzung länger als 20 Minuten inaktiv lassen, kommt es zu einem Timeout und der Worker-Agent wird gestoppt. Folgen Sie den Anweisungen im folgenden Verfahren, um den Worker-Agent neu zu starten.
Bevor Sie einen Worker Agent starten können, müssen Sie eine Deadline Cloud-Farm, eine Warteschlange und eine Flotte einrichten. Siehe [Erstellen Sie eine Deadline Cloud-Farm](create-a-farm.md).
**Um den Worker Agent im Entwicklermodus auszuführen**
1. Wenn Ihre Farm immer noch auf der ersten CloudShell Registerkarte geöffnet ist, öffnen Sie eine zweite CloudShell Registerkarte und erstellen Sie dann die `demoenv-persist` Verzeichnisse `demoenv-logs` und.
```
mkdir ~/demoenv-logs
mkdir ~/demoenv-persist
```
1. Laden Sie die Deadline Cloud Worker Agent-Pakete von PyPI herunter und installieren Sie sie:
**Anmerkung**
Ein Windows, es ist erforderlich, dass die Agentendateien im globalen Site-Packages-Verzeichnis von Python installiert werden. Virtuelle Python-Umgebungen werden derzeit nicht unterstützt.
```
python -m pip install deadline-cloud-worker-agent
```
1. Damit der Worker-Agent die temporären Verzeichnisse für die Ausführung von Jobs erstellen kann, erstellen Sie ein Verzeichnis:
```
sudo mkdir /sessions
sudo chmod 750 /sessions
sudo chown cloudshell-user /sessions
```
1. Führen Sie den Deadline Cloud-Worker-Agent im Entwicklermodus mit den Variablen `DEV_FARM_ID` aus`DEV_CMF_ID`, die Sie dem hinzugefügt haben`~/.bashrc`.
```
deadline-worker-agent \
--farm-id $DEV_FARM_ID \
--fleet-id $DEV_CMF_ID \
--run-jobs-as-agent-user \
--logs-dir ~/demoenv-logs \
--persistence-dir ~/demoenv-persist
```
Während der Worker-Agent den `UpdateWorkerSchedule` API-Vorgang initialisiert und dann abfragt, wird die folgende Ausgabe angezeigt:
```
INFO Worker Agent starting
[2024-03-27 15:51:01,292][INFO ] 👋 Worker Agent starting
[2024-03-27 15:51:01,292][INFO ] AgentInfo
Python Interpreter: /usr/bin/python3
Python Version: 3.9.16 (main, Sep 8 2023, 00:00:00) - [GCC 11.4.1 20230605 (Red Hat 11.4.1-2)]
Platform: linux
...
[2024-03-27 15:51:02,528][INFO ] 📥 API.Resp 📥 [deadline:UpdateWorkerSchedule](200) params={'assignedSessions': {}, 'cancelSessionActions': {}, 'updateIntervalSeconds': 15} ...
[2024-03-27 15:51:17,635][INFO ] 📥 API.Resp 📥 [deadline:UpdateWorkerSchedule](200) params=(Duplicate removed, see previous response) ...
[2024-03-27 15:51:32,756][INFO ] 📥 API.Resp 📥 [deadline:UpdateWorkerSchedule](200) params=(Duplicate removed, see previous response) ...
...
```
1. Wählen Sie Ihre erste CloudShell Registerkarte aus und listen Sie dann die Mitarbeiter in der Flotte auf.
```
deadline worker list --fleet-id $DEV_CMF_ID
```
Es wird eine Ausgabe wie die folgende angezeigt:
```
Displaying 1 of 1 workers starting at 0
- workerId: worker-8c9af877c8734e89914047111f
status: STARTED
createdAt: 2023-12-13 20:43:06+00:00
```
In einer Produktionskonfiguration erfordert der Deadline Cloud-Worker-Agent die Einrichtung mehrerer Benutzer und Konfigurationsverzeichnisse als Administratorbenutzer auf dem Host-Computer. Sie können diese Einstellungen überschreiben, da Sie Jobs in Ihrer eigenen Entwicklungsfarm ausführen, auf die nur Sie zugreifen können.
## Nächste Schritte
Jetzt, da ein Worker-Agent auf Ihren Worker-Hosts ausgeführt wird, können Sie Jobs an Ihre Mitarbeiter senden. Sie haben folgende Möglichkeiten:
+ [Mit Deadline Cloud einreichen](submit-a-job.md)mit einem einfachen OpenJD-Jobpaket.
+ [Jobs mit Stellenanhängen in Deadline Cloud einreichen](run-jobs-job-attachments.md)die Dateien zwischen Workstations teilen, die unterschiedliche Betriebssysteme verwenden.
# Mit Deadline Cloud einreichen
Um Deadline Cloud-Jobs auf Ihren Worker-Hosts auszuführen, erstellen und verwenden Sie ein Open Job Description (OpenJD) -Jobpaket, um einen Job zu konfigurieren. Das Bundle konfiguriert den Job, indem es beispielsweise Eingabedateien für einen Job angibt und wo die Ausgabe des Jobs geschrieben werden soll. Dieses Thema enthält Beispiele dafür, wie Sie ein Job-Bundle konfigurieren können.
Bevor Sie die Verfahren in diesem Abschnitt ausführen können, müssen Sie die folgenden Schritte ausführen:
+ [Erstellen Sie eine Deadline Cloud-Farm](create-a-farm.md)
+ [Führen Sie den Deadline Cloud Worker Agent aus](run-worker.md)
Gehen Sie wie folgt vor, um AWS Deadline Cloud zum Ausführen von Jobs zu verwenden. Verwenden Sie die erste AWS CloudShell Registerkarte, um Jobs an Ihre Entwicklerfarm zu senden. Verwenden Sie die zweite CloudShell Registerkarte, um die Ergebnisse des Worker-Agents anzuzeigen.
**Topics**
+ [Reichen Sie die simple\$1job Probe ein](#submit-a-simplejob-sample)
+ [Reichen Sie eine simple\$1job mit einem Parameter ein](#submit-with-parameter)
+ [Erstellen Sie ein simple\$1file\$1job-Job-Bundle mit Datei-I/O](#create-job-bundle-with-file-io)
+ [Nächste Schritte](#submit-a-job-next)
## Reichen Sie die simple\$1job Probe ein
Nachdem Sie eine Farm erstellt und den Worker Agent ausgeführt haben, können Sie das simple\$1job Beispiel an Deadline Cloud senden.
**Um das simple\$1job Beispiel an Deadline Cloud zu senden**
1. Wählen Sie Ihren ersten CloudShell Tab.
1. Laden Sie das Beispiel von herunter GitHub.
```
cd ~
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Navigieren Sie zum Verzeichnis mit den Beispielen für das Job-Bundle.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Reichen Sie das simple\$1job Beispiel ein.
```
deadline bundle submit simple_job
```
1. Wählen Sie Ihre zweite CloudShell Registerkarte, um die Protokollausgabe über das Aufrufen`BatchGetJobEntities`, das Aufrufen einer Sitzung und das Ausführen einer Sitzungsaktion anzuzeigen.
```
...
[2024-03-27 16:00:21,846][INFO ] 🔷 Session.Starting 🔷 [session-053d77cef82648fe2] Starting new Session. [queue-3ba4ff683ff54db09b851a2ed8327d7b/job-d34cc98a6e234b6f82577940ab4f76c6]
[2024-03-27 16:00:21,853][INFO ] 📤 API.Req 📤 [deadline:BatchGetJobEntity] resource={'farm-id': 'farm-3e24cfc9bbcd423e9c1b6754bc1', 'fleet-id': 'fleet-246ee60f46d44559b6cce010d05', 'worker-id': 'worker-75e0fce9c3c344a69bff57fcd83'} params={'identifiers': [{'jobDetails': {'jobId': 'job-d34cc98a6e234b6f82577940ab4'}}]} request_url=https://scheduling.deadline.us-west-2.amazonaws.com/2023-10-12/farms/farm-3e24cfc9bbcd423e /fleets/fleet-246ee60f46d44559b1 /workers/worker- 75e0fce9c3c344a69b /batchGetJobEntity
[2024-03-27 16:00:22,013][INFO ] 📥 API.Resp 📥 [deadline:BatchGetJobEntity](200) params={'entities': [{'jobDetails': {'jobId': 'job-d34cc98a6e234b6f82577940ab6', 'jobRunAsUser': {'posix': {'user': 'job-user', 'group': 'job-group'}, 'runAs': 'QUEUE_CONFIGURED_USER'}, 'logGroupName': '/aws/deadline/farm-3e24cfc9bbcd423e9c1b6754bc1/queue-3ba4ff683ff54db09b851a2ed83', 'parameters': '*REDACTED*', 'schemaVersion': 'jobtemplate-2023-09'}}], 'errors': []} request_id=a3f55914-6470-439e-89e5-313f0c6
[2024-03-27 16:00:22,013][INFO ] 🔷 Session.Add 🔷 [session-053d77cef82648fea9c69827182] Appended new SessionActions. (ActionIds: ['sessionaction-053d77cef82648fea9c69827182-0']) [queue-3ba4ff683ff54db09b851a2ed8b/job-d34cc98a6e234b6f82577940ab6]
[2024-03-27 16:00:22,014][WARNING ] 🔷 Session.User 🔷 [session-053d77cef82648fea9c69827182] Running as the Worker Agent's user. (User: cloudshell-user) [queue-3ba4ff683ff54db09b851a2ed8b/job-d34cc98a6e234b6f82577940ac6]
[2024-03-27 16:00:22,015][WARNING ] 🔷 Session.AWSCreds 🔷 [session-053d77cef82648fea9c69827182] AWS Credentials are not available: Queue has no IAM Role. [queue-3ba4ff683ff54db09b851a2ed8b/job-d34cc98a6e234b6f82577940ab6]
[2024-03-27 16:00:22,026][INFO ] 🔷 Session.Logs 🔷 [session-053d77cef82648fea9c69827182] Logs streamed to: AWS CloudWatch Logs. (LogDestination: /aws/deadline/farm-3e24cfc9bbcd423e9c1b6754bc1/queue-3ba4ff683ff54db09b851a2ed83/session-053d77cef82648fea9c69827181) [queue-3ba4ff683ff54db09b851a2ed83/job-d34cc98a6e234b6f82577940ab4]
[2024-03-27 16:00:22,026][INFO ] 🔷 Session.Logs 🔷 [session-053d77cef82648fea9c69827182] Logs streamed to: local file. (LogDestination: /home/cloudshell-user/demoenv-logs/queue-3ba4ff683ff54db09b851a2ed8b/session-053d77cef82648fea9c69827182.log) [queue-3ba4ff683ff54db09b851a2ed83/job-d34cc98a6e234b6f82577940ab4]
...
```
**Anmerkung**
Es werden nur die Protokollausgaben des Worker-Agenten angezeigt. Es gibt ein separates Protokoll für die Sitzung, in der der Job ausgeführt wird.
1. Wählen Sie Ihre erste Registerkarte und überprüfen Sie dann die Protokolldateien, die der Worker-Agent schreibt.
1. Navigieren Sie zum Protokollverzeichnis des Worker-Agents und sehen Sie sich dessen Inhalt an.
```
cd ~/demoenv-logs
ls
```
1. Drucken Sie die erste Protokolldatei, die der Worker-Agent erstellt.
```
cat worker-agent-bootstrap.log
```
Diese Datei enthält die Ergebnisse des Worker-Agents darüber, wie er die Deadline Cloud-API aufgerufen hat, um eine Worker-Ressource in Ihrer Flotte zu erstellen, und dann die Flottenrolle übernommen hat.
1. Druckt die Protokolldatei aus, die ausgegeben wird, wenn der Worker Agent der Flotte beitritt.
```
cat worker-agent.log
```
Dieses Protokoll enthält Ausgaben über alle Aktionen, die der Worker-Agent ausführt, enthält jedoch keine Ausgaben über die Warteschlangen, in denen er Jobs ausführt, mit Ausnahme IDs der Ressourcen.
1. Druckt die Protokolldateien für jede Sitzung in einem Verzeichnis, das den gleichen Namen wie die Ressourcen-ID der Warteschlange hat.
```
cat $DEV_QUEUE_ID/session-*.log
```
Wenn der Auftrag erfolgreich ist, sieht die Ausgabe der Protokolldatei wie folgt aus:
```
cat $DEV_QUEUE_ID/$(ls -t $DEV_QUEUE_ID | head -1)
2024-03-27 16:00:22,026 WARNING Session running with no AWS Credentials.
2024-03-27 16:00:22,404 INFO
2024-03-27 16:00:22,405 INFO ==============================================
2024-03-27 16:00:22,405 INFO --------- Running Task
2024-03-27 16:00:22,405 INFO ==============================================
2024-03-27 16:00:22,406 INFO ----------------------------------------------
2024-03-27 16:00:22,406 INFO Phase: Setup
2024-03-27 16:00:22,406 INFO ----------------------------------------------
2024-03-27 16:00:22,406 INFO Writing embedded files for Task to disk.
2024-03-27 16:00:22,406 INFO Mapping: Task.File.runScript -> /sessions/session-053d77cef82648fea9c698271812a/embedded_fileswa_gj55_/tmp2u9yqtsz
2024-03-27 16:00:22,406 INFO Wrote: runScript -> /sessions/session-053d77cef82648fea9c698271812a/embedded_fileswa_gj55_/tmp2u9yqtsz
2024-03-27 16:00:22,407 INFO ----------------------------------------------
2024-03-27 16:00:22,407 INFO Phase: Running action
2024-03-27 16:00:22,407 INFO ----------------------------------------------
2024-03-27 16:00:22,407 INFO Running command /sessions/session-053d77cef82648fea9c698271812a/tmpzuzxpslm.sh
2024-03-27 16:00:22,414 INFO Command started as pid: 471
2024-03-27 16:00:22,415 INFO Output:
2024-03-27 16:00:22,420 INFO Welcome to AWS Deadline Cloud!
2024-03-27 16:00:22,571 INFO
2024-03-27 16:00:22,572 INFO ==============================================
2024-03-27 16:00:22,572 INFO --------- Session Cleanup
2024-03-27 16:00:22,572 INFO ==============================================
2024-03-27 16:00:22,572 INFO Deleting working directory: /sessions/session-053d77cef82648fea9c698271812a
```
1. Druckt Informationen über den Job.
```
deadline job get
```
Wenn Sie den Job weiterleiten, speichert das System ihn als Standard, sodass Sie die Job-ID nicht eingeben müssen.
## Reichen Sie eine simple\$1job mit einem Parameter ein
Sie können Jobs mit Parametern einreichen. Im folgenden Verfahren bearbeiten Sie die simple\$1job Vorlage so, dass sie eine benutzerdefinierte Nachricht enthält, senden die und drucken dann die Sitzungsprotokolldatei aussimple\$1job, um die Nachricht anzuzeigen.
**Um das simple\$1job Beispiel mit einem Parameter einzureichen**
1. Wählen Sie Ihre erste CloudShell Registerkarte aus und navigieren Sie dann zum Verzeichnis mit den Job-Bundle-Beispielen.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Drucken Sie den Inhalt der simple\$1job Vorlage aus.
```
cat simple_job/template.yaml
```
Der `parameterDefinitions` Abschnitt mit dem `Message` Parameter sollte wie folgt aussehen:
```
parameterDefinitions:
- name: Message
type: STRING
default: Welcome to AWS Deadline Cloud!
```
1. Senden Sie das simple\$1job Beispiel mit einem Parameterwert und warten Sie dann, bis die Ausführung des Jobs abgeschlossen ist.
```
deadline bundle submit simple_job \
-p "Message=Greetings from the developer getting started guide."
```
1. Um die benutzerdefinierte Nachricht zu sehen, sehen Sie sich die letzte Sitzungsprotokolldatei an.
```
cd ~/demoenv-logs
cat $DEV_QUEUE_ID/$(ls -t $DEV_QUEUE_ID | head -1)
```
## Erstellen Sie ein simple\$1file\$1job-Job-Bundle mit Datei-I/O
Ein Renderjob muss die Szenendefinition lesen, daraus ein Bild rendern und dieses Bild dann in einer Ausgabedatei speichern. Sie können diese Aktion simulieren, indem Sie den Job den Hash der Eingabe berechnen lassen, anstatt ein Bild zu rendern.
**Um ein simple\$1file\$1job-Job-Paket mit Datei-I/O zu erstellen**
1. Wählen Sie Ihre erste CloudShell Registerkarte aus und navigieren Sie dann zum Verzeichnis mit den Job-Bundle-Beispielen.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Erstellen Sie eine Kopie von `simple_job` mit dem neuen Namen`simple_file_job`.
```
cp -r simple_job simple_file_job
```
1. Bearbeiten Sie die Jobvorlage wie folgt:
**Anmerkung**
Wir empfehlen Ihnen, nano für diese Schritte die Verwendung zu verwenden. Wenn Sie lieber verwenden möchtenVim, müssen Sie den Einfügemodus über einstellen`:set paste`.
1. Öffnen Sie die Vorlage in einem Texteditor.
```
nano simple_file_job/template.yaml
```
1. Fügen Sie die folgenden `type``objectType`, und hinzu `dataFlow``parameterDefinitions`.
```
- name: InFile
type: PATH
objectType: FILE
dataFlow: IN
- name: OutFile
type: PATH
objectType: FILE
dataFlow: OUT
```
1. Fügen Sie den folgenden `bash` Skriptbefehl am Ende der Datei hinzu, die aus der Eingabedatei liest und in die Ausgabedatei schreibt.
```
# hash the input file, and write that to the output
sha256sum "{{Param.InFile}}" > "{{Param.OutFile}}"
```
Die aktualisierte Version `template.yaml` sollte genau den folgenden Angaben entsprechen:
```
specificationVersion: 'jobtemplate-2023-09'
name: Simple File Job Bundle Example
parameterDefinitions:
- name: Message
type: STRING
default: Welcome to AWS Deadline Cloud!
- name: InFile
type: PATH
objectType: FILE
dataFlow: IN
- name: OutFile
type: PATH
objectType: FILE
dataFlow: OUT
steps:
- name: WelcomeToDeadlineCloud
script:
actions:
onRun:
command: '{{Task.File.Run}}'
embeddedFiles:
- name: Run
type: TEXT
runnable: true
data: |
#!/usr/bin/env bash
echo "{{Param.Message}}"
# hash the input file, and write that to the output
sha256sum "{{Param.InFile}}" > "{{Param.OutFile}}"
```
**Anmerkung**
Wenn Sie den Abstand in der anpassen möchten, stellen Sie sicher`template.yaml`, dass Sie Leerzeichen anstelle von Einzügen verwenden.
1. Speichern Sie die Datei und beenden Sie den Texteditor.
1. Geben Sie Parameterwerte für die Eingabe- und Ausgabedateien an, um den simple\$1file\$1job zu senden.
```
deadline bundle submit simple_file_job \
-p "InFile=simple_job/template.yaml" \
-p "OutFile=hash.txt"
```
1. Druckt Informationen über den Job.
```
deadline job get
```
+ Sie werden eine Ausgabe wie die folgende sehen:
```
parameters:
Message:
string: Welcome to AWS Deadline Cloud!
InFile:
path: /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/simple_job/template.yaml
OutFile:
path: /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/hash.txt
```
+ Sie haben zwar nur relative Pfade angegeben, für die Parameter ist jedoch der vollständige Pfadsatz festgelegt. Der AWS CLI verknüpft das aktuelle Arbeitsverzeichnis mit allen Pfaden, die als Parameter bereitgestellt werden, wenn die Pfade den folgenden Typ haben`PATH`.
+ Der Worker-Agent, der im anderen Terminalfenster ausgeführt wird, nimmt den Job auf und führt ihn aus. Diese Aktion erstellt die `hash.txt` Datei, die Sie mit dem folgenden Befehl anzeigen können.
```
cat hash.txt
```
Dieser Befehl druckt eine Ausgabe, die der folgenden ähnelt.
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/simple_job/template.yaml
```
## Nächste Schritte
Nachdem Sie gelernt haben, wie Sie einfache Jobs mit der Deadline Cloud CLI einreichen, können Sie Folgendes erkunden:
+ [Jobs mit Stellenanhängen in Deadline Cloud einreichen](run-jobs-job-attachments.md)um zu erfahren, wie man Jobs auf Hosts mit unterschiedlichen Betriebssystemen ausführt.
+ [Fügen Sie Ihrer Entwicklerfarm in Deadline Cloud eine vom Service verwaltete Flotte hinzu](service-managed-fleet.md)um Ihre Jobs auf Hosts auszuführen, die von Deadline Cloud verwaltet werden.
+ [Bereinigen Sie Ihre Farmressourcen in Deadline Cloud](cleaning-up.md)um die Ressourcen herunterzufahren, die Sie für dieses Tutorial verwendet haben.
# Jobs mit Stellenanhängen in Deadline Cloud einreichen
Viele Farmen verwenden gemeinsam genutzte Dateisysteme, um Dateien zwischen den Hosts, die Jobs einreichen, und denen, die Jobs ausführen, gemeinsam zu nutzen. Im vorherigen Beispiel wird das lokale Dateisystem `simple_file_job` beispielsweise von den AWS CloudShell Terminalfenstern gemeinsam genutzt, die auf Registerkarte eins, wo Sie den Job einreichen, und Registerkarte zwei, wo Sie den Worker-Agent ausführen, ausgeführt werden.
Ein gemeinsam genutztes Dateisystem ist vorteilhaft, wenn sich die Worker-Hosts und die Worker-Hosts im selben lokalen Netzwerk befinden. Wenn Sie Ihre Daten vor Ort in der Nähe der Workstations speichern, die darauf zugreifen, bedeutet die Verwendung einer cloudbasierten Farm, dass Sie Ihre Dateisysteme über ein VPN mit hoher Latenz gemeinsam nutzen oder Ihre Dateisysteme in der Cloud synchronisieren müssen. Keine dieser Optionen ist einfach einzurichten oder zu bedienen.
AWS Deadline Cloud bietet eine einfache Lösung mit *Job-Anhängen*, die E-Mail-Anhängen ähneln. Mit Job-Anhängen hängen Sie Daten an Ihren Job an. Anschließend kümmert sich Deadline Cloud um die Details der Übertragung und Speicherung Ihrer Auftragsdaten in Amazon Simple Storage Service (Amazon S3) -Buckets.
Workflows zur Erstellung von Inhalten sind oft iterativ, was bedeutet, dass ein Benutzer Jobs mit einer kleinen Teilmenge modifizierter Dateien einreicht. Da Amazon S3 S3-Buckets Auftragsanhänge in einem inhaltsadressierbaren Speicher speichern, basiert der Name jedes Objekts auf dem Hash der Objektdaten, und der Inhalt eines Verzeichnisbaums wird in einem Manifest-Dateiformat gespeichert, das an einen Auftrag angehängt ist.
Bevor Sie die Verfahren in diesem Abschnitt ausführen können, müssen Sie die folgenden Schritte ausführen:
+ [Erstellen Sie eine Deadline Cloud-Farm](create-a-farm.md)
+ [Führen Sie den Deadline Cloud Worker Agent aus](run-worker.md)
Gehen Sie wie folgt vor, um Jobs mit Auftragsanhängen auszuführen.
**Topics**
+ [Fügen Sie Ihrer Warteschlange eine Konfiguration für Jobanhänge hinzu](#job-attachments-config)
+ [simple\$1file\$1jobMit Stellenanhängen einreichen](#submit-job-attachments)
+ [Verstehen, wie Jobanhänge in Amazon S3 gespeichert werden](#job-attachments-in-depth)
+ [Nächste Schritte](#run-jobs-job-attachments-next)
## Fügen Sie Ihrer Warteschlange eine Konfiguration für Jobanhänge hinzu
Um Jobanhänge in Ihrer Warteschlange zu aktivieren, fügen Sie der Warteschlangenressource in Ihrem Konto eine Konfiguration für Jobanhänge hinzu.
**Um Ihrer Warteschlange eine Konfiguration für Jobanhänge hinzuzufügen**
1. Wählen Sie Ihre erste CloudShell Registerkarte und geben Sie dann einen der folgenden Befehle ein, um einen Amazon S3 S3-Bucket für Jobanhänge zu verwenden.
+ Wenn Sie noch keinen privaten Amazon S3 S3-Bucket haben, können Sie einen neuen S3-Bucket erstellen und verwenden.
```
DEV_FARM_BUCKET=$(echo $DEV_FARM_NAME \
| tr '[:upper:]' '[:lower:]')-$(xxd -l 16 -p /dev/urandom)
if [ "$AWS_REGION" == "us-east-1" ]; then LOCATION_CONSTRAINT=
else LOCATION_CONSTRAINT="--create-bucket-configuration \
LocationConstraint=${AWS_REGION}"
fi
aws s3api create-bucket \
$LOCATION_CONSTRAINT \
--acl private \
--bucket ${DEV_FARM_BUCKET}
```
+ Wenn Sie bereits einen privaten Amazon S3 S3-Bucket haben, können Sie ihn verwenden, indem Sie ihn *`MY_BUCKET_NAME`* durch den Namen Ihres Buckets ersetzen.
```
DEV_FARM_BUCKET=MY_BUCKET_NAME
```
1. Nachdem Sie Ihren Amazon S3 S3-Bucket erstellt oder ausgewählt haben, fügen Sie den Bucket-Namen hinzu, `~/.bashrc` um den Bucket für andere Terminalsitzungen verfügbar zu machen.
```
echo "DEV_FARM_BUCKET=$DEV_FARM_BUCKET" >> ~/.bashrc
source ~/.bashrc
```
1. Erstellen Sie eine AWS Identity and Access Management (IAM-) Rolle für die Warteschlange.
```
aws iam create-role --role-name "${DEV_FARM_NAME}QueueRole" \
--assume-role-policy-document \
'{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.deadline.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
aws iam put-role-policy \
--role-name "${DEV_FARM_NAME}QueueRole" \
--policy-name S3BucketsAccess \
--policy-document \
'{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject*",
"s3:GetBucket*",
"s3:List*",
"s3:DeleteObject*",
"s3:PutObject",
"s3:PutObjectLegalHold",
"s3:PutObjectRetention",
"s3:PutObjectTagging",
"s3:PutObjectVersionTagging",
"s3:Abort*"
],
"Resource": [
"arn:aws:s3:::'$DEV_FARM_BUCKET'",
"arn:aws:s3:::'$DEV_FARM_BUCKET'/*"
],
"Effect": "Allow"
}
]
}'
```
1. Aktualisieren Sie Ihre Warteschlange so, dass sie die Einstellungen für Jobanhänge und die IAM-Rolle enthält.
```
QUEUE_ROLE_ARN="arn:aws:iam::$(aws sts get-caller-identity \
--query "Account" --output text):role/${DEV_FARM_NAME}QueueRole"
aws deadline update-queue \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--role-arn $QUEUE_ROLE_ARN \
--job-attachment-settings \
'{
"s3BucketName": "'$DEV_FARM_BUCKET'",
"rootPrefix": "JobAttachments"
}'
```
1. Vergewissern Sie sich, dass Sie Ihre Warteschlange aktualisiert haben.
```
deadline queue get
```
Es wird eine Ausgabe wie die folgende angezeigt:
```
...
jobAttachmentSettings:
s3BucketName: DEV_FARM_BUCKET
rootPrefix: JobAttachments
roleArn: arn:aws:iam::ACCOUNT_NUMBER:role/DeveloperFarmQueueRole
...
```
## simple\$1file\$1jobMit Stellenanhängen einreichen
Wenn Sie Job-Anhänge verwenden, müssen Job-Bundles Deadline Cloud genügend Informationen liefern, um den Datenfluss des Jobs zu bestimmen, z. B. anhand von `PATH` Parametern. Im Fall von haben Sie die `template.yaml` Datei bearbeitetsimple\$1file\$1job, um Deadline Cloud mitzuteilen, dass sich der Datenfluss in der Eingabe- und Ausgabedatei befindet.
Nachdem Sie die Konfiguration für Jobanhänge zu Ihrer Warteschlange hinzugefügt haben, können Sie das simple\$1file\$1job-Beispiel mit Jobanhängen einreichen. Nachdem Sie dies getan haben, können Sie sich die Protokollierung und die Jobausgabe ansehen, um sich zu vergewissern, dass das simple\$1file\$1job mit den Stellenanhängen funktioniert.
**Um das simple\$1file\$1job-Job-Paket mit Job-Anhängen einzureichen**
1. Wählen Sie Ihre erste CloudShell Registerkarte und öffnen Sie dann das Verzeichnis. `JobBundle-Samples`
1.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Reichen Sie simple\$1file\$1job in die Warteschlange ein. Wenn Sie aufgefordert werden, den Upload zu bestätigen, geben Sie ein. **y**
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. Führen Sie den folgenden Befehl aus, um die Ausgabe des Sitzungsprotokolls der Jobanhänge zur Datenübertragung anzuzeigen.
```
JOB_ID=$(deadline config get defaults.job_id)
SESSION_ID=$(aws deadline list-sessions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--query "sessions[0].sessionId" \
--output text)
cat ~/demoenv-logs/$DEV_QUEUE_ID/$SESSION_ID.log
```
1. Listet die Sitzungsaktionen auf, die innerhalb der Sitzung ausgeführt wurden.
```
aws deadline list-session-actions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--session-id $SESSION_ID
```
Es werden Ausgaben wie die folgende angezeigt:
```
{
"sessionactions": [
{
"sessionActionId": "sessionaction-123-0",
"status": "SUCCEEDED",
"startedAt": "",
"endedAt": "",
"progressPercent": 100.0,
"definition": {
"syncInputJobAttachments": {}
}
},
{
"sessionActionId": "sessionaction-123-1",
"status": "SUCCEEDED",
"startedAt": "",
"endedAt": "",
"progressPercent": 100.0,
"definition": {
"taskRun": {
"taskId": "task-abc-0",
"stepId": "step-def"
}
}
}
]
}
```
Bei der ersten Sitzungsaktion wurden die Eingabeauftragsanhänge heruntergeladen, während die zweite Aktion die Aufgabe wie in den vorherigen Schritten ausführt und dann die Anlagen für den Ausgabeauftrag hochgeladen hat.
1. Listet das Ausgabeverzeichnis auf.
```
ls *.txt
```
Die Ausgabe `hash.txt` ist beispielsweise im Verzeichnis vorhanden, aber `hash-jobattachments.txt` nicht vorhanden, da die Ausgabedatei des Jobs noch nicht heruntergeladen wurde.
1. Laden Sie die Ausgabe des letzten Jobs herunter.
```
deadline job download-output
```
1. Sehen Sie sich die Ausgabe der heruntergeladenen Datei an.
```
cat hash-jobattachments.txt
```
Es wird eine Ausgabe wie die folgende angezeigt:
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## Verstehen, wie Jobanhänge in Amazon S3 gespeichert werden
Sie können die AWS Command Line Interface (AWS CLI) verwenden, um Daten für Jobanhänge hoch- oder herunterzuladen, die in Amazon S3 S3-Buckets gespeichert sind. Wenn Sie wissen, wie Deadline Cloud Jobanhänge auf Amazon S3 speichert, hilft Ihnen das bei der Entwicklung von Workloads und Pipeline-Integrationen.
**Um zu überprüfen, wie Deadline Cloud-Jobanhänge in Amazon S3 gespeichert werden**
1. Wählen Sie Ihren ersten CloudShell Tab und öffnen Sie dann das Verzeichnis mit den Job-Bundle-Beispielen.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Untersuchen Sie die Jobeigenschaften.
```
deadline job get
```
Es wird eine Ausgabe wie die folgende angezeigt:
```
parameters:
Message:
string: Welcome to AWS Deadline Cloud!
InFile:
path: /home/cloudshell-user/deadline-cloud-samples/job_bundles/simple_job/template.yaml
OutFile:
path: /home/cloudshell-user/deadline-cloud-samples/job_bundles/hash-jobattachments.txt
attachments:
manifests:
- rootPath: /home/cloudshell-user/deadline-cloud-samples/job_bundles/
rootPathFormat: posix
outputRelativeDirectories:
- .
inputManifestPath: farm-3040c59a5b9943d58052c29d907a645d/queue-cde9977c9f4d4018a1d85f3e6c1a4e6e/Inputs/f46af01ca8904cd8b514586671c79303/0d69cd94523ba617c731f29c019d16e8_input.xxh128
inputManifestHash: f95ef91b5dab1fc1341b75637fe987ee
fileSystem: COPIED
```
Das Feld „Anlagen“ enthält eine Liste von Manifeststrukturen, die Eingabe- und Ausgabedatenpfade beschreiben, die der Job bei seiner Ausführung verwendet. Sehen Sie `rootPath` sich den lokalen Verzeichnispfad auf dem Computer an, der den Job eingereicht hat. Um das Amazon S3 S3-Objektsuffix zu sehen, das eine Manifestdatei enthält, lesen Sie den`inputManifestFile`. Die Manifestdatei enthält Metadaten für einen Verzeichnisstruktur-Snapshot der Eingabedaten des Jobs.
1. Drucken Sie das Amazon S3 S3-Manifest-Objekt hübsch aus, um die Eingabeverzeichnisstruktur für den Job zu sehen.
```
MANIFEST_SUFFIX=$(aws deadline get-job \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--query "attachments.manifests[0].inputManifestPath" \
--output text)
aws s3 cp s3://$DEV_FARM_BUCKET/JobAttachments/Manifests/$MANIFEST_SUFFIX - | jq .
```
Es wird eine Ausgabe wie die folgende angezeigt:
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "2ec297b04c59c4741ed97ac8fb83080c",
"mtime": 1698186190000000,
"path": "simple_job/template.yaml",
"size": 445
}
],
"totalSize": 445
}
```
1. Konstruieren Sie das Amazon S3 S3-Präfix, das die Manifeste für die Anlagen des Ausgabeauftrags enthält, und listen Sie das Objekt darunter auf.
```
SESSION_ACTION=$(aws deadline list-session-actions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--session-id $SESSION_ID \
--query "sessionActions[?definition.taskRun != null] | [0]")
STEP_ID=$(echo $SESSION_ACTION | jq -r .definition.taskRun.stepId)
TASK_ID=$(echo $SESSION_ACTION | jq -r .definition.taskRun.taskId)
TASK_OUTPUT_PREFIX=JobAttachments/Manifests/$DEV_FARM_ID/$DEV_QUEUE_ID/$JOB_ID/$STEP_ID/$TASK_ID/
aws s3api list-objects-v2 --bucket $DEV_FARM_BUCKET --prefix $TASK_OUTPUT_PREFIX
```
Die angehängten Ausgabeaufträge werden nicht direkt von der Jobressource referenziert, sondern stattdessen in einem Amazon S3 S3-Bucket platziert, der auf der Farmressource basiert IDs.
1. Rufen Sie den neuesten Manifestobjektschlüssel für die spezifische Sitzungsaktions-ID ab und drucken Sie dann die Manifestobjekte hübsch aus.
```
SESSION_ACTION_ID=$(echo $SESSION_ACTION | jq -r .sessionActionId)
MANIFEST_KEY=$(aws s3api list-objects-v2 \
--bucket $DEV_FARM_BUCKET \
--prefix $TASK_OUTPUT_PREFIX \
--query "Contents[*].Key" --output text \
| grep $SESSION_ACTION_ID \
| sort | tail -1)
MANIFEST_OBJECT=$(aws s3 cp s3://$DEV_FARM_BUCKET/$MANIFEST_KEY -)
echo $MANIFEST_OBJECT | jq .
```
In der Ausgabe werden Eigenschaften der Datei `hash-jobattachments.txt` wie die folgenden angezeigt:
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "f60b8e7d0fabf7214ba0b6822e82e08b",
"mtime": 1698785252554950,
"path": "hash-jobattachments.txt",
"size": 182
}
],
"totalSize": 182
}
```
Ihr Job wird nur ein einziges Manifest-Objekt pro Aufgabenausführung haben, aber im Allgemeinen ist es möglich, mehr Objekte pro Aufgabenausführung zu haben.
1. Zeigen Sie die für den Inhalt adressierbare Amazon S3 S3-Speicherausgabe unter dem Präfix an. `Data`
```
FILE_HASH=$(echo $MANIFEST_OBJECT | jq -r .paths[0].hash)
FILE_PATH=$(echo $MANIFEST_OBJECT | jq -r .paths[0].path)
aws s3 cp s3://$DEV_FARM_BUCKET/JobAttachments/Data/$FILE_HASH -
```
Es wird eine Ausgabe wie die folgende angezeigt:
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## Nächste Schritte
Nachdem Sie gelernt haben, wie Sie Jobs mit Anhängen mithilfe der Deadline Cloud-CLI einreichen, können Sie Folgendes erkunden:
+ [Mit Deadline Cloud einreichen](submit-a-job.md)um zu erfahren, wie Sie Jobs mit einem OpenJD-Bundle auf Ihren Worker-Hosts ausführen.
+ [Fügen Sie Ihrer Entwicklerfarm in Deadline Cloud eine vom Service verwaltete Flotte hinzu](service-managed-fleet.md)um Ihre Jobs auf Hosts auszuführen, die von Deadline Cloud verwaltet werden.
+ [Bereinigen Sie Ihre Farmressourcen in Deadline Cloud](cleaning-up.md)um die Ressourcen herunterzufahren, die Sie für dieses Tutorial verwendet haben.
# Fügen Sie Ihrer Entwicklerfarm in Deadline Cloud eine vom Service verwaltete Flotte hinzu
AWS CloudShell bietet nicht genügend Rechenkapazität, um größere Workloads zu testen. Es ist auch nicht für Jobs konfiguriert, die Aufgaben auf mehrere Worker-Hosts verteilen.
Anstatt zu verwenden CloudShell, können Sie Ihrer Entwicklerfarm eine Auto Scaling Service Managed Fleet (SMF) hinzufügen. Ein SMF bietet ausreichend Rechenkapazität für größere Workloads und kann Jobs bewältigen, bei denen Jobaufgaben auf mehrere Worker-Hosts verteilt werden müssen.
Bevor Sie ein SMF hinzufügen, müssen Sie eine Deadline Cloud-Farm, eine Warteschlange und eine Flotte einrichten. Siehe [Erstellen Sie eine Deadline Cloud-Farm](create-a-farm.md).
**Um Ihrer Entwicklerfarm eine vom Service verwaltete Flotte hinzuzufügen**
1. Wählen Sie Ihre erste AWS CloudShell Registerkarte aus, erstellen Sie dann die vom Service verwaltete Flotte und fügen Sie deren Flotten-ID hinzu. `.bashrc` Diese Aktion macht es für andere Terminalsitzungen verfügbar.
```
FLEET_ROLE_ARN="arn:aws:iam::$(aws sts get-caller-identity \
--query "Account" --output text):role/${DEV_FARM_NAME}FleetRole"
aws deadline create-fleet \
--farm-id $DEV_FARM_ID \
--display-name "$DEV_FARM_NAME SMF" \
--role-arn $FLEET_ROLE_ARN \
--max-worker-count 5 \
--configuration \
'{
"serviceManagedEc2": {
"instanceCapabilities": {
"vCpuCount": {
"min": 2,
"max": 4
},
"memoryMiB": {
"min": 512
},
"osFamily": "linux",
"cpuArchitectureType": "x86_64"
},
"instanceMarketOptions": {
"type": "spot"
}
}
}'
echo "DEV_SMF_ID=$(aws deadline list-fleets \
--farm-id $DEV_FARM_ID \
--query "fleets[?displayName=='$DEV_FARM_NAME SMF'].fleetId \
| [0]" --output text)" >> ~/.bashrc
source ~/.bashrc
```
1. Ordnen Sie das SMF Ihrer Warteschlange zu.
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_SMF_ID
```
1. In simple\$1file\$1job die Warteschlange einreichen. Wenn Sie aufgefordert werden, den Upload zu bestätigen, geben Sie ein**y**.
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. Vergewissern Sie sich, dass das SMF ordnungsgemäß funktioniert.
```
deadline fleet get
```
+ Es kann einige Minuten dauern, bis der Mitarbeiter anfängt. Wiederholen Sie den `deadline fleet get` Befehl, bis Sie sehen, dass die Flotte läuft.
+ Die `queueFleetAssociationsStatus` für den Service verwaltete Flotte wird es sein. `ACTIVE`
+ Die SMF `autoScalingStatus` wird von `GROWING` zu wechseln. `STEADY`
Ihr Status wird in etwa wie folgt aussehen:
```
fleetId: fleet-2cc78e0dd3f04d1db427e7dc1d51ea44
farmId: farm-63ee8d77cdab4a578b685be8c5561c4a
displayName: DeveloperFarm SMF
description: ''
status: ACTIVE
autoScalingStatus: STEADY
targetWorkerCount: 0
workerCount: 0
minWorkerCount: 0
maxWorkerCount: 5
```
1. Sehen Sie sich das Protokoll für den Job an, den Sie eingereicht haben. Dieses Protokoll wird in einem Protokoll in Amazon CloudWatch Logs gespeichert, nicht im CloudShell Dateisystem.
```
JOB_ID=$(deadline config get defaults.job_id)
SESSION_ID=$(aws deadline list-sessions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--query "sessions[0].sessionId" \
--output text)
aws logs tail /aws/deadline/$DEV_FARM_ID/$DEV_QUEUE_ID \
--log-stream-names $SESSION_ID
```
## Nächste Schritte
Nachdem Sie eine Flotte mit Servicemanagement erstellt und getestet haben, sollten Sie die Ressourcen, die Sie erstellt haben, entfernen, um unnötige Kosten zu vermeiden.
+ [Bereinigen Sie Ihre Farmressourcen in Deadline Cloud](cleaning-up.md)um die Ressourcen herunterzufahren, die Sie für dieses Tutorial verwendet haben.
# Bereinigen Sie Ihre Farmressourcen in Deadline Cloud
Um neue Workloads und Pipeline-Integrationen zu entwickeln und zu testen, können Sie weiterhin die Deadline Cloud-Entwicklerfarm verwenden, die Sie für dieses Tutorial erstellt haben. Wenn Sie Ihre Entwicklerfarm nicht mehr benötigen, können Sie ihre Ressourcen, einschließlich Farm-, Flotten-, Warteschlangen-, AWS Identity and Access Management (IAM-) Rollen und Logs, in Amazon CloudWatch Logs löschen. Nachdem Sie diese Ressourcen gelöscht haben, müssen Sie das Tutorial erneut beginnen, um die Ressourcen verwenden zu können. Weitere Informationen finden Sie unter [Erste Schritte mit Deadline Cloud-Ressourcen](getting-started.md).
**Um die Ressourcen der Entwicklerfarm zu bereinigen**
1. Wählen Sie Ihren ersten CloudShell Tab und beenden Sie dann alle Verbindungen zwischen Warteschlangen und Flotten für Ihre Warteschlange.
```
FLEETS=$(aws deadline list-queue-fleet-associations \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--query "queueFleetAssociations[].fleetId" \
--output text)
for FLEET_ID in $FLEETS; do
aws deadline update-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $FLEET_ID \
--status STOP_SCHEDULING_AND_CANCEL_TASKS
done
```
1. Listet die Flottenzuordnungen der Warteschlange auf.
```
aws deadline list-queue-fleet-associations \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
Möglicherweise müssen Sie den Befehl erneut ausführen, bis die Ausgabe meldet`"status": "STOPPED"`, dann können Sie mit dem nächsten Schritt fortfahren. Dieser Vorgang kann mehrere Minuten in Anspruch nehmen.
```
{
"queueFleetAssociations": [
{
"queueId": "queue-abcdefgh01234567890123456789012id",
"fleetId": "fleet-abcdefgh01234567890123456789012id",
"status": "STOPPED",
"createdAt": "2023-11-21T20:49:19+00:00",
"createdBy": "arn:aws:sts::123456789012:assumed-role/RoleToBeAssumed/MySessionName",
"updatedAt": "2023-11-21T20:49:38+00:00",
"updatedBy": "arn:aws:sts::123456789012:assumed-role/RoleToBeAssumed/MySessionName"
},
{
"queueId": "queue-abcdefgh01234567890123456789012id",
"fleetId": "fleet-abcdefgh01234567890123456789012id",
"status": "STOPPED",
"createdAt": "2023-11-21T20:32:06+00:00",
"createdBy": "arn:aws:sts::123456789012:assumed-role/RoleToBeAssumed/MySessionName",
"updatedAt": "2023-11-21T20:49:39+00:00",
"updatedBy": "arn:aws:sts::123456789012:assumed-role/RoleToBeAssumed/MySessionName"
}
]
}
```
1. Löschen Sie alle Verknüpfungen zwischen Warteschlange und Flotte für Ihre Warteschlange.
```
for FLEET_ID in $FLEETS; do
aws deadline delete-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $FLEET_ID
done
```
1. Löschen Sie alle Flotten, die Ihrer Warteschlange zugeordnet sind.
```
for FLEET_ID in $FLEETS; do
aws deadline delete-fleet \
--farm-id $DEV_FARM_ID \
--fleet-id $FLEET_ID
done
```
1. Löscht die Warteschlange.
```
aws deadline delete-queue \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
1. Löschen Sie die Farm.
```
aws deadline delete-farm \
--farm-id $DEV_FARM_ID
```
1. Löschen Sie andere AWS Ressourcen für Ihre Farm.
1. Löschen Sie die Flottenrolle AWS Identity and Access Management (IAM).
```
aws iam delete-role-policy \
--role-name "${DEV_FARM_NAME}FleetRole" \
--policy-name WorkerPermissions
aws iam delete-role \
--role-name "${DEV_FARM_NAME}FleetRole"
```
1. Löschen Sie die Warteschlangen-IAM-Rolle.
```
aws iam delete-role-policy \
--role-name "${DEV_FARM_NAME}QueueRole" \
--policy-name S3BucketsAccess
aws iam delete-role \
--role-name "${DEV_FARM_NAME}QueueRole"
```
1. Löschen Sie die Amazon CloudWatch Logs-Protokollgruppen. Jede Warteschlange und Flotte hat ihre eigene Protokollgruppe.
```
aws logs delete-log-group \
--log-group-name "/aws/deadline/$DEV_FARM_ID/$DEV_QUEUE_ID"
aws logs delete-log-group \
--log-group-name "/aws/deadline/$DEV_FARM_ID/$DEV_CMF_ID"
aws logs delete-log-group \
--log-group-name "/aws/deadline/$DEV_FARM_ID/$DEV_SMF_ID"
```