As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Downloads automáticos A CLI do Deadline fornece um comando para baixar a saída de todas as tarefas em uma fila que foram concluídas desde a última vez em que o mesmo comando foi executado. Você pode configurar isso como um cron job ou uma tarefa agendada para ser executada repetidamente. Essa configuração configura o download automático da saída de forma contínua. Antes de configurar os downloads automáticos, siga as etapas em [Perfis de armazenamento para anexos de tarefas](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/storage-profile.html) para configurar todos os caminhos dos dados do ativo para upload e download. Se uma tarefa usa um caminho de saída que não está em seu perfil de armazenamento, o download automático ignora o download dessa saída e imprime mensagens de aviso para resumir os arquivos que não foram baixados. Da mesma forma, se um trabalho for enviado sem um perfil de armazenamento, o download automático ignorará esse trabalho e imprimirá uma mensagem de aviso. Por padrão, os remetentes do Deadline Cloud exibem mensagens de aviso para caminhos que estão fora dos perfis de armazenamento para ajudar a garantir a configuração correta. ## Configurando credenciais AWS Os downloads automáticos usam a CLI do Deadline para baixar continuamente os resultados das tarefas. Para autenticar esses downloads, você precisa de credenciais IAM de longo prazo. As credenciais do monitor Deadline Cloud expiram, então você não pode usá-las para essa finalidade. Siga as etapas abaixo para configurar credenciais de longo prazo. **Importante** Tenha atenção aos seguintes avisos: **NÃO** use as credenciais raiz da sua conta para acessar AWS recursos. Estas credenciais fornecem acesso ilimitado à conta e são difíceis de revogar. **NÃO** coloque chaves de acesso literais ou informações de credenciais em arquivos de aplicações. Se colocar, criará um risco de exposição acidental das credenciais se, por exemplo, fizer upload do projeto em um repositório público. **NÃO** inclua arquivos que contenham credenciais em sua área de projeto. Proteja suas chaves de acesso. Não as forneça a terceiros não autorizados, mesmo que seja para ajudar a [localizar os identificadores da sua conta](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-identifiers.html). Ao fazer isso, você pode dar a alguém acesso permanente à conta. Lembre-se de que todas as credenciais armazenadas no arquivo de AWS credenciais compartilhado são armazenadas em texto simples. Para obter mais detalhes, consulte [Práticas recomendadas para gerenciar chaves de AWS acesso na *Referência AWS geral*.](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#securing_access-keys) **Criar um usuário do IAM** 1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. No painel de navegação, selecione **Usuários** e escolha **Criar usuário**. 1. Dê um nome ao usuário**deadline-output-downloader**. Desmarque a caixa de seleção **Fornecer acesso ao usuário ao Console de gerenciamento da AWS** e escolha **Avançar**. 1. Selecione **Anexar políticas diretamente**. 1. Escolha **Criar política** para criar uma política personalizada com as permissões mínimas necessárias. 1. No editor JSON, especifique as seguintes permissões: ------ #### [ 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. Nomeie a política **DeadlineCloudOutputDownloadPolicy** e escolha **Criar política**. 1. Volte para a página de criação do usuário, atualize a lista de políticas, selecione a **DeadlineCloudOutputDownloadPolicy**que você acabou de criar e escolha **Avançar**. 1. Revise os detalhes do usuário e escolha **Criar usuário**. **Criar uma chave de acesso** 1. Na página de detalhes do usuário, selecione a guia **Credenciais de segurança**. Na seção **Chaves de acesso**, escolha **Criar chave de acesso**. 1. Indique que você deseja usar a chave para Outro, escolha **Avançar** e, em seguida, escolha **Criar chave de acesso**. 1. Na página **Recuperar chaves de acesso**, escolha **Mostrar** para revelar o valor da chave de acesso secreta do usuário. Você pode copiar as credenciais ou baixar um arquivo .csv. **Armazene as chaves de acesso do usuário** + Armazene as chaves de acesso do usuário no arquivo de AWS credenciais do seu sistema: + LinuxAtivado, o arquivo está localizado em `~/.aws/credentials` + WindowsAtivado, o arquivo está localizado em `%USERPROFILE\.aws\credentials` Substitua as seguintes teclas: ``` [deadline-downloader] aws_access_key_id=ACCESS_KEY_ID aws_secret_access_key=SECRET_ACCESS_KEY region=YOUR_AWS_REGION ``` **Importante** Quando você não precisar mais desse usuário do IAM, recomendamos que você o remova para se alinhar às [melhores práticas AWS de segurança](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#lock-away-credentials). Recomendamos que você exija que seus usuários humanos usem credenciais temporárias [Centro de Identidade do AWS IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html)durante o acesso AWS. ## Pré-requisitos Conclua as etapas a seguir antes de criar um cron job ou uma tarefa agendada para download automático. 1. Se você ainda não o fez, instale o [Python](https://www.python.org/). 1. Instale a CLI do Deadline executando: ``` python -m pip install deadline ``` 1. Confirme se a versão da CLI do Deadline é 0.52.1 ou mais recente com o comando a seguir. ``` $ deadline --version deadline, version 0.52.1 ``` ## Teste o comando de download de saída **Para verificar se o comando funciona em seu ambiente** 1. Conheça o caminho até o Deadline ------ #### [ Linux and macOS ] ``` $ which deadline ``` ------ #### [ Windows ] ``` C:\> where deadline ``` ------ #### [ PowerShell ] ``` PS C:\> Get-Command deadline ``` ------ 1. Execute o comando sync-output para inicializar. ``` /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. Você só precisa fazer essa etapa se sua máquina de download for a mesma que a máquina de envio. Substitua `--storage-profile-id YOUR_PROFILE_ID \` acima por`--ignore-storage-profiles`. 1. Envie um trabalho de teste. 1. Baixe o arquivo.zip em. GitHub 1. Abra o [deadline-cloud-samples GitHub repositório.](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline) 1. Escolha **Código** e, no menu suspenso, selecione **Baixar** ZIP. 1. Descompacte o arquivo baixado em um diretório local. 1. Executar ``` cd /path/to/unzipped/deadline-cloud-samples-mainline/job_bundles/job_attachments_devguide_output ``` 1. Executar ``` deadline bundle submit . ``` 1. Se você não tiver a configuração de prazo padrão, talvez seja necessário fornecer o seguinte na linha de comando. ``` --farm-id YOUR-FARM-ID --queue-id YOUR-QUEUE-ID ``` 1. Aguarde a conclusão do trabalho antes de ir para a próxima etapa. 1. Execute o comando sync-output novamente. ``` /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. Verifique o seguinte: + As saídas do seu trabalho de teste aparecem no diretório de destino. + Um arquivo de ponto de verificação é criado no diretório de ponto de verificação especificado. ## Configurar downloads agendados Selecione a guia do seu sistema operacional para saber como configurar downloads automáticos a cada 5 minutos. ------ #### [ Linux ] 1. **Verifique o prazo de instalação da CLI** Obtenha o caminho exato até seu executável de prazos: ``` $ which deadline ``` Observe esse caminho (por exemplo,`/opt/homebrew/bin/deadline`) para uso no arquivo plist. 1. **Criar diretório de pontos de verificação** Crie o diretório em que os arquivos do ponto de verificação serão armazenados. Garanta as permissões adequadas para que seu usuário execute o comando. ``` $ mkdir -p /path/to/checkpoint/directory ``` 1. **Criar diretório de registros** Crie um diretório para registros de tarefas do cron: ``` $ mkdir -p /path/to/logs ``` Considere configurar a rotação de log no arquivo de log usando https://www.redhat.com/en/ blog/setting-logrotate 1. **Verifique o Crontab atual** Veja seu crontab atual para ver os trabalhos existentes: ``` $ crontab -l ``` 1. **Editar Crontab** Abra seu arquivo crontab para edição: ``` $ crontab -e ``` Se for sua primeira vez, você pode ser solicitado a escolher um editor (nano, vim etc.). 1. **Adicionar entrada do Cron Job** Adicione a linha a seguir para executar o trabalho a cada 5 minutos (substitua os caminhos pelos valores reais das etapas 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. **Verifique a instalação do Cron Job** Depois de salvar e sair do editor, verifique se o cron job foi adicionado: ``` $ crontab -l ``` Você deve ver seu novo emprego listado. 1. **Verifique o status do serviço Cron** Verifique se o serviço cron está em execução: ``` # For systemd systems (most modern Linux distributions) $ sudo systemctl status cron # or $ sudo systemctl status crond # For older systems $ sudo service cron status ``` Se não estiver em execução, inicie-o: ``` $ sudo systemctl start cron $ sudo systemctl enable cron # Enable auto-start on boot ``` ------ #### [ macOS ] 1. **Verifique o prazo de instalação da CLI** Obtenha o caminho exato até seu executável de prazos: ``` $ which deadline ``` Observe esse caminho (por exemplo,`/opt/homebrew/bin/deadline`) para uso no arquivo plist. 1. **Crie um diretório de pontos de verificação e um diretório de registros** Crie o diretório em que os arquivos do ponto de verificação serão armazenados: ``` $ mkdir -p /path/to/checkpoint/directory $ mkdir -p /path/to/logs ``` Considere configurar a rotação de log no arquivo de log usando https://formulae.brew. sh/formula/logrotate 1. **Criar um arquivo Plist** Crie um arquivo de configuração `~/Library/LaunchAgents/com.user.deadlinesync.plist` com o seguinte conteúdo (`/path/to/deadline`substitua pelo caminho real da etapa 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 ``` Substitua `--storage-profile-id YOUR_PROFILE_ID` acima por `--ignore-storage-profiles` se sua máquina de download for igual à máquina de envio. 1. **Validar arquivo da lista** Valide a sintaxe XML do seu arquivo plist: ``` $ plutil -lint ~/Library/LaunchAgents/com.user.deadlinesync.plist ``` Isso deve retornar “OK” se o arquivo for válido. 1. **Verifique se há agentes de lançamento ou daemons de inicialização existentes** Verifique se um agente de lançamento já está carregado: ``` $ launchctl list | grep deadlinesync OR $ sudo launchctl list | grep deadlinesync ``` Se houver, descarregue-o primeiro: ``` $ launchctl bootout gui/$(id -u)/com.user.deadlinesync OR $ sudo launchctl bootout system/com.user.deadlinesync ``` 1. **Crie e inicialize** Para executar essa tarefa enquanto o usuário estiver conectado, execute-a como **LaunchAgent**. Para executar essa tarefa sem que um usuário esteja logado toda vez que a máquina estiver em execução, execute-a como um **LaunchDaemon**. 1. Para executar como **LaunchAgent:** 1. Use a configuração criada em `~/Library/LaunchAgents/com.user.deadlinesync.plist` 1. Em seguida, carregue a configuração usando o comando bootstrap: ``` $ launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.user.deadlinesync.plist ``` 1. Para executar como **LaunchDaemon**: 1. Mova o arquivo Pilst e altere as permissões executando o seguinte: ``` $ 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. Carregue o agente de inicialização usando o comando bootstrap moderno: ``` $ sudo launchctl bootstrap system /Library/LaunchDaemons/com.user.deadlinesync.plist ``` 1. **Verifique o status** Se você inicializou uma LaunchAgent execução, o seguinte para confirmar que ela foi carregada: ``` $ launchctl list | grep deadlinesync ``` Se você inicializou um LaunchDaemon, confirme se ele está carregado executando: ``` $ sudo launchctl list | grep deadlinesync ``` A saída deve ser semelhante a ``` SOME_PID_NUMBER 0 com.user.deadlinesync ``` Para obter informações detalhadas sobre o status: ``` $ launchctl print gui/$(id -u)/com.user.deadlinesync ``` Isso mostra o estado atual, os argumentos do programa, as variáveis de ambiente, o intervalo de execução e o histórico de execução. ------ #### [ Windows ] **nota** A tarefa agendada criada usando essas instruções só funciona quando o usuário está logado. Para configurá-lo na inicialização do sistema sem exigir o login do usuário, consulte a [Windowsdocumentação](https://learn.microsoft.com/en-us/windows/win32/taskschd/using-the-task-scheduler) oficial. Para todas as etapas abaixo, use o prompt de comando - execute como administrador: 1. **Verifique o prazo de instalação da CLI** Encontre o prazo executável: ``` C:\> where deadline ``` Observe o caminho completo (por exemplo,`C:\Program Files\Amazon\DeadlineCloud\deadline.exe`) para uso na tarefa. 1. **Criar diretório de pontos de verificação** Crie o diretório em que os arquivos do ponto de verificação serão armazenados: ``` C:\> mkdir "path\to\checkpoint\directory" ``` 1. **Criar diretório de registros** Crie um diretório para registros de tarefas: ``` C:\> mkdir "path\to\logs" ``` 1. **Criar invólucro de arquivos em lote** Crie o arquivo em lotes com o seguinte conteúdo: ``` 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. **Arquivo de teste em lote** Teste o arquivo em lotes manualmente: ``` C:\> .\path\to\deadline_sync.bat ``` Verifique se o arquivo de log foi criado: ``` C:\> notepad path\to\logs\deadline_sync.log ``` 1. **Verifique o serviço de agendador de tarefas** Verifique se o serviço Agendador de Tarefas está em execução: ``` C:\> sc query "Schedule" ``` Se o serviço não existir, tente nomes alternativos: ``` C:\> sc query "TaskScheduler" C:\> sc query "Task Scheduler" ``` Se não estiver em execução, inicie-o: ``` C:\> sc start "Schedule" ``` 1. **Criar tarefa agendada** Crie a tarefa para ser executada a cada 5 minutos. ``` C:\> schtasks /create /tn "DeadlineOutputSync" /tr "C:\path\to\deadline_sync.bat" /sc minute /mo 5 ``` Detalhamento do comando: + `/tn`- Nome da tarefa + `/tr`- Tarefa a ser executada (seu arquivo em lote) + `/sc minute /mo 5`- Horário: a cada 5 minutos 1. **Verificar a criação da tarefa** Verifique se a tarefa foi criada com sucesso: ``` schtasks /query /tn "DeadlineOutputSync" /v /fo LIST ``` Procure por: + **Tarefa a ser executada**: deve mostrar o caminho do arquivo em lote + **Próximo tempo de execução**: deve mostrar um tempo dentro de 5 minutos 1. **Execução da tarefa de teste** Execute a tarefa manualmente para testar: ``` schtasks /run /tn "DeadlineOutputSync" ``` Verifique o status da tarefa: ``` schtasks /query /tn "DeadlineOutputSync" ``` ------ **Verifique a configuração.** Para verificar se a configuração dos downloads automáticos foi bem-sucedida, conclua as etapas a seguir. 1. Envie um novo trabalho de teste. 1. Aguarde a conclusão de um intervalo do agendador, que nesse caso é de 5 minutos. 1. Verifique se as novas saídas são baixadas automaticamente. Se as saídas não forem baixadas, consulte a seção Solução de problemas para ver os registros do processo. ## Solução de problemas de downloads automáticos Se você encontrar problemas com os downloads automáticos, verifique o seguinte: ### Problemas de perfil de armazenamento + Um erro como `[Errno 2] No such file or directory` ou `[Errno 13] Permission denied` no arquivo de log pode estar relacionado a perfis de armazenamento ausentes ou mal configurados. + Consulte [Perfis de armazenamento](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/storage-profile-job-attachments.html) para obter informações sobre como configurar seus perfis de armazenamento quando a máquina de download é diferente da máquina de envio. + Para downloads na mesma máquina, experimente a `--ignore-storage-profiles` bandeira. ### Permissões de diretório + Certifique-se de que o usuário do serviço de agendador tenha: + Acesso de leitura/gravação ao diretório do ponto de verificação + Acesso de gravação ao diretório de destino de saída + Para Linux emacOS, use `ls -la` para verificar as permissões. + ParaWindows, revise as configurações de segurança na pasta Propriedades. ### Verificando os registros do agendador ------ #### [ Linux ] 1. Verifique se o serviço cron está em execução: ``` # For systemd systems $ sudo systemctl status cron # or $ sudo systemctl status crond # Check if your user has cron job correctly configured $ crontab -l ``` 1. Veja os registros de execução do 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. Verifique seus registros específicos do cron job: ``` # View the log file specified in your cron job $ tail -100f /path/to/logs/deadline_sync.log ``` 1. Pesquise a execução do cron job nos registros do 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. Verifique as atualizações do arquivo do ponto de verificação: ``` # 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. Verifique o arquivo de log: ``` $ ls -la /path/to/log/deadline_sync.log ``` ------ #### [ macOS ] Visualizando os registros de execução do Launch Agent: 1. Verifique se o agente de lançamento está em execução: ``` $ sudo launchctl list | grep deadlinesync ``` A saída mostra: `PID Status Label` (O PID será `-` quando não estiver em execução no momento, o que é normal para trabalhos com intervalos) 1. Veja o status detalhado do agente de lançamento: ``` $ sudo launchctl print system/com.user.deadlinesync ``` Isso mostra o histórico de execução, o último código de saída, o número de execuções e o estado atual. 1. Veja os registros de execução do agente de lançamento: ``` # 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. Force a execução do agente de lançamento para testes imediatos: ``` $ sudo launchctl kickstart gui/$(id -u)/com.user.deadlinesync ``` Isso aciona imediatamente o trabalho, independentemente do cronograma, útil para testes. 1. Verifique as atualizações do arquivo do ponto de verificação: ``` # List checkpoint files with timestamps $ ls -la /path/to/checkpoint/directory/ ``` 1. Verifique o arquivo de log: ``` $ ls -la /path/to/log/deadline_sync.log ``` ------ #### [ Windows ] 1. Verifique se o serviço Agendador de Tarefas está em execução: ``` C:\> sc query "Schedule" ``` Se o serviço não existir, tente nomes alternativos: ``` C:\> sc query "TaskScheduler" C:\> sc query "Task Scheduler" ``` 1. Veja suas tarefas agendadas: ``` C:> schtasks /query /tn "DeadlineOutputSync" ``` 1. Verifique o arquivo de log da sua tarefa: ``` # View the log file created by your batch script C:> notepad C:\path\to\logs\deadline_sync.log ``` 1. Verifique as atualizações do arquivo do ponto de verificação: ``` # List checkpoint files with timestamps C:> dir "C:\path\to\checkpoint\directory" /od ``` ------