Téléchargements automatiques - AWS Deadline Cloud
Configuration des informations d’identification PrérequisTestez la commande de téléchargement de sortieConfigurer des téléchargements planifiésRésolution des problèmes

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

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. Cela crée un 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 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

Si vous souhaitez exécuter la commande de synchronisation des sorties manuellement ou comprendre son fonctionnement avant de la configurer en tant que tâche cron, vous pouvez utiliser les informations d'identification obtenues lors de la connexion à l'application de bureau Deadline Cloud Monitor.

Informations d'identification locales AWS

Vos employés sur site utilisent des informations d'identification pour accéder à la sortie des pièces jointes aux tâches de Deadline Cloud. Pour un accès plus sécurisé, nous vous recommandons d'utiliser IAM Roles Anywhere pour authentifier vos employés. Pour plus d'informations, consultez IAM Roles Anywhere.

Pour les tests, vous pouvez utiliser les clés d'accès utilisateur IAM pour les AWS informations d'identification. Nous vous recommandons de définir une date d'expiration pour l'utilisateur IAM en incluant une politique intégrée restrictive.

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'insérez PAS de clés d'accès littérales ou d'informations d'identification dans vos fichiers de candidature. 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. En effet, vous lui accorderiez ainsi 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.

Créer un utilisateur IAM

  1. Ouvrez la console IAM à l'adresse https://console.aws.amazon.com/iam/.

  2. Dans le volet de navigation, sélectionnez Utilisateurs, puis Créer un utilisateur.

  3. Nommez l'utilisateurdeadline-output-downloader. Décochez la case Fournir un accès utilisateur au AWS Management Console, puis choisissez Suivant.

  4. Choisissez Joindre directement les politiques.

  5. Choisissez Créer une politique pour créer une politique personnalisée avec les autorisations minimales requises.

  6. Dans l'éditeur JSON, spécifiez les autorisations suivantes :

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

  7. Nommez la politique DeadlineCloudOutputDownloadPolicy et choisissez Create policy.

  8. Retournez à la page de création d'utilisateur, actualisez la liste des politiques, sélectionnez celle DeadlineCloudOutputDownloadPolicyque vous venez de créer, puis choisissez Next.

  9. Vérifiez les informations de l'utilisateur, puis choisissez Créer un utilisateur.

Restreindre l'accès des utilisateurs à une fenêtre de temps limitée

Toutes les clés d'accès utilisateur IAM que vous créez sont des informations d'identification à long terme. Pour garantir que ces informations d'identification expirent en cas de mauvaise gestion, vous pouvez les fixer dans le temps en créant une politique intégrée qui spécifie une date après laquelle les clés ne seront plus valides.

  1. Ouvrez l'utilisateur IAM que vous venez de créer. Dans l'onglet Autorisations, choisissez Ajouter des autorisations, puis choisissez Créer une politique intégrée.

  2. Dans l'éditeur JSON, spécifiez les autorisations suivantes. Pour utiliser cette politique, remplacez la valeur d'aws:CurrentTimehorodatage dans l'exemple de politique par votre propre heure et date.

    {
                            "Version": "2012-10-17",
                            "Statement": [
                              {
                                "Effect": "Deny",
                                "Action": "*",
                                "Resource": "*",
                                "Condition": {
                                  "DateGreaterThan": {
                                    "aws:CurrentTime": "2024-01-01T00:00:00Z"
                                  }
                                }
                              }
                            ]
                         }
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.

  2. Indiquez que vous souhaitez utiliser la clé pour Autre, puis cliquez sur Suivant, puis sur Créer une clé d'accès.

  3. 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

  1. 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

  2. Pour utiliser ces informations d'identification à tout moment, définissez les variables d'environnement AWS_PROFILE surdeadline-downloader.

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é. Nous vous recommandons de demander à vos utilisateurs humains d'utiliser des informations d'identification temporaires AWS IAM Identity Centerlors de l'accès AWS.

Prérequis

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.

  2. Installez la CLI Deadline en exécutant :

    python -m pip install deadline

  3. 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

  2. Exécutez la commande sync-output pour démarrer.

      /path/to/deadline queue sync-output \
  --farm-id YOUR_FARM_ID \
  --queue-id YOUR_QUEUE_ID \
  --storage-profile-id YOUR_PROFILE_ID \
  --checkpoint-dir /path/to/checkpoint/directory \

  3. 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.

  4. 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.

      2. Choisissez Code puis, dans le menu déroulant, sélectionnez Télécharger le fichier ZIP.

      3. Décompressez l'archive téléchargée dans un répertoire local.

    2. Exécuter

       cd /path/to/unzipped/deadline-cloud-samples-mainline/job_bundles/job_attachments_devguide_output

    3. 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

    4. Attendez que le travail soit terminé avant de passer à l'étape suivante.

  5. Exécutez à nouveau la commande sync-output.

     /path/to/deadline queue sync-output \
  --farm-id YOUR_FARM_ID \
  --queue-id YOUR_QUEUE_ID \
  --storage-profile-id YOUR_PROFILE_ID \
  --checkpoint-dir /path/to/checkpoint/directory

  6. 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.

  2. 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

  3. 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

  4. Vérifier le Crontab actuel

    Consultez votre crontab actuel pour voir les tâches existantes :

    $ crontab -l

  5. 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.).

  6. 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 * * * * AWS_PROFILE=deadline-downloader /path/to/deadline queue sync-output --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

  7. 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é.

  8. 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.

  2. 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

  3. 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) :

    <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.user.deadlinesync</string>
    <key>ProgramArguments</key>
    <array>
        <string>/path/to/deadline</string>
        <string>queue</string>
        <string>sync-output</string>
        <string>--farm-id</string>
        <string>YOUR_FARM_ID</string>
        <string>--queue-id</string>
        <string>YOUR_QUEUE_ID</string>
        <string>--storage-profile-id</string>
        <string>YOUR STORAGE PROFILE ID</string>
        <string>--checkpoint-dir</string>
        <string>/path/to/checkpoint/dir</string>
    </array>
    <key>EnvironmentVariables</key>
    <dict>
    <key>AWS_PROFILE</key>
    <string>deadline-downloader</string>
    </dict>
    <key>RunAtLoad</key>
    <true/>
    <key>UserName</key>
    <string>YOUR_USER_NAME</string>
    <key>StandardOutPath</key>
    <string>/path/to/logs/deadline_sync.log</string>
    <key>StartInterval</key>
    <integer>300</integer>
</dict>
</plist>

    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

  4. 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.

  5. Vérifiez la présence d'agents de lancement ou de 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

  6. 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

      2. Chargez ensuite la configuration à l'aide de la commande bootstrap :

        $ launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.user.deadlinesync.plist

    2. 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

      2. Chargez l'agent de lancement à l'aide de la commande bootstrap moderne :

        $ sudo launchctl bootstrap system /Library/LaunchDaemons/com.user.deadlinesync.plist

  7. 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 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.

  2. 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"

  3. Créer un répertoire de journaux

    Créez un répertoire pour les journaux des tâches :

    C:\> mkdir "path\to\logs"

  4. 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 --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

  5. 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

  6. 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"

  7. 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

  8. 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

  9. 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.

  2. Attendez la fin d'un intervalle du planificateur, qui dans ce cas est de 5 minutes.

  3. 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 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

  2. 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

  3. 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

  4. 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

  5. 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

  6. 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)

  2. 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.

  3. 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'

  4. 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.

  5. Vérifiez les mises à jour des fichiers de point de contrôle :

    
# List checkpoint files with timestamps
$ ls -la /path/to/checkpoint/directory/

  6. 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"

  2. Consultez vos tâches planifiées :

    
C:> schtasks /query /tn "DeadlineOutputSync"

  3. 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

  4. 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