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 O Deadline CLI fornece um comando para baixar a saída de todas as tarefas em uma fila que foi concluída 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 um trabalho 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 ignora esse trabalho e imprime 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. ## Configurar AWS credenciais Os downloads automáticos usam a CLI do Deadline para baixar continuamente os resultados do trabalho. 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 compartilhadas são armazenadas em texto sem formatação. 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. Nomeie o usuário**deadline-output-downloader**. Desmarque a caixa de seleção ** Fornecer acesso do 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. Dê um nome à política **DeadlineCloudOutputDownloadPolicy** e escolha ** Criar política**. 1. Retorne à 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 seu 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 em seu sistema: + LinuxAtivado, o arquivo está localizado em `~/.aws/credentials` + WindowsAtivado, o arquivo está localizado em `%USERPROFILE\.aws\credentials` Substitua as seguintes chaves: ``` [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](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#lock-away-credentials) de segurança. 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 o Deadline CLI executando: ``` python -m pip install deadline ``` 1. Confirme se a versão do Deadline CLI é 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ó precisará executar 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. Faça o download do arquivo.zip do GitHub. 1. Abra o repositório [ deadline-cloud-samples GitHub . ](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 passar 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 pontos 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 prazo: ``` $ 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 log ** Crie um diretório para os 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 ** Visualize seu crontab atual para ver as vagas existentes: ``` $ crontab -l ``` 1. **Editar Crontab ** Abra seu arquivo crontab para edição: ``` $ crontab -e ``` Na primeira vez em que você executa o comando, talvez seja solicitado que você escolha um editor (nano, vim etc.). 1. **Adicionar entrada de 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. **Verificar 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 prazo: ``` $ 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 e 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 em `~/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 a mesma que a máquina de envio. 1. **Validar arquivo Plist ** Valide a sintaxe XML do seu arquivo plist: ``` $ plutil -lint ~/Library/LaunchAgents/com.user.deadlinesync.plist ``` O comando retornará “OK” se o arquivo for válido. 1. **Verifique se há agentes de lançamento ou daemons de lançamento existentes ** Verifique se um agente de lançamento já está carregado: ``` $ launchctl list | grep deadlinesync OR $ sudo launchctl list | grep deadlinesync ``` Se existir, 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 lançamento usando o comando bootstrap moderno: ``` $ sudo launchctl bootstrap system /Library/LaunchDaemons/com.user.deadlinesync.plist ``` 1. **Verificar status ** Se você inicializou uma, LaunchAgent execute o seguinte para confirmar que ela está 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 ter a seguinte aparência ``` 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 [Windows documentação oficial](https://learn.microsoft.com/en-us/windows/win32/taskschd/using-the-task-scheduler). 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 onde os arquivos do ponto de verificação serão armazenados: ``` C:\> mkdir "path\to\checkpoint\directory" ``` 1. **Criar diretório de log ** Crie um diretório para os 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 lote de teste ** 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`- Programação: 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: + **Tarefa a ser executada**: deve mostrar o caminho do arquivo em lote + **Próximo tempo de execução**: deve mostrar um horário em 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" ``` ------ **Verificar 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 com o 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: + Read/write acesso ao diretório de pontos 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 de 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 dos arquivos do 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. 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 operaçã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 dos arquivos do checkpoint: ``` # 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 dos arquivos do checkpoint: ``` # List checkpoint files with timestamps C:> dir "C:\path\to\checkpoint\directory" /od ``` ------