# @aws-cdk/aws-batch-alpha 中文文档

规范地址：https://npmcn.com/package/%40aws-cdk/aws-batch-alpha/

版本：2\.95\.1-alpha\.0
npm 元数据更新时间：2023-11-21T10:14:04.623Z
中文译文更新时间：2026-11-07T13:53:44.621Z
软件包许可：Apache-2\.0

本文由上游 README 翻译，可能存在偏差，请结合原文核对 API、命令与配置。版权与许可归原作者所有。

原始 npm 页面：https://www.npmjs.com/package/%40aws-cdk/aws-batch-alpha
原文对照：https://npmcn.com/package/%40aws-cdk/aws-batch-alpha/?lang=original
项目主页：https://github.com/aws/aws-cdk
源码仓库：https://github.com/aws/aws-cdk

弃用说明：This package has been stabilized and moved to aws-cdk-lib

## 关键信息（来自 npm 元数据）

- 包体积（解压后）：1.2 MB，35 个文件
- 模块格式：CommonJS
- TypeScript 类型：包内自带
- Node.js 要求：\>= 14\.15\.0
- 运行依赖：0 个
- peer 依赖：aws-cdk-lib 2\.95\.1，constructs ^10\.0\.0
- 首次发布：2021-10-13T18:38:13.374Z
- 最新版本发布：2023-09-09T01:43:20.284Z
- 近 30 天下载量：48463（2026-10-07 至 2026-11-05，npm 官方下载统计）
- 已发布版本数：139（近 12 个月 0 个）

## 中文简介

AWS 的 CDK 构造库: 批次

## 安装

```sh
npm install @aws-cdk/aws-batch-alpha
```

也可以使用：`pnpm add @aws-cdk/aws-batch-alpha`、`yarn add @aws-cdk/aws-batch-alpha`、`bun add @aws-cdk/aws-batch-alpha`

## README

# AWS 批量构造库

* * *

![cdk-constructs: Developer Preview](https://img.shields.io/badge/cdk--constructs-developer--preview-informational.svg?style=for-the-badge)

> 本单元中较高层次构件的API 位于 **开发者预览** 在他们之前 变得稳定。 我们只会做出突破性改变 解决意想不到的API问题 因此, 这些API不受约束 [语义版本](https://semver.org/),并打破更改 将在发布说明中宣布。 这意味着,当你可能使用它们, 你可能需要 更新此软件包更新版本时的源代码.

* * *

这个模块是 [AWS 云开发套件](https://github.com/aws/aws-cdk) 项目.

AWS Batch是AWS中高效运行数十万个计算工作的批量处理工具. 批量可以动态提供 [亚马逊EC2](https://aws.amazon.com/ec2/) 满足所提交工作所需资源的事例 并简化你批量工作量的规划、安排和处决。 批次通过四个不同的资源实现这一点:

-   计算环境: 包含用于执行任务的资源
-   任务定义: 定义可以提交的任务类型
-   任务队列:等待任务来计算环境的路线
-   排程政策: 应用到队列上以控制工作退出队列并进入计算环境的方式和时间

`ComputeEnvironment`s可以管理或未管理。 批次将自动提供管理下的EC2实例 `ComputeEnvironment` 并将 不提供未管理中的任何实例 `ComputeEnvironment`管理 `ComputeEnvironment`s 可以使用ECS, Fargate 或 EKS 资源来旋转 EC2 实例(确保您的 EKS 集群有 [已配置](https://docs.aws.amazon.com/batch/latest/userguide/getting-started-eks.html) ,在链接之前支持批量计算环境。 您可以使用启动模板和放置组来精确配置这些资源 将供养.

`JobDefinition`s可以使用ECS资源或EKS资源. 东加勒比国家 `JobDefinition`s可以使用多个容器来完成分配的工作量. 埃克萨斯 `JobDefinition`s只能执行单个容器。 提交的工作使用情况 `JobDefinition`s作为模板.

`JobQueue`s必须至少链接一个 `ComputeEnvironment`。除非 `SchedulingPolicy` 已指定.

`SchedulingPolicy`s 告诉调度员如何选择由计算环境执行哪些任务.

## 使用实例( E)

### 成本优化

#### 实例

零星实例被大大低估了可以随时由AWS收回的EC2实例. 容错或无国籍的工作量可以利用即时定价. 使用点点实例, 设置 `spot` 改为 `true` 在管理下的 Ec2 或 Fargate 计算环境中:

```ts
const vpc = new ec2.Vpc(this, 'VPC');
new batch.FargateComputeEnvironment(this, 'myFargateComputeEnv', {
  vpc,
  spot: true,
});
```

批量允许您指定当前即时价格在点购实例中的百分比 必须是使用 `spotBidPercentage`。 。 。 . 此默认为100%, 这是推荐值 . 无法指定此值 `FargateComputeEnvironment`编号 仅适用于 `ManagedEc2EcsComputeEnvironment`编号. 以下代码配置一个计算环境只使用点实例 最多为按需例价的20%:

```ts
const vpc = new ec2.Vpc(this, 'VPC');
new batch.ManagedEc2EcsComputeEnvironment(this, 'myEc2ComputeEnv', {
   vpc,
   spot: true,
   spotBidPercentage: 20,
});
```

对于状态或非干扰-容忍工作流程,省略 `spot` 或设定为 `false` 只提供按需实例.

#### 选择实例类型

批次允许您选择会运行工作量的实例类型或类 . 此示例配置您的 `ComputeEnvironment` 仅使用 `M5AD.large` 实例:

```ts
const vpc = new ec2.Vpc(this, 'VPC');

new batch.ManagedEc2EcsComputeEnvironment(this, 'myEc2ComputeEnv', {
  vpc,
  instanceTypes: [ec2.InstanceType.of(ec2.InstanceClass.M5AD, ec2.InstanceSize.LARGE)],
});
```

批量允许您只指定实例类,并允许它选择大小,您可以这样做到:

```ts
const vpc = new ec2.Vpc(this, 'VPC');

declare const computeEnv: batch.IManagedEc2EcsComputeEnvironment
computeEnv.addInstanceClass(ec2.InstanceClass.M5AD);
// Or, specify it on the constructor:
new batch.ManagedEc2EcsComputeEnvironment(this, 'myEc2ComputeEnv', {
  vpc,
  instanceClasses: [ec2.InstanceClass.R4],
});
```

除非您明确说明 `useOptimalInstanceClasses: false`,这个计算环境将使用 `'optimal'` 实例, 它告诉Batch从C4,M4和R4案例家庭挑选一个案例. _说明_:批次不允许指定具有不同架构的实例类型或类. 譬如说, `InstanceClass.A1` 无法同时指定 `'optimal'`, (中文(简体) ), 因为 `A1` 使用 ARM 并 `'optimal'` 使用x86 64. 您可以同时指定 `'optimal'` 同一计算环境中的几种不同实例类型:

```ts
declare const vpc: ec2.IVpc;

const computeEnv = new batch.ManagedEc2EcsComputeEnvironment(this, 'myEc2ComputeEnv', {
  instanceTypes: [ec2.InstanceType.of(ec2.InstanceClass.M5AD, ec2.InstanceSize.LARGE)],
  useOptimalInstanceClasses: true, // default
  vpc,
});
// Note: this is equivalent to specifying
computeEnv.addInstanceType(ec2.InstanceType.of(ec2.InstanceClass.M5AD, ec2.InstanceSize.LARGE));
computeEnv.addInstanceClass(ec2.InstanceClass.C4);
computeEnv.addInstanceClass(ec2.InstanceClass.M4);
computeEnv.addInstanceClass(ec2.InstanceClass.R4);
```

#### 分配战略

| 分配战略 | 优化用于 | 下行情况 |
| --- | --- | --- |
| 最佳结果 | 费用 | 可能限制吞吐量 |
| 最佳战绩 | 吞吐量 | 可能增加费用 |
| (简体中文) | 最小的中断 | 只对 Spot 实例有用 |
| (简体中文) | 最小中断 + 价格 | 只对 Spot 实例有用 |

批次提供了不同的分配策略来帮助它选择提供哪个实例. 如果您的工作流程允许中断, 您应该启用 `spot` 在你身边 `ComputeEnvironment` 和使用情况 `SPOT_PRICE_CAPACITY_OPTIMIZED` (如果 `spot` 已启用). 这将让批量从您指定的实例类型中选择 (b) 能够最大限度地减少中断机会的最现货能力,并且价格最低. 为了从你的现场事件中获得最大的好处, 您应该允许批量从尽可能多的不同实例类型中选择. 如果你只关心最小的中断,而不想要批量优化成本,使用 `SPOT_CAPACITY_OPTIMIZED`。 。 。 . `SPOT_PRICE_CAPACITY_OPTIMIZED` 建议结束 `SPOT_CAPACITY_OPTIMIZED` 对于大多数使用的案例.

如果您的工作流程无法容忍中断, 并且您想要以牺牲成本来降低成本 可能更长的等待时间,使用时间 `AllocationStrategy.BEST_FIT`。 。 。 . 这将选择符合队列中所有任务的最小成本实例类型 . 如果不存在此类情况, 队列不会选择新类型;相反,它会等待实例可供使用. 这可以拖住你 `Queue`,在您的计算环境中,只使用其最大容量的一部分 (或根本没有) `BEST_FIT` 实例可供使用.

如果你运行的工作流程 无法容忍中断 你想最大化的吞吐量, 您可以使用 `AllocationStrategy.BEST_FIT_PROGRESSIVE`。 。 。 . 如果 `spot` 实值 `false` 或不详. 此策略将检查队列中的Jobs并选择符合要求的示例类型 包含在队列中且每个vCPU成本最低的工作,就像 `BEST_FIT`。 。 。 . 但是,如果不是所有的能力都能被这种实例所充斥, 它会选择一个新的最佳实例类型来运行任何无法匹配的工作 `BEST_FIT` 能力. 为了充分利用这一分配战略, 建议尽可能多地使用适合你工作量的例课. 此示例显示 `ComputeEnvironment` 用于 `BEST_FIT_PROGRESSIVE` 与 `'optimal'` 财务报告和审定财务报表 `InstanceClass.M5` 实例类型 :

```ts
declare const vpc: ec2.IVpc;

const computeEnv = new batch.ManagedEc2EcsComputeEnvironment(this, 'myEc2ComputeEnv', {
  vpc,
  instanceClasses: [ec2.InstanceClass.M5],
});
```

此示例显示 `ComputeEnvironment` 用于 `BEST_FIT` 与 `'optimal'` 实例 :

```ts
declare const vpc: ec2.IVpc;

const computeEnv = new batch.ManagedEc2EcsComputeEnvironment(this, 'myEc2ComputeEnv', {
  vpc,
  allocationStrategy: batch.AllocationStrategy.BEST_FIT,
});
```

_说明_数字 : `allocationStrategy` 无法在 Fargate 计算环境上指定 .

### 控制 vCPU 分配

您可以指定最大和最小的 vCPU 管理 `ComputeEnvironment` 可以在任何特定时间拥有. 批量会 _永远_ 维护 `minvCpus` 在计算环境时,即使它没有执行任何任务, 即使它是残废的。 批次会将实例缩放到 `maxvCpus` 实例价值 任务退出任务队列并输入计算环境。 如果您使用 `AllocationStrategy.BEST_FIT_PROGRESSIVE`, (中文(简体) ), `AllocationStrategy.SPOT_PRICE_CAPACITY_OPTIMIZED`,或 `AllocationStrategy.SPOT_CAPACITY_OPTIMIZED`, (中文(简体) ), 批量可能超过 `maxvCpus`它永远不会超过 `maxvCpus` 由不止一个实例类型。 此示例配置一个 `minvCpus` 页:1 `maxvCpus` 其中100个:

```ts
declare const vpc: ec2.IVpc;

new batch.ManagedEc2EcsComputeEnvironment(this, 'myEc2ComputeEnv', {
  vpc,
  instanceClasses: [ec2.InstanceClass.R4],
  minvCpus: 10,
  maxvCpus: 100,
});
```

### 标记实例

您可以使用 CDK 标记您管理的 EC2 计算环境启动的任何实例 `Tags` API : (英语)

```ts
import { Tags } from 'aws-cdk-lib';

declare const vpc: ec2.IVpc;

const tagCE = new batch.ManagedEc2EcsComputeEnvironment(this, 'CEThatMakesTaggedInstnaces', {
  vpc,
});

Tags.of(tagCE).add('super', 'salamander');
```

未管理 `ComputeEnvironment`s 不支持 `maxvCpus` 或者说 `minvCpus` 因为你必须自己提供和管理实例; 也就是说,批量不会按照需要扩大或缩小.

### 在多个任务类型之间共享计算环境

多个 `JobQueue`s 可以分享同样的 `ComputeEnvironment`。 。 。 . 如果多个队列试图将Jobs提交到相同的队列 `ComputeEnvironment`, (中文(简体) ), 批次会以最高优先级从队列中选择任务. 此示例创建两个 `JobQueue`共享 a `ComputeEnvironment`数字 :

```ts
declare const vpc: ec2.IVpc;
const sharedComputeEnv = new batch.FargateComputeEnvironment(this, 'spotEnv', {
  vpc,
  spot: true,
});
const lowPriorityQueue = new batch.JobQueue(this, 'JobQueue', {
   priority: 1,
});
const highPriorityQueue = new batch.JobQueue(this, 'JobQueue', {
   priority: 10,
});
lowPriorityQueue.addComputeEnvironment(sharedComputeEnv, 1);
highPriorityQueue.addComputeEnvironment(sharedComputeEnv, 1);
```

### 公平分享时间安排

批次 `JobQueue`s 执行 FIFO 命令中提交给他们的作业,除非您指定 `SchedulingPolicy`。 。 。 . FIFO排队可能导致短跑工作被饿死,而长跑工作则会填补计算环境. 为了解决这个问题,乔布斯可以和股份联系在一起.

股份包括: `shareIdentifier` (单位:千美元) `weightFactor`,这与分配给该共享标识符的vCPU是相向的. 在提交任务时,您可以指定它 `shareIdentifier` 把这份工作和这份工作联系起来. 让我们看看调度器如何利用这些信息来安排工作.

例如,如果有两股的定义如下:

| 共享标识符 | 重量因素 |
| --- | --- |
| A 类 | 1个 |
| 页:1 | 1个 |

权重因素具有以下关系:

```math
A_{vCpus} / A_{Weight} = B_{vCpus} / B_{Weight}
```

地点 `BvCpus` 是分配给带有共享标识符的工作的 vCPU 数量 `'B'`,以及 `B_weight` 是加权系数 `B`。 。 。 .

分配到一个职位的vCpus总数等于每个职位所需vCpus数量的比例. 假设每个工作需要32个VCpus(`A_requirement` =32),每个B类工作需要64 vCpus(英语:`B_requirement` =64个:

```math
A_{vCpus} = A_{Jobs} * A_{Requirement}
```

```math
B_{vCpus} = B_{Jobs} * B_{Requirement}
```

我们有:

```math
A_{vCpus} / A_{Weight} = B_{vCpus} / B_{Weight}
```

```math
A_{Jobs} * A_{Requirement} / A_{Weight} = B_{Jobs} * B_{Requirement} / B_{Weight}
```

```math
A_{Jobs} * 32 / 1 = B_{Jobs} * 64 / 1
```

```math
A_{Jobs} * 32 = B_{Jobs} * 64
```

```math
A_{Jobs} = B_{Jobs} * 2
```

因此,调度器将安排两个 `'A'` 每个任务 `'B'` 任务.

你可以控制重量因素 改变这些比率,但请注意 权重因子与分配给相应份额的vCpus相负相联.

此示例将像这样配置 :

```ts
const fairsharePolicy = new batch.FairshareSchedulingPolicy(this, 'myFairsharePolicy');

fairsharePolicy.addShare({
  shareIdentifier: 'A',
  weightFactor: 1,
});
fairsharePolicy.addShare({
  shareIdentifier: 'B',
  weightFactor: 1,
});
new batch.JobQueue(this, 'JobQueue', {
  schedulingPolicy: fairsharePolicy,
});
```

_说明_:调度器只考虑计算环境的当前使用,除非您指定 `shareDecay`。 。 。 . 例如,a `shareDecay` 在上述例子中,5分钟是指在任何特定时间点,两倍于 `'A'` 任务 将分别安排 `'B'` 工作,但只 在过去5分钟。 若为 `'B'` 工作超过5分钟,然后 排程器允许放两个以上 `'A'` 每个任务 `'B'` 工作,因为使用这些长期运行 `'B'` 5分钟后将不再考虑工作. `shareDecay` 线性减少使用量 用于计算的长期工作。 例如如果共享衰减为60秒, 然后运行30秒钟的工作 被认为只是实际的50%, 但一整分钟后 排程员假装不存在 公平计算.

以下代码指定 a `shareDecay` 5分钟:

```ts
import * as cdk from 'aws-cdk-lib'
const fairsharePolicy = new batch.FairshareSchedulingPolicy(this, 'myFairsharePolicy', {
   shareDecay: cdk.Duration.minutes(5),
});
```

如果你有高优先级的工作 他们一到就应该执行, 您可以定义 `computeReservation` 指定百分比 最大vCPU容量,应保留给属于 _不在队列中_。 。 。 . 实际保留百分比被批次定义为:

```math
 (\frac{computeReservation}{100}) ^ {ActiveFairShares}
```

地点 `ActiveFairShares` 是拥有的股份数量 队列中至少有一项任务具有独有的共享标识符.

最好用一个例子来说明这一点. 假设有三股股份 并有股票标识 `A`, (中文(简体) ), `B` 财务报告和审定财务报表 `C` 分别为: 并且我们具体说明 `computeReservation` 百分之七十五 绝对是 队列目前为空, 并且没有其他股份.

由于队列是空的,所以没有活跃的公平股. 因此 (75/100^0 = 1 = 最大 vCpus 100% 保留给所有股份.

带有标识符的工作 `A` 输入队列.

现在活跃的公平股数是1,因此 (75/100)^1 =.75 = 最大 vCpus 的75% 保留给没有标识符的所有股份 `A`· ; 对于这个例子,这是 `B` 财务报告和审定财务报表 `C`, (中文(简体) ), (但是,如果提交的工作带有本公平分享政策未涵盖的共享标识,这些将被视作 `B` 财务报告和审定财务报表 `C` (见a/cn.9/wg.iii/wp.96和corr.1).

现在一个 `B` 任务输入队列。 现在活跃的公平股数是2, 因此(75/100)^2=.5625=最高vCpus的56.25%保留给所有没有标识的股份 `A` 或者说 `B`。 。 。 .

现在,第二 `A` 任务输入队列。 活跃的公平股数仍然是2, 因此,保留的百分比仍然是56.25%

现在一个 `C` 任务输入队列。 现在活跃的公平股数是3, 因此(75/100)^3 = 421875 = 42.1875 最大 vCpus 为所有没有标识的股份保留 `A`, (中文(简体) ), `B`,或 `C`。 。 。 .

如果没有其他工作可以说明的股份,这意味着你42.1875%的能力永远不会被使用!

现在, `A`, (中文(简体) ), `B`,以及 `C` 只能消费100% - 42.1875% = 57.8125%的 vCpus. 请注意,这一百分比是: **没有** 分隔 `A`, (中文(简体) ), `B`,以及 `C`。 。 。 . 相反,调度器将使用他们的 `weightFactor`确定哪些工作需要安排; 唯一的区别是,与其竞争最大容量的100%,不如竞争最大容量的57.8125%.

此示例指定一个 `computeReservation` 如上例所述,75%将从事下列工作:

```ts
new batch.FairshareSchedulingPolicy(this, 'myFairsharePolicy', {
  computeReservation: 75,
  shares: [
    { weightFactor: 1, shareIdentifier: 'A' },
    { weightFactor: 0.5, shareIdentifier: 'B' },
    { weightFactor: 2, shareIdentifier: 'C' },
  ],
});
```

您可以指定一个 `priority` 在你身边 `JobDefinition`s 告诉调度器优先处理某些共享共享标识符的工作.

### 配置工作重试政策

某些工作流程可能导致工作因间歇性问题而失败. 工作可以指定重试政策,以不同的行动应对不同的失败. 关于离职方式的信息有三种不同方式;

-   `exitCode`: 退出代码从容器执行的过程返回. 只能匹配非零退出代码.
-   `reason`: 任何中间软件出错, 就像您的 Docker 注册被关闭 .
-   `statusReason`: 基础设施出错, 最常见的是, 您的现成实例被回收 .

对于大多数使用的案例来说,其中只有一个将一次与某一特定行动有关. 指定通用 `exitCode`s, (中文(简体) ), `reason`s,或 `statusReason`s,使用来自 页:1 `Reason` 课。 这个例子显示了一些常见的失败原因:

```ts
import * as cdk from 'aws-cdk-lib';

const jobDefn = new batch.EcsJobDefinition(this, 'JobDefn', {
   container: new batch.EcsEc2ContainerDefinition(this, 'containerDefn', {
    image: ecs.ContainerImage.fromRegistry('public.ecr.aws/amazonlinux/amazonlinux:latest'),
    memory: cdk.Size.mebibytes(2048),
    cpu: 256,
  }),
  retryAttempts: 5,
  retryStrategies: [
    batch.RetryStrategy.of(batch.Action.EXIT, batch.Reason.CANNOT_PULL_CONTAINER),
  ],
});
jobDefn.addRetryStrategy(
  batch.RetryStrategy.of(batch.Action.EXIT, batch.Reason.SPOT_INSTANCE_RECLAIMED),
);
jobDefn.addRetryStrategy(
  batch.RetryStrategy.of(batch.Action.EXIT, batch.Reason.CANNOT_PULL_CONTAINER),
);
jobDefn.addRetryStrategy(
  batch.RetryStrategy.of(batch.Action.EXIT, batch.Reason.custom({
    onExitCode: '40*',
    onReason: 'some reason',
  })),
);
```

当指定一个自定义的原因时, ,您可以指定一个与每个匹配的 glob 字符串,并对不同的失败做出相应的反应. 每个任务最多可以配置五个不同的重试策略, 并且每个策略可以匹配一些或所有 `exitCode`, (中文(简体) ), `reason`,以及 `statusReason`。 。 。 . 你可以选择配置一个工作要重试的次数, 但是您不能为不同的策略配置不同的重试数; 它们都共享相同的数 . 如果在给定的重试策略中指定了多个条件, 它们必须都与将要采取的行动相匹配; 条件是放在一起的,而不是命令.

### 运行单容器ECS工作流程

批量可以在ECS或EKS上运行工作. ECS工作可以被定义为单个容器或多节点. 此示例创建一个 `JobDefinition` 操作带有ECS的单一容器:

```ts
import * as cdk from 'aws-cdk-lib';
import * as iam from 'aws-cdk-lib/aws-iam';
import * as efs from 'aws-cdk-lib/aws-efs';

declare const myFileSystem: efs.IFileSystem;
declare const myJobRole: iam.Role;
myFileSystem.grantRead(myJobRole);

const jobDefn = new batch.EcsJobDefinition(this, 'JobDefn', {
  container: new batch.EcsEc2ContainerDefinition(this, 'containerDefn', {
    image: ecs.ContainerImage.fromRegistry('public.ecr.aws/amazonlinux/amazonlinux:latest'),
    memory: cdk.Size.mebibytes(2048),
    cpu: 256,
    volumes: [batch.EcsVolume.efs({
      name: 'myVolume',
      fileSystem: myFileSystem,
      containerPath: '/Volumes/myVolume',
      useJobRole: true,
    })],
    jobRole: myJobRole,
  }),
});
```

对于需要持续存储的工作流程,批量支持安装 `Volume`s到容器. 您既可以提供体积,也可以在一次操作中将其挂入容器:

```ts
import * as efs from 'aws-cdk-lib/aws-efs';

declare const myFileSystem: efs.IFileSystem;
declare const jobDefn: batch.EcsJobDefinition;

jobDefn.container.addVolume(batch.EcsVolume.efs({
  name: 'myVolume',
  fileSystem: myFileSystem,
  containerPath: '/Volumes/myVolume',
}));
```

### 秘诀

您可以将“ 秘密管理者” 秘密 ARN 或 SSM 参数作为环境变量暴露在您的容器中. 以下例子界定了 `MY_SECRET_ENV_VAR` 包含 由 : `mySecret`数字 :

```ts
import * as cdk from 'aws-cdk-lib';

declare const mySecret: secretsmanager.ISecret;

const jobDefn = new batch.EcsJobDefinition(this, 'JobDefn', {
  container: new batch.EcsEc2ContainerDefinition(this, 'containerDefn', {
    image: ecs.ContainerImage.fromRegistry('public.ecr.aws/amazonlinux/amazonlinux:latest'),
    memory: cdk.Size.mebibytes(2048),
    cpu: 256,
    secrets: {
      MY_SECRET_ENV_VAR: batch.Secret.fromSecretsManager(mySecret),
    }
  }),
});
```

### 运行工作流

批次还支持在EKS上运行工作流程. 下述例子创造了 `JobDefinition` 运行在EKS:

```ts
import * as cdk from 'aws-cdk-lib';
const jobDefn = new batch.EksJobDefinition(this, 'eksf2', {
  container: new batch.EksContainerDefinition(this, 'container', {
    image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
    volumes: [batch.EksVolume.emptyDir({
      name: 'myEmptyDirVolume',
      mountPath: '/mount/path',
      medium: batch.EmptyDirMediumType.MEMORY,
      readonly: true,
      sizeLimit: cdk.Size.mebibytes(2048),
    })],
  }),
});
```

你可以挂载 `Volume`单次操作中的这些容器:

```ts
declare const jobDefn: batch.EksJobDefinition;
jobDefn.container.addVolume(batch.EksVolume.emptyDir({
  name: 'emptyDir',
  mountPath: '/Volumes/emptyDir',
}));
jobDefn.container.addVolume(batch.EksVolume.hostPath({
  name: 'hostPath',
  hostPath: '/sys',
  mountPath: '/Volumes/hostPath',
}));
jobDefn.container.addVolume(batch.EksVolume.secret({
  name: 'secret',
  optional: true,
  mountPath: '/Volumes/secret',
  secretName: 'mySecret',
}));
```

### 正在运行的分布式工作流程

一些工作流程从平行化中受益,在分布式环境中运行时功能最强, 例如某些数值计算或模拟。 批量报价 `MultiNodeJobDefinition`s, (中文(简体) ), 为此,允许一个单一工作同时进行多个情况. 消息传递接口(MPI)常与这些工作流程一起被使用. 您必须配置您的容器才能正确使用 MPI, 但批量允许不同节点运行不同的容器来方便地相互通信. 您必须配置您的容器, 以便使用批量提供的某些环境变量, 让他们知道哪一个是主节点 以及其他信息. 关于使用MPI进行批量数字计算的一个深入的例子, 看这个 [博客文章](https://aws.amazon.com/blogs/compute/building-a-tightly-coupled-molecular-dynamics-workflow-with-multi-node-parallel-jobs-in-aws-batch/) 特别是,告诉容器是哪个主节点的环境变量可以配置在您身上 `MultiNodeJobDefinition` 内容如下:

```ts
import * as cdk from 'aws-cdk-lib';
const multiNodeJob = new batch.MultiNodeJobDefinition(this, 'JobDefinition', {
  instanceType: ec2.InstanceType.of(ec2.InstanceClass.R4, ec2.InstanceSize.LARGE),
  containers: [{
    container: new batch.EcsEc2ContainerDefinition(this, 'mainMPIContainer', {
      image: ecs.ContainerImage.fromRegistry('yourregsitry.com/yourMPIImage:latest'),
      cpu: 256,
      memory: cdk.Size.mebibytes(2048),
    }),
    startNode: 0,
    endNode: 5,
  }],
});
// convenience method
multiNodeJob.addContainer({
  startNode: 6,
  endNode: 10,
  container: new batch.EcsEc2ContainerDefinition(this, 'multiContainer', {
    image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
    cpu: 256,
    memory: cdk.Size.mebibytes(2048),
  }),
});
```

如果您需要将控制节点设置为 0 以外的索引,请直接指定:

```ts
const multiNodeJob = new batch.MultiNodeJobDefinition(this, 'JobDefinition', {
  mainNode: 5,
  instanceType: ec2.InstanceType.of(ec2.InstanceClass.R4, ec2.InstanceSize.LARGE),
});
```

### 传递参数到任务

批次允许您定义您的参数 `JobDefinition`,可以在容器命令中引用。 例如:

```ts
import * as cdk from 'aws-cdk-lib';
new batch.EcsJobDefinition(this, 'JobDefn', {
  parameters: { echoParam: 'foobar' },
  container: new batch.EcsEc2ContainerDefinition(this, 'containerDefn', {
    image: ecs.ContainerImage.fromRegistry('public.ecr.aws/amazonlinux/amazonlinux:latest'),
    memory: cdk.Size.mebibytes(2048),
    cpu: 256,
    command: [
      'echo',
      'Ref::echoParam',
    ],
  }),
});
```

### 理解逐步分配战略

AWS 批次使用一个 [分配战略](https://docs.aws.amazon.com/batch/latest/userguide/allocation-strategies.html) 确定计算资源将有效处理收到的工作请求。 默认, **最佳结果** 将根据vCPU的要求选择可用的计算实例。 如果不存在,则工作将等待资源到位。 然而,通过这一策略,您可能会有工作在排队中不必要的等待,尽管有更强大的实例可用。 下面是这种情况的一个例子:

```plaintext
Compute Environment:

1. m5.xlarge => 4 vCPU
2. m5.2xlarge => 8 vCPU
```

```plaintext
Job Queue:
---------
| A | B |
---------

Job Requirements:
A => 4 vCPU - ALLOCATED TO m5.xlarge
B => 2 vCPU - WAITING
```

在这种情况下,批量将分配 **任务A** 以计算资源 # 1 ,因为它是符合 vCPU 要求的成本效益最高的资源。 不过,有了这个 `BEST_FIT` 战略, **任务B** 将不分配给我们其他可用的计算资源,尽管它足够强大,足以处理它。 相反,它会等到第一个任务完成 或等待一个类似的 `m5.xlarge` 资源.

替代办法是使用 `BEST_FIT_PROGRESSIVE` (c) 制定战略,使剩余工作能够在更大的容器中处理,而不论VCPU的要求和费用如何.

### 权限

你可以授予任何校长 `batch:submitJob` 允许在任务定义和像这样的任务队列上使用 :

```ts
import * as cdk from 'aws-cdk-lib';
import * as iam from 'aws-cdk-lib/aws-iam';

declare const vpc: ec2.IVpc;

const ecsJob = new batch.EcsJobDefinition(this, 'JobDefn', {
  container: new batch.EcsEc2ContainerDefinition(this, 'containerDefn', {
    image: ecs.ContainerImage.fromRegistry('public.ecr.aws/amazonlinux/amazonlinux:latest'),
    memory: cdk.Size.mebibytes(2048),
    cpu: 256,
  }),
});

const queue = new batch.JobQueue(this, 'JobQueue', {
  computeEnvironments: [{
    computeEnvironment: new batch.ManagedEc2EcsComputeEnvironment(this, 'managedEc2CE', {
      vpc,
    }),
    order: 1,
  }],
  priority: 10,
});

const user = new iam.User(this, 'MyUser');
ecsJob.grantSubmitJob(user, queue);
```

## 常见问题

### @aws-cdk/aws-batch-alpha 是什么？

AWS 的 CDK 构造库: 批次注意：该包已被作者标记为弃用——This package has been stabilized and moved to aws-cdk-lib

### 如何安装 @aws-cdk/aws-batch-alpha？

在项目目录运行 npm install @aws-cdk/aws-batch-alpha，或使用 pnpm add / yarn add / bun add。它还需要宿主项目提供 peer 依赖：aws-cdk-lib（2\.95\.1）、constructs（^10\.0\.0）。npm 7 及以上与 pnpm 8 及以上默认会自动安装必需的 peer 依赖，Yarn 需要手动安装。

### @aws-cdk/aws-batch-alpha 支持 TypeScript 吗？

支持。包内自带 TypeScript 类型声明（package\.json 声明了 types 入口），安装后即可获得类型提示，无需再安装 @types 包。

### @aws-cdk/aws-batch-alpha 支持 ESM 还是 CommonJS？

以 CommonJS 形式发布，可以直接 require\(\)；在 ES Module 项目中也可以用 import 引入（Node\.js 会把 module\.exports 作为默认导出）。

### @aws-cdk/aws-batch-alpha 需要什么版本的 Node\.js？

package\.json 的 engines 字段要求 Node\.js \>= 14\.15\.0。版本不符时 npm 默认只给出警告，开启 engine-strict 后会拒绝安装。

### @aws-cdk/aws-batch-alpha 可以商用吗？

@aws-cdk/aws-batch-alpha 使用 Apache-2\.0 许可。宽松许可：允许商业使用、修改和再分发，并附带明确的专利授权；分发时需保留许可与 NOTICE 文件，修改过的文件要注明改动。以上为概括，不构成法律意见，请以许可原文为准。

### @aws-cdk/aws-batch-alpha 的下载量有多少？

根据 npm 官方下载统计，@aws-cdk/aws-batch-alpha 在 2026/10/07 – 2026/11/05 这 30 天内被下载 48,463 次，日均约 1,615 次。下载量会把 CI 构建、镜像同步和作为其他包依赖的安装一并计入，适合横向比较热度，不能直接等同于使用人数。

### @aws-cdk/aws-batch-alpha 还在维护吗？

最新版本 2\.95\.1-alpha\.0 发布于 2023/09/09（3 年前）；至今共发布 139 个版本，其中过去 12 个月发布了 0 个；首次发布于 2021/10/14。作者已将其标记为弃用，新项目建议寻找替代方案。