Configurar fila para anexos de tarefas Envie com anexos de emprego Como os anexos do trabalho são armazenados Próximas etapas

Envie vagas com anexos de vagas no Deadline Cloud

Muitas fazendas usam sistemas de arquivos compartilhados para compartilhar arquivos entre os hosts que enviam trabalhos e aqueles que executam trabalhos. Por exemplo, no simple_file_job exemplo anterior, o sistema de arquivos local é compartilhado entre as janelas do AWS CloudShell terminal, que são executadas na guia um, na qual você envia o trabalho, e na guia dois, na qual você executa o agente de trabalho.

Um sistema de arquivos compartilhado é vantajoso quando a estação de trabalho remetente e os hosts do trabalhador estão na mesma rede local. Se você armazena seus dados no local próximo às estações de trabalho que os acessam, usar um farm baseado em nuvem significa que você precisa compartilhar seus sistemas de arquivos por meio de uma VPN de alta latência ou sincronizar seus sistemas de arquivos na nuvem. Nenhuma dessas opções é fácil de configurar ou operar.

AWS O Deadline Cloud oferece uma solução simples com anexos de trabalho, que são semelhantes aos anexos de e-mail. Com os anexos do trabalho, você anexa dados ao seu trabalho. Em seguida, o Deadline Cloud trata dos detalhes da transferência e armazenamento dos dados do seu trabalho nos buckets do Amazon Simple Storage Service (Amazon S3).

Os fluxos de trabalho de criação de conteúdo geralmente são iterativos, o que significa que um usuário envia trabalhos com um pequeno subconjunto de arquivos modificados. Como os buckets do Amazon S3 armazenam anexos de trabalho em um armazenamento endereçável por conteúdo, o nome de cada objeto é baseado no hash dos dados do objeto e o conteúdo de uma árvore de diretórios é armazenado em um formato de arquivo manifesto anexado a um trabalho.

Antes de seguir os procedimentos desta seção, você deve concluir o seguinte:

Para executar trabalhos com anexos de trabalhos, conclua as etapas a seguir.

Tópicos

Adicione uma configuração de anexos de tarefas à sua fila
Enviar simple_file_job com anexos de trabalho
Entendendo como os anexos de trabalho são armazenados no Amazon S3
Próximas etapas

Adicione uma configuração de anexos de tarefas à sua fila

Para habilitar anexos de trabalhos em sua fila, adicione uma configuração de anexos de trabalhos ao recurso de fila em sua conta.

Para adicionar uma configuração de anexos de tarefas à sua fila

Escolha sua primeira CloudShell guia e, em seguida, insira um dos seguintes comandos para usar um bucket do Amazon S3 para anexos de trabalhos.

Se você não tiver um bucket Amazon S3 privado existente, você pode criar e usar um novo 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 você já tem um bucket privado do Amazon S3, você pode usá-lo MY_BUCKET_NAME substituindo-o pelo nome do seu bucket.
```
DEV_FARM_BUCKET=MY_BUCKET_NAME
```

Depois de criar ou escolher seu bucket do Amazon S3, adicione o nome do bucket ~/.bashrc para disponibilizá-lo para outras sessões do terminal.
```
echo "DEV_FARM_BUCKET=$DEV_FARM_BUCKET" >> ~/.bashrc
 source ~/.bashrc
```

Crie uma função AWS Identity and Access Management (IAM) para a fila.


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

Atualize sua fila para incluir as configurações de anexos do trabalho e a função do 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"
        }'

Confirme se você atualizou sua fila.


deadline queue get

Uma saída como a seguinte é mostrada:


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

Enviar simple_file_job com anexos de trabalho

Quando você usa anexos de tarefas, os pacotes de tarefas devem fornecer ao Deadline Cloud informações suficientes para determinar o fluxo de dados da tarefa, como o uso de parâmetros. PATH No caso do simple_file_job, você editou o template.yaml arquivo para informar ao Deadline Cloud que o fluxo de dados está no arquivo de entrada e no arquivo de saída.

Depois de adicionar a configuração dos anexos do trabalho à sua fila, você pode enviar a amostra simple_file_job com os anexos do trabalho. Depois de fazer isso, você pode visualizar o registro e a saída do trabalho para confirmar que o simple_file_job com anexos de trabalho está funcionando.

Para enviar o pacote de tarefas simple_file_job com anexos de tarefas

Escolha sua primeira CloudShell guia e abra o JobBundle-Samples diretório.


cd ~/deadline-cloud-samples/job_bundles/

Envie simple_file_job para a fila. Quando solicitado a confirmar o upload, insiray.


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

Para visualizar a saída do log da sessão de transferência de dados dos anexos do trabalho, execute o comando a seguir.


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

Liste as ações da sessão que foram executadas na sessão.


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

Uma saída como a seguinte é mostrada:


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

A primeira ação da sessão baixou os anexos do trabalho de entrada, enquanto a segunda ação executa a tarefa como nas etapas anteriores e, em seguida, carregou os anexos do trabalho de saída.

Liste o diretório de saída.
```
ls *.txt
```
Uma saída como a hash.txt que existe no diretório, mas hash-jobattachments.txt não existe porque o arquivo de saída da tarefa ainda não foi baixado.
Baixe a saída do trabalho mais recente.
```
deadline job download-output
```

Visualize a saída do arquivo baixado.


cat hash-jobattachments.txt

Uma saída como a seguinte é mostrada:


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

Entendendo como os anexos de trabalho são armazenados no Amazon S3

Você pode usar o AWS Command Line Interface (AWS CLI) para carregar ou baixar dados para anexos de tarefas, que são armazenados em buckets do Amazon S3. Entender como o Deadline Cloud armazena anexos de trabalhos no Amazon S3 ajudará você a desenvolver cargas de trabalho e integrações de pipeline.

Para inspecionar como os anexos de trabalho do Deadline Cloud são armazenados no Amazon S3

Escolha sua primeira CloudShell guia e, em seguida, abra o diretório de amostras do pacote de tarefas.
```
cd ~/deadline-cloud-samples/job_bundles/
```

Inspecione as propriedades do trabalho.


deadline job get

Uma saída como a seguinte é mostrada:


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

O campo de anexos contém uma lista de estruturas de manifesto que descrevem os caminhos de dados de entrada e saída que a tarefa usa quando é executada. Veja rootPath o caminho do diretório local na máquina que enviou o trabalho. Para visualizar o sufixo do objeto Amazon S3 que contém um arquivo de manifesto, revise o. inputManifestFile O arquivo de manifesto contém metadados para um instantâneo da árvore de diretórios dos dados de entrada do trabalho.

Imprima bem o objeto de manifesto do Amazon S3 para ver a estrutura do diretório de entrada para o trabalho.


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 .

Uma saída como a seguinte é mostrada:


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

Crie o prefixo do Amazon S3 que contém manifestos para os anexos do trabalho de saída e liste o objeto abaixo dele.


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

Os anexos do trabalho de saída não são referenciados diretamente do recurso de trabalho, mas são colocados em um bucket do Amazon S3 com base no recurso da fazenda. IDs

Obtenha a chave de objeto de manifesto mais recente para o ID de ação de sessão específico e, em seguida, imprima bem os objetos do 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 .

Você verá propriedades do arquivo hash-jobattachments.txt na saída, como as seguintes:


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

Seu trabalho terá apenas um único objeto manifesto por tarefa executada, mas, em geral, é possível ter mais objetos por tarefa executada.

Visualize a saída de armazenamento do Amazon S3 endereçável ao conteúdo sob o prefixo. 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 -

Uma saída como a seguinte é mostrada:


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

Próximas etapas

Depois de aprender a enviar trabalhos com anexos usando a CLI do Deadline Cloud, você pode explorar:

Envie com o Deadline Cloudpara aprender a executar trabalhos usando um pacote OpenJD em seus hosts de trabalho.
Adicione uma frota gerenciada por serviços à sua fazenda de desenvolvedores no Deadline Cloudpara executar seus trabalhos em hosts gerenciados pelo Deadline Cloud.
Limpe os recursos da sua fazenda no Deadline Cloudpara encerrar os recursos que você usou neste tutorial.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Enviar trabalhos

Adicione uma frota gerenciada por serviços