Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # 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. Questa configurazione imposta il download automatico dell'output su base continua. Prima di configurare i download automatici, seguite i passaggi riportati in [Profili di archiviazione per allegati di lavoro per](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/storage-profile.html) 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 I download automatici utilizzano la CLI di Deadline per scaricare continuamente gli output dei lavori. Per autenticare questi download, sono necessarie credenziali IAM a lungo termine. Le credenziali di Deadline Cloud Monitor scadono, quindi non puoi utilizzarle per questo scopo. Segui i passaggi seguenti per configurare 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](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-identifiers.html). 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 vengono archiviate in testo semplice. Per maggiori dettagli, consulta [le migliori pratiche per la gestione delle chiavi di AWS accesso nella Guida *AWS generale*](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#securing_access-keys). **Creare un utente IAM** 1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Nel riquadro di navigazione, seleziona **Utenti**, quindi seleziona **Crea utente**. 1. Assegna un nome all'utente**deadline-output-downloader**. Deseleziona la casella di controllo **Fornisci l'accesso utente a Console di gestione AWS**, quindi scegli **Avanti**. 1. Scegli **Allega direttamente le politiche**. 1. Scegli **Crea politica** per creare una politica personalizzata con le autorizzazioni minime richieste. 1. Nell'editor JSON, specifica le seguenti autorizzazioni: ------ #### [ 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. Assegna un nome alla politica **DeadlineCloudOutputDownloadPolicy** e scegli **Crea** politica. 1. Torna alla pagina di creazione dell'utente, aggiorna l'elenco dei criteri e seleziona **DeadlineCloudOutputDownloadPolicy**quello appena creato, quindi scegli **Avanti**. 1. Controlla i dettagli dell'utente, quindi scegli **Crea utente**. **Creare una chiave di accesso** 1. Dalla pagina dei dettagli dell'utente, seleziona la scheda **Credenziali di sicurezza**. Nella sezione **Chiavi di accesso**, scegliere **Crea chiave di accesso**. 1. Indica che desideri utilizzare la chiave per Altro, quindi scegli **Avanti**, quindi scegli **Crea chiave di accesso**. 1. 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}} ``` **Importante** Quando non hai più bisogno di questo utente IAM, ti consigliamo di rimuoverlo per allinearlo alle [best practice AWS di sicurezza](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#lock-away-credentials). Ti consigliamo di richiedere agli utenti umani di utilizzare credenziali temporanee [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html)durante l'accesso. AWS ## Prerequisiti Completa i seguenti passaggi prima di creare un cron job o un'attività pianificata per il download automatico. 1. Se non l'hai già fatto, installa [Python](https://www.python.org/). 1. Installa la CLI di Deadline eseguendo: ``` python -m pip install deadline ``` 1. 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** 1. Scopri il percorso verso Deadline ------ #### [ Linux and macOS ] ``` $ which deadline ``` ------ #### [ Windows ] ``` C:\> where deadline ``` ------ #### [ PowerShell ] ``` PS C:\> Get-Command deadline ``` ------ 1. 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 \ ``` 1. È 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`. 1. Invia un lavoro di prova. 1. Scarica il file.zip da GitHub. 1. Apri il [deadline-cloud-samples GitHub repository](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline). 1. Scegli **Code** e quindi, dal menu a discesa, seleziona **Scarica** ZIP. 1. Decomprimi l'archivio scaricato in una directory locale. 1. Esecuzione ``` cd /path/to/unzipped/deadline-cloud-samples-mainline/job_bundles/job_attachments_devguide_output ``` 1. 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}} ``` 1. Attendi il completamento del lavoro prima di passare alla fase successiva. 1. Eseguite 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 ``` 1. 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 ] 1. **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. 1. **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 ``` 1. **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/ 1. **Controlla il Crontab corrente** Visualizza il tuo crontab attuale per vedere i lavori esistenti: ``` $ crontab -l ``` 1. **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.). 1. **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 * * * * /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. **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. 1. **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 ] 1. **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. 1. **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 1. **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): ``` 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 ``` Sostituisci `--storage-profile-id {{YOUR_PROFILE_ID}}` quanto sopra con `--ignore-storage-profiles` se il computer di download è lo stesso del computer di invio. 1. **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. 1. **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 ``` 1. **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` 1. Quindi carica la configurazione usando il comando bootstrap: ``` $ launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.user.deadlinesync.plist ``` 1. 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 ``` 1. Carica l'agente di avvio utilizzando il moderno comando bootstrap: ``` $ sudo launchctl bootstrap system /Library/LaunchDaemons/com.user.deadlinesync.plist ``` 1. **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](https://learn.microsoft.com/en-us/windows/win32/taskschd/using-the-task-scheduler) ufficiale. Per tutti i passaggi seguenti, usa il prompt dei comandi: esegui come amministratore: 1. **Verifica l'installazione della CLI di Deadline** Trova l'eseguibile della scadenza: ``` C:\> where deadline ``` Annota il percorso completo (ad esempio`C:\Program Files\Amazon\DeadlineCloud\deadline.exe`) da utilizzare nell'attività. 1. **Crea una cartella Checkpoint** Crea la directory in cui verranno archiviati i file di checkpoint: ``` C:\> mkdir "path\to\checkpoint\directory" ``` 1. **Crea una directory di registro** Crea una directory per i registri delle attività: ``` C:\> mkdir "path\to\logs" ``` 1. **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 ``` 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 ``` 1. **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" ``` 1. **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 1. **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 1. **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. 1. Invia un nuovo lavoro di prova. 1. Attendi il completamento di un intervallo di pianificazione, che in questo caso è di 5 minuti. 1. 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](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/storage-profile-job-attachments.html) 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 ] 1. 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 ``` 1. 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 ``` 1. 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 ``` 1. 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 ``` 1. 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 ``` 1. Controlla il file di registro: ``` $ ls -la /path/to/log/deadline_sync.log ``` ------ #### [ macOS ] Visualizzazione dei log di esecuzione di Launch Agent: 1. 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) 1. 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. 1. 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' ``` 1. Forza l'esecuzione dell'agente di avvio 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. 1. Controlla gli aggiornamenti dei file di checkpoint: ``` # List checkpoint files with timestamps $ ls -la /path/to/checkpoint/directory/ ``` 1. Controlla il file di registro: ``` $ ls -la /path/to/log/deadline_sync.log ``` ------ #### [ Windows ] 1. 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" ``` 1. Visualizza le attività pianificate: ``` C:> schtasks /query /tn "DeadlineOutputSync" ``` 1. 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 ``` 1. Controlla gli aggiornamenti dei file di checkpoint: ``` # List checkpoint files with timestamps C:> dir "C:\path\to\checkpoint\directory" /od ``` ------