Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Cómo empezar con los recursos de Deadline Cloud
Para empezar a crear soluciones personalizadas para AWS Deadline Cloud, debe configurar sus recursos. Estos incluyen una granja, al menos una cola para la granja y al menos una flota de trabajadores para atender la cola. Puede crear sus recursos mediante la consola de Deadline Cloud o puede utilizar la. AWS Command Line Interface
En este tutorial, los utilizarás AWS CloudShell para crear una granja de desarrolladores sencilla y ejecutar el agente de trabajo. A continuación, podrá enviar y ejecutar un trabajo sencillo con parámetros y adjuntos, añadir una flota gestionada por el servicio y limpiar los recursos de su granja cuando haya terminado.
En las siguientes secciones, se presentan las diferentes funciones de Deadline Cloud y cómo funcionan y funcionan juntas. Seguir estos pasos resulta útil para desarrollar y probar nuevas cargas de trabajo y personalizaciones.
Para obtener instrucciones sobre cómo configurar su granja mediante la consola, consulte [Primeros pasos](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/getting-started.html) en la guía del *usuario de Deadline Cloud*.
**Topics**
+ [Cree una granja de Deadline Cloud](create-a-farm.md)
+ [Ejecute el agente de trabajo de Deadline Cloud](run-worker.md)
+ [Envía con Deadline Cloud](submit-a-job.md)
+ [Envíe trabajos con adjuntos de trabajo en Deadline Cloud](run-jobs-job-attachments.md)
+ [Agrega una flota gestionada por servicios a tu granja de desarrolladores en Deadline Cloud](service-managed-fleet.md)
+ [Limpia los recursos de tu granja en Deadline Cloud](cleaning-up.md)
# Cree una granja de Deadline Cloud
Para crear tu granja de desarrolladores y poner en cola los recursos en AWS Deadline Cloud, usa el AWS Command Line Interface (AWS CLI), como se muestra en el siguiente procedimiento. También crearás un rol AWS Identity and Access Management (IAM) y una flota gestionada por el cliente (CMF) y asociarás la flota a tu cola. A continuación, puede configurar la granja AWS CLI y confirmar que está configurada y funcionando según lo especificado.
Puedes usar esta granja para explorar las funciones de Deadline Cloud y, a continuación, desarrollar y probar nuevas cargas de trabajo, personalizaciones e integraciones de canalizaciones.
**Para crear una granja**
1. [Abre una AWS CloudShell sesión](https://console.aws.amazon.com/cloudshell/home?region=us-west-2). Utilizará la CloudShell ventana para introducir comandos AWS Command Line Interface (AWS CLI) para ejecutar los ejemplos de este tutorial. Mantén la CloudShell ventana abierta a medida que avanzas.
1. Cree un nombre para su granja y añada ese nombre a`~/.bashrc`. Esto hará que esté disponible para otras sesiones terminales.
```
echo "DEV_FARM_NAME=DeveloperFarm" >> ~/.bashrc
source ~/.bashrc
```
1. Cree el recurso de granja y añada su ID de granja a`~/.bashrc`.
```
aws deadline create-farm \
--display-name "$DEV_FARM_NAME"
echo "DEV_FARM_ID=\$(aws deadline list-farms \
--query \"farms[?displayName=='\$DEV_FARM_NAME'].farmId \
| [0]\" --output text)" >> ~/.bashrc
source ~/.bashrc
```
1. Cree el recurso de cola y añada su ID de cola a `~/.bashrc.`
```
aws deadline create-queue \
--farm-id $DEV_FARM_ID \
--display-name "$DEV_FARM_NAME Queue" \
--job-run-as-user '{"posix": {"user": "job-user", "group": "job-group"}, "runAs":"QUEUE_CONFIGURED_USER"}'
echo "DEV_QUEUE_ID=\$(aws deadline list-queues \
--farm-id \$DEV_FARM_ID \
--query \"queues[?displayName=='\$DEV_FARM_NAME Queue'].queueId \
| [0]\" --output text)" >> ~/.bashrc
source ~/.bashrc
```
1. Cree un rol de IAM para la flota. Esta función proporciona a los trabajadores anfitriones de su flota las credenciales de seguridad necesarias para ejecutar los trabajos desde su lista de espera.
```
aws iam create-role \
--role-name "${DEV_FARM_NAME}FleetRole" \
--assume-role-policy-document \
'{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.deadline.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
aws iam put-role-policy \
--role-name "${DEV_FARM_NAME}FleetRole" \
--policy-name WorkerPermissions \
--policy-document \
'{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"deadline:AssumeFleetRoleForWorker",
"deadline:UpdateWorker",
"deadline:DeleteWorker",
"deadline:UpdateWorkerSchedule",
"deadline:BatchGetJobEntity",
"deadline:AssumeQueueRoleForWorker"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:PrincipalAccount": "${aws:ResourceAccount}"
}
}
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream"
],
"Resource": "arn:aws:logs:*:*:*:/aws/deadline/*",
"Condition": {
"StringEquals": {
"aws:PrincipalAccount": "${aws:ResourceAccount}"
}
}
},
{
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:GetLogEvents"
],
"Resource": "arn:aws:logs:*:*:*:/aws/deadline/*",
"Condition": {
"StringEquals": {
"aws:PrincipalAccount": "${aws:ResourceAccount}"
}
}
}
]
}'
```
1. Cree la flota gestionada por el cliente (CMF) y añada su ID de flota a. `~/.bashrc`
```
FLEET_ROLE_ARN="arn:aws:iam::$(aws sts get-caller-identity \
--query "Account" --output text):role/${DEV_FARM_NAME}FleetRole"
aws deadline create-fleet \
--farm-id $DEV_FARM_ID \
--display-name "$DEV_FARM_NAME CMF" \
--role-arn $FLEET_ROLE_ARN \
--max-worker-count 5 \
--configuration \
'{
"customerManaged": {
"mode": "NO_SCALING",
"workerCapabilities": {
"vCpuCount": {"min": 1},
"memoryMiB": {"min": 512},
"osFamily": "linux",
"cpuArchitectureType": "x86_64"
}
}
}'
echo "DEV_CMF_ID=\$(aws deadline list-fleets \
--farm-id \$DEV_FARM_ID \
--query \"fleets[?displayName=='\$DEV_FARM_NAME CMF'].fleetId \
| [0]\" --output text)" >> ~/.bashrc
source ~/.bashrc
```
1. Asocia la CMF a tu cola.
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_CMF_ID
```
1. Instale la interfaz de línea de comandos de Deadline Cloud.
```
pip install deadline
```
1. Para establecer la granja predeterminada en el ID de granja y la cola en el ID de cola que creó anteriormente, utilice el siguiente comando.
```
deadline config set defaults.farm_id $DEV_FARM_ID
deadline config set defaults.queue_id $DEV_QUEUE_ID
```
1. (Opcional) Para confirmar que la granja está configurada de acuerdo con sus especificaciones, utilice los siguientes comandos:
+ Enumere todas las granjas: **deadline farm list**
+ Listar todas las colas de la granja predeterminada: **deadline queue list**
+ Enumere todas las flotas de la granja predeterminada: **deadline fleet list**
+ Obtenga la granja predeterminada: **deadline farm get**
+ Obtenga la cola predeterminada: **deadline queue get**
+ Obtenga todas las flotas asociadas a la cola predeterminada: **deadline fleet get**
## Pasos a seguir a continuación
Tras crear tu granja, puedes ejecutar el agente de trabajo de Deadline Cloud en los hosts de tu flota para procesar los trabajos. Consulte [Ejecute el agente de trabajo de Deadline Cloud](run-worker.md).
# Ejecute el agente de trabajo de Deadline Cloud
Para poder ejecutar los trabajos que envíes a la lista de espera de tu granja de desarrolladores, debes ejecutar el agente de trabajo de AWS Deadline Cloud en modo desarrollador en un host de trabajo.
Durante el resto de este tutorial, realizarás AWS CLI operaciones en tu granja de desarrolladores mediante dos AWS CloudShell pestañas. En la primera pestaña, puede enviar trabajos. En la segunda pestaña, puede ejecutar el agente de trabajo.
**nota**
Si deja la CloudShell sesión inactiva durante más de 20 minutos, se agotará el tiempo de espera y se detendrá al agente de trabajo. Para reiniciar el agente de trabajo, siga las instrucciones del siguiente procedimiento.
Antes de poder crear un agente de trabajo, debe configurar una granja, una cola y una flota de Deadline Cloud. Consulte [Cree una granja de Deadline Cloud](create-a-farm.md).
**Para ejecutar el agente de trabajo en modo desarrollador**
1. Con la granja aún abierta en la primera CloudShell pestaña, abre una segunda CloudShell pestaña y, a continuación, crea los `demoenv-persist` directorios `demoenv-logs` y.
```
mkdir ~/demoenv-logs
mkdir ~/demoenv-persist
```
1. Descarga e instala los paquetes de agentes de trabajo de Deadline Cloud desde PyPI:
**nota**
Activado Windows, es necesario que los archivos del agente estén instalados en el directorio global de paquetes de sitios de Python. Los entornos virtuales de Python no son compatibles actualmente.
```
python -m pip install deadline-cloud-worker-agent
```
1. Para permitir que el agente de trabajo cree los directorios temporales para las tareas en ejecución, cree un directorio:
```
sudo mkdir /sessions
sudo chmod 750 /sessions
sudo chown cloudshell-user /sessions
```
1. Ejecute el agente de trabajo de Deadline Cloud en modo desarrollador con `DEV_FARM_ID` las variables `DEV_CMF_ID` que haya agregado al`~/.bashrc`.
```
deadline-worker-agent \
--farm-id $DEV_FARM_ID \
--fleet-id $DEV_CMF_ID \
--run-jobs-as-agent-user \
--logs-dir ~/demoenv-logs \
--persistence-dir ~/demoenv-persist
```
A medida que el agente de trabajo inicializa y, a continuación, sondea la operación de la `UpdateWorkerSchedule` API, se muestra el siguiente resultado:
```
INFO Worker Agent starting
[2024-03-27 15:51:01,292][INFO ] 👋 Worker Agent starting
[2024-03-27 15:51:01,292][INFO ] AgentInfo
Python Interpreter: /usr/bin/python3
Python Version: 3.9.16 (main, Sep 8 2023, 00:00:00) - [GCC 11.4.1 20230605 (Red Hat 11.4.1-2)]
Platform: linux
...
[2024-03-27 15:51:02,528][INFO ] 📥 API.Resp 📥 [deadline:UpdateWorkerSchedule](200) params={'assignedSessions': {}, 'cancelSessionActions': {}, 'updateIntervalSeconds': 15} ...
[2024-03-27 15:51:17,635][INFO ] 📥 API.Resp 📥 [deadline:UpdateWorkerSchedule](200) params=(Duplicate removed, see previous response) ...
[2024-03-27 15:51:32,756][INFO ] 📥 API.Resp 📥 [deadline:UpdateWorkerSchedule](200) params=(Duplicate removed, see previous response) ...
...
```
1. Seleccione la primera CloudShell pestaña y, a continuación, enumere los trabajadores de la flota.
```
deadline worker list --fleet-id $DEV_CMF_ID
```
Se muestra un resultado como el siguiente:
```
Displaying 1 of 1 workers starting at 0
- workerId: worker-8c9af877c8734e89914047111f
status: STARTED
createdAt: 2023-12-13 20:43:06+00:00
```
En una configuración de producción, el agente de trabajo de Deadline Cloud requiere configurar varios usuarios y directorios de configuración como usuario administrativo en la máquina host. Puede anular esta configuración porque ejecuta los trabajos en su propia granja de desarrollo, a la que solo usted puede acceder.
## Pasos a seguir a continuación
Ahora que hay un agente de trabajadores en los hosts de sus trabajadores, puede enviar los trabajos a sus trabajadores. Puede hacer lo siguiente:
+ [Envía con Deadline Cloud](submit-a-job.md)utilizando un sencillo paquete de trabajos de OpenJD.
+ [Envíe trabajos con adjuntos de trabajo en Deadline Cloud](run-jobs-job-attachments.md)que comparten archivos entre estaciones de trabajo que utilizan diferentes sistemas operativos.
# Envía con Deadline Cloud
Para ejecutar trabajos de Deadline Cloud en los hosts de sus trabajadores, cree y utilice un paquete de trabajos de Open Job Description (OpenJD) para configurar un trabajo. El paquete configura el trabajo, por ejemplo, especificando los archivos de entrada para un trabajo y dónde escribir el resultado del trabajo. En este tema se incluyen ejemplos de formas de configurar un paquete de trabajos.
Para poder seguir los procedimientos de esta sección, debe completar lo siguiente:
+ [Cree una granja de Deadline Cloud](create-a-farm.md)
+ [Ejecute el agente de trabajo de Deadline Cloud](run-worker.md)
Para usar AWS Deadline Cloud para ejecutar trabajos, utilice los siguientes procedimientos. Usa la primera AWS CloudShell pestaña para enviar trabajos a tu granja de desarrolladores. Utilice la segunda CloudShell pestaña para ver el resultado del agente obrero.
**Topics**
+ [Envíe la simple\$1job muestra](#submit-a-simplejob-sample)
+ [Envíe un anuncio simple\$1job con un parámetro](#submit-with-parameter)
+ [Cree un paquete de trabajos simple\$1file\$1job con E/S de archivos](#create-job-bundle-with-file-io)
+ [Siguientes pasos](#submit-a-job-next)
## Envíe la simple\$1job muestra
Después de crear una granja y gestionar el agente obrero, puede enviar la simple\$1job muestra a Deadline Cloud.
**Para enviar la simple\$1job muestra a Deadline Cloud**
1. Elige tu primera CloudShell pestaña.
1. Descarga la muestra de GitHub.
```
cd ~
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Navegue hasta el directorio de ejemplos de paquetes de trabajos.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Envíe la simple\$1job muestra.
```
deadline bundle submit simple_job
```
1. Seleccione la segunda CloudShell pestaña para ver el resultado del registro sobre las llamadas`BatchGetJobEntities`, la obtención de una sesión y la ejecución de una acción de sesión.
```
...
[2024-03-27 16:00:21,846][INFO ] 🔷 Session.Starting 🔷 [session-053d77cef82648fe2] Starting new Session. [queue-3ba4ff683ff54db09b851a2ed8327d7b/job-d34cc98a6e234b6f82577940ab4f76c6]
[2024-03-27 16:00:21,853][INFO ] 📤 API.Req 📤 [deadline:BatchGetJobEntity] resource={'farm-id': 'farm-3e24cfc9bbcd423e9c1b6754bc1', 'fleet-id': 'fleet-246ee60f46d44559b6cce010d05', 'worker-id': 'worker-75e0fce9c3c344a69bff57fcd83'} params={'identifiers': [{'jobDetails': {'jobId': 'job-d34cc98a6e234b6f82577940ab4'}}]} request_url=https://scheduling.deadline.us-west-2.amazonaws.com/2023-10-12/farms/farm-3e24cfc9bbcd423e /fleets/fleet-246ee60f46d44559b1 /workers/worker- 75e0fce9c3c344a69b /batchGetJobEntity
[2024-03-27 16:00:22,013][INFO ] 📥 API.Resp 📥 [deadline:BatchGetJobEntity](200) params={'entities': [{'jobDetails': {'jobId': 'job-d34cc98a6e234b6f82577940ab6', 'jobRunAsUser': {'posix': {'user': 'job-user', 'group': 'job-group'}, 'runAs': 'QUEUE_CONFIGURED_USER'}, 'logGroupName': '/aws/deadline/farm-3e24cfc9bbcd423e9c1b6754bc1/queue-3ba4ff683ff54db09b851a2ed83', 'parameters': '*REDACTED*', 'schemaVersion': 'jobtemplate-2023-09'}}], 'errors': []} request_id=a3f55914-6470-439e-89e5-313f0c6
[2024-03-27 16:00:22,013][INFO ] 🔷 Session.Add 🔷 [session-053d77cef82648fea9c69827182] Appended new SessionActions. (ActionIds: ['sessionaction-053d77cef82648fea9c69827182-0']) [queue-3ba4ff683ff54db09b851a2ed8b/job-d34cc98a6e234b6f82577940ab6]
[2024-03-27 16:00:22,014][WARNING ] 🔷 Session.User 🔷 [session-053d77cef82648fea9c69827182] Running as the Worker Agent's user. (User: cloudshell-user) [queue-3ba4ff683ff54db09b851a2ed8b/job-d34cc98a6e234b6f82577940ac6]
[2024-03-27 16:00:22,015][WARNING ] 🔷 Session.AWSCreds 🔷 [session-053d77cef82648fea9c69827182] AWS Credentials are not available: Queue has no IAM Role. [queue-3ba4ff683ff54db09b851a2ed8b/job-d34cc98a6e234b6f82577940ab6]
[2024-03-27 16:00:22,026][INFO ] 🔷 Session.Logs 🔷 [session-053d77cef82648fea9c69827182] Logs streamed to: AWS CloudWatch Logs. (LogDestination: /aws/deadline/farm-3e24cfc9bbcd423e9c1b6754bc1/queue-3ba4ff683ff54db09b851a2ed83/session-053d77cef82648fea9c69827181) [queue-3ba4ff683ff54db09b851a2ed83/job-d34cc98a6e234b6f82577940ab4]
[2024-03-27 16:00:22,026][INFO ] 🔷 Session.Logs 🔷 [session-053d77cef82648fea9c69827182] Logs streamed to: local file. (LogDestination: /home/cloudshell-user/demoenv-logs/queue-3ba4ff683ff54db09b851a2ed8b/session-053d77cef82648fea9c69827182.log) [queue-3ba4ff683ff54db09b851a2ed83/job-d34cc98a6e234b6f82577940ab4]
...
```
**nota**
Solo se muestra el resultado del registro del agente de trabajo. Hay un registro independiente para la sesión en la que se ejecuta el trabajo.
1. Elija la primera pestaña y, a continuación, inspeccione los archivos de registro que escribe el agente de trabajo.
1. Navegue hasta el directorio de registros del agente de trabajo y vea su contenido.
```
cd ~/demoenv-logs
ls
```
1. Imprima el primer archivo de registro que cree el agente de trabajo.
```
cat worker-agent-bootstrap.log
```
Este archivo contiene información sobre cómo llamó a la API de Deadline Cloud para crear un recurso de trabajadores en su flota y, después, asumió la función de flota.
1. Imprima el resultado del archivo de registro cuando el agente obrero se una a la flota.
```
cat worker-agent.log
```
Este registro contiene resultados sobre todas las acciones que realiza el agente trabajador, pero no contiene resultados sobre las colas desde las que ejecuta los trabajos, excepto en lo que respecta a esos recursos. IDs
1. Imprima los archivos de registro de cada sesión en un directorio que tenga el mismo nombre que el identificador del recurso de la cola.
```
cat $DEV_QUEUE_ID/session-*.log
```
Si el trabajo se realiza correctamente, la salida del archivo de registro será similar a la siguiente:
```
cat $DEV_QUEUE_ID/$(ls -t $DEV_QUEUE_ID | head -1)
2024-03-27 16:00:22,026 WARNING Session running with no AWS Credentials.
2024-03-27 16:00:22,404 INFO
2024-03-27 16:00:22,405 INFO ==============================================
2024-03-27 16:00:22,405 INFO --------- Running Task
2024-03-27 16:00:22,405 INFO ==============================================
2024-03-27 16:00:22,406 INFO ----------------------------------------------
2024-03-27 16:00:22,406 INFO Phase: Setup
2024-03-27 16:00:22,406 INFO ----------------------------------------------
2024-03-27 16:00:22,406 INFO Writing embedded files for Task to disk.
2024-03-27 16:00:22,406 INFO Mapping: Task.File.runScript -> /sessions/session-053d77cef82648fea9c698271812a/embedded_fileswa_gj55_/tmp2u9yqtsz
2024-03-27 16:00:22,406 INFO Wrote: runScript -> /sessions/session-053d77cef82648fea9c698271812a/embedded_fileswa_gj55_/tmp2u9yqtsz
2024-03-27 16:00:22,407 INFO ----------------------------------------------
2024-03-27 16:00:22,407 INFO Phase: Running action
2024-03-27 16:00:22,407 INFO ----------------------------------------------
2024-03-27 16:00:22,407 INFO Running command /sessions/session-053d77cef82648fea9c698271812a/tmpzuzxpslm.sh
2024-03-27 16:00:22,414 INFO Command started as pid: 471
2024-03-27 16:00:22,415 INFO Output:
2024-03-27 16:00:22,420 INFO Welcome to AWS Deadline Cloud!
2024-03-27 16:00:22,571 INFO
2024-03-27 16:00:22,572 INFO ==============================================
2024-03-27 16:00:22,572 INFO --------- Session Cleanup
2024-03-27 16:00:22,572 INFO ==============================================
2024-03-27 16:00:22,572 INFO Deleting working directory: /sessions/session-053d77cef82648fea9c698271812a
```
1. Imprima la información sobre el trabajo.
```
deadline job get
```
Al enviar el trabajo, el sistema lo guarda como predeterminado para que no tenga que introducir el identificador del trabajo.
## Envíe un anuncio simple\$1job con un parámetro
Puede enviar trabajos con parámetros. En el siguiente procedimiento, edite la simple\$1job plantilla para incluir un mensaje personalizado, envíe el simple\$1job archivo de registro de la sesión e imprima el mismo para ver el mensaje.
**Para enviar el simple\$1job ejemplo con un parámetro**
1. Seleccione la primera CloudShell pestaña y, a continuación, navegue hasta el directorio de ejemplos de paquetes de trabajos.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Imprima el contenido de la simple\$1job plantilla.
```
cat simple_job/template.yaml
```
La `parameterDefinitions` sección con el `Message` parámetro debería tener el siguiente aspecto:
```
parameterDefinitions:
- name: Message
type: STRING
default: Welcome to AWS Deadline Cloud!
```
1. Envíe la simple\$1job muestra con un valor de parámetro y espere a que el trabajo termine de ejecutarse.
```
deadline bundle submit simple_job \
-p "Message=Greetings from the developer getting started guide."
```
1. Para ver el mensaje personalizado, consulte el archivo de registro de sesión más reciente.
```
cd ~/demoenv-logs
cat $DEV_QUEUE_ID/$(ls -t $DEV_QUEUE_ID | head -1)
```
## Cree un paquete de trabajos simple\$1file\$1job con E/S de archivos
Un trabajo de renderizado necesita leer la definición de la escena, renderizar una imagen a partir de ella y, a continuación, guardar esa imagen en un archivo de salida. Puede simular esta acción haciendo que el trabajo calcule el hash de la entrada en lugar de renderizar una imagen.
**Para crear un paquete de trabajos simple\$1file\$1job con E/S de archivos**
1. Seleccione la primera CloudShell pestaña y, a continuación, navegue hasta el directorio de ejemplos del paquete de trabajos.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Haga una copia de `simple_job` con el nuevo nombre`simple_file_job`.
```
cp -r simple_job simple_file_job
```
1. Edite la plantilla de trabajo de la siguiente manera:
**nota**
Le recomendamos que utilice nano estos pasos. Si prefiere usarloVim, debe configurar su modo de pegado usando`:set paste`.
1. Abre la plantilla en un editor de texto.
```
nano simple_file_job/template.yaml
```
1. Añada lo siguiente `type``objectType`, y `dataFlow``parameterDefinitions`.
```
- name: InFile
type: PATH
objectType: FILE
dataFlow: IN
- name: OutFile
type: PATH
objectType: FILE
dataFlow: OUT
```
1. Añada el siguiente comando de `bash` script al final del archivo para leer el archivo de entrada y escribir en el archivo de salida.
```
# hash the input file, and write that to the output
sha256sum "{{Param.InFile}}" > "{{Param.OutFile}}"
```
La actualización `template.yaml` debe coincidir exactamente con lo siguiente:
```
specificationVersion: 'jobtemplate-2023-09'
name: Simple File Job Bundle Example
parameterDefinitions:
- name: Message
type: STRING
default: Welcome to AWS Deadline Cloud!
- name: InFile
type: PATH
objectType: FILE
dataFlow: IN
- name: OutFile
type: PATH
objectType: FILE
dataFlow: OUT
steps:
- name: WelcomeToDeadlineCloud
script:
actions:
onRun:
command: '{{Task.File.Run}}'
embeddedFiles:
- name: Run
type: TEXT
runnable: true
data: |
#!/usr/bin/env bash
echo "{{Param.Message}}"
# hash the input file, and write that to the output
sha256sum "{{Param.InFile}}" > "{{Param.OutFile}}"
```
**nota**
Si desea ajustar el espaciado`template.yaml`, asegúrese de utilizar espacios en lugar de hendiduras.
1. Guarde el archivo y salga del editor de texto.
1. Proporcione los valores de los parámetros de los archivos de entrada y salida para enviar el simple\$1file\$1job.
```
deadline bundle submit simple_file_job \
-p "InFile=simple_job/template.yaml" \
-p "OutFile=hash.txt"
```
1. Imprima la información sobre el trabajo.
```
deadline job get
```
+ Verá un resultado como el siguiente:
```
parameters:
Message:
string: Welcome to AWS Deadline Cloud!
InFile:
path: /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/simple_job/template.yaml
OutFile:
path: /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/hash.txt
```
+ Aunque solo proporcionó rutas relativas, los parámetros tienen configurada la ruta completa. AWS CLI Une el directorio de trabajo actual a cualquier ruta que se proporcione como parámetro cuando las rutas tienen ese tipo`PATH`.
+ El agente de trabajo que se encuentra en la otra ventana de la terminal recoge y ejecuta el trabajo. Esta acción crea el `hash.txt` archivo, que puede ver con el siguiente comando.
```
cat hash.txt
```
Este comando imprimirá un resultado similar al siguiente.
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/simple_job/template.yaml
```
## Siguientes pasos
Después de aprender a enviar trabajos sencillos mediante la CLI de Deadline Cloud, puede explorar:
+ [Envíe trabajos con adjuntos de trabajo en Deadline Cloud](run-jobs-job-attachments.md)para obtener información sobre cómo ejecutar trabajos en hosts que ejecutan diferentes sistemas operativos.
+ [Agrega una flota gestionada por servicios a tu granja de desarrolladores en Deadline Cloud](service-managed-fleet.md)para ejecutar tus trabajos en hosts gestionados por Deadline Cloud.
+ [Limpia los recursos de tu granja en Deadline Cloud](cleaning-up.md)para cerrar los recursos que utilizaste para este tutorial.
# Envíe trabajos con adjuntos de trabajo en Deadline Cloud
Muchas granjas utilizan sistemas de archivos compartidos para compartir archivos entre los anfitriones que envían los trabajos y los que los ejecutan. Por ejemplo, en el `simple_file_job` ejemplo anterior, el sistema de archivos local se comparte entre las ventanas de AWS CloudShell terminal, que se encuentran en la pestaña uno, donde se envía el trabajo, y en la pestaña dos, donde se ejecuta el agente de trabajo.
Un sistema de archivos compartido es ventajoso cuando la estación de trabajo remitente y los hosts de trabajo se encuentran en la misma red de área local. Si almacena los datos de forma local, cerca de las estaciones de trabajo que acceden a ellos, si utiliza una granja de servidores basada en la nube, tendrá que compartir sus sistemas de archivos a través de una VPN de alta latencia o sincronizarlos en la nube. Ninguna de estas opciones es fácil de configurar ni utilizar.
AWS Deadline Cloud ofrece una solución sencilla con *archivos adjuntos de trabajo*, que son similares a los archivos adjuntos de correo electrónico. Con los archivos adjuntos de trabajo, puede adjuntar datos a su trabajo. A continuación, Deadline Cloud gestiona los detalles de la transferencia y el almacenamiento de los datos de su trabajo en los depósitos de Amazon Simple Storage Service (Amazon S3).
Los flujos de trabajo de creación de contenido suelen ser iterativos, lo que significa que un usuario envía los trabajos con un pequeño subconjunto de archivos modificados. Como los buckets de Amazon S3 almacenan los adjuntos de los trabajos en un almacenamiento direccionable por contenido, el nombre de cada objeto se basa en el hash de los datos del objeto y el contenido de un árbol de directorios se almacena en un formato de archivo de manifiesto adjunto a un trabajo.
Para poder seguir los procedimientos de esta sección, debe completar lo siguiente:
+ [Cree una granja de Deadline Cloud](create-a-farm.md)
+ [Ejecute el agente de trabajo de Deadline Cloud](run-worker.md)
Para ejecutar trabajos con trabajos adjuntos, complete los siguientes pasos.
**Topics**
+ [Añada una configuración de adjuntos de trabajos a su cola](#job-attachments-config)
+ [Enviar simple\$1file\$1job con adjuntos de trabajo](#submit-job-attachments)
+ [Entender cómo se almacenan los archivos adjuntos de trabajo en Amazon S3](#job-attachments-in-depth)
+ [Siguientes pasos](#run-jobs-job-attachments-next)
## Añada una configuración de adjuntos de trabajos a su cola
Para habilitar los adjuntos de trabajos en su cola, añada una configuración de adjuntos de trabajos al recurso de cola de su cuenta.
**Para añadir una configuración de adjuntos de trabajos a su cola**
1. Seleccione la primera CloudShell pestaña y, a continuación, introduzca uno de los siguientes comandos para usar un bucket de Amazon S3 para adjuntar trabajos.
+ Si no tiene un bucket privado de Amazon S3 existente, puede crear y usar un bucket S3 nuevo.
```
DEV_FARM_BUCKET=$(echo $DEV_FARM_NAME \
| tr '[:upper:]' '[:lower:]')-$(xxd -l 16 -p /dev/urandom)
if [ "$AWS_REGION" == "us-east-1" ]; then LOCATION_CONSTRAINT=
else LOCATION_CONSTRAINT="--create-bucket-configuration \
LocationConstraint=${AWS_REGION}"
fi
aws s3api create-bucket \
$LOCATION_CONSTRAINT \
--acl private \
--bucket ${DEV_FARM_BUCKET}
```
+ Si ya tienes un bucket privado de Amazon S3, puedes usarlo *`MY_BUCKET_NAME`* sustituyéndolo por el nombre de tu bucket.
```
DEV_FARM_BUCKET=MY_BUCKET_NAME
```
1. Después de crear o elegir su bucket de Amazon S3, añada el nombre del bucket `~/.bashrc` para que esté disponible para otras sesiones de terminal.
```
echo "DEV_FARM_BUCKET=$DEV_FARM_BUCKET" >> ~/.bashrc
source ~/.bashrc
```
1. Cree un rol AWS Identity and Access Management (de IAM) para la cola.
```
aws iam create-role --role-name "${DEV_FARM_NAME}QueueRole" \
--assume-role-policy-document \
'{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.deadline.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
aws iam put-role-policy \
--role-name "${DEV_FARM_NAME}QueueRole" \
--policy-name S3BucketsAccess \
--policy-document \
'{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject*",
"s3:GetBucket*",
"s3:List*",
"s3:DeleteObject*",
"s3:PutObject",
"s3:PutObjectLegalHold",
"s3:PutObjectRetention",
"s3:PutObjectTagging",
"s3:PutObjectVersionTagging",
"s3:Abort*"
],
"Resource": [
"arn:aws:s3:::'$DEV_FARM_BUCKET'",
"arn:aws:s3:::'$DEV_FARM_BUCKET'/*"
],
"Effect": "Allow"
}
]
}'
```
1. Actualice la cola para incluir la configuración de los adjuntos de trabajos y la función de IAM.
```
QUEUE_ROLE_ARN="arn:aws:iam::$(aws sts get-caller-identity \
--query "Account" --output text):role/${DEV_FARM_NAME}QueueRole"
aws deadline update-queue \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--role-arn $QUEUE_ROLE_ARN \
--job-attachment-settings \
'{
"s3BucketName": "'$DEV_FARM_BUCKET'",
"rootPrefix": "JobAttachments"
}'
```
1. Confirme que ha actualizado la cola.
```
deadline queue get
```
Se muestra un resultado como el siguiente:
```
...
jobAttachmentSettings:
s3BucketName: DEV_FARM_BUCKET
rootPrefix: JobAttachments
roleArn: arn:aws:iam::ACCOUNT_NUMBER:role/DeveloperFarmQueueRole
...
```
## Enviar simple\$1file\$1job con adjuntos de trabajo
Cuando utilizas adjuntos de trabajo, los paquetes de trabajos deben proporcionar a Deadline Cloud suficiente información para determinar el flujo de datos del trabajo, por ejemplo, mediante `PATH` parámetros. En el caso desimple\$1file\$1job, editaste el `template.yaml` archivo para indicar a Deadline Cloud que el flujo de datos está en el archivo de entrada y en el archivo de salida.
Una vez que hayas añadido la configuración de adjuntos de trabajos a tu lista, puedes enviar el ejemplo de simple\$1file\$1job con los adjuntos de trabajo. Una vez hecho esto, podrá ver el registro y el resultado de los trabajos para confirmar que el archivo con los trabajos adjuntos funciona. simple\$1file\$1job
**Para enviar el paquete de trabajos simple\$1file\$1job con los trabajos adjuntos**
1. Elija la primera CloudShell pestaña y, a continuación, abra el directorio. `JobBundle-Samples`
1.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Envía simple\$1file\$1job a la lista de espera. Cuando se te pida que confirmes la carga, ingresa. **y**
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. Para ver el resultado del registro de la sesión de transferencia de datos de los archivos adjuntos al trabajo, ejecute el siguiente comando.
```
JOB_ID=$(deadline config get defaults.job_id)
SESSION_ID=$(aws deadline list-sessions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--query "sessions[0].sessionId" \
--output text)
cat ~/demoenv-logs/$DEV_QUEUE_ID/$SESSION_ID.log
```
1. Enumere las acciones de la sesión que se ejecutaron dentro de la sesión.
```
aws deadline list-session-actions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--session-id $SESSION_ID
```
Se muestra un resultado como el siguiente:
```
{
"sessionactions": [
{
"sessionActionId": "sessionaction-123-0",
"status": "SUCCEEDED",
"startedAt": "",
"endedAt": "",
"progressPercent": 100.0,
"definition": {
"syncInputJobAttachments": {}
}
},
{
"sessionActionId": "sessionaction-123-1",
"status": "SUCCEEDED",
"startedAt": "",
"endedAt": "",
"progressPercent": 100.0,
"definition": {
"taskRun": {
"taskId": "task-abc-0",
"stepId": "step-def"
}
}
}
]
}
```
La primera acción de la sesión descargó los adjuntos del trabajo de entrada, mientras que la segunda acción ejecuta la tarea como en los pasos anteriores y, a continuación, carga los adjuntos del trabajo de salida.
1. Enumere el directorio de salida.
```
ls *.txt
```
Este tipo de salida `hash.txt` existe en el directorio, pero `hash-jobattachments.txt` no existe porque el archivo de salida del trabajo aún no se ha descargado.
1. Descarga el resultado del trabajo más reciente.
```
deadline job download-output
```
1. Vea el resultado del archivo descargado.
```
cat hash-jobattachments.txt
```
Se muestra un resultado como el siguiente:
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## Entender cómo se almacenan los archivos adjuntos de trabajo en Amazon S3
Puede usar AWS Command Line Interface (AWS CLI) para cargar o descargar datos para adjuntos de trabajos, que se almacenan en depósitos de Amazon S3. Comprender cómo Deadline Cloud almacena los adjuntos de trabajo en Amazon S3 le ayudará a desarrollar integraciones de cargas de trabajo y canalizaciones.
**Para inspeccionar cómo se almacenan los adjuntos de trabajo de Deadline Cloud en Amazon S3**
1. Elija la primera CloudShell pestaña y, a continuación, abra el directorio de ejemplos de paquetes de trabajos.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Inspeccione las propiedades del trabajo.
```
deadline job get
```
Se muestra un resultado como el siguiente:
```
parameters:
Message:
string: Welcome to AWS Deadline Cloud!
InFile:
path: /home/cloudshell-user/deadline-cloud-samples/job_bundles/simple_job/template.yaml
OutFile:
path: /home/cloudshell-user/deadline-cloud-samples/job_bundles/hash-jobattachments.txt
attachments:
manifests:
- rootPath: /home/cloudshell-user/deadline-cloud-samples/job_bundles/
rootPathFormat: posix
outputRelativeDirectories:
- .
inputManifestPath: farm-3040c59a5b9943d58052c29d907a645d/queue-cde9977c9f4d4018a1d85f3e6c1a4e6e/Inputs/f46af01ca8904cd8b514586671c79303/0d69cd94523ba617c731f29c019d16e8_input.xxh128
inputManifestHash: f95ef91b5dab1fc1341b75637fe987ee
fileSystem: COPIED
```
El campo de adjuntos contiene una lista de estructuras de manifiesto que describen las rutas de datos de entrada y salida que utiliza el trabajo cuando se ejecuta. Observe `rootPath` la ruta del directorio local de la máquina que envió el trabajo. Para ver el sufijo de objeto de Amazon S3 que contiene un archivo de manifiesto, consulte la`inputManifestFile`. El archivo de manifiesto contiene metadatos para una instantánea del árbol de directorios de los datos de entrada del trabajo.
1. Imprima de forma bonita el objeto del manifiesto de Amazon S3 para ver la estructura de directorios de entrada del trabajo.
```
MANIFEST_SUFFIX=$(aws deadline get-job \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--query "attachments.manifests[0].inputManifestPath" \
--output text)
aws s3 cp s3://$DEV_FARM_BUCKET/JobAttachments/Manifests/$MANIFEST_SUFFIX - | jq .
```
Se muestra un resultado como el siguiente:
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "2ec297b04c59c4741ed97ac8fb83080c",
"mtime": 1698186190000000,
"path": "simple_job/template.yaml",
"size": 445
}
],
"totalSize": 445
}
```
1. Cree el prefijo Amazon S3 que contiene los manifiestos de los adjuntos de los trabajos de salida y enumere el objeto debajo de él.
```
SESSION_ACTION=$(aws deadline list-session-actions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--session-id $SESSION_ID \
--query "sessionActions[?definition.taskRun != null] | [0]")
STEP_ID=$(echo $SESSION_ACTION | jq -r .definition.taskRun.stepId)
TASK_ID=$(echo $SESSION_ACTION | jq -r .definition.taskRun.taskId)
TASK_OUTPUT_PREFIX=JobAttachments/Manifests/$DEV_FARM_ID/$DEV_QUEUE_ID/$JOB_ID/$STEP_ID/$TASK_ID/
aws s3api list-objects-v2 --bucket $DEV_FARM_BUCKET --prefix $TASK_OUTPUT_PREFIX
```
No se hace referencia directamente a los adjuntos del trabajo de salida desde el recurso del trabajo, sino que se colocan en un bucket de Amazon S3 en función del recurso de la granja IDs.
1. Obtenga la clave de objeto de manifiesto más reciente para el identificador de acción de sesión específico y, a continuación, imprima de forma bonita los objetos del manifiesto.
```
SESSION_ACTION_ID=$(echo $SESSION_ACTION | jq -r .sessionActionId)
MANIFEST_KEY=$(aws s3api list-objects-v2 \
--bucket $DEV_FARM_BUCKET \
--prefix $TASK_OUTPUT_PREFIX \
--query "Contents[*].Key" --output text \
| grep $SESSION_ACTION_ID \
| sort | tail -1)
MANIFEST_OBJECT=$(aws s3 cp s3://$DEV_FARM_BUCKET/$MANIFEST_KEY -)
echo $MANIFEST_OBJECT | jq .
```
Verás las propiedades del archivo `hash-jobattachments.txt` en el resultado, como las siguientes:
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "f60b8e7d0fabf7214ba0b6822e82e08b",
"mtime": 1698785252554950,
"path": "hash-jobattachments.txt",
"size": 182
}
],
"totalSize": 182
}
```
Tu trabajo solo tendrá un objeto de manifiesto por cada tarea que se ejecute, pero en general es posible tener más objetos por tarea ejecutada.
1. Vea la salida de almacenamiento de Amazon S3 direccionable por contenido bajo el prefijo. `Data`
```
FILE_HASH=$(echo $MANIFEST_OBJECT | jq -r .paths[0].hash)
FILE_PATH=$(echo $MANIFEST_OBJECT | jq -r .paths[0].path)
aws s3 cp s3://$DEV_FARM_BUCKET/JobAttachments/Data/$FILE_HASH -
```
Se muestra un resultado como el siguiente:
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## Siguientes pasos
Después de aprender a enviar trabajos con archivos adjuntos mediante la CLI de Deadline Cloud, puede explorar:
+ [Envía con Deadline Cloud](submit-a-job.md)para aprender a ejecutar trabajos con un paquete de OpenJD en los hosts de sus trabajadores.
+ [Agrega una flota gestionada por servicios a tu granja de desarrolladores en Deadline Cloud](service-managed-fleet.md)para ejecutar tus trabajos en hosts gestionados por Deadline Cloud.
+ [Limpia los recursos de tu granja en Deadline Cloud](cleaning-up.md)para cerrar los recursos que utilizaste para este tutorial.
# Agrega una flota gestionada por servicios a tu granja de desarrolladores en Deadline Cloud
AWS CloudShell no proporciona suficiente capacidad de cómputo para probar cargas de trabajo más grandes. Tampoco está configurado para funcionar con trabajos que distribuyen las tareas en varios hosts de trabajo.
En lugar de utilizarla CloudShell, puede añadir una flota gestionada por servicios (SMF) de Auto Scaling a su granja de desarrolladores. Un SMF proporciona suficiente capacidad de cómputo para cargas de trabajo más grandes y puede gestionar trabajos que necesiten distribuirse entre varios hosts de trabajo.
Antes de añadir una SMF, debe configurar una granja, una cola y una flota de Deadline Cloud. Consulte [Cree una granja de Deadline Cloud](create-a-farm.md).
**Para añadir una flota gestionada por servicios a tu granja de desarrolladores**
1. Selecciona la primera AWS CloudShell pestaña y, a continuación, crea la flota gestionada por el servicio y añade su ID de flota a. `.bashrc` Esta acción hace que esté disponible para otras sesiones de terminal.
```
FLEET_ROLE_ARN="arn:aws:iam::$(aws sts get-caller-identity \
--query "Account" --output text):role/${DEV_FARM_NAME}FleetRole"
aws deadline create-fleet \
--farm-id $DEV_FARM_ID \
--display-name "$DEV_FARM_NAME SMF" \
--role-arn $FLEET_ROLE_ARN \
--max-worker-count 5 \
--configuration \
'{
"serviceManagedEc2": {
"instanceCapabilities": {
"vCpuCount": {
"min": 2,
"max": 4
},
"memoryMiB": {
"min": 512
},
"osFamily": "linux",
"cpuArchitectureType": "x86_64"
},
"instanceMarketOptions": {
"type": "spot"
}
}
}'
echo "DEV_SMF_ID=$(aws deadline list-fleets \
--farm-id $DEV_FARM_ID \
--query "fleets[?displayName=='$DEV_FARM_NAME SMF'].fleetId \
| [0]" --output text)" >> ~/.bashrc
source ~/.bashrc
```
1. Asocie el SMF a su cola.
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_SMF_ID
```
1. Envíelo simple\$1file\$1job a la cola. Cuando se te pida que confirmes la carga, ingresa**y**.
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. Confirme que el SMF funciona correctamente.
```
deadline fleet get
```
+ El trabajador puede tardar unos minutos en empezar. Repita el `deadline fleet get` comando hasta que vea que la flota está funcionando.
+ La flota gestionada `queueFleetAssociationsStatus` por el servicio será. `ACTIVE`
+ El SMF `autoScalingStatus` cambiará de a. `GROWING` `STEADY`
Su estado será similar al siguiente:
```
fleetId: fleet-2cc78e0dd3f04d1db427e7dc1d51ea44
farmId: farm-63ee8d77cdab4a578b685be8c5561c4a
displayName: DeveloperFarm SMF
description: ''
status: ACTIVE
autoScalingStatus: STEADY
targetWorkerCount: 0
workerCount: 0
minWorkerCount: 0
maxWorkerCount: 5
```
1. Vea el registro del trabajo que envió. Este registro se guarda en un registro de Amazon CloudWatch Logs, no en el sistema de CloudShell archivos.
```
JOB_ID=$(deadline config get defaults.job_id)
SESSION_ID=$(aws deadline list-sessions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--query "sessions[0].sessionId" \
--output text)
aws logs tail /aws/deadline/$DEV_FARM_ID/$DEV_QUEUE_ID \
--log-stream-names $SESSION_ID
```
## Siguientes pasos
Tras crear y probar una flota gestionada por un servicio, debe eliminar los recursos que haya creado para evitar cargos innecesarios.
+ [Limpia los recursos de tu granja en Deadline Cloud](cleaning-up.md)para cerrar los recursos que utilizaste en este tutorial.
# Limpia los recursos de tu granja en Deadline Cloud
Para desarrollar y probar nuevas cargas de trabajo e integraciones de canalizaciones, puedes seguir utilizando la granja de desarrolladores de Deadline Cloud que creaste para este tutorial. Si ya no necesitas tu granja de desarrolladores, puedes eliminar sus recursos, incluidos la granja, la flota, la cola, las funciones AWS Identity and Access Management (IAM) y los registros de Amazon CloudWatch Logs. Tras eliminar estos recursos, tendrá que volver a empezar el tutorial para poder utilizarlos. Para obtener más información, consulte [Cómo empezar con los recursos de Deadline Cloud](getting-started.md).
**Para limpiar los recursos de la granja de desarrolladores**
1. Elige la primera CloudShell pestaña y, a continuación, detiene todas las asociaciones de flotas que forman parte de tu lista.
```
FLEETS=$(aws deadline list-queue-fleet-associations \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--query "queueFleetAssociations[].fleetId" \
--output text)
for FLEET_ID in $FLEETS; do
aws deadline update-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $FLEET_ID \
--status STOP_SCHEDULING_AND_CANCEL_TASKS
done
```
1. Haz una lista de las asociaciones de flotas en cola.
```
aws deadline list-queue-fleet-associations \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
Puede que tenga que volver a ejecutar el comando hasta que se muestre el resultado y`"status": "STOPPED"`, a continuación, puede continuar con el siguiente paso. Este proceso puede tardar varios minutos en completarse.
```
{
"queueFleetAssociations": [
{
"queueId": "queue-abcdefgh01234567890123456789012id",
"fleetId": "fleet-abcdefgh01234567890123456789012id",
"status": "STOPPED",
"createdAt": "2023-11-21T20:49:19+00:00",
"createdBy": "arn:aws:sts::123456789012:assumed-role/RoleToBeAssumed/MySessionName",
"updatedAt": "2023-11-21T20:49:38+00:00",
"updatedBy": "arn:aws:sts::123456789012:assumed-role/RoleToBeAssumed/MySessionName"
},
{
"queueId": "queue-abcdefgh01234567890123456789012id",
"fleetId": "fleet-abcdefgh01234567890123456789012id",
"status": "STOPPED",
"createdAt": "2023-11-21T20:32:06+00:00",
"createdBy": "arn:aws:sts::123456789012:assumed-role/RoleToBeAssumed/MySessionName",
"updatedAt": "2023-11-21T20:49:39+00:00",
"updatedBy": "arn:aws:sts::123456789012:assumed-role/RoleToBeAssumed/MySessionName"
}
]
}
```
1. Elimine todas las asociaciones de colas y flotas de su cola.
```
for FLEET_ID in $FLEETS; do
aws deadline delete-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $FLEET_ID
done
```
1. Elimina todas las flotas asociadas a tu cola.
```
for FLEET_ID in $FLEETS; do
aws deadline delete-fleet \
--farm-id $DEV_FARM_ID \
--fleet-id $FLEET_ID
done
```
1. Elimine la cola.
```
aws deadline delete-queue \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
1. Elimine la granja.
```
aws deadline delete-farm \
--farm-id $DEV_FARM_ID
```
1. Elimina otros AWS recursos de tu granja.
1. Elimine el rol de flota AWS Identity and Access Management (IAM).
```
aws iam delete-role-policy \
--role-name "${DEV_FARM_NAME}FleetRole" \
--policy-name WorkerPermissions
aws iam delete-role \
--role-name "${DEV_FARM_NAME}FleetRole"
```
1. Elimine la función de IAM de cola.
```
aws iam delete-role-policy \
--role-name "${DEV_FARM_NAME}QueueRole" \
--policy-name S3BucketsAccess
aws iam delete-role \
--role-name "${DEV_FARM_NAME}QueueRole"
```
1. Elimine los grupos de CloudWatch registros de Amazon Logs. Cada cola y flota tiene su propio grupo de registros.
```
aws logs delete-log-group \
--log-group-name "/aws/deadline/$DEV_FARM_ID/$DEV_QUEUE_ID"
aws logs delete-log-group \
--log-group-name "/aws/deadline/$DEV_FARM_ID/$DEV_CMF_ID"
aws logs delete-log-group \
--log-group-name "/aws/deadline/$DEV_FARM_ID/$DEV_SMF_ID"
```