Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
Exemple de données de répartition des coûts fractionnés pour les instances accélérées
L'objectif de l'exemple suivant est de vous montrer comment les données de répartition des coûts partagés sont calculées en calculant le coût de l'espace de noms et des pods Kubernetes dans les clusters Amazon EKS. Les taux utilisés dans cet exemple sont fournis à titre indicatif uniquement.
Vous pouvez utiliser les produits suivants en une heure :
-
EC2 Instance unique qui exécute quatre modules dans deux espaces de noms, et vous souhaitez comprendre les coûts de chaque espace de noms.
-
L' EC2 instance est p3.16xlarge avec 8 GPU, 64 vCPU et 488 Go de RAM.
-
Le coût amorti de l'instance est de 10 $/heure.
Les données de répartition des coûts normalisent le coût par ressource sur la base d'un ratio relatif GPU : (cpu : mémoire) de 9:1. Cela implique qu'une unité de processeur graphique coûte 9 fois plus cher qu'une unité de processeur et de mémoire. Une pondération de 9:1. est ensuite attribuée au processeur et à la mémoire. Pour une EC2 instance non accélérée, le comportement par défaut actuel sera adopté, à savoir cpu : le poids de la mémoire par défaut est de 9:1.
Étape 1 : Calculez le coût unitaire
Sur la base des ressources du processeur et de la mémoire de l' EC2 instance et en utilisant le ratio mentionné ci-dessus, les données de répartition des coûts calculent d'abord le coût unitaire par GPU, vCPU-hr et 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
| Instance | Type d'instance | vCPU disponible | GPU disponible | ** | Mémoire disponible | Coût horaire amorti | Coût par heure de processeur virtuel | Coût par heure de processeur graphique | Coût par Go par heure |
|---|---|---|---|---|---|---|---|---|---|
| Instance 1 | p3.16xlarge | 64 | 8 | 488 | 10$ | 0,05 USD | 0,50$ | 0.005 |
Étape 2 : Calculez la capacité allouée et inutilisée
- Capacité allouée
-
Le GPU, le processeur virtuel et la mémoire alloués au pod Kubernetes depuis l' EC2 instance parent, définis comme la capacité maximale (réservée, utilisée)
- Capacité inutilisée de l'instance
-
La capacité inutilisée du GPU, du processeur virtuel et de la mémoire
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
Dans cet exemple, le processeur de l'instance est supérieur à l'abonnement, attribué au Pod 2 qui a utilisé plus de GPU et de vcpu que ce qui était réservé.
| Nom du pod | Espace de noms | vcpu Réservé | vcpu utilisé | vcpu alloué | GPU réservé | GPU utilisé | GPU alloué | Mémoire réservée | Mémoire utilisée | Mémoire allouée |
|---|---|---|---|---|---|---|---|---|---|---|
| Capsule 1 | Espace de noms 1 | 16 | 4 | 16 | 1 | 1 | 1 | 100 | 60 | 100 |
| Capsule 2 | Espace de noms 2 | 16 | 18 | 18 | 2 | 3 | 3 | 100 | 140 | 140 |
| Capsule 3 | Espace de noms 1 | 16 | 4 | 16 | 2 | 1 | 2 | 100 | 60 | 100 |
| Capsule 4 | Espace de noms 2 | 16 | 4 | 16 | 2 | 2 | 2 | 100 | 40 | 100 |
| Inutilisé | Inutilisé | 0 | 34 | 0 | 1 | 1 | 0 | 88 | 188 | 48 |
| *** | 64 | 32 | 66 | 8 | 8 | 8 | 488 | 488 | 488 |
Étape 3 : Calculez le partage de l'utilisation et des ratios d'utilisation
- Taux d'utilisation fractionné
-
Pourcentage de processeur ou de mémoire utilisé par le pod Kubernetes par rapport à l'ensemble du processeur ou de la mémoire disponible sur l'instance. EC2
- Ratio non utilisé
-
Le pourcentage de processeur ou de mémoire utilisé par le pod Kubernetes par rapport à l'ensemble du processeur ou de la mémoire utilisé sur l' EC2 instance (c'est-à-dire sans tenir compte du processeur ou de la mémoire inutilisés de l'instance).
Pourcentage de processeur ou de mémoire utilisé par le Kubernetes Pod par rapport à l'ensemble du processeur ou de la mémoire disponible sur l'instance. 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
| Nom du pod | Espace de noms | Utilisation du processeur virtuel | Rapport de division du processeur | Utilisation du GPU | Rapport de division du processeur graphique | Utilisation de la mémoire | Rapport de répartition de la mémoire |
|---|---|---|---|---|---|---|---|
| Capsule 1 | Espace de noms 1 | 0,242 | 0 | 0.125 | 0 | 0,205 | 0.227 |
| Capsule 2 | Espace de noms 2 | 0,277 | 0 | 0,375 | 0 | 0,287 | 0,318 |
| Capsule 3 | Espace de noms 1 | 0,242 | 0 | 0.25 | 0 | 0,205 | 0.227 |
| Capsule 4 | Espace de noms 2 | 0,242 | 0 | 0.25 | 0 | 0,205 | 0.227 |
| Inutilisé | Inutilisé | 0 | 0,098 | ||||
| 1 | 0 | 1 | 0 | 1 | 1 |
Étape 4 : Calculez le coût partagé et les coûts non utilisés
- Coût partagé
-
La répartition du coût par utilisation du coût de l' EC2 instance en fonction de l'utilisation du processeur et de la mémoire alloués par les pods Kubernetes
- Coût d'instance non utilisé
-
Le coût des ressources de processeur ou de mémoire non utilisées sur l'instance
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
[Remarque : coût inutilisé = ratio d'utilité inutilisé * ressource totale * coût horaire de la ressource]
| Nom du pod | Espace de noms | Coût partagé | Coût non utilisé | Coût total |
|---|---|---|---|---|
| Capsule 1 | Espace de noms 1 | 1,85$ | 0,06 $ | 1,91$ |
| Capsule 2 | Espace de noms 2 | 3,18$ | 0,09$ | 3,26$ |
| Capsule 3 | Espace de noms 1 | 2,35$ | 0,06 $ | 2,41$ |
| Capsule 4 | Espace de noms 2 | 2,35$ | 0,06 $ | 2,41$ |
| Total | 10$ |
