Configurar credenciales de Requisitos previos Pruebe el comando de descarga de salida Configura descargas programadas Resolución de problemas

Descargas automáticas

La CLI de Deadline proporciona un comando para descargar el resultado de todas las tareas de una cola que se hayan completado desde la última vez que se ejecutó el mismo comando. Puede configurarlo como un trabajo cron o una tarea programada para que se ejecute repetidamente. Esta configuración configura la descarga automática de los resultados de forma continua.

Antes de configurar las descargas automáticas, siga los pasos que se indican en los perfiles de almacenamiento de los archivos adjuntos a los trabajos para configurar todas las rutas de los datos de los activos para su carga y descarga. Si un trabajo utiliza una ruta de salida que no está en su perfil de almacenamiento, la descarga automática omite la descarga de esa salida e imprime mensajes de advertencia para resumir los archivos que no se descargó. Del mismo modo, si un trabajo se envía sin un perfil de almacenamiento, la descarga automática omite ese trabajo e imprime un mensaje de advertencia. De forma predeterminada, los remitentes de Deadline Cloud muestran mensajes de advertencia en las rutas que se encuentran fuera de los perfiles de almacenamiento para garantizar una configuración correcta.

Configurar las credenciales AWS

Las descargas automáticas utilizan la CLI de Deadline para descargar continuamente los resultados de los trabajos. Para autenticar estas descargas, necesita credenciales de IAM de larga duración. Las credenciales del monitor de Deadline Cloud caducan, por lo que no puede utilizarlas para este fin.

Sigue los pasos que se indican a continuación para configurar las credenciales a largo plazo.

importante

Preste atención a las siguientes advertencias:

NO utilices las credenciales raíz de tu cuenta para acceder a AWS los recursos. Estas credenciales proporcionan acceso ilimitado a la cuenta y son difíciles de revocar.
NO incluya claves de acceso literales ni información sobre credenciales en sus archivos de aplicación. Si lo hace, puede crear un riesgo de exposición accidental de sus credenciales si, por ejemplo, carga el proyecto en un repositorio público.
NO incluya archivos que contengan credenciales en el área del proyecto.
Proteja sus claves de acceso. No proporcione sus claves de acceso a terceros no autorizados, ni siquiera para que le ayuden a buscar sus identificadores de cuenta. De este modo, podrías dar a alguien acceso permanente a tu cuenta.
Ten en cuenta que todas las credenciales almacenadas en el archivo de AWS credenciales compartidas se guardan en texto plano.

Para obtener más información, consulte las prácticas recomendadas para administrar las claves de AWS acceso en la Referencia AWS general.

Creación de un usuario de IAM

Abra la consola de IAM en https://console.aws.amazon.com/iam/.
En el panel de navegación, seleccione Usuarios y, a continuación, seleccione Crear usuario.
Asigne un nombre al usuariodeadline-output-downloader. Desactive la casilla de verificación Proporcionar acceso de usuario al y, a continuación Consola de administración de AWS, seleccione Siguiente.
Seleccione Asociar políticas directamente.
Seleccione Crear política para crear una política personalizada con los permisos mínimos necesarios.

En el editor JSON, especifique los siguientes permisos:

Asigne un nombre a la política DeadlineCloudOutputDownloadPolicy y elija Crear política.
Vuelva a la página de creación de usuarios, actualice la lista de políticas, seleccione la DeadlineCloudOutputDownloadPolicyque acaba de crear y, a continuación, elija Siguiente.
Revisa los detalles del usuario y, a continuación, selecciona Crear usuario.

Creación de una clave de acceso

En la página de detalles del usuario, selecciona la pestaña Credenciales de seguridad. En la sección Claves de acceso, haga clic en Crear clave de acceso.
Indique que desea utilizar la clave para Otros, seleccione Siguiente y, a continuación, seleccione Crear clave de acceso.
En la página Recuperar claves de acceso, selecciona Mostrar para ver el valor de la clave de acceso secreta de tu usuario. Puede copiar las credenciales o descargar un archivo .csv.

Guarde las claves de acceso del usuario

Guarde las claves de acceso de los usuarios en el archivo de AWS credenciales de su sistema:
- SíLinux, el archivo se encuentra en ~/.aws/credentials
- SíWindows, el archivo se encuentra en %USERPROFILE\.aws\credentials
Sustituya las siguientes teclas:
```
[deadline-downloader]
aws_access_key_id=ACCESS_KEY_ID
aws_secret_access_key=SECRET_ACCESS_KEY
region=YOUR_AWS_REGION
```

importante

Cuando ya no necesite este usuario de IAM, le recomendamos que lo quite para adaptarlo a las mejores prácticas AWS de seguridad. Le recomendamos que exija a sus usuarios humanos que utilicen credenciales temporales para AWS IAM Identity Centeracceder AWS.

Requisitos previos

Complete los siguientes pasos antes de crear un trabajo cron o una tarea programada para su descarga automática.

Si aún no lo has hecho, instala Python.
Instale la CLI de Deadline ejecutando:
```
python -m pip install deadline
```
Confirme que la versión de la CLI de Deadline sea 0.52.1 o posterior con el siguiente comando.
```
$ deadline --version
deadline, version 0.52.1
```

Pruebe el comando de descarga de salida

Para comprobar que el comando funciona en su entorno

Obtenga la ruta a Deadline

Ejecute el comando sync-output para arrancar.


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

Solo necesita realizar este paso si su máquina de descarga es la misma que la máquina de envío. Sustituya --storage-profile-id YOUR_PROFILE_ID \ lo anterior por--ignore-storage-profiles.
Envíe un trabajo de prueba.
1. Descargue el archivo.zip de GitHub.
  1. Abra el deadline-cloud-samples GitHub repositorio.
  2. Selecciona Código y, a continuación, en el menú desplegable, selecciona Descargar ZIP.
  3. Descomprime el archivo descargado en un directorio local.
2. Ejecutar
```
 cd /path/to/unzipped/deadline-cloud-samples-mainline/job_bundles/job_attachments_devguide_output
```
3. Ejecutar
```
deadline bundle submit .
```
  1. Si no tienes la configuración de fecha límite predeterminada, es posible que tengas que proporcionar lo siguiente en la línea de comandos.
```
--farm-id YOUR-FARM-ID --queue-id YOUR-QUEUE-ID
```
4. Espera a que se complete el trabajo antes de continuar con el siguiente paso.

Vuelva a ejecutar el 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

Compruebe lo siguiente:
- Los resultados del trabajo de prueba aparecen en el directorio de destino.
- Se crea un archivo de puntos de control en el directorio de puntos de control especificado.

Configura descargas programadas

Selecciona la pestaña de tu sistema operativo para aprender a configurar las descargas automáticas cada 5 minutos.

Linux

Verificar la instalación de Deadline CLI

Obtenga la ruta exacta a su ejecutable con fecha límite:
```
$ which deadline
```
Anote esta ruta (por ejemplo,/opt/homebrew/bin/deadline) para usarla en el archivo plist.
Cree un directorio de puntos de control

Cree el directorio donde se almacenarán los archivos de los puntos de control. Asegúrese de que el usuario tenga los permisos adecuados para ejecutar el comando.
```
$ mkdir -p /path/to/checkpoint/directory
```
Cree un directorio de registros

Cree un directorio para los registros de trabajos cron:
```
$ mkdir -p /path/to/logs
```
Considere configurar la rotación de registros en el archivo de registro mediante https://www.redhat.com/en/ blog/setting-logrotate
Compruebe el crontab actual

Consulta tu crontab actual para ver los trabajos existentes:
```
$ crontab -l
```
Edita Crontab

Abre tu archivo crontab para editarlo:
```
$ crontab -e
```
Si es la primera vez, es posible que se te pida que selecciones un editor (nano, vim, etc.).

Añadir entrada de trabajo de Cron

Añada la siguiente línea para ejecutar el trabajo cada 5 minutos (sustituya las rutas por los valores reales de los pasos 1 y 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

Verificar la instalación de Cron Job

Tras guardar y salir del editor, compruebe que se ha añadido el trabajo cron:
```
$ crontab -l
```
Deberías ver tu nuevo trabajo en la lista.

Compruebe el estado del servicio de Cron

Asegúrese de que el servicio cron esté funcionando:


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

# For older systems
$ sudo service cron status

Si no se está ejecutando, inícielo:


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

macOS

Verificar la instalación de Deadline CLI

Obtenga la ruta exacta a su ejecutable con fecha límite:
```
$ which deadline
```
Anote esta ruta (por ejemplo,/opt/homebrew/bin/deadline) para usarla en el archivo plist.
Cree un directorio de puntos de control y un directorio de registros

Cree el directorio donde se almacenarán los archivos de los puntos de control:
```
$ mkdir -p /path/to/checkpoint/directory
$ mkdir -p /path/to/logs
```
Considere configurar la rotación de registros en el archivo de registro mediante https://formulae.brew. sh/formula/logrotate

Crear un archivo Plist

Cree un archivo de configuración ~/Library/LaunchAgents/com.user.deadlinesync.plist con el siguiente contenido (/path/to/deadlinesustitúyalo por la ruta real del paso 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>

Reemplace --storage-profile-id YOUR_PROFILE_ID lo anterior por --ignore-storage-profiles si su máquina de descarga es la misma que la máquina de envío.

Valide el archivo Plist

Valide la sintaxis XML de su archivo plist:
```
$ plutil -lint ~/Library/LaunchAgents/com.user.deadlinesync.plist
```
Esto debería devolver «OK» si el archivo es válido.

Comprueba si hay agentes de lanzamiento o demonios de lanzamiento existentes

Comprueba si ya hay un agente de lanzamiento cargado:


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

Si existe uno, descárguelo primero:


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

Crea y arranca

Para ejecutar esta tarea mientras el usuario está conectado, ejecútela como LaunchAgent. Para ejecutar esta tarea sin que un usuario inicie sesión cada vez que se ejecute la máquina, ejecútela como LaunchDaemon.
1. Para ejecutarla como LaunchAgent:
  1. Utilice la configuración creada en ~/Library/LaunchAgents/com.user.deadlinesync.plist
  2. A continuación, cargue la configuración mediante el comando bootstrap:
```
$ launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.user.deadlinesync.plist
```
2. Para ejecutar como LaunchDaemon:
  1. Mueva el archivo Pilst y cambie los permisos ejecutando lo siguiente:
```
$ 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. Cargue el agente de lanzamiento con el comando bootstrap moderno:
```
$ sudo launchctl bootstrap system /Library/LaunchDaemons/com.user.deadlinesync.plist
```
Verifica el estado

Si ha iniciado una LaunchAgent ejecución, haga lo siguiente para confirmar que está cargada:
```
$ launchctl list | grep deadlinesync
```
Si has arrancado un LaunchDaemon, ejecuta para confirmar que está cargado:
```
$ sudo launchctl list | grep deadlinesync
```
El resultado debería tener el siguiente aspecto
```
SOME_PID_NUMBER 0 com.user.deadlinesync
```
Para obtener información de estado detallada:
```
$ launchctl print gui/$(id -u)/com.user.deadlinesync
```
Muestra el estado actual, los argumentos del programa, las variables de entorno, el intervalo de ejecución y el historial de ejecución.

Windows

nota

La tarea programada creada con estas instrucciones solo funciona cuando el usuario ha iniciado sesión.

Para configurarla al iniciar el sistema sin necesidad de iniciar sesión por parte del usuario, consulte la Windowsdocumentación oficial.

Para todos los pasos que se indican a continuación, utilice Command Prompt (ejecute como administrador):

Verificar la instalación de Deadline CLI

Busque el ejecutable de la fecha límite:
```
C:\> where deadline
```
Anote la ruta completa (por ejemplo,C:\Program Files\Amazon\DeadlineCloud\deadline.exe) para usarla en la tarea.
Cree un directorio de puntos de control

Cree el directorio donde se almacenarán los archivos de puntos de control:
```
C:\> mkdir "path\to\checkpoint\directory"
```
Cree un directorio de registros

Cree un directorio para los registros de tareas:
```
C:\> mkdir "path\to\logs"
```

Crear contenedor de archivos por lotes

Cree el archivo por lotes con el siguiente contenido:


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

Archivo Batch de prueba

Pruebe el archivo por lotes manualmente:
```
C:\> .\path\to\deadline_sync.bat
```
Compruebe que se ha creado el archivo de registro:
```
C:\> notepad path\to\logs\deadline_sync.log
```
Compruebe el servicio del programador de tareas

Asegúrese de que el servicio del programador de tareas esté funcionando:
```
C:\> sc query "Schedule"
```
Si el servicio no existe, prueba con nombres alternativos:
```
C:\> sc query "TaskScheduler"
C:\> sc query "Task Scheduler"
```
Si no se está ejecutando, inícielo:
```
C:\> sc start "Schedule"
```
Crear tarea programada

Cree la tarea para que se ejecute cada 5 minutos.
```
C:\> schtasks /create /tn "DeadlineOutputSync" /tr "C:\path\to\deadline_sync.bat" /sc minute /mo 5
```
Desglose de comandos:
- /tn- Nombre de la tarea
- /tr- Tarea a ejecutar (su archivo por lotes)
- /sc minute /mo 5- Horario: cada 5 minutos
Verificar la creación de tareas

Compruebe que la tarea se haya creado correctamente:
```
schtasks /query /tn "DeadlineOutputSync" /v /fo LIST
```
Busque:
- Tarea a ejecutar: debe mostrar la ruta del archivo por lotes
- Próxima hora de ejecución: debería mostrar una hora de 5 minutos
Pruebe la ejecución de la tarea

Ejecute la tarea manualmente para probar:
```
schtasks /run /tn "DeadlineOutputSync"
```
Compruebe el estado de la tarea:
```
schtasks /query /tn "DeadlineOutputSync"
```

Verifique la configuración

Para comprobar que la configuración de las descargas automáticas se ha configurado correctamente, siga estos pasos.

Envíe un nuevo trabajo de prueba.
Espere a que se complete un intervalo del programador, que en este caso es de 5 minutos.
Compruebe que las nuevas salidas se descarguen automáticamente.

Si los resultados no se descargan, consulte la sección de solución de problemas para ver los registros del proceso.

Solución de problemas de descargas automáticas

Si tienes problemas con las descargas automáticas, comprueba lo siguiente:

Problemas con el perfil de almacenamiento

Un error similar [Errno 2] No such file or directory o [Errno 13] Permission denied en el archivo de registro podría estar relacionado con perfiles de almacenamiento faltantes o mal configurados.
Consulte Perfiles de almacenamiento para obtener información sobre cómo configurar los perfiles de almacenamiento cuando la máquina de descarga es diferente de la máquina de envío.
Para descargas desde la misma máquina, prueba con la --ignore-storage-profiles bandera.

Permisos de directorio

Asegúrese de que el usuario del servicio de programación tenga:
- Acceso de lectura y escritura al directorio de puntos de control
- Acceso de escritura al directorio de destino de salida
Para Linux ymacOS, utilice ls -la para comprobar los permisos.
ParaWindows, revise la configuración de seguridad en la carpeta Propiedades.

Comprobando los registros del programador

Linux

Compruebe si el servicio cron se está ejecutando:



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

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

Ver los registros de ejecución de 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

Comprueba tus registros de trabajos cron específicos:



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

Busca la ejecución de tareas cron en los registros del 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

Compruebe las actualizaciones de los archivos de puntos de control:



# 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

Compruebe el archivo de registro:



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

macOS

Visualización de los registros de ejecución del agente de lanzamiento:

Compruebe si el agente de lanzamiento se está ejecutando:
```
$ sudo launchctl list | grep deadlinesync
       
```
El resultado muestra: PID Status Label (el PID será - cuando no se esté ejecutando actualmente, lo cual es normal en los trabajos a intervalos)
Vea el estado detallado del agente de lanzamiento:
```
$ sudo launchctl print system/com.user.deadlinesync
       
```
Muestra el historial de ejecuciones, el código de la última salida, el número de ejecuciones y el estado actual.

Vea los registros de ejecución del agente de lanzamiento:



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

Force la ejecución del agente de lanzamiento para probarlo inmediatamente:
```
$ sudo launchctl kickstart gui/$(id -u)/com.user.deadlinesync
       
```
Esto desencadena el trabajo de forma inmediata, independientemente de la programación, lo que resulta útil para las pruebas.

Compruebe las actualizaciones de los archivos de puntos de control:



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

Compruebe el archivo de registro:



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

Windows

Compruebe si el servicio del programador de tareas está en ejecución:
```
C:\> sc query "Schedule"
```
Si el servicio no existe, pruebe con nombres alternativos:
```
C:\> sc query "TaskScheduler"
C:\> sc query "Task Scheduler"
```

Consulta tus tareas programadas:



C:> schtasks /query /tn "DeadlineOutputSync"

Comprueba el archivo de registro de tu tarea:



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

Comprueba las actualizaciones de los archivos de puntos de control:



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

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Sistema de archivos virtual

Realice un seguimiento de los gastos y el uso