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. # Téléchargements automatiques L'interface de ligne de commande Deadline fournit une commande permettant de télécharger le résultat de toutes les tâches d'une file d'attente qui se sont 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 ](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/storage-profile.html) aux tâches afin de configurer tous les chemins d'accès aux données des actifs pour le chargement et le téléchargement. 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ésumant les fichiers qu'elle n'a pas 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 qui ne font pas partie des profils de stockage afin de garantir une configuration correcte. ## Configuration AWS informations d’identification Les téléchargements automatiques utilisent l'interface de ligne de commande 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. Les identifiants du moniteur Deadline Cloud 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 pourriez 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 pour la gestion des clés AWS d'accès dans la Référence *AWS générale*. ](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 Console de gestion AWS**, puis choisissez ** Suivant**. 1. Choisissez ** Joindre directement des 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. Donnez un nom à la politique **DeadlineCloudOutputDownloadPolicy** et choisissez ** Créer une politique**. 1. Retournez à la page de création d'un utilisateur, actualisez la liste des politiques, sélectionnez celle ** DeadlineCloudOutputDownloadPolicy ** que vous venez de créer, puis choisissez ** Suivant**. 1. Vérifiez les informations relatives à 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 touche pour Autre, puis choisissez ** Suivant**, puis choisissez ** 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. **Stockez les clés d'accès utilisateur** + Enregistrez les clés d'accès utilisateur dans le fichier AWS d'informations d'identification de votre système : + OuiLinux, le fichier se trouve dans `~/.aws/credentials` + OuiWindows, 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'avez plus besoin de cet utilisateur IAM, nous vous recommandons de le supprimer pour respecter les meilleures pratiques [AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#lock-away-credentials) de sécurité. 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 un téléchargement automatique. 1. Si ce n'est pas déjà fait, installez [ Python](https://www.python.org/). 1. Installez l'interface de ligne de commande Deadline en exécutant : ``` python -m pip install deadline ``` 1. Vérifiez que la version de l'interface de ligne de commande 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 vers 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 la même que celle de soumission. Remplacer `--storage-profile-id YOUR_PROFILE_ID \` ci-dessus par`--ignore-storage-profiles`. 1. Soumettez une tâche de test. 1. Téléchargez le fichier .zip depuis GitHub. 1. Ouvrez le référentiel [ deadline-cloud-samples GitHub . ](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 n'avez pas configuré 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 la tâche soit terminée 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 points de contrôle est créé dans le répertoire de points de contrôle que vous avez indiqué. ## 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 la date limite d'installation de l'interface ** Obtenez le chemin exact vers l'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 jobs existants : ``` $ crontab -l ``` 1. **Modifier Crontab ** Ouvrez votre fichier crontab pour le modifier : ``` $ crontab -e ``` La première fois que vous exécutez la commande, vous pouvez être invité à choisir un éditeur (nano, vim, etc.). 1. **Ajouter Cron Job Entry ** Ajoutez la ligne suivante pour exécuter la tâche 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 ``` Votre nouveau poste devrait être 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 ne fonctionne pas, démarrez-le : ``` $ sudo systemctl start cron $ sudo systemctl enable cron # Enable auto-start on boot ``` ------ #### [ macOS ] 1. **Vérifier la date limite d'installation de l'interface ** Obtenez le chemin exact vers l'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 du journal sur 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 de 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 d'envoi. 1. **Valider le fichier Plist ** Validez la syntaxe XML de votre fichier plist : ``` $ plutil -lint ~/Library/LaunchAgents/com.user.deadlinesync.plist ``` La commande renvoie « 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 bootstrap ** 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'aucun utilisateur ne soit connecté à chaque fois que la machine est en marche, 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 la commande suivante : ``` $ 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 l'état : ``` $ 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 [Windows documentation officielle](https://learn.microsoft.com/en-us/windows/win32/taskschd/using-the-task-scheduler). Pour toutes les étapes ci-dessous, utilisez l'invite de commande - exécutez en tant qu'administrateur : 1. **Vérifier la date limite d'installation de l'interface ** Trouvez l'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 batch de test ** 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érifiez le service de planification des tâches ** Assurez-vous que 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" ``` S'il ne fonctionne pas, 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 d'une tâche ** 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 de planification, qui dans ce cas est de 5 minutes. 1. Vérifiez que les nouvelles sorties sont téléchargées automatiquement. Si les sorties ne sont pas téléchargées, 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 similaire `[Errno 2] No such file or directory` ou présente `[Errno 13] Permission denied` 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 d'envoi. + Pour les téléchargements effectués sur le même ordinateur, essayez le `--ignore-storage-profiles` drapeau. ### Autorisations du répertoire + Assurez-vous que l'utilisateur du service de planification dispose des éléments suivants : + Read/write accès au répertoire des points 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 du 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 points 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. Consultez 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 `-` lorsqu'il n'est pas en cours d'exécution, ce qui est normal pour les tâches à intervalles) 1. Afficher le statut détaillé de l'agent de lancement : ``` $ sudo launchctl print system/com.user.deadlinesync ``` Cela affiche 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. Exécutez de force l'agent de lancement pour un test immédiat : ``` $ sudo launchctl kickstart gui/$(id -u)/com.user.deadlinesync ``` Cela déclenche immédiatement le travail quel que soit le calendrier, ce qui est utile pour les tests. 1. Vérifiez les mises à jour des fichiers de points de contrôle : ``` # List checkpoint files with timestamps $ ls -la /path/to/checkpoint/directory/ ``` 1. Consultez 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 points de contrôle : ``` # List checkpoint files with timestamps C:> dir "C:\path\to\checkpoint\directory" /od ``` ------