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 :
+ Instance EC2 unique qui exécute quatre pods dans deux espaces de noms, et vous souhaitez comprendre les coûts de chaque espace de noms.
+ L'instance EC2 est une instance p3.16xlarge avec 8 GPU, 64 vCPU et 488 Go de RAM.
+ Le coût amorti de l'instance est de 10 \$1/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 instance EC2 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'instance EC2 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`
**Tableau 1 : Calcul du coût unitaire**
| Instance | Type d'instance | vCPU disponible | GPU disponible | \$1\$1 | 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\$1 | 0,05 USD | 0,50\$1 | 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 par l'instance EC2 parente, 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é.
**Tableau 2 : Calcul de la capacité allouée et inutilisée**
| Nom du pod | Namespace | 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 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Pod 1 | Espace de noms 1 | 16 | 4 | 16 | 1 | 1 | 1 | 100 | 60 | 100 |
| Pod 2 | Espace de noms 2 | 16 | 18 | 18 | 2 | 3 | 3 | 100 | 140 | 140 |
| Pod 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 |
| Non utilisé | Non utilisé | 0 | 34 | 0 | 1 | 1 | 0 | 88 | 188 | 48 |
| \$1\$1\$1 | | 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'instance EC2 (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`
**Tableau 3 : Ratios d'utilisation du calcul**
| Nom du pod | Namespace | 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 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Pod 1 | Espace de noms 1 | 0,242 | 0 | 0.125 | 0 | 0,205 | 0.227 |
| Pod 2 | Espace de noms 2 | 0,277 | 0 | 0,375 | 0 | 0,287 | 0,318 |
| Pod 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 |
| Non utilisé | Non utilisé | 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'instance EC2 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é \$1 ressource totale \$1 coût horaire de la ressource]
**Tableau 4 - Résumé des coûts divisés et non utilisés calculés chaque heure pour tous les pods fonctionnant au sein du cluster**
| Nom du pod | Namespace | Coût partagé | Coût non utilisé | Coût total |
| --- | --- | --- | --- | --- |
| Pod 1 | Espace de noms 1 | 1,85\$1 | 0,06 \$1 | 1,91\$1 |
| Pod 2 | Espace de noms 2 | 3,18\$1 | 0,09\$1 | 3,26\$1 |
| Pod 3 | Espace de noms 1 | 2,35\$1 | 0,06 \$1 | 2,41\$1 |
| Capsule 4 | Espace de noms 2 | 2,35\$1 | 0,06 \$1 | 2,41\$1 |
| Total | | | | 10\$1 |