Configura le credenziali Prerequisiti Prova il comando di download dell'output Configura i download pianificati Risoluzione dei problemi

Download automatici

L'interfaccia a riga di comando di Deadline fornisce un comando per scaricare l'output di tutte le attività in una coda completate dall'ultima volta in cui è stato eseguito lo stesso comando. Puoi configurarlo come un cron job o un'attività pianificata da eseguire ripetutamente. Questa configurazione imposta il download automatico dell'output su base continua.

Prima di configurare i download automatici, segui i passaggi descritti in Profili di archiviazione per allegati di lavoro per configurare tutti i percorsi dei dati delle risorse per il caricamento e il download. Se un processo utilizza un percorso di output non presente nel relativo profilo di archiviazione, il download automatico ignora il download dell'output e stampa i messaggi di avviso per riepilogare i file non scaricati. Analogamente, se un lavoro viene inviato senza un profilo di archiviazione, il download automatico lo ignora e stampa un messaggio di avviso. Per impostazione predefinita, i mittenti di Deadline Cloud visualizzano messaggi di avviso per i percorsi esterni ai profili di archiviazione per contribuire a garantire la corretta configurazione.

Configurazione AWS credenziali

I download automatici utilizzano la CLI di Deadline per scaricare continuamente i risultati dei lavori. Per autenticare questi download, sono necessarie credenziali IAM a lungo termine. Le credenziali di monitoraggio di Deadline Cloud scadono, quindi non puoi utilizzarle per questo scopo.

Segui i passaggi seguenti per configurare le credenziali a lungo termine.

Importante

Presta attenzione ai seguenti avvertimenti:

NON utilizzare le credenziali root del tuo account per accedere AWS alle risorse. Queste credenziali forniscono un accesso illimitato all’account e sono difficili da revocare.
NON inserire chiavi di accesso letterali o informazioni sulle credenziali nei file dell’applicazione. In caso contrario, rischi di esporre accidentalmente le credenziali se, per esempio, carichi il progetto in repository pubblici.
NON includere file che contengono credenziali nell’area del progetto.
Proteggi le tue chiavi di accesso. Non fornire le chiavi di accesso a parti non autorizzate, neppure per contribuire a trovare gli identificatori di account. In questo modo, potresti concedere a qualcuno l'accesso permanente al tuo account.
Tieni presente che tutte le credenziali archiviate nel file delle AWS credenziali condivise sono archiviate in testo normale.

Per maggiori dettagli, vedi Best practice per la gestione delle chiavi di AWS accesso nella Guida AWS generale.

Creare un utente IAM

Aprire la console IAM all'indirizzo https://console.aws.amazon.com/iam/.
Nel riquadro di navigazione, seleziona Utenti, quindi seleziona Crea utente.
Assegna un nome all'utentedeadline-output-downloader. Deseleziona la casella di controllo Fornisci l'accesso utente a Console di gestione AWS, quindi scegli Avanti.
Scegli Allega direttamente le politiche.
Scegli Crea policy per creare una policy personalizzata con le autorizzazioni minime richieste.

Nell'editor JSON, specifica le seguenti autorizzazioni:

Assegna un nome alla policy DeadlineCloudOutputDownloadPolicy e scegli Crea policy.
Torna alla pagina di creazione dell'utente, aggiorna l'elenco dei criteri e seleziona quelli DeadlineCloudOutputDownloadPolicy appena creati, quindi scegli Avanti.
Rivedi i dettagli dell'utente e quindi scegli Crea utente.

Creare una chiave di accesso

Dalla pagina dei dettagli dell'utente, seleziona la scheda Credenziali di sicurezza. Nella sezione Chiavi di accesso, scegliere Crea chiave di accesso.
Indica che desideri utilizzare la chiave per Altro, quindi scegli Avanti, quindi scegli Crea chiave di accesso.
Nella pagina Recupera le chiavi di accesso, scegli Mostra per rivelare il valore della chiave di accesso segreta dell'utente. Puoi copiare le credenziali o scaricare un file .csv.

Memorizza le chiavi di accesso dell'utente

Archivia le chiavi di accesso degli utenti nel file AWS delle credenziali sul tuo sistema:
- SìLinux, il file si trova in ~/.aws/credentials
- SìWindows, il file si trova in %USERPROFILE\.aws\credentials
Sostituisci i seguenti tasti:
```
[deadline-downloader]
aws_access_key_id=ACCESS_KEY_ID
aws_secret_access_key=SECRET_ACCESS_KEY
region=YOUR_AWS_REGION
```

Importante

Quando non hai più bisogno di questo utente IAM, ti consigliamo di rimuoverlo per allinearti alle best practice AWS di sicurezza. Ti consigliamo di richiedere agli utenti umani di utilizzare credenziali temporanee Centro identità AWS IAM durante l'accesso. AWS

Prerequisiti

Completa i passaggi seguenti prima di creare un cron job o un'attività pianificata per il download automatico.

Se non l'hai già fatto, installa Python.
Installa la CLI di Deadline eseguendo:
```
python -m pip install deadline
```
Verifica che la versione di Deadline CLI sia 0.52.1 o successiva con il seguente comando.
```
$ deadline --version
deadline, version 0.52.1
```

Prova il comando di download dell'output

Per verificare che il comando funzioni nel tuo ambiente

Ottieni il percorso verso Deadline
Linux and macOS
```
$ which deadline
```
Windows
```
C:\> where deadline
```
PowerShell
```
PS C:\> Get-Command deadline
```

Esegui il comando sync-output su bootstrap.


  /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 \

È necessario eseguire questo passaggio solo se la macchina per il download è la stessa della macchina di invio. Sostituisci --storage-profile-id YOUR_PROFILE_ID \ quanto sopra con--ignore-storage-profiles.
Invia un lavoro di prova.
1. Scarica il file .zip da GitHub.
  1. Apri il repository deadline-cloud-samples GitHub .
  2. Scegli Codice e poi, dal menu a discesa, seleziona Scarica ZIP.
  3. Decomprimi l'archivio scaricato in una directory locale.
2. Esecuzione
```
 cd /path/to/unzipped/deadline-cloud-samples-mainline/job_bundles/job_attachments_devguide_output
```
3. Esecuzione
```
deadline bundle submit .
```
  1. Se non disponi della configurazione di scadenza predefinita, potresti dover fornire quanto segue nella riga di comando.
```
--farm-id YOUR-FARM-ID --queue-id YOUR-QUEUE-ID
```
4. Attendi il completamento del lavoro prima di passare alla fase successiva.

Esegui nuovamente il comando 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

Verificare quanto segue:
- Gli output del processo di test vengono visualizzati nella directory di destinazione.
- Un file di checkpoint viene creato nella directory dei checkpoint specificata.

Configura i download pianificati

Seleziona la scheda relativa al tuo sistema operativo per scoprire come configurare i download automatici ogni 5 minuti.

Linux

Verifica l'installazione della CLI di Deadline

Ottieni il percorso esatto del file eseguibile di Deadline:
```
$ which deadline
```
Annota questo percorso (ad esempio/opt/homebrew/bin/deadline) da utilizzare nel file plist.
Crea Checkpoint Directory

Crea la directory in cui verranno archiviati i file di checkpoint. Assicurati che l'utente abbia le autorizzazioni appropriate per eseguire il comando.
```
$ mkdir -p /path/to/checkpoint/directory
```
Crea una directory di registro

Crea una directory per i log dei cron job:
```
$ mkdir -p /path/to/logs
```
Prendi in considerazione l'impostazione della rotazione dei log nel file di registro utilizzando https://www.redhat.com/en/blog/setting-logrotate
Controlla il Crontab corrente

Visualizza il tuo crontab attuale per vedere i lavori esistenti:
```
$ crontab -l
```
Modifica Crontab

Apri il tuo file crontab per modificarlo:
```
$ crontab -e
```
La prima volta che esegui il comando, ti potrebbe essere richiesto di scegliere un editor (nano, vim e così via).

Aggiungi Cron Job Entry

Aggiungi la riga seguente per eseguire il lavoro ogni 5 minuti (sostituisci i percorsi con i valori effettivi dei passaggi 1 e 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

Verifica l'installazione di Cron Job

Dopo aver salvato e chiuso l'editor, verifica che il cron job sia stato aggiunto:
```
$ crontab -l
```
Dovresti vedere il tuo nuovo lavoro elencato.

Controlla lo stato del servizio Cron

Assicurati che il servizio cron sia in esecuzione:


# For systemd systems (most modern Linux distributions)
$ sudo systemctl status cron
# or
$ sudo systemctl status crond

# For older systems
$ sudo service cron status

Se non è in esecuzione, avvialo:


$ sudo systemctl start cron
$ sudo systemctl enable cron  # Enable auto-start on boot

macOS

Verifica l'installazione della CLI di Deadline

Ottieni il percorso esatto del file eseguibile di Deadline:
```
$ which deadline
```
Annota questo percorso (ad esempio/opt/homebrew/bin/deadline) da utilizzare nel file plist.
Crea Checkpoint Directory e Log Directory

Crea la directory in cui verranno archiviati i file dei checkpoint:
```
$ mkdir -p /path/to/checkpoint/directory
$ mkdir -p /path/to/logs
```
Prendi in considerazione l'impostazione della rotazione del registro nel file di registro utilizzando https://formulae.brew.sh/formula/logrotate

Create un file Plist

Crea un file di configurazione ~/Library/LaunchAgents/com.user.deadlinesync.plist con il seguente contenuto (sostituiscilo /path/to/deadline con il percorso effettivo del passaggio 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>--profile</string>
        <string>deadline-downloader</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>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>

Sostituisci --storage-profile-id YOUR_PROFILE_ID quanto sopra con --ignore-storage-profiles se la macchina per il download è la stessa della macchina di invio.

Convalida il file Plist

Convalida la sintassi XML del tuo file plist:
```
$ plutil -lint ~/Library/LaunchAgents/com.user.deadlinesync.plist
```
Il comando restituisce «OK» se il file è valido.

Verifica la presenza di Launch Agent o Launch Daemon esistenti

Controlla se un Launch Agent è già caricato:


$ launchctl list | grep deadlinesync
OR
$ sudo launchctl list | grep deadlinesync

Se ne esiste uno, scaricalo prima:


$ launchctl bootout gui/$(id -u)/com.user.deadlinesync
OR
$ sudo launchctl bootout system/com.user.deadlinesync

Crea e avvia il bootstrap

Per eseguire questa operazione mentre l'utente è connesso, eseguila come. LaunchAgent Per eseguire questa attività senza che un utente effettui l'accesso ogni volta che il computer è in esecuzione, eseguila come. LaunchDaemon
1. Per eseguire come: LaunchAgent
  1. Usa la configurazione creata in ~/Library/LaunchAgents/com.user.deadlinesync.plist
  2. Quindi carica la configurazione usando il comando bootstrap:
```
$ launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.user.deadlinesync.plist
```
2. Da eseguire come: LaunchDaemon
  1. Sposta il file Pilst e modifica le autorizzazioni eseguendo quanto segue:
```
$ 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. Carica l'agente di avvio utilizzando il comando bootstrap moderno:
```
$ sudo launchctl bootstrap system /Library/LaunchDaemons/com.user.deadlinesync.plist
```
Verifica lo stato

Se hai eseguito il bootstrap, LaunchAgent esegui quanto segue per confermare che è stato caricato:
```
$ launchctl list | grep deadlinesync
```
Se hai avviato un LaunchDaemon, conferma che sia stato caricato eseguendo:
```
$ sudo launchctl list | grep deadlinesync
```
L'output dovrebbe essere simile
```
SOME_PID_NUMBER 0 com.user.deadlinesync
```
Per informazioni dettagliate sullo stato:
```
$ launchctl print gui/$(id -u)/com.user.deadlinesync
```
Questo mostra lo stato corrente, gli argomenti del programma, le variabili di ambiente, l'intervallo di esecuzione e la cronologia delle esecuzioni.

Windows

Nota

L'operazione pianificata creata utilizzando queste istruzioni funziona solo quando l'utente è connesso.

Per configurarlo all'avvio del sistema senza richiedere il login dell'utente, consulta la Windows documentazione ufficiale.

Per tutti i passaggi seguenti, usa il prompt dei comandi: esegui come amministratore:

Verifica l'installazione della CLI di Deadline

Trova l'eseguibile della scadenza:
```
C:\> where deadline
```
Annota il percorso completo (ad esempioC:\Program Files\Amazon\DeadlineCloud\deadline.exe) da utilizzare nell'attività.
Crea Checkpoint Directory

Crea la directory in cui verranno archiviati i file dei checkpoint:
```
C:\> mkdir "path\to\checkpoint\directory"
```
Crea una directory di registro

Crea una directory per i log delle attività:
```
C:\> mkdir "path\to\logs"
```

Crea un wrapper di file batch

Crea il file batch con il seguente contenuto:


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

File batch di prova

Prova il file batch manualmente:
```
C:\> .\path\to\deadline_sync.bat
```
Verifica che il file di registro sia stato creato:
```
C:\> notepad path\to\logs\deadline_sync.log
```
Controlla il servizio Task Scheduler

Assicurati che il servizio Task Scheduler sia in esecuzione:
```
C:\> sc query "Schedule"
```
Se il servizio non esiste, prova con nomi alternativi:
```
C:\> sc query "TaskScheduler"
C:\> sc query "Task Scheduler"
```
Se non è in esecuzione, avvialo:
```
C:\> sc start "Schedule"
```
Crea attività pianificata

Crea l'attività da eseguire ogni 5 minuti.
```
C:\> schtasks /create /tn "DeadlineOutputSync" /tr "C:\path\to\deadline_sync.bat" /sc minute /mo 5
```
Suddivisione dei comandi:
- /tn- Nome dell'attività
- /tr- Attività da eseguire (il tuo file batch)
- /sc minute /mo 5- Pianificazione: ogni 5 minuti
Verifica la creazione dell'attività

Verifica che l'attività sia stata creata correttamente:
```
schtasks /query /tn "DeadlineOutputSync" /v /fo LIST
```
Cerca:
- Attività da eseguire: dovrebbe mostrare il percorso del file batch
- Ora di esecuzione successiva: dovrebbe mostrare un tempo entro 5 minuti
Esecuzione dell'attività di test

Esegui l'attività manualmente per verificare:
```
schtasks /run /tn "DeadlineOutputSync"
```
Controlla lo stato dell'attività:
```
schtasks /query /tn "DeadlineOutputSync"
```

Verifica la configurazione

Per verificare che la configurazione dei download automatici sia avvenuta correttamente, completa i seguenti passaggi.

Invia un nuovo lavoro di prova.
Attendi il completamento di un intervallo di pianificazione, che in questo caso è di 5 minuti.
Verifica che i nuovi output vengano scaricati automaticamente.

Se gli output non vengono scaricati, consulta la sezione Risoluzione dei problemi per i log del processo.

Risoluzione dei problemi relativi ai download automatici

Se riscontri problemi con i download automatici, verifica quanto segue:

Problemi relativi al profilo di archiviazione

Un errore simile [Errno 2] No such file or directory o presente [Errno 13] Permission denied nel file di registro potrebbe essere correlato a profili di archiviazione mancanti o non configurati correttamente.
Vedi Profili di archiviazione per informazioni su come impostare i profili di archiviazione quando il computer che esegue il download è diverso da quello di invio.
Per i download sullo stesso computer, prova il flag. --ignore-storage-profiles

Autorizzazioni relative alle directory

Assicurati che l'utente del servizio di pianificazione disponga di:
- Read/write accesso alla directory dei checkpoint
- Accesso in scrittura alla directory di destinazione dell'output
Per Linux emacOS, usa ls -la per controllare le autorizzazioni.
PerWindows, consulta le impostazioni di sicurezza nella cartella Proprietà.

Verifica dei registri dello Scheduler

Linux

Controlla se il servizio cron è in esecuzione:



# For systemd systems
$ sudo systemctl status cron
# or
$ sudo systemctl status crond

# Check if your user has cron job correctly configured
$ crontab -l

Visualizza i log di esecuzione di 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

Controlla i log specifici del tuo cron job:



# View the log file specified in your cron job
$ tail -100f /path/to/logs/deadline_sync.log

Cerca l'esecuzione di cron job nei log di sistema:



# 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

Controlla gli aggiornamenti dei file di checkpoint:



# 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

Controlla il file di registro:



$ ls -la /path/to/log/deadline_sync.log

macOS

Visualizzazione dei registri di esecuzione di Launch Agent:

Controlla se l'agente di avvio è in esecuzione:
```
$ sudo launchctl list | grep deadlinesync
       
```
L'output mostra: PID Status Label (il PID sarà visualizzato - quando non è attualmente in esecuzione, il che è normale per i lavori a intervalli)
Visualizza lo stato dettagliato dell'agente di avvio:
```
$ sudo launchctl print system/com.user.deadlinesync
       
```
Mostra la cronologia delle esecuzioni, l'ultimo codice di uscita, il numero di esecuzioni e lo stato corrente.

Visualizza i registri di esecuzione dell'agente di avvio:



# 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'

Forza l'esecuzione dell'agente di lancio per un test immediato:
```
$ sudo launchctl kickstart gui/$(id -u)/com.user.deadlinesync
       
```
Questo attiva immediatamente il processo indipendentemente dalla pianificazione, utile per i test.

Controlla gli aggiornamenti dei file di checkpoint:



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

Controlla il file di registro:



$ ls -la /path/to/log/deadline_sync.log

Windows

Controlla se il servizio Task Scheduler è in esecuzione:
```
C:\> sc query "Schedule"
```
Se il servizio non esiste, prova con nomi alternativi:
```
C:\> sc query "TaskScheduler"
C:\> sc query "Task Scheduler"
```

Visualizza le attività pianificate:



C:> schtasks /query /tn "DeadlineOutputSync"

Controlla il file di registro dell'attività:



# View the log file created by your batch script
C:> notepad C:\path\to\logs\deadline_sync.log

Controlla gli aggiornamenti dei file di checkpoint:



# List checkpoint files with timestamps
C:> dir "C:\path\to\checkpoint\directory" /od

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

File system virtuale

Tieni traccia della spesa e dell'utilizzo