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.
# Pièces jointes aux offres d'emploi dans Deadline Cloud
Grâce aux *pièces jointes aux tâches*, vous pouvez transférer des fichiers entre votre poste de travail et AWS Deadline Cloud. Avec les pièces jointes aux tâches, vous n'avez pas besoin de configurer manuellement un compartiment Amazon S3 pour vos fichiers. Au lieu de cela, lorsque vous créez une file d'attente avec la console Deadline Cloud, vous choisissez le bucket pour les pièces jointes à vos tâches.
La première fois que vous soumettez une tâche à Deadline Cloud, tous les fichiers de la tâche sont transférés vers Deadline Cloud. Pour les soumissions ultérieures, seuls les fichiers modifiés sont transférés, ce qui permet d'économiser du temps et de la bande passante.
Une fois le traitement terminé, vous pouvez télécharger le résultat depuis la page détaillée de la tâche ou à l'aide de la `deadline job download-output` commande Deadline Cloud CLI.
Vous pouvez utiliser le même compartiment S3 pour plusieurs files d'attente. Définissez un préfixe racine différent pour chaque file d'attente afin d'organiser les pièces jointes dans le compartiment.
Lorsque vous créez une file d'attente avec la console, vous pouvez choisir un rôle Gestion des identités et des accès AWS (IAM) existant ou demander à la console de créer un nouveau rôle. Si la console crée le rôle, elle définit les autorisations d'accès au compartiment spécifié pour la file d'attente. Si vous choisissez un rôle existant, vous devez lui accorder les autorisations d'accès au compartiment S3.
## Chiffrement pour les compartiments S3 associés aux tâches
Les fichiers joints aux tâches sont chiffrés dans votre compartiment S3 par défaut. Ce cryptage permet de protéger vos informations contre tout accès non autorisé. Vous n'avez rien à faire pour que vos fichiers soient chiffrés à l'aide des clés fournies par Deadline Cloud. Pour plus d'informations, consultez le *guide de l'utilisateur* [Amazon S3 qui chiffre désormais automatiquement tous les nouveaux objets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html).
Vous pouvez utiliser votre propre AWS Key Management Service clé gérée par le client pour chiffrer le compartiment S3 qui contient les pièces jointes à vos tâches. Pour ce faire, vous devez modifier le rôle IAM de la file d'attente associée au bucket afin de permettre l'accès au AWS KMS key.
**Pour ouvrir l'éditeur de stratégie IAM pour le rôle de file d'attente**
1. Connectez-vous à la [console Deadline Cloud AWS Management Console et ouvrez-la](https://console.aws.amazon.com/deadlinecloud/home). Sur la page principale, dans la section **Commencer**, choisissez **Afficher les fermes**.
1. Dans la liste des parcs de serveurs, choisissez le parc contenant la file d'attente à modifier.
1. Dans la liste des files d'attente, choisissez la file à modifier.
1. Dans la section **Détails de la file d'attente**, choisissez le **rôle de service** pour ouvrir la console IAM correspondant au rôle de service.
Effectuez ensuite la procédure suivante.
**Pour mettre à jour la politique de rôle avec l'autorisation de AWS KMS**
1. Dans la liste des **politiques d'autorisations**, choisissez la politique du rôle.
1. Dans la section **Autorisations définies dans cette politique**, choisissez **Modifier**.
1. Choisissez **Ajouter une nouvelle instruction**.
1. Copiez et collez la politique suivante dans l'éditeur. Changez le *`Region`* ``*`accountID`*, et *`keyID`* `` selon vos propres valeurs.
```
{
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:DescribeKey",
"kms:GenerateDataKey"
],
"Resource": [
"arn:aws:kms:us-east-1:111122223333:key/keyID"
]
}
```
1. Choisissez **Suivant**.
1. Passez en revue les modifications apportées à la politique, puis lorsque vous êtes satisfait, choisissez **Enregistrer les modifications**.
## Remplacer le compartiment des pièces jointes
Vous pouvez remplacer votre compartiment de pièces jointes actuel par un autre compartiment de pièces jointes. Vous trouverez un bouton sous l'onglet **Job Attachments** dans les détails de la file d'attente. Vous pouvez l'utiliser pour modifier le compartiment des pièces jointes aux tâches ou remplacer le dossier racine dans le même compartiment pour télécharger les pièces jointes aux tâches.
**Pour accéder aux paramètres des pièces jointes aux tâches**
1. Accédez aux **détails de la file d'attente**, puis recherchez l'onglet **Job Attachments**.
1. Dans l'onglet Pièces jointes aux tâches, deux options s'offrent à vous :
1. Modifiez le compartiment des pièces jointes aux tâches en procédant comme suit :
1. Sélectionnez un nouveau compartiment S3.
1. Mettez à jour la politique de rôle de service de la file d'attente pour autoriser l'accès au nouveau compartiment.
OU
1. Modifiez le dossier racine d'un bucket existant en procédant comme suit :
1. Modifiez le nom du dossier racine.
1. Mettez à jour l'ARN de la ressource dans le rôle de service de file d'attente.
**Pour mettre à jour le rôle de service**
1. Accédez à votre rôle de ferme > file d'attente > service de file d'attente.
1. Choisissez **Modifier dans JSON**.
1. Localisez l'ARN de la ressource (le dossier racine par défaut est **DeadlineCloud**) :
```
"arn:aws:s3:::/DeadlineCloud/*"
]
```
1. Mettez à jour l'ARN avec un nouveau compartiment ou dossier :
```
"arn:aws:s3:::/NEW-ROOT-FOLDER-NAME/*"
]
```
1. Vérifiez les autorisations après avoir apporté ces modifications pour garantir un accès approprié.
## Gestion des pièces jointes aux tâches dans les compartiments S3
Deadline Cloud stocke les fichiers joints requis pour votre tâche dans un compartiment S3. Ces fichiers s'accumulent au fil du temps, ce qui augmente les coûts d'Amazon S3. Pour réduire les coûts, vous pouvez appliquer une configuration S3 Lifecycle à votre compartiment S3. Cette configuration permet de supprimer automatiquement les fichiers du compartiment. Comme le compartiment S3 se trouve dans votre compte, vous pouvez choisir de modifier ou de supprimer la configuration du cycle de vie S3 à tout moment. Pour plus d'informations, consultez la section [Exemples de configuration du cycle de vie S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/lifecycle-configuration-examples.html) dans le *guide de l'utilisateur Amazon S3*.
Pour une solution de gestion des compartiments S3 plus précise, vous pouvez configurer vos objets Compte AWS pour qu'ils expirent dans un compartiment S3 en fonction de leur dernier accès. Pour plus d'informations, consultez la section [Expiration des objets Amazon S3 en fonction de la date du dernier accès afin de réduire les coûts](https://aws.amazon.com/blogs/architecture/expiring-amazon-s3-objects-based-on-last-accessed-date-to-decrease-costs/) sur le blog AWS d'architecture.
# Système de fichiers virtuel Deadline Cloud
La prise en charge du système de fichiers virtuel pour les pièces jointes aux tâches dans AWS Deadline Cloud permet au logiciel client sur les employés de communiquer directement avec Amazon Simple Storage Service. Les travailleurs peuvent charger des fichiers uniquement lorsque cela est nécessaire au lieu de télécharger tous les fichiers avant le traitement. Les fichiers sont stockés localement. Cette approche permet d'éviter de télécharger à plusieurs reprises des ressources utilisées plusieurs fois. Tous les fichiers sont supprimés une fois le travail terminé.
+ Le système de fichiers virtuel améliore considérablement les performances pour des profils de travail spécifiques. En général, ce sont les petits sous-ensembles du nombre total de fichiers comportant des flottes de travailleurs plus importantes qui présentent le plus d'avantages. Les délais de traitement sont à peu près équivalents pour un petit nombre de dossiers nécessitant moins de personnel.
+ La prise en charge des systèmes de fichiers virtuels n'est disponible que pour les Linux employés des flottes gérées par des services.
+ Le système de fichiers virtuel Deadline Cloud prend en charge les opérations suivantes, mais n'est pas compatible avec POSIX :
+ Fichier`create`,`delete`,`open`,`close`,`read`, `write``append`,`truncate`,`rename`,`move`,`copy`,`stat`,`fsync`, et `falloc`
+ Répertoire`create`, `delete``rename`,`move`,`copy`, et `stat`
+ Le système de fichiers virtuel est conçu pour réduire le transfert de données et améliorer les performances lorsque vos tâches n'accèdent qu'à une partie d'un ensemble de données volumineux. Il n'est pas optimisé pour toutes les charges de travail. Vous devez tester votre charge de travail avant d'exécuter des tâches de production.
## Activer le support VFS
Le support du système de fichiers virtuel (VFS) est activé pour chaque tâche. Une tâche revient au cadre de pièces jointes par défaut dans les cas suivants :
+ Un profil d'instance de travail ne prend pas en charge un système de fichiers virtuel.
+ Des problèmes empêchent le lancement du processus du système de fichiers virtuel.
+ Le système de fichiers virtuel ne peut pas être monté.
**Pour activer la prise en charge du système de fichiers virtuel à l'aide de l'expéditeur**
1. Lorsque vous soumettez une tâche, cliquez sur le bouton **Paramètres** pour ouvrir le **panneau de configuration du poste de travail AWS Deadline Cloud**.
1. **Dans le menu déroulant des **options du système de fichiers Job attachments**, sélectionnez VIRTUAL.**
![\[L'émetteur de Deadline Cloud présentant les options du système de fichiers pour les pièces jointes aux tâches.\]](http://docs.aws.amazon.com/fr_fr/deadline-cloud/latest/userguide/images/submitter-vfs.png)
1. Pour enregistrer vos modifications, cliquez **sur OK**.
**Pour activer la prise en charge des systèmes de fichiers virtuels à l'aide du AWS CLI**
+ Utilisez la commande suivante lorsque vous soumettez une tâche enregistrée :
```
deadline bundle submit-job --job-attachments-file-system VIRTUAL
```
Pour vérifier que le système de fichiers virtuel a été lancé correctement pour une tâche donnée, consultez vos journaux dans Amazon CloudWatch Logs. Recherchez les messages suivants :
```
Using mount_point mount_point
Launching vfs with command command
Launched vfs as pid PID number
```
Si le journal contient le message suivant, le support du système de fichiers virtuel est désactivé :
```
Virtual File System not found, falling back to COPIED for JobAttachmentsFileSystem.
```
## Résolution des problèmes liés au support des systèmes de fichiers virtuels
Vous pouvez consulter les journaux de votre système de fichiers virtuel à l'aide du moniteur Deadline Cloud. Pour obtenir des instructions, veuillez consulter [Afficher les journaux de session et de travail dans Deadline Cloud](view-logs.md).
Les journaux du système de fichiers virtuel sont également envoyés au groupe CloudWatch Logs associé à la file d'attente partagée avec la sortie de l'agent de travail.
# Téléchargements automatiques
La CLI Deadline fournit une commande permettant de télécharger le résultat de toutes les tâches d'une file d'attente terminées depuis la dernière exécution de la même commande. Vous pouvez le configurer comme une tâche cron ou une tâche planifiée à exécuter de manière répétée. Cette configuration met en place le téléchargement automatique de la sortie sur une base continue.
Avant de configurer les téléchargements automatiques, suivez les étapes décrites dans [Profils de stockage pour les pièces jointes aux tâches](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/storage-profile.html) afin de configurer tous les chemins des données relatives aux actifs à charger et à télécharger. Si une tâche utilise un chemin de sortie qui ne figure pas dans son profil de stockage, le téléchargement automatique ignore le téléchargement de cette sortie et affiche des messages d'avertissement récapitulant les fichiers non téléchargés. De même, si une tâche est soumise sans profil de stockage, le téléchargement automatique ignore cette tâche et affiche un message d'avertissement. Par défaut, les émetteurs de Deadline Cloud affichent des messages d'avertissement pour les chemins situés en dehors des profils de stockage afin de garantir une configuration correcte.
## Configuration des AWS informations d'identification
Les téléchargements automatiques utilisent la CLI Deadline pour télécharger en continu les résultats des tâches. Pour authentifier ces téléchargements, vous avez besoin d'informations d'identification IAM à long terme. Deadline Les identifiants Cloud Monitor expirent, vous ne pouvez donc pas les utiliser à cette fin.
Suivez les étapes ci-dessous pour configurer des informations d'identification à long terme.
**Important**
Tenez compte des avertissements suivants :
**N'utilisez PAS** les informations d'identification root de votre compte pour accéder aux AWS ressources. Ces informations d’identification offrent un accès illimité au compte et sont difficiles à révoquer.
**N’incluez PAS** de clés d’accès littérales ou d’informations d’identification dans vos fichiers d’application. Vous risqueriez en effet d’exposer accidentellement vos informations d’identification si, par exemple, vous chargiez le projet sur un référentiel public.
**N’incluez PAS** de fichiers contenant des informations d’identification dans votre zone de projet.
Sécurisez vos clés d'accès. Ne communiquez pas vos clés d’accès à des tiers non autorisés, même pour vous aider à trouver les [identifiants de votre compte](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-identifiers.html). Ce faisant, vous pouvez donner à quelqu'un un accès permanent à votre compte.
Sachez que toutes les informations d'identification stockées dans le fichier AWS d'informations d'identification partagé sont stockées en texte brut.
Pour plus de détails, consultez la section [Meilleures pratiques en matière de gestion des clés AWS d'accès dans le manuel de *référence AWS général*.](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#securing_access-keys)
**Créer un utilisateur IAM**
1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Dans le volet de navigation, sélectionnez **Utilisateurs**, puis **Créer un utilisateur**.
1. Donnez un nom à l'utilisateur**deadline-output-downloader**. Décochez la case **Fournir un accès utilisateur au AWS Management Console**, puis choisissez **Next**.
1. Choisissez **Joindre directement les politiques**.
1. Choisissez **Créer une politique** pour créer une politique personnalisée avec les autorisations minimales requises.
1. Dans l'éditeur JSON, spécifiez les autorisations suivantes :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DeadlineCloudOutputDownload",
"Effect": "Allow",
"Action": [
"deadline:AssumeQueueRoleForUser",
"deadline:ListQueueEnvironments",
"deadline:ListSessions",
"deadline:ListSessionActions",
"deadline:SearchJobs",
"deadline:GetJob",
"deadline:GetQueue",
"deadline:GetStorageProfileForQueue"
],
"Resource": "*"
}
]
}
```
------
1. Nommez la politique **DeadlineCloudOutputDownloadPolicy** et choisissez **Create policy**.
1. Retournez à la page de création d'utilisateur, actualisez la liste des politiques, sélectionnez celle **DeadlineCloudOutputDownloadPolicy**que vous venez de créer, puis choisissez **Next**.
1. Vérifiez les informations de l'utilisateur, puis choisissez **Créer un utilisateur**.
**Créer une clé d’accès**
1. Sur la page des détails de l'utilisateur, sélectionnez l'onglet **Informations d'identification de sécurité**. Dans la section **Clés d’accès**, choisissez **Créer une clé d’accès**.
1. Indiquez que vous souhaitez utiliser la clé pour Autre, puis cliquez sur **Suivant**, puis sur **Créer une clé d'accès**.
1. Sur la page **Récupérer les clés d'accès**, choisissez **Afficher** pour révéler la valeur de la clé d'accès secrète de votre utilisateur. Vous pouvez copier les informations d’identification ou télécharger un fichier .csv.
**Stocker les clés d'accès des utilisateurs**
+ Stockez les clés d'accès utilisateur dans le fichier AWS d'informations d'identification de votre système :
+ LinuxActivé, le fichier se trouve dans `~/.aws/credentials`
+ WindowsActivé, le fichier se trouve dans `%USERPROFILE\.aws\credentials`
Remplacez les clés suivantes :
```
[deadline-downloader]
aws_access_key_id=ACCESS_KEY_ID
aws_secret_access_key=SECRET_ACCESS_KEY
region=YOUR_AWS_REGION
```
**Important**
Lorsque vous n'aurez plus besoin de cet utilisateur IAM, nous vous recommandons de le supprimer afin de respecter les [meilleures pratiques en AWS matière de sécurité](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#lock-away-credentials). Nous vous recommandons de demander à vos utilisateurs humains d'utiliser des informations d'identification temporaires [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html)lors de l'accès AWS.
## Conditions préalables
Effectuez les étapes suivantes avant de créer une tâche cron ou une tâche planifiée pour le téléchargement automatique.
1. Si ce n'est pas déjà fait, installez [Python](https://www.python.org/).
1. Installez la CLI Deadline en exécutant :
```
python -m pip install deadline
```
1. Vérifiez que la version de la CLI Deadline est 0.52.1 ou plus récente à l'aide de la commande suivante.
```
$ deadline --version
deadline, version 0.52.1
```
## Testez la commande de téléchargement de sortie
**Pour vérifier que la commande fonctionne dans votre environnement**
1. Trouvez le chemin d'accès à Deadline
------
#### [ Linux and macOS ]
```
$ which deadline
```
------
#### [ Windows ]
```
C:\> where deadline
```
------
#### [ PowerShell ]
```
PS C:\> Get-Command deadline
```
------
1. Exécutez la commande sync-output pour démarrer.
```
/path/to/deadline queue sync-output \
--profile deadline-downloader \
--farm-id YOUR_FARM_ID \
--queue-id YOUR_QUEUE_ID \
--storage-profile-id YOUR_PROFILE_ID \
--checkpoint-dir /path/to/checkpoint/directory \
```
1. Vous ne devez effectuer cette étape que si votre machine de téléchargement est identique à la machine de soumission. Remplacez `--storage-profile-id YOUR_PROFILE_ID \` ci-dessus par`--ignore-storage-profiles`.
1. Soumettez une offre d'emploi de test.
1. Téléchargez le fichier .zip depuis. GitHub
1. Ouvrez le [deadline-cloud-samples GitHub référentiel](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline).
1. Choisissez **Code** puis, dans le menu déroulant, sélectionnez **Télécharger le fichier ZIP**.
1. Décompressez l'archive téléchargée dans un répertoire local.
1. Exécuter
```
cd /path/to/unzipped/deadline-cloud-samples-mainline/job_bundles/job_attachments_devguide_output
```
1. Exécuter
```
deadline bundle submit .
```
1. Si vous ne disposez pas de la configuration de date limite par défaut, vous devrez peut-être fournir les informations suivantes dans la ligne de commande.
```
--farm-id YOUR-FARM-ID --queue-id YOUR-QUEUE-ID
```
1. Attendez que le travail soit terminé avant de passer à l'étape suivante.
1. Exécutez à nouveau la commande sync-output.
```
/path/to/deadline queue sync-output \
--profile deadline-downloader \
--farm-id YOUR_FARM_ID \
--queue-id YOUR_QUEUE_ID \
--storage-profile-id YOUR_PROFILE_ID \
--checkpoint-dir /path/to/checkpoint/directory
```
1. Vérifiez les paramètres suivants :
+ Les résultats de votre tâche de test apparaissent dans le répertoire de destination.
+ Un fichier de point de contrôle est créé dans le répertoire de points de contrôle que vous avez spécifié.
## Configurer des téléchargements planifiés
Sélectionnez l'onglet correspondant à votre système d'exploitation pour savoir comment configurer les téléchargements automatiques toutes les 5 minutes.
------
#### [ Linux ]
1. **Vérifier l'installation de la CLI par date limite**
Obtenez le chemin exact vers le fichier exécutable de votre date limite :
```
$ which deadline
```
Notez ce chemin (par exemple,`/opt/homebrew/bin/deadline`) à utiliser dans le fichier plist.
1. **Créer un répertoire de points de contrôle**
Créez le répertoire dans lequel les fichiers de points de contrôle seront stockés. Assurez-vous que votre utilisateur dispose des autorisations appropriées pour exécuter la commande.
```
$ mkdir -p /path/to/checkpoint/directory
```
1. **Créer un répertoire de journaux**
Créez un répertoire pour les journaux des tâches cron :
```
$ mkdir -p /path/to/logs
```
Envisagez de configurer la rotation du journal sur le fichier journal à l'aide de https://www.redhat.com/en/ blog/setting-logrotate
1. **Vérifier le Crontab actuel**
Consultez votre crontab actuel pour voir les tâches existantes :
```
$ crontab -l
```
1. **Modifier Crontab**
Ouvrez votre fichier crontab pour le modifier :
```
$ crontab -e
```
Si c'est la première fois, vous serez peut-être invité à choisir un éditeur (nano, vim, etc.).
1. **Ajouter une entrée Cron Job**
Ajoutez la ligne suivante pour exécuter le travail toutes les 5 minutes (remplacez les chemins par les valeurs réelles des étapes 1 et 2) :
```
*/5 * * * * /path/to/deadline queue sync-output --profile deadline-downloader --farm-id YOUR_FARM_ID --queue-id YOUR_QUEUE_ID --storage-profile-id YOUR_PROFILE_ID --checkpoint-dir /path/to/checkpoint/directory >> /path/to/logs/deadline_sync.log 2>&1
```
1. **Vérifier l'installation de Cron Job**
Après avoir enregistré et quitté l'éditeur, vérifiez que la tâche cron a été ajoutée :
```
$ crontab -l
```
Vous devriez voir votre nouvel emploi répertorié.
1. **Vérifier l'état du service Cron**
Assurez-vous que le service cron est en cours d'exécution :
```
# For systemd systems (most modern Linux distributions)
$ sudo systemctl status cron
# or
$ sudo systemctl status crond
# For older systems
$ sudo service cron status
```
S'il n'est pas en cours d'exécution, démarrez-le :
```
$ sudo systemctl start cron
$ sudo systemctl enable cron # Enable auto-start on boot
```
------
#### [ macOS ]
1. **Vérifier l'installation de la CLI par date limite**
Obtenez le chemin exact vers le fichier exécutable de votre date limite :
```
$ which deadline
```
Notez ce chemin (par exemple,`/opt/homebrew/bin/deadline`) à utiliser dans le fichier plist.
1. **Créer un répertoire de points de contrôle et un répertoire de journaux**
Créez le répertoire dans lequel les fichiers de points de contrôle seront stockés :
```
$ mkdir -p /path/to/checkpoint/directory
$ mkdir -p /path/to/logs
```
Envisagez de configurer la rotation des journaux dans le fichier journal à l'aide de https://formulae.brew. sh/formula/logrotate
1. **Création d'un fichier Plist**
Créez un fichier de configuration `~/Library/LaunchAgents/com.user.deadlinesync.plist` avec le contenu suivant (remplacez-le par `/path/to/deadline` le chemin réel indiqué à l'étape 1) :
```
Label
com.user.deadlinesync
ProgramArguments
/path/to/deadline
queue
sync-output
--profile
deadline-downloader
--farm-id
YOUR_FARM_ID
--queue-id
YOUR_QUEUE_ID
--storage-profile-id
YOUR STORAGE PROFILE ID
--checkpoint-dir
/path/to/checkpoint/dir
RunAtLoad
UserName
YOUR_USER_NAME
StandardOutPath
/path/to/logs/deadline_sync.log
StartInterval
300
```
Remplacez `--storage-profile-id YOUR_PROFILE_ID` ci-dessus par `--ignore-storage-profiles` si votre machine de téléchargement est la même que la machine de soumission.
1. **Valider le fichier Plist**
Validez la syntaxe XML de votre fichier plist :
```
$ plutil -lint ~/Library/LaunchAgents/com.user.deadlinesync.plist
```
Cela devrait renvoyer « OK » si le fichier est valide.
1. **Vérifiez les agents de lancement ou les démons de lancement existants**
Vérifiez si un agent de lancement est déjà chargé :
```
$ launchctl list | grep deadlinesync
OR
$ sudo launchctl list | grep deadlinesync
```
S'il en existe un, déchargez-le d'abord :
```
$ launchctl bootout gui/$(id -u)/com.user.deadlinesync
OR
$ sudo launchctl bootout system/com.user.deadlinesync
```
1. **Création et démarrage**
Pour exécuter cette tâche alors que l'utilisateur est connecté, exécutez-la en tant que **LaunchAgent**. Pour exécuter cette tâche sans qu'un utilisateur ne soit connecté à chaque fois que la machine est en cours d'exécution, exécutez-la en tant que **LaunchDaemon**.
1. Pour exécuter en tant que **LaunchAgent:**
1. Utilisez la configuration créée sous `~/Library/LaunchAgents/com.user.deadlinesync.plist`
1. Chargez ensuite la configuration à l'aide de la commande bootstrap :
```
$ launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.user.deadlinesync.plist
```
1. Pour exécuter en tant que **LaunchDaemon**:
1. Déplacez le fichier Pilst et modifiez les autorisations en exécutant ce qui suit :
```
$ sudo mv ~/Library/LaunchAgents/com.user.deadlinesync.plist /Library/LaunchDaemons/
$ sudo chown root:wheel /Library/LaunchDaemons/com.user.deadlinesync.plist
$ sudo chmod 644 /Library/LaunchDaemons/com.user.deadlinesync.plist
```
1. Chargez l'agent de lancement à l'aide de la commande bootstrap moderne :
```
$ sudo launchctl bootstrap system /Library/LaunchDaemons/com.user.deadlinesync.plist
```
1. **Vérifier le statut**
Si vous avez amorcé une LaunchAgent exécution, procédez comme suit pour confirmer qu'elle est chargée :
```
$ launchctl list | grep deadlinesync
```
Si vous avez amorcé un LaunchDaemon, confirmez qu'il est chargé en exécutant :
```
$ sudo launchctl list | grep deadlinesync
```
La sortie doit ressembler à
```
SOME_PID_NUMBER 0 com.user.deadlinesync
```
Pour des informations détaillées sur le statut :
```
$ launchctl print gui/$(id -u)/com.user.deadlinesync
```
Cela montre l'état actuel, les arguments du programme, les variables d'environnement, l'intervalle d'exécution et l'historique des exécutions.
------
#### [ Windows ]
**Note**
La tâche planifiée créée à l'aide de ces instructions ne fonctionne que lorsque l'utilisateur est connecté.
Pour le configurer au démarrage du système sans nécessiter de connexion utilisateur, consultez la [Windowsdocumentation](https://learn.microsoft.com/en-us/windows/win32/taskschd/using-the-task-scheduler) officielle.
Pour toutes les étapes ci-dessous, utilisez l'invite de commande - exécutez en tant qu'administrateur :
1. **Vérifier l'installation de la CLI par date limite**
Trouvez le fichier exécutable de la date limite :
```
C:\> where deadline
```
Notez le chemin complet (par exemple,`C:\Program Files\Amazon\DeadlineCloud\deadline.exe`) à utiliser dans la tâche.
1. **Créer un répertoire de points de contrôle**
Créez le répertoire dans lequel les fichiers de points de contrôle seront stockés :
```
C:\> mkdir "path\to\checkpoint\directory"
```
1. **Créer un répertoire de journaux**
Créez un répertoire pour les journaux des tâches :
```
C:\> mkdir "path\to\logs"
```
1. **Créer un wrapper de fichiers Batch**
Créez le fichier batch avec le contenu suivant :
```
C:\> notepad C:\path\to\deadline_sync.bat
```
```
YOUR_PATH_TO_DEADLINE.EXE queue sync-output --profile deadline-downloader --farm-id YOUR_FARM_ID --queue-id YOUR_QUEUE_ID --storage-profile-id YOUR_PROFILE_ID --checkpoint-dir path\to\checkpoint\checkpoints > path\to\logs\deadline.log 2>&1
```
1. **Fichier de test Batch**
Testez le fichier batch manuellement :
```
C:\> .\path\to\deadline_sync.bat
```
Vérifiez que le fichier journal a été créé :
```
C:\> notepad path\to\logs\deadline_sync.log
```
1. **Vérifier le service du planificateur de tâches**
Assurez-vous que le service du planificateur de tâches est en cours d'exécution :
```
C:\> sc query "Schedule"
```
Si le service n'existe pas, essayez d'autres noms :
```
C:\> sc query "TaskScheduler"
C:\> sc query "Task Scheduler"
```
S'il n'est pas en cours d'exécution, démarrez-le :
```
C:\> sc start "Schedule"
```
1. **Créer une tâche planifiée**
Créez la tâche à exécuter toutes les 5 minutes.
```
C:\> schtasks /create /tn "DeadlineOutputSync" /tr "C:\path\to\deadline_sync.bat" /sc minute /mo 5
```
Répartition des commandes :
+ `/tn`- Nom de la tâche
+ `/tr`- Tâche à exécuter (votre fichier batch)
+ `/sc minute /mo 5`- Horaire : toutes les 5 minutes
1. **Vérifier la création de tâches**
Vérifiez que la tâche a bien été créée :
```
schtasks /query /tn "DeadlineOutputSync" /v /fo LIST
```
Recherchez :
+ **Tâche à exécuter** : devrait afficher le chemin de votre fichier batch
+ **Durée de la prochaine exécution** : devrait afficher une heure dans les 5 minutes
1. **Exécution des tâches de test**
Exécutez la tâche manuellement pour tester :
```
schtasks /run /tn "DeadlineOutputSync"
```
Vérifiez l'état de la tâche :
```
schtasks /query /tn "DeadlineOutputSync"
```
------
**Vérifiez la configuration**
Pour vérifier que la configuration des téléchargements automatiques s'est bien déroulée, procédez comme suit.
1. Soumettez une nouvelle tâche de test.
1. Attendez la fin d'un intervalle du planificateur, qui dans ce cas est de 5 minutes.
1. Vérifiez que les nouvelles sorties sont téléchargées automatiquement.
Si les résultats ne sont pas téléchargés, consultez la section Dépannage pour les journaux de processus.
## Résolution des problèmes liés aux téléchargements automatiques
Si vous rencontrez des problèmes avec les téléchargements automatiques, vérifiez les points suivants :
### Problèmes liés au profil de stockage
+ Une erreur telle que `[Errno 2] No such file or directory` ou `[Errno 13] Permission denied` présente dans le fichier journal peut être liée à des profils de stockage manquants ou mal configurés.
+ Consultez la section [Profils de stockage](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/storage-profile-job-attachments.html) pour savoir comment configurer vos profils de stockage lorsque la machine de téléchargement est différente de la machine de soumission.
+ Pour les téléchargements sur la même machine, essayez le `--ignore-storage-profiles` drapeau.
### Autorisations d'annuaire
+ Assurez-vous que l'utilisateur du service de planification dispose des éléments suivants :
+ Accès en lecture/écriture au répertoire du point de contrôle
+ Accès en écriture au répertoire de destination de sortie
+ Pour Linux etmacOS, utilisez `ls -la` pour vérifier les autorisations.
+ PourWindows, consultez les paramètres de sécurité dans le dossier Propriétés.
### Vérification des journaux du planificateur
------
#### [ Linux ]
1. Vérifiez si le service cron est en cours d'exécution :
```
# For systemd systems
$ sudo systemctl status cron
# or
$ sudo systemctl status crond
# Check if your user has cron job correctly configured
$ crontab -l
```
1. Afficher les journaux d'exécution de cron :
```
# Check system logs for cron activity (most common locations)
$ sudo tail -f /var/log/syslog | grep CRON
$ sudo tail -f /var/log/cron.log | grep deadline
# View recent cron logs
$ sudo journalctl -u cron -f
$ sudo journalctl -u crond -f # On some systems
```
1. Vérifiez vos journaux de tâches cron spécifiques :
```
# View the log file specified in your cron job
$ tail -100f /path/to/logs/deadline_sync.log
```
1. Recherchez l'exécution d'une tâche cron dans les journaux système :
```
# Look for your specific cron job executions
$ sudo grep "deadline.*incremental-output-download" /var/log/syslog
# Check for cron job starts and completions
$ sudo grep "$(whoami).*CMD.*deadline" /var/log/syslog
```
1. Vérifiez les mises à jour des fichiers de point de contrôle :
```
# List checkpoint files with timestamps
$ ls -la /path/to/checkpoint/directory/
# Check when checkpoint was last modified
$ stat /path/to/checkpoint/directory/queue-*_download_checkpoint.json
```
1. Vérifiez le fichier journal :
```
$ ls -la /path/to/log/deadline_sync.log
```
------
#### [ macOS ]
Affichage des journaux d'exécution de l'agent de lancement :
1. Vérifiez si l'agent de lancement est en cours d'exécution :
```
$ sudo launchctl list | grep deadlinesync
```
La sortie indique : `PID Status Label` (le PID sera indiqué `-` lorsqu'il n'est pas en cours d'exécution, ce qui est normal pour les tâches par intervalles)
1. Afficher le statut détaillé de l'agent de lancement :
```
$ sudo launchctl print system/com.user.deadlinesync
```
Cela montre l'historique des exécutions, le dernier code de sortie, le nombre d'exécutions et l'état actuel.
1. Afficher les journaux d'exécution de l'agent de lancement :
```
# View recent logs (last hour)
log show --predicate 'subsystem contains "com.user.deadlinesync"' --last 1h
# View logs from a specific time period
log show --predicate 'subsystem contains "com.user.deadlinesync"' --start '2024-08-27 09:00:00'
```
1. Forcez l'exécution de l'agent de lancement pour un test immédiat :
```
$ sudo launchctl kickstart gui/$(id -u)/com.user.deadlinesync
```
Cela déclenche immédiatement la tâche quel que soit le calendrier, ce qui est utile pour les tests.
1. Vérifiez les mises à jour des fichiers de point de contrôle :
```
# List checkpoint files with timestamps
$ ls -la /path/to/checkpoint/directory/
```
1. Vérifiez le fichier journal :
```
$ ls -la /path/to/log/deadline_sync.log
```
------
#### [ Windows ]
1. Vérifiez si le service Task Scheduler est en cours d'exécution :
```
C:\> sc query "Schedule"
```
Si le service n'existe pas, essayez d'autres noms :
```
C:\> sc query "TaskScheduler"
C:\> sc query "Task Scheduler"
```
1. Consultez vos tâches planifiées :
```
C:> schtasks /query /tn "DeadlineOutputSync"
```
1. Consultez le fichier journal de votre tâche :
```
# View the log file created by your batch script
C:> notepad C:\path\to\logs\deadline_sync.log
```
1. Vérifiez les mises à jour des fichiers de point de contrôle :
```
# List checkpoint files with timestamps
C:> dir "C:\path\to\checkpoint\directory" /od
```
------