Envíe trabajos con adjuntos de trabajo en Deadline Cloud - Nube de plazos
Configure la cola para los adjuntos de trabajosEnviar con adjuntos de trabajoCómo se almacenan los archivos adjuntos de los trabajosPasos a seguir a continuación

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Envíe trabajos con adjuntos de trabajo en Deadline Cloud

Muchas granjas utilizan sistemas de archivos compartidos para compartir archivos entre los anfitriones que envían los trabajos y los que los ejecutan. Por ejemplo, en el simple_file_job ejemplo anterior, el sistema de archivos local se comparte entre las ventanas de AWS CloudShell terminal, que se encuentran en la pestaña uno, donde se envía el trabajo, y en la pestaña dos, donde se ejecuta el agente de trabajo.

Un sistema de archivos compartido es ventajoso cuando la estación de trabajo remitente y los hosts de trabajo se encuentran en la misma red de área local. Si almacena los datos de forma local, cerca de las estaciones de trabajo que acceden a ellos, si utiliza una granja de servidores basada en la nube, tendrá que compartir sus sistemas de archivos a través de una VPN de alta latencia o sincronizarlos en la nube. Ninguna de estas opciones es fácil de configurar ni utilizar.

AWS Deadline Cloud ofrece una solución sencilla con archivos adjuntos de trabajo, que son similares a los archivos adjuntos de correo electrónico. Con los archivos adjuntos de trabajo, puede adjuntar datos a su trabajo. A continuación, Deadline Cloud gestiona los detalles de la transferencia y el almacenamiento de los datos de su trabajo en los depósitos de Amazon Simple Storage Service (Amazon S3).

Los flujos de trabajo de creación de contenido suelen ser iterativos, lo que significa que un usuario envía los trabajos con un pequeño subconjunto de archivos modificados. Como los buckets de Amazon S3 almacenan los adjuntos de los trabajos en un almacenamiento direccionable por contenido, el nombre de cada objeto se basa en el hash de los datos del objeto y el contenido de un árbol de directorios se almacena en un formato de archivo de manifiesto adjunto a un trabajo.

Para poder seguir los procedimientos de esta sección, debe completar lo siguiente:

Para ejecutar trabajos con trabajos adjuntos, complete los siguientes pasos.

Añada una configuración de adjuntos de trabajos a su cola

Para habilitar los adjuntos de trabajos en su cola, añada una configuración de adjuntos de trabajos al recurso de cola de su cuenta.

Para añadir una configuración de adjuntos de trabajos a su cola

  1. Seleccione la primera CloudShell pestaña y, a continuación, introduzca uno de los siguientes comandos para usar un bucket de Amazon S3 para adjuntar trabajos.

    • Si no tiene un bucket privado de Amazon S3 existente, puede crear y usar un bucket S3 nuevo.

      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}

    • Si ya tienes un bucket privado de Amazon S3, puedes usarlo MY_BUCKET_NAME sustituyéndolo por el nombre de tu bucket.

      DEV_FARM_BUCKET=MY_BUCKET_NAME

  2. Después de crear o elegir su bucket de Amazon S3, añada el nombre del bucket ~/.bashrc para que esté disponible para otras sesiones de terminal.

    echo "DEV_FARM_BUCKET=$DEV_FARM_BUCKET" >> ~/.bashrc
 source ~/.bashrc

  3. Cree un rol AWS Identity and Access Management (de IAM) para la cola.

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

  4. Actualice la cola para incluir la configuración de los adjuntos de trabajos y la función de 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"
        }'

  5. Confirme que ha actualizado la cola.

    deadline queue get

    Se muestra un resultado como el siguiente:

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

Enviar simple_file_job con adjuntos de trabajo

Cuando utilizas adjuntos de trabajo, los paquetes de trabajos deben proporcionar a Deadline Cloud suficiente información para determinar el flujo de datos del trabajo, por ejemplo, mediante PATH parámetros. En el caso del simple_file_job, editó el template.yaml archivo para indicar a Deadline Cloud que el flujo de datos está en el archivo de entrada y en el archivo de salida.

Una vez que hayas agregado la configuración de adjuntos de trabajos a tu lista, puedes enviar el ejemplo de simple_file_job con los adjuntos de trabajos. Una vez hecho esto, puede ver el registro y el resultado del trabajo para confirmar que simple_file_job con trabajos adjuntos funciona.

Para enviar el paquete de trabajos simple_file_job con los trabajos adjuntos

  1. Elija la primera CloudShell pestaña y, a continuación, abra el directorio. JobBundle-Samples

  2. cd ~/deadline-cloud-samples/job_bundles/

  3. Envía simple_file_job a la lista de espera. Cuando se te pida que confirmes la carga, ingresa. y

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

  4. Para ver el resultado del registro de la sesión de transferencia de datos de los archivos adjuntos al trabajo, ejecute el siguiente comando.

    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

  5. Enumere las acciones de la sesión que se ejecutaron dentro de la sesión.

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

    Se muestra un resultado como el siguiente:

    {
    "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 primera acción de la sesión descargó los adjuntos del trabajo de entrada, mientras que la segunda acción ejecuta la tarea como en los pasos anteriores y, a continuación, carga los adjuntos del trabajo de salida.

  6. Enumere el directorio de salida.

    ls *.txt

    Este tipo de salida hash.txt existe en el directorio, pero hash-jobattachments.txt no existe porque el archivo de salida del trabajo aún no se ha descargado.

  7. Descarga el resultado del trabajo más reciente.

    deadline job download-output

  8. Vea el resultado del archivo descargado.

    cat hash-jobattachments.txt

    Se muestra un resultado como el siguiente:

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

Entender cómo se almacenan los archivos adjuntos de trabajo en Amazon S3

Puede usar AWS Command Line Interface (AWS CLI) para cargar o descargar datos para los adjuntos de trabajos, que se almacenan en los buckets de Amazon S3. Comprender cómo Deadline Cloud almacena los adjuntos de trabajo en Amazon S3 le ayudará a desarrollar integraciones de cargas de trabajo y canalizaciones.

Para inspeccionar cómo se almacenan los adjuntos de trabajo de Deadline Cloud en Amazon S3

  1. Seleccione la primera CloudShell pestaña y, a continuación, abra el directorio de ejemplos de paquetes de trabajos.

    cd ~/deadline-cloud-samples/job_bundles/

  2. Inspeccione las propiedades del trabajo.

    deadline job get

    Se muestra un resultado como el siguiente:

    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

    El campo de adjuntos contiene una lista de estructuras de manifiesto que describen las rutas de datos de entrada y salida que utiliza el trabajo cuando se ejecuta. Observe rootPath la ruta del directorio local de la máquina que envió el trabajo. Para ver el sufijo de objeto de Amazon S3 que contiene un archivo de manifiesto, consulte lainputManifestFile. El archivo de manifiesto contiene metadatos para una instantánea del árbol de directorios de los datos de entrada del trabajo.

  3. Imprima de forma bonita el objeto del manifiesto de Amazon S3 para ver la estructura de directorios de entrada del trabajo.

    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 .

    Se muestra un resultado como el siguiente:

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

  4. Cree el prefijo Amazon S3 que contiene los manifiestos de los adjuntos de los trabajos de salida y enumere el objeto debajo de él.

    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

    No se hace referencia directamente a los adjuntos del trabajo de salida desde el recurso del trabajo, sino que se colocan en un bucket de Amazon S3 en función del recurso de la granja IDs.

  5. Obtenga la clave de objeto de manifiesto más reciente para el identificador de acción de sesión específico y, a continuación, imprima de forma bonita los objetos del manifiesto.

    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 .

    Verás las propiedades del archivo hash-jobattachments.txt en el resultado, como las siguientes:

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

    Tu trabajo solo tendrá un objeto de manifiesto por tarea ejecutada, pero en general es posible tener más objetos por tarea ejecutada.

  6. Vea la salida de almacenamiento de Amazon S3 direccionable por contenido bajo el prefijo. 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 -

    Se muestra un resultado como el siguiente:

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

Pasos a seguir a continuación

Después de aprender a enviar trabajos con archivos adjuntos mediante la CLI de Deadline Cloud, puede explorar: