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

Download automatici

La CLI di Deadline fornisce un comando per scaricare l'output di tutte le attività in una coda che sono state completate dall'ultima volta che lo stesso comando è stato eseguito. Puoi configurarlo come cron job o task pianificato da eseguire ripetutamente. Questo crea il download automatico dell'output su base continua.

Prima di configurare i download automatici, seguite i passaggi riportati in Storage profiles for job attachments per configurare tutti i percorsi dei dati delle risorse per il caricamento e il download. Se un processo utilizza un percorso di output che non è incluso nel relativo profilo di archiviazione, il download automatico salta il download dell'output e stampa messaggi di avviso per riepilogare i file non scaricati. Analogamente, se un lavoro viene inviato senza un profilo di archiviazione, il download automatico salta il lavoro e stampa un messaggio di avviso. Per impostazione predefinita, i mittenti di Deadline Cloud visualizzano messaggi di avviso per i percorsi che non rientrano nei profili di archiviazione per garantire una configurazione corretta.

Configurazione delle credenziali AWS

Se desideri eseguire manualmente il comando di sincronizzazione dell'output o capire come funziona prima di configurarlo come cron job, puoi utilizzare le credenziali dell'accesso all'applicazione desktop di monitoraggio Deadline Cloud.

Credenziali locali AWS

I tuoi dipendenti locali utilizzano le credenziali per accedere all'output degli allegati di lavoro di Deadline Cloud. Per un accesso più sicuro, ti consigliamo di utilizzare IAM Roles Anywhere per autenticare i tuoi lavoratori. Per ulteriori informazioni, consulta IAM Roles Anywhere.

Per i test, puoi utilizzare le chiavi di accesso utente IAM per le AWS credenziali. Ti consigliamo di impostare una scadenza per l'utente IAM includendo una policy in linea restrittiva.

Importante

Presta attenzione ai seguenti avvertimenti:

NON utilizzate le credenziali root del vostro account per accedere alle risorse. AWS Queste credenziali forniscono un accesso illimitato all'account e sono difficili da revocare.
NON inserite 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 includete 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. Se lo facessi, daresti a qualcuno accesso permanente al tuo account.
Tieni presente che tutte le credenziali archiviate nel file delle AWS credenziali condivise vengono archiviate in testo semplice.

Per maggiori dettagli, consulta le migliori pratiche per la gestione delle chiavi di AWS accesso nella Guida AWS generale.

Crea 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 AWS Management Console, quindi scegli Avanti.
Scegli Allega direttamente le politiche.
Scegli Crea politica per creare una politica personalizzata con le autorizzazioni minime richieste.

Nell'editor JSON, specifica le seguenti autorizzazioni:


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

Assegna un nome alla politica DeadlineCloudOutputDownloadPolicy e scegli Crea politica.
Torna alla pagina di creazione dell'utente, aggiorna l'elenco dei criteri e seleziona DeadlineCloudOutputDownloadPolicyquello appena creato, quindi scegli Avanti.
Controlla i dettagli dell'utente, quindi scegli Crea utente.

Limita l'accesso degli utenti a una finestra temporale limitata

Tutte le chiavi di accesso utente IAM che crei sono credenziali a lungo termine. Per garantire che queste credenziali scadano nel caso in cui vengano gestite in modo improprio, puoi limitarle nel tempo creando una policy in linea che specifichi una data dopo la quale le chiavi non saranno più valide.

Apri l'utente IAM che hai appena creato. Nella scheda Autorizzazioni, scegli Aggiungi autorizzazioni, quindi scegli Crea policy in linea.

Nell'editor JSON, specifica le seguenti autorizzazioni. Per utilizzare questa politica, sostituisci il valore del aws:CurrentTime timestamp nella politica di esempio con la tua ora e data.


{
                            "Version": "2012-10-17",
                            "Statement": [
                              {
                                "Effect": "Deny",
                                "Action": "*",
                                "Resource": "*",
                                "Condition": {
                                  "DateGreaterThan": {
                                    "aws:CurrentTime": "2024-01-01T00:00:00Z"
                                  }
                                }
                              }
                            ]
                         }

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

Memorizza le chiavi di accesso utente nel file AWS delle credenziali sul tuo sistema:
- SìLinux, il file si trova in ~/.aws/credentials
- WindowsAttivo, 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
```
Per utilizzare queste credenziali in qualsiasi momento, imposta le variabili AWS_PROFILE env su. deadline-downloader

Importante

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

Prerequisiti

Completa i seguenti passaggi 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
```
Conferma che la versione della CLI di Deadline 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

Scopri 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 \
  --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 il computer di download è lo stesso del computer 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 deadline-cloud-samples GitHub repository.
  2. Scegli Code e quindi, 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 predefinita della scadenza, 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 \
  --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 test job vengono visualizzati nella directory di destinazione.
- Un file di checkpoint viene creato nella directory di checkpoint specificata.

Imposta 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 con scadenza:
```
$ which deadline
```
Nota questo percorso (ad esempio/opt/homebrew/bin/deadline) per utilizzarlo nel file plist.
Crea una cartella Checkpoint

Crea la directory in cui verranno archiviati i file dei checkpoint. Garantisci all'utente le autorizzazioni appropriate per eseguire il comando.
```
$ mkdir -p /path/to/checkpoint/directory
```
Crea una directory di log

Crea una directory per i log di cron job:
```
$ mkdir -p /path/to/logs
```
Prendi in considerazione la possibilità di impostare la rotazione dei log sul file di registro usando blog/setting-logrotate https://www.redhat.com/en/
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
```
Se è la prima volta, potrebbe esserti richiesto di scegliere un editor (nano, vim, ecc.).

Aggiungi Cron Job Entry

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

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 nell'elenco.

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 con scadenza:
```
$ which deadline
```
Nota questo percorso (ad esempio/opt/homebrew/bin/deadline) per utilizzarlo nel file plist.
Crea Checkpoint Directory e Log Directory

Crea la directory in cui verranno archiviati i file di checkpoint:
```
$ mkdir -p /path/to/checkpoint/directory
$ mkdir -p /path/to/logs
```
Valuta la possibilità di impostare la rotazione del registro sul file di registro utilizzando https://formulae.brew. sh/formula/logrotate

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

Sostituisci --storage-profile-id YOUR_PROFILE_ID quanto sopra con --ignore-storage-profiles se il computer di download è lo stesso del computer di invio

Convalida il file Plist

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

Verifica la presenza di agenti di lancio o daemon di lancio esistenti

Controlla se un agente di lancio è 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

Per eseguire questa attività 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 comeLaunchAgent:
  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. Per 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 moderno comando bootstrap:
```
$ sudo launchctl bootstrap system /Library/LaunchDaemons/com.user.deadlinesync.plist
```
Verifica lo stato

Se hai avviato un' LaunchAgent esecuzione, esegui quanto segue per confermare che è stata caricata:
```
$ launchctl list | grep deadlinesync
```
Se hai avviato una LaunchDaemon, conferma che sia stata caricata eseguendo:
```
$ sudo launchctl list | grep deadlinesync
```
L'output dovrebbe avere il seguente aspetto
```
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 di esecuzione.

Windows

Nota

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

Per configurarla all'avvio del sistema senza richiedere l'accesso dell'utente, consulta la Windowsdocumentazione 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 una cartella Checkpoint

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

Crea una directory per i registri 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 --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 test

Esegui il test manuale del file batch:
```
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
- Durata di esecuzione successiva: dovrebbe mostrare un orario entro 5 minuti
Esecuzione dell'attività di test

Esegui l'attività manualmente per testare:
```
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.
Verificate che i nuovi output vengano scaricati automaticamente.

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

Risoluzione dei problemi di download automatici

Se riscontri problemi con i download automatici, controlla 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 configurati in modo errato.
Vedi Profili di archiviazione per informazioni su come configurare i profili di archiviazione quando il computer di download è diverso dal computer di invio.
Per i download dalla stessa macchina, prova il flag. --ignore-storage-profiles

Autorizzazioni per le directory

Assicurati che l'utente del servizio di pianificazione disponga di:
- Accesso in lettura/scrittura 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à.

Controllo 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 tuoi registri di cron job specifici:



# 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 log di esecuzione di Launch Agent:

Controlla se il Launch Agent è in esecuzione:
```
$ sudo launchctl list | grep deadlinesync
       
```
L'output mostra: PID Status Label (il PID sarà attivo - quando non è attualmente in esecuzione, il che è normale per i lavori a intervalli)
Visualizza lo stato dettagliato dell'agente di lancio:
```
$ sudo launchctl print system/com.user.deadlinesync
       
```
Questo mostra la cronologia delle esecuzioni, il codice dell'ultima 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
       
```
Ciò attiva immediatamente il lavoro 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 della tua 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