本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# Amazon EKS 上 AWS Batch 的内存和 vCPU 注意事项
<a name="memory-cpu-batch-eks"></a>

在 Amazon EKS 上的 AWS Batch 中，您可以指定可供容器使用的资源。例如，您可以为 vCPU 和内存资源指定 `requests` 或 `limits` 值。

以下是指定 vCPU 资源的限制：
+ 至少必须指定一个 vCPU`requests` 或 `limits`。
+ 一个 vCPU 单元等同于一个物理或虚拟内核。
+ vCPU 值必须以整数或以 0.25 为增量输入。
+ 最小的有效 vCPU 值为 0.25。
+ 如果指定了两者的值，则 `requests` 值必须小于或等于 `limits` 值。这样，您就可以配置软和硬 vCPU 配置。
+ 无法以 milliCPU 形式指定 vCPU 值。例如，`100m` 不是有效值。
+ AWS Batch 使用 `requests` 值进行缩放决策。如果未指定 `requests` 值，则会将 `limits` 值复制到 `requests` 值中。

以下是指定内存资源的限制：
+ 至少必须指定内存 `requests` 或 `limits` 值之一。
+ 内存值必须在 mebibytes (MiBs) 中。
+ 如果两者都指定，则 `requests` 值必须等于 `limits` 值。
+ AWS Batch 使用 `requests` 值进行缩放决策。如果未指定 `requests` 值，则会将 `limits` 值复制到 `requests` 值中。

以下是指定 GPU 资源的限制：
+ 如果两者都指定，则 `requests` 值必须等于 `limits` 值。
+ AWS Batch 使用 `requests` 值进行缩放决策。如果未指定 `requests` 值，则会将 `limits` 值复制到 `requests` 值中。

## 示例：作业定义
<a name="memory-cpu-batch-eks-example-job-definition"></a>

Amazon EKS 作业定义的以下 AWS Batch 配置了软 vCPU 共享。这允许在 Amazon EKS 上的 AWS Batch 使用该实例类型的所有 vCPU 容量。但是，如果还有其他作业在运行，则会为该作业分配最多 `2` vCPU。内存限制为不超过 2 GB。

```
{
   "jobDefinitionName": "MyJobOnEks_Sleep",
   "type": "container",
   "eksProperties": {
       "podProperties": {
           "containers": [
               {
                   "image": "public.ecr.aws/amazonlinux/amazonlinux:2",
                   "command": ["sleep", "60"],
                   "resources": {
                       "requests": {
                           "cpu": "2",
                           "memory": "2048Mi"
                       }
                   }
               }
           ]
       }
   }
}
```

Amazon EKS 作业定义上的以下 AWS Batch 的 `1` 值为 `request` ，最多可为该作业分配 `4` vCPU。

```
{
   "jobDefinitionName": "MyJobOnEks_Sleep",
   "type": "container",
   "eksProperties": {
       "podProperties": {
           "containers": [
               {
                   "image": "public.ecr.aws/amazonlinux/amazonlinux:2",
                   "command": ["sleep", "60"],
                   "resources": {
                       "requests": {
                           "cpu": "1"
                       },
                       "limits": {
                           "cpu": "4",
                           "memory": "2048Mi"
                       }
                   }
               }
           ]
       }
   }
}
```

Amazon EKS 任务定义上的以下 AWS Batch 将 vCPU `limits` 值设置为 `1`，内存 `limits` 值设置为 1 GB。

```
{
   "jobDefinitionName": "MyJobOnEks_Sleep",
   "type": "container",
   "eksProperties": {
       "podProperties": {
           "containers": [
               {
                   "image": "public.ecr.aws/amazonlinux/amazonlinux:2",
                   "command": ["sleep", "60"],
                   "resources": {
                       "limits": {
                           "cpu": "1",
                           "memory": "1024Mi"
                       }
                   }
               }
           ]
       }
   }
}
```

在 AWS Batch 将 Amazon EKS 作业上的 AWS Batch 转换为 Amazon EKS 容器组（pod）时，AWS Batch 会将 `limits` 值复制给 `requests` 值。在未指定 `requests` 值时，会出现这种情况。提交前面的示例作业定义时，容器组（pod）`spec` 如下所示。

```
apiVersion: v1
kind: Pod
...
spec:
  ...
  containers:
    - command:
        - sleep
        - 60
      image: public.ecr.aws/amazonlinux/amazonlinux:2
      resources:
        limits:
          cpu: 1
          memory: 1024Mi
        requests:
          cpu: 1
          memory: 1024Mi
      ...
```

## 节点 CPU 和内存预留
<a name="memory-cpu-batch-eks-node-cpu-memory-reservations"></a>

AWS Batch 依赖 `bootstrap.sh` 文件的默认逻辑来预留 vCPU 和内存。有关 `bootstrap.sh` 文件的更多信息，请参阅 [bootstrap.sh](https://github.com/awslabs/amazon-eks-ami/blob/main/templates/al2/runtime/bootstrap.sh)。在调整 vCPU 和内存资源的大小时，请考虑以下示例。

**注意**  
如果没有实例在运行，vCPU 和内存预留最初可能会影响 AWS Batch 扩展逻辑和决策。实例运行后，AWS Batch 调整初始分配。

## 示例：节点 CPU 预留
<a name="memory-cpu-batch-eks-node-cpu-reservations"></a>

CPU 预留值是使用实例可用的 vCPU 总数以毫核为单位计算的。


| vCPU 数量 | 预留百分比 | 
| --- | --- | 
| 1 | 6% | 
| 2 | 1% | 
| 3-4 | 0.5% | 
| 4 及以上 | 0.25% | 

使用上述值，以下各项为真：
+ 具有 2 个 vCPU 的 `c5.large` 实例的 CPU 预留值为 70 m。计算方法如下：*(1\$160) \$1 (1\$110) = 70 m*。
+ 具有 96 个 vCPU 的 `c5.24xlarge` 实例的 CPU 预留值为 310 m。计算方法如下：(1\$160) \$1 (1\$110) \$1 (2\$15) \$1 (92\$12.5) = 310 m。

在此示例中，有 1930 个（计算为 2000-70）毫核 vCPU 单元可用于在 `c5.large` 实例上运行作业。假设您的作业需要 `2` (2\$11000 m) 个 vCPU 单元，则该作业不适合单个 `c5.large` 实例。但是，需要 `1.75` vCPU 单元的作业合适。

## 示例：节点内存预留
<a name="memory-cpu-batch-eks-node-memory-reservations"></a>

内存预留值以 MB 为单位计算，使用以下公式：
+ 实例容量以 MB 为单位。例如，一个 8 GB 实例为 7,748 MiB。
+ `kubeReserved` 值。`kubeReserved` 值是为系统进程守护程序保留的内存量。`kubeReserved` 值的计算方式如下：*((11 \$1 实例类型支持的最大容器组（pod）数) \$1 255)*。有关实例类型支持的最大容器组（pod）数量的信息，请参阅 [eni-max-pods.txt](https://github.com/awslabs/amazon-eks-ami/blob/main/nodeadm/internal/kubelet/eni-max-pods.txt) 
+ `HardEvictionLimit` 值。当可用内存低于 `HardEvictionLimit` 值时，实例会尝试驱逐容器组（pod）。

计算可分配内存的公式如下：(*instance\$1capacity\$1in\$1MiB*) - (11 \$1 (*maximum\$1number\$1of\$1pods*)) - 255 - (*`HardEvictionLimit` value.*))。

 一个 `c5.large` 实例最多支持 29 个容器组（pod）。对于 `HardEvictionLimit` 值为 100 MiB 的 8 GB `c5.large` 实例，可分配的内存为 7074 MiB。这是通过以下方式计算的：*(7748 - (11 \$1 29) -255 -100) = 7074 MiB*。在此示例中，8,192 MiB 作业不适合此实例，尽管它是 8 gibibyte (GiB) 实例。

## DaemonSets
<a name="memory-cpu-batch-eks-reservations-daemonset-scaling"></a>

在使用 DaemonSets 时，请考虑以下几点：
+ 如果 Amazon EKS 实例上没有 AWS Batch 在运行，则 DaemonSets 最初可能会影响 AWS Batch 扩展逻辑和决策。AWS Batch 最初为预期 DaemonSets 分配了 0.5 个 vCPU 单元和 500 MiB。实例运行后，AWS Batch 调整初始分配。
+ 如果 DaemonSet 定义了 vCPU 或内存限制，那么在 Amazon EKS 作业上的 AWS Batch 的资源就会减少。我们建议您将分配给 AWS Batch 作业 DaemonSets 的数量保持在尽可能低的水平。