Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Guida introduttiva alle risorse di Deadline Cloud
Per iniziare a creare soluzioni personalizzate per AWS Deadline Cloud, devi configurare le tue risorse. Queste includono una fattoria, almeno una coda per l'azienda agricola e almeno una flotta di lavoratori per la manutenzione della coda. Puoi creare le tue risorse utilizzando la console Deadline Cloud oppure puoi utilizzare il. AWS Command Line Interface
In questo tutorial, lo utilizzerai AWS CloudShell per creare una semplice farm per sviluppatori ed eseguire il worker agent. Potrai quindi inviare ed eseguire un semplice lavoro con parametri e allegati, aggiungere una flotta gestita dai servizi e ripulire le risorse della fattoria quando hai finito.
Le sezioni seguenti illustrano le diverse funzionalità di Deadline Cloud e il modo in cui funzionano e interagiscono. Seguire questi passaggi è utile per sviluppare e testare nuovi carichi di lavoro e personalizzazioni.
Per istruzioni su come configurare la tua fattoria utilizzando la console, consulta [Guida introduttiva](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/getting-started.html) nella Guida per l'utente di *Deadline Cloud*.
**Topics**
+ [Crea una cloud farm di Deadline](create-a-farm.md)
+ [Esegui l'agente di lavoro Deadline Cloud](run-worker.md)
+ [Invia con Deadline Cloud](submit-a-job.md)
+ [Invia offerte di lavoro con allegati di lavoro in Deadline Cloud](run-jobs-job-attachments.md)
+ [Aggiungi una flotta gestita dai servizi alla tua farm di sviluppatori in Deadline Cloud](service-managed-fleet.md)
+ [Pulisci le risorse della tua azienda agricola in Deadline Cloud](cleaning-up.md)
# Crea una cloud farm di Deadline
Per creare la tua farm per sviluppatori e le risorse in coda in AWS Deadline Cloud, usa AWS Command Line Interface (AWS CLI), come mostrato nella procedura seguente. Inoltre, creerai un ruolo AWS Identity and Access Management (IAM) e una flotta gestita dal cliente (CMF) e assocerai la flotta alla tua coda. Quindi puoi configurare AWS CLI e confermare che la tua farm sia configurata e funzioni come specificato.
Puoi utilizzare questa farm per esplorare le funzionalità di Deadline Cloud, quindi sviluppare e testare nuovi carichi di lavoro, personalizzazioni e integrazioni di pipeline.
**Per creare una fattoria**
1. [Aprire una AWS CloudShell sessione](https://console.aws.amazon.com/cloudshell/home?region=us-west-2). Utilizzerai la CloudShell finestra per inserire i comandi AWS Command Line Interface (AWS CLI) per eseguire gli esempi di questo tutorial. Mantieni la CloudShell finestra aperta mentre procedi.
1. Crea un nome per la tua fattoria e aggiungi il nome della fattoria a`~/.bashrc`. In questo modo sarà disponibile per altre sessioni terminali.
```
echo "DEV_FARM_NAME=DeveloperFarm" >> ~/.bashrc
source ~/.bashrc
```
1. Crea la risorsa della fattoria e aggiungi il relativo ID della fattoria 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. Crea la risorsa della coda e aggiungi il relativo ID di coda 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. Crea un ruolo IAM per la flotta. Questo ruolo fornisce agli host dei lavoratori del tuo parco macchine le credenziali di sicurezza necessarie per eseguire i lavori dalla tua coda.
```
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. Crea la flotta gestita dal cliente (CMF) e aggiungi il relativo ID della flotta 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. Associa il CMF alla tua coda.
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_CMF_ID
```
1. Installa l'interfaccia a riga di comando di Deadline Cloud.
```
pip install deadline
```
1. Per impostare la farm predefinita sull'ID della fattoria e la coda sull'ID della coda che hai creato in precedenza, usa il comando seguente.
```
deadline config set defaults.farm_id $DEV_FARM_ID
deadline config set defaults.queue_id $DEV_QUEUE_ID
```
1. (Facoltativo) Per confermare che la fattoria è configurata in base alle specifiche, utilizzate i seguenti comandi:
+ Elenca tutte le fattorie — **deadline farm list**
+ Elenca tutte le code nella farm predefinita: **deadline queue list**
+ Elenca tutte le flotte nella fattoria predefinita: **deadline fleet list**
+ Ottieni la fattoria predefinita: **deadline farm get**
+ Ottieni la coda predefinita: **deadline queue get**
+ Ottieni tutte le flotte associate alla coda predefinita: **deadline fleet get**
## Passaggi successivi
Dopo aver creato la tua fattoria, puoi far funzionare l'operatore Deadline Cloud sugli host della tua flotta per elaborare i lavori. Per informazioni, consulta [Esegui l'agente di lavoro Deadline Cloud](run-worker.md).
# Esegui l'agente di lavoro Deadline Cloud
Prima di poter eseguire i lavori che invii alla coda nella tua farm di sviluppatori, devi eseguire il worker agent di AWS Deadline Cloud in modalità sviluppatore su un worker host.
Nel resto di questo tutorial, eseguirai AWS CLI operazioni sulla tua farm di sviluppatori utilizzando due schede. AWS CloudShell Nella prima scheda, puoi inviare offerte di lavoro. Nella seconda scheda, puoi eseguire l'agente di lavoro.
**Nota**
Se lasci la CloudShell sessione inattiva per più di 20 minuti, scade il timeout e interrompe l'agente di lavoro. Per riavviare l'agente di lavoro, segui le istruzioni nella procedura seguente.
Prima di poter avviare un worker agent, devi configurare una farm, una coda e una flotta di Deadline Cloud. Consultare [Crea una cloud farm di Deadline](create-a-farm.md).
**Per eseguire l'agente di lavoro in modalità sviluppatore**
1. Con la fattoria ancora aperta nella prima CloudShell scheda, apri una seconda CloudShell scheda, quindi crea le `demoenv-persist` cartelle `demoenv-logs` e.
```
mkdir ~/demoenv-logs
mkdir ~/demoenv-persist
```
1. Scarica e installa i pacchetti Deadline Cloud worker agent da PyPI:
**Nota**
Abilitato Windows, è necessario che i file dell'agente siano installati nella directory globale dei pacchetti del sito di Python. Gli ambienti virtuali Python non sono attualmente supportati.
```
python -m pip install deadline-cloud-worker-agent
```
1. Per consentire all'agente di lavoro di creare le directory temporanee per i lavori in esecuzione, crea una directory:
```
sudo mkdir /sessions
sudo chmod 750 /sessions
sudo chown cloudshell-user /sessions
```
1. Esegui il worker agent Deadline Cloud in modalità sviluppatore con `DEV_FARM_ID` le variabili `DEV_CMF_ID` che hai aggiunto a. `~/.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
```
Quando l'agente di lavoro inizializza e quindi esegue il polling del funzionamento dell'`UpdateWorkerSchedule`API, viene visualizzato il seguente output:
```
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. Seleziona la prima CloudShell scheda, quindi elenca i lavoratori della flotta.
```
deadline worker list --fleet-id $DEV_CMF_ID
```
Viene visualizzato un output come il seguente:
```
Displaying 1 of 1 workers starting at 0
- workerId: worker-8c9af877c8734e89914047111f
status: STARTED
createdAt: 2023-12-13 20:43:06+00:00
```
In una configurazione di produzione, il worker agent di Deadline Cloud richiede la configurazione di più utenti e directory di configurazione come utente amministrativo sulla macchina host. Puoi ignorare queste impostazioni perché stai eseguendo lavori nella tua farm di sviluppo, a cui solo tu puoi accedere.
## Passaggi successivi
Ora che un worker agent è in esecuzione sui tuoi host di lavoro, puoi inviare lavori ai tuoi lavoratori. È possibile:
+ [Invia con Deadline Cloud](submit-a-job.md)utilizzando un semplice pacchetto di lavori OpenJD.
+ [Invia offerte di lavoro con allegati di lavoro in Deadline Cloud](run-jobs-job-attachments.md)che condividono file tra postazioni di lavoro che utilizzano sistemi operativi diversi.
# Invia con Deadline Cloud
Per eseguire lavori Deadline Cloud sui tuoi host di lavoro, crei e utilizzi un pacchetto di lavori Open Job Description (OpenJD) per configurare un lavoro. Il pacchetto configura il lavoro, ad esempio specificando i file di input per un lavoro e dove scrivere l'output del lavoro. Questo argomento include esempi di modi in cui è possibile configurare un job bundle.
Prima di poter seguire le procedure in questa sezione, è necessario completare quanto segue:
+ [Crea una cloud farm di Deadline](create-a-farm.md)
+ [Esegui l'agente di lavoro Deadline Cloud](run-worker.md)
Per utilizzare AWS Deadline Cloud per eseguire lavori, utilizza le seguenti procedure. Usa la prima AWS CloudShell scheda per inviare lavori alla tua farm di sviluppatori. Usa la seconda CloudShell scheda per visualizzare l'output del worker agent.
**Topics**
+ [Invia il simple\$1job campione](#submit-a-simplejob-sample)
+ [Invia un messaggio simple\$1job con un parametro](#submit-with-parameter)
+ [Crea un pacchetto di job simple\$1file\$1job con file I/O](#create-job-bundle-with-file-io)
+ [Fasi successive](#submit-a-job-next)
## Invia il simple\$1job campione
Dopo aver creato una fattoria e aver avviato l'agente operaio, puoi inviare il simple\$1job campione a Deadline Cloud.
**Per inviare il simple\$1job campione a Deadline Cloud**
1. Scegli la tua prima CloudShell scheda.
1. Scarica l'esempio da GitHub.
```
cd ~
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Vai alla directory degli esempi del job bundle.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Invia il simple\$1job campione.
```
deadline bundle submit simple_job
```
1. Scegli la seconda CloudShell scheda per visualizzare l'output di registrazione relativo alle chiamate`BatchGetJobEntities`, all'attivazione di una sessione e all'esecuzione di un'azione di sessione.
```
...
[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**
Viene mostrato solo l'output di registrazione del worker agent. Esiste un registro separato per la sessione che esegue il lavoro.
1. Scegli la tua prima scheda, quindi controlla i file di registro scritti dal worker agent.
1. Passa alla directory dei registri del worker agent e visualizzane il contenuto.
```
cd ~/demoenv-logs
ls
```
1. Stampa il primo file di registro creato dal worker agent.
```
cat worker-agent-bootstrap.log
```
Questo file contiene l'output dell'agente di lavoro su come ha chiamato l'API Deadline Cloud per creare una risorsa worker nel parco macchine e poi ha assunto il ruolo del parco macchine.
1. Stampa l'output del file di registro quando l'agente lavoratore si unisce alla flotta.
```
cat worker-agent.log
```
Questo registro contiene output su tutte le azioni intraprese dall'agente di lavoro, ma non contiene output sulle code da cui esegue i lavori, ad eccezione IDs di quelle risorse.
1. Stampa i file di registro per ogni sessione in una directory con lo stesso nome dell'id della risorsa della coda.
```
cat $DEV_QUEUE_ID/session-*.log
```
Se il processo ha esito positivo, l'output del file di registro sarà simile al seguente:
```
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. Stampa le informazioni sul lavoro.
```
deadline job get
```
Quando inviate il lavoro, il sistema lo salva come predefinito in modo da non dover inserire l'ID del lavoro.
## Invia un messaggio simple\$1job con un parametro
Puoi inviare lavori con parametri. Nella procedura seguente, si modifica il simple\$1job modello per includere un messaggio personalizzato, si invia il file di registro della simple\$1job sessione e si stampa il file di registro della sessione per visualizzare il messaggio.
**Per inviare l'simple\$1jobesempio con un parametro**
1. Seleziona la tua prima CloudShell scheda, quindi vai alla directory degli esempi di job bundle.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Stampa il contenuto del simple\$1job modello.
```
cat simple_job/template.yaml
```
La `parameterDefinitions` sezione con il `Message` parametro dovrebbe avere l'aspetto seguente:
```
parameterDefinitions:
- name: Message
type: STRING
default: Welcome to AWS Deadline Cloud!
```
1. Inviate l'simple\$1jobesempio con un valore di parametro, quindi attendete che il processo finisca di funzionare.
```
deadline bundle submit simple_job \
-p "Message=Greetings from the developer getting started guide."
```
1. Per visualizzare il messaggio personalizzato, visualizza il file di registro della sessione più recente.
```
cd ~/demoenv-logs
cat $DEV_QUEUE_ID/$(ls -t $DEV_QUEUE_ID | head -1)
```
## Crea un pacchetto di job simple\$1file\$1job con file I/O
Un lavoro di rendering deve leggere la definizione della scena, renderizzare un'immagine a partire da essa e quindi salvare l'immagine in un file di output. È possibile simulare questa azione facendo in modo che il job calcoli l'hash dell'input anziché renderizzare un'immagine.
**Per creare un pacchetto di lavoro simple\$1file\$1job con file I/O**
1. Seleziona la prima CloudShell scheda, quindi vai alla directory degli esempi di job bundle.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Crea una copia `simple_job` con il nuovo nome`simple_file_job`.
```
cp -r simple_job simple_file_job
```
1. Modifica il modello di lavoro come segue:
**Nota**
Ti consigliamo di utilizzarlo nano per questi passaggi. Se si preferisce utilizzareVim, è necessario impostarne la modalità di incolla utilizzando`:set paste`.
1. Apri il modello in un editor di testo.
```
nano simple_file_job/template.yaml
```
1. Aggiungi quanto segue `type``objectType`, e `dataFlow``parameterDefinitions`.
```
- name: InFile
type: PATH
objectType: FILE
dataFlow: IN
- name: OutFile
type: PATH
objectType: FILE
dataFlow: OUT
```
1. Aggiungere il seguente comando di `bash` script alla fine del file che legge dal file di input e scrive nel file di output.
```
# hash the input file, and write that to the output
sha256sum "{{Param.InFile}}" > "{{Param.OutFile}}"
```
L'aggiornamento `template.yaml` dovrebbe corrispondere esattamente a quanto segue:
```
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**
Se desideri regolare la spaziatura in`template.yaml`, assicurati di utilizzare spazi anziché rientri.
1. Salvate il file e uscite dall'editor di testo.
1. Fornite i valori dei parametri per i file di input e output per inviare il simple\$1file\$1job.
```
deadline bundle submit simple_file_job \
-p "InFile=simple_job/template.yaml" \
-p "OutFile=hash.txt"
```
1. Stampa le informazioni sul lavoro.
```
deadline job get
```
+ Verrà visualizzato un output come il seguente:
```
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
```
+ Sebbene abbiate fornito solo percorsi relativi, per i parametri è impostato il percorso completo. AWS CLI Unisce la directory di lavoro corrente a tutti i percorsi forniti come parametri quando i percorsi hanno il tipo`PATH`.
+ L'agente di lavoro in esecuzione nell'altra finestra del terminale rileva ed esegue il lavoro. Questa azione crea il `hash.txt` file, che è possibile visualizzare con il seguente comando.
```
cat hash.txt
```
Questo comando stamperà un output simile al seguente.
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/simple_job/template.yaml
```
## Fasi successive
Dopo aver appreso come inviare lavori semplici utilizzando la CLI di Deadline Cloud, puoi scoprire:
+ [Invia offerte di lavoro con allegati di lavoro in Deadline Cloud](run-jobs-job-attachments.md)per imparare a eseguire lavori su host che eseguono sistemi operativi diversi.
+ [Aggiungi una flotta gestita dai servizi alla tua farm di sviluppatori in Deadline Cloud](service-managed-fleet.md)per eseguire i tuoi lavori su host gestiti da Deadline Cloud.
+ [Pulisci le risorse della tua azienda agricola in Deadline Cloud](cleaning-up.md)per chiudere le risorse che hai usato per questo tutorial.
# Invia offerte di lavoro con allegati di lavoro in Deadline Cloud
Molte farm utilizzano file system condivisi per condividere file tra gli host che inviano i job e quelli che eseguono i job. Ad esempio, nell'`simple_file_job`esempio precedente, il file system locale è condiviso tra le finestre del AWS CloudShell terminale, che vengono eseguite nella scheda uno in cui si invia il lavoro, e nella scheda due in cui si esegue il worker agent.
Un file system condiviso è vantaggioso quando la postazione di lavoro del mittente e gli host del lavoratore si trovano sulla stessa rete locale. Se memorizzi i dati in locale vicino alle workstation che vi accedono, l'utilizzo di una farm basata sul cloud significa dover condividere i file system tramite una VPN ad alta latenza o sincronizzare i file system nel cloud. Nessuna di queste opzioni è facile da configurare o utilizzare.
AWS Deadline Cloud offre una soluzione semplice con *allegati di lavoro, simili agli allegati* delle e-mail. Con gli allegati di lavoro, alleghi dati al tuo lavoro. Deadline Cloud gestisce quindi i dettagli del trasferimento e dell'archiviazione dei dati di lavoro nei bucket Amazon Simple Storage Service (Amazon S3).
I flussi di lavoro per la creazione di contenuti sono spesso iterativi, il che significa che un utente invia lavori con un piccolo sottoinsieme di file modificati. Poiché i bucket Amazon S3 archiviano gli allegati del lavoro in uno storage content-addressable, il nome di ogni oggetto si basa sull'hash dei dati dell'oggetto e il contenuto di un albero di directory viene archiviato in un formato di file manifesto allegato a un lavoro.
Prima di poter seguire le procedure in questa sezione, devi completare quanto segue:
+ [Crea una cloud farm di Deadline](create-a-farm.md)
+ [Esegui l'agente di lavoro Deadline Cloud](run-worker.md)
Per eseguire lavori con allegati di lavoro, completare i passaggi seguenti.
**Topics**
+ [Aggiungi una configurazione degli allegati di lavoro alla tua coda](#job-attachments-config)
+ [Invia simple\$1file\$1job con allegati di lavoro](#submit-job-attachments)
+ [Informazioni su come vengono archiviati gli allegati di lavoro in Amazon S3](#job-attachments-in-depth)
+ [Fasi successive](#run-jobs-job-attachments-next)
## Aggiungi una configurazione degli allegati di lavoro alla tua coda
Per abilitare gli allegati dei lavori nella tua coda, aggiungi una configurazione degli allegati di lavoro alla risorsa di coda del tuo account.
**Per aggiungere una configurazione degli allegati di lavoro alla tua coda**
1. Scegli la tua prima CloudShell scheda, quindi inserisci uno dei seguenti comandi per utilizzare un bucket Amazon S3 per gli allegati dei lavori.
+ Se non disponi di un bucket Amazon S3 privato esistente, puoi creare e utilizzare un nuovo bucket 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}
```
+ Se disponi già di un bucket Amazon S3 privato, puoi utilizzarlo sostituendolo *`MY_BUCKET_NAME`* con il nome del tuo bucket.
```
DEV_FARM_BUCKET=MY_BUCKET_NAME
```
1. Dopo aver creato o scelto il bucket Amazon S3, aggiungi il nome del bucket a per renderlo disponibile `~/.bashrc` per altre sessioni di terminale.
```
echo "DEV_FARM_BUCKET=$DEV_FARM_BUCKET" >> ~/.bashrc
source ~/.bashrc
```
1. Crea un ruolo AWS Identity and Access Management (IAM) per la coda.
```
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. Aggiorna la coda per includere le impostazioni degli allegati di lavoro e il ruolo 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. Conferma di aver aggiornato la coda.
```
deadline queue get
```
Viene visualizzato un output come il seguente:
```
...
jobAttachmentSettings:
s3BucketName: DEV_FARM_BUCKET
rootPrefix: JobAttachments
roleArn: arn:aws:iam::ACCOUNT_NUMBER:role/DeveloperFarmQueueRole
...
```
## Invia simple\$1file\$1job con allegati di lavoro
Quando utilizzi gli allegati di lavoro, i pacchetti di lavoro devono fornire a Deadline Cloud informazioni sufficienti per determinare il flusso di dati del lavoro, ad esempio l'utilizzo dei parametri. `PATH` Nel caso disimple\$1file\$1job, hai modificato il `template.yaml` file per indicare a Deadline Cloud che il flusso di dati si trova nel file di input e nel file di output.
Dopo aver aggiunto la configurazione degli allegati di lavoro alla coda, puoi inviare l'esempio di simple\$1file\$1job con gli allegati del lavoro. Dopo aver eseguito questa operazione, è possibile visualizzare la registrazione e l'output del lavoro per confermare che l'operazione con gli allegati del lavoro funziona. simple\$1file\$1job
**Per inviare il pacchetto di lavoro simple\$1file\$1job con gli allegati del lavoro**
1. Scegli la tua prima CloudShell scheda, quindi apri la cartella. `JobBundle-Samples`
1.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Invia simple\$1file\$1job alla coda. Quando ti viene richiesto di confermare il caricamento, inserisci. **y**
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. Per visualizzare l'output del registro della sessione di trasferimento dati degli allegati del lavoro, eseguite il comando seguente.
```
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. Elenca le azioni della sessione eseguite all'interno della sessione.
```
aws deadline list-session-actions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--session-id $SESSION_ID
```
Viene mostrato un output come il seguente:
```
{
"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 prima azione della sessione ha scaricato gli allegati del lavoro di input, mentre la seconda azione esegue l'attività come nei passaggi precedenti e quindi ha caricato gli allegati del lavoro di output.
1. Elenca la directory di output.
```
ls *.txt
```
Un output come questo `hash.txt` esiste nella directory, ma `hash-jobattachments.txt` non esiste perché il file di output del processo non è stato ancora scaricato.
1. Scarica l'output del processo più recente.
```
deadline job download-output
```
1. Visualizza l'output del file scaricato.
```
cat hash-jobattachments.txt
```
Viene mostrato un output come il seguente:
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## Informazioni su come vengono archiviati gli allegati di lavoro in Amazon S3
Puoi utilizzare AWS Command Line Interface (AWS CLI) per caricare o scaricare dati per gli allegati di lavoro, che vengono archiviati nei bucket Amazon S3. Capire come Deadline Cloud archivia gli allegati di lavoro su Amazon S3 ti aiuterà a sviluppare carichi di lavoro e integrazioni di pipeline.
**Per controllare come vengono archiviati gli allegati dei lavori di Deadline Cloud in Amazon S3**
1. Scegli la tua prima CloudShell scheda, quindi apri la directory degli esempi di job bundle.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Ispeziona le proprietà del lavoro.
```
deadline job get
```
Viene mostrato un output come il seguente:
```
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
```
Il campo degli allegati contiene un elenco di strutture manifeste che descrivono i percorsi dei dati di input e output utilizzati dal job durante l'esecuzione. Guarda `rootPath` per vedere il percorso della directory locale sul computer che ha inviato il lavoro. Per visualizzare il suffisso dell'oggetto Amazon S3 che contiene un file manifesto, consulta il. `inputManifestFile` Il file manifest contiene i metadati per un'istantanea ad albero di directory dei dati di input del processo.
1. Stampa bene l'oggetto manifest di Amazon S3 per vedere la struttura della directory di input per il lavoro.
```
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 .
```
Viene mostrato un output come il seguente:
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "2ec297b04c59c4741ed97ac8fb83080c",
"mtime": 1698186190000000,
"path": "simple_job/template.yaml",
"size": 445
}
],
"totalSize": 445
}
```
1. Crea il prefisso Amazon S3 che contiene i manifest per gli allegati del processo di output ed elenca l'oggetto al suo interno.
```
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
```
Gli allegati del lavoro di output non sono referenziati direttamente dalla risorsa del lavoro, ma vengono invece inseriti in un bucket Amazon S3 basato sulla risorsa della fattoria. IDs
1. Ottieni la chiave dell'oggetto manifesto più recente per l'ID di azione della sessione specifica, quindi stampa in modo semplice gli oggetti del manifesto.
```
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 .
```
`hash-jobattachments.txt`Nell'output vedrete le proprietà del file, come le seguenti:
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "f60b8e7d0fabf7214ba0b6822e82e08b",
"mtime": 1698785252554950,
"path": "hash-jobattachments.txt",
"size": 182
}
],
"totalSize": 182
}
```
Il job avrà un solo oggetto manifesto per operazione eseguita, ma in generale è possibile avere più oggetti per operazione eseguita.
1. Visualizza l'output di storage Amazon S3 indirizzabile ai contenuti sotto il prefisso. `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 -
```
Viene mostrato un output come il seguente:
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## Fasi successive
Dopo aver appreso come inviare offerte di lavoro con allegati utilizzando la CLI di Deadline Cloud, puoi scoprire:
+ [Invia con Deadline Cloud](submit-a-job.md)per imparare a eseguire lavori utilizzando un pacchetto OpenJD sui tuoi host di lavoro.
+ [Aggiungi una flotta gestita dai servizi alla tua farm di sviluppatori in Deadline Cloud](service-managed-fleet.md)per eseguire i tuoi lavori su host gestiti da Deadline Cloud.
+ [Pulisci le risorse della tua azienda agricola in Deadline Cloud](cleaning-up.md)per chiudere le risorse che hai usato per questo tutorial.
# Aggiungi una flotta gestita dai servizi alla tua farm di sviluppatori in Deadline Cloud
AWS CloudShell non fornisce una capacità di elaborazione sufficiente per testare carichi di lavoro più grandi. Inoltre, non è configurato per funzionare con lavori che distribuiscono le attività su più host di lavoro.
Invece di utilizzarla CloudShell, puoi aggiungere una flotta gestita dai servizi di Auto Scaling (SMF) alla tua farm di sviluppatori. Un SMF offre una capacità di elaborazione sufficiente per carichi di lavoro più grandi ed è in grado di gestire lavori che richiedono la distribuzione delle attività lavorative su più host di lavoro.
Prima di aggiungere un SMF, devi configurare una farm, una coda e una flotta Deadline Cloud. Per informazioni, consulta [Crea una cloud farm di Deadline](create-a-farm.md).
**Per aggiungere una flotta gestita dai servizi alla tua farm di sviluppatori**
1. Scegli la tua prima AWS CloudShell scheda, quindi crea la flotta gestita dai servizi e aggiungi il relativo ID della flotta a. `.bashrc` Questa azione lo rende disponibile per altre sessioni terminali.
```
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. Associate l'SMF alla vostra coda.
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_SMF_ID
```
1. Invia simple\$1file\$1job alla coda. Quando ti viene richiesto di confermare il caricamento, inserisci. **y**
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. Conferma che l'SMF funzioni correttamente.
```
deadline fleet get
```
+ L'operatore potrebbe impiegare alcuni minuti per iniziare. Ripeti il `deadline fleet get` comando finché non vedi che la flotta è in funzione.
+ La flotta `queueFleetAssociationsStatus` per i servizi gestiti sarà. `ACTIVE`
+ La SMF `autoScalingStatus` cambierà da a. `GROWING` `STEADY`
Il tuo stato sarà simile al seguente:
```
fleetId: fleet-2cc78e0dd3f04d1db427e7dc1d51ea44
farmId: farm-63ee8d77cdab4a578b685be8c5561c4a
displayName: DeveloperFarm SMF
description: ''
status: ACTIVE
autoScalingStatus: STEADY
targetWorkerCount: 0
workerCount: 0
minWorkerCount: 0
maxWorkerCount: 5
```
1. Visualizza il registro del lavoro che hai inviato. Questo registro viene memorizzato in un registro in Amazon CloudWatch Logs, non nel CloudShell file system.
```
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
```
## Fasi successive
Dopo aver creato e testato una flotta gestita dai servizi, dovresti rimuovere le risorse che hai creato per evitare addebiti inutili.
+ [Pulisci le risorse della tua azienda agricola in Deadline Cloud](cleaning-up.md)per chiudere le risorse che hai usato per questo tutorial.
# Pulisci le risorse della tua azienda agricola in Deadline Cloud
Per sviluppare e testare nuovi carichi di lavoro e integrazioni di pipeline, puoi continuare a utilizzare la farm per sviluppatori Deadline Cloud che hai creato per questo tutorial. Se non hai più bisogno della tua farm di sviluppatori, puoi eliminarne le risorse, tra cui farm, fleet, queue, ruoli AWS Identity and Access Management (IAM) e log in Amazon CloudWatch Logs. Dopo aver eliminato queste risorse, dovrai ricominciare il tutorial per utilizzarle. Per ulteriori informazioni, consulta [Guida introduttiva alle risorse di Deadline Cloud](getting-started.md).
**Per ripulire le risorse della farm degli sviluppatori**
1. Scegli la tua prima CloudShell scheda, quindi interrompi tutte le associazioni queue-fleet relative alla tua coda.
```
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. Elenca le associazioni delle flotte in coda.
```
aws deadline list-queue-fleet-associations \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
Potrebbe essere necessario eseguire nuovamente il comando fino a quando l'output non riporta i risultati`"status": "STOPPED"`, quindi è possibile procedere al passaggio successivo. Il completamento di questo processo può richiedere diversi minuti.
```
{
"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. Elimina tutte le associazioni queue-fleet per la tua coda.
```
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 tutte le flotte associate alla coda.
```
for FLEET_ID in $FLEETS; do
aws deadline delete-fleet \
--farm-id $DEV_FARM_ID \
--fleet-id $FLEET_ID
done
```
1. Elimina la coda.
```
aws deadline delete-queue \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
1. Eliminare la fattoria.
```
aws deadline delete-farm \
--farm-id $DEV_FARM_ID
```
1. Elimina altre AWS risorse per la tua fattoria.
1. Elimina il ruolo fleet 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. Elimina il ruolo IAM in coda.
```
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. Elimina i gruppi di log di Amazon CloudWatch Logs. Ogni coda e flotta ha il proprio gruppo di log.
```
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"
```