Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
Beispiel für Daten zur geteilten Kostenzuweisung für beschleunigte Instances
Das folgende Beispiel soll Ihnen zeigen, wie Daten zur geteilten Kostenzuweisung berechnet werden, indem die Kosten für Kubernetes-Namespace und Pods in Amazon EKS-Clustern berechnet werden. Die im gesamten Beispiel verwendeten Tarife dienen nur zur Veranschaulichung.
Sie haben in einer einzigen Stunde die folgende Nutzung:
-
Eine einzelne EC2 Instanz, die vier Pods in zwei Namespaces ausführt, und Sie möchten die Kosten der einzelnen Namespaces verstehen.
-
Die EC2 Instanz ist p3.16xlarge mit 8 GPU, 64 vCPU und 488 GB RAM.
-
Die amortisierten Kosten der Instance belaufen sich auf 10 USD/Stunde.
Daten zur geteilten Kostenzuweisung normalisieren die Kosten pro Ressource auf der Grundlage eines relativen Verhältnisses von GPU: (CPU: Speicher) von 9:1. Dies bedeutet, dass eine GPU-Einheit 9-mal so viel kostet wie eine Einheit von CPU und Speicher. CPU und Speicher wird dann ein Gewicht von 9:1 zugewiesen. Für eine nicht beschleunigte EC2 Instanz wird das aktuelle Standardverhalten übernommen, nämlich CPU: Die Speichergewichtung ist standardmäßig 9:1.
Schritt 1: Berechnen Sie die Stückkosten
Basierend auf den CPU- und Speicherressourcen auf der EC2 Instance und unter Verwendung des oben genannten Verhältnisses berechnen die Daten zur geteilten Kostenzuweisung zunächst die Stückkosten pro GPU vCPU vCPU-Stunde und GB-Stunde.
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 | Instance-Typ | vCPU verfügbar | GPU verfügbar | ** | Speicher verfügbar | Amortisierte Kosten pro Stunde | Kosten pro vCPU-Stunde | Kosten pro GPU-Stunde | Kosten pro GB-Stunde |
|---|---|---|---|---|---|---|---|---|---|
| Instance 1 | p3.16xgroß | 64 | 8 | 488 | 10$ | $0.05 | 0,50$ | 0,005 |
Schritt 2: Berechnen Sie die zugewiesene und ungenutzte Kapazität
- Zugewiesene Kapazität
-
Die GPU, vCPU und der Speicher, die dem Kubernetes-Pod von der übergeordneten EC2 Instance zugewiesen wurden, definiert als Maximum an (reservierter, genutzter) Kapazität
- Ungenutzte Kapazität der Instanz
-
Die ungenutzte Kapazität von GPU, vCPU und Arbeitsspeicher
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 diesem Beispiel hat die Instanz mehr CPU als Abonnement, was Pod 2 zugeschrieben wird, der mehr GPU und vCPU verbrauchte als reserviert.
| Pod-Name | Namespace | vcpu reserviert | vcpu verwendet | vcpu zugewiesen | GPU reserviert | Verwendete GPU | GPU zugewiesen | Speicher reserviert | Verwendeter Speicher | Zugewiesener Speicher |
|---|---|---|---|---|---|---|---|---|---|---|
| Pod 1 | Namespace 1 | 16 | 4 | 16 | 1 | 1 | 1 | 100 | 60 | 100 |
| Kapsel 2 | Namespace 2 | 16 | 18 | 18 | 2 | 3 | 3 | 100 | 140 | 140 |
| Kapsel 3 | Namespace 1 | 16 | 4 | 16 | 2 | 1 | 2 | 100 | 60 | 100 |
| Kapsel 4 | Namespace 2 | 16 | 4 | 16 | 2 | 2 | 2 | 100 | 40 | 100 |
| Unbenutzt | Unbenutzt | 0 | 34 | 0 | 1 | 1 | 0 | 88 | 188 | 48 |
| *** | 64 | 32 | 66 | 8 | 8 | 8 | 488 | 488 | 488 |
Schritt 3: Berechnen Sie die Aufteilung der Nutzungs- und Nutzungsquoten
- Aufgeteiltes Nutzungsverhältnis
-
Der Prozentsatz der vom Kubernetes-Pod genutzten CPU oder des Speichers im Vergleich zur gesamten auf der EC2 Instance verfügbaren CPU oder Arbeitsspeicher.
- Anteil ungenutzter Anteil
-
Der Prozentsatz der vom Kubernetes-Pod genutzten CPU oder des Speichers im Vergleich zur gesamten CPU- oder Speicherbelegung der EC2 Instance (d. h. ohne Berücksichtigung der ungenutzten CPU oder des ungenutzten Speichers auf der Instance).
Der Prozentsatz der vom Kubernetes-Pod genutzten CPU oder des Speichers im Vergleich zur gesamten auf der Instance verfügbaren CPU oder des gesamten Speichers. 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
| Pod-Name | Namespace | vCPU-Auslastung | vCPU-Aufteilungsverhältnis | GPU-Auslastung | GPU-Aufteilungsverhältnis | Speichernutzung | Verhältnis der Speicheraufteilung |
|---|---|---|---|---|---|---|---|
| Kapsel 1 | Namespace 1 | 0,242 | 0 | 0.125 | 0 | 0,205 | 0.227 |
| Kapsel 2 | Namespace 2 | 0,277 | 0 | 0,375 | 0 | 0,287 | 0,318 |
| Kapsel 3 | Namespace 1 | 0,242 | 0 | 0,25 | 0 | 0,205 | 0.227 |
| Kapsel 4 | Namespace 2 | 0,242 | 0 | 0,25 | 0 | 0,205 | 0.227 |
| Unbenutzt | Unbenutzt | 0 | 0,098 | ||||
| 1 | 0 | 1 | 0 | 1 | 1 |
Schritt 4: Berechne die geteilten Kosten und die ungenutzten Kosten
- Kosten aufteilen
-
Die Aufteilung der EC2 Instanzkosten pro Nutzung auf der Grundlage der zugewiesenen CPU- und Speichernutzung durch die Kubernetes-Pods
- Kosten für ungenutzte Instances
-
Die Kosten für ungenutzte CPU- oder Speicherressourcen auf der 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
[Hinweis: Ungenutzte Kosten = Verhältnis ungenutzter Nutzwert x Gesamtressource x Stundenkosten der Ressource]
| Pod-Name | Namespace | Kosten aufteilen | Ungenutzte Kosten | Gesamtkosten |
|---|---|---|---|---|
| Kapsel 1 | Namespace 1 | 1,85$ | 0,06 USD | 1,91$ |
| Kapsel 2 | Namespace 2 | 3,18$ | 0,09$ | 3,26$ |
| Kapsel 3 | Namespace 1 | 2,35$ | 0,06 USD | 2,41$ |
| Kapsel 4 | Namespace 2 | 2,35$ | 0,06 USD | 2,41$ |
| Gesamt | 10$ |
