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
177
178
179
180
181
|
// Code generated by smithy-go-codegen DO NOT EDIT.
package ec2
import (
"context"
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/ec2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// When you enable faster launching for a Windows AMI, images are pre-provisioned,
// using snapshots to launch instances up to 65% faster. To create the optimized
// Windows image, Amazon EC2 launches an instance and runs through Sysprep steps,
// rebooting as required. Then it creates a set of reserved snapshots that are used
// for subsequent launches. The reserved snapshots are automatically replenished as
// they are used, depending on your settings for launch frequency. To change these
// settings, you must own the AMI.
func (c *Client) EnableFastLaunch(ctx context.Context, params *EnableFastLaunchInput, optFns ...func(*Options)) (*EnableFastLaunchOutput, error) {
if params == nil {
params = &EnableFastLaunchInput{}
}
result, metadata, err := c.invokeOperation(ctx, "EnableFastLaunch", params, optFns, c.addOperationEnableFastLaunchMiddlewares)
if err != nil {
return nil, err
}
out := result.(*EnableFastLaunchOutput)
out.ResultMetadata = metadata
return out, nil
}
type EnableFastLaunchInput struct {
// The ID of the image for which you’re enabling faster launching.
//
// This member is required.
ImageId *string
// Checks whether you have the required permissions for the action, without
// actually making the request, and provides an error response. If you have the
// required permissions, the error response is DryRunOperation. Otherwise, it is
// UnauthorizedOperation.
DryRun *bool
// The launch template to use when launching Windows instances from pre-provisioned
// snapshots. Launch template parameters can include either the name or ID of the
// launch template, but not both.
LaunchTemplate *types.FastLaunchLaunchTemplateSpecificationRequest
// The maximum number of parallel instances to launch for creating resources. Value
// must be 6 or greater.
MaxParallelLaunches *int32
// The type of resource to use for pre-provisioning the Windows AMI for faster
// launching. Supported values include: snapshot, which is the default value.
ResourceType *string
// Configuration settings for creating and managing the snapshots that are used for
// pre-provisioning the Windows AMI for faster launching. The associated
// ResourceType must be snapshot.
SnapshotConfiguration *types.FastLaunchSnapshotConfigurationRequest
noSmithyDocumentSerde
}
type EnableFastLaunchOutput struct {
// The image ID that identifies the Windows AMI for which faster launching was
// enabled.
ImageId *string
// The launch template that is used when launching Windows instances from
// pre-provisioned snapshots.
LaunchTemplate *types.FastLaunchLaunchTemplateSpecificationResponse
// The maximum number of parallel instances to launch for creating resources.
MaxParallelLaunches *int32
// The owner ID for the Windows AMI for which faster launching was enabled.
OwnerId *string
// The type of resource that was defined for pre-provisioning the Windows AMI for
// faster launching.
ResourceType types.FastLaunchResourceType
// The configuration settings that were defined for creating and managing the
// pre-provisioned snapshots for faster launching of the Windows AMI. This property
// is returned when the associated resourceType is snapshot.
SnapshotConfiguration *types.FastLaunchSnapshotConfigurationResponse
// The current state of faster launching for the specified Windows AMI.
State types.FastLaunchStateCode
// The reason that the state changed for faster launching for the Windows AMI.
StateTransitionReason *string
// The time that the state changed for faster launching for the Windows AMI.
StateTransitionTime *time.Time
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationEnableFastLaunchMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsEc2query_serializeOpEnableFastLaunch{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsEc2query_deserializeOpEnableFastLaunch{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpEnableFastLaunchValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opEnableFastLaunch(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opEnableFastLaunch(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "ec2",
OperationName: "EnableFastLaunch",
}
}
|
