Disallow ARM-based instances, which are not currently supported (#1536)

Author: deliahu

pkg/lib/aws/ec2.go

@@ -18,6 +18,7 @@ package aws
 
 import (
 	"math"
+	"regexp"
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
@@ -28,6 +29,19 @@ import (
 	s "github.com/cortexlabs/cortex/pkg/lib/strings"
 )
 
+// aws instance types take this form: (\w+)([0-9]+)(\w*).(\w+)
+// the first group is the instance series, e.g. "m", "t", "g", "inf", ...
+// the second group is a version number for that series, e.g. 3, 4, ...
+// the third group is optional, and is a set of single-character "flags"
+//   "g" represents ARM (graviton), "a" for AMD, "n" for fast networking, "d" for fast storage, etc.
+// the fourth and final group (after the dot) is the instance size, e.g. "large"
+var _armInstanceRegex = regexp.MustCompile(`^\w+[0-9]+\w*g\w*\.\w+$`)
+
+// instanceType must be a valid instance type that exists in AWS, e.g. g4dn.xlarge
+func IsARMInstance(instanceType string) bool {
+	return _armInstanceRegex.MatchString(instanceType)
+}
+
 func (c *Client) SpotInstancePrice(region string, instanceType string) (float64, error) {
 	result, err := c.EC2().DescribeSpotPriceHistory(&ec2.DescribeSpotPriceHistoryInput{
 		InstanceTypes:       []*string{aws.String(instanceType)},

pkg/lib/aws/elb.go

@@ -17,14 +17,22 @@ limitations under the License.
 package aws
 
 import (
+	"strings"
+
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/elbv2"
 	"github.com/cortexlabs/cortex/pkg/lib/errors"
 	"github.com/cortexlabs/cortex/pkg/lib/sets/strset"
 )
 
 // https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html
-var NLBUnsupportedInstancePrefixes = strset.New("c1", "cc1", "cc2", "cg1", "cg2", "cr1", "g1", "g2", "hi1", "hs1", "m1", "m2", "m3", "t1")
+var _nlbUnsupportedInstancePrefixes = strset.New("c1", "cc1", "cc2", "cg1", "cg2", "cr1", "g1", "g2", "hi1", "hs1", "m1", "m2", "m3", "t1")
+
+// instanceType must be a valid instance type that exists in AWS, e.g. g4dn.xlarge
+func IsInstanceSupportedByNLB(instanceType string) bool {
+	instancePrefix := strings.Split(instanceType, ".")[0]
+	return !_nlbUnsupportedInstancePrefixes.Has(instancePrefix)
+}
 
 // returns the the first load balancer which has all of the specified tags, or nil if no load balancers match
 func (c *Client) FindLoadBalancer(tags map[string]string) (*elbv2.LoadBalancer, error) {

pkg/lib/aws/servicequotas.go

@@ -27,20 +27,20 @@ import (
 	"github.com/cortexlabs/cortex/pkg/lib/sets/strset"
 )
 
-var _instancePrefixRegex = regexp.MustCompile(`[a-zA-Z]+`)
-var _standardInstancePrefixes = strset.New("a", "c", "d", "h", "i", "m", "r", "t", "z")
-var _knownInstancePrefixes = strset.Union(_standardInstancePrefixes, strset.New("p", "g", "inf", "x", "f"))
+var _instanceCategoryRegex = regexp.MustCompile(`[a-zA-Z]+`)
+var _standardInstanceCategories = strset.New("a", "c", "d", "h", "i", "m", "r", "t", "z")
+var _knownInstanceCategories = strset.Union(_standardInstanceCategories, strset.New("p", "g", "inf", "x", "f"))
 
 func (c *Client) VerifyInstanceQuota(instanceType string) error {
-	instancePrefix := _instancePrefixRegex.FindString(instanceType)
+	instanceCategory := _instanceCategoryRegex.FindString(instanceType)
 
 	// Allow the instance if we don't recognize the type
-	if !_knownInstancePrefixes.Has(instancePrefix) {
+	if !_knownInstanceCategories.Has(instanceCategory) {
 		return nil
 	}
 
-	if _standardInstancePrefixes.Has(instancePrefix) {
-		instancePrefix = "standard"
+	if _standardInstanceCategories.Has(instanceCategory) {
+		instanceCategory = "standard"
 	}
 
 	var cpuLimit *int
@@ -62,7 +62,7 @@ func (c *Client) VerifyInstanceQuota(instanceType string) error {
 					continue
 				}
 
-				if strings.ToLower(*metricClass) == instancePrefix+"/ondemand" {
+				if strings.ToLower(*metricClass) == instanceCategory+"/ondemand" {
 					cpuLimit = pointer.Int(int(*quota.Value)) // quota is specified in number of vCPU permitted per family
 					return false
 				}

pkg/types/clusterconfig/clusterconfig.go

@@ -654,11 +654,14 @@ func checkCortexSupport(instanceMetadata aws.InstanceMetadata) error {
 		return ErrorInstanceTypeTooSmall()
 	}
 
-	instancePrefix := strings.Split(instanceMetadata.Type, ".")[0]
-	if aws.NLBUnsupportedInstancePrefixes.Has(instancePrefix) {
+	if !aws.IsInstanceSupportedByNLB(instanceMetadata.Type) {
 		return ErrorInstanceTypeNotSupported(instanceMetadata.Type)
 	}
 
+	if aws.IsARMInstance(instanceMetadata.Type) {
+		return ErrorARMInstancesNotSupported(instanceMetadata.Type)
+	}
+
 	if err := checkCNISupport(instanceMetadata.Type); err != nil {
 		return err
 	}

pkg/types/clusterconfig/errors.go

@@ -38,6 +38,7 @@ const (
 	ErrSpotPriceGreaterThanTargetOnDemand     = "clusterconfig.spot_price_greater_than_target_on_demand"
 	ErrSpotPriceGreaterThanMaxPrice           = "clusterconfig.spot_price_greater_than_max_price"
 	ErrInstanceTypeNotSupported               = "clusterconfig.instance_type_not_supported"
+	ErrARMInstancesNotSupported               = "clusterconfig.arm_instances_not_supported"
 	ErrAtLeastOneInstanceDistribution         = "clusterconfig.at_least_one_instance_distribution"
 	ErrNoCompatibleSpotInstanceFound          = "clusterconfig.no_compatible_spot_instance_found"
 	ErrConfiguredWhenSpotIsNotEnabled         = "clusterconfig.configured_when_spot_is_not_enabled"
@@ -133,6 +134,13 @@ func ErrorInstanceTypeNotSupported(instanceType string) error {
 	})
 }
 
+func ErrorARMInstancesNotSupported(instanceType string) error {
+	return errors.WithStack(&errors.Error{
+		Kind:    ErrARMInstancesNotSupported,
+		Message: fmt.Sprintf("ARM-based instances (including %s) are not supported", instanceType),
+	})
+}
+
 func ErrorConfiguredWhenSpotIsNotEnabled(configKey string) error {
 	return errors.WithStack(&errors.Error{
 		Kind:    ErrConfiguredWhenSpotIsNotEnabled,