Configurar credenciales de Requisitos previos Pruebe el comando de descarga de salida Configure las 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 de tareas para configurar todas las rutas de carga y descarga de los datos de los activos. Si un trabajo usa 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 descargó. Del mismo modo, si se envía un trabajo 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 sobre las rutas que se encuentran fuera de los perfiles de almacenamiento para ayudar a garantizar una configuración correcta.

Configuración AWS credentials

Las descargas automáticas utilizan la CLI de Deadline para descargar de forma continua los resultados de los trabajos. Para autenticar estas descargas, necesita credenciales de IAM de larga duración. Las credenciales de Deadline Cloud Monitor caducan, por lo que no puede usarlas para este propósito.

Siga 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, puedes dar a alguien acceso permanente a tu cuenta.
Tenga en cuenta que las credenciales almacenadas en el archivo de AWS credenciales compartidas se almacenan en texto sin formato.

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 a los usuarios 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 requeridos.

En el editor JSON, especifica 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 DeadlineCloudOutputDownloadPolicy que acaba de crear y, a continuación, elija Siguiente.
Revise los detalles del usuario y, a continuación, elija 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.
Indica que quieres usar la clave para Otros y, a continuación, selecciona Siguiente y, a continuación, elige 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 de los usuarios

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 claves:
```
[deadline-downloader]
aws_access_key_id=ACCESS_KEY_ID
aws_secret_access_key=SECRET_ACCESS_KEY
region=YOUR_AWS_REGION
```

importante

Cuando ya no necesites este usuario de IAM, te recomendamos que lo elimines para adaptarlo a las prácticas recomendadas AWS de seguridad. Le recomendamos que exija a sus usuarios humanos que utilicen credenciales temporales AWS IAM Identity Center al acceder 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 es 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

Ejecuta 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ía un trabajo de prueba.
1. Descargue el archivo.zip desde GitHub.
  1. Abra el repositorio deadline-cloud-samples GitHub .
  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.

Configure las descargas programadas

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

Linux

Verifique la fecha límite de instalación de 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 el directorio Checkpoint

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 de cron:
```
$ mkdir -p /path/to/logs
```
Considere configurar la rotación del registro en el archivo de registro utilizando 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
```
La primera vez que ejecutes el comando, es posible que se te pida que elijas un editor (nano, vim, etc.).

Agregar 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

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

Verifique el estado del servicio de Cron

Asegúrese de que el servicio cron esté en ejecución:


# 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

Verifique la fecha límite de instalación de 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 el directorio de puntos de control y el 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 del registro en el archivo de registro utilizando https://formulae.brew.sh/formula/logrotate

Cree un archivo Plist

Crea un archivo de configuración en ~/Library/LaunchAgents/com.user.deadlinesync.plist con el siguiente contenido (/path/to/deadlinesustitúyelo por la ruta actual 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>

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

Validar el archivo Plist

Valide la sintaxis XML de su archivo plist:
```
$ plutil -lint ~/Library/LaunchAgents/com.user.deadlinesync.plist
```
El comando devuelve «Aceptar» si el archivo es válido.

Compruebe si existen agentes de lanzamiento o demonios de lanzamiento

Compruebe 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 ha iniciado sesión, ejecútela como LaunchAgent. Para ejecutar esta tarea sin que un usuario inicie sesión cada vez que la máquina esté en funcionamiento, 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 ejecutarlo 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
```
Verificar el estado

Si arrancaste, LaunchAgent ejecuta lo siguiente para confirmar que está cargado:
```
$ launchctl list | grep deadlinesync
```
Si has arrancado una LaunchDaemon, confirma que está cargada ejecutando:
```
$ sudo launchctl list | grep deadlinesync
```
La salida 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 que el usuario inicie sesión, consulte la Windows documentación oficial.

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

Verifique la fecha límite de instalación de 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 el directorio de puntos de control

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

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

Crear un 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 por lotes de prueba

Pruebe el archivo por lotes manualmente:
```
C:\> .\path\to\deadline_sync.bat
```
Compruebe que se creó el archivo de registro:
```
C:\> notepad path\to\logs\deadline_sync.log
```
Compruebe el servicio de programación de tareas

Asegúrese de que el servicio Programador de tareas esté en ejecución:
```
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 los comandos:
- /tn- Nombre de la tarea
- /tr- Tarea a ejecutar (su archivo por lotes)
- /sc minute /mo 5- Programación: cada 5 minutos
Verifique la creación de tareas

Compruebe que la tarea se creó correctamente:
```
schtasks /query /tn "DeadlineOutputSync" /v /fo LIST
```
Busque lo siguiente:
- Tarea a ejecutar: Debería mostrar la ruta del archivo por lotes
- Tiempo de próxima ejecución: debería mostrar una hora en 5 minutos
Ejecución de la tarea de prueba

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

Verificar la configuración

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

Envía 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 las salidas 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 al que [Errno 2] No such file or directory aparece [Errno 13] Permission denied en el archivo de registro puede estar relacionado con la falta de perfiles de almacenamiento o con una configuración incorrecta.
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 realizadas 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:
- Read/write acceso al directorio de puntos de control
- Acceso de escritura al directorio de destino de salida
Para Linux ymacOS, utilícelo 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

Revisa tus registros específicos de trabajos de cron:



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

Busca la ejecución de un trabajo de 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

Comprueba las actualizaciones de los archivos de 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

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 se mostrará - cuando no se esté ejecutando actualmente, lo cual es normal en los trabajos con intervalos)
Ver el estado detallado del agente de lanzamiento:
```
$ sudo launchctl print system/com.user.deadlinesync
       
```
Muestra el historial de ejecución, el último código de 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 realizar pruebas inmediatas:
```
$ sudo launchctl kickstart gui/$(id -u)/com.user.deadlinesync
       
```
Esto activa inmediatamente el trabajo independientemente de la programación, lo que resulta útil para las pruebas.

Compruebe las actualizaciones de los archivos de Checkpoint:



# 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, prueba con nombres alternativos:
```
C:\> sc query "TaskScheduler"
C:\> sc query "Task Scheduler"
```

Consulta tus tareas programadas:



C:> schtasks /query /tn "DeadlineOutputSync"

Revisa 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 Checkpoint:



# 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