AWS 批量构造库

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

这个模块是 AWS 云开发套件 项目.

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

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

ComputeEnvironments可以管理或未管理。 批次将自动提供管理下的EC2实例 ComputeEnvironment 并将 不提供未管理中的任何实例 ComputeEnvironment管理 ComputeEnvironments 可以使用ECS, Fargate 或 EKS 资源来旋转 EC2 实例(确保您的 EKS 集群有 已配置 ,在链接之前支持批量计算环境。 您可以使用启动模板和放置组来精确配置这些资源 将供养.

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

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

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

使用实例( E)

成本优化

实例

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

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

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

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

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

选择实例类型

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

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

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

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

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' 同一计算环境中的几种不同实例类型:

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 在你身边 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 实例类型 :

declare const vpc: ec2.IVpc;

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

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

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个:

declare const vpc: ec2.IVpc;

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

标记实例

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

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');

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

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

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

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);

公平分享时间安排

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

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

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

权重因素具有以下关系:

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个:

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

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

我们有:

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

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

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

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

A_{Jobs} = B_{Jobs} * 2

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

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

此示例将像这样配置 :

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分钟:

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

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

 (\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%将从事下列工作:

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

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

配置工作重试政策

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

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

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

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的单一容器:

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,
  }),
});

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

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数字 :

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:

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单次操作中的这些容器:

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',
}));

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

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

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 以外的索引,请直接指定:

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

传递参数到任务

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

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 批次使用一个 分配战略 确定计算资源将有效处理收到的工作请求。 默认, 最佳结果 将根据vCPU的要求选择可用的计算实例。 如果不存在,则工作将等待资源到位。 然而,通过这一策略,您可能会有工作在排队中不必要的等待,尽管有更强大的实例可用。 下面是这种情况的一个例子:

Compute Environment:

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

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 允许在任务定义和像这样的任务队列上使用 :

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);