As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Introdução aos recursos do Deadline Cloud
Para começar a criar soluções personalizadas para AWS o Deadline Cloud, você deve configurar seus recursos. Isso inclui uma fazenda, pelo menos uma fila para a fazenda e pelo menos uma frota de trabalhadores para atender a fila. Você pode criar seus recursos usando o console do Deadline Cloud, ou você pode usar AWS Command Line Interface o.
Neste tutorial, você usará AWS CloudShell para criar um farm de desenvolvedores simples e executar o agente de trabalho. Em seguida, você pode enviar e executar um trabalho simples com parâmetros e anexos, adicionar uma frota gerenciada por serviços e limpar os recursos da fazenda quando terminar.
As seções a seguir apresentam os diferentes recursos do Deadline Cloud e como eles funcionam e funcionam juntos. Seguir essas etapas é útil para desenvolver e testar novas cargas de trabalho e personalizações.
Para obter instruções sobre como configurar sua fazenda usando o console, consulte [Introdução](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/getting-started.html) no *Guia do usuário do Deadline Cloud*.
**Topics**
+ [Crie um Deadline Cloud Farm](create-a-farm.md)
+ [Execute o agente Deadline Cloud Worker](run-worker.md)
+ [Envie com o Deadline Cloud](submit-a-job.md)
+ [Envie vagas com anexos de vagas no Deadline Cloud](run-jobs-job-attachments.md)
+ [Adicione uma frota gerenciada por serviços à sua fazenda de desenvolvedores no Deadline Cloud](service-managed-fleet.md)
+ [Limpe os recursos da sua fazenda no Deadline Cloud](cleaning-up.md)
# Crie um Deadline Cloud Farm
Para criar seu farm de desenvolvedores e enfileirar recursos no AWS Deadline Cloud, use o AWS Command Line Interface (AWS CLI), conforme mostrado no procedimento a seguir. Você também criará uma função AWS Identity and Access Management (IAM) e uma frota gerenciada pelo cliente (CMF) e associará a frota à sua fila. Em seguida, você pode configurar AWS CLI e confirmar se sua fazenda está configurada e funcionando conforme especificado.
Você pode usar essa fazenda para explorar os recursos do Deadline Cloud e, em seguida, desenvolver e testar novas cargas de trabalho, personalizações e integrações de pipeline.
**Para criar uma fazenda**
1. [Abra uma AWS CloudShell sessão](https://console.aws.amazon.com/cloudshell/home?region=us-west-2). Você usará a CloudShell janela para inserir os comandos AWS Command Line Interface (AWS CLI) para executar os exemplos deste tutorial. Mantenha a CloudShell janela aberta à medida que avança.
1. Crie um nome para sua fazenda e adicione esse nome à`~/.bashrc`. Isso o disponibilizará para outras sessões do terminal.
```
echo "DEV_FARM_NAME=DeveloperFarm" >> ~/.bashrc
source ~/.bashrc
```
1. Crie o recurso da fazenda e adicione seu ID da fazenda `~/.bashrc` a.
```
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. Crie o recurso de fila e adicione seu ID de fila ao `~/.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. Crie uma função do IAM para a frota. Essa função fornece aos anfitriões de trabalhadores em sua frota as credenciais de segurança necessárias para executar trabalhos em sua fila.
```
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. Crie a frota gerenciada pelo cliente (CMF) e adicione sua ID de frota 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. Associe o CMF à sua fila.
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_CMF_ID
```
1. Instale a interface de linha de comando do Deadline Cloud.
```
pip install deadline
```
1. Para definir a fazenda padrão como a ID da fazenda e a fila como a ID da fila que você criou anteriormente, use o comando a seguir.
```
deadline config set defaults.farm_id $DEV_FARM_ID
deadline config set defaults.queue_id $DEV_QUEUE_ID
```
1. (Opcional) Para confirmar se sua fazenda está configurada de acordo com suas especificações, use os seguintes comandos:
+ Listar todas as fazendas — **deadline farm list**
+ Listar todas as filas na fazenda padrão — **deadline queue list**
+ Listar todas as frotas na fazenda padrão — **deadline fleet list**
+ Obtenha a fazenda padrão — **deadline farm get**
+ Obtenha a fila padrão — **deadline queue get**
+ Obtenha todas as frotas associadas à fila padrão — **deadline fleet get**
## Próximas etapas
Depois de criar sua fazenda, você pode executar o agente Deadline Cloud Worker nos hosts da sua frota para processar trabalhos. Consulte [Execute o agente Deadline Cloud Worker](run-worker.md).
# Execute o agente Deadline Cloud Worker
Antes de executar os trabalhos enviados para a fila em seu farm de desenvolvedores, você deve executar o agente de trabalho do AWS Deadline Cloud no modo desenvolvedor em um host de trabalho.
Durante o restante deste tutorial, você executará AWS CLI operações em seu farm de desenvolvedores usando duas AWS CloudShell guias. Na primeira guia, você pode enviar trabalhos. Na segunda guia, você pode executar o agente de trabalho.
**nota**
Se você deixar sua CloudShell sessão ociosa por mais de 20 minutos, o tempo limite será atingido e o agente de trabalho será interrompido. Para reiniciar o agente de trabalho, siga as instruções no procedimento a seguir.
Antes de iniciar um agente de trabalho, você deve configurar uma fazenda, uma fila e uma frota do Deadline Cloud. Consulte [Crie um Deadline Cloud Farm](create-a-farm.md).
**Para executar o agente de trabalho no modo de desenvolvedor**
1. Com sua fazenda ainda aberta na primeira CloudShell guia, abra uma segunda CloudShell guia `demoenv-logs` e crie os `demoenv-persist` diretórios e.
```
mkdir ~/demoenv-logs
mkdir ~/demoenv-persist
```
1. Baixe e instale os pacotes do agente Deadline Cloud Worker do PyPI:
**nota**
Ativado Windows, é necessário que os arquivos do agente sejam instalados no diretório global de pacotes de sites do Python. Atualmente, não há suporte para ambientes virtuais Python.
```
python -m pip install deadline-cloud-worker-agent
```
1. Para permitir que o agente de trabalho crie os diretórios temporários para execução de trabalhos, crie um diretório:
```
sudo mkdir /sessions
sudo chmod 750 /sessions
sudo chown cloudshell-user /sessions
```
1. Execute o agente Deadline Cloud Worker no modo de desenvolvedor com as variáveis `DEV_FARM_ID` e `DEV_CMF_ID` que você adicionou ao`~/.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
```
Conforme o agente de trabalho inicializa e, em seguida, pesquisa a operação da `UpdateWorkerSchedule` API, a seguinte saída é exibida:
```
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. Selecione sua primeira CloudShell guia e, em seguida, liste os trabalhadores da frota.
```
deadline worker list --fleet-id $DEV_CMF_ID
```
Uma saída como a seguinte é exibida:
```
Displaying 1 of 1 workers starting at 0
- workerId: worker-8c9af877c8734e89914047111f
status: STARTED
createdAt: 2023-12-13 20:43:06+00:00
```
Em uma configuração de produção, o agente do Deadline Cloud Worker exige a configuração de vários usuários e diretórios de configuração como usuário administrativo na máquina host. Você pode substituir essas configurações porque está executando trabalhos em sua própria fazenda de desenvolvimento, que somente você pode acessar.
## Próximas etapas
Agora que um agente de trabalho está sendo executado em seus hosts de trabalhadores, você pode enviar trabalhos para seus trabalhadores. É possível:
+ [Envie com o Deadline Cloud](submit-a-job.md)usando um pacote de tarefas simples do OpenJD.
+ [Envie vagas com anexos de vagas no Deadline Cloud](run-jobs-job-attachments.md)que compartilham arquivos entre estações de trabalho usando sistemas operacionais diferentes.
# Envie com o Deadline Cloud
Para executar trabalhos do Deadline Cloud em seus hosts de trabalho, você cria e usa um pacote de trabalhos do Open Job Description (OpenJD) para configurar um trabalho. O pacote configura o trabalho, por exemplo, especificando arquivos de entrada para um trabalho e onde gravar a saída do trabalho. Este tópico inclui exemplos de maneiras pelas quais você pode configurar um pacote de tarefas.
Antes de seguir os procedimentos desta seção, você deve concluir o seguinte:
+ [Crie um Deadline Cloud Farm](create-a-farm.md)
+ [Execute o agente Deadline Cloud Worker](run-worker.md)
Para usar o AWS Deadline Cloud para executar trabalhos, use os procedimentos a seguir. Use a primeira AWS CloudShell guia para enviar trabalhos para sua fazenda de desenvolvedores. Use a segunda CloudShell guia para visualizar a saída do agente de trabalho.
**Topics**
+ [Envie a simple\$1job amostra](#submit-a-simplejob-sample)
+ [Envie um simple\$1job com um parâmetro](#submit-with-parameter)
+ [Crie um pacote de tarefas simple\$1file\$1job com E/S de arquivo](#create-job-bundle-with-file-io)
+ [Próximas etapas](#submit-a-job-next)
## Envie a simple\$1job amostra
Depois de criar uma fazenda e executar o agente de trabalho, você pode enviar a simple\$1job amostra para o Deadline Cloud.
**Para enviar a simple\$1job amostra para o Deadline Cloud**
1. Escolha sua primeira CloudShell guia.
1. Faça o download da amostra em GitHub.
```
cd ~
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Navegue até o diretório de amostras do pacote de tarefas.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Envie a simple\$1job amostra.
```
deadline bundle submit simple_job
```
1. Escolha sua segunda CloudShell guia para ver a saída de registro sobre chamadas`BatchGetJobEntities`, obtenção de uma sessão e execução de uma ação de sessão.
```
...
[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**
Somente a saída de registro do agente de trabalho é mostrada. Há um registro separado para a sessão que executa o trabalho.
1. Escolha sua primeira guia e, em seguida, inspecione os arquivos de log que o agente de trabalho grava.
1. Navegue até o diretório de registros do agente de trabalho e visualize seu conteúdo.
```
cd ~/demoenv-logs
ls
```
1. Imprima o primeiro arquivo de log criado pelo agente de trabalho.
```
cat worker-agent-bootstrap.log
```
Esse arquivo contém a saída do agente de trabalho sobre como ele chamou a API Deadline Cloud para criar um recurso de trabalhador em sua frota e, em seguida, assumiu a função de frota.
1. Imprima a saída do arquivo de log quando o agente de trabalho se junta à frota.
```
cat worker-agent.log
```
Esse registro contém saídas sobre todas as ações que o agente de trabalho executa, mas não contém saídas sobre as filas a partir das quais ele executa trabalhos, exceto esses IDs recursos.
1. Imprima os arquivos de log de cada sessão em um diretório com o mesmo nome do ID do recurso da fila.
```
cat $DEV_QUEUE_ID/session-*.log
```
Se o trabalho for bem-sucedido, a saída do arquivo de log será semelhante à seguinte:
```
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 informações sobre o trabalho.
```
deadline job get
```
Quando você envia o trabalho, o sistema o salva como padrão para que você não precise inserir o ID do trabalho.
## Envie um simple\$1job com um parâmetro
Você pode enviar trabalhos com parâmetros. No procedimento a seguir, você edita o simple\$1job modelo para incluir uma mensagem personalizada, envia a simple\$1job e imprime o arquivo de log da sessão para visualizar a mensagem.
**Para enviar a simple\$1job amostra com um parâmetro**
1. Selecione sua primeira CloudShell guia e, em seguida, navegue até o diretório de amostras do pacote de tarefas.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Imprima o conteúdo do simple\$1job modelo.
```
cat simple_job/template.yaml
```
A `parameterDefinitions` seção com o `Message` parâmetro deve ter a seguinte aparência:
```
parameterDefinitions:
- name: Message
type: STRING
default: Welcome to AWS Deadline Cloud!
```
1. Envie a simple\$1job amostra com um valor de parâmetro e aguarde a conclusão da execução do trabalho.
```
deadline bundle submit simple_job \
-p "Message=Greetings from the developer getting started guide."
```
1. Para ver a mensagem personalizada, veja o arquivo de registro da sessão mais recente.
```
cd ~/demoenv-logs
cat $DEV_QUEUE_ID/$(ls -t $DEV_QUEUE_ID | head -1)
```
## Crie um pacote de tarefas simple\$1file\$1job com E/S de arquivo
Um trabalho de renderização precisa ler a definição da cena, renderizar uma imagem a partir dela e depois salvar essa imagem em um arquivo de saída. Você pode simular essa ação fazendo com que o trabalho calcule o hash da entrada em vez de renderizar uma imagem.
**Para criar um pacote de tarefas simple\$1file\$1job com E/S de arquivo**
1. Selecione sua primeira CloudShell guia e, em seguida, navegue até o diretório de amostras do pacote de tarefas.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Faça uma cópia do `simple_job` com o novo nome`simple_file_job`.
```
cp -r simple_job simple_file_job
```
1. Edite o modelo de trabalho da seguinte forma:
**nota**
Recomendamos que você use nano essas etapas. Se você preferir usarVim, defina o modo de colagem usando`:set paste`.
1. Abra o modelo em um editor de texto.
```
nano simple_file_job/template.yaml
```
1. Adicione o seguinte `type``objectType`, `dataFlow` `parameterDefinitions` e.
```
- name: InFile
type: PATH
objectType: FILE
dataFlow: IN
- name: OutFile
type: PATH
objectType: FILE
dataFlow: OUT
```
1. Adicione o seguinte comando de `bash` script ao final do arquivo que lê o arquivo de entrada e grava no arquivo de saída.
```
# hash the input file, and write that to the output
sha256sum "{{Param.InFile}}" > "{{Param.OutFile}}"
```
A atualização `template.yaml` deve corresponder exatamente ao seguinte:
```
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 você quiser ajustar o espaçamento no`template.yaml`, certifique-se de usar espaços em vez de recuos.
1. Salve o arquivo e saia do editor de texto.
1. Forneça valores de parâmetros para os arquivos de entrada e saída para enviar o simple\$1file\$1job.
```
deadline bundle submit simple_file_job \
-p "InFile=simple_job/template.yaml" \
-p "OutFile=hash.txt"
```
1. Imprima informações sobre o trabalho.
```
deadline job get
```
+ Você verá uma saída como a seguinte:
```
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
```
+ Embora você tenha fornecido somente caminhos relativos, os parâmetros têm o caminho completo definido. O AWS CLI une o diretório de trabalho atual a todos os caminhos fornecidos como parâmetros quando os caminhos têm o tipo`PATH`.
+ O agente de trabalho em execução na outra janela do terminal pega e executa o trabalho. Essa ação cria o `hash.txt` arquivo, que você pode visualizar com o comando a seguir.
```
cat hash.txt
```
Esse comando imprimirá uma saída semelhante à seguinte.
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/simple_job/template.yaml
```
## Próximas etapas
Depois de aprender a enviar trabalhos simples usando a CLI do Deadline Cloud, você pode explorar:
+ [Envie vagas com anexos de vagas no Deadline Cloud](run-jobs-job-attachments.md)para aprender a executar trabalhos em hosts que executam sistemas operacionais diferentes.
+ [Adicione uma frota gerenciada por serviços à sua fazenda de desenvolvedores no Deadline Cloud](service-managed-fleet.md)para executar seus trabalhos em hosts gerenciados pelo Deadline Cloud.
+ [Limpe os recursos da sua fazenda no Deadline Cloud](cleaning-up.md)para encerrar os recursos que você usou neste tutorial.
# Envie vagas com anexos de vagas no Deadline Cloud
Muitas fazendas usam sistemas de arquivos compartilhados para compartilhar arquivos entre os hosts que enviam trabalhos e aqueles que executam trabalhos. Por exemplo, no `simple_file_job` exemplo anterior, o sistema de arquivos local é compartilhado entre as janelas do AWS CloudShell terminal, que são executadas na guia um, na qual você envia o trabalho, e na guia dois, na qual você executa o agente de trabalho.
Um sistema de arquivos compartilhado é vantajoso quando a estação de trabalho remetente e os hosts do trabalhador estão na mesma rede local. Se você armazena seus dados no local próximo às estações de trabalho que os acessam, usar um farm baseado em nuvem significa que você precisa compartilhar seus sistemas de arquivos por meio de uma VPN de alta latência ou sincronizar seus sistemas de arquivos na nuvem. Nenhuma dessas opções é fácil de configurar ou operar.
AWS O Deadline Cloud oferece uma solução simples com *anexos de trabalho, que são semelhantes aos anexos* de e-mail. Com os anexos do trabalho, você anexa dados ao seu trabalho. Em seguida, o Deadline Cloud trata dos detalhes da transferência e armazenamento dos dados do seu trabalho nos buckets do Amazon Simple Storage Service (Amazon S3).
Os fluxos de trabalho de criação de conteúdo geralmente são iterativos, o que significa que um usuário envia trabalhos com um pequeno subconjunto de arquivos modificados. Como os buckets do Amazon S3 armazenam anexos de trabalho em um armazenamento endereçável por conteúdo, o nome de cada objeto é baseado no hash dos dados do objeto e o conteúdo de uma árvore de diretórios é armazenado em um formato de arquivo manifesto anexado a um trabalho.
Antes de seguir os procedimentos desta seção, você deve concluir o seguinte:
+ [Crie um Deadline Cloud Farm](create-a-farm.md)
+ [Execute o agente Deadline Cloud Worker](run-worker.md)
Para executar trabalhos com anexos de trabalhos, conclua as etapas a seguir.
**Topics**
+ [Adicione uma configuração de anexos de tarefas à sua fila](#job-attachments-config)
+ [Envie simple\$1file\$1job com anexos de emprego](#submit-job-attachments)
+ [Entendendo como os anexos de trabalho são armazenados no Amazon S3](#job-attachments-in-depth)
+ [Próximas etapas](#run-jobs-job-attachments-next)
## Adicione uma configuração de anexos de tarefas à sua fila
Para habilitar anexos de trabalhos em sua fila, adicione uma configuração de anexos de trabalhos ao recurso de fila em sua conta.
**Para adicionar uma configuração de anexos de tarefas à sua fila**
1. Escolha sua primeira CloudShell guia e, em seguida, insira um dos seguintes comandos para usar um bucket do Amazon S3 para anexos de trabalhos.
+ Se você não tiver um bucket Amazon S3 privado existente, você pode criar e usar um novo 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 você já tem um bucket privado do Amazon S3, você pode usá-lo *`MY_BUCKET_NAME`* substituindo-o pelo nome do seu bucket.
```
DEV_FARM_BUCKET=MY_BUCKET_NAME
```
1. Depois de criar ou escolher seu bucket do Amazon S3, adicione o nome do bucket `~/.bashrc` para disponibilizá-lo para outras sessões do terminal.
```
echo "DEV_FARM_BUCKET=$DEV_FARM_BUCKET" >> ~/.bashrc
source ~/.bashrc
```
1. Crie uma função AWS Identity and Access Management (IAM) para a fila.
```
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. Atualize sua fila para incluir as configurações de anexos do trabalho e a função do 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 se você atualizou sua fila.
```
deadline queue get
```
Uma saída como a seguinte é mostrada:
```
...
jobAttachmentSettings:
s3BucketName: DEV_FARM_BUCKET
rootPrefix: JobAttachments
roleArn: arn:aws:iam::ACCOUNT_NUMBER:role/DeveloperFarmQueueRole
...
```
## Envie simple\$1file\$1job com anexos de emprego
Quando você usa anexos de tarefas, os pacotes de tarefas devem fornecer ao Deadline Cloud informações suficientes para determinar o fluxo de dados da tarefa, como o uso de parâmetros. `PATH` No caso dosimple\$1file\$1job, você editou o `template.yaml` arquivo para informar ao Deadline Cloud que o fluxo de dados está no arquivo de entrada e no arquivo de saída.
Depois de adicionar a configuração dos anexos do trabalho à sua fila, você pode enviar a amostra simple\$1file\$1job com os anexos do trabalho. Depois de fazer isso, você pode visualizar o registro e a saída do trabalho para confirmar se o simple\$1file\$1job com anexos do trabalho está funcionando.
**Para enviar o pacote de tarefas simple\$1file\$1job com anexos de tarefas**
1. Escolha sua primeira CloudShell guia e abra o `JobBundle-Samples` diretório.
1.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Envie simple\$1file\$1job para a fila. Quando solicitado a confirmar o upload, insira**y**.
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. Para visualizar a saída do log da sessão de transferência de dados dos anexos do trabalho, execute o comando a seguir.
```
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. Liste as ações da sessão que foram executadas na sessão.
```
aws deadline list-session-actions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--session-id $SESSION_ID
```
Uma saída como a seguinte é mostrada:
```
{
"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"
}
}
}
]
}
```
A primeira ação da sessão baixou os anexos do trabalho de entrada, enquanto a segunda ação executa a tarefa como nas etapas anteriores e, em seguida, carregou os anexos do trabalho de saída.
1. Liste o diretório de saída.
```
ls *.txt
```
Uma saída como a `hash.txt` que existe no diretório, mas `hash-jobattachments.txt` não existe porque o arquivo de saída da tarefa ainda não foi baixado.
1. Baixe a saída do trabalho mais recente.
```
deadline job download-output
```
1. Visualize a saída do arquivo baixado.
```
cat hash-jobattachments.txt
```
Uma saída como a seguinte é mostrada:
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## Entendendo como os anexos de trabalho são armazenados no Amazon S3
Você pode usar o AWS Command Line Interface (AWS CLI) para carregar ou baixar dados para anexos de tarefas, que são armazenados em buckets do Amazon S3. Entender como o Deadline Cloud armazena anexos de trabalhos no Amazon S3 ajudará você a desenvolver cargas de trabalho e integrações de pipeline.
**Para inspecionar como os anexos de trabalho do Deadline Cloud são armazenados no Amazon S3**
1. Escolha sua primeira CloudShell guia e, em seguida, abra o diretório de amostras do pacote de tarefas.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Inspecione as propriedades do trabalho.
```
deadline job get
```
Uma saída como a seguinte é mostrada:
```
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
```
O campo de anexos contém uma lista de estruturas de manifesto que descrevem os caminhos de dados de entrada e saída que a tarefa usa quando é executada. Veja `rootPath` o caminho do diretório local na máquina que enviou o trabalho. Para visualizar o sufixo do objeto Amazon S3 que contém um arquivo de manifesto, revise o. `inputManifestFile` O arquivo de manifesto contém metadados para um instantâneo da árvore de diretórios dos dados de entrada do trabalho.
1. Imprima bem o objeto de manifesto do Amazon S3 para ver a estrutura do diretório de entrada para o trabalho.
```
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 .
```
Uma saída como a seguinte é mostrada:
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "2ec297b04c59c4741ed97ac8fb83080c",
"mtime": 1698186190000000,
"path": "simple_job/template.yaml",
"size": 445
}
],
"totalSize": 445
}
```
1. Crie o prefixo do Amazon S3 que contém manifestos para os anexos do trabalho de saída e liste o objeto abaixo dele.
```
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
```
Os anexos do trabalho de saída não são referenciados diretamente do recurso de trabalho, mas são colocados em um bucket do Amazon S3 com base no recurso da fazenda. IDs
1. Obtenha a chave de objeto de manifesto mais recente para o ID de ação de sessão específico e, em seguida, imprima bem os objetos do 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 .
```
Você verá propriedades do arquivo `hash-jobattachments.txt` na saída, como as seguintes:
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "f60b8e7d0fabf7214ba0b6822e82e08b",
"mtime": 1698785252554950,
"path": "hash-jobattachments.txt",
"size": 182
}
],
"totalSize": 182
}
```
Seu trabalho terá apenas um único objeto manifesto por tarefa executada, mas, em geral, é possível ter mais objetos por tarefa executada.
1. Visualize a saída de armazenamento do Amazon S3 endereçável ao conteúdo sob o prefixo. `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 -
```
Uma saída como a seguinte é mostrada:
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## Próximas etapas
Depois de aprender a enviar trabalhos com anexos usando a CLI do Deadline Cloud, você pode explorar:
+ [Envie com o Deadline Cloud](submit-a-job.md)para aprender a executar trabalhos usando um pacote OpenJD em seus hosts de trabalho.
+ [Adicione uma frota gerenciada por serviços à sua fazenda de desenvolvedores no Deadline Cloud](service-managed-fleet.md)para executar seus trabalhos em hosts gerenciados pelo Deadline Cloud.
+ [Limpe os recursos da sua fazenda no Deadline Cloud](cleaning-up.md)para encerrar os recursos que você usou neste tutorial.
# Adicione uma frota gerenciada por serviços à sua fazenda de desenvolvedores no Deadline Cloud
AWS CloudShell não fornece capacidade computacional suficiente para testar cargas de trabalho maiores. Também não está configurado para funcionar com trabalhos que distribuem tarefas em vários hosts de trabalho.
Em vez de usar CloudShell, você pode adicionar uma frota gerenciada por serviços (SMF) do Auto Scaling à sua fazenda de desenvolvedores. Um SMF fornece capacidade computacional suficiente para cargas de trabalho maiores e pode lidar com trabalhos que precisam distribuir tarefas de trabalho em vários hosts de trabalho.
Antes de adicionar um SMF, você deve configurar uma fazenda, uma fila e uma frota do Deadline Cloud. Consulte [Crie um Deadline Cloud Farm](create-a-farm.md).
**Para adicionar uma frota gerenciada por serviços à sua fazenda de desenvolvedores**
1. Escolha sua primeira AWS CloudShell guia e, em seguida, crie a frota gerenciada pelo serviço e adicione sua ID de frota a. `.bashrc` Essa ação o torna disponível para outras sessões do 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. Associe o SMF à sua fila.
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_SMF_ID
```
1. Envie simple\$1file\$1job para a fila. Quando solicitado a confirmar o upload, insira**y**.
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. Confirme se o SMF está funcionando corretamente.
```
deadline fleet get
```
+ O trabalhador pode levar alguns minutos para começar. Repita o `deadline fleet get` comando até ver que a frota está funcionando.
+ A frota `queueFleetAssociationsStatus` de quatro serviços gerenciados será. `ACTIVE`
+ O SMF `autoScalingStatus` mudará de `GROWING` para`STEADY`.
Seu status será semelhante ao seguinte:
```
fleetId: fleet-2cc78e0dd3f04d1db427e7dc1d51ea44
farmId: farm-63ee8d77cdab4a578b685be8c5561c4a
displayName: DeveloperFarm SMF
description: ''
status: ACTIVE
autoScalingStatus: STEADY
targetWorkerCount: 0
workerCount: 0
minWorkerCount: 0
maxWorkerCount: 5
```
1. Visualize o registro do trabalho que você enviou. Esse log é armazenado em um log no Amazon CloudWatch Logs, não no sistema de CloudShell arquivos.
```
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
```
## Próximas etapas
Depois de criar e testar uma frota gerenciada por serviços, você deve remover os recursos que criou para evitar cobranças desnecessárias.
+ [Limpe os recursos da sua fazenda no Deadline Cloud](cleaning-up.md)para encerrar os recursos que você usou neste tutorial.
# Limpe os recursos da sua fazenda no Deadline Cloud
Para desenvolver e testar novas cargas de trabalho e integrações de pipeline, você pode continuar usando o farm de desenvolvedores do Deadline Cloud que você criou para este tutorial. Se você não precisar mais da sua fazenda de desenvolvedores, poderá excluir seus recursos, incluindo fazenda, frota, fila, funções AWS Identity and Access Management (IAM) e registros no Amazon CloudWatch Logs. Depois de excluir esses recursos, você precisará começar o tutorial novamente para usar os recursos. Para obter mais informações, consulte [Introdução aos recursos do Deadline Cloud](getting-started.md).
**Para limpar os recursos da fazenda de desenvolvedores**
1. Escolha sua primeira CloudShell guia e, em seguida, interrompa todas as associações de filas e frotas da sua fila.
```
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. Liste as associações de frotas de filas.
```
aws deadline list-queue-fleet-associations \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
Talvez seja necessário executar novamente o comando até que a saída seja reportada e, em seguida`"status": "STOPPED"`, você pode prosseguir para a próxima etapa. O processo pode demorar vários minutos para ser concluído.
```
{
"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. Exclua todas as associações de filas e frotas da sua fila.
```
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. Exclua todas as frotas associadas à sua fila.
```
for FLEET_ID in $FLEETS; do
aws deadline delete-fleet \
--farm-id $DEV_FARM_ID \
--fleet-id $FLEET_ID
done
```
1. Exclua a fila.
```
aws deadline delete-queue \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
1. Exclua a fazenda.
```
aws deadline delete-farm \
--farm-id $DEV_FARM_ID
```
1. Exclua outros AWS recursos da sua fazenda.
1. Exclua a função de frota 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. Exclua a função do IAM da fila.
```
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. Exclua os grupos de CloudWatch log do Amazon Logs. Cada fila e frota tem seu próprio 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"
```