Newshot

在 Amazon EKS 上使用 NVIDIA Run:ai GPU Fractioning

AI summary

GPU 共享并非新概念:MIG、时间分片和 MPS 分别满足不同的隔离与利用率需求,而 NVIDIA Run:ai GPU Fractioning 在 MPS 基础上增加了与 Kubernetes 集成的调度、按 Pod 的内存契约、强制限制和指标。作为面向 Kubernetes 的 AI 工作负载编排软件,其 GPU Fractioning Operator 可帮助多个团队在 Amazon EKS 上共享一到两块 GPU,避免在 GPU 显存仍有空闲时让笔记本、模型评估和小型推理服务排队等待。

Translation(model translation, not the source's own text)

在 Amazon EKS 上使用 NVIDIA Run:ai GPU Fractioning

GPU 共享并不是新概念:Multi-Instance GPU(MIG)、time-slicing 和 Multi-Process Service(MPS)分别面向不同的隔离与利用率需求。NVIDIA Run:ai GPU Fractioning 构建在 MPS 之上,并集成了 Kubernetes 调度、按 Pod 的内存契约、强制执行与指标。

NVIDIA Run:ai 是面向 Kubernetes 的 AI 工作负载编排软件。其 GPU Fractioning Operator 可以帮助多个团队在 Amazon Elastic Kubernetes Service(Amazon EKS)上共享一到两块 GPU。笔记本、模型评测和小型推理服务往往会让团队排队等待,即使 GPU 内存仍有空闲。在本演练的基线配置中,NVIDIA device plugin 将单块 GPU 暴露为一个 nvidia.com/gpu 资源,并禁用 GPU 共享。两个各自请求 nvidia.com/gpu: 1 的 Pod 无法在该节点上并发运行,即使它们合计的 GPU 内存需求完全放得下。

NVIDIA Run:ai GPU Fractioning 为基于软件的共享增加了 Kubernetes 调度集成、强制执行的 GPU 内存限制以及按 Pod 的指标。该方法适用于满足 GPU Fractioning Operator 硬件与软件要求的 NVIDIA GPU,包括不支持 MIG 的 GPU。我们使用一台配备 NVIDIA A10G Tensor Core GPU 的 Amazon Elastic Compute Cloud(Amazon EC2)g5.xlarge 实例作为经验证的示例。其他配置需要做兼容性检查和验证。

NVIDIA 于 2026 年 10 月 13 日宣布 NVIDIA Run:ai 开源发布。本示例使用了其四个模块化组件中的两个:KAI Scheduler 和 GPU Fractioning Operator。KAI Resource Management 和 Workload Map 面向组织治理和额外的工作负载类型,不在本演练范围内。

在本文中,我们展示如何构建自定义 Amazon Linux 2023(AL2023)镜像,并在 Amazon EKS 上配置 GPU 内存共享。在经验证的 G5/A10G 示例中,你先建立整块 GPU 的基线,再为每个 Pod 分配 8 GiB 内存契约,并验证 6 GiB 的分配。随后你查看按 Pod 的指标,测试 9 GiB 分配请求被拒绝的情况,并清理这个一次性环境。

选择 GPU 共享方案

MIG 在受支持的 GPU 上提供硬件分区。device-plugin 的 time-slicing 共享一块 GPU,但不提供副本内存或故障隔离。MPS 允许多个 CUDA 进程并发运行。故障隔离程度取决于配置。NVIDIA Run:ai GPU Fractioning 增加了强制执行的按容器内存限制,并支持 time-slicing(默认)或 sm-sharing 计算模式。NVIDIA 文档说明其默认模式具有独立的工作负载错误域,而 sm-sharing 则共享错误域。这些都不是安全保证。本演练测试的是内存限制,而非故障隔离或计算性能。内存限制并不预留成比例的计算资源。

Amazon EKS 记录了多种 GPU 共享选项:MIG、使用 NVIDIA device plugin 的 time-slicing,以及使用 NVIDIA DRA driver 和 Karpenter 的 time-slicing。关于如何在其中选择的指引,请参阅 Amazon EKS Best Practices Guide 中的 GPU 共享指引。当你需要在没有 MIG 的 GPU 上强制执行按 Pod 的 GPU 内存限制,并且可以运行固定规格的 GPU 节点组时,请选择 GPU fractioning。

Dynamic Resource Allocation(DRA)提供了用于请求和分配设备的 Kubernetes API。GPU 共享与隔离取决于设备驱动的实现和已启用的功能。KAI Scheduler 和 GPU Operator 支持 DRA。本演练使用 NvFractions 注解,而非 DRA。

GPU fractioning 可以帮助存在空闲时段的交互式笔记本、短时评测作业、GPU 兼容性测试以及小型推理服务。请根据实测峰值用量加上额外开销来确定每个 GPU 内存请求,然后在并发负载下测试延迟。演示中的密度提升并不等同于吞吐量提升或普遍的成本降低。

解决方案概述

下图展示了在 US East (Ohio) 区域(us-east-2)经过验证的单 GPU 环境。你使用 AWS Command Line Interface(AWS CLI)、eksctl、Helm 和 Packer 来构建并运行它。Amazon EKS 控制平面在 AWS 托管的 Amazon Virtual Private Cloud(Amazon VPC)中运行 Kubernetes 版本 1.36,与客户 VPC 分离。它连接到客户 VPC 私有子网中的 EC2 工作节点。

一个 m7i.large 系统节点承载 operator 控制器和 KAI Scheduler。KAI Scheduler 将两个 Pod 都放置在带污点的 g5.xlarge 上,该实例配有一块 A10G,包含 23,028 MiB 的 GPU 内存。

每个 Pod 有 8 GiB 的 GPU 内存限制,并分配 6 GiB 的 GPU 内存。GPU 工作节点使用自定义 AL2023,搭配 NVIDIA R615 驱动分支、NVIDIA Container Toolkit 和 containerd。它运行带有 Node Resource Interface(NRI)集成的 fractiond,并使用 MPS 进行共享。metricsd 守护进程导出每个 Pod 的 GPU 内存指标。

在 us-east-2 中,AWS 托管的 EKS 1.36 控制平面连接到 VPC 中私有的 m7i.large 系统节点和 g5.xlarge GPU 工作节点。KAI 在一块 A10G 上调度两个 Pod。每个 Pod 有 8 GiB 限制并分配 6 GiB。AL2023 R615 工作节点使用 NRI、fractiond、MPS 和按 Pod 的 metricsd。
在 us-east-2 中,AWS 托管的 EKS 1.36 控制平面连接到 VPC 中私有的 m7i.large 系统节点和 g5.xlarge GPU 工作节点。KAI 在一块 A10G 上调度两个 Pod。每个 Pod 有 8 GiB 限制并分配 6 GiB。AL2023 R615 工作节点使用 NRI、fractiond、MPS 和按 Pod 的 metricsd。

图 1:在 Amazon EKS 中一块 A10G 上两个 GPU 内存契约的已验证示例

实现演练

本演练使用 AWS Samples 仓库。确认前提条件和已验证的组件版本,然后完成步骤 1 到 10。

前提条件

使用一个具有 Amazon EKS、AWS CloudFormation、Amazon VPC、Amazon EC2、Amazon Elastic Block Store(Amazon EBS)、AWS Identity and Access Management(IAM)以及用于 Amazon Machine Image(AMI)发现的 AWS Systems Manager 权限的 AWS 账户。确认 g5.xlarge、系统节点和临时 m5.xlarge 镜像构建器的配额与容量。安装 AWS CLI v2、eksctl、kubectl、Helm、Packer、Git、jq 和 curl。

使用你常用的 AWS 凭证提供方:命名配置文件、AWS IAM Identity Center、代入角色或访问密钥环境变量。优先使用临时凭证。使用临时访问密钥时需要 AWS_SESSION_TOKEN。示例使用 us-east-2。其他区域必须支持所选的 Amazon EKS 版本和实例类型。

在另选 GPU 之前,请查看 NVIDIA 的 GPU Operator 硬件列表、所选驱动的硬件支持以及 GPU Fractioning Operator 的前提条件。仅硬件支持并不能确立 fractioning 兼容性。本演练仅验证 G5/A10G 配置。AMI 构建面向 x86_64。检查 CUDA 兼容性和内存余量:两个 8 GiB 契约需要为两个契约和运行时开销留出空间。较小的设备需要较小的契约并调整探针。

本演练会创建可计费资源,包括 Amazon EKS 控制平面、NAT 网关、实例、卷和 AMI 快照。请使用一次性环境,并在验证完成后执行清理。

使用已验证的 AL2023 栈

在验证时,EKS 优化的 AL2023 NVIDIA 镜像提供 R580 和 R595 驱动分支。GPU Fractioning Operator v0.1.7 需要 R615 或更新版本。R615 生命周期较短,且不是 GPU Operator 的默认版本。本示例构建一个自定义的标准 Amazon EKS 1.36 AL2023 镜像,驱动和工具包由 AMI 自带。它不使用在其他操作系统上由 operator 管理的驱动容器。该表记录的是实验室验证,而非厂商支持认证。

组件已验证版本
Amazon EKS1.36
GPUNVIDIA A10G,23,028 MiB
NVIDIA 驱动 / Container Toolkit615.71.10 / 1.20.1-1
containerd2.3.5,带 NRI
GPU Operator / device plugin26.7.1 / 0.20.1
KAI Scheduler / Fractioning Operator0.18.5 / 0.1.7

我们于 2026 年 10 月 22 日使用 NVIDIA driver 615.71.10 验证了本演练。2026 年 11 月 18 日,在更新 GPU 节点污点后,我们使用相同驱动的镜像重复了除 Step 3 镜像构建之外的每一步。结果一致。下表列出的是已测试的组件版本,并非永久支持矩阵。更改任何组件前,请重新查阅 Amazon EKS AMI 文档和 NVIDIA 先决条件。

Step 1: 克隆并配置

克隆仓库,然后根据提供的示例创建本地配置文件并限制其权限:


        git clone https://github.com/aws-samples/sample-code-for-gpu-fractioning-on-eks.git
cd sample-code-for-gpu-fractioning-on-eks
cp walkthrough.env.example walkthrough.env
chmod 600 walkthrough.env
      

克隆后,使用 walkthrough.env 进行配置,并为每个阶段运行 run.sh。生成的文件和 kubeconfig 保留在被忽略的 .state 目录中。GPU_INSTANCE_TYPE 选择实例类型。仅更改它并不能建立兼容性。

walkthrough.env 中的默认值和可选身份验证设置


        AWS_REGION=us-east-2
CLUSTER_NAME=runai-fractioning-blog
EKS_VERSION=1.36
GPU_INSTANCE_TYPE=g5.xlarge
NVIDIA_DRIVER_VERSION=615.71.10

# Choose a profile or access-key variables, not both.
# AWS_PROFILE=my-profile
# AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY_ID
# AWS_SECRET_ACCESS_KEY=YOUR_SECRET_ACCESS_KEY
# AWS_SESSION_TOKEN=YOUR_SESSION_TOKEN
      

切勿提交凭据。本地配置文件已被 Git 忽略。在预置资源前确认当前身份:


        ./run.sh check
      

单独运行各阶段以检查结果,或使用 ./run.sh walkthrough 运行至内存限制测试。清理始终是单独的操作。

Step 2: 创建一次性集群

运行以下命令创建一次性 Amazon EKS 集群及其系统节点:


        ./run.sh create-cluster
      

该命令会预置一个运行 Kubernetes 版本 1.36 的 Amazon EKS 集群、一个带单个 NAT 网关的专用 VPC、OpenID Connect (OIDC) 集成,以及一个私有 m7i.large 托管节点。

config/eksctl-cluster.yaml.tpl 中的选定字段


        iam:
  withOIDC: true
vpc:
  nat:
    gateway: Single
managedNodeGroups:
  - name: system-ondemand
    instanceType: m7i.large
    desiredCapacity: 1
    privateNetworking: true
      

Step 3: 构建自定义 AL2023 镜像

运行以下命令构建带 R615 驱动分支的自定义 AL2023 镜像:


        ./run.sh build-ami
      

该脚本会发现一个公共构建子网,以及适用于 AL2023 上 Kubernetes 1.36 的推荐标准 Amazon EKS AMI。Packer 安装 R615 驱动分支的当前补丁版本和 toolkit,配置 NVIDIA 运行时,检查包状态,并创建加密镜像。特定区域的 AMI ID 存储在 .state/ami-id 中。

NVIDIA_DRIVER_VERSION 选择 R615 分支。它不是精确的补丁固定。该工作流会记录发现的驱动版本及其 AMI ID,并在 AMI 和节点组标签中使用该版本。请阅读 .state/installed-driver-version 以查看你的构建中观察到的版本。对于生产环境,请在你自己的构建中固定确切的包和基础镜像,并验证受支持的驱动分支升级。

你之所以需要此步骤,仅因为验证时 EKS 优化的 AL2023 NVIDIA AMI 未包含 R615 驱动分支。一旦其为你所用 GPU 选择的驱动以及其余主机先决条件满足 GPU Fractioning Operator 的要求,请优先使用 EKS 优化的 NVIDIA AMI。请查看 GitHub 上 Amazon EKS AMI 发行版中的驱动版本。该示例的脚本目前需要 R615 驱动以及镜像构建生成的元数据,因此使用原版 AMI 也需要修改脚本。

ami/eks-al2023-r615.pkr.hcl 中的相关 Packer 设置


        source "amazon-ebs" "eks_al2023_r615" {
  source_ami = var.source_ami_id
  region = var.aws_region
  encrypt_boot = true
  metadata_options {
    http_tokens = "required"
  }
}
      

SOURCE_AMI_ID 和 PACKER_SUBNET_ID 是用于指定已批准的基础镜像或构建子网的可选覆盖项。当操作系统或 GPU 栈发生变化时,重新构建并测试镜像。

Step 4: Add the GPU worker

运行以下命令,添加一个使用自定义镜像的 GPU 托管节点组:


        ./run.sh add-gpu-node
      

默认情况下,该托管节点组使用自定义镜像,并保持为一个 On-Demand g5.xlarge,即经过验证的 GPU 工作节点。GPU 污点会排除普通工作负载。该脚本禁用了 eksctl 的 NVIDIA device-plugin 安装,因为该组件由 GPU Operator 管理。

config/eksctl-gpu-nodegroup.yaml.tpl 中的部分字段


        managedNodeGroups:
  - name: gpu-g5-r615-ondemand
    instanceType: g5.xlarge
    ami: <generated-ami-id>
    amiFamily: AmazonLinux2023
    desiredCapacity: 1
    minSize: 1
    maxSize: 1
    privateNetworking: true
    taints:
      - key: nvidia.com/gpu
        effect: NoSchedule
      

Step 5: Install GPU Operator and inspect the host

运行以下命令安装 GPU Operator 并检查 GPU 工作节点的主机配置:


        ./run.sh install-gpu-operator
      

GPU Operator 26.7.1 提供 device plugin 和 Kubernetes 集成。其配置保留了镜像自有的驱动和工具包:


        driver:
  enabled: false
toolkit:
  enabled: false
      

同一命令会在 GPU 工作节点上运行一个临时的特权检查 Pod,打印主机配置,然后删除该 Pod。经过验证的节点报告如下:

观察到的宿主机配置


        GPU: NVIDIA A10G, 23028 MiB
Driver: 615.71.10
NVIDIA Container Toolkit: 1.20.1-1
containerd: 2.3.5
cgroup filesystem: cgroup2fs
NRI socket paths:
  /var/run/nri/nri.sock
  /run/nri/nri.sock
      

在这个 AL2023 节点上,/var/run 是指向 /run 的符号链接。两个路径指向同一个套接字。请将特权检查限制在一次性环境中,并确认该 Pod 已被删除。

Step 6: Establish the whole-GPU baseline

运行以下命令,在安装分片功能之前测试整卡 GPU 调度:


        ./run.sh baseline
      

每个基线 Pod 都将 nvidia.com/gpu 的请求和限制设置为 1。该测试假设只有一个可用的物理 GPU,且未启用共享:一个 Pod 运行,另一个保持 Pending。这展示了在安装分片功能之前的整设备调度约束。在多 GPU 节点上,请调整此基线,并验证两个分片工作负载使用同一块 GPU。

测得的基线结果


        NAME          READY   STATUS    NODE
whole-gpu-a   1/1     Running   <gpu-node>
whole-gpu-b   0/1     Pending   <none>
      

脚本会检查此状态并删除两个基线 Pod。

Step 7: Install KAI Scheduler and GPU Fractioning Operator

运行以下命令安装 KAI Scheduler,其中包含 GPU Fractioning Operator:


        ./run.sh install-kai
      

固定版本的 KAI Scheduler 0.18.5 chart 包含 GPU Fractioning Operator 0.1.7。这些 values 启用了 NvFractions 和按 Pod 指标,同时保留 GPU 栈版本检查。可选的 nvidia.com/container.<name>.gpu-compute.mode 注解用于选择计算模式。这些工作负载不改变默认值。

helm/kai-values.yaml 中的相关字段


        global:
  gpuSharingMode: NvFractions
  nvFractions:
    set: true
gpu-fractioning:
  metricsAgent:
    enabled: true
  skipGpuStackVersionChecks: false
      

在验证中,FractiondReady、MpsdReady 和 Ready 均为 True。DriverUpgradeInProgress 为 False,原因为 NoDriverUpgrade,这与 AMI 保留驱动所有权一致。

Step 8: Run the positive sharing test

运行以下命令部署两个具有 8 GiB GPU 内存契约的 Pod:


        ./run.sh share
      

每个 Pod 都将内存请求和限制设置为 8 GiB,并选择 kai-scheduler。两者都不请求整块 nvidia.com/gpu 资源。仓库会应用这些调度字段,并运行一个分配 6 GiB 的 CUDA 探针:

kubernetes/fraction-8gi-pods.yaml 中的关键字段

使用 NVIDIA Run:ai GPU Fractioning on Amazon EKS


        metadata:
  annotations:
    nvidia.com/container.gpu-workload.gpu-memory.request: 8Gi
    nvidia.com/container.gpu-workload.gpu-memory.limit: 8Gi
spec:
  schedulerName: kai-scheduler
  runtimeClassName: nvidia
      

实测的正向结果


        NAME             READY   STATUS    NODE
fraction-8gi-a   1/1     Running   <same-gpu-node>
fraction-8gi-b   1/1     Running   <same-gpu-node>
      

脚本会校验节点名与 GPU UUID 是否一致。在验证中,两个 Pod 都看到 8,192 MiB,并报告 allocation_succeeded_mib=6144。这些检查确认了以下三点:两个 Pod 被放置在同一块物理 GPU 上,设备视图受到限制,并且各自在其合约范围内分配成功。

每个 Pod 实测的分配输出


        NVIDIA_GPU_MEMORY_LIMIT=8192
requested_allocation_mib=6144
allocation_succeeded_mib=6144
      

在两个 Pod 保持活跃期间观察内存


        ./run.sh metrics
      

gpu_fractioning_gpu_memory_used_bytes 指标按 Pod 和 GPU UUID 归属内存。观测到的每 Pod 6,394 MiB(约 6.24 GiB)比探针的 6,144 MiB 分配量高出 250 MiB。指标可能包含 CUDA 上下文和运行时开销。本实验并未测量这部分差异的构成。在监控这块共享设备时,请将工作负载身份与 request、limit 和使用量数值一并保留。

每个 Pod 实测的指标序列


        gpu_fractioning_gpu_memory_used_bytes{
  gpu_uuid="<same-gpu-uuid>",
  namespace="runai-fractioning-test",
  pod="fraction-8gi-a"} 6.704594944e+09

gpu_fractioning_gpu_memory_used_bytes{
  gpu_uuid="<same-gpu-uuid>",
  namespace="runai-fractioning-test",
  pod="fraction-8gi-b"} 6.704594944e+09
      

步骤 9:验证超过限额时被拒绝

运行以下命令,测试一次超出 8 GiB 合约的分配:


        ./run.sh limit
      

该命令会删除正向测试的 Pod,并创建一个带有 8 GiB 合约、尝试进行 9 GiB 分配的 Pod。探针报告:

实测的超限结果


        NVIDIA_GPU_MEMORY_LIMIT=8192
requested_allocation_mib=9216
allocation_failed=out of memory
      

实测的负向测试 Pod 状态


        NAME                      READY   STATUS      NODE
fraction-8gi-over-limit   0/1     Completed   <gpu-node>
      

这里 cudaMalloc 返回内存不足错误,探针在退出前处理了该错误,并以退出码 0 结束。Completed 是预期状态,而不是 OOMKilled。这演示的是分配被拒绝,而非容器被终止或一般性的故障隔离。

步骤 10:清理

在删除集群之前先获取 VPC ID。后续的独立检查使用默认的集群名称和区域。如果你改过配置,请替换为你自己的值。

获取 VPC ID


        VPC_ID=$(aws eks describe-cluster \
  --name runai-fractioning-blog --region us-east-2 \
  --query cluster.resourcesVpcConfig.vpcId --output text)
      

删除一次性环境


        ./run.sh cleanup
      

标准清理会删除测试命名空间、Helm release 和一次性集群,同时保留自定义 AMI 及其 Amazon EBS 快照。

验证资源已删除


        aws eks describe-cluster \
  --name runai-fractioning-blog --region us-east-2
aws cloudformation describe-stacks \
  --stack-name eksctl-runai-fractioning-blog-cluster \
  --region us-east-2
aws ec2 describe-vpcs --vpc-ids "$VPC_ID" --region us-east-2
      

对于已删除的资源,应当会返回明确的 resource-not-found 响应。认证错误或权限错误并不能证明资源已删除。此外还应检查剩余的节点组和带集群标签的实例。如果清理失败,请检查 CloudFormation 事件,并在重试之前解决其拥有的依赖关系。Amazon EKS 端点不存在,并不能证明其 VPC 已经消失。

只有当自定义 AMI 及其 Amazon EBS 快照不再需要时,才使用 ./run.sh cleanup-all。如果镜像删除被拒绝,请确认 AMI ID 和样本归属标签。不要绕过该保护措施。

生产环境注意事项

文章标题:Using NVIDIA Run:ai GPU Fractioning on Amazon EKS

正文: 将此视为一次行为验证。使用可信工作负载,并针对 fraction 请求应用最小权限 IAM、命名空间控制、已批准镜像和准入规则。当需要更强隔离时,在受支持的硬件上选择整块 GPU 或 MIG。

固定版本的 fractioning 守护进程使用特权容器、主机 PID 访问以及 NRI/MPS 主机挂载。请将其部署和配置限制为仅可信管理员可操作。

为 CUDA 上下文、缓存、批处理和运行时开销留出余量。在并发负载下测量延迟和吞吐量。监控分配失败、MPS 健康状况、NRI 连通性和 GPU 错误。将基础 AMI、驱动、工具包、设备插件、operator、调度器和工作负载镜像固定为一个经过测试的组合。在 rollout 前重建镜像并测试回滚。

本演练需要预先配置好的 GPU 容量。它不配置也不验证 GPU-fraction-aware 自动扩缩容。Fractional Pod 选择 kai-scheduler,不请求 nvidia.com/gpu 资源,并使用 nodeSelector 指向固定为一个节点的节点组。Karpenter 对次级调度器的支持是一个尚未实现的功能请求(GitHub 上的 issue #742)。自定义镜像无法在 Amazon EKS Auto Mode 管理的节点上运行,因为 Auto Mode 会选择并管理这些节点的 AMI。集群可以将 Auto Mode 管理的节点与托管节点组混合使用,但我们未在此类集群中验证本演练。

使用 Karpenter 的团队可以在 EC2NodeClass 中通过 ID 引用同一个自定义 AMI。自动扩缩容限制仍然适用。我们未验证此路径。

KAI Scheduler 是一个次级调度器。它为选择它的 Pod 处理排队和放置。如果你已经在使用 Kueue,在采用 KAI Scheduler 之前,请先确定由哪个组件负责 GPU 工作负载的排队。

我们建议在 GPU 节点上运行 Amazon EKS 节点监控代理。在 2026 年 11 月 18 日的一次回归运行中,该代理在启用 MPS 共享的自定义 R615 镜像上运行,并在整个共享和限制测试期间报告 GPU 状况健康。该次运行未测试故障检测。由于 GPU Operator 已经运行 Data Center GPU Manager (DCGM) 主机引擎,请将该代理配置为使用该主机引擎,而不是其捆绑的主机引擎。

结论

在本文中,我们展示了如何在 Amazon EKS 上使用自定义 AL2023 镜像配置 GPU 显存 fractioning,并以 G5/A10G 作为经过验证的示例。在检查前置条件并验证所选配置后,该方法可扩展到兼容的 NVIDIA GPU。你建立了整块 GPU 基线,在同一块 GPU 上运行了两个有界工作负载,检查了每个 Pod 的内存使用情况,并验证了超过限制的分配会被拒绝。当工作负载内存适配时,fractioning 可以改善对现有容量的使用。生产采用还需要隔离控制和性能测试。

要重复该实验,请克隆 AWS Samples 仓库,并将你的结果与其验证过的证据进行比较。在将该示例适配到你的工作负载之前,请查阅 GPU Fractioning Operator 文档和 Amazon EKS accelerated AMI 指南。

本文中的内容和观点属于第三方作者,AWS 不对本文内容或准确性负责。

关于作者

The translation is machine-generated and individual terms may be off. Nothing is rewritten or cut; the original is authoritative.

Published by AWS Machine Learning
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗