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

# 加速型实例的拆分成本分配数据示例
<a name="example-accelerated-instances"></a>

以下示例的目的是，向您说明如何计算 Amazon EKS 集群中的 Kubernetes 命名空间和容器组（pod）的成本，从而计算拆分成本分配数据。在整个示例中使用的费率仅用于说明目的。

您在一小时内具有以下使用量：
+ 您拥有在两个命名空间中运行四个容器组（pod）的单个 EC2 实例，并且想要了解每个命名空间的成本。
+ EC2 实例是 p3.16xlarge，有 8 个 GPU、64 个 vCPU 和 488 GB RAM。
+ 实例的摊销成本为每小时 10 美元。

拆分成本分配数据根据 GPU:（CPU:内存）的相对比率为 9:1，对每个资源的成本进行标准化分摊。这意味着，一个单位的 GPU 成本高达 CPU 和内存单位成本的 9 倍。然后将 CPU 和内存的权重分配为 9:1。对于非加速型 EC2 实例，将采用当前的默认行为，即 CPU:内存权重默认为 9:1。

## 步骤 1：计算单位成本
<a name="w2aac32c21c13c31c11"></a>

根据 EC2 实例上的 CPU 和内存资源，并使用上述比率，拆分成本分配数据先计算每个 GPU、每 vCPU 小时和每 GB 小时的单位成本。

`GPU-Weight =9`

`GPU+Memory-Weight =1`

`CPU-Weight=1*.9=.9`

`Memory-Weight=1*0.1=0.1`

`Hourly-Instance-Cost=$10`

`GPU-Available=8`

`Memory-Available=488`

`CPU-Available=64`

`UnitCostPerResource = Hourly-Instance-Cost/(( GPU-Weight * GPU-Available) + (Memory-Weight * Memory-Available) + (CPU-Weight * CPU-Available)) = $10/((9*8gpu)+ (0.1 * 488GB) + (.9 * 64vcpu)) = $0.056`

`Cost-per-GPU-Hour = GPU-Weight * UnitCostPerResource = 9 * $0.056 = $0.504`

`Cost-per-vcpu-Hour = CPU-Weight * UnitCostPerResource = .9 * $0.056 = $0.05`

`Cost-per-GB-Hour = Memory-Weight * UnitCostPerResource = .1 * $0.056 = $0.00506`


**表 1：单位成本计算**  

| 实例 | 实例类型 | 可用 vCPU | 可用 GPU | \$1\$1 | 可用内存 | 每小时摊销成本 | 每 vCPU 小时成本 | 每 GPU 小时成本 | 每 GB 小时成本 | 
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | 
| 实例 1 | p3.16xlarge | 64 | 8 |  | 488 | 10 美元 | 0.05 美元 | 0.50 美元 | 0.005 | 

## 步骤 2：计算已分配容量和未使用的容量
<a name="w2aac32c21c13c31c13"></a>

已分配容量  
从父 EC2 实例中分配给 Kubernetes 容器组（pod）的 GPU、vCPU 和内存，定义为最大（预留、已使用）容量

实例未使用的容量  
GPU、vCPU 和内存的未使用容量

`Pod1-Allocated-GPU = Max (1 GPU, 1 GPU) = 1 GPU`

`Pod1-Allocated-vcpu = Max (16 vcpu, 4 vcpu) = 16 vcpu`

`Pod1-Allocated-Memory = Max (100 GB, 60 GB) = 100 GB`

`Instance-Unused-GPU = Max (GPU-Available - SUM(Allocated-vcpu), 0)`

`= Max (8 – 8, 0) = 0`

`Instance-Unused-vcpu = Max (CPU-Available - SUM(Allocated-vcpu), 0)`

`= Max (16 – 18, 0) = 0`

`Instance-Unused-Memory = Max (Memory-Available - SUM(Allocated-Memory), 0)`

`= Max (488 – 440, 0) = 48 GB`

在该示例中，实例过度订阅 CPU，这是由于容器组（pod）2 实际使用的 GPU 和 vCPU 数量超过了预留数量。


**表 2：计算已分配容量和未使用的容量**  

| 容器组（pod）名称 | 命名空间 | 预留的 vCPU | 使用的 vCPU | 分配的 vCPU | 预留的 GPU | 使用的 GPU | 分配的 GPU | 预留的内存 | 使用的内存 | 分配的内存 | 
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | 
| 容器组 1 | 命名空间 1 | 16 | 4 | 16 | 1 | 1 | 1 | 100 | 60 | 100 | 
| 容器组 2 | 命名空间 2 | 16 | 18 | 18 | 2 | 3 | 3 | 100 | 140 | 140 | 
| 容器组 3 | 命名空间 1 | 16 | 4 | 16 | 2 | 1 | 2 | 100 | 60 | 100 | 
| Pod 4 | 命名空间 2 | 16 | 4 | 16 | 2 | 2 | 2 | 100 | 40 | 100 | 
| 未使用 | 未使用 | 0 | 34 | 0 | 1 | 1 | 0 | 88 | 188 | 48 | 
| \$1\$1\$1 |  | 64 | 32 | 66 | 8 | 8 | 8 | 488 | 488 | 488 | 

## 步骤 3：计算拆分使用率和利用率
<a name="w2aac32c21c13c31c15"></a>

拆分使用率  
Kubernetes 容器组（pod）使用的 CPU 或内存占 EC2 实例上提供的总体 CPU 或内存的百分比。

未使用率  
Kubernetes 容器组（pod）使用的 CPU 或内存占 EC2 实例上使用的总体 CPU 或内存的百分比（即，不考虑实例上未使用的 CPU 或内存）。

Kubernetes 容器组（pod）使用的 CPU 或内存占 EC2 实例上提供的总体 CPU 或内存的百分比。

`Pod1-GPU-Utilization-Ratio = Allocated-GPU / Total-GPU`

`= 1 gpu / 8 gpu = 0.125`

`Pod1-vcpu-Utilization-Ratio = Allocated-vcpu / Total-vcpu`

`= 16 vcpu / 66 vcpu = 0.24`

`Pod1-Memory-Utilization-Ratio = Allocated-GB / Total-GB`

`= 100 GB/ 488GB = 0.205`

`Pod1-GPU-Split-Ratio = Pod1-GPU-Utilization-Ratio / (Total-GPU-Utilization-Ratio – Instance-Unused-GPU). Set to 0 if Instance-Unused-GPU = 0`

`= 0 since Instance-Unused-GPU is 0`

`Pod1-vcpu-Split-Ratio = Pod1-CPU-Utilization-Ratio / (Total-CPU-Utilization-Ratio – Instance-Unused-CPU). Set to 0 if Instance-Unused-CPU = 0`

`= 0 since Instance-Unused-CPU is 0`

`Pod1-Memory-Split-Ratio = Pod-Memory-Utilization-Ratio / (Total-Utilization-Ratio – Instance-Unused-Memory). Set to 0 if Instance-Unused-Memory = 0`

`= 0.204/ (1-0.102) = 0.227`


**表 3：计算利用率**  

| 容器组（pod）名称 | 命名空间 | vCPU 利用率 | vCPU 拆分率 | GPU 利用率 | GPU 拆分率 | 内存利用率 | 内存拆分率 | 
| --- | --- | --- | --- | --- | --- | --- | --- | 
| 容器组 1 | 命名空间 1 | 0.242 | 0 | 0.125 | 0 | 0.205 | 0.227 | 
| 容器组 2 | 命名空间 2 | 0.277 | 0 | 0.375 | 0 | 0.287 | 0.318 | 
| 容器组 3 | 命名空间 1 | 0.242 | 0 | 0.25 | 0 | 0.205 | 0.227 | 
| Pod 4 | 命名空间 2 | 0.242 | 0 | 0.25 | 0 | 0.205 | 0.227 | 
| 未使用 | 未使用 | 0 |  |  |  | 0.098 |  | 
|  |  | 1 | 0 | 1 | 0 | 1 | 1 | 

## 步骤 4：计算拆分成本和未使用成本
<a name="w2aac32c21c13c31c17"></a>

拆分成本  
EC2 实例成本的按使用付费成本分配，基于 Kubernetes 容器组（pod）使用的分配 CPU 和内存。

未使用实例成本  
实例上未使用的 CPU 或内存资源的成本

`Pod1-Split-Cost = (Pod1-GPU-Utilization-Ratio * GPU-Available * Cost per GPU-Hour) + (Pod1-vcpu-Utilization-Ratio * vcpu-Available * Cost per vcpu-Hour) + (Pod1-Memory-Utilization-Ratio * Memory-Available * Cost per GB-Hour)`

`= (.125*8gpu*$0.504) + (0.242 * 64 vcpu * $0.05) + (0.204 * 488GB * $0.00506) = 0.504+ 0.774 + 0.503 = $1.85`

`Pod1-Unused-Cost = (GPU-Split-Ratio * Unused-Cost) + (vcpu-Split-Ratio * Unused-Cost) + (Memory-Split-Ratio * Unused-Cost)`

`= (0*0*8*$0.504) + (0 * $0.05) + (0.227 *.102*488GB*$.00506) = $0.06`

`Pod1-Total-Split-Cost = Pod1-Split-Cost + Pod1-Unused-Cost = $1.85 + $0.06 = $1.91`

[注意：未使用成本 = 未使用的利用率 \$1 总资源量 \$1 资源每小时成本]


**表 4 - 每小时针对集群内运行的所有容器组（pod）计算得出的拆分成本和未使用成本摘要**  

| 容器组（pod）名称 | 命名空间 | 拆分成本 | 未使用成本 | 总成本 | 
| --- | --- | --- | --- | --- | 
| 容器组 1 | 命名空间 1 | 1.85 美元 | 0.06 | 1.91 美元 | 
| 容器组 2 | 命名空间 2 | 3.18 美元 | 0.09 美元 | 3.26 美元 | 
| 容器组 3 | 命名空间 1 | 2.35 | 0.06 | 2.41 美元 | 
| Pod 4 | 命名空间 2 | 2.35 | 0.06 | 2.41 美元 | 
| Total |  |  |  | 10 美元 |