1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
// Code generated by smithy-go-codegen DO NOT EDIT.
package gamelift
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/gamelift/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Retrieves the instance limits and current utilization for an Amazon Web
// Services Region or location. Instance limits control the number of instances,
// per instance type, per location, that your Amazon Web Services account can use.
// Learn more at Amazon EC2 Instance Types (http://aws.amazon.com/ec2/instance-types/)
// . The information returned includes the maximum number of instances allowed and
// your account's current usage across all fleets. This information can affect your
// ability to scale your Amazon GameLift fleets. You can request a limit increase
// for your account by using the Service limits page in the Amazon GameLift
// console. Instance limits differ based on whether the instances are deployed in a
// fleet's home Region or in a remote location. For remote locations, limits also
// differ based on the combination of home Region and remote location. All requests
// must specify an Amazon Web Services Region (either explicitly or as your default
// settings). To get the limit for a remote location, you must also specify the
// location. For example, the following requests all return different results:
// - Request specifies the Region ap-northeast-1 with no location. The result is
// limits and usage data on all instance types that are deployed in us-east-2 ,
// by all of the fleets that reside in ap-northeast-1 .
// - Request specifies the Region us-east-1 with location ca-central-1 . The
// result is limits and usage data on all instance types that are deployed in
// ca-central-1 , by all of the fleets that reside in us-east-2 . These limits do
// not affect fleets in any other Regions that deploy instances to ca-central-1 .
// - Request specifies the Region eu-west-1 with location ca-central-1 . The
// result is limits and usage data on all instance types that are deployed in
// ca-central-1 , by all of the fleets that reside in eu-west-1 .
//
// This operation can be used in the following ways:
// - To get limit and usage data for all instance types that are deployed in an
// Amazon Web Services Region by fleets that reside in the same Region: Specify the
// Region only. Optionally, specify a single instance type to retrieve information
// for.
// - To get limit and usage data for all instance types that are deployed to a
// remote location by fleets that reside in different Amazon Web Services Region:
// Provide both the Amazon Web Services Region and the remote location. Optionally,
// specify a single instance type to retrieve information for.
//
// If successful, an EC2InstanceLimits object is returned with limits and usage
// data for each requested instance type. Learn more Setting up Amazon GameLift
// fleets (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
func (c *Client) DescribeEC2InstanceLimits(ctx context.Context, params *DescribeEC2InstanceLimitsInput, optFns ...func(*Options)) (*DescribeEC2InstanceLimitsOutput, error) {
if params == nil {
params = &DescribeEC2InstanceLimitsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeEC2InstanceLimits", params, optFns, c.addOperationDescribeEC2InstanceLimitsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeEC2InstanceLimitsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeEC2InstanceLimitsInput struct {
// Name of an Amazon EC2 instance type that is supported in Amazon GameLift. A
// fleet instance type determines the computing resources of each instance in the
// fleet, including CPU, memory, storage, and networking capacity. Do not specify a
// value for this parameter to retrieve limits for all instance types.
EC2InstanceType types.EC2InstanceType
// The name of a remote location to request instance limits for, in the form of an
// Amazon Web Services Region code such as us-west-2 .
Location *string
noSmithyDocumentSerde
}
type DescribeEC2InstanceLimitsOutput struct {
// The maximum number of instances for the specified instance type.
EC2InstanceLimits []types.EC2InstanceLimit
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeEC2InstanceLimitsMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeEC2InstanceLimits{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeEC2InstanceLimits{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "DescribeEC2InstanceLimits"); err != nil {
return fmt.Errorf("add protocol finalizers: %v", err)
}
if err = addlegacyEndpointContextSetter(stack, options); err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack, options); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeEC2InstanceLimits(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
if err = addDisableHTTPSMiddleware(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeEC2InstanceLimits(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "DescribeEC2InstanceLimits",
}
}
|
