Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utiliser les pièces jointes aux tâches pour partager des fichiers
<a name="build-job-attachments"></a>

Utilisez les *pièces jointes aux tâches* pour rendre les fichiers ne figurant pas dans les répertoires partagés disponibles pour vos tâches et pour capturer les fichiers de sortie s'ils ne sont pas écrits dans des répertoires partagés. Job Attachments utilise Amazon S3 pour transférer les fichiers entre les hôtes. Les fichiers sont stockés dans des compartiments S3 et il n'est pas nécessaire de télécharger un fichier si son contenu n'a pas changé.

Vous devez utiliser des pièces jointes lorsque vous exécutez des tâches sur des [flottes gérées par des services, car les](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/smf-manage.html) hôtes ne partagent pas l'emplacement des systèmes de fichiers. Les pièces jointes aux tâches sont également utiles dans les [flottes gérées par les clients lorsque les](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/manage-cmf.html) fichiers d'entrée ou de sortie d'une tâche sont stockés sur un système de fichiers réseau partagé, par exemple lorsque votre ensemble de [tâches contient des scripts](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submit-job-bundle.html) shell ou Python. 

 Lorsque vous soumettez un ensemble de tâches à l'aide de la [CLI de Deadline Cloud](https://pypi.org/project/deadline/) ou d'un émetteur de Deadline Cloud, les pièces jointes aux tâches utilisent le profil de stockage de la tâche et les emplacements du système de fichiers requis dans la file d'attente pour identifier les fichiers d'entrée qui ne se trouvent pas sur un hôte de travail et qui doivent être téléchargés sur Amazon S3 dans le cadre de la soumission de la tâche. Ces profils de stockage aident également Deadline Cloud à identifier les fichiers de sortie sur les sites d'accueil des travailleurs qui doivent être téléchargés sur Amazon S3 afin d'être disponibles sur votre poste de travail. 

 Les exemples de pièces jointes aux tâches utilisent les configurations de ferme, de flotte, de files d'attente et de profils de stockage issues de [Exemple d'infrastructure de projet](sample-project-infrastructure.md) et[Profils de stockage et mappage des chemins](storage-profiles-and-path-mapping.md). Vous devriez parcourir ces sections avant celle-ci. 

Dans les exemples suivants, vous utilisez un exemple de série de tâches comme point de départ, puis vous le modifiez pour explorer les fonctionnalités de la pièce jointe aux tâches. Les offres d'emploi constituent le meilleur moyen pour vos offres d'emploi d'utiliser les pièces jointes. Ils combinent un modèle de [tâche Open Job Description](https://github.com/OpenJobDescription/openjd-specifications/wiki) dans un répertoire avec des fichiers supplémentaires qui répertorient les fichiers et les répertoires requis par les tâches utilisant le bundle de tâches. Pour plus d'informations sur les offres d'emploi, consultez[Modèles Open Job Description (OpenJD) pour Deadline Cloud](build-job-bundle.md).

# Soumission de fichiers avec une tâche
<a name="submitting-files-with-a-job"></a>

Avec Deadline Cloud, vous pouvez permettre aux flux de travail d'accéder aux fichiers d'entrée qui ne sont pas disponibles dans les emplacements des systèmes de fichiers partagés sur les hôtes de travail. Les pièces jointes aux tâches permettent aux tâches de rendu d'accéder à des fichiers résidant uniquement sur le disque d'un poste de travail local ou dans un environnement de parc géré par des services. Lorsque vous soumettez un ensemble de tâches, vous pouvez inclure des listes de fichiers d'entrée et de répertoires requis par la tâche. Deadline Cloud identifie ces fichiers non partagés, les télécharge depuis la machine locale vers Amazon S3 et les télécharge sur l'hôte du poste de travail. Il rationalise le processus de transfert des actifs d'entrée vers les nœuds de rendu, garantissant ainsi que tous les fichiers requis sont accessibles pour l'exécution distribuée des tâches.

Vous pouvez spécifier les fichiers des tâches directement dans le bundle de tâches, utiliser les paramètres du modèle de tâche que vous fournissez à l'aide de variables d'environnement ou d'un script, et utiliser le `assets_references` fichier de la tâche. Vous pouvez utiliser l'une de ces méthodes ou une combinaison des trois. Vous pouvez spécifier un profil de stockage pour le bundle de la tâche afin qu'il ne télécharge que les fichiers modifiés sur le poste de travail local.

Cette section utilise un exemple de bundle de tâches GitHub pour montrer comment Deadline Cloud identifie les fichiers de votre tâche à télécharger, comment ces fichiers sont organisés dans Amazon S3 et comment ils sont mis à la disposition des hôtes de travail traitant vos tâches. 

**Topics**
+ [Comment Deadline Cloud télécharge des fichiers sur Amazon S3](what-job-attachments-uploads-to-amazon-s3.md)
+ [Comment Deadline Cloud choisit les fichiers à télécharger](how-job-attachments-decides-what-to-upload-to-amazon-s3.md)
+ [Comment les tâches trouvent-elles les fichiers d'entrée des pièces jointes](how-jobs-find-job-attachments-input-files.md)

# Comment Deadline Cloud télécharge des fichiers sur Amazon S3
<a name="what-job-attachments-uploads-to-amazon-s3"></a>

Cet exemple montre comment Deadline Cloud télécharge des fichiers depuis votre poste de travail ou votre hôte de travail vers Amazon S3 afin qu'ils puissent être partagés. Il utilise un exemple de bundle de tâches GitHub et la CLI de Deadline Cloud pour soumettre des tâches.

 Commencez par cloner le [ GitHubréférentiel d'échantillons de Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples) dans votre [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html)environnement, puis copiez le bundle de `job_attachments_devguide` tâches dans votre répertoire personnel : 

```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
cp -r deadline-cloud-samples/job_bundles/job_attachments_devguide ~/
```

 Installez la [CLI de Deadline Cloud](https://pypi.org/project/deadline/) pour soumettre des ensembles de tâches : 

```
pip install deadline --upgrade
```

 Le bundle de `job_attachments_devguide` tâches comporte une seule étape avec une tâche qui exécute un script shell bash dont l'emplacement du système de fichiers est transmis en tant que paramètre de tâche. La définition du paramètre de tâche est la suivante : 

```
...
- name: ScriptFile
  type: PATH
  default: script.sh
  dataFlow: IN
  objectType: FILE
...
```

 La `IN` valeur de la `dataFlow` propriété indique aux pièces jointes à la tâche que la valeur du `ScriptFile` paramètre est une entrée de la tâche. La valeur de la `default` propriété est un emplacement relatif par rapport au répertoire du bundle de tâches, mais il peut également s'agir d'un chemin absolu. Cette définition de paramètre déclare le `script.sh` fichier du répertoire du bundle de tâches en tant que fichier d'entrée requis pour l'exécution de la tâche. 

 Ensuite, assurez-vous qu'aucun profil de stockage n'est configuré sur la CLI de Deadline Cloud, puis soumettez la tâche à la file d'attente `Q1` : 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of QUEUE1_ID to queue Q1's identifier
QUEUE1_ID=queue-00112233445566778899aabbccddeeff

deadline config set settings.storage_profile_id ''

deadline bundle submit --farm-id $FARM_ID --queue-id $QUEUE1_ID job_attachments_devguide/
```

 Le résultat de la CLI de Deadline Cloud après l'exécution de cette commande est le suivant : 

```
Submitting to Queue: Q1
...
Hashing Attachments  [####################################]  100%
Hashing Summary:
    Processed 1 file totaling 39.0 B.
    Skipped re-processing 0 files totaling 0.0 B.
    Total processing time of 0.0327 seconds at 1.19 KB/s.

Uploading Attachments  [####################################]  100%
Upload Summary:
    Processed 1 file totaling 39.0 B.
    Skipped re-processing 0 files totaling 0.0 B.
    Total processing time of 0.25639 seconds at 152.0 B/s.

Waiting for Job to be created...
Submitted job bundle:
   job_attachments_devguide/
Job creation completed successfully
job-74148c13342e4514b63c7a7518657005
```

Lorsque vous soumettez la tâche, Deadline Cloud hache d'abord le `script.sh` fichier, puis le télécharge sur Amazon S3. 

Deadline Cloud traite le compartiment S3 comme un espace de stockage adressable par le contenu. Les fichiers sont téléchargés vers des objets S3. Le nom de l'objet est dérivé d'un hachage du contenu du fichier. Si deux fichiers ont un contenu identique, ils ont la même valeur de hachage, quel que soit leur emplacement ou leur nom. Ce stockage adressable par contenu permet à Deadline Cloud d'éviter de télécharger un fichier s'il est déjà disponible.

 Vous pouvez utiliser l'[AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) pour voir les objets qui ont été chargés sur Amazon S3 : 

```
# The name of queue `Q1`'s job attachments S3 bucket
Q1_S3_BUCKET=$(
  aws deadline get-queue --farm-id $FARM_ID --queue-id $QUEUE1_ID \
    --query 'jobAttachmentSettings.s3BucketName' | tr -d '"'
)

aws s3 ls s3://$Q1_S3_BUCKET --recursive
```

 Deux objets ont été chargés sur S3 : 
+  `DeadlineCloud/Data/87cb19095dd5d78fcaf56384ef0e6241.xxh128`— Le contenu de`script.sh`. [La valeur de `87cb19095dd5d78fcaf56384ef0e6241` la clé d'objet est le hachage du contenu du fichier, et l'extension `xxh128` indique que la valeur de hachage a été calculée sous la forme d'un xxhash de 128 bits.](https://xxhash.com/) 
+  `DeadlineCloud/Manifests/<farm-id>/<queue-id>/Inputs/<guid>/a1d221c7fd97b08175b3872a37428e8c_input`— L'objet manifeste pour la soumission de la tâche. Les valeurs `<farm-id>``<queue-id>`, et `<guid>` sont l'identifiant de votre ferme, l'identifiant de la file d'attente et une valeur hexadécimale aléatoire. La valeur `a1d221c7fd97b08175b3872a37428e8c` dans cet exemple est une valeur de hachage calculée à partir de la chaîne`/home/cloudshell-user/job_attachments_devguide`, le répertoire dans lequel se `script.sh` trouve le répertoire. 

 L'objet manifeste contient les informations relatives aux fichiers d'entrée sur un chemin racine spécifique téléchargés vers S3 dans le cadre de la soumission de la tâche. Téléchargez ce fichier manifeste (`aws s3 cp s3://$Q1_S3_BUCKET/<objectname>`). Son contenu est similaire à : 

```
{
    "hashAlg": "xxh128",
    "manifestVersion": "2023-03-03",
    "paths": [
        {
            "hash": "87cb19095dd5d78fcaf56384ef0e6241",
            "mtime": 1721147454416085,
            "path": "script.sh",
            "size": 39
        }
    ],
    "totalSize": 39
}
```

Cela indique que le fichier `script.sh` a été chargé et que le hachage du contenu de ce fichier est `87cb19095dd5d78fcaf56384ef0e6241` le même. Cette valeur de hachage correspond à la valeur du nom `DeadlineCloud/Data/87cb19095dd5d78fcaf56384ef0e6241.xxh128` de l'objet. Il est utilisé par Deadline Cloud pour savoir quel objet télécharger pour le contenu de ce fichier.

 Le schéma complet de ce fichier est [disponible dans GitHub](https://github.com/aws-deadline/deadline-cloud/blob/mainline/src/deadline/job_attachments/asset_manifests/v2023_03_03/validate.py). 

Lorsque vous utilisez cette [CreateJob opération](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateJob.html), vous pouvez définir l'emplacement des objets du manifeste. Vous pouvez utiliser l'[GetJobopération](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_GetJob.html) pour voir l'emplacement : 

```
{
    "attachments": {
        "file system": "COPIED",
        "manifests": [
            {
                "inputManifestHash": "5b0db3d311805ea8de7787b64cbbe8b3",
                "inputManifestPath": "<farm-id>/<queue-id>/Inputs/<guid>/a1d221c7fd97b08175b3872a37428e8c_input",
                "rootPath": "/home/cloudshell-user/job_attachments_devguide",
                "rootPathFormat": "posix"
            }
        ]
    },
    ...
}
```

# Comment Deadline Cloud choisit les fichiers à télécharger
<a name="how-job-attachments-decides-what-to-upload-to-amazon-s3"></a>

 Les fichiers et répertoires que les pièces jointes aux tâches considèrent comme des entrées pour votre tâche sont les suivants : 
+  Les valeurs de tous les paramètres de tâche de `PATH` type -type définis dans le modèle de tâches du bundle de tâches avec une `dataFlow` valeur de `IN` ou`INOUT`.
+  Les fichiers et répertoires répertoriés en tant qu'entrées dans le fichier de référence des actifs du bundle de tâches. 

 Si vous soumettez une tâche sans profil de stockage, tous les fichiers considérés pour le téléchargement sont chargés. Si vous soumettez une tâche avec un profil de stockage, les fichiers ne sont pas chargés vers Amazon S3 s'ils se trouvent dans les emplacements du système de fichiers de `SHARED` type du profil de stockage, qui sont également des emplacements de système de fichiers obligatoires pour la file d'attente. Ces emplacements sont censés être disponibles sur les hôtes de travail qui exécutent la tâche. Il n'est donc pas nécessaire de les télécharger sur S3. 

 Dans cet exemple, vous créez des emplacements de système de `SHARED` fichiers `WSAll` dans votre CloudShell environnement AWS, puis vous ajoutez des fichiers à ces emplacements de système de fichiers. Utilisez la commande suivante : 

```
# Change the value of WSALL_ID to the identifier of the WSAll storage profile
WSALL_ID=sp-00112233445566778899aabbccddeeff

sudo mkdir -p /shared/common /shared/projects/project1 /shared/projects/project2
sudo chown -R cloudshell-user:cloudshell-user /shared

for d in /shared/common /shared/projects/project1 /shared/projects/project2; do
  echo "File contents for $d" > ${d}/file.txt
done
```

 Ajoutez ensuite un fichier de références d'actifs au bundle de tâches qui inclut tous les fichiers que vous avez créés en tant qu'entrées pour le travail. Utilisez la commande suivante : 

```
cat > ${HOME}/job_attachments_devguide/asset_references.yaml << EOF
assetReferences:
  inputs:
    filenames:
    - /shared/common/file.txt
    directories:
    - /shared/projects/project1
    - /shared/projects/project2
EOF
```

 Configurez ensuite la CLI de Deadline Cloud pour soumettre les tâches avec le profil de `WSAll` stockage, puis soumettez le bundle de tâches : 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of QUEUE1_ID to queue Q1's identifier
QUEUE1_ID=queue-00112233445566778899aabbccddeeff
# Change the value of WSALL_ID to the identifier of the WSAll storage profile
WSALL_ID=sp-00112233445566778899aabbccddeeff

deadline config set settings.storage_profile_id $WSALL_ID

deadline bundle submit --farm-id $FARM_ID --queue-id $QUEUE1_ID job_attachments_devguide/
```

Deadline Cloud télécharge deux fichiers sur Amazon S3 lorsque vous soumettez la tâche. Vous pouvez télécharger les objets du manifeste de la tâche depuis S3 pour voir les fichiers téléchargés : 

```
for manifest in $( \
  aws deadline get-job --farm-id $FARM_ID --queue-id $QUEUE1_ID --job-id $JOB_ID \
    --query 'attachments.manifests[].inputManifestPath' \
    | jq -r '.[]'
); do
  echo "Manifest object: $manifest"
  aws s3 cp --quiet s3://$Q1_S3_BUCKET/DeadlineCloud/Manifests/$manifest /dev/stdout | jq .
done
```

 Dans cet exemple, il existe un seul fichier manifeste dont le contenu est le suivant : 

```
{
    "hashAlg": "xxh128",
    "manifestVersion": "2023-03-03",
    "paths": [
        {
            "hash": "87cb19095dd5d78fcaf56384ef0e6241",
            "mtime": 1721147454416085,
            "path": "home/cloudshell-user/job_attachments_devguide/script.sh",
            "size": 39
        },
        {
            "hash": "af5a605a3a4e86ce7be7ac5237b51b79",
            "mtime": 1721163773582362,
            "path": "shared/projects/project2/file.txt",
            "size": 44
        }
    ],
    "totalSize": 83
}
```

 Utilisez l'[GetJob opération](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_GetJob.html) pour le manifeste pour vérifier qu'il s'`rootPath`agit de «/». 

```
aws deadline get-job --farm-id $FARM_ID --queue-id $QUEUE1_ID --job-id $JOB_ID --query 'attachments.manifests[*]'
```

 Le chemin racine d'un ensemble de fichiers d'entrée est toujours le sous-chemin commun le plus long de ces fichiers. Si votre tâche a été soumise à la Windows place et que certains fichiers d'entrée n'ont aucun sous-chemin commun parce qu'ils se trouvent sur des lecteurs différents, vous voyez un chemin racine distinct sur chaque lecteur. Les chemins d'un manifeste sont toujours relatifs au chemin racine du manifeste. Les fichiers d'entrée qui ont été téléchargés sont donc les suivants : 
+  `/home/cloudshell-user/job_attachments_devguide/script.sh`— Le fichier de script contenu dans le bundle de tâches. 
+  `/shared/projects/project2/file.txt`— Le fichier situé dans un emplacement `SHARED` du système de fichiers dans le profil `WSAll` de stockage qui **ne figure pas** dans la liste des emplacements de système de fichiers requis pour la file d'attente`Q1`. 

Les fichiers situés dans les emplacements du système de fichiers `FSCommon` (`/shared/common/file.txt`) et `FS1` (`/shared/projects/project1/file.txt`) ne figurent pas dans la liste. Cela est dû au fait que ces emplacements de système de fichiers se trouvent `SHARED` dans le profil `WSAll` de stockage et qu'ils figurent tous deux dans la liste des emplacements de système de fichiers requis dans la file d'attente`Q1`. 

Vous pouvez voir les emplacements du système de fichiers pris en compte `SHARED` pour une tâche soumise avec un profil de stockage particulier lors de l'[GetStorageProfileForQueue opération](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_GetStorageProfileForQueue.html). Pour rechercher le profil de stockage `WSAll` pour la file d'attente, `Q1` utilisez la commande suivante : 

```
aws deadline get-storage-profile --farm-id $FARM_ID --storage-profile-id $WSALL_ID

aws deadline get-storage-profile-for-queue --farm-id $FARM_ID --queue-id $QUEUE1_ID --storage-profile-id $WSALL_ID
```

# Comment les tâches trouvent-elles les fichiers d'entrée des pièces jointes
<a name="how-jobs-find-job-attachments-input-files"></a>

 Pour qu'une tâche utilise les fichiers que Deadline Cloud télécharge sur Amazon S3 à l'aide de pièces jointes, elle a besoin que ces fichiers soient disponibles via le système de fichiers sur les hôtes de travail. Lorsqu'une [session](https://github.com/OpenJobDescription/openjd-specifications/wiki/How-Jobs-Are-Run#sessions) pour votre tâche s'exécute sur un hôte de travail, Deadline Cloud télécharge les fichiers d'entrée de la tâche dans un répertoire temporaire sur le disque local de l'hôte de travail et ajoute des règles de mappage de chemin pour chacun des chemins racines de la tâche vers son emplacement dans le système de fichiers sur le disque local. 

 Pour cet exemple, lancez l'agent de travail Deadline Cloud dans un CloudShell onglet AWS. Laissez toutes les tâches déjà soumises terminer leur exécution, puis supprimez les journaux des tâches du répertoire des journaux : 

```
rm -rf ~/devdemo-logs/queue-*
```

 Le script suivant modifie le bundle de tâches pour afficher tous les fichiers du répertoire de travail temporaire de la session ainsi que le contenu du fichier de règles de mappage de chemins, puis soumet un job avec le bundle modifié : 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of QUEUE1_ID to queue Q1's identifier
QUEUE1_ID=queue-00112233445566778899aabbccddeeff
# Change the value of WSALL_ID to the identifier of the WSAll storage profile
WSALL_ID=sp-00112233445566778899aabbccddeeff

deadline config set settings.storage_profile_id $WSALL_ID

cat > ~/job_attachments_devguide/script.sh << EOF
#!/bin/bash

echo "Session working directory is: \$(pwd)"
echo
echo "Contents:"
find . -type f
echo
echo "Path mapping rules file: \$1"
jq . \$1
EOF

cat > ~/job_attachments_devguide/template.yaml << EOF
specificationVersion: jobtemplate-2023-09
name: "Job Attachments Explorer"
parameterDefinitions:
- name: ScriptFile
  type: PATH
  default: script.sh
  dataFlow: IN
  objectType: FILE
steps:
- name: Step
  script:
    actions:
      onRun:
        command: /bin/bash
        args:
        - "{{Param.ScriptFile}}"
        - "{{Session.PathMappingRulesFile}}"
EOF

deadline bundle submit --farm-id $FARM_ID --queue-id $QUEUE1_ID job_attachments_devguide/
```

 Vous pouvez consulter le journal de l'exécution de la tâche une fois qu'elle a été exécutée par le travailleur dans votre AWS CloudShell environnement : 

```
cat demoenv-logs/queue-*/session*.log
```

Le journal indique que la première chose qui se produit au cours de la session est que les deux fichiers d'entrée de la tâche sont téléchargés vers le travailleur : 

```
2024-07-17 01:26:37,824 INFO ==============================================
2024-07-17 01:26:37,825 INFO --------- Job Attachments Download for Job
2024-07-17 01:26:37,825 INFO ==============================================
2024-07-17 01:26:37,825 INFO Syncing inputs using Job Attachments
2024-07-17 01:26:38,116 INFO Downloaded 142.0 B / 186.0 B of 2 files (Transfer rate: 0.0 B/s)
2024-07-17 01:26:38,174 INFO Downloaded 186.0 B / 186.0 B of 2 files (Transfer rate: 733.0 B/s)
2024-07-17 01:26:38,176 INFO Summary Statistics for file downloads:
Processed 2 files totaling 186.0 B.
Skipped re-processing 0 files totaling 0.0 B.
Total processing time of 0.09752 seconds at 1.91 KB/s.
```

 Vient ensuite le résultat de `script.sh` run by the job : 
+  Les fichiers d'entrée téléchargés lors de la soumission de la tâche se trouvent dans un répertoire dont le nom commence par « assetroot » dans le répertoire temporaire de la session. 
+  Les chemins des fichiers d'entrée ont été déplacés par rapport au répertoire « assetroot » plutôt que par rapport au chemin racine du manifeste d'entrée () de la tâche. `"/"`
+  Le fichier de règles de mappage de chemins contient une règle supplémentaire qui `"/"` correspond au chemin absolu du répertoire « assetroot ». 

 Par exemple : 

```
2024-07-17 01:26:38,264 INFO Output:
2024-07-17 01:26:38,267 INFO Session working directory is: /sessions/session-5b33f
2024-07-17 01:26:38,267 INFO 
2024-07-17 01:26:38,267 INFO Contents:
2024-07-17 01:26:38,269 INFO ./tmp_xdhbsdo.sh
2024-07-17 01:26:38,269 INFO ./tmpdi00052b.json
2024-07-17 01:26:38,269 INFO ./assetroot-assetroot-3751a/shared/projects/project2/file.txt
2024-07-17 01:26:38,269 INFO ./assetroot-assetroot-3751a/home/cloudshell-user/job_attachments_devguide/script.sh
2024-07-17 01:26:38,269 INFO 
2024-07-17 01:26:38,270 INFO Path mapping rules file: /sessions/session-5b33f/tmpdi00052b.json
2024-07-17 01:26:38,282 INFO {
2024-07-17 01:26:38,282 INFO   "version": "pathmapping-1.0",
2024-07-17 01:26:38,282 INFO   "path_mapping_rules": [
2024-07-17 01:26:38,282 INFO     {
2024-07-17 01:26:38,282 INFO       "source_path_format": "POSIX",
2024-07-17 01:26:38,282 INFO       "source_path": "/shared/projects/project1",
2024-07-17 01:26:38,283 INFO       "destination_path": "/mnt/projects/project1"
2024-07-17 01:26:38,283 INFO     },
2024-07-17 01:26:38,283 INFO     {
2024-07-17 01:26:38,283 INFO       "source_path_format": "POSIX",
2024-07-17 01:26:38,283 INFO       "source_path": "/shared/common",
2024-07-17 01:26:38,283 INFO       "destination_path": "/mnt/common"
2024-07-17 01:26:38,283 INFO     },
2024-07-17 01:26:38,283 INFO     {
2024-07-17 01:26:38,283 INFO       "source_path_format": "POSIX",
2024-07-17 01:26:38,283 INFO       "source_path": "/",
2024-07-17 01:26:38,283 INFO       "destination_path": "/sessions/session-5b33f/assetroot-assetroot-3751a"
2024-07-17 01:26:38,283 INFO     }
2024-07-17 01:26:38,283 INFO   ]
2024-07-17 01:26:38,283 INFO }
```

**Note**  
 Si la tâche que vous soumettez comporte plusieurs manifestes avec des chemins racines différents, il existe un répertoire nommé « assetroot » différent pour chacun des chemins racines. 

 Si vous devez référencer l'emplacement du système de fichiers déplacé de l'un de vos fichiers d'entrée, répertoires ou emplacements de système de fichiers, vous pouvez soit traiter le fichier de règles de mappage de chemins dans votre tâche et effectuer le remappage vous-même, soit ajouter un paramètre de tâche de `PATH` type au modèle de tâche de votre ensemble de tâches et transmettre la valeur que vous devez remapper en tant que valeur de ce paramètre. Par exemple, l'exemple suivant modifie le lot de tâches pour qu'il comporte l'un de ces paramètres de tâche, puis soumet une tâche avec l'emplacement du système de fichiers `/shared/projects/project2` comme valeur : 

```
cat > ~/job_attachments_devguide/template.yaml << EOF
specificationVersion: jobtemplate-2023-09
name: "Job Attachments Explorer"
parameterDefinitions:
- name: LocationToRemap
  type: PATH
steps:
- name: Step
  script:
    actions:
      onRun:
        command: /bin/echo
        args:
        - "The location of {{RawParam.LocationToRemap}} in the session is {{Param.LocationToRemap}}"
EOF

deadline bundle submit --farm-id $FARM_ID --queue-id $QUEUE1_ID job_attachments_devguide/ \
  -p LocationToRemap=/shared/projects/project2
```

 Le fichier journal de l'exécution de cette tâche contient sa sortie : 

```
2024-07-17 01:40:35,283 INFO Output:
2024-07-17 01:40:35,284 INFO The location of /shared/projects/project2 in the session is /sessions/session-5b33f/assetroot-assetroot-3751a
```

# Obtenir des fichiers de sortie à partir d'une tâche
<a name="getting-output-files-from-a-job"></a>

Cet exemple montre comment Deadline Cloud identifie les fichiers de sortie générés par vos tâches, décide de télécharger ou non ces fichiers sur Amazon S3 et comment vous pouvez obtenir ces fichiers de sortie sur votre poste de travail. 

 Utilisez le lot de `job_attachments_devguide_output` tâches au lieu du lot de `job_attachments_devguide` tâches dans cet exemple. Commencez par créer une copie du bundle dans votre AWS CloudShell environnement à partir de votre clone du GitHub référentiel d'échantillons de Deadline Cloud : 

```
cp -r deadline-cloud-samples/job_bundles/job_attachments_devguide_output ~/
```

 La différence importante entre cet ensemble de tâches et le lot de `job_attachments_devguide` tâches réside dans l'ajout d'un nouveau paramètre de tâche dans le modèle de tâche : 

```
...
parameterDefinitions:
...
- name: OutputDir
  type: PATH
  objectType: DIRECTORY
  dataFlow: OUT
  default: ./output_dir
  description: This directory contains the output for all steps.
...
```

 La `dataFlow` propriété du paramètre possède la valeur`OUT`. Deadline Cloud utilise la valeur des paramètres de `dataFlow` tâche avec une valeur égale `OUT` ou `INOUT` en tant que résultats de votre tâche. Si l'emplacement du système de fichiers transmis sous forme de valeur à ces types de paramètres de tâche est remappé à un emplacement du système de fichiers local sur le serveur de travail qui exécute le travail, Deadline Cloud recherchera de nouveaux fichiers à cet emplacement et les téléchargera sur Amazon S3 en tant que résultats de travail. 

 Pour voir comment cela fonctionne, lancez d'abord l'agent de travail Deadline Cloud dans un AWS CloudShell onglet. Laissez toutes les tâches déjà soumises terminer leur exécution. Supprimez ensuite les journaux des tâches du répertoire des journaux : 

```
rm -rf ~/devdemo-logs/queue-*
```

 Soumettez ensuite une tâche avec cet ensemble de tâches. Une fois que le worker a CloudShell exécuté vos courses, consultez les journaux : 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of QUEUE1_ID to queue Q1's identifier
QUEUE1_ID=queue-00112233445566778899aabbccddeeff
# Change the value of WSALL_ID to the identifier of the WSAll storage profile
WSALL_ID=sp-00112233445566778899aabbccddeeff

deadline config set settings.storage_profile_id $WSALL_ID

deadline bundle submit --farm-id $FARM_ID --queue-id $QUEUE1_ID ./job_attachments_devguide_output
```

 Le journal indique qu'un fichier a été détecté en sortie et chargé sur Amazon S3 : 

```
2024-07-17 02:13:10,873 INFO ----------------------------------------------
2024-07-17 02:13:10,873 INFO Uploading output files to Job Attachments
2024-07-17 02:13:10,873 INFO ----------------------------------------------
2024-07-17 02:13:10,873 INFO Started syncing outputs using Job Attachments
2024-07-17 02:13:10,955 INFO Found 1 file totaling 117.0 B in output directory: /sessions/session-7efa/assetroot-assetroot-3751a/output_dir
2024-07-17 02:13:10,956 INFO Uploading output manifest to DeadlineCloud/Manifests/farm-0011/queue-2233/job-4455/step-6677/task-6677-0/2024-07-17T02:13:10.835545Z_sessionaction-8899-1/c6808439dfc59f86763aff5b07b9a76c_output
2024-07-17 02:13:10,988 INFO Uploading 1 output file to S3: s3BucketName/DeadlineCloud/Data
2024-07-17 02:13:11,011 INFO Uploaded 117.0 B / 117.0 B of 1 file (Transfer rate: 0.0 B/s)
2024-07-17 02:13:11,011 INFO Summary Statistics for file uploads:
Processed 1 file totaling 117.0 B.
Skipped re-processing 0 files totaling 0.0 B.
Total processing time of 0.02281 seconds at 5.13 KB/s.
```

 Le journal indique également que Deadline Cloud a créé un nouvel objet manifeste dans le compartiment Amazon S3 configuré pour être utilisé par les pièces jointes aux tâches en file d'attente`Q1`. Le nom de l'objet manifeste est dérivé de la batterie de serveurs, de la file d'attente, de la tâche, de l'étape, de la tâche, de l'horodatage et des `sessionaction` identifiants de la tâche qui a généré le résultat. Téléchargez ce fichier manifeste pour voir où Deadline Cloud a placé les fichiers de sortie pour cette tâche : 

```
# The name of queue `Q1`'s job attachments S3 bucket
Q1_S3_BUCKET=$(
  aws deadline get-queue --farm-id $FARM_ID --queue-id $QUEUE1_ID \
    --query 'jobAttachmentSettings.s3BucketName' | tr -d '"'
)

# Fill this in with the object name from your log
OBJECT_KEY="DeadlineCloud/Manifests/..."

aws s3 cp --quiet s3://$Q1_S3_BUCKET/$OBJECT_KEY /dev/stdout | jq .
```

 Le manifeste se présente comme suit : 

```
{
  "hashAlg": "xxh128",
  "manifestVersion": "2023-03-03",
  "paths": [
    {
      "hash": "34178940e1ef9956db8ea7f7c97ed842",
      "mtime": 1721182390859777,
      "path": "output_dir/output.txt",
      "size": 117
    }
  ],
  "totalSize": 117
}
```

 Cela montre que le contenu du fichier de sortie est enregistré sur Amazon S3 de la même manière que les fichiers d'entrée des tâches. Comme pour les fichiers d'entrée, le fichier de sortie est stocké dans S3 avec un nom d'objet contenant le hachage du fichier et le préfixe`DeadlineCloud/Data`. 

```
$ aws s3 ls --recursive s3://$Q1_S3_BUCKET | grep 34178940e1ef9956db8ea7f7c97ed842
2024-07-17 02:13:11        117 DeadlineCloud/Data/34178940e1ef9956db8ea7f7c97ed842.xxh128
```

 Vous pouvez télécharger le résultat d'une tâche sur votre poste de travail à l'aide du moniteur Deadline Cloud ou de la CLI de Deadline Cloud : 

```
deadline job download-output --farm-id $FARM_ID --queue-id $QUEUE1_ID --job-id $JOB_ID
```

 La valeur du paramètre de `OutputDir` tâche dans la tâche soumise est`./output_dir`, de sorte que la sortie est téléchargée dans un répertoire appelé `output_dir` dans le répertoire du bundle de tâches. Si vous avez spécifié un chemin absolu ou un emplacement relatif différent comme valeur pour`OutputDir`, les fichiers de sortie seront plutôt téléchargés vers cet emplacement. 

```
$ deadline job download-output --farm-id $FARM_ID --queue-id $QUEUE1_ID --job-id $JOB_ID
Downloading output from Job 'Job Attachments Explorer: Output'

Summary of files to download:
    /home/cloudshell-user/job_attachments_devguide_output/output_dir/output.txt (1 file)

You are about to download files which may come from multiple root directories. Here are a list of the current root directories:
[0] /home/cloudshell-user/job_attachments_devguide_output
> Please enter the index of root directory to edit, y to proceed without changes, or n to cancel the download (0, y, n) [y]: 

Downloading Outputs  [####################################]  100%
Download Summary:
    Downloaded 1 files totaling 117.0 B.
    Total download time of 0.14189 seconds at 824.0 B/s.
    Download locations (total file counts):
        /home/cloudshell-user/job_attachments_devguide_output (1 file)
```

# Utilisation des fichiers d'une étape dans une étape dépendante
<a name="using-files-output-from-a-step-in-a-dependent-step"></a>

Cet exemple montre comment une étape d'une tâche peut accéder aux sorties d'une étape dont elle dépend dans la même tâche. 

 Pour rendre les résultats d'une étape accessibles à une autre, Deadline Cloud ajoute des actions supplémentaires à une session afin de télécharger ces résultats avant d'exécuter des tâches dans la session. Vous lui indiquez à partir de quelles étapes télécharger les sorties en déclarant ces étapes comme des dépendances de l'étape qui doit utiliser les sorties. 

Utilisez le `job_attachments_devguide_output` job bundle pour cet exemple. Commencez par créer une copie dans votre AWS CloudShell environnement à partir de votre clone du GitHub référentiel d'échantillons de Deadline Cloud. Modifiez-le pour ajouter une étape dépendante qui ne s'exécute qu'après l'étape existante et utilise le résultat de cette étape : 

```
cp -r deadline-cloud-samples/job_bundles/job_attachments_devguide_output ~/

cat >> job_attachments_devguide_output/template.yaml << EOF
- name: DependentStep
  dependencies:
  - dependsOn: Step
  script:
    actions:
      onRun:
        command: /bin/cat
        args:
        - "{{Param.OutputDir}}/output.txt"
EOF
```

 La tâche créée avec cet ensemble de tâches modifié s'exécute sous la forme de deux sessions distinctes, une pour la tâche de l'étape « Étape », puis une seconde pour la tâche de l'étape « DependentStep ». 

Démarrez d'abord l'agent de travail de Deadline Cloud dans un CloudShell onglet. Laissez toutes les tâches déjà soumises terminer leur exécution, puis supprimez les journaux des tâches du répertoire des journaux : 

```
rm -rf ~/devdemo-logs/queue-*
```

 Soumettez ensuite une tâche à l'aide de l'ensemble de `job_attachments_devguide_output` tâches modifié. Attendez qu'il ait fini de s'exécuter sur le travailleur de votre CloudShell environnement. Consultez les journaux des deux sessions : 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of QUEUE1_ID to queue Q1's identifier
QUEUE1_ID=queue-00112233445566778899aabbccddeeff
# Change the value of WSALL_ID to the identifier of the WSAll storage profile
WSALL_ID=sp-00112233445566778899aabbccddeeff

deadline config set settings.storage_profile_id $WSALL_ID

deadline bundle submit --farm-id $FARM_ID --queue-id $QUEUE1_ID ./job_attachments_devguide_output

# Wait for the job to finish running, and then:

cat demoenv-logs/queue-*/session-*
```

 Dans le journal de session de la tâche de l'étape nommée`DependentStep`, deux actions de téléchargement distinctes sont exécutées : 

```
2024-07-17 02:52:05,666 INFO ==============================================
2024-07-17 02:52:05,666 INFO --------- Job Attachments Download for Job
2024-07-17 02:52:05,667 INFO ==============================================
2024-07-17 02:52:05,667 INFO Syncing inputs using Job Attachments
2024-07-17 02:52:05,928 INFO Downloaded 207.0 B / 207.0 B of 1 file (Transfer rate: 0.0 B/s)
2024-07-17 02:52:05,929 INFO Summary Statistics for file downloads:
Processed 1 file totaling 207.0 B.
Skipped re-processing 0 files totaling 0.0 B.
Total processing time of 0.03954 seconds at 5.23 KB/s.

2024-07-17 02:52:05,979 INFO 
2024-07-17 02:52:05,979 INFO ==============================================
2024-07-17 02:52:05,979 INFO --------- Job Attachments Download for Step
2024-07-17 02:52:05,979 INFO ==============================================
2024-07-17 02:52:05,980 INFO Syncing inputs using Job Attachments
2024-07-17 02:52:06,133 INFO Downloaded 117.0 B / 117.0 B of 1 file (Transfer rate: 0.0 B/s)
2024-07-17 02:52:06,134 INFO Summary Statistics for file downloads:
Processed 1 file totaling 117.0 B.
Skipped re-processing 0 files totaling 0.0 B.
Total processing time of 0.03227 seconds at 3.62 KB/s.
```

 La première action télécharge le `script.sh` fichier utilisé par l'étape nommée « Étape ». La deuxième action télécharge les résultats de cette étape. Deadline Cloud détermine les fichiers à télécharger en utilisant le manifeste de sortie généré par cette étape comme manifeste d'entrée. 

 À la fin du même journal, vous pouvez voir le résultat de l'étape nommée DependentStep « » : 

```
2024-07-17 02:52:06,213 INFO Output:
2024-07-17 02:52:06,216 INFO Script location: /sessions/session-5b33f/assetroot-assetroot-3751a/script.sh
```