Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esempio di suddivisione dei dati di allocazione dei costi per istanze accelerate
Lo scopo del seguente esempio è mostrare come vengono calcolati i dati di suddivisione dei costi calcolando il costo dello spazio dei nomi e dei pod Kubernetes nei cluster Amazon EKS. Le tariffe utilizzate nell'esempio sono solo a scopo illustrativo.
Hai il seguente utilizzo in una sola ora:
+ Un'unica istanza EC2 che esegue quattro pod su due namespace e che desideri comprendere i costi di ogni namespace.
+ L'istanza EC2 è p3.16xlarge con 8 GPU, 64 vCPU e 488 GB di RAM.
+ Il costo ammortizzato dell'istanza è di 10 USD all'ora.
I dati di allocazione dei costi suddivisi normalizzano il costo per risorsa in base a un rapporto relativo tra GPU :( cpu: memoria) di 9:1. Ciò implica che un'unità di GPU costa 9 volte tanto quanto un'unità di CPU e memoria. Alla CPU e alla memoria viene quindi assegnato un peso di 9:1. Per un'istanza EC2 non accelerata, verrà adottato il comportamento predefinito corrente, ovvero cpu: memory weight predefinito è 9:1.
## Fase 1: Calcola il costo unitario
Sulla base delle risorse di CPU e memoria sull'istanza EC2 e utilizzando il rapporto sopra menzionato, i dati di Split Cost Allocation calcolano innanzitutto il costo unitario per 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`
**Tabella 1: Calcolo del costo unitario**
| Istanza | Tipo di istanza | vCPU disponibile | GPU disponibile | \$1\$1 | Memoria disponibile | Costo orario ammortizzato | Costo per vCPU all'ora | Costo per ora della GPU | Costo per GB all'ora |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Istanza 1 | p3.16xlarge | 64 | 8 | | 488 | \$110 | 0,05 \$1 | \$10,50 | 0.005 |
## Fase 2: Calcolare la capacità allocata e non utilizzata
Capacità allocata
La GPU, la vcpu e la memoria allocate al pod Kubernetes dall'istanza EC2 principale, definita come la capacità massima (riservata, utilizzata)
Capacità inutilizzata dell'istanza
La capacità inutilizzata di GPU, vcpu e memoria
`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`
In questo esempio, l'istanza utilizza più CPU rispetto all'abbonamento, attribuita al Pod 2 che utilizzava più GPU e vcpu di quelle riservate.
**Tabella 2: Calcola la capacità allocata e non utilizzata**
| Nome del pod | Namespace | vcpu riservato | vcpu Usato | vcpu allocato | GPU riservata | GPU utilizzata | GPU allocata | Memoria riservata | Memoria utilizzata | Memoria allocata |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Pod 1 | Namespace 1 | 16 | 4 | 16 | 1 | 1 | 1 | 100 | 60 | 100 |
| Pod 2 | Spazio dei nomi 2 | 16 | 18 | 18 | 2 | 3 | 3 | 100 | 140 | 140 |
| Pod 3 | Spazio dei nomi 1 | 16 | 4 | 16 | 2 | 1 | 2 | 100 | 60 | 100 |
| Pod 4 | Namespace 2 | 16 | 4 | 16 | 2 | 2 | 2 | 100 | 40 | 100 |
| Non utilizzato | Non utilizzato | 0 | 34 | 0 | 1 | 1 | 0 | 88 | 188 | 48 |
| \$1\$1\$1 | | 64 | 32 | 66 | 8 | 8 | 8 | 488 | 488 | 488 |
## Fase 3: Calcola i rapporti di utilizzo e utilizzo suddivisi
Dividi il rapporto di utilizzo
La percentuale di CPU o memoria utilizzata dal pod Kubernetes rispetto alla CPU o memoria complessiva disponibile sull'istanza EC2.
Rapporto non utilizzato
La percentuale di CPU o memoria utilizzata dal pod Kubernetes rispetto alla CPU o memoria complessive utilizzate sull'istanza EC2 (ovvero, senza tenere conto della CPU o della memoria non utilizzate sull'istanza).
La percentuale di CPU o memoria utilizzata dal Kubernetes Pod rispetto alla CPU o memoria complessiva disponibile sull'istanza 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`
**Tabella 3: Rapporti di utilizzo del calcolo**
| Nome del pod | Namespace | Utilizzo di vcpu | rapporto di suddivisione vcpu | Utilizzo della GPU | Rapporto di suddivisione della GPU | Utilizzo della memoria | Rapporto di suddivisione della memoria |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 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 |
| Cialda 4 | Namespace 2 | 0,242 | 0 | 0.25 | 0 | 0,205 | 0.227 |
| Non utilizzato | Non utilizzato | 0 | | | | 0,098 | |
| | | 1 | 0 | 1 | 0 | 1 | 1 |
## Fase 4: Calcola il costo suddiviso e i costi non utilizzati
Suddivisione del costo
L'allocazione del costo in base all'utilizzo del costo dell'istanza EC2 in base all'utilizzo di CPU e memoria allocato dai Kubernetes Pods
Costo delle istanze non utilizzate
Il costo delle risorse di CPU o memoria non utilizzate sull'istanza
`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`
[Nota: costo non utilizzato = rapporto di utilità inutilizzato \$1 risorsa totale\$1 costo orario della risorsa]
**Tabella 4 - Riepilogo dei costi suddivisi e non utilizzati calcolati ogni ora per tutti i pod in esecuzione all'interno del cluster**
| Nome del pod | Namespace | Costo diviso | Costo non utilizzato | Costo totale |
| --- | --- | --- | --- | --- |
| Pod 1 | Namespace 1 | 1,85\$1 | \$10,06 | \$11,91 |
| Pod 2 | Namespace 2 | 3,18\$1 | \$10,09 | 3,26\$1 |
| Pod 3 | Namespace 1 | \$12,35 | \$10,06 | \$12,41 |
| Cialda 4 | Namespace 2 | \$12,35 | \$10,06 | \$12,41 |
| Totale | | | | \$110 |