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-Instance, die vier Pods in zwei Namespaces ausführt, und Sie möchten die Kosten der einzelnen Namespaces verstehen.
+ Die EC2-Instance 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-Instance 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 Split Cost Allocation-Daten 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`
**Tabelle 1: Berechnung der Stückkosten**
| Instance | Instance-Typ | vCPU verfügbar | GPU verfügbar | \$1\$1 | 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\$1 | \$10.05 | 0,50\$1 | 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 Instance
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 war.
**Tabelle 2: Berechnung der zugewiesenen und ungenutzten Kapazität**
| 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 |
| 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 |
| Kapsel 4 | Namespace 2 | 16 | 4 | 16 | 2 | 2 | 2 | 100 | 40 | 100 |
| Nicht verwendet | Nicht verwendet | 0 | 34 | 0 | 1 | 1 | 0 | 88 | 188 | 48 |
| \$1\$1\$1 | | 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 verfügbaren CPU oder dem auf der EC2-Instance verfügbaren Speicher.
Anteil ungenutzter Anteil
Der Prozentsatz der vom Kubernetes-Pod genutzten CPU oder des Speichers im Vergleich zur gesamten CPU- oder Speicherbelegung auf 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 EC2-Instance verfügbaren CPU oder des gesamten Speichers.
`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`
**Tabelle 3: Rechenauslastungsquoten**
| Pod-Name | Namespace | vCPU-Auslastung | vCPU-Aufteilungsverhältnis | GPU-Auslastung | GPU-Aufteilungsverhältnis | Speichernutzung | Verhältnis der Speicheraufteilung |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 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 |
| Kapsel 4 | Namespace 2 | 0,242 | 0 | 0,25 | 0 | 0,205 | 0.227 |
| Nicht verwendet | Nicht verwendet | 0 | | | | 0,098 | |
| | | 1 | 0 | 1 | 0 | 1 | 1 |
## Schritt 4: Berechne die geteilten Kosten und die ungenutzten Kosten
Kosten aufteilen
Die Aufteilung der Kosten pro Nutzung der EC2-Instance 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]
**Tabelle 4 — Zusammenfassung der aufgeteilten und ungenutzten Kosten, die jede Stunde für alle Pods berechnet werden, die innerhalb des Clusters ausgeführt werden**
| Pod-Name | Namespace | Kosten aufteilen | Ungenutzte Kosten | Gesamtkosten |
| --- | --- | --- | --- | --- |
| Pod 1 | Namespace 1 | 1,85\$1 | 0,06 USD | 1,91\$1 |
| Pod 2 | Namespace 2 | 3,18\$1 | 0,09\$1 | 3,26\$1 |
| Pod 3 | Namespace 1 | 2,35\$1 | 0,06 USD | 2,41\$1 |
| Kapsel 4 | Namespace 2 | 2,35\$1 | 0,06 USD | 2,41\$1 |
| Gesamt | | | | 10\$1 |