Merge pull request #349 from christopherhein/feature/344-support-1-11

Adds support for Kubernetes 1.11 clusters to be created

Dockerfile

@@ -45,7 +45,7 @@ RUN pip install --root=/out aws-mfa==0.0.12 awscli==1.16.34
 
 WORKDIR /out
 
-ENV KUBECTL_VERSION v1.10.3
+ENV KUBECTL_VERSION v1.11.5
 RUN curl --silent --location "https://dl.k8s.io/${KUBECTL_VERSION}/bin/linux/amd64/kubectl" --output usr/local/bin/kubectl \
     && chmod +x usr/local/bin/kubectl
 

README.md

@@ -85,6 +85,12 @@ To create the same kind of basic cluster, but with a different name, run:
 eksctl create cluster --name=cluster-1 --nodes=4
 ```
 
+EKS supports two versions `1.10` and `1.11` (default), with `eksctl` you can deploy either version by passing `--version`.
+
+```
+eksctl create cluster --version=1.10
+```
+
 A default [StorageClass](https://kubernetes.io/docs/concepts/storage/storage-classes/) (gp2 volume type provisioned by EBS) will be added automatically when creating a cluster.  If you want to prevent this, use the `--storage-class` flag.  For example:
 
 ```

pkg/ami/auto_resolver.go

@@ -9,13 +9,24 @@ import (
 
 // ImageSearchPatterns is a map of image search patterns by
 // image OS family and by class
-var ImageSearchPatterns = map[string]map[int]string{
-	ImageFamilyAmazonLinux2: {
-		ImageClassGeneral: "amazon-eks-node-*",
-		ImageClassGPU:     "amazon-eks-gpu-node-*",
+var ImageSearchPatterns = map[string]map[string]map[int]string{
+	"1.10": {
+		ImageFamilyAmazonLinux2: {
+			ImageClassGeneral: "amazon-eks-node-1.10-v*",
+			ImageClassGPU:     "amazon-eks-gpu-node-1.10-v*",
+		},
+		ImageFamilyUbuntu1804: {
+			ImageClassGeneral: "ubuntu-eks/1.10.3/*",
+		},
 	},
-	ImageFamilyUbuntu1804: {
-		ImageClassGeneral: "ubuntu-eks/1.10.3/*",
+	"1.11": {
+		ImageFamilyAmazonLinux2: {
+			ImageClassGeneral: "amazon-eks-node-1.11-v*",
+			ImageClassGPU:     "amazon-eks-gpu-node-1.11-v*",
+		},
+		ImageFamilyUbuntu1804: {
+			ImageClassGeneral: "ubuntu-eks/1.11.5/*",
+		},
 	},
 }
 
@@ -27,16 +38,16 @@ type AutoResolver struct {
 
 // Resolve will return an AMI to use based on the default AMI for
 // each region
-func (r *AutoResolver) Resolve(region string, instanceType string, imageFamily string) (string, error) {
+func (r *AutoResolver) Resolve(region, version, instanceType, imageFamily string) (string, error) {
 	logger.Debug("resolving AMI using AutoResolver for region %s, instanceType %s and imageFamily %s", region, instanceType, imageFamily)
 
-	p := ImageSearchPatterns[imageFamily][ImageClassGeneral]
+	p := ImageSearchPatterns[version][imageFamily][ImageClassGeneral]
 	if utils.IsGPUInstanceType(instanceType) {
 		var ok bool
-		p, ok = ImageSearchPatterns[imageFamily][ImageClassGPU]
+		p, ok = ImageSearchPatterns[version][imageFamily][ImageClassGPU]
 		if !ok {
 			logger.Critical("image family %s doesn't support GPU image class", imageFamily)
-			return "", NewErrFailedResolution(region, instanceType, imageFamily)
+			return "", NewErrFailedResolution(region, version, instanceType, imageFamily)
 		}
 	}
 

pkg/ami/auto_resolver_test.go

@@ -25,6 +25,7 @@ var _ = Describe("AMI Auto Resolution", func() {
 			p            *testutils.MockProvider
 			err          error
 			region       string
+			version      string
 			instanceType string
 			imageFamily  string
 			resolvedAmi  string
@@ -35,6 +36,7 @@ var _ = Describe("AMI Auto Resolution", func() {
 		Context("with a valid region and N instance type", func() {
 			BeforeEach(func() {
 				region = "eu-west-1"
+				version = "1.10"
 				expectedAmi = "ami-12345"
 			})
 
@@ -49,10 +51,10 @@ var _ = Describe("AMI Auto Resolution", func() {
 						imageState = "available"
 
 						_, p = createProviders()
-						addMockDescribeImages(p, "amazon-eks-node-*", expectedAmi, imageState, "2018-08-20T23:25:53.000Z")
+						addMockDescribeImages(p, "amazon-eks-node-1.10-v*", expectedAmi, imageState, "2018-08-20T23:25:53.000Z")
 
 						resolver := NewAutoResolver(p.MockEC2())
-						resolvedAmi, err = resolver.Resolve(region, instanceType, imageFamily)
+						resolvedAmi, err = resolver.Resolve(region, version, instanceType, imageFamily)
 					})
 
 					It("should not error", func() {
@@ -73,10 +75,10 @@ var _ = Describe("AMI Auto Resolution", func() {
 						imageState = "pending"
 
 						_, p = createProviders()
-						addMockDescribeImagesMultiple(p, "amazon-eks-node-*", []returnAmi{})
+						addMockDescribeImagesMultiple(p, "amazon-eks-node-1.10-v*", []returnAmi{})
 
 						resolver := NewAutoResolver(p.MockEC2())
-						resolvedAmi, err = resolver.Resolve(region, instanceType, imageFamily)
+						resolvedAmi, err = resolver.Resolve(region, version, instanceType, imageFamily)
 					})
 
 					It("should not error", func() {
@@ -111,10 +113,10 @@ var _ = Describe("AMI Auto Resolution", func() {
 							},
 						}
 
-						addMockDescribeImagesMultiple(p, "amazon-eks-node-*", images)
+						addMockDescribeImagesMultiple(p, "amazon-eks-node-1.10-v*", images)
 
 						resolver := NewAutoResolver(p.MockEC2())
-						resolvedAmi, err = resolver.Resolve(region, instanceType, imageFamily)
+						resolvedAmi, err = resolver.Resolve(region, version, instanceType, imageFamily)
 					})
 
 					It("should not error", func() {
@@ -141,10 +143,10 @@ var _ = Describe("AMI Auto Resolution", func() {
 						imageState = "available"
 
 						_, p = createProviders()
-						addMockDescribeImages(p, "amazon-eks-gpu-node-*", expectedAmi, imageState, "2018-08-20T23:25:53.000Z")
+						addMockDescribeImages(p, "amazon-eks-gpu-node-1.10-v*", expectedAmi, imageState, "2018-08-20T23:25:53.000Z")
 
 						resolver := NewAutoResolver(p.MockEC2())
-						resolvedAmi, err = resolver.Resolve(region, instanceType, imageFamily)
+						resolvedAmi, err = resolver.Resolve(region, version, instanceType, imageFamily)
 					})
 
 					It("should not error", func() {

pkg/ami/error.go

@@ -8,23 +8,25 @@ import (
 // failure to resolve a region/instance type/image family to an AMI
 type ErrFailedResolution struct {
 	region       string
+	version      string
 	instanceType string
 	imageFamily  string
 }
 
 // NewErrFailedResolution creates a new instance of ErrFailedResolution for a
 // give region, instance type and image family
-func NewErrFailedResolution(region string, instanceType string, imageFamily string) *ErrFailedResolution {
+func NewErrFailedResolution(region, version, instanceType, imageFamily string) *ErrFailedResolution {
 	return &ErrFailedResolution{
 		region:       region,
+		version:      version,
 		instanceType: instanceType,
 		imageFamily:  imageFamily,
 	}
 }
 
 // Error return the error message
 func (e *ErrFailedResolution) Error() string {
-	return fmt.Sprintf("Unable to determine AMI for region %s, instance type %s and image family %s", e.region, e.instanceType, e.imageFamily)
+	return fmt.Sprintf("Unable to determine AMI for region %s, version %s, instance type %s and image family %s", e.region, e.version, e.instanceType, e.imageFamily)
 }
 
 // ErrNotFound is an error type that represents

pkg/ami/resolver.go

@@ -8,9 +8,9 @@ var (
 // Resolve will resolve an AMI from the supplied region
 // and instance type. It will invoke a specific resolver
 // to do the actual determining of AMI.
-func Resolve(region string, instanceType string, imageFamily string) (string, error) {
+func Resolve(region, version, instanceType, imageFamily string) (string, error) {
 	for _, resolver := range DefaultResolvers {
-		ami, err := resolver.Resolve(region, instanceType, imageFamily)
+		ami, err := resolver.Resolve(region, version, instanceType, imageFamily)
 		if err != nil {
 			return "", err
 		}
@@ -19,11 +19,11 @@ func Resolve(region string, instanceType string, imageFamily string) (string, er
 		}
 	}
 
-	return "", NewErrFailedResolution(region, instanceType, imageFamily)
+	return "", NewErrFailedResolution(region, version, instanceType, imageFamily)
 }
 
 // Resolver provides an interface to enable implementing multiple
 // ways to determine which AMI to use from the region/instance type/image family.
 type Resolver interface {
-	Resolve(region string, instanceType string, imageFamily string) (string, error)
+	Resolve(region, version, instanceType, imageFamily string) (string, error)
 }

pkg/ami/static_resolver.go

@@ -13,10 +13,10 @@ type StaticDefaultResolver struct {
 
 // Resolve will return an AMI to use based on the default AMI for each region
 // currently source of truth for these is here
-func (r *StaticDefaultResolver) Resolve(region string, instanceType string, imageFamily string) (string, error) {
-	logger.Debug("resolving AMI using StaticDefaultResolver for region %s, instanceType %s and imageFamily %s", region, instanceType, imageFamily)
+func (r *StaticDefaultResolver) Resolve(region, version, instanceType, imageFamily string) (string, error) {
+	logger.Debug("resolving AMI using StaticDefaultResolver for region %s, version %s, instanceType %s and imageFamily %s", region, instanceType, imageFamily)
 
-	regionalAMIs := StaticImages[imageFamily][ImageClassGeneral]
+	regionalAMIs := StaticImages[version][imageFamily][ImageClassGeneral]
 	return regionalAMIs[region], nil
 }
 
@@ -25,18 +25,18 @@ type StaticGPUResolver struct {
 }
 
 // Resolve will return an AMI based on the region for GPU instance types
-func (r *StaticGPUResolver) Resolve(region string, instanceType string, imageFamily string) (string, error) {
+func (r *StaticGPUResolver) Resolve(region, version, instanceType, imageFamily string) (string, error) {
 	logger.Debug("resolving AMI using StaticGPUResolver for region %s, instanceType %s and imageFamily %s", region, instanceType, imageFamily)
 
 	if !utils.IsGPUInstanceType(instanceType) {
 		logger.Debug("can't resolve AMI using StaticGPUResolver as instance type %s is non-GPU", instanceType)
 		return "", nil
 	}
 
-	regionalAMIs, ok := StaticImages[imageFamily][ImageClassGPU]
+	regionalAMIs, ok := StaticImages[version][imageFamily][ImageClassGPU]
 	if !ok {
 		logger.Critical("image family %s doesn't support GPU image class", imageFamily)
-		return "", NewErrFailedResolution(region, instanceType, imageFamily)
+		return "", NewErrFailedResolution(region, version, instanceType, imageFamily)
 	}
 
 	return regionalAMIs[region], nil

pkg/ami/static_resolver_ami.go

@@ -3,25 +3,49 @@ package ami
 // This file was generated by static_resolver_ami_generate.go; DO NOT EDIT.
 
 // StaticImages is a map that holds the list of AMIs to be used by for static resolution
-var StaticImages = map[string]map[int]map[string]string{
-	"AmazonLinux2": {
-		ImageClassGPU: {
-			"eu-west-1": "ami-0c3479bcd739094f0",
-			"us-east-1": "ami-0c974dde3f6d691a1",
-			"us-east-2": "ami-089849e811ace242f",
-			"us-west-2": "ami-08156e8fd65879a13",
+var StaticImages = map[string]map[string]map[int]map[string]string{
+	"1.10": {
+		"AmazonLinux2": {
+			ImageClassGPU: {
+				"eu-west-1": "ami-047637529a86c7237",
+				"us-east-1": "ami-03c499c67bc65c089",
+				"us-east-2": "ami-081210a2fd7f3c487",
+				"us-west-2": "ami-08754f7ac73185331",
+			},
+			ImageClassGeneral: {
+				"eu-west-1": "ami-03612357ac9da2c7d",
+				"us-east-1": "ami-027792c3cc6de7b5b",
+				"us-east-2": "ami-036130f4127a367f7",
+				"us-west-2": "ami-07af9511082779ae7",
+			},
 		},
-		ImageClassGeneral: {
-			"eu-west-1": "ami-00c3b2d35bddd4f5c",
-			"us-east-1": "ami-0a0b913ef3249b655",
-			"us-east-2": "ami-0958a76db2d150238",
-			"us-west-2": "ami-0f54a2f7d2e9c88b3",
+		"Ubuntu1804": {ImageClassGeneral: {
+			"eu-west-1": "ami-07036622490f7e97b",
+			"us-east-1": "ami-06fd8200ac0eb656d",
+			"us-east-2": "ami-0866798422f5d546b",
+			"us-west-2": "ami-6322011b",
+		}},
+	},
+	"1.11": {
+		"AmazonLinux2": {
+			ImageClassGPU: {
+				"eu-west-1": "ami-050db3f5f9dbd4439",
+				"us-east-1": "ami-08a0bb74d1c9a5e2f",
+				"us-east-2": "ami-04a758678ae5ebad5",
+				"us-west-2": "ami-014f4e495a19d3e4f",
+			},
+			ImageClassGeneral: {
+				"eu-west-1": "ami-0a9006fb385703b54",
+				"us-east-1": "ami-0b4eb1d8782fc3aea",
+				"us-east-2": "ami-053cbe66e0033ebcf",
+				"us-west-2": "ami-094fa4044a2a3cf52",
+			},
 		},
+		"Ubuntu1804": {ImageClassGeneral: {
+			"eu-west-1": "",
+			"us-east-1": "",
+			"us-east-2": "",
+			"us-west-2": "",
+		}},
 	},
-	"Ubuntu1804": {ImageClassGeneral: {
-		"eu-west-1": "ami-07036622490f7e97b",
-		"us-east-1": "ami-06fd8200ac0eb656d",
-		"us-east-2": "ami-0866798422f5d546b",
-		"us-west-2": "ami-6322011b",
-	}},
 }

pkg/ami/static_resolver_ami_generate.go

@@ -29,29 +29,33 @@ func main() {
 
 	client := newMultiRegionClient()
 
-	for family := range ami.ImageSearchPatterns {
-		familyImages := Dict{}
-		log.Printf("looking up %s images", family)
-		for class := range ami.ImageSearchPatterns[family] {
-			classImages := Dict{}
-			for _, region := range api.SupportedRegions() {
-				p := ami.ImageSearchPatterns[family][class]
-				log.Printf("looking up images matching %q in %q", p, region)
-				image, err := ami.FindImage(client[region], p)
-				if err != nil {
-					log.Fatal(err)
+	for version := range ami.ImageSearchPatterns {
+		versionImages := Dict{}
+		for family := range ami.ImageSearchPatterns[version] {
+			familyImages := Dict{}
+			log.Printf("looking up %s/%s images", family, version)
+			for class := range ami.ImageSearchPatterns[version][family] {
+				classImages := Dict{}
+				for _, region := range api.SupportedRegions() {
+					p := ami.ImageSearchPatterns[version][family][class]
+					log.Printf("looking up images matching %q in %q", p, region)
+					image, err := ami.FindImage(client[region], p)
+					if err != nil {
+						log.Fatal(err)
+					}
+					classImages[Lit(region)] = Lit(image)
 				}
-				classImages[Lit(region)] = Lit(image)
+				familyImages[Id(ami.ImageClasses[class])] = Values(classImages)
 			}
-			familyImages[Id(ami.ImageClasses[class])] = Values(classImages)
+			versionImages[Lit(family)] = Values(familyImages)
 		}
-		d[Lit(family)] = Values(familyImages)
+		d[Lit(version)] = Values(versionImages)
 	}
 
 	f.Comment("StaticImages is a map that holds the list of AMIs to be used by for static resolution")
 
 	f.Var().Id("StaticImages").Op("=").
-		Map(String()).Map(Int()).Map(String()).String().Values(d)
+		Map(String()).Map(String()).Map(Int()).Map(String()).String().Values(d)
 
 	if err := f.Save("static_resolver_ami.go"); err != nil {
 		log.Fatal(err.Error())