GCE: base pricing of custom instances on their instance family type

Author: BigDarkClown

cluster-autoscaler/cloudprovider/gce/gce_price_model.go

@@ -18,6 +18,7 @@ package gce
 
 import (
 	"math"
+	"strings"
 	"time"
 
 	apiv1 "k8s.io/api/core/v1"
@@ -31,15 +32,59 @@ type GcePriceModel struct {
 
 const (
 	//TODO: Move it to a config file.
-	cpuPricePerHour         = 0.033174
-	memoryPricePerHourPerGb = 0.004446
-	preemptibleDiscount     = 0.00698 / 0.033174
+	cpuPricePerHour         = 0.022890
+	memoryPricePerHourPerGb = 0.003067
+	preemptibleDiscount     = 0.006867 / 0.022890
 	gpuPricePerHour         = 0.700
 
 	preemptibleLabel = "cloud.google.com/gke-preemptible"
 )
 
 var (
+	predefinedCpuPricePerHour = map[string]float64{
+		"c2":  0.03398,
+		"e2":  0.021811,
+		"m1":  0.0348,
+		"n1":  0.031611,
+		"n2":  0.031611,
+		"n2d": 0.027502,
+	}
+	predefinedMemoryPricePerHourPerGb = map[string]float64{
+		"c2":  0.00455,
+		"e2":  0.002923,
+		"m1":  0.0051,
+		"n1":  0.004237,
+		"n2":  0.004237,
+		"n2d": 0.003686,
+	}
+	predefinedPreemptibleDiscount = map[string]float64{
+		"c2":  0.00822 / 0.03398,
+		"e2":  0.006543 / 0.021811,
+		"m1":  0.00733 / 0.0348,
+		"n1":  0.006655 / 0.031611,
+		"n2":  0.007650 / 0.031611,
+		"n2d": 0.006655 / 0.027502,
+	}
+
+	customCpuPricePerHour = map[string]float64{
+		"e2":  0.022890,
+		"n1":  0.033174,
+		"n2":  0.033174,
+		"n2d": 0.028877,
+	}
+	customMemoryPricePerHourPerGb = map[string]float64{
+		"e2":  0.003067,
+		"n1":  0.004446,
+		"n2":  0.004446,
+		"n2d": 0.003870,
+	}
+	customPreemptibleDiscount = map[string]float64{
+		"e2":  0.006867 / 0.022890,
+		"n1":  0.00698 / 0.033174,
+		"n2":  0.00802 / 0.033174,
+		"n2d": 0.006980 / 0.028877,
+	}
+
 	// e2-micro and e2-small have allocatable set too high resulting in
 	// overcommit. To make cluster autoscaler prefer e2-medium given the choice
 	// between the three machine types, the prices for e2-micro and e2-small
@@ -278,10 +323,8 @@ func (model *GcePriceModel) NodePrice(node *apiv1.Node, startTime time.Time, end
 		}
 	}
 	if !basePriceFound {
-		price = getBasePrice(node.Status.Capacity, startTime, endTime)
-		if node.Labels != nil && node.Labels[preemptibleLabel] == "true" {
-			price = price * preemptibleDiscount
-		}
+		price = getBasePrice(node.Status.Capacity, node.Labels[apiv1.LabelInstanceType], startTime, endTime)
+		price = price * getPreemptibleDiscount(node)
 	}
 	// TODO: handle SSDs.
 
@@ -295,27 +338,74 @@ func getHours(startTime time.Time, endTime time.Time) float64 {
 	return hours
 }
 
+func getInstanceFamily(instanceType string) string {
+	return strings.Split(instanceType, "-")[0]
+}
+
+func isInstanceCustom(instanceType string) bool {
+	return strings.Contains(instanceType, "custom")
+}
+
+func getPreemptibleDiscount(node *apiv1.Node) float64 {
+	if node.Labels[preemptibleLabel] != "true" {
+		return 1.0
+	}
+	instanceType := node.Labels[apiv1.LabelInstanceType]
+	instanceFamily := getInstanceFamily(instanceType)
+
+	discountMap := predefinedPreemptibleDiscount
+	if isInstanceCustom(instanceType) {
+		discountMap = customPreemptibleDiscount
+	}
+
+	if _, found := discountMap[instanceFamily]; found {
+		return discountMap[instanceFamily]
+	}
+	return preemptibleDiscount
+}
+
 // PodPrice returns a theoretical minimum price of running a pod for a given
 // period of time on a perfectly matching machine.
 func (model *GcePriceModel) PodPrice(pod *apiv1.Pod, startTime time.Time, endTime time.Time) (float64, error) {
 	price := 0.0
 	for _, container := range pod.Spec.Containers {
-		price += getBasePrice(container.Resources.Requests, startTime, endTime)
+		price += getBasePrice(container.Resources.Requests, "", startTime, endTime)
 		price += getAdditionalPrice(container.Resources.Requests, startTime, endTime)
 	}
 	return price, nil
 }
 
-func getBasePrice(resources apiv1.ResourceList, startTime time.Time, endTime time.Time) float64 {
+func getBasePrice(resources apiv1.ResourceList, instanceType string, startTime time.Time, endTime time.Time) float64 {
 	if len(resources) == 0 {
 		return 0
 	}
 	hours := getHours(startTime, endTime)
+	instanceFamily := getInstanceFamily(instanceType)
+	isCustom := isInstanceCustom(instanceType)
 	price := 0.0
+
 	cpu := resources[apiv1.ResourceCPU]
+	cpuPrice := cpuPricePerHour
+	cpuPriceMap := predefinedCpuPricePerHour
+	if isCustom {
+		cpuPriceMap = customCpuPricePerHour
+	}
+	if _, found := cpuPriceMap[instanceFamily]; found {
+		cpuPrice = cpuPriceMap[instanceFamily]
+	}
+	price += float64(cpu.MilliValue()) / 1000.0 * cpuPrice * hours
+
 	mem := resources[apiv1.ResourceMemory]
-	price += float64(cpu.MilliValue()) / 1000.0 * cpuPricePerHour * hours
-	price += float64(mem.Value()) / float64(units.GiB) * memoryPricePerHourPerGb * hours
+	memPrice := memoryPricePerHourPerGb
+	memPriceMap := predefinedMemoryPricePerHourPerGb
+	if isCustom {
+		memPriceMap = customMemoryPricePerHourPerGb
+	}
+	if _, found := memPriceMap[instanceFamily]; found {
+		memPrice = memPriceMap[instanceFamily]
+	}
+	price += float64(mem.Value()) / float64(units.GiB) * memPrice * hours
+
 	return price
 }
 

cluster-autoscaler/cloudprovider/gce/gce_price_model_test.go

@@ -47,6 +47,30 @@ func TestGetNodePrice(t *testing.T) {
 		OperatingSystemLinux)
 	labels2[preemptibleLabel] = "true"
 
+	labels3, _ := BuildGenericLabels(GceRef{
+		Name:    "kubernetes-minion-group",
+		Project: "mwielgus-proj",
+		Zone:    "us-central1-b"},
+		"n1-custom",
+		"sillyname",
+		OperatingSystemLinux)
+
+	labels4, _ := BuildGenericLabels(GceRef{
+		Name:    "kubernetes-minion-group",
+		Project: "mwielgus-proj",
+		Zone:    "us-central1-b"},
+		"n1-unknown",
+		"sillyname",
+		OperatingSystemLinux)
+
+	labels5, _ := BuildGenericLabels(GceRef{
+		Name:    "kubernetes-minion-group",
+		Project: "mwielgus-proj",
+		Zone:    "us-central1-b"},
+		"e2-custom",
+		"sillyname",
+		OperatingSystemLinux)
+
 	model := &GcePriceModel{}
 	now := time.Now()
 
@@ -66,6 +90,7 @@ func TestGetNodePrice(t *testing.T) {
 
 	// custom node
 	node3 := BuildTestNode("sillyname3", 8000, 30*units.GiB)
+	node3.Labels = labels3
 	price3, err := model.NodePrice(node3, now, now.Add(time.Hour))
 	assert.NoError(t, err)
 	// custom nodes should be slightly more expensive than regular.
@@ -92,10 +117,27 @@ func TestGetNodePrice(t *testing.T) {
 
 	// small custom node
 	node6 := BuildTestNode("sillyname6", 1000, 3750*units.MiB)
+	node6.Labels = labels3
 	price6, err := model.NodePrice(node6, now, now.Add(time.Hour))
 	assert.NoError(t, err)
 	// 8 times smaller node should be 8 times less expensive.
 	assert.True(t, math.Abs(price3-8*price6) < 0.1)
+
+	// unknown instance type
+	node7 := BuildTestNode("sillyname7", 8000, 30*units.GiB)
+	node7.Labels = labels4
+	price7, err := model.NodePrice(node7, now, now.Add(time.Hour))
+	assert.NoError(t, err)
+	// Unknown instance type should have similar pricing to its node family
+	assert.True(t, math.Abs(price1-price7) < 0.1)
+
+	// custom node from cheaper family
+	node8 := BuildTestNode("sillyname8", 9000, 32*units.GiB)
+	node8.Labels = labels5
+	price8, err := model.NodePrice(node8, now, now.Add(time.Hour))
+	assert.NoError(t, err)
+	// Bigger custom e2 node should be cheaper than smaller custom n1 node
+	assert.True(t, price8 < price3)
 }
 
 func TestGetPodPrice(t *testing.T) {