As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Exemplo de dados de alocação de custos divididos para instâncias aceleradas
O objetivo do exemplo a seguir é mostrar como os dados de alocação de custos divididos são computados calculando o custo do namespace e pods do Kubernetes em clusters no Amazon EKS. As taxas usadas em todo o exemplo são apenas para fins ilustrativos.
Você tem o seguinte uso em uma única hora:
+ Instância única do EC2 que executa quatro pods em dois namespaces, e você quer entender os custos de cada namespace.
+ A instância do EC2 é p3.16xlarge com 8 GPUs, 64 vCPUs e 488 GB de RAM.
+ O custo amortizado da instância é de 10 USD/hora.
Os dados de alocação de custos divididos normalizam o custo por recurso com base em uma proporção relativa de GPU: (cpu: memória) de 9:1. Isso implica que uma unidade de GPU custa 9x mais do que uma unidade de CPU e memória. A CPU e a memória recebem então um peso de 9:1. Em relação a uma instância do EC2 não acelerada, o comportamento padrão atual será adotado, que é cpu: o peso da memória é padronizado como 9:1.
## Etapa 1: calcular o custo unitário
Com base nos recursos de CPU e memória na instância do EC2 e usando a proporção mencionada acima, os dados de alocação de custos divididos calculam primeiro o custo unitário por GPU, vCPU-HR e GB-h.
`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`
**Tabela 1: Cálculo do custo unitário**
| Instância | Tipo de instância | vCPU disponível | GPU disponível | \$1\$1 | Memória disponível | Custo amortizado por hora | Custo por vCPU por hora | Custo por GPU por hora | Custo por GB por hora |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Instância 1 | p3.16xlarge | 64 | 8 | | 488 | \$110 | 0,05 USD | \$10,50 | 0.005 |
## Etapa 2: calcular a capacidade alocada e não utilizada
Capacidade alocada
A GPU, a vcpu e a memória alocadas ao pod do Kubernetes por meio da instância do EC2 principal, definida como a capacidade máxima (usada e reservada).
Capacidade não utilizada da instância
A capacidade não utilizada da GPU, vcpu e memória
`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`
Neste exemplo, a instância tem excesso de assinatura de CPU, atribuído ao Pod 2, que usou mais GPU e vcpu do que o reservado.
**Tabela 2: Calcular a capacidade alocada e não utilizada**
| Nome do pod | Namespace | vcpu reservada | vcpu usada | vcpu alocada | GPU reservada | GPU usada | GPU alocada | Memória reservada | Memória usada | Memória alocada |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Pod 1 | Namespace 1 | 16 | 4 | 16 | 1 | 1 | 1 | 100 | 60 | 100 |
| Pod 2 | Namespace 2 | 16 | 18 | 18 | 2 | 3 | 3 | 100 | 140 | 140 |
| Pod 3 | Namespace 1 | 16 | 4 | 16 | 2 | 1 | 2 | 100 | 60 | 100 |
| Cápsula 4 | Namespace 2 | 16 | 4 | 16 | 2 | 2 | 2 | 100 | 40 | 100 |
| Não utilizado | Não utilizado | 0 | 34 | 0 | 1 | 1 | 0 | 88 | 188 | 48 |
| \$1\$1\$1 | | 64 | 32 | 66 | 8 | 8 | 8 | 488 | 488 | 488 |
## Etapa 3: calcular as proporções de utilização e uso dividido
Proporção de uso dividido
A porcentagem de CPU ou memória usada pelo pod do Kubernetes em comparação à CPU ou à memória geral disponível na instância do EC2.
Proporção não utilizada
A porcentagem de CPU ou memória usada pelo pod do Kubernetes em comparação à CPU ou à memória geral usada na instância do EC2 (ou seja, sem considerar a CPU ou a memória não utilizadas na instância).
A porcentagem de CPU ou memória usada pelo pod do Kubernetes em comparação à CPU ou à memória geral disponível na instância do EC2.
`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`
**Tabela 3: Proporão de utilização da computação**
| Nome do pod | Namespace | Utilização da vcpu | Proporção de divisão de vcpu | Utilização da GPU | Proporção de divisão da GPU | Utilização da memória | Proporção de divisão de memória |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Pod 1 | Namespace 1 | 0,242 | 0 | 0.125 | 0 | 0,205 | 0.227 |
| Pod 2 | Namespace 2 | 0,277 | 0 | 0,375 | 0 | 0,287 | 0,318 |
| Pod 3 | Namespace 1 | 0,242 | 0 | 0.25 | 0 | 0,205 | 0.227 |
| Cápsula 4 | Namespace 2 | 0,242 | 0 | 0.25 | 0 | 0,205 | 0.227 |
| Não utilizado | Não utilizado | 0 | | | | 0,098 | |
| | | 1 | 0 | 1 | 0 | 1 | 1 |
## Etapa 4: Calcular o custo dividido e os custos não utilizados
Custo dividido
A alocação do custo de pagamento por uso do custo da instância do EC2 com base no uso de CPU e memória alocados pelos pods do Kubernetes.
Custo da instância não utilizada
Custo da instância ou dos recursos de memória não utilizados na instância.
`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`
[Observação: custo não utilizado = proporção de uso não utilizada \$1 Recurso total \$1 custo por hora do recurso]
**Tabela 4 - Resumo dos custos divididos e não utilizados calculados a cada hora para todos os pods em execução no cluster**
| Nome do pod | Namespace | Custo dividido | Custo não utilizado | Custo total |
| --- | --- | --- | --- | --- |
| Pod 1 | Namespace 1 | \$11,85 | US\$1 0,06 | \$11,91 |
| Pod 2 | Namespace 2 | \$13,18 | \$10,09 | \$13,26 |
| Pod 3 | Namespace 1 | \$12,35 | US\$1 0,06 | \$12,41 |
| Cápsula 4 | Namespace 2 | \$12,35 | US\$1 0,06 | \$12,41 |
| Total | | | | \$110 |