diff --git a/Gopkg.lock b/Gopkg.lock index 943d06240e4b1..c1d80fb7b662d 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -107,7 +107,7 @@ version = "v9" [[projects]] - digest = "1:f2bce9137130ed14d0b50a8ba5cef3b9d8829c304c97d164eb35421644cc746e" + digest = "1:9b9aa0e8cd09203c6f105eeccb15da48c707d4827d21810dfe6bd718935f917e" name = "github.com/aws/aws-sdk-go" packages = [ "aws", @@ -150,6 +150,7 @@ "service/iam", "service/iam/iamiface", "service/kms", + "service/pricing", "service/route53", "service/route53/route53iface", "service/s3", @@ -2120,6 +2121,7 @@ "github.com/aws/aws-sdk-go/service/elb/elbiface", "github.com/aws/aws-sdk-go/service/iam", "github.com/aws/aws-sdk-go/service/iam/iamiface", + "github.com/aws/aws-sdk-go/service/pricing", "github.com/aws/aws-sdk-go/service/route53", "github.com/aws/aws-sdk-go/service/route53/route53iface", "github.com/aws/aws-sdk-go/service/s3", diff --git a/Makefile b/Makefile index 191149319a8fe..beae08ba7d9cf 100644 --- a/Makefile +++ b/Makefile @@ -768,3 +768,9 @@ bazel-version-dist: bazel-crossbuild-nodeup bazel-crossbuild-kops bazel-protokub .PHONY: bazel-upload bazel-upload: bazel-version-dist # Upload kops to S3 aws s3 sync --acl public-read ${BAZELUPLOAD}/ ${S3_BUCKET} + +.PHONY: update-machine-types +update-machine-types: #Update machine_types.go + go build -o hack/machine_types/machine_types ${KOPS_ROOT}/hack/machine_types/machine_types.go + hack/machine_types/machine_types + go fmt upup/pkg/fi/cloudup/awsup/machine_types.go diff --git a/hack/.packages b/hack/.packages index bc0030dfdc9fd..6cebb2cd09f4b 100644 --- a/hack/.packages +++ b/hack/.packages @@ -28,6 +28,7 @@ k8s.io/kops/dnsprovider/pkg/dnsprovider/providers/google/clouddns/internal/stubs k8s.io/kops/dnsprovider/pkg/dnsprovider/rrstype k8s.io/kops/dnsprovider/pkg/dnsprovider/tests k8s.io/kops/examples/kops-api-example +k8s.io/kops/hack/machine_types k8s.io/kops/kube-discovery/cmd/kube-discovery k8s.io/kops/node-authorizer/cmd/node-authorizer k8s.io/kops/node-authorizer/pkg/authorizers/alwaysallow diff --git a/hack/machine_types/.gitignore b/hack/machine_types/.gitignore new file mode 100644 index 0000000000000..c6239bdb1432d --- /dev/null +++ b/hack/machine_types/.gitignore @@ -0,0 +1 @@ +machine_types \ No newline at end of file diff --git a/hack/machine_types/BUILD.bazel b/hack/machine_types/BUILD.bazel new file mode 100644 index 0000000000000..8c93f7bceb825 --- /dev/null +++ b/hack/machine_types/BUILD.bazel @@ -0,0 +1,22 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library") + +go_library( + name = "go_default_library", + srcs = ["machine_types.go"], + importpath = "k8s.io/kops/hack/machine_types", + visibility = ["//visibility:private"], + deps = [ + "//upup/pkg/fi/cloudup/awsup:go_default_library", + "//vendor/github.com/aws/aws-sdk-go/aws:go_default_library", + "//vendor/github.com/aws/aws-sdk-go/aws/awserr:go_default_library", + "//vendor/github.com/aws/aws-sdk-go/aws/session:go_default_library", + "//vendor/github.com/aws/aws-sdk-go/service/pricing:go_default_library", + "//vendor/github.com/golang/glog:go_default_library", + ], +) + +go_binary( + name = "machinetypes", + embed = [":go_default_library"], + visibility = ["//visibility:public"], +) diff --git a/hack/machine_types/README.md b/hack/machine_types/README.md new file mode 100644 index 0000000000000..9d9e5ddebb80f --- /dev/null +++ b/hack/machine_types/README.md @@ -0,0 +1,19 @@ +Machine Types Generator +======================= + +To prevent errors or lagging updates, we use this generator to update the known aws machine types +that are [hard coded in kops](https://github.com/kubernetes/kops/blob/7d7112c1e9a52d4f677db6bd98943d308ec9f581/upup/pkg/fi/cloudup/awsup/machine_types.go#L76). + +This generator uses the AWS Pricing API to get most of it's info on what instance types are supported. + +Usage +----- +``` +make update-machine-types +git add . +git commit -am "Updated machine types" +``` + +TODO: +----- +* Cross reference other regions besides us-east-1. Currently we just look at one region to determine instance types. diff --git a/hack/machine_types/machine_types.go b/hack/machine_types/machine_types.go new file mode 100644 index 0000000000000..434c0e0363fbc --- /dev/null +++ b/hack/machine_types/machine_types.go @@ -0,0 +1,278 @@ +/* +Copyright 2018 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package main + +import ( + "bufio" + "bytes" + "flag" + "fmt" + "io/ioutil" + "log" + "os" + "path/filepath" + "sort" + "strconv" + "strings" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/pricing" + "github.com/golang/glog" + "k8s.io/kops/upup/pkg/fi/cloudup/awsup" +) + +func init() { + flag.Parse() + flag.Lookup("logtostderr").Value.Set("true") +} + +func main() { + + glog.Info("Beginning AWS Machine Refresh") + + // Not currently in the API + t2CreditsPerHour := map[string]float32{ + "t1.micro": 1, + "t2.nano": 3, + "t2.micro": 6, + "t2.small": 12, + "t2.medium": 24, + "t2.large": 36, + "t2.xlarge": 54, + "t2.2xlarge": 81, + } + + machines := []awsup.AWSMachineTypeInfo{} + families := make(map[string]struct{}) + + prices := []aws.JSONValue{} + + svc := pricing.New(session.New(), aws.NewConfig().WithRegion("us-east-1")) + typeTerm := pricing.FilterTypeTermMatch + input := &pricing.GetProductsInput{ + Filters: []*pricing.Filter{ + { + Field: aws.String("operatingSystem"), + Type: &typeTerm, + Value: aws.String("Linux"), + }, + { + Field: aws.String("tenancy"), + Type: &typeTerm, + Value: aws.String("shared"), + }, + { + Field: aws.String("location"), + Type: &typeTerm, + Value: aws.String("US East (N. Virginia)"), + }, + { + Field: aws.String("preInstalledSw"), + Type: &typeTerm, + Value: aws.String("NA"), + }, + }, + FormatVersion: aws.String("aws_v1"), + ServiceCode: aws.String("AmazonEC2"), + } + + for { + result, err := svc.GetProducts(input) + + if err != nil { + if aerr, ok := err.(awserr.Error); ok { + switch aerr.Code() { + case pricing.ErrCodeInternalErrorException: + glog.Errorf(pricing.ErrCodeInternalErrorException, aerr.Error()) + case pricing.ErrCodeInvalidParameterException: + glog.Errorf(pricing.ErrCodeInvalidParameterException, aerr.Error()) + case pricing.ErrCodeNotFoundException: + glog.Errorf(pricing.ErrCodeNotFoundException, aerr.Error()) + case pricing.ErrCodeInvalidNextTokenException: + glog.Errorf(pricing.ErrCodeInvalidNextTokenException, aerr.Error()) + case pricing.ErrCodeExpiredNextTokenException: + glog.Errorf(pricing.ErrCodeExpiredNextTokenException, aerr.Error()) + default: + glog.Errorf(aerr.Error()) + } + } else { + // Print the error, cast err to awserr.Error to get the Code and + // Message from an error. + glog.Errorf(err.Error()) + } + return + } + + for _, p := range result.PriceList { + prices = append(prices, p) + } + + if result.NextToken != nil { + input.NextToken = result.NextToken + } else { + break + } + } + + for _, item := range prices { + for k, v := range item { + if k == "product" { + product := v.(map[string]interface{}) + attributes := map[string]string{} + for k, v := range product["attributes"].(map[string]interface{}) { + attributes[k] = v.(string) + } + + machine := awsup.AWSMachineTypeInfo{ + Name: attributes["instanceType"], + Cores: stringToInt(attributes["vcpu"]), + } + + memory := strings.TrimRight(attributes["memory"], " GiB") + machine.MemoryGB = stringToFloat32(memory) + + if attributes["storage"] != "EBS only" { + storage := strings.Split(attributes["storage"], " ") + count := stringToInt(storage[0]) + size := stringToInt(storage[2]) + + ephemeralDisks := []int{} + for i := 0; i < count; i++ { + ephemeralDisks = append(ephemeralDisks, size) + } + + machine.EphemeralDisks = ephemeralDisks + } + + if attributes["instanceFamily"] == "GPU instance" { + machine.GPU = true + } + + if attributes["ecu"] == "Variable" { + machine.Burstable = true + machine.ECU = t2CreditsPerHour[machine.Name] // This is actually credits * ECUs, but we'll add that later + } else { + machine.ECU = stringToFloat32(attributes["ecu"]) + } + + machines = append(machines, machine) + + family := strings.Split(attributes["instanceType"], ".")[0] + families[family] = struct{}{} + + } + } + } + + sortedFamilies := []string{} + for f := range families { + sortedFamilies = append(sortedFamilies, f) + } + sort.Strings(sortedFamilies) + + sort.Slice(machines, func(i, j int) bool { return machines[i].Name < machines[j].Name }) + + var output string + + for _, f := range sortedFamilies { + output = output + fmt.Sprintf("\n// %s family", f) + for _, m := range machines { + if family := strings.Split(m.Name, ".")[0]; family == f { + var ecu string + if m.Burstable { + ecu = fmt.Sprintf("%v * BurstableCreditsToECUS", m.ECU) + } else { + ecu = fmt.Sprint(m.ECU) + } + body := fmt.Sprintf(` + { + Name: "%s", + MemoryGB: %v, + ECU: %v, + Cores: %v, + EphemeralDisks: %#v, + },`, m.Name, m.MemoryGB, ecu, m.Cores, m.EphemeralDisks) + output = output + body + } + } + output = output + "\n" + } + + ex, err := os.Executable() + if err != nil { + glog.Error(err) + } + exPath := filepath.Dir(ex) + path := exPath + "/../../upup/pkg/fi/cloudup/awsup/machine_types.go" + + glog.Infof("Writing changes to %v", path) + + fileInput, err := ioutil.ReadFile(path) + if err != nil { + log.Fatalln(err) + } + scanner := bufio.NewScanner(bytes.NewReader(fileInput)) + + scanner.Split(bufio.ScanLines) + + var newfile string + flag := false + for scanner.Scan() { + line := scanner.Text() + + if strings.Contains(line, "END GENERATED CONTENT") { + flag = false + } + if !flag { + newfile = newfile + line + "\n" + } + if strings.Contains(line, "BEGIN GENERATED CONTENT") { + flag = true + newfile = newfile + output + } + } + + err = ioutil.WriteFile(path, []byte(newfile), 0644) + if err != nil { + glog.Error(err) + } + + glog.Info("Done.") + glog.Flush() +} + +func stringToFloat32(s string) float32 { + // For 1,000 case + clean := strings.Replace(s, ",", "", -1) + value, err := strconv.ParseFloat(clean, 32) + if err != nil { + glog.Errorf("error converting string to float32: %v", err) + } + return float32(value) +} + +func stringToInt(s string) int { + // For 1,000 case + clean := strings.Replace(s, ",", "", -1) + value, err := strconv.Atoi(clean) + if err != nil { + glog.Error(err) + } + return value +} diff --git a/upup/pkg/fi/cloudup/awsup/machine_types.go b/upup/pkg/fi/cloudup/awsup/machine_types.go index d2e6ba8ca0056..1ce9f90411d24 100644 --- a/upup/pkg/fi/cloudup/awsup/machine_types.go +++ b/upup/pkg/fi/cloudup/awsup/machine_types.go @@ -74,654 +74,693 @@ func GetMachineTypeInfo(machineType string) (*AWSMachineTypeInfo, error) { var MachineTypes []AWSMachineTypeInfo = []AWSMachineTypeInfo{ // This is tedious, but seems simpler than trying to have some logic and then a lot of exceptions - // t2 family + // NOTE: Content below is auto generated by `make update-machine-types` + // BEGIN GENERATED CONTENT + + // c1 family { - Name: "t2.nano", - MemoryGB: 0.5, - ECU: 3 * BurstableCreditsToECUS, - Cores: 1, - EphemeralDisks: nil, - Burstable: true, + Name: "c1.medium", + MemoryGB: 1.7, + ECU: 5, + Cores: 2, + EphemeralDisks: []int{350}, }, { - Name: "t2.micro", - MemoryGB: 1, - ECU: 6 * BurstableCreditsToECUS, - Cores: 1, - EphemeralDisks: nil, - Burstable: true, + Name: "c1.xlarge", + MemoryGB: 7, + ECU: 20, + Cores: 8, + EphemeralDisks: []int{420, 420, 420, 420}, }, + + // c3 family { - Name: "t2.small", - MemoryGB: 2, - ECU: 12 * BurstableCreditsToECUS, - Cores: 1, - EphemeralDisks: nil, - Burstable: true, + Name: "c3.2xlarge", + MemoryGB: 15, + ECU: 28, + Cores: 8, + EphemeralDisks: []int{80, 80}, }, { - Name: "t2.medium", - MemoryGB: 4, - ECU: 24 * BurstableCreditsToECUS, - Cores: 2, - EphemeralDisks: nil, - Burstable: true, + Name: "c3.4xlarge", + MemoryGB: 30, + ECU: 55, + Cores: 16, + EphemeralDisks: []int{160, 160}, }, { - Name: "t2.large", - MemoryGB: 8, - ECU: 36 * BurstableCreditsToECUS, + Name: "c3.8xlarge", + MemoryGB: 60, + ECU: 108, + Cores: 32, + EphemeralDisks: []int{320, 320}, + }, + { + Name: "c3.large", + MemoryGB: 3.75, + ECU: 7, Cores: 2, - EphemeralDisks: nil, - Burstable: true, + EphemeralDisks: []int{16, 16}, }, { - Name: "t2.xlarge", - MemoryGB: 16, - ECU: 54 * BurstableCreditsToECUS, + Name: "c3.xlarge", + MemoryGB: 7.5, + ECU: 14, Cores: 4, - EphemeralDisks: nil, - Burstable: true, + EphemeralDisks: []int{40, 40}, }, + + // c4 family { - Name: "t2.2xlarge", - MemoryGB: 32, - ECU: 81 * BurstableCreditsToECUS, + Name: "c4.2xlarge", + MemoryGB: 15, + ECU: 31, Cores: 8, - EphemeralDisks: nil, - Burstable: true, + EphemeralDisks: []int(nil), }, - - // t3 family { - Name: "t3.nano", - MemoryGB: 0.5, - ECU: 6 * BurstableCreditsToECUS, - Cores: 2, - EphemeralDisks: nil, - Burstable: true, + Name: "c4.4xlarge", + MemoryGB: 30, + ECU: 62, + Cores: 16, + EphemeralDisks: []int(nil), }, { - Name: "t3.micro", - MemoryGB: 1, - ECU: 12 * BurstableCreditsToECUS, - Cores: 2, - EphemeralDisks: nil, - Burstable: true, + Name: "c4.8xlarge", + MemoryGB: 60, + ECU: 132, + Cores: 36, + EphemeralDisks: []int(nil), }, { - Name: "t3.small", - MemoryGB: 2, - ECU: 24 * BurstableCreditsToECUS, + Name: "c4.large", + MemoryGB: 3.75, + ECU: 8, Cores: 2, - EphemeralDisks: nil, - Burstable: true, + EphemeralDisks: []int(nil), }, { - Name: "t3.medium", - MemoryGB: 4, - ECU: 24 * BurstableCreditsToECUS, - Cores: 2, - EphemeralDisks: nil, - Burstable: true, + Name: "c4.xlarge", + MemoryGB: 7.5, + ECU: 16, + Cores: 4, + EphemeralDisks: []int(nil), }, + + // c5 family { - Name: "t3.large", - MemoryGB: 8, - ECU: 36 * BurstableCreditsToECUS, - Cores: 2, - EphemeralDisks: nil, - Burstable: true, + Name: "c5.18xlarge", + MemoryGB: 144, + ECU: 281, + Cores: 72, + EphemeralDisks: []int(nil), }, { - Name: "t3.xlarge", + Name: "c5.2xlarge", MemoryGB: 16, - ECU: 96 * BurstableCreditsToECUS, - Cores: 4, - EphemeralDisks: nil, - Burstable: true, + ECU: 34, + Cores: 8, + EphemeralDisks: []int(nil), }, { - Name: "t3.2xlarge", + Name: "c5.4xlarge", MemoryGB: 32, - ECU: 192 * BurstableCreditsToECUS, - Cores: 8, - EphemeralDisks: nil, - Burstable: true, + ECU: 68, + Cores: 16, + EphemeralDisks: []int(nil), }, - - // m3 family { - Name: "m3.medium", - MemoryGB: 3.75, - ECU: 3, - Cores: 1, - EphemeralDisks: []int{4}, + Name: "c5.9xlarge", + MemoryGB: 72, + ECU: 141, + Cores: 36, + EphemeralDisks: []int(nil), }, { - Name: "m3.large", - MemoryGB: 7.5, - ECU: 6.5, + Name: "c5.large", + MemoryGB: 4, + ECU: 9, Cores: 2, - EphemeralDisks: []int{32}, + EphemeralDisks: []int(nil), }, { - Name: "m3.xlarge", - MemoryGB: 15, - ECU: 13, + Name: "c5.xlarge", + MemoryGB: 8, + ECU: 17, Cores: 4, - EphemeralDisks: []int{40, 40}, - }, - { - Name: "m3.2xlarge", - MemoryGB: 30, - ECU: 26, - Cores: 8, - EphemeralDisks: []int{80, 80}, + EphemeralDisks: []int(nil), }, - // m4 family + // c5d family { - Name: "m4.large", - MemoryGB: 8, - ECU: 6.5, - Cores: 2, - EphemeralDisks: nil, + Name: "c5d.18xlarge", + MemoryGB: 144, + ECU: 281, + Cores: 72, + EphemeralDisks: []int{1800}, }, { - Name: "m4.xlarge", + Name: "c5d.2xlarge", MemoryGB: 16, - ECU: 13, - Cores: 4, - EphemeralDisks: nil, + ECU: 34, + Cores: 8, + EphemeralDisks: []int{200}, }, { - Name: "m4.2xlarge", + Name: "c5d.4xlarge", MemoryGB: 32, - ECU: 26, - Cores: 8, - EphemeralDisks: nil, + ECU: 68, + Cores: 16, + EphemeralDisks: []int{400}, }, { - Name: "m4.4xlarge", - MemoryGB: 64, - ECU: 53.5, - Cores: 16, - EphemeralDisks: nil, + Name: "c5d.9xlarge", + MemoryGB: 72, + ECU: 141, + Cores: 36, + EphemeralDisks: []int{900}, }, { - Name: "m4.10xlarge", - MemoryGB: 160, - ECU: 124.5, - Cores: 40, - EphemeralDisks: nil, + Name: "c5d.large", + MemoryGB: 4, + ECU: 9, + Cores: 2, + EphemeralDisks: []int{50}, }, { - Name: "m4.16xlarge", - MemoryGB: 256, - ECU: 188, - Cores: 64, - EphemeralDisks: nil, + Name: "c5d.xlarge", + MemoryGB: 8, + ECU: 17, + Cores: 4, + EphemeralDisks: []int{100}, }, - // m5 family + // cc2 family { - Name: "m5.large", - MemoryGB: 8, - ECU: 10, - Cores: 2, - EphemeralDisks: nil, + Name: "cc2.8xlarge", + MemoryGB: 60.5, + ECU: 88, + Cores: 32, + EphemeralDisks: []int{840, 840, 840, 840}, }, + + // cr1 family { - Name: "m5.xlarge", - MemoryGB: 16, - ECU: 15, - Cores: 4, - EphemeralDisks: nil, + Name: "cr1.8xlarge", + MemoryGB: 244, + ECU: 88, + Cores: 32, + EphemeralDisks: []int{120, 120}, }, + + // d2 family { - Name: "m5.2xlarge", - MemoryGB: 32, - ECU: 31, + Name: "d2.2xlarge", + MemoryGB: 61, + ECU: 28, Cores: 8, - EphemeralDisks: nil, + EphemeralDisks: []int{2000, 2000, 2000, 2000, 2000, 2000}, }, { - Name: "m5.4xlarge", - MemoryGB: 64, - ECU: 61, + Name: "d2.4xlarge", + MemoryGB: 122, + ECU: 56, Cores: 16, - EphemeralDisks: nil, + EphemeralDisks: []int{2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000}, }, { - Name: "m5.12xlarge", - MemoryGB: 192, - ECU: 173, - Cores: 48, - EphemeralDisks: nil, + Name: "d2.8xlarge", + MemoryGB: 244, + ECU: 116, + Cores: 36, + EphemeralDisks: []int{2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000}, }, { - Name: "m5.24xlarge", - MemoryGB: 384, - ECU: 345, - Cores: 96, - EphemeralDisks: nil, + Name: "d2.xlarge", + MemoryGB: 30.5, + ECU: 14, + Cores: 4, + EphemeralDisks: []int{2000, 2000, 2000}, }, - // m5d family - { - Name: "m5d.large", - MemoryGB: 8, - ECU: 10, - Cores: 2, - EphemeralDisks: []int{75}, - }, + // f1 family { - Name: "m5d.xlarge", - MemoryGB: 16, - ECU: 15, - Cores: 4, - EphemeralDisks: []int{150}, + Name: "f1.16xlarge", + MemoryGB: 976, + ECU: 188, + Cores: 64, + EphemeralDisks: []int(nil), }, { - Name: "m5d.2xlarge", - MemoryGB: 32, - ECU: 31, + Name: "f1.2xlarge", + MemoryGB: 122, + ECU: 26, Cores: 8, - EphemeralDisks: []int{300}, + EphemeralDisks: []int(nil), }, + + // g2 family { - Name: "m5d.4xlarge", + Name: "g2.2xlarge", + MemoryGB: 15, + ECU: 26, + Cores: 8, + EphemeralDisks: []int{60}, + }, + { + Name: "g2.8xlarge", + MemoryGB: 60, + ECU: 104, + Cores: 32, + EphemeralDisks: []int{120, 120}, + }, + + // g3 family + { + Name: "g3.16xlarge", + MemoryGB: 488, + ECU: 188, + Cores: 64, + EphemeralDisks: []int(nil), + }, + { + Name: "g3.4xlarge", + MemoryGB: 122, + ECU: 47, + Cores: 16, + EphemeralDisks: []int(nil), + }, + { + Name: "g3.8xlarge", + MemoryGB: 244, + ECU: 94, + Cores: 32, + EphemeralDisks: []int(nil), + }, + + // h1 family + { + Name: "h1.16xlarge", + MemoryGB: 256, + ECU: 188, + Cores: 64, + EphemeralDisks: []int{2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000}, + }, + { + Name: "h1.2xlarge", + MemoryGB: 32, + ECU: 26, + Cores: 8, + EphemeralDisks: []int{2000}, + }, + { + Name: "h1.4xlarge", MemoryGB: 64, - ECU: 61, + ECU: 53.5, Cores: 16, - EphemeralDisks: []int{300, 300}, + EphemeralDisks: []int{2000, 2000}, }, { - Name: "m5d.12xlarge", - MemoryGB: 192, - ECU: 173, - Cores: 48, - EphemeralDisks: []int{900, 900}, + Name: "h1.8xlarge", + MemoryGB: 128, + ECU: 99, + Cores: 32, + EphemeralDisks: []int{2000, 2000, 2000, 2000}, }, + + // hs1 family { - Name: "m5d.24xlarge", - MemoryGB: 384, - ECU: 345, - Cores: 96, - EphemeralDisks: []int{900, 900, 900, 900}, + Name: "hs1.8xlarge", + MemoryGB: 117, + ECU: 35, + Cores: 17, + EphemeralDisks: []int{2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000}, }, - // c3 family + // i2 family { - Name: "c3.large", - MemoryGB: 3.75, - ECU: 7, - Cores: 2, - EphemeralDisks: []int{16, 16}, + Name: "i2.2xlarge", + MemoryGB: 61, + ECU: 27, + Cores: 8, + EphemeralDisks: []int{800, 800}, }, { - Name: "c3.xlarge", - MemoryGB: 7.5, + Name: "i2.4xlarge", + MemoryGB: 122, + ECU: 53, + Cores: 16, + EphemeralDisks: []int{800, 800, 800, 800}, + }, + { + Name: "i2.8xlarge", + MemoryGB: 244, + ECU: 104, + Cores: 32, + EphemeralDisks: []int{800, 800, 800, 800, 800, 800, 800, 800}, + }, + { + Name: "i2.xlarge", + MemoryGB: 30.5, ECU: 14, Cores: 4, - EphemeralDisks: []int{40, 40}, + EphemeralDisks: []int{800}, }, + + // i3 family { - Name: "c3.2xlarge", - MemoryGB: 15, - ECU: 28, + Name: "i3.16xlarge", + MemoryGB: 488, + ECU: 200, + Cores: 64, + EphemeralDisks: []int{1900, 1900, 1900, 1900, 1900, 1900, 1900, 1900}, + }, + { + Name: "i3.2xlarge", + MemoryGB: 61, + ECU: 27, Cores: 8, - EphemeralDisks: []int{80, 80}, + EphemeralDisks: []int{1900}, }, { - Name: "c3.4xlarge", - MemoryGB: 30, - ECU: 55, + Name: "i3.4xlarge", + MemoryGB: 122, + ECU: 53, Cores: 16, - EphemeralDisks: []int{160, 160}, + EphemeralDisks: []int{1900, 1900}, }, { - Name: "c3.8xlarge", - MemoryGB: 60, - ECU: 108, + Name: "i3.8xlarge", + MemoryGB: 244, + ECU: 99, Cores: 32, - EphemeralDisks: []int{320, 320}, + EphemeralDisks: []int{1900, 1900, 1900, 1900}, }, - - // c4 family { - Name: "c4.large", - MemoryGB: 3.75, - ECU: 8, + Name: "i3.large", + MemoryGB: 15.25, + ECU: 7, Cores: 2, - EphemeralDisks: nil, + EphemeralDisks: []int{475}, }, { - Name: "c4.xlarge", - MemoryGB: 7.5, - ECU: 16, + Name: "i3.metal", + MemoryGB: 512, + ECU: 208, + Cores: 72, + EphemeralDisks: []int{1900, 1900, 1900, 1900, 1900, 1900, 1900, 1900}, + }, + { + Name: "i3.xlarge", + MemoryGB: 30.5, + ECU: 13, Cores: 4, - EphemeralDisks: nil, + EphemeralDisks: []int{950}, }, + + // m1 family { - Name: "c4.2xlarge", - MemoryGB: 15, - ECU: 31, - Cores: 8, - EphemeralDisks: nil, + Name: "m1.large", + MemoryGB: 7.5, + ECU: 4, + Cores: 2, + EphemeralDisks: []int{420, 420}, }, { - Name: "c4.4xlarge", - MemoryGB: 30, - ECU: 62, - Cores: 16, - EphemeralDisks: nil, + Name: "m1.medium", + MemoryGB: 3.75, + ECU: 2, + Cores: 1, + EphemeralDisks: []int{410}, }, { - Name: "c4.8xlarge", - MemoryGB: 60, - ECU: 132, - Cores: 32, - EphemeralDisks: nil, + Name: "m1.small", + MemoryGB: 1.7, + ECU: 1, + Cores: 1, + EphemeralDisks: []int{160}, }, - - // c5 family { - Name: "c5.large", - MemoryGB: 4, + Name: "m1.xlarge", + MemoryGB: 15, ECU: 8, - Cores: 2, - EphemeralDisks: nil, + Cores: 4, + EphemeralDisks: []int{420, 420, 420, 420}, }, + + // m2 family { - Name: "c5.xlarge", - MemoryGB: 8, - ECU: 16, + Name: "m2.2xlarge", + MemoryGB: 34.2, + ECU: 13, Cores: 4, - EphemeralDisks: nil, + EphemeralDisks: []int{850}, }, { - Name: "c5.2xlarge", - MemoryGB: 16, - ECU: 31, + Name: "m2.4xlarge", + MemoryGB: 68.4, + ECU: 26, Cores: 8, - EphemeralDisks: nil, + EphemeralDisks: []int{840, 840}, }, { - Name: "c5.4xlarge", - MemoryGB: 32, - ECU: 62, - Cores: 16, - EphemeralDisks: nil, + Name: "m2.xlarge", + MemoryGB: 17.1, + ECU: 6.5, + Cores: 2, + EphemeralDisks: []int{420}, }, + + // m3 family { - Name: "c5.9xlarge", - MemoryGB: 72, - ECU: 139, - Cores: 36, - EphemeralDisks: nil, + Name: "m3.2xlarge", + MemoryGB: 30, + ECU: 26, + Cores: 8, + EphemeralDisks: []int{80, 80}, }, { - Name: "c5.18xlarge", - MemoryGB: 144, - ECU: 278, - Cores: 72, - EphemeralDisks: nil, + Name: "m3.large", + MemoryGB: 7.5, + ECU: 6.5, + Cores: 2, + EphemeralDisks: []int{32}, }, - - // c5d family { - Name: "c5d.large", - MemoryGB: 4, - ECU: 8, - Cores: 2, - EphemeralDisks: []int{50}, + Name: "m3.medium", + MemoryGB: 3.75, + ECU: 3, + Cores: 1, + EphemeralDisks: []int{4}, }, { - Name: "c5d.xlarge", - MemoryGB: 8, - ECU: 16, + Name: "m3.xlarge", + MemoryGB: 15, + ECU: 13, Cores: 4, - EphemeralDisks: []int{100}, + EphemeralDisks: []int{40, 40}, }, + + // m4 family { - Name: "c5d.2xlarge", - MemoryGB: 16, - ECU: 31, - Cores: 8, - EphemeralDisks: []int{200}, + Name: "m4.10xlarge", + MemoryGB: 160, + ECU: 124.5, + Cores: 40, + EphemeralDisks: []int(nil), }, { - Name: "c5d.4xlarge", + Name: "m4.16xlarge", + MemoryGB: 256, + ECU: 188, + Cores: 64, + EphemeralDisks: []int(nil), + }, + { + Name: "m4.2xlarge", MemoryGB: 32, - ECU: 62, + ECU: 26, + Cores: 8, + EphemeralDisks: []int(nil), + }, + { + Name: "m4.4xlarge", + MemoryGB: 64, + ECU: 53.5, Cores: 16, - EphemeralDisks: []int{400}, + EphemeralDisks: []int(nil), }, { - Name: "c5d.9xlarge", - MemoryGB: 72, - ECU: 139, - Cores: 36, - EphemeralDisks: []int{900}, + Name: "m4.large", + MemoryGB: 8, + ECU: 6.5, + Cores: 2, + EphemeralDisks: []int(nil), }, { - Name: "c5d.18xlarge", - MemoryGB: 144, - ECU: 278, - Cores: 72, - EphemeralDisks: []int{900, 900}, + Name: "m4.xlarge", + MemoryGB: 16, + ECU: 13, + Cores: 4, + EphemeralDisks: []int(nil), }, - // cc2 family + // m5 family { - Name: "cc2.8xlarge", - MemoryGB: 60.5, - ECU: 88, - Cores: 32, - EphemeralDisks: []int{840, 840, 840, 840}, + Name: "m5.12xlarge", + MemoryGB: 192, + ECU: 173, + Cores: 48, + EphemeralDisks: []int(nil), }, - - // cg1 family { - Name: "cg1.4xlarge", - MemoryGB: 22.5, - ECU: 33.5, - Cores: 16, - EphemeralDisks: []int{840, 840}, - GPU: true, + Name: "m5.24xlarge", + MemoryGB: 384, + ECU: 345, + Cores: 96, + EphemeralDisks: []int(nil), }, - - // cr1 family { - Name: "cr1.8xlarge", - MemoryGB: 244.0, - ECU: 88, - Cores: 32, - EphemeralDisks: []int{120, 120}, + Name: "m5.2xlarge", + MemoryGB: 32, + ECU: 31, + Cores: 8, + EphemeralDisks: []int(nil), }, - - // d2 family { - Name: "d2.xlarge", - MemoryGB: 30.5, - ECU: 14, - Cores: 4, - EphemeralDisks: []int{2000, 2000, 2000}, + Name: "m5.4xlarge", + MemoryGB: 64, + ECU: 60, + Cores: 16, + EphemeralDisks: []int(nil), }, { - Name: "d2.2xlarge", - MemoryGB: 61.0, - ECU: 28, - Cores: 8, - EphemeralDisks: []int{2000, 2000, 2000, 2000, 2000, 2000}, + Name: "m5.large", + MemoryGB: 8, + ECU: 8, + Cores: 2, + EphemeralDisks: []int(nil), }, { - Name: "d2.4xlarge", - MemoryGB: 122.0, - ECU: 56, - Cores: 16, - EphemeralDisks: []int{ - 2000, 2000, 2000, 2000, 2000, 2000, - 2000, 2000, 2000, 2000, 2000, 2000, - }, + Name: "m5.xlarge", + MemoryGB: 16, + ECU: 16, + Cores: 4, + EphemeralDisks: []int(nil), + }, + + // m5d family + { + Name: "m5d.12xlarge", + MemoryGB: 192, + ECU: 173, + Cores: 48, + EphemeralDisks: []int{900, 900}, }, { - Name: "d2.8xlarge", - MemoryGB: 244.0, - ECU: 116, - Cores: 36, - EphemeralDisks: []int{ - 2000, 2000, 2000, 2000, 2000, 2000, - 2000, 2000, 2000, 2000, 2000, 2000, - 2000, 2000, 2000, 2000, 2000, 2000, - 2000, 2000, 2000, 2000, 2000, 2000, - }, + Name: "m5d.24xlarge", + MemoryGB: 384, + ECU: 345, + Cores: 96, + EphemeralDisks: []int{900, 900, 900, 900}, }, - - // h1 family { - Name: "h1.2xlarge", + Name: "m5d.2xlarge", MemoryGB: 32, - ECU: 26, + ECU: 31, Cores: 8, - EphemeralDisks: []int{2000}, + EphemeralDisks: []int{300}, }, { - Name: "h1.4xlarge", + Name: "m5d.4xlarge", MemoryGB: 64, - ECU: 53.5, + ECU: 60, Cores: 16, - EphemeralDisks: []int{2000, 2000}, + EphemeralDisks: []int{300, 300}, }, { - Name: "h1.8xlarge", - MemoryGB: 128, - ECU: 99, - Cores: 32, - EphemeralDisks: []int{2000, 2000, 2000, 2000}, + Name: "m5d.large", + MemoryGB: 8, + ECU: 8, + Cores: 2, + EphemeralDisks: []int{75}, }, { - Name: "h1.16xlarge", - MemoryGB: 256, - ECU: 188, - Cores: 64, - EphemeralDisks: []int{ - 2000, 2000, 2000, 2000, - 2000, 2000, 2000, 2000, - }, + Name: "m5d.xlarge", + MemoryGB: 16, + ECU: 16, + Cores: 4, + EphemeralDisks: []int{150}, }, - // g2 family + // p2 family { - Name: "g2.2xlarge", - MemoryGB: 15, - ECU: 26, - Cores: 8, - EphemeralDisks: []int{60}, - GPU: true, + Name: "p2.16xlarge", + MemoryGB: 768, + ECU: 188, + Cores: 64, + EphemeralDisks: []int(nil), }, { - Name: "g2.8xlarge", - MemoryGB: 60, - ECU: 104, + Name: "p2.8xlarge", + MemoryGB: 488, + ECU: 94, Cores: 32, - EphemeralDisks: []int{120, 120}, - GPU: true, + EphemeralDisks: []int(nil), }, - - // hi1 family { - Name: "hi1.4xlarge", - MemoryGB: 60.5, - ECU: 35, - Cores: 16, - EphemeralDisks: []int{1024, 1024}, + Name: "p2.xlarge", + MemoryGB: 61, + ECU: 12, + Cores: 4, + EphemeralDisks: []int(nil), }, - // i2 family + // p3 family { - Name: "i2.xlarge", - MemoryGB: 30.5, - ECU: 14, - Cores: 4, - EphemeralDisks: []int{800}, + Name: "p3.16xlarge", + MemoryGB: 488, + ECU: 188, + Cores: 64, + EphemeralDisks: []int(nil), }, { - Name: "i2.2xlarge", + Name: "p3.2xlarge", MemoryGB: 61, - ECU: 27, + ECU: 26, Cores: 8, - EphemeralDisks: []int{800, 800}, - }, - { - Name: "i2.4xlarge", - MemoryGB: 122, - ECU: 53, - Cores: 16, - EphemeralDisks: []int{800, 800, 800, 800}, + EphemeralDisks: []int(nil), }, { - Name: "i2.8xlarge", + Name: "p3.8xlarge", MemoryGB: 244, - ECU: 104, + ECU: 94, Cores: 32, - EphemeralDisks: []int{800, 800, 800, 800, 800, 800, 800, 800}, + EphemeralDisks: []int(nil), }, - // i3 family - { - Name: "i3.large", - MemoryGB: 15.25, - ECU: 9, - Cores: 2, - EphemeralDisks: []int{475}, - }, - { - Name: "i3.xlarge", - MemoryGB: 30.5, - ECU: 14, - Cores: 4, - EphemeralDisks: []int{950}, - }, + // r3 family { - Name: "i3.2xlarge", + Name: "r3.2xlarge", MemoryGB: 61, - ECU: 27, + ECU: 26, Cores: 8, - EphemeralDisks: []int{1900}, + EphemeralDisks: []int{160}, }, { - Name: "i3.4xlarge", + Name: "r3.4xlarge", MemoryGB: 122, - ECU: 53, + ECU: 52, Cores: 16, - EphemeralDisks: []int{1900, 1900}, + EphemeralDisks: []int{320}, }, { - Name: "i3.8xlarge", + Name: "r3.8xlarge", MemoryGB: 244, ECU: 104, Cores: 32, - EphemeralDisks: []int{1900, 1900, 1900, 1900}, - }, - { - Name: "i3.16xlarge", - MemoryGB: 488, - ECU: 208, - Cores: 64, - EphemeralDisks: []int{1900, 1900, 1900, 1900, 1900, 1900, 1900, 1900}, - }, - { - Name: "i3.metal", - MemoryGB: 512, - ECU: 208, - Cores: 72, - EphemeralDisks: []int{1900, 1900, 1900, 1900, 1900, 1900, 1900, 1900}, + EphemeralDisks: []int{320, 320}, }, - - // r3 family { Name: "r3.large", MemoryGB: 15.25, @@ -736,178 +775,124 @@ var MachineTypes []AWSMachineTypeInfo = []AWSMachineTypeInfo{ Cores: 4, EphemeralDisks: []int{80}, }, - { - Name: "r3.2xlarge", - MemoryGB: 61, - ECU: 26, - Cores: 8, - EphemeralDisks: []int{160}, - }, - { - Name: "r3.4xlarge", - MemoryGB: 122, - ECU: 52, - Cores: 16, - EphemeralDisks: []int{320}, - }, - { - Name: "r3.8xlarge", - MemoryGB: 244, - ECU: 104, - Cores: 32, - EphemeralDisks: []int{320, 320}, - }, - - // x1e family + // r4 family { - Name: "x1e.xlarge", - MemoryGB: 122, - ECU: 12, - Cores: 4, - EphemeralDisks: []int{120}, + Name: "r4.16xlarge", + MemoryGB: 488, + ECU: 195, + Cores: 64, + EphemeralDisks: []int(nil), }, { - Name: "x1e.2xlarge", - MemoryGB: 244, - ECU: 23, + Name: "r4.2xlarge", + MemoryGB: 61, + ECU: 27, Cores: 8, - EphemeralDisks: []int{240}, + EphemeralDisks: []int(nil), }, { - Name: "x1e.4xlarge", - MemoryGB: 488, - ECU: 47, + Name: "r4.4xlarge", + MemoryGB: 122, + ECU: 53, Cores: 16, - EphemeralDisks: []int{480}, + EphemeralDisks: []int(nil), }, { - Name: "x1e.8xlarge", - MemoryGB: 976, - ECU: 91, + Name: "r4.8xlarge", + MemoryGB: 244, + ECU: 99, Cores: 32, - EphemeralDisks: []int{960}, + EphemeralDisks: []int(nil), }, - { - Name: "x1e.16xlarge", - MemoryGB: 1952, - ECU: 179, - Cores: 64, - EphemeralDisks: []int{1920}, - }, - { - Name: "x1e.32xlarge", - MemoryGB: 3904, - ECU: 340, - Cores: 128, - EphemeralDisks: []int{1920, 1920}, - }, - - // x1 family - { - Name: "x1.16xlarge", - MemoryGB: 976, - ECU: 174.5, - Cores: 64, - EphemeralDisks: []int{1920}, - }, - { - Name: "x1.32xlarge", - MemoryGB: 1952, - ECU: 349, - Cores: 128, - EphemeralDisks: []int{1920, 1920}, - }, - - // r4 family { Name: "r4.large", MemoryGB: 15.25, ECU: 7, Cores: 2, - EphemeralDisks: nil, + EphemeralDisks: []int(nil), }, { Name: "r4.xlarge", MemoryGB: 30.5, ECU: 13.5, Cores: 4, - EphemeralDisks: nil, + EphemeralDisks: []int(nil), }, + + // r5 family { - Name: "r4.2xlarge", - MemoryGB: 61, - ECU: 27, - Cores: 8, - EphemeralDisks: nil, + Name: "r5.12xlarge", + MemoryGB: 384, + ECU: 173, + Cores: 48, + EphemeralDisks: []int(nil), }, { - Name: "r4.4xlarge", - MemoryGB: 122, - ECU: 53, - Cores: 16, - EphemeralDisks: nil, + Name: "r5.24xlarge", + MemoryGB: 768, + ECU: 345, + Cores: 96, + EphemeralDisks: []int(nil), }, { - Name: "r4.8xlarge", - MemoryGB: 244, - ECU: 99, - Cores: 32, - EphemeralDisks: nil, + Name: "r5.2xlarge", + MemoryGB: 64, + ECU: 31, + Cores: 8, + EphemeralDisks: []int(nil), }, { - Name: "r4.16xlarge", - MemoryGB: 488, - ECU: 195, - Cores: 64, - EphemeralDisks: nil, + Name: "r5.4xlarge", + MemoryGB: 128, + ECU: 60, + Cores: 16, + EphemeralDisks: []int(nil), }, - - // r5 family { Name: "r5.large", MemoryGB: 16, ECU: 8, Cores: 2, - EphemeralDisks: nil, + EphemeralDisks: []int(nil), }, { Name: "r5.xlarge", MemoryGB: 32, ECU: 16, Cores: 4, - EphemeralDisks: nil, - }, - { - Name: "r5.2xlarge", - MemoryGB: 64, - ECU: 31, - Cores: 8, - EphemeralDisks: nil, - }, - { - Name: "r5.4xlarge", - MemoryGB: 128, - ECU: 61, - Cores: 16, - EphemeralDisks: nil, + EphemeralDisks: []int(nil), }, + + // r5d family { - Name: "r5.12xlarge", + Name: "r5d.12xlarge", MemoryGB: 384, - ECU: 172, + ECU: 173, Cores: 48, - EphemeralDisks: nil, + EphemeralDisks: []int{900, 900}, }, { - Name: "r5.24xlarge", + Name: "r5d.24xlarge", MemoryGB: 768, ECU: 345, Cores: 96, - EphemeralDisks: nil, + EphemeralDisks: []int{900, 900, 900, 900}, + }, + { + Name: "r5d.2xlarge", + MemoryGB: 64, + ECU: 31, + Cores: 8, + EphemeralDisks: []int{300}, + }, + { + Name: "r5d.4xlarge", + MemoryGB: 128, + ECU: 60, + Cores: 16, + EphemeralDisks: []int{300, 300}, }, - - // r5d family { Name: "r5d.large", MemoryGB: 16, @@ -922,170 +907,220 @@ var MachineTypes []AWSMachineTypeInfo = []AWSMachineTypeInfo{ Cores: 4, EphemeralDisks: []int{150}, }, + + // t1 family { - Name: "r5d.2xlarge", - MemoryGB: 64, - ECU: 31, + Name: "t1.micro", + MemoryGB: 0.613, + ECU: 1 * BurstableCreditsToECUS, + Cores: 1, + EphemeralDisks: []int(nil), + }, + + // t2 family + { + Name: "t2.2xlarge", + MemoryGB: 32, + ECU: 81 * BurstableCreditsToECUS, Cores: 8, - EphemeralDisks: []int{300}, + EphemeralDisks: []int(nil), }, { - Name: "r5d.4xlarge", - MemoryGB: 128, - ECU: 61, - Cores: 16, - EphemeralDisks: []int{300, 300}, + Name: "t2.large", + MemoryGB: 8, + ECU: 36 * BurstableCreditsToECUS, + Cores: 2, + EphemeralDisks: []int(nil), }, { - Name: "r5d.12xlarge", - MemoryGB: 384, - ECU: 172, - Cores: 48, - EphemeralDisks: []int{900, 900}, + Name: "t2.medium", + MemoryGB: 4, + ECU: 24 * BurstableCreditsToECUS, + Cores: 2, + EphemeralDisks: []int(nil), }, { - Name: "r5d.24xlarge", - MemoryGB: 768, - ECU: 345, - Cores: 96, - EphemeralDisks: []int{900, 900, 900, 900}, + Name: "t2.micro", + MemoryGB: 1, + ECU: 6 * BurstableCreditsToECUS, + Cores: 1, + EphemeralDisks: []int(nil), }, - - // z1d family { - Name: "z1d.large", - MemoryGB: 16, - ECU: 11, - Cores: 2, - EphemeralDisks: []int{75}, + Name: "t2.nano", + MemoryGB: 0.5, + ECU: 3 * BurstableCreditsToECUS, + Cores: 1, + EphemeralDisks: []int(nil), }, { - Name: "z1d.xlarge", - MemoryGB: 32, - ECU: 21, + Name: "t2.small", + MemoryGB: 2, + ECU: 12 * BurstableCreditsToECUS, + Cores: 1, + EphemeralDisks: []int(nil), + }, + { + Name: "t2.xlarge", + MemoryGB: 16, + ECU: 54 * BurstableCreditsToECUS, Cores: 4, - EphemeralDisks: []int{150}, + EphemeralDisks: []int(nil), }, + + // t3 family { - Name: "z1d.2xlarge", - MemoryGB: 64, - ECU: 42, + Name: "t3.2xlarge", + MemoryGB: 32, + ECU: 0 * BurstableCreditsToECUS, Cores: 8, - EphemeralDisks: []int{300}, + EphemeralDisks: []int(nil), }, { - Name: "z1d.3xlarge", - MemoryGB: 96, - ECU: 62, - Cores: 12, - EphemeralDisks: []int{450}, + Name: "t3.large", + MemoryGB: 8, + ECU: 0 * BurstableCreditsToECUS, + Cores: 2, + EphemeralDisks: []int(nil), }, { - Name: "z1d.6xlarge", - MemoryGB: 128, - ECU: 122, - Cores: 24, - EphemeralDisks: []int{900}, + Name: "t3.medium", + MemoryGB: 4, + ECU: 0 * BurstableCreditsToECUS, + Cores: 2, + EphemeralDisks: []int(nil), }, { - Name: "z1d.12xlarge", - MemoryGB: 235, - ECU: 243, - Cores: 48, - EphemeralDisks: []int{900, 900}, + Name: "t3.micro", + MemoryGB: 1, + ECU: 0 * BurstableCreditsToECUS, + Cores: 2, + EphemeralDisks: []int(nil), }, - - // p2 family { - Name: "p2.xlarge", - MemoryGB: 61, - ECU: 12, - Cores: 4, - EphemeralDisks: nil, - GPU: true, + Name: "t3.nano", + MemoryGB: 0.5, + ECU: 0 * BurstableCreditsToECUS, + Cores: 2, + EphemeralDisks: []int(nil), }, { - Name: "p2.8xlarge", - MemoryGB: 488, - ECU: 94, - Cores: 32, - EphemeralDisks: nil, - GPU: true, + Name: "t3.small", + MemoryGB: 2, + ECU: 0 * BurstableCreditsToECUS, + Cores: 2, + EphemeralDisks: []int(nil), }, { - Name: "p2.16xlarge", - MemoryGB: 732, - ECU: 188, + Name: "t3.xlarge", + MemoryGB: 16, + ECU: 0 * BurstableCreditsToECUS, + Cores: 4, + EphemeralDisks: []int(nil), + }, + + // x1 family + { + Name: "x1.16xlarge", + MemoryGB: 976, + ECU: 174.5, Cores: 64, - EphemeralDisks: nil, - GPU: true, + EphemeralDisks: []int{1920}, + }, + { + Name: "x1.32xlarge", + MemoryGB: 1952, + ECU: 349, + Cores: 128, + EphemeralDisks: []int{1920, 1920}, }, - // p3 family + // x1e family { - Name: "p3.2xlarge", - MemoryGB: 61, - ECU: 23.5, - Cores: 8, - EphemeralDisks: nil, - GPU: true, + Name: "x1e.16xlarge", + MemoryGB: 1952, + ECU: 179, + Cores: 64, + EphemeralDisks: []int{1920}, }, { - Name: "p3.8xlarge", + Name: "x1e.2xlarge", MemoryGB: 244, - ECU: 94, - Cores: 32, - EphemeralDisks: nil, - GPU: true, + ECU: 23, + Cores: 8, + EphemeralDisks: []int{240}, }, { - Name: "p3.16xlarge", - MemoryGB: 488, - ECU: 188, - Cores: 64, - EphemeralDisks: nil, - GPU: true, + Name: "x1e.32xlarge", + MemoryGB: 3904, + ECU: 340, + Cores: 128, + EphemeralDisks: []int{1920, 1920}, }, - - // g3 family { - Name: "g3.4xlarge", - MemoryGB: 122, - Cores: 16, + Name: "x1e.4xlarge", + MemoryGB: 488, ECU: 47, - EphemeralDisks: nil, - GPU: true, + Cores: 16, + EphemeralDisks: []int{480}, }, { - Name: "g3.8xlarge", - MemoryGB: 244, - ECU: 94, + Name: "x1e.8xlarge", + MemoryGB: 976, + ECU: 91, Cores: 32, - EphemeralDisks: nil, - GPU: true, + EphemeralDisks: []int{960}, }, { - Name: "g3.16xlarge", - MemoryGB: 488, - ECU: 188, - Cores: 64, - EphemeralDisks: nil, - GPU: true, + Name: "x1e.xlarge", + MemoryGB: 122, + ECU: 12, + Cores: 4, + EphemeralDisks: []int{120}, }, - // f1 family + // z1d family { - Name: "f1.2xlarge", - MemoryGB: 122, - ECU: 94, + Name: "z1d.12xlarge", + MemoryGB: 384, + ECU: 235, + Cores: 48, + EphemeralDisks: []int{900, 900}, + }, + { + Name: "z1d.2xlarge", + MemoryGB: 64, + ECU: 43, Cores: 8, - EphemeralDisks: nil, + EphemeralDisks: []int{300}, }, { - Name: "f1.16xlarge", - MemoryGB: 976, - ECU: 376, - Cores: 64, - EphemeralDisks: nil, + Name: "z1d.3xlarge", + MemoryGB: 96, + ECU: 65, + Cores: 12, + EphemeralDisks: []int{450}, + }, + { + Name: "z1d.6xlarge", + MemoryGB: 192, + ECU: 128, + Cores: 24, + EphemeralDisks: []int{900}, + }, + { + Name: "z1d.large", + MemoryGB: 16, + ECU: 11, + Cores: 2, + EphemeralDisks: []int{75}, + }, + { + Name: "z1d.xlarge", + MemoryGB: 32, + ECU: 21, + Cores: 4, + EphemeralDisks: []int{150}, }, + // END GENERATED CONTENT } diff --git a/vendor/github.com/aws/aws-sdk-go/service/pricing/BUILD.bazel b/vendor/github.com/aws/aws-sdk-go/service/pricing/BUILD.bazel new file mode 100644 index 0000000000000..fc663254d4fb4 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/pricing/BUILD.bazel @@ -0,0 +1,23 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_library") + +go_library( + name = "go_default_library", + srcs = [ + "api.go", + "doc.go", + "errors.go", + "service.go", + ], + importmap = "vendor/github.com/aws/aws-sdk-go/service/pricing", + importpath = "github.com/aws/aws-sdk-go/service/pricing", + visibility = ["//visibility:public"], + deps = [ + "//vendor/github.com/aws/aws-sdk-go/aws:go_default_library", + "//vendor/github.com/aws/aws-sdk-go/aws/awsutil:go_default_library", + "//vendor/github.com/aws/aws-sdk-go/aws/client:go_default_library", + "//vendor/github.com/aws/aws-sdk-go/aws/client/metadata:go_default_library", + "//vendor/github.com/aws/aws-sdk-go/aws/request:go_default_library", + "//vendor/github.com/aws/aws-sdk-go/aws/signer/v4:go_default_library", + "//vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc:go_default_library", + ], +) diff --git a/vendor/github.com/aws/aws-sdk-go/service/pricing/api.go b/vendor/github.com/aws/aws-sdk-go/service/pricing/api.go new file mode 100644 index 0000000000000..f5be2db265a1c --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/pricing/api.go @@ -0,0 +1,955 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package pricing + +import ( + "fmt" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awsutil" + "github.com/aws/aws-sdk-go/aws/request" +) + +const opDescribeServices = "DescribeServices" + +// DescribeServicesRequest generates a "aws/request.Request" representing the +// client's request for the DescribeServices operation. The "output" return +// value will be populated with the request's response once the request completes +// successfuly. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See DescribeServices for more information on using the DescribeServices +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the DescribeServicesRequest method. +// req, resp := client.DescribeServicesRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/pricing-2017-10-15/DescribeServices +func (c *Pricing) DescribeServicesRequest(input *DescribeServicesInput) (req *request.Request, output *DescribeServicesOutput) { + op := &request.Operation{ + Name: opDescribeServices, + HTTPMethod: "POST", + HTTPPath: "/", + Paginator: &request.Paginator{ + InputTokens: []string{"NextToken"}, + OutputTokens: []string{"NextToken"}, + LimitToken: "MaxResults", + TruncationToken: "", + }, + } + + if input == nil { + input = &DescribeServicesInput{} + } + + output = &DescribeServicesOutput{} + req = c.newRequest(op, input, output) + return +} + +// DescribeServices API operation for AWS Price List Service. +// +// Returns the metadata for one service or a list of the metadata for all services. +// Use this without a service code to get the service codes for all services. +// Use it with a service code, such as AmazonEC2, to get information specific +// to that service, such as the attribute names available for that service. +// For example, some of the attribute names available for EC2 are volumeType, +// maxIopsVolume, operation, locationType, and instanceCapacity10xlarge. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for AWS Price List Service's +// API operation DescribeServices for usage and error information. +// +// Returned Error Codes: +// * ErrCodeInternalErrorException "InternalErrorException" +// An error on the server occurred during the processing of your request. Try +// again later. +// +// * ErrCodeInvalidParameterException "InvalidParameterException" +// One or more parameters had an invalid value. +// +// * ErrCodeNotFoundException "NotFoundException" +// The requested resource can't be found. +// +// * ErrCodeInvalidNextTokenException "InvalidNextTokenException" +// The pagination token is invalid. Try again without a pagination token. +// +// * ErrCodeExpiredNextTokenException "ExpiredNextTokenException" +// The pagination token expired. Try again without a pagination token. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/pricing-2017-10-15/DescribeServices +func (c *Pricing) DescribeServices(input *DescribeServicesInput) (*DescribeServicesOutput, error) { + req, out := c.DescribeServicesRequest(input) + return out, req.Send() +} + +// DescribeServicesWithContext is the same as DescribeServices with the addition of +// the ability to pass a context and additional request options. +// +// See DescribeServices for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Pricing) DescribeServicesWithContext(ctx aws.Context, input *DescribeServicesInput, opts ...request.Option) (*DescribeServicesOutput, error) { + req, out := c.DescribeServicesRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +// DescribeServicesPages iterates over the pages of a DescribeServices operation, +// calling the "fn" function with the response data for each page. To stop +// iterating, return false from the fn function. +// +// See DescribeServices method for more information on how to use this operation. +// +// Note: This operation can generate multiple requests to a service. +// +// // Example iterating over at most 3 pages of a DescribeServices operation. +// pageNum := 0 +// err := client.DescribeServicesPages(params, +// func(page *DescribeServicesOutput, lastPage bool) bool { +// pageNum++ +// fmt.Println(page) +// return pageNum <= 3 +// }) +// +func (c *Pricing) DescribeServicesPages(input *DescribeServicesInput, fn func(*DescribeServicesOutput, bool) bool) error { + return c.DescribeServicesPagesWithContext(aws.BackgroundContext(), input, fn) +} + +// DescribeServicesPagesWithContext same as DescribeServicesPages except +// it takes a Context and allows setting request options on the pages. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Pricing) DescribeServicesPagesWithContext(ctx aws.Context, input *DescribeServicesInput, fn func(*DescribeServicesOutput, bool) bool, opts ...request.Option) error { + p := request.Pagination{ + NewRequest: func() (*request.Request, error) { + var inCpy *DescribeServicesInput + if input != nil { + tmp := *input + inCpy = &tmp + } + req, _ := c.DescribeServicesRequest(inCpy) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return req, nil + }, + } + + cont := true + for p.Next() && cont { + cont = fn(p.Page().(*DescribeServicesOutput), !p.HasNextPage()) + } + return p.Err() +} + +const opGetAttributeValues = "GetAttributeValues" + +// GetAttributeValuesRequest generates a "aws/request.Request" representing the +// client's request for the GetAttributeValues operation. The "output" return +// value will be populated with the request's response once the request completes +// successfuly. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See GetAttributeValues for more information on using the GetAttributeValues +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the GetAttributeValuesRequest method. +// req, resp := client.GetAttributeValuesRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/pricing-2017-10-15/GetAttributeValues +func (c *Pricing) GetAttributeValuesRequest(input *GetAttributeValuesInput) (req *request.Request, output *GetAttributeValuesOutput) { + op := &request.Operation{ + Name: opGetAttributeValues, + HTTPMethod: "POST", + HTTPPath: "/", + Paginator: &request.Paginator{ + InputTokens: []string{"NextToken"}, + OutputTokens: []string{"NextToken"}, + LimitToken: "MaxResults", + TruncationToken: "", + }, + } + + if input == nil { + input = &GetAttributeValuesInput{} + } + + output = &GetAttributeValuesOutput{} + req = c.newRequest(op, input, output) + return +} + +// GetAttributeValues API operation for AWS Price List Service. +// +// Returns a list of attribute values. Attibutes are similar to the details +// in a Price List API offer file. For a list of available attributes, see Offer +// File Definitions (http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/reading-an-offer.html#pps-defs) +// in the AWS Billing and Cost Management User Guide (http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/billing-what-is.html). +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for AWS Price List Service's +// API operation GetAttributeValues for usage and error information. +// +// Returned Error Codes: +// * ErrCodeInternalErrorException "InternalErrorException" +// An error on the server occurred during the processing of your request. Try +// again later. +// +// * ErrCodeInvalidParameterException "InvalidParameterException" +// One or more parameters had an invalid value. +// +// * ErrCodeNotFoundException "NotFoundException" +// The requested resource can't be found. +// +// * ErrCodeInvalidNextTokenException "InvalidNextTokenException" +// The pagination token is invalid. Try again without a pagination token. +// +// * ErrCodeExpiredNextTokenException "ExpiredNextTokenException" +// The pagination token expired. Try again without a pagination token. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/pricing-2017-10-15/GetAttributeValues +func (c *Pricing) GetAttributeValues(input *GetAttributeValuesInput) (*GetAttributeValuesOutput, error) { + req, out := c.GetAttributeValuesRequest(input) + return out, req.Send() +} + +// GetAttributeValuesWithContext is the same as GetAttributeValues with the addition of +// the ability to pass a context and additional request options. +// +// See GetAttributeValues for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Pricing) GetAttributeValuesWithContext(ctx aws.Context, input *GetAttributeValuesInput, opts ...request.Option) (*GetAttributeValuesOutput, error) { + req, out := c.GetAttributeValuesRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +// GetAttributeValuesPages iterates over the pages of a GetAttributeValues operation, +// calling the "fn" function with the response data for each page. To stop +// iterating, return false from the fn function. +// +// See GetAttributeValues method for more information on how to use this operation. +// +// Note: This operation can generate multiple requests to a service. +// +// // Example iterating over at most 3 pages of a GetAttributeValues operation. +// pageNum := 0 +// err := client.GetAttributeValuesPages(params, +// func(page *GetAttributeValuesOutput, lastPage bool) bool { +// pageNum++ +// fmt.Println(page) +// return pageNum <= 3 +// }) +// +func (c *Pricing) GetAttributeValuesPages(input *GetAttributeValuesInput, fn func(*GetAttributeValuesOutput, bool) bool) error { + return c.GetAttributeValuesPagesWithContext(aws.BackgroundContext(), input, fn) +} + +// GetAttributeValuesPagesWithContext same as GetAttributeValuesPages except +// it takes a Context and allows setting request options on the pages. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Pricing) GetAttributeValuesPagesWithContext(ctx aws.Context, input *GetAttributeValuesInput, fn func(*GetAttributeValuesOutput, bool) bool, opts ...request.Option) error { + p := request.Pagination{ + NewRequest: func() (*request.Request, error) { + var inCpy *GetAttributeValuesInput + if input != nil { + tmp := *input + inCpy = &tmp + } + req, _ := c.GetAttributeValuesRequest(inCpy) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return req, nil + }, + } + + cont := true + for p.Next() && cont { + cont = fn(p.Page().(*GetAttributeValuesOutput), !p.HasNextPage()) + } + return p.Err() +} + +const opGetProducts = "GetProducts" + +// GetProductsRequest generates a "aws/request.Request" representing the +// client's request for the GetProducts operation. The "output" return +// value will be populated with the request's response once the request completes +// successfuly. +// +// Use "Send" method on the returned Request to send the API call to the service. +// the "output" return value is not valid until after Send returns without error. +// +// See GetProducts for more information on using the GetProducts +// API call, and error handling. +// +// This method is useful when you want to inject custom logic or configuration +// into the SDK's request lifecycle. Such as custom headers, or retry logic. +// +// +// // Example sending a request using the GetProductsRequest method. +// req, resp := client.GetProductsRequest(params) +// +// err := req.Send() +// if err == nil { // resp is now filled +// fmt.Println(resp) +// } +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/pricing-2017-10-15/GetProducts +func (c *Pricing) GetProductsRequest(input *GetProductsInput) (req *request.Request, output *GetProductsOutput) { + op := &request.Operation{ + Name: opGetProducts, + HTTPMethod: "POST", + HTTPPath: "/", + Paginator: &request.Paginator{ + InputTokens: []string{"NextToken"}, + OutputTokens: []string{"NextToken"}, + LimitToken: "MaxResults", + TruncationToken: "", + }, + } + + if input == nil { + input = &GetProductsInput{} + } + + output = &GetProductsOutput{} + req = c.newRequest(op, input, output) + return +} + +// GetProducts API operation for AWS Price List Service. +// +// Returns a list of all products that match the filter criteria. +// +// Returns awserr.Error for service API and SDK errors. Use runtime type assertions +// with awserr.Error's Code and Message methods to get detailed information about +// the error. +// +// See the AWS API reference guide for AWS Price List Service's +// API operation GetProducts for usage and error information. +// +// Returned Error Codes: +// * ErrCodeInternalErrorException "InternalErrorException" +// An error on the server occurred during the processing of your request. Try +// again later. +// +// * ErrCodeInvalidParameterException "InvalidParameterException" +// One or more parameters had an invalid value. +// +// * ErrCodeNotFoundException "NotFoundException" +// The requested resource can't be found. +// +// * ErrCodeInvalidNextTokenException "InvalidNextTokenException" +// The pagination token is invalid. Try again without a pagination token. +// +// * ErrCodeExpiredNextTokenException "ExpiredNextTokenException" +// The pagination token expired. Try again without a pagination token. +// +// See also, https://docs.aws.amazon.com/goto/WebAPI/pricing-2017-10-15/GetProducts +func (c *Pricing) GetProducts(input *GetProductsInput) (*GetProductsOutput, error) { + req, out := c.GetProductsRequest(input) + return out, req.Send() +} + +// GetProductsWithContext is the same as GetProducts with the addition of +// the ability to pass a context and additional request options. +// +// See GetProducts for details on how to use this API operation. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Pricing) GetProductsWithContext(ctx aws.Context, input *GetProductsInput, opts ...request.Option) (*GetProductsOutput, error) { + req, out := c.GetProductsRequest(input) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return out, req.Send() +} + +// GetProductsPages iterates over the pages of a GetProducts operation, +// calling the "fn" function with the response data for each page. To stop +// iterating, return false from the fn function. +// +// See GetProducts method for more information on how to use this operation. +// +// Note: This operation can generate multiple requests to a service. +// +// // Example iterating over at most 3 pages of a GetProducts operation. +// pageNum := 0 +// err := client.GetProductsPages(params, +// func(page *GetProductsOutput, lastPage bool) bool { +// pageNum++ +// fmt.Println(page) +// return pageNum <= 3 +// }) +// +func (c *Pricing) GetProductsPages(input *GetProductsInput, fn func(*GetProductsOutput, bool) bool) error { + return c.GetProductsPagesWithContext(aws.BackgroundContext(), input, fn) +} + +// GetProductsPagesWithContext same as GetProductsPages except +// it takes a Context and allows setting request options on the pages. +// +// The context must be non-nil and will be used for request cancellation. If +// the context is nil a panic will occur. In the future the SDK may create +// sub-contexts for http.Requests. See https://golang.org/pkg/context/ +// for more information on using Contexts. +func (c *Pricing) GetProductsPagesWithContext(ctx aws.Context, input *GetProductsInput, fn func(*GetProductsOutput, bool) bool, opts ...request.Option) error { + p := request.Pagination{ + NewRequest: func() (*request.Request, error) { + var inCpy *GetProductsInput + if input != nil { + tmp := *input + inCpy = &tmp + } + req, _ := c.GetProductsRequest(inCpy) + req.SetContext(ctx) + req.ApplyOptions(opts...) + return req, nil + }, + } + + cont := true + for p.Next() && cont { + cont = fn(p.Page().(*GetProductsOutput), !p.HasNextPage()) + } + return p.Err() +} + +// The values of a given attribute, such as Throughput Optimized HDD or Provisioned +// IOPS for the Amazon EC2volumeType attribute. +type AttributeValue struct { + _ struct{} `type:"structure"` + + // The specific value of an attributeName. + Value *string `type:"string"` +} + +// String returns the string representation +func (s AttributeValue) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s AttributeValue) GoString() string { + return s.String() +} + +// SetValue sets the Value field's value. +func (s *AttributeValue) SetValue(v string) *AttributeValue { + s.Value = &v + return s +} + +type DescribeServicesInput struct { + _ struct{} `type:"structure"` + + // The format version that you want the response to be in. + // + // Valid values are: aws_v1 + FormatVersion *string `type:"string"` + + // The maximum number of results that you want returned in the response. + MaxResults *int64 `min:"1" type:"integer"` + + // The pagination token that indicates the next set of results that you want + // to retrieve. + NextToken *string `type:"string"` + + // The code for the service whose information you want to retrieve, such as + // AmazonEC2. You can use the ServiceCode to filter the results in a GetProducts + // call. To retrieve a list of all services, leave this blank. + ServiceCode *string `type:"string"` +} + +// String returns the string representation +func (s DescribeServicesInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeServicesInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *DescribeServicesInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "DescribeServicesInput"} + if s.MaxResults != nil && *s.MaxResults < 1 { + invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1)) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetFormatVersion sets the FormatVersion field's value. +func (s *DescribeServicesInput) SetFormatVersion(v string) *DescribeServicesInput { + s.FormatVersion = &v + return s +} + +// SetMaxResults sets the MaxResults field's value. +func (s *DescribeServicesInput) SetMaxResults(v int64) *DescribeServicesInput { + s.MaxResults = &v + return s +} + +// SetNextToken sets the NextToken field's value. +func (s *DescribeServicesInput) SetNextToken(v string) *DescribeServicesInput { + s.NextToken = &v + return s +} + +// SetServiceCode sets the ServiceCode field's value. +func (s *DescribeServicesInput) SetServiceCode(v string) *DescribeServicesInput { + s.ServiceCode = &v + return s +} + +type DescribeServicesOutput struct { + _ struct{} `type:"structure"` + + // The format version of the response. For example, aws_v1. + FormatVersion *string `type:"string"` + + // The pagination token for the next set of retreivable results. + NextToken *string `type:"string"` + + // The service metadata for the service or services in the response. + Services []*Service `type:"list"` +} + +// String returns the string representation +func (s DescribeServicesOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s DescribeServicesOutput) GoString() string { + return s.String() +} + +// SetFormatVersion sets the FormatVersion field's value. +func (s *DescribeServicesOutput) SetFormatVersion(v string) *DescribeServicesOutput { + s.FormatVersion = &v + return s +} + +// SetNextToken sets the NextToken field's value. +func (s *DescribeServicesOutput) SetNextToken(v string) *DescribeServicesOutput { + s.NextToken = &v + return s +} + +// SetServices sets the Services field's value. +func (s *DescribeServicesOutput) SetServices(v []*Service) *DescribeServicesOutput { + s.Services = v + return s +} + +// The constraints that you want all returned products to match. +type Filter struct { + _ struct{} `type:"structure"` + + // The product metadata field that you want to filter on. You can filter by + // just the service code to see all products for a specific service, filter + // by just the attribute name to see a specific attribute for multiple services, + // or use both a service code and an attribute name to retrieve only products + // that match both fields. + // + // Valid values include: ServiceCode, and all attribute names + // + // For example, you can filter by the AmazonEC2 service code and the volumeType + // attribute name to get the prices for only Amazon EC2 volumes. + // + // Field is a required field + Field *string `type:"string" required:"true"` + + // The type of filter that you want to use. + // + // Valid values are: TERM_MATCH. TERM_MATCH returns only products that match + // both the given filter field and the given value. + // + // Type is a required field + Type *string `type:"string" required:"true" enum:"FilterType"` + + // The service code or attribute value that you want to filter by. If you are + // filtering by service code this is the actual service code, such as AmazonEC2. + // If you are filtering by attribute name, this is the attribute value that + // you want the returned products to match, such as a Provisioned IOPS volume. + // + // Value is a required field + Value *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s Filter) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Filter) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *Filter) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "Filter"} + if s.Field == nil { + invalidParams.Add(request.NewErrParamRequired("Field")) + } + if s.Type == nil { + invalidParams.Add(request.NewErrParamRequired("Type")) + } + if s.Value == nil { + invalidParams.Add(request.NewErrParamRequired("Value")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetField sets the Field field's value. +func (s *Filter) SetField(v string) *Filter { + s.Field = &v + return s +} + +// SetType sets the Type field's value. +func (s *Filter) SetType(v string) *Filter { + s.Type = &v + return s +} + +// SetValue sets the Value field's value. +func (s *Filter) SetValue(v string) *Filter { + s.Value = &v + return s +} + +type GetAttributeValuesInput struct { + _ struct{} `type:"structure"` + + // The name of the attribute that you want to retrieve the values for, such + // as volumeType. + // + // AttributeName is a required field + AttributeName *string `type:"string" required:"true"` + + // The maximum number of results to return in response. + MaxResults *int64 `min:"1" type:"integer"` + + // The pagination token that indicates the next set of results that you want + // to retrieve. + NextToken *string `type:"string"` + + // The service code for the service whose attributes you want to retrieve. For + // example, if you want the retrieve an EC2 attribute, use AmazonEC2. + // + // ServiceCode is a required field + ServiceCode *string `type:"string" required:"true"` +} + +// String returns the string representation +func (s GetAttributeValuesInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetAttributeValuesInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *GetAttributeValuesInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "GetAttributeValuesInput"} + if s.AttributeName == nil { + invalidParams.Add(request.NewErrParamRequired("AttributeName")) + } + if s.MaxResults != nil && *s.MaxResults < 1 { + invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1)) + } + if s.ServiceCode == nil { + invalidParams.Add(request.NewErrParamRequired("ServiceCode")) + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetAttributeName sets the AttributeName field's value. +func (s *GetAttributeValuesInput) SetAttributeName(v string) *GetAttributeValuesInput { + s.AttributeName = &v + return s +} + +// SetMaxResults sets the MaxResults field's value. +func (s *GetAttributeValuesInput) SetMaxResults(v int64) *GetAttributeValuesInput { + s.MaxResults = &v + return s +} + +// SetNextToken sets the NextToken field's value. +func (s *GetAttributeValuesInput) SetNextToken(v string) *GetAttributeValuesInput { + s.NextToken = &v + return s +} + +// SetServiceCode sets the ServiceCode field's value. +func (s *GetAttributeValuesInput) SetServiceCode(v string) *GetAttributeValuesInput { + s.ServiceCode = &v + return s +} + +type GetAttributeValuesOutput struct { + _ struct{} `type:"structure"` + + // The list of values for an attribute. For example, Throughput Optimized HDD + // and Provisioned IOPS are two available values for the AmazonEC2volumeType. + AttributeValues []*AttributeValue `type:"list"` + + // The pagination token that indicates the next set of results to retrieve. + NextToken *string `type:"string"` +} + +// String returns the string representation +func (s GetAttributeValuesOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetAttributeValuesOutput) GoString() string { + return s.String() +} + +// SetAttributeValues sets the AttributeValues field's value. +func (s *GetAttributeValuesOutput) SetAttributeValues(v []*AttributeValue) *GetAttributeValuesOutput { + s.AttributeValues = v + return s +} + +// SetNextToken sets the NextToken field's value. +func (s *GetAttributeValuesOutput) SetNextToken(v string) *GetAttributeValuesOutput { + s.NextToken = &v + return s +} + +type GetProductsInput struct { + _ struct{} `type:"structure"` + + // The list of filters that limit the returned products. only products that + // match all filters are returned. + Filters []*Filter `type:"list"` + + // The format version that you want the response to be in. + // + // Valid values are: aws_v1 + FormatVersion *string `type:"string"` + + // The maximum number of results to return in the response. + MaxResults *int64 `min:"1" type:"integer"` + + // The pagination token that indicates the next set of results that you want + // to retrieve. + NextToken *string `type:"string"` + + // The code for the service whose products you want to retrieve. + ServiceCode *string `type:"string"` +} + +// String returns the string representation +func (s GetProductsInput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetProductsInput) GoString() string { + return s.String() +} + +// Validate inspects the fields of the type to determine if they are valid. +func (s *GetProductsInput) Validate() error { + invalidParams := request.ErrInvalidParams{Context: "GetProductsInput"} + if s.MaxResults != nil && *s.MaxResults < 1 { + invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1)) + } + if s.Filters != nil { + for i, v := range s.Filters { + if v == nil { + continue + } + if err := v.Validate(); err != nil { + invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(request.ErrInvalidParams)) + } + } + } + + if invalidParams.Len() > 0 { + return invalidParams + } + return nil +} + +// SetFilters sets the Filters field's value. +func (s *GetProductsInput) SetFilters(v []*Filter) *GetProductsInput { + s.Filters = v + return s +} + +// SetFormatVersion sets the FormatVersion field's value. +func (s *GetProductsInput) SetFormatVersion(v string) *GetProductsInput { + s.FormatVersion = &v + return s +} + +// SetMaxResults sets the MaxResults field's value. +func (s *GetProductsInput) SetMaxResults(v int64) *GetProductsInput { + s.MaxResults = &v + return s +} + +// SetNextToken sets the NextToken field's value. +func (s *GetProductsInput) SetNextToken(v string) *GetProductsInput { + s.NextToken = &v + return s +} + +// SetServiceCode sets the ServiceCode field's value. +func (s *GetProductsInput) SetServiceCode(v string) *GetProductsInput { + s.ServiceCode = &v + return s +} + +type GetProductsOutput struct { + _ struct{} `type:"structure"` + + // The format version of the response. For example, aws_v1. + FormatVersion *string `type:"string"` + + // The pagination token that indicates the next set of results to retrieve. + NextToken *string `type:"string"` + + // The list of products that match your filters. The list contains both the + // product metadata and the price information. + PriceList []aws.JSONValue `type:"list"` +} + +// String returns the string representation +func (s GetProductsOutput) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s GetProductsOutput) GoString() string { + return s.String() +} + +// SetFormatVersion sets the FormatVersion field's value. +func (s *GetProductsOutput) SetFormatVersion(v string) *GetProductsOutput { + s.FormatVersion = &v + return s +} + +// SetNextToken sets the NextToken field's value. +func (s *GetProductsOutput) SetNextToken(v string) *GetProductsOutput { + s.NextToken = &v + return s +} + +// SetPriceList sets the PriceList field's value. +func (s *GetProductsOutput) SetPriceList(v []aws.JSONValue) *GetProductsOutput { + s.PriceList = v + return s +} + +// The metadata for a service, such as the service code and available attribute +// names. +type Service struct { + _ struct{} `type:"structure"` + + // The attributes that are available for this service. + AttributeNames []*string `type:"list"` + + // The code for the AWS service. + ServiceCode *string `type:"string"` +} + +// String returns the string representation +func (s Service) String() string { + return awsutil.Prettify(s) +} + +// GoString returns the string representation +func (s Service) GoString() string { + return s.String() +} + +// SetAttributeNames sets the AttributeNames field's value. +func (s *Service) SetAttributeNames(v []*string) *Service { + s.AttributeNames = v + return s +} + +// SetServiceCode sets the ServiceCode field's value. +func (s *Service) SetServiceCode(v string) *Service { + s.ServiceCode = &v + return s +} + +const ( + // FilterTypeTermMatch is a FilterType enum value + FilterTypeTermMatch = "TERM_MATCH" +) diff --git a/vendor/github.com/aws/aws-sdk-go/service/pricing/doc.go b/vendor/github.com/aws/aws-sdk-go/service/pricing/doc.go new file mode 100644 index 0000000000000..0555bc4c3cb37 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/pricing/doc.go @@ -0,0 +1,51 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +// Package pricing provides the client and types for making API +// requests to AWS Price List Service. +// +// AWS Price List Service API (AWS Price List Service) is a centralized and +// convenient way to programmatically query Amazon Web Services for services, +// products, and pricing information. The AWS Price List Service uses standardized +// product attributes such as Location, Storage Class, and Operating System, +// and provides prices at the SKU level. You can use the AWS Price List Service +// to build cost control and scenario planning tools, reconcile billing data, +// forecast future spend for budgeting purposes, and provide cost benefit analysis +// that compare your internal workloads with AWS. +// +// Use GetServices without a service code to retrieve the service codes for +// all AWS services, then GetServices with a service code to retreive the attribute +// names for that service. After you have the service code and attribute names, +// you can use GetAttributeValues to see what values are available for an attribute. +// With the service code and an attribute name and value, you can use GetProducts +// to find specific products that you're interested in, such as an AmazonEC2 +// instance, with a Provisioned IOPSvolumeType. +// +// Service Endpoint +// +// AWS Price List Service API provides the following two endpoints: +// +// * https://api.pricing.us-east-1.amazonaws.com +// +// * https://api.pricing.ap-south-1.amazonaws.com +// +// See https://docs.aws.amazon.com/goto/WebAPI/pricing-2017-10-15 for more information on this service. +// +// See pricing package documentation for more information. +// https://docs.aws.amazon.com/sdk-for-go/api/service/pricing/ +// +// Using the Client +// +// To contact AWS Price List Service with the SDK use the New function to create +// a new service client. With that client you can make API requests to the service. +// These clients are safe to use concurrently. +// +// See the SDK's documentation for more information on how to use the SDK. +// https://docs.aws.amazon.com/sdk-for-go/api/ +// +// See aws.Config documentation for more information on configuring SDK clients. +// https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config +// +// See the AWS Price List Service client Pricing for more +// information on creating client for this service. +// https://docs.aws.amazon.com/sdk-for-go/api/service/pricing/#New +package pricing diff --git a/vendor/github.com/aws/aws-sdk-go/service/pricing/errors.go b/vendor/github.com/aws/aws-sdk-go/service/pricing/errors.go new file mode 100644 index 0000000000000..10e4c44fe9296 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/pricing/errors.go @@ -0,0 +1,37 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package pricing + +const ( + + // ErrCodeExpiredNextTokenException for service response error code + // "ExpiredNextTokenException". + // + // The pagination token expired. Try again without a pagination token. + ErrCodeExpiredNextTokenException = "ExpiredNextTokenException" + + // ErrCodeInternalErrorException for service response error code + // "InternalErrorException". + // + // An error on the server occurred during the processing of your request. Try + // again later. + ErrCodeInternalErrorException = "InternalErrorException" + + // ErrCodeInvalidNextTokenException for service response error code + // "InvalidNextTokenException". + // + // The pagination token is invalid. Try again without a pagination token. + ErrCodeInvalidNextTokenException = "InvalidNextTokenException" + + // ErrCodeInvalidParameterException for service response error code + // "InvalidParameterException". + // + // One or more parameters had an invalid value. + ErrCodeInvalidParameterException = "InvalidParameterException" + + // ErrCodeNotFoundException for service response error code + // "NotFoundException". + // + // The requested resource can't be found. + ErrCodeNotFoundException = "NotFoundException" +) diff --git a/vendor/github.com/aws/aws-sdk-go/service/pricing/service.go b/vendor/github.com/aws/aws-sdk-go/service/pricing/service.go new file mode 100644 index 0000000000000..b4b8b815ab77d --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go/service/pricing/service.go @@ -0,0 +1,98 @@ +// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. + +package pricing + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/client" + "github.com/aws/aws-sdk-go/aws/client/metadata" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/aws/signer/v4" + "github.com/aws/aws-sdk-go/private/protocol/jsonrpc" +) + +// Pricing provides the API operation methods for making requests to +// AWS Price List Service. See this package's package overview docs +// for details on the service. +// +// Pricing methods are safe to use concurrently. It is not safe to +// modify mutate any of the struct's properties though. +type Pricing struct { + *client.Client +} + +// Used for custom client initialization logic +var initClient func(*client.Client) + +// Used for custom request initialization logic +var initRequest func(*request.Request) + +// Service information constants +const ( + ServiceName = "api.pricing" // Service endpoint prefix API calls made to. + EndpointsID = ServiceName // Service ID for Regions and Endpoints metadata. +) + +// New creates a new instance of the Pricing client with a session. +// If additional configuration is needed for the client instance use the optional +// aws.Config parameter to add your extra config. +// +// Example: +// // Create a Pricing client from just a session. +// svc := pricing.New(mySession) +// +// // Create a Pricing client with additional configuration +// svc := pricing.New(mySession, aws.NewConfig().WithRegion("us-west-2")) +func New(p client.ConfigProvider, cfgs ...*aws.Config) *Pricing { + c := p.ClientConfig(EndpointsID, cfgs...) + if c.SigningNameDerived || len(c.SigningName) == 0 { + c.SigningName = "pricing" + } + return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) +} + +// newClient creates, initializes and returns a new service client instance. +func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *Pricing { + svc := &Pricing{ + Client: client.New( + cfg, + metadata.ClientInfo{ + ServiceName: ServiceName, + SigningName: signingName, + SigningRegion: signingRegion, + Endpoint: endpoint, + APIVersion: "2017-10-15", + JSONVersion: "1.1", + TargetPrefix: "AWSPriceListService", + }, + handlers, + ), + } + + // Handlers + svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) + svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) + svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) + svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) + svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) + + // Run custom client initialization if present + if initClient != nil { + initClient(svc.Client) + } + + return svc +} + +// newRequest creates a new request for a Pricing operation and runs any +// custom request initialization. +func (c *Pricing) newRequest(op *request.Operation, params, data interface{}) *request.Request { + req := c.NewRequest(op, params, data) + + // Run custom request initialization if present + if initRequest != nil { + initRequest(req) + } + + return req +}