Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Commencer à utiliser les ressources de Deadline Cloud
Pour commencer à créer des solutions personnalisées pour AWS Deadline Cloud, vous devez configurer vos ressources. Il s'agit notamment d'une ferme, d'au moins une file d'attente pour la ferme et d'au moins un parc de travailleurs pour desservir la file d'attente. Vous pouvez créer vos ressources à l'aide de la console Deadline Cloud, ou vous pouvez utiliser le AWS Command Line Interface.
Dans ce didacticiel, vous allez AWS CloudShell créer une ferme de développement simple et exécuter l'agent de travail. Vous pouvez ensuite soumettre et exécuter une tâche simple avec des paramètres et des pièces jointes, ajouter un parc géré par des services et nettoyer les ressources de votre ferme lorsque vous avez terminé.
Les sections suivantes vous présentent les différentes fonctionnalités de Deadline Cloud, ainsi que la façon dont elles fonctionnent et fonctionnent ensemble. Il est utile de suivre ces étapes pour développer et tester de nouvelles charges de travail et personnalisations.
Pour obtenir des instructions sur la configuration de votre ferme à l'aide de la console, consultez [Getting started](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/getting-started.html) dans le *guide de l'utilisateur de Deadline Cloud*.
**Topics**
+ [Création d'un parc Deadline Cloud](create-a-farm.md)
+ [Exécutez l'agent de travail Deadline Cloud](run-worker.md)
+ [Soumettre avec Deadline Cloud](submit-a-job.md)
+ [Soumettez des offres d'emploi avec des pièces jointes dans Deadline Cloud](run-jobs-job-attachments.md)
+ [Ajoutez une flotte gérée par des services à votre parc de développeurs dans Deadline Cloud](service-managed-fleet.md)
+ [Nettoyez les ressources de votre ferme dans Deadline Cloud](cleaning-up.md)
# Création d'un parc Deadline Cloud
Pour créer votre parc de développeurs et vos ressources de file d'attente dans AWS Deadline Cloud, utilisez le AWS Command Line Interface (AWS CLI), comme indiqué dans la procédure suivante. Vous allez également créer un rôle Gestion des identités et des accès AWS (IAM) et une flotte gérée par le client (CMF) et associer la flotte à votre file d'attente. Vous pouvez ensuite configurer AWS CLI et confirmer que votre ferme est configurée et fonctionne comme indiqué.
Vous pouvez utiliser cette ferme pour explorer les fonctionnalités de Deadline Cloud, puis développer et tester de nouvelles charges de travail, personnalisations et intégrations de pipelines.
**Pour créer une ferme**
1. [Ouvrez une AWS CloudShell session](https://console.aws.amazon.com/cloudshell/home?region=us-west-2). Vous allez utiliser la CloudShell fenêtre pour saisir les commandes AWS Command Line Interface (AWS CLI) afin d'exécuter les exemples de ce didacticiel. Gardez la CloudShell fenêtre ouverte pendant que vous poursuivez.
1. Créez un nom pour votre ferme et ajoutez-y le nom de la ferme à`~/.bashrc`. Cela le rendra disponible pour les autres sessions du terminal.
```
echo "DEV_FARM_NAME=DeveloperFarm" >> ~/.bashrc
source ~/.bashrc
```
1. Créez la ressource agricole et ajoutez-y son identifiant de ferme`~/.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. Créez la ressource de file d'attente et ajoutez son ID de file d'attente à `~/.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. Créez un rôle IAM pour la flotte. Ce rôle fournit aux hôtes de travail de votre flotte les informations de sécurité nécessaires pour exécuter des tâches depuis votre file d'attente.
```
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. Créez la flotte gérée par le client (CMF) et ajoutez son identifiant de flotte à. `~/.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. Associez le CMF à votre file d'attente.
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_CMF_ID
```
1. Installez l'interface de ligne de commande de Deadline Cloud.
```
pip install deadline
```
1. Pour définir le parc par défaut sur l'ID du parc de serveurs et la file d'attente sur l'ID de file d'attente que vous avez créé précédemment, utilisez la commande suivante.
```
deadline config set defaults.farm_id $DEV_FARM_ID
deadline config set defaults.queue_id $DEV_QUEUE_ID
```
1. (Facultatif) Pour vérifier que votre ferme est configurée conformément à vos spécifications, utilisez les commandes suivantes :
+ Liste de toutes les fermes — **deadline farm list**
+ Répertorier toutes les files d'attente de la ferme par défaut — **deadline queue list**
+ Répertorier toutes les flottes de la ferme par défaut : **deadline fleet list**
+ Obtenez la ferme par défaut — **deadline farm get**
+ Obtenez la file d'attente par défaut — **deadline queue get**
+ Obtenez toutes les flottes associées à la file d'attente par défaut — **deadline fleet get**
## Étapes suivantes
Après avoir créé votre parc de serveurs, vous pouvez exécuter l'agent de travail Deadline Cloud sur les hôtes de votre parc pour traiter les tâches. Consultez [Exécutez l'agent de travail Deadline Cloud](run-worker.md).
# Exécutez l'agent de travail Deadline Cloud
Avant de pouvoir exécuter les tâches que vous soumettez à la file d'attente de votre parc de développeurs, vous devez exécuter l'agent de travail de AWS Deadline Cloud en mode développeur sur un hôte de travail.
Dans le reste de ce didacticiel, vous allez effectuer des AWS CLI opérations sur votre ferme de développeurs à l'aide de deux AWS CloudShell onglets. Dans le premier onglet, vous pouvez soumettre des offres d'emploi. Dans le deuxième onglet, vous pouvez exécuter l'agent de travail.
**Note**
Si vous laissez votre CloudShell session inactive pendant plus de 20 minutes, le délai expirera et l'agent de travail sera arrêté. Pour redémarrer l'agent de travail, suivez les instructions de la procédure suivante.
Avant de créer un agent de travail, vous devez configurer un parc, une file d'attente et un parc Deadline Cloud. Consultez [Création d'un parc Deadline Cloud](create-a-farm.md).
**Pour exécuter l'agent de travail en mode développeur**
1. Votre ferme étant toujours ouverte dans le premier CloudShell onglet, ouvrez un deuxième CloudShell onglet, puis créez les `demoenv-persist` répertoires `demoenv-logs` et.
```
mkdir ~/demoenv-logs
mkdir ~/demoenv-persist
```
1. Téléchargez et installez les packages d'agents de travail de Deadline Cloud depuis PyPI :
**Note**
Activé Windows, les fichiers de l'agent doivent être installés dans le répertoire global site-packages de Python. Les environnements virtuels Python ne sont actuellement pas pris en charge.
```
python -m pip install deadline-cloud-worker-agent
```
1. Pour permettre à l'agent de travail de créer les répertoires temporaires pour exécuter les tâches, créez un répertoire :
```
sudo mkdir /sessions
sudo chmod 750 /sessions
sudo chown cloudshell-user /sessions
```
1. Exécutez l'agent de travail de Deadline Cloud en mode développeur avec les variables `DEV_FARM_ID` et `DEV_CMF_ID` celles que vous avez ajoutées au`~/.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
```
Lorsque l'agent de travail initialise puis interroge l'opération d'`UpdateWorkerSchedule`API, le résultat suivant s'affiche :
```
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. Sélectionnez votre premier CloudShell onglet, puis listez les travailleurs de la flotte.
```
deadline worker list --fleet-id $DEV_CMF_ID
```
Des résultats tels que les suivants sont affichés :
```
Displaying 1 of 1 workers starting at 0
- workerId: worker-8c9af877c8734e89914047111f
status: STARTED
createdAt: 2023-12-13 20:43:06+00:00
```
Dans une configuration de production, l'agent de travail de Deadline Cloud nécessite la configuration de plusieurs utilisateurs et répertoires de configuration en tant qu'utilisateur administratif sur la machine hôte. Vous pouvez annuler ces paramètres car vous exécutez des tâches dans votre propre ferme de développement, à laquelle vous seul pouvez accéder.
## Étapes suivantes
Maintenant qu'un agent de travail est en cours d'exécution sur vos hôtes de travail, vous pouvez envoyer des tâches à vos employés. Vous pouvez :
+ [Soumettre avec Deadline Cloud](submit-a-job.md)en utilisant un simple bundle de tâches OpenJD.
+ [Soumettez des offres d'emploi avec des pièces jointes dans Deadline Cloud](run-jobs-job-attachments.md)qui partagent des fichiers entre des postes de travail utilisant différents systèmes d'exploitation.
# Soumettre avec Deadline Cloud
Pour exécuter des tâches Deadline Cloud sur vos hôtes de travail, vous devez créer et utiliser un ensemble de tâches Open Job Description (OpenJD) pour configurer une tâche. Le bundle configure la tâche, par exemple en spécifiant les fichiers d'entrée pour une tâche et en indiquant où écrire la sortie de la tâche. Cette rubrique contient des exemples de méthodes permettant de configurer un ensemble de tâches.
Avant de pouvoir suivre les procédures décrites dans cette section, vous devez effectuer les opérations suivantes :
+ [Création d'un parc Deadline Cloud](create-a-farm.md)
+ [Exécutez l'agent de travail Deadline Cloud](run-worker.md)
Pour utiliser AWS Deadline Cloud pour exécuter des tâches, suivez les procédures suivantes. Utilisez le premier AWS CloudShell onglet pour soumettre des offres d'emploi à votre parc de développeurs. Utilisez le deuxième CloudShell onglet pour afficher la sortie de l'agent de travail.
**Topics**
+ [Soumettre l'simple\$1jobéchantillon](#submit-a-simplejob-sample)
+ [Soumettre un simple\$1job avec un paramètre](#submit-with-parameter)
+ [Création d'un ensemble de tâches simple\$1file\$1job avec des E/S de fichiers](#create-job-bundle-with-file-io)
+ [Étapes suivantes](#submit-a-job-next)
## Soumettre l'simple\$1jobéchantillon
Après avoir créé une ferme et exécuté l'agent de travail, vous pouvez envoyer l'simple\$1jobéchantillon à Deadline Cloud.
**Pour envoyer l'simple\$1jobéchantillon à Deadline Cloud**
1. Choisissez votre premier CloudShell onglet.
1. Téléchargez l'exemple à partir de GitHub.
```
cd ~
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Accédez au répertoire des exemples de lots de tâches.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Soumettez l'simple\$1jobéchantillon.
```
deadline bundle submit simple_job
```
1. Choisissez votre deuxième CloudShell onglet pour afficher les résultats de journalisation concernant les appels`BatchGetJobEntities`, l'obtention d'une session et l'exécution d'une action de session.
```
...
[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]
...
```
**Note**
Seule la sortie de journalisation de l'agent de travail est affichée. Il existe un journal distinct pour la session qui exécute le travail.
1. Choisissez votre premier onglet, puis inspectez les fichiers journaux écrits par l'agent de travail.
1. Accédez au répertoire des journaux de l'agent de travail et visualisez son contenu.
```
cd ~/demoenv-logs
ls
```
1. Imprimez le premier fichier journal créé par l'agent de travail.
```
cat worker-agent-bootstrap.log
```
Ce fichier contient une sortie de l'agent de travail expliquant comment il a appelé l'API Deadline Cloud pour créer une ressource de personnel dans votre flotte, puis a assumé le rôle de flotte.
1. Imprimez la sortie du fichier journal lorsque l'agent des travailleurs rejoint le parc.
```
cat worker-agent.log
```
Ce journal contient des résultats sur toutes les actions entreprises par l'agent de travail, mais pas sur les files d'attente à partir desquelles il exécute les tâches, à l'exception IDs de ces ressources.
1. Imprimez les fichiers journaux de chaque session dans un répertoire dont le nom est identique à l'identifiant de la ressource de file d'attente.
```
cat $DEV_QUEUE_ID/session-*.log
```
En cas de réussite de la tâche, le résultat du fichier journal sera similaire à ce qui suit :
```
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. Imprimez les informations relatives à la tâche.
```
deadline job get
```
Lorsque vous soumettez la tâche, le système l'enregistre par défaut afin que vous n'ayez pas à saisir l'ID de la tâche.
## Soumettre un simple\$1job avec un paramètre
Vous pouvez soumettre des tâches avec des paramètres. Dans la procédure suivante, vous modifiez le simple\$1job modèle pour inclure un message personnalisé, vous soumettez le fichier journal de sessionsimple\$1job, puis vous l'imprimez pour afficher le message.
**Pour soumettre l'simple\$1jobéchantillon avec un paramètre**
1. Sélectionnez votre premier CloudShell onglet, puis accédez au répertoire des exemples de lots de tâches.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Imprimez le contenu du simple\$1job modèle.
```
cat simple_job/template.yaml
```
La `parameterDefinitions` section contenant le `Message` paramètre doit ressembler à ce qui suit :
```
parameterDefinitions:
- name: Message
type: STRING
default: Welcome to AWS Deadline Cloud!
```
1. Soumettez l'simple\$1jobexemple avec une valeur de paramètre, puis attendez que le travail soit terminé.
```
deadline bundle submit simple_job \
-p "Message=Greetings from the developer getting started guide."
```
1. Pour voir le message personnalisé, consultez le fichier journal de session le plus récent.
```
cd ~/demoenv-logs
cat $DEV_QUEUE_ID/$(ls -t $DEV_QUEUE_ID | head -1)
```
## Création d'un ensemble de tâches simple\$1file\$1job avec des E/S de fichiers
Une tâche de rendu doit lire la définition de la scène, en faire le rendu d'une image, puis enregistrer cette image dans un fichier de sortie. Vous pouvez simuler cette action en demandant à la tâche de calculer le hachage de l'entrée au lieu de restituer une image.
**Pour créer un ensemble de tâches simple\$1file\$1job avec des E/S de fichiers**
1. Sélectionnez votre premier CloudShell onglet, puis accédez au répertoire des exemples de lots de tâches.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Faites-en une copie `simple_job` avec le nouveau nom`simple_file_job`.
```
cp -r simple_job simple_file_job
```
1. Modifiez le modèle de tâche comme suit :
**Note**
Nous vous recommandons de l'utiliser nano pour ces étapes. Si vous préférez l'utiliserVim, vous devez définir son mode de collage à l'aide de`:set paste`.
1. Ouvrez le modèle dans un éditeur de texte.
```
nano simple_file_job/template.yaml
```
1. Ajoutez les éléments suivants `type``objectType`, et `dataFlow``parameterDefinitions`.
```
- name: InFile
type: PATH
objectType: FILE
dataFlow: IN
- name: OutFile
type: PATH
objectType: FILE
dataFlow: OUT
```
1. Ajoutez la commande de `bash` script suivante à la fin du fichier qui lit le fichier d'entrée et écrit dans le fichier de sortie.
```
# hash the input file, and write that to the output
sha256sum "{{Param.InFile}}" > "{{Param.OutFile}}"
```
La mise à jour `template.yaml` doit correspondre exactement à ce qui suit :
```
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}}"
```
**Note**
Si vous souhaitez ajuster l'espacement dans le`template.yaml`, assurez-vous d'utiliser des espaces plutôt que des indentations.
1. Enregistrez le fichier et quittez l'éditeur de texte.
1. Fournissez des valeurs de paramètres pour les fichiers d'entrée et de sortie afin de soumettre le simple\$1file\$1job.
```
deadline bundle submit simple_file_job \
-p "InFile=simple_job/template.yaml" \
-p "OutFile=hash.txt"
```
1. Imprimez les informations relatives à la tâche.
```
deadline job get
```
+ Vous verrez des résultats tels que les suivants :
```
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
```
+ Bien que vous n'ayez fourni que des chemins relatifs, le chemin complet est défini pour les paramètres. Le AWS CLI joint le répertoire de travail actuel à tous les chemins fournis en tant que paramètres lorsque les chemins ont le type`PATH`.
+ L'agent de travail exécuté dans l'autre fenêtre du terminal prend en charge et exécute la tâche. Cette action crée le `hash.txt` fichier, que vous pouvez consulter à l'aide de la commande suivante.
```
cat hash.txt
```
Cette commande imprimera un résultat similaire à ce qui suit.
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/simple_job/template.yaml
```
## Étapes suivantes
Après avoir appris à soumettre des tâches simples à l'aide de la CLI de Deadline Cloud, vous pouvez explorer les points suivants :
+ [Soumettez des offres d'emploi avec des pièces jointes dans Deadline Cloud](run-jobs-job-attachments.md)pour savoir comment exécuter des tâches sur des hôtes exécutant différents systèmes d'exploitation.
+ [Ajoutez une flotte gérée par des services à votre parc de développeurs dans Deadline Cloud](service-managed-fleet.md)pour exécuter vos tâches sur des hôtes gérés par Deadline Cloud.
+ [Nettoyez les ressources de votre ferme dans Deadline Cloud](cleaning-up.md)pour arrêter les ressources que vous avez utilisées pour ce didacticiel.
# Soumettez des offres d'emploi avec des pièces jointes dans Deadline Cloud
De nombreuses fermes utilisent des systèmes de fichiers partagés pour partager des fichiers entre les hôtes qui soumettent des tâches et ceux qui exécutent des tâches. Par exemple, dans l'`simple_file_job`exemple précédent, le système de fichiers local est partagé entre les fenêtres du AWS CloudShell terminal, qui s'exécutent dans l'onglet 1 où vous soumettez le travail, et dans l'onglet 2 où vous exécutez l'agent de travail.
Un système de fichiers partagé est avantageux lorsque le poste de travail émetteur et les hôtes de travail se trouvent sur le même réseau local. Si vous stockez vos données sur site à proximité des postes de travail qui y accèdent, l'utilisation d'une ferme basée sur le cloud signifie que vous devez partager vos systèmes de fichiers via un VPN à latence élevée ou synchroniser vos systèmes de fichiers dans le cloud. Aucune de ces options n'est facile à configurer ou à utiliser.
AWS Deadline Cloud propose une solution simple avec des *pièces jointes à des tâches*, similaires à des pièces jointes à des e-mails. Avec les pièces jointes à une tâche, vous associez des données à votre tâche. Deadline Cloud gère ensuite les détails du transfert et du stockage de vos données de travail dans des compartiments Amazon Simple Storage Service (Amazon S3).
Les processus de création de contenu sont souvent itératifs, ce qui signifie qu'un utilisateur soumet des tâches avec un petit sous-ensemble de fichiers modifiés. Comme les compartiments Amazon S3 stockent les pièces jointes aux tâches dans un espace de stockage adressable par le contenu, le nom de chaque objet est basé sur le hachage des données de l'objet et le contenu d'une arborescence de répertoires est stocké dans un format de fichier manifeste joint à une tâche.
Avant de pouvoir suivre les procédures décrites dans cette section, vous devez effectuer les opérations suivantes :
+ [Création d'un parc Deadline Cloud](create-a-farm.md)
+ [Exécutez l'agent de travail Deadline Cloud](run-worker.md)
Pour exécuter des tâches avec des pièces jointes, procédez comme suit.
**Topics**
+ [Ajoutez une configuration de pièces jointes aux tâches à votre file d'attente](#job-attachments-config)
+ [Soumettre simple\$1file\$1job avec des pièces jointes au poste](#submit-job-attachments)
+ [Comprendre comment les pièces jointes aux tâches sont stockées dans Amazon S3](#job-attachments-in-depth)
+ [Étapes suivantes](#run-jobs-job-attachments-next)
## Ajoutez une configuration de pièces jointes aux tâches à votre file d'attente
Pour activer les pièces jointes aux tâches dans votre file d'attente, ajoutez une configuration de pièces jointes aux tâches à la ressource de file d'attente de votre compte.
**Pour ajouter une configuration de pièces jointes aux tâches à votre file d'attente**
1. Choisissez votre premier CloudShell onglet, puis entrez l'une des commandes suivantes pour utiliser un compartiment Amazon S3 pour les pièces jointes aux tâches.
+ Si vous n'avez pas de compartiment Amazon S3 privé existant, vous pouvez créer et utiliser un nouveau compartiment S3.
```
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 vous possédez déjà un compartiment Amazon S3 privé, vous pouvez l'utiliser en le *`MY_BUCKET_NAME`* remplaçant par le nom de votre compartiment.
```
DEV_FARM_BUCKET=MY_BUCKET_NAME
```
1. Après avoir créé ou choisi votre compartiment Amazon S3, ajoutez le nom du compartiment `~/.bashrc` pour le rendre disponible pour d'autres sessions de terminal.
```
echo "DEV_FARM_BUCKET=$DEV_FARM_BUCKET" >> ~/.bashrc
source ~/.bashrc
```
1. Créez un rôle Gestion des identités et des accès AWS (IAM) pour la file d'attente.
```
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. Mettez à jour votre file d'attente pour inclure les paramètres des pièces jointes aux tâches et le rôle 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. Confirmez que vous avez mis à jour votre file d'attente.
```
deadline queue get
```
Des résultats tels que les suivants sont affichés :
```
...
jobAttachmentSettings:
s3BucketName: DEV_FARM_BUCKET
rootPrefix: JobAttachments
roleArn: arn:aws:iam::ACCOUNT_NUMBER:role/DeveloperFarmQueueRole
...
```
## Soumettre simple\$1file\$1job avec des pièces jointes au poste
Lorsque vous utilisez des pièces jointes à des tâches, les ensembles de tâches doivent fournir à Deadline Cloud suffisamment d'informations pour déterminer le flux de données de la tâche, par exemple en utilisant des `PATH` paramètres. Dans ce cassimple\$1file\$1job, vous avez modifié le `template.yaml` fichier pour indiquer à Deadline Cloud que le flux de données se trouve dans le fichier d'entrée et le fichier de sortie.
Après avoir ajouté la configuration des pièces jointes aux tâches à votre file d'attente, vous pouvez envoyer l'exemple simple\$1file\$1job avec les pièces jointes aux tâches. Ensuite, vous pouvez consulter le journal et le résultat de la tâche pour confirmer que les pièces jointes simple\$1file\$1job aux tâches fonctionnent.
**Pour soumettre le bundle de tâches simple\$1file\$1job avec des pièces jointes**
1. Choisissez votre premier CloudShell onglet, puis ouvrez le `JobBundle-Samples` répertoire.
1.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Soumettez simple\$1file\$1job à la file d'attente. Lorsque vous êtes invité à confirmer le téléchargement, entrez**y**.
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. Pour afficher le résultat du journal de session de transfert de données des pièces jointes aux tâches, exécutez la commande suivante.
```
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. Répertoriez les actions de session exécutées au cours de la session.
```
aws deadline list-session-actions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--session-id $SESSION_ID
```
Des résultats tels que les suivants sont affichés :
```
{
"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 première action de session a téléchargé les pièces jointes de tâche d'entrée, tandis que la seconde action exécute la tâche comme dans les étapes précédentes, puis a chargé les pièces jointes de tâche de sortie.
1. Répertoriez le répertoire de sortie.
```
ls *.txt
```
Une sortie telle qu'`hash.txt`elle existe dans le répertoire, mais `hash-jobattachments.txt` n'existe pas car le fichier de sortie de la tâche n'a pas encore été téléchargé.
1. Téléchargez le résultat de la tâche la plus récente.
```
deadline job download-output
```
1. Affichez le résultat du fichier téléchargé.
```
cat hash-jobattachments.txt
```
Des résultats tels que les suivants sont affichés :
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## Comprendre comment les pièces jointes aux tâches sont stockées dans Amazon S3
Vous pouvez utiliser le AWS Command Line Interface (AWS CLI) pour charger ou télécharger des données relatives aux pièces jointes aux tâches, qui sont stockées dans des compartiments Amazon S3. Comprendre comment Deadline Cloud stocke les pièces jointes aux tâches sur Amazon S3 vous aidera à développer des charges de travail et à intégrer des pipelines.
**Pour vérifier comment les pièces jointes aux tâches de Deadline Cloud sont stockées dans Amazon S3**
1. Choisissez votre premier CloudShell onglet, puis ouvrez le répertoire des exemples de lots de tâches.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Inspectez les propriétés de la tâche.
```
deadline job get
```
Des résultats tels que les suivants sont affichés :
```
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
```
Le champ Pièces jointes contient une liste de structures de manifeste qui décrivent les chemins de données d'entrée et de sortie utilisés par la tâche lors de son exécution. Regardez `rootPath` le chemin du répertoire local sur la machine qui a soumis le travail. Pour consulter le suffixe d'objet Amazon S3 qui contient un fichier manifeste, consultez le`inputManifestFile`. Le fichier manifeste contient des métadonnées pour un instantané de l'arborescence des répertoires des données d'entrée de la tâche.
1. Imprimez joliment l'objet manifeste Amazon S3 pour voir la structure du répertoire d'entrée correspondant à la tâche.
```
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 .
```
Des résultats tels que les suivants sont affichés :
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "2ec297b04c59c4741ed97ac8fb83080c",
"mtime": 1698186190000000,
"path": "simple_job/template.yaml",
"size": 445
}
],
"totalSize": 445
}
```
1. Créez le préfixe Amazon S3 qui contient les manifestes pour les pièces jointes aux tâches de sortie et listez l'objet situé en dessous.
```
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
```
Les pièces jointes aux tâches de sortie ne sont pas directement référencées à partir de la ressource de tâche, mais sont placées dans un compartiment Amazon S3 basé sur les ressources de la ferme IDs.
1. Obtenez la clé d'objet manifeste la plus récente pour l'identifiant d'action de session spécifique, puis imprimez joliment les objets du manifeste.
```
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 .
```
Vous verrez les propriétés du fichier `hash-jobattachments.txt` dans la sortie, telles que les suivantes :
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "f60b8e7d0fabf7214ba0b6822e82e08b",
"mtime": 1698785252554950,
"path": "hash-jobattachments.txt",
"size": 182
}
],
"totalSize": 182
}
```
Votre tâche ne comportera qu'un seul objet manifeste par exécution de tâche, mais en général, il est possible d'avoir plus d'objets par exécution de tâche.
1. Affichez la sortie de stockage Amazon S3 adressable au contenu sous le préfixe. `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 -
```
Des résultats tels que les suivants sont affichés :
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## Étapes suivantes
Après avoir appris à soumettre des tâches avec pièces jointes à l'aide de la CLI de Deadline Cloud, vous pouvez découvrir :
+ [Soumettre avec Deadline Cloud](submit-a-job.md)pour savoir comment exécuter des tâches à l'aide d'un bundle OpenJD sur vos hôtes de travail.
+ [Ajoutez une flotte gérée par des services à votre parc de développeurs dans Deadline Cloud](service-managed-fleet.md)pour exécuter vos tâches sur des hôtes gérés par Deadline Cloud.
+ [Nettoyez les ressources de votre ferme dans Deadline Cloud](cleaning-up.md)pour arrêter les ressources que vous avez utilisées pour ce didacticiel.
# Ajoutez une flotte gérée par des services à votre parc de développeurs dans Deadline Cloud
AWS CloudShell ne fournit pas une capacité de calcul suffisante pour tester des charges de travail plus importantes. Il n'est pas non plus configuré pour fonctionner avec des tâches qui distribuent des tâches sur plusieurs hôtes de travail.
Au lieu de l'utiliser CloudShell, vous pouvez ajouter une flotte gérée par des services (SMF) Auto Scaling à votre parc de développeurs. Un SMF fournit une capacité de calcul suffisante pour des charges de travail plus importantes et peut gérer des tâches nécessitant de répartir les tâches entre plusieurs hôtes de travail.
Avant d'ajouter un SMF, vous devez configurer un parc, une file d'attente et un parc Deadline Cloud. Consultez [Création d'un parc Deadline Cloud](create-a-farm.md).
**Pour ajouter une flotte gérée par des services à votre parc de développeurs**
1. Choisissez votre premier AWS CloudShell onglet, puis créez le parc géré par le service et ajoutez-y son identifiant de flotte. `.bashrc` Cette action le rend disponible pour d'autres sessions 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. Associez le SMF à votre file d'attente.
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_SMF_ID
```
1. Soumettre simple\$1file\$1job à la file d'attente. Lorsque vous êtes invité à confirmer le téléchargement, entrez**y**.
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. Vérifiez que le SMF fonctionne correctement.
```
deadline fleet get
```
+ Le travailleur peut mettre quelques minutes à démarrer. Répétez la `deadline fleet get` commande jusqu'à ce que vous voyiez que la flotte fonctionne.
+ La flotte `queueFleetAssociationsStatus` destinée à la gestion des services sera. `ACTIVE`
+ Le SMF `autoScalingStatus` passera de `GROWING` à. `STEADY`
Votre statut ressemblera à ce qui suit :
```
fleetId: fleet-2cc78e0dd3f04d1db427e7dc1d51ea44
farmId: farm-63ee8d77cdab4a578b685be8c5561c4a
displayName: DeveloperFarm SMF
description: ''
status: ACTIVE
autoScalingStatus: STEADY
targetWorkerCount: 0
workerCount: 0
minWorkerCount: 0
maxWorkerCount: 5
```
1. Consultez le journal de la tâche que vous avez soumise. Ce journal est stocké dans un journal dans Amazon CloudWatch Logs, et non dans le système de CloudShell fichiers.
```
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
```
## Étapes suivantes
Après avoir créé et testé un parc géré par des services, vous devez supprimer les ressources que vous avez créées pour éviter des frais inutiles.
+ [Nettoyez les ressources de votre ferme dans Deadline Cloud](cleaning-up.md)pour arrêter les ressources que vous avez utilisées pour ce didacticiel.
# Nettoyez les ressources de votre ferme dans Deadline Cloud
Pour développer et tester de nouvelles charges de travail et de nouvelles intégrations de pipeline, vous pouvez continuer à utiliser le parc de développeurs Deadline Cloud que vous avez créé pour ce didacticiel. Si vous n'avez plus besoin de votre parc de développeurs, vous pouvez supprimer ses ressources, notamment la ferme, le parc, la file d'attente, les rôles Gestion des identités et des accès AWS (IAM) et les journaux dans Amazon CloudWatch Logs. Après avoir supprimé ces ressources, vous devrez recommencer le didacticiel pour pouvoir les utiliser. Pour de plus amples informations, veuillez consulter [Commencer à utiliser les ressources de Deadline Cloud](getting-started.md).
**Pour assainir les ressources agricoles des développeurs**
1. Choisissez votre premier CloudShell onglet, puis arrêtez toutes les associations de files d'attente et de flottes pour votre file d'attente.
```
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. Répertoriez les associations de parcs de files d'attente.
```
aws deadline list-queue-fleet-associations \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
Vous devrez peut-être réexécuter la commande jusqu'à ce que le résultat soit `"status": "STOPPED"` affiché, puis vous pourrez passer à l'étape suivante. Ce processus peut prendre plusieurs minutes.
```
{
"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. Supprimez toutes les associations de files d'attente et de flottes associées à votre file d'attente.
```
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. Supprimez toutes les flottes associées à votre file d'attente.
```
for FLEET_ID in $FLEETS; do
aws deadline delete-fleet \
--farm-id $DEV_FARM_ID \
--fleet-id $FLEET_ID
done
```
1. Supprimez la file d'attente.
```
aws deadline delete-queue \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
1. Supprimez la ferme.
```
aws deadline delete-farm \
--farm-id $DEV_FARM_ID
```
1. Supprimez les autres AWS ressources de votre ferme.
1. Supprimez le rôle de flotte Gestion des identités et des accès AWS (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. Supprimez le rôle IAM de la file d'attente.
```
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. Supprimez les groupes de CloudWatch journaux Amazon Logs. Chaque file d'attente et flotte possède son propre groupe de journaux.
```
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"
```