Konfigurieren Sie die Warteschlange für Jobanhänge Mit Stellenanhängen einreichen Wie werden Jobanhänge gespeichert Nächste Schritte

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:

Gehen Sie wie folgt vor, um Jobs mit Auftragsanhängen auszuführen.

Themen

Fügen Sie Ihrer Warteschlange eine Konfiguration für Jobanhänge hinzu
Einreichen simple_file_job mit Stellenanhängen
Verstehen, wie Jobanhänge in Amazon S3 gespeichert werden
Nächste Schritte

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

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
```
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
```

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"
                }
            ]
            }'

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"
        }'

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
...

Einreichen simple_file_job mit Stellenanhängen

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 der simple_file_job, Sie haben die template.yaml Datei bearbeitet, um Deadline Cloud mitzuteilen, dass sich der Datenfluss in der Eingabedatei und der Ausgabedatei befindet.

Nachdem Sie die Konfiguration für Jobanhänge zu Ihrer Warteschlange hinzugefügt haben, können Sie das simple_file_job-Beispiel mit Stellenanhängen einreichen. Nachdem Sie dies getan haben, können Sie sich die Protokollierung und die Jobausgabe ansehen, um zu überprüfen, ob simple_file_job mit Job-Anhängen funktioniert.

Um das simple_file_job-Job-Paket mit Job-Anhängen einzureichen

Wählen Sie Ihre erste CloudShell Registerkarte und öffnen Sie dann das Verzeichnis. JobBundle-Samples


cd ~/deadline-cloud-samples/job_bundles/

Reichen Sie simple_file_job 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
```

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

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 wird eine Ausgabe wie die folgende angezeigt:


{
    "sessionactions": [
        {
            "sessionActionId": "sessionaction-123-0",
            "status": "SUCCEEDED",
            "startedAt": "<timestamp>",
            "endedAt": "<timestamp>",
            "progressPercent": 100.0,
            "definition": {
                "syncInputJobAttachments": {}
            }
        },
        {
            "sessionActionId": "sessionaction-123-1",
            "status": "SUCCEEDED",
            "startedAt": "<timestamp>",
            "endedAt": "<timestamp>",
            "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.

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.
Laden Sie die Ausgabe des letzten Jobs herunter.
```
deadline job download-output
```

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

Wählen Sie Ihren ersten CloudShell Tab und öffnen Sie dann das Verzeichnis mit den Job-Bundle-Beispielen.
```
cd ~/deadline-cloud-samples/job_bundles/
```

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 deninputManifestFile. Die Manifestdatei enthält Metadaten für einen Verzeichnisstruktur-Snapshot der Eingabedaten des Jobs.

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
 }

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.

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.

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 einreichenum 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 hinzuum Ihre Jobs auf Hosts auszuführen, die von Deadline Cloud verwaltet werden.
Bereinigen Sie Ihre Farmressourcen in Deadline Cloudum die Ressourcen herunterzufahren, die Sie für dieses Tutorial verwendet haben.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Jobs einreichen

Fügen Sie eine vom Service verwaltete Flotte hinzu