本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# Deadline Cloud 资源入门
要开始为 De AWS adline Cloud 创建自定义解决方案，您必须设置资源。其中包括农场、服务器场的至少一个队列以及为队列提供服务的至少一个工作人员车队。您可以使用 Deadline Cloud 控制台创建资源，也可以使用 AWS Command Line Interface。
在本教程中，您将使用 AWS CloudShell 创建一个简单的开发者群组并运行工作器代理。然后，您可以提交并运行带有参数和附件的简单作业，添加服务托管队列，并在完成后清理农场资源。
以下各节将向您介绍 Deadline Cloud 的不同功能，以及它们是如何运作和协同工作的。遵循这些步骤对于开发和测试新的工作负载和自定义项非常有用。
有关使用控制台设置服务器场的说明，请参阅 De *adline Cloud 用户指南*中的[入门](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/getting-started.html)。
**Topics**
+ [创建截止日期云场](create-a-farm.md)
+ [运行 Deadline 云端工作者代理](run-worker.md)
+ [使用截止日期云提交](submit-a-job.md)
+ [在 Deadline Cloud 中提交带有作业附件的工作](run-jobs-job-attachments.md)
+ [在 Deadline Cloud 中向你的开发者群添加服务管理队列](service-managed-fleet.md)
+ [在 Deadline Cloud 中清理农场资源](cleaning-up.md)
# 创建截止日期云场
要在 De AWS adline Cloud 中创建开发者群和队列资源，请使用 AWS Command Line Interface (AWS CLI)，如以下过程所示。您还将创建一个 AWS Identity and Access Management (IAM) 角色和一个客户管理的队列 (CMF)，并将队列与您的队列关联。然后，您可以配置 AWS CLI 并确认您的服务器场已按指定设置并正常运行。
您可以使用此服务器场来探索 Deadline Cloud 的功能，然后开发和测试新的工作负载、自定义项和管道集成。
**创建农场**
1. [打开会 AWS CloudShell 话](https://console.aws.amazon.com/cloudshell/home?region=us-west-2)。您将使用 CloudShell 窗口输入 AWS Command Line Interface (AWS CLI) 命令来运行本教程中的示例。继续操作时，请保持 CloudShell 窗口处于打开状态。
1. 为您的农场创建一个名称，然后将该农场名称添加到`~/.bashrc`。这将使其可用于其他终端会话。
```
echo "DEV_FARM_NAME=DeveloperFarm" >> ~/.bashrc
source ~/.bashrc
```
1. 创建服务器场资源，并将其场 ID 添加到`~/.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. 创建队列资源，并将其队列 ID 添加到 `~/.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. 为舰队创建 IAM 角色。此角色为队列中的工作人员主机提供必要的安全证书，以便在队列中运行作业。
```
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. 创建客户管理的队列 (CMF)，并将其队列 ID 添加到。`~/.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. 将 CMF 与您的队列关联。
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_CMF_ID
```
1. 安装 Deadline Cloud 命令行界面。
```
pip install deadline
```
1. 要将默认场设置为场 ID，将队列设置为之前创建的队列 ID，请使用以下命令。
```
deadline config set defaults.farm_id $DEV_FARM_ID
deadline config set defaults.queue_id $DEV_QUEUE_ID
```
1. （可选）要确认您的服务器场是否按照您的规格进行设置，请使用以下命令：
+ 列出所有农场 — **deadline farm list**
+ 列出默认服务器场中的所有队列 — **deadline queue list**
+ 列出默认服务器场中的所有舰队 — **deadline fleet list**
+ 获取默认农场 — **deadline farm get**
+ 获取默认队列 — **deadline queue get**
+ 获取所有与默认队列关联的舰队 — **deadline fleet get**
## 后续步骤
创建服务器场后，您可以在队列中的主机上运行 Deadline Cloud 工作代理来处理作业。请参阅[运行 Deadline 云端工作者代理](run-worker.md)。
# 运行 Deadline 云端工作者代理
必须先在工作服务器主机上以开发者模式运行 De AWS adline Cloud 工作器代理，然后才能在开发者群中运行提交到队列的作业。
在本教程的其余部分中，您将使用两个 AWS CloudShell 选项卡在开发者群中执行 AWS CLI 操作。在第一个选项卡中，您可以提交作业。在第二个选项卡中，您可以运行工作器代理。
**注意**
如果您的 CloudShell 会话闲置时间超过 20 分钟，则会话将超时并停止工作器代理。要重新启动工作器代理，请按照以下过程中的说明进行操作。
在启动工作人员代理之前，必须先设置 Deadline Cloud 场、队列和队列。请参阅[创建截止日期云场](create-a-farm.md)。
**在开发者模式下运行工作器代理**
1. 当您的农场在第一个 CloudShell 选项卡中仍处于打开状态时，打开第二个 CloudShell 选项卡，然后创建`demoenv-logs`和`demoenv-persist`目录。
```
mkdir ~/demoenv-logs
mkdir ~/demoenv-persist
```
1. 从 PyPI 下载并安装 Deadline Cloud 工作器代理包：
**注意**
On Windows，则需要将代理文件安装到 Python 的全局站点包目录中。目前不支持 Python 虚拟环境。
```
python -m pip install deadline-cloud-worker-agent
```
1. 要允许工作器代理为正在运行的作业创建临时目录，请创建一个目录：
```
sudo mkdir /sessions
sudo chmod 750 /sessions
sudo chown cloudshell-user /sessions
```
1. 使用您添加到的变量`DEV_FARM_ID`在开发者模式下运行 Deadline Cloud 工作器代理`~/.bashrc`。`DEV_CMF_ID`
```
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
```
当工作代理初始化然后轮询 `UpdateWorkerSchedule` API 操作时，将显示以下输出：
```
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. 选择您的第一个 CloudShell 选项卡，然后列出车队中的员工。
```
deadline worker list --fleet-id $DEV_CMF_ID
```
将显示如下输出：
```
Displaying 1 of 1 workers starting at 0
- workerId: worker-8c9af877c8734e89914047111f
status: STARTED
createdAt: 2023-12-13 20:43:06+00:00
```
在生产配置中，Deadline Cloud 工作器代理需要在主机上以管理用户的身份设置多个用户和配置目录。您可以覆盖这些设置，因为您在自己的开发场中运行作业，只有您可以访问这些开发场。
## 后续步骤
现在，您的工作器主机上正在运行工作器代理，您可以向您的工作人员发送作业。您可以：
+ [使用截止日期云提交](submit-a-job.md)使用一个简单的 OpenJD 工作包。
+ [在 Deadline Cloud 中提交带有作业附件的工作](run-jobs-job-attachments.md)它们在使用不同操作系统的工作站之间共享文件。
# 使用截止日期云提交
要在工作服务器主机上运行 Deadline Cloud 作业，您需要创建并使用 OpenJD 作业描述 (OpenJD) 任务包来配置作业。捆绑包配置作业，例如，通过指定作业的输入文件以及将作业输出写入何处。本主题包括配置任务捆绑包的方法示例。
在按照本节中的步骤进行操作之前，必须完成以下操作：
+ [创建截止日期云场](create-a-farm.md)
+ [运行 Deadline 云端工作者代理](run-worker.md)
要使用 De AWS adline Cloud 运行作业，请按以下步骤操作。使用第一个 AWS CloudShell 选项卡向您的开发者群提交作业。使用第二个 CloudShell 选项卡查看工作器代理的输出。
**Topics**
+ [提交simple\$1job样本](#submit-a-simplejob-sample)
+ [提交simple\$1job带有参数的](#submit-with-parameter)
+ [创建带有文件 I/O 的 simple\$1file\$1job 任务捆绑包](#create-job-bundle-with-file-io)
+ [后续步骤](#submit-a-job-next)
## 提交simple\$1job样本
创建服务器场并运行工作器代理后，您可以将simple\$1job示例提交到 Deadline Cloud。
**将simple\$1job样本提交到 Deadline Cloud**
1. 选择您的第一个 CloudShell 选项卡。
1. 从中下载示例 GitHub。
```
cd ~
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. 导航到任务捆绑包示例目录。
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. 提交simple\$1job样本。
```
deadline bundle submit simple_job
```
1. 选择第二个 CloudShell 选项卡可查看有关呼叫`BatchGetJobEntities`、获取会话和运行会话操作的日志输出。
```
...
[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]
...
```
**注意**
仅显示工作器代理的日志输出。运行作业的会话有一个单独的日志。
1. 选择第一个选项卡，然后检查工作器代理写入的日志文件。
1. 导航到工作器代理日志目录并查看其内容。
```
cd ~/demoenv-logs
ls
```
1. 打印工作器代理创建的第一个日志文件。
```
cat worker-agent-bootstrap.log
```
此文件包含工作人员代理输出，说明它如何调用 Deadline Cloud API 在您的队列中创建工作人员资源，然后担任队列角色。
1. 打印工作器代理加入队列时的日志文件输出。
```
cat worker-agent.log
```
此日志包含有关工作器代理执行的所有操作的输出，但不包含有关其运行作业的队列 IDs 的输出，但这些资源除外。
1. 在与队列资源 ID 同名的目录中打印每个会话的日志文件。
```
cat $DEV_QUEUE_ID/session-*.log
```
如果作业成功，则日志文件输出将类似于以下内容：
```
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. 打印有关作业的信息。
```
deadline job get
```
提交作业时，系统会将其保存为默认值，因此您无需输入作业 ID。
## 提交simple\$1job带有参数的
您可以提交带有参数的作业。在以下步骤中，您可以编辑simple\$1job模板以包含自定义消息，提交simple\$1job，然后打印会话日志文件以查看消息。
**提交带参数的simple\$1job示例**
1. 选择您的第一个 CloudShell 选项卡，然后导航到任务捆绑包示例目录。
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. 打印simple\$1job模板的内容。
```
cat simple_job/template.yaml
```
带有`Message`参数的`parameterDefinitions`部分应如下所示：
```
parameterDefinitions:
- name: Message
type: STRING
default: Welcome to AWS Deadline Cloud!
```
1. 提交带有参数值的simple\$1job示例，然后等待任务完成运行。
```
deadline bundle submit simple_job \
-p "Message=Greetings from the developer getting started guide."
```
1. 要查看自定义消息，请查看最新的会话日志文件。
```
cd ~/demoenv-logs
cat $DEV_QUEUE_ID/$(ls -t $DEV_QUEUE_ID | head -1)
```
## 创建带有文件 I/O 的 simple\$1file\$1job 任务捆绑包
渲染作业需要读取场景定义，从中渲染图像，然后将该图像保存到输出文件中。您可以通过让作业计算输入的哈希值而不是渲染图像来模拟此操作。
**创建带有文件 I/O 的 simple\$1file\$1job 任务捆绑包**
1. 选择您的第一个 CloudShell 选项卡，然后导航到任务捆绑包示例目录。
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. 用新名称制作一份副本`simple_file_job`。`simple_job`
```
cp -r simple_job simple_file_job
```
1. 按如下方式编辑作业模板：
**注意**
我们建议您使用nano这些步骤。如果您更喜欢使用Vim，则必须使用设置其粘贴模式`:set paste`。
1. 在文本编辑器中打开模板。
```
nano simple_file_job/template.yaml
```
1. 添加以下内容`type``objectType`、和`dataFlow``parameterDefinitions`。
```
- name: InFile
type: PATH
objectType: FILE
dataFlow: IN
- name: OutFile
type: PATH
objectType: FILE
dataFlow: OUT
```
1. 将以下`bash`脚本命令添加到文件末尾，该命令从输入文件读取并写入输出文件。
```
# hash the input file, and write that to the output
sha256sum "{{Param.InFile}}" > "{{Param.OutFile}}"
```
更新后的内容`template.yaml`应与以下内容完全匹配：
```
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}}"
```
**注意**
如果要调整中的间距`template.yaml`，请确保使用空格而不是缩进。
1. 保存文件，然后退出文本编辑器。
1. 为输入和输出文件提供参数值以提交 simple\$1file\$1job。
```
deadline bundle submit simple_file_job \
-p "InFile=simple_job/template.yaml" \
-p "OutFile=hash.txt"
```
1. 打印有关作业的信息。
```
deadline job get
```
+ 您将看到如下输出：
```
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
```
+ 尽管您只提供了相对路径，但参数设置了完整路径。将当前工作目录与作为参数提供的任何路径 AWS CLI 连接起来，而这些路径的类型为该路径`PATH`。
+ 在另一个终端窗口中运行的工作器代理接起并运行作业。此操作将创建`hash.txt`文件，您可以使用以下命令查看该文件。
```
cat hash.txt
```
此命令将打印类似于以下内容的输出。
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/simple_job/template.yaml
```
## 后续步骤
在学习了如何使用 Deadline Cloud CLI 提交简单作业后，您可以探索：
+ [在 Deadline Cloud 中提交带有作业附件的工作](run-jobs-job-attachments.md)学习如何在运行不同操作系统的主机上运行作业。
+ [在 Deadline Cloud 中向你的开发者群添加服务管理队列](service-managed-fleet.md)在由 Deadline Cloud 管理的主机上运行作业。
+ [在 Deadline Cloud 中清理农场资源](cleaning-up.md)关闭您在本教程中使用的资源。
# 在 Deadline Cloud 中提交带有作业附件的工作
许多服务器场使用共享文件系统在提交作业的主机和运行作业的主机之间共享文件。例如，在前面的`simple_file_job`示例中，本地文件系统在终端窗口之间共享， AWS CloudShell 终端窗口在您提交作业的选项卡一和运行工作代理的选项卡二中运行。
当提交者工作站和工作主机位于同一个局域网中时，共享文件系统更具优势。如果您将数据存储在本地访问数据的工作站附近，那么使用基于云的服务器场意味着您必须通过高延迟 VPN 共享文件系统或在云中同步文件系统。这两个选项都不容易设置或操作。
AWS Deadline Cloud 提供了一个带有*作业附件*的简单解决方案，类似于电子邮件附件。使用作业附件，您可以将数据附加到作业中。然后，Deadline Cloud 会处理在亚马逊简单存储服务 (Amazon S3) 存储桶中传输和存储任务数据的细节。
内容创建工作流程通常是迭代的，这意味着用户提交作业时会包含一小部分修改过的文件。由于 Amazon S3 存储桶将任务附件存储在内容可寻址的存储中，因此每个对象的名称都基于对象数据的哈希值，并且目录树的内容以任务所附的清单文件格式存储。
在按照本节中的步骤进行操作之前，必须完成以下操作：
+ [创建截止日期云场](create-a-farm.md)
+ [运行 Deadline 云端工作者代理](run-worker.md)
要运行带有作业附件的作业，请完成以下步骤。
**Topics**
+ [向队列中添加作业附件配置](#job-attachments-config)
+ [提交simple\$1file\$1job时附上工作附件](#submit-job-attachments)
+ [了解任务附件在 Amazon S3 中的存储方式](#job-attachments-in-depth)
+ [后续步骤](#run-jobs-job-attachments-next)
## 向队列中添加作业附件配置
要在队列中启用作业附件，请向账户中的队列资源添加作业附件配置。
**向队列中添加作业附件配置**
1. 选择您的第一个 CloudShell 选项卡，然后输入以下命令之一，使用 Amazon S3 存储桶存储任务附件。
+ 如果您没有现有的私有 Amazon S3 存储桶，则可以创建和使用新的 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}
```
+ 如果您已经拥有私有 Amazon S3 存储桶，则可以通过将其*`MY_BUCKET_NAME`*替换为存储桶的名称来使用它。
```
DEV_FARM_BUCKET=MY_BUCKET_NAME
```
1. 创建或选择 Amazon S3 存储桶后，将存储桶名称添加到`~/.bashrc`，以使该存储桶可用于其他终端会话。
```
echo "DEV_FARM_BUCKET=$DEV_FARM_BUCKET" >> ~/.bashrc
source ~/.bashrc
```
1. 为队列创建 AWS Identity and Access Management (IAM) 角色。
```
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. 更新您的队列以包含任务附件设置和 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. 确认您已更新队列。
```
deadline queue get
```
输出如下所示：
```
...
jobAttachmentSettings:
s3BucketName: DEV_FARM_BUCKET
rootPrefix: JobAttachments
roleArn: arn:aws:iam::ACCOUNT_NUMBER:role/DeveloperFarmQueueRole
...
```
## 提交simple\$1file\$1job时附上工作附件
使用作业附件时，任务捆绑包必须为 Deadline Cloud 提供足够的信息，以确定作业的数据流，例如使用`PATH`参数。如果是simple\$1file\$1job，您编辑`template.yaml`文件是为了告诉 Deadline Cloud 数据流在输入文件和输出文件中。
将作业附件配置添加到队列后，您可以提交带有作业附件的 simple\$1file\$1job 示例。完成此操作后，您可以查看日志记录和作业输出，以确认simple\$1file\$1job带有作业附件的运行正常。
**提交带有作业附件的 simple\$1file\$1job 任务捆绑包**
1. 选择您的第一个 CloudShell 选项卡，然后打开该`JobBundle-Samples`目录。
1.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. 将 simple\$1file\$1job 提交到队列。当系统提示您确认上传时，请输入**y**。
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. 要查看作业附件数据传输会话日志输出，请运行以下命令。
```
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. 列出在会话中运行的会话操作。
```
aws deadline list-session-actions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--session-id $SESSION_ID
```
输出如下所示：
```
{
"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"
}
}
}
]
}
```
第一个会话操作下载了输入作业附件，而第二个操作则像前面的步骤一样运行任务，然后上传了输出作业附件。
1. 列出输出目录。
```
ls *.txt
```
例如，输出`hash.txt`存在于目录中，但`hash-jobattachments.txt`由于作业的输出文件尚未下载，因此不存在。
1. 下载最近作业的输出。
```
deadline job download-output
```
1. 查看已下载文件的输出。
```
cat hash-jobattachments.txt
```
输出如下所示：
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## 了解任务附件在 Amazon S3 中的存储方式
您可以使用 AWS Command Line Interface (AWS CLI) 上传或下载任务附件的数据，这些数据存储在 Amazon S3 存储桶中。了解 Deadline Cloud 如何在 Amazon S3 上存储作业附件将有助于您开发工作负载和管道集成。
**检查 Deadline Cloud 作业附件在 Amazon S3 中的存储方式**
1. 选择您的第一个 CloudShell 选项卡，然后打开任务捆绑包示例目录。
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. 检查作业属性。
```
deadline job get
```
输出如下所示：
```
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
```
附件字段包含清单结构列表，这些清单结构描述了作业运行时使用的输入和输出数据路径。查看`rootPath`提交作业的计算机上的本地目录路径。要查看包含清单文件的 Amazon S3 对象后缀，请查看。`inputManifestFile`清单文件包含任务输入数据的目录树快照的元数据。
1. 漂亮地打印 Amazon S3 清单对象以查看任务的输入目录结构。
```
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 .
```
输出如下所示：
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "2ec297b04c59c4741ed97ac8fb83080c",
"mtime": 1698186190000000,
"path": "simple_job/template.yaml",
"size": 445
}
],
"totalSize": 445
}
```
1. 构造用于保存输出任务附件清单的 Amazon S3 前缀，并在其下列出对象。
```
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
```
输出任务附件不是直接从任务资源中引用的，而是根据服务器场资源放置在 Amazon S3 存储桶中 IDs。
1. 获取特定会话操作 ID 的最新清单对象密钥，然后漂亮地打印清单对象。
```
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`中看到该文件的属性，如下所示：
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "f60b8e7d0fabf7214ba0b6822e82e08b",
"mtime": 1698785252554950,
"path": "hash-jobattachments.txt",
"size": 182
}
],
"totalSize": 182
}
```
每次运行任务时，您的作业只会有一个清单对象，但一般而言，每次运行的任务可能会有更多的对象。
1. 在前缀下查看可寻址内容的 Amazon S3 存储输出。`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 -
```
输出如下所示：
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## 后续步骤
在学习了如何使用 Deadline Cloud CLI 提交带有附件的作业后，您可以探索：
+ [使用截止日期云提交](submit-a-job.md)学习如何在工作主机上使用 OpenJD 捆绑包运行作业。
+ [在 Deadline Cloud 中向你的开发者群添加服务管理队列](service-managed-fleet.md)在由 Deadline Cloud 管理的主机上运行作业。
+ [在 Deadline Cloud 中清理农场资源](cleaning-up.md)关闭您在本教程中使用的资源。
# 在 Deadline Cloud 中向你的开发者群添加服务管理队列
AWS CloudShell 无法提供足够的计算容量来测试更大的工作负载。它也未配置为处理在多个工作主机上分配任务的作业。
您可以将 A CloudShell uto Scaling 服务托管队列 (SMF) 添加到您的开发者群中，而不必使用。SMF 为较大的工作负载提供了足够的计算容量，并且可以处理需要在多个工作主机上分配作业任务的作业。
在添加 SMF 之前，必须设置 Deadline Cloud 场、队列和队列。请参阅[创建截止日期云场](create-a-farm.md)。
**将服务托管队列添加到您的开发者群中**
1. 选择您的第一个 AWS CloudShell 选项卡，然后创建服务管理的队列并将其队列 ID 添加到。`.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 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. 将 SMF 与您的队列关联。
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_SMF_ID
```
1. 提交simple\$1file\$1job到队列。当系统提示您确认上传时，请输入**y**。
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. 确认 SMF 工作正常。
```
deadline fleet get
```
+ 工作人员可能需要几分钟才能开始。重复该`deadline fleet get`命令，直到您可以看到舰队正在运行。
+ `queueFleetAssociationsStatus`用于服务管理的舰队将是。`ACTIVE`
+ SMF `autoScalingStatus` 将从变`GROWING`为。`STEADY`
您的状态将类似于以下内容：
```
fleetId: fleet-2cc78e0dd3f04d1db427e7dc1d51ea44
farmId: farm-63ee8d77cdab4a578b685be8c5561c4a
displayName: DeveloperFarm SMF
description: ''
status: ACTIVE
autoScalingStatus: STEADY
targetWorkerCount: 0
workerCount: 0
minWorkerCount: 0
maxWorkerCount: 5
```
1. 查看您提交的作业的日志。此日志存储在 Amazon Logs 的 CloudWatch 日志中，而不是 CloudShell 文件系统中。
```
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
```
## 后续步骤
创建并测试服务托管队列后，应删除创建的资源，以避免不必要的费用。
+ [在 Deadline Cloud 中清理农场资源](cleaning-up.md)关闭您在本教程中使用的资源。
# 在 Deadline Cloud 中清理农场资源
要开发和测试新的工作负载和管道集成，您可以继续使用为本教程创建的 Deadline Cloud 开发者群组。如果您不再需要开发者群组，则可以删除其资源，包括场、队列、队列、 AWS Identity and Access Management (IAM) 角色和 Amazon Logs 中的 CloudWatch 日志。删除这些资源后，您需要重新开始本教程才能使用这些资源。有关更多信息，请参阅 [Deadline Cloud 资源入门](getting-started.md)。
**清理开发者农场资源**
1. 选择第一个 CloudShell 选项卡，然后停止队列的所有队列队列关联。
```
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. 列出队列队列关联。
```
aws deadline list-queue-fleet-associations \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
在输出报告之前，您可能需要重新运行该命令`"status": "STOPPED"`，然后才能继续下一步。此过程可能需要几分钟才能完成。
```
{
"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. 删除队列的所有队列队列关联。
```
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. 删除与您的队列关联的所有舰队。
```
for FLEET_ID in $FLEETS; do
aws deadline delete-fleet \
--farm-id $DEV_FARM_ID \
--fleet-id $FLEET_ID
done
```
1. 删除队列。
```
aws deadline delete-queue \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
1. 删除农场。
```
aws deadline delete-farm \
--farm-id $DEV_FARM_ID
```
1. 删除农场的其他 AWS 资源。
1. 删除舰队 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. 删除队列 IAM 角色。
```
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. 删除 Amazon CloudWatch 日志组。每个队列和队列都有自己的日志组。
```
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"
```