Configura la coda per gli allegati dei lavori Invia con allegati di lavoro Come vengono archiviati gli allegati di lavoro Passaggi successivi

Invia offerte di lavoro con allegati di lavoro in Deadline Cloud

Molte farm utilizzano file system condivisi per condividere file tra gli host che inviano i job e quelli che eseguono i job. Ad esempio, nell'simple_file_jobesempio precedente, il file system locale è condiviso tra le finestre del AWS CloudShell terminale, che vengono eseguite nella scheda uno in cui si invia il lavoro, e nella scheda due in cui si esegue il worker agent.

Un file system condiviso è vantaggioso quando la postazione di lavoro del mittente e gli host del lavoratore si trovano sulla stessa rete locale. Se memorizzi i dati in locale vicino alle workstation che vi accedono, l'utilizzo di una farm basata sul cloud significa dover condividere i file system tramite una VPN ad alta latenza o sincronizzare i file system nel cloud. Nessuna di queste opzioni è facile da configurare o utilizzare.

AWS Deadline Cloud offre una soluzione semplice con allegati di lavoro, simili agli allegati delle e-mail. Con gli allegati di lavoro, alleghi dati al tuo lavoro. Deadline Cloud gestisce quindi i dettagli del trasferimento e dell'archiviazione dei dati di lavoro nei bucket Amazon Simple Storage Service (Amazon S3).

I flussi di lavoro per la creazione di contenuti sono spesso iterativi, il che significa che un utente invia lavori con un piccolo sottoinsieme di file modificati. Poiché i bucket Amazon S3 archiviano gli allegati del lavoro in uno storage content-addressable, il nome di ogni oggetto si basa sull'hash dei dati dell'oggetto e il contenuto di un albero di directory viene archiviato in un formato di file manifesto allegato a un lavoro.

Prima di poter seguire le procedure in questa sezione, devi completare quanto segue:

Per eseguire lavori con allegati di lavoro, completare i passaggi seguenti.

Argomenti

Aggiungi una configurazione degli allegati di lavoro alla tua coda
Invia simple_file_job con allegati di lavoro
Informazioni su come vengono archiviati gli allegati di lavoro in Amazon S3
Passaggi successivi

Aggiungi una configurazione degli allegati di lavoro alla tua coda

Per abilitare gli allegati dei lavori nella tua coda, aggiungi una configurazione degli allegati di lavoro alla risorsa di coda del tuo account.

Per aggiungere una configurazione degli allegati di lavoro alla tua coda

Scegli la tua prima CloudShell scheda, quindi inserisci uno dei seguenti comandi per utilizzare un bucket Amazon S3 per gli allegati dei lavori.

Se non disponi di un bucket Amazon S3 privato esistente, puoi creare e utilizzare un nuovo bucket S3.


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}

Se disponi già di un bucket Amazon S3 privato, puoi utilizzarlo sostituendolo MY_BUCKET_NAME con il nome del tuo bucket.
```
DEV_FARM_BUCKET=MY_BUCKET_NAME
```

Dopo aver creato o scelto il bucket Amazon S3, aggiungi il nome del bucket a per renderlo disponibile ~/.bashrc per altre sessioni di terminale.
```
echo "DEV_FARM_BUCKET=$DEV_FARM_BUCKET" >> ~/.bashrc
 source ~/.bashrc
```

Crea un ruolo AWS Identity and Access Management (IAM) per la coda.


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

Aggiorna la coda per includere le impostazioni degli allegati di lavoro e il ruolo IAM.


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

Conferma di aver aggiornato la coda.


deadline queue get

Viene visualizzato un output come il seguente:


...
jobAttachmentSettings:
  s3BucketName: DEV_FARM_BUCKET
  rootPrefix: JobAttachments
roleArn: arn:aws:iam::ACCOUNT_NUMBER:role/DeveloperFarmQueueRole
...

Invia simple_file_job con allegati di lavoro

Quando utilizzi gli allegati di lavoro, i pacchetti di lavoro devono fornire a Deadline Cloud informazioni sufficienti per determinare il flusso di dati del lavoro, ad esempio l'utilizzo dei parametri. PATH Nel caso del simple_file_job, hai modificato il template.yaml file per comunicare a Deadline Cloud che il flusso di dati si trova nel file di input e nel file di output.

Dopo aver aggiunto la configurazione degli allegati di lavoro alla coda, puoi inviare l'esempio di simple_file_job con gli allegati del lavoro. Dopo aver eseguito questa operazione, è possibile visualizzare la registrazione e l'output del lavoro per confermare che simple_file_job con allegati di lavoro funziona.

Per inviare il pacchetto di lavoro simple_file_job con gli allegati del lavoro

Scegli la tua prima CloudShell scheda, quindi apri la cartella. JobBundle-Samples


cd ~/deadline-cloud-samples/job_bundles/

Invia simple_file_job alla coda. Quando ti viene richiesto di confermare il caricamento, inserisci. y


deadline bundle submit simple_file_job \
    -p InFile=simple_job/template.yaml \
    -p OutFile=hash-jobattachments.txt

Per visualizzare l'output del registro della sessione di trasferimento dati degli allegati del lavoro, eseguite il comando seguente.


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

Elenca le azioni della sessione che sono state eseguite all'interno della sessione.


aws deadline list-session-actions \
    --farm-id $DEV_FARM_ID \
    --queue-id $DEV_QUEUE_ID \
    --job-id $JOB_ID \
    --session-id $SESSION_ID

Viene mostrato un output come il seguente:


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

La prima azione della sessione ha scaricato gli allegati del lavoro di input, mentre la seconda azione esegue l'attività come nei passaggi precedenti e quindi ha caricato gli allegati del lavoro di output.

Elenca la directory di output.
```
ls *.txt
```
Un output come questo hash.txt esiste nella directory, ma hash-jobattachments.txt non esiste perché il file di output del processo non è stato ancora scaricato.
Scarica l'output del processo più recente.
```
deadline job download-output
```

Visualizza l'output del file scaricato.


cat hash-jobattachments.txt

Viene mostrato un output come il seguente:


eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3  /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml

Informazioni su come vengono archiviati gli allegati di lavoro in Amazon S3

Puoi utilizzare AWS Command Line Interface (AWS CLI) per caricare o scaricare dati per gli allegati di lavoro, che vengono archiviati nei bucket Amazon S3. Capire come Deadline Cloud archivia gli allegati di lavoro su Amazon S3 ti aiuterà a sviluppare carichi di lavoro e integrazioni di pipeline.

Per controllare come vengono archiviati gli allegati dei lavori di Deadline Cloud in Amazon S3

Scegli la tua prima CloudShell scheda, quindi apri la directory degli esempi di job bundle.
```
cd ~/deadline-cloud-samples/job_bundles/
```

Ispeziona le proprietà del lavoro.


deadline job get

Viene mostrato un output come il seguente:


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

Il campo degli allegati contiene un elenco di strutture manifeste che descrivono i percorsi dei dati di input e output utilizzati dal job durante l'esecuzione. Guarda rootPath per vedere il percorso della directory locale sul computer che ha inviato il lavoro. Per visualizzare il suffisso dell'oggetto Amazon S3 che contiene un file manifesto, consulta il. inputManifestFile Il file manifest contiene i metadati per un'istantanea ad albero di directory dei dati di input del processo.

Stampa bene l'oggetto manifest di Amazon S3 per vedere la struttura della directory di input per il lavoro.


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 .

Viene mostrato un output come il seguente:


{
     "hashAlg": "xxh128",
     "manifestVersion": "2023-03-03",
     "paths": [
     {
         "hash": "2ec297b04c59c4741ed97ac8fb83080c",
         "mtime": 1698186190000000,
         "path": "simple_job/template.yaml",
         "size": 445
     }
     ],
     "totalSize": 445
 }

Crea il prefisso Amazon S3 che contiene i manifest per gli allegati del processo di output ed elenca l'oggetto al suo interno.


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

Gli allegati del lavoro di output non sono referenziati direttamente dalla risorsa del lavoro, ma vengono invece inseriti in un bucket Amazon S3 basato sulla risorsa della fattoria. IDs

Ottieni la chiave dell'oggetto manifesto più recente per l'ID di azione della sessione specifica, quindi stampa in modo semplice gli oggetti del manifesto.


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 .

hash-jobattachments.txtNell'output vedrete le proprietà del file, come le seguenti:


{
     "hashAlg": "xxh128",
     "manifestVersion": "2023-03-03",
     "paths": [
     {
         "hash": "f60b8e7d0fabf7214ba0b6822e82e08b",
         "mtime": 1698785252554950,
         "path": "hash-jobattachments.txt",
         "size": 182
     }
     ],
     "totalSize": 182
 }

Il job avrà un solo oggetto manifesto per operazione eseguita, ma in generale è possibile avere più oggetti per operazione eseguita.

Visualizza l'output di storage Amazon S3 indirizzabile ai contenuti sotto il prefisso. 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 -

Viene mostrato un output come il seguente:


eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3  /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml

Passaggi successivi

Dopo aver appreso come inviare offerte di lavoro con allegati utilizzando la CLI di Deadline Cloud, puoi scoprire:

Invia con Deadline Cloudper imparare a eseguire lavori utilizzando un pacchetto OpenJD sui tuoi host di lavoro.
Aggiungi una flotta gestita dai servizi alla tua farm di sviluppatori in Deadline Cloudper eseguire i tuoi lavori su host gestiti da Deadline Cloud.
Pulisci le risorse della tua azienda agricola in Deadline Cloudper chiudere le risorse che hai usato per questo tutorial.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Invia offerte di lavoro

Aggiungi una flotta gestita dai servizi