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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
// Code generated by smithy-go-codegen DO NOT EDIT.
package ec2
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/ec2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// When you enable Windows fast launch 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. You can only change these settings for Windows AMIs that you
// own or that have been shared with you.
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 {
// Specify the ID of the image for which to enable Windows fast launch.
//
// 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 instances that Amazon EC2 can launch at the same time to
// create pre-provisioned snapshots for Windows fast launch. Value must be 6 or
// greater.
MaxParallelLaunches *int32
// The type of resource to use for pre-provisioning the AMI for Windows fast
// launch. 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 AMI for Windows fast launch. The associated
// ResourceType must be snapshot .
SnapshotConfiguration *types.FastLaunchSnapshotConfigurationRequest
noSmithyDocumentSerde
}
type EnableFastLaunchOutput struct {
// The image ID that identifies the AMI for which Windows fast launch 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 instances that Amazon EC2 can launch at the same time to
// create pre-provisioned snapshots for Windows fast launch.
MaxParallelLaunches *int32
// The owner ID for the AMI for which Windows fast launch was enabled.
OwnerId *string
// The type of resource that was defined for pre-provisioning the AMI for Windows
// fast launch.
ResourceType types.FastLaunchResourceType
// Settings to create and manage the pre-provisioned snapshots that Amazon EC2
// uses for faster launches from the Windows AMI. This property is returned when
// the associated resourceType is snapshot .
SnapshotConfiguration *types.FastLaunchSnapshotConfigurationResponse
// The current state of Windows fast launch for the specified AMI.
State types.FastLaunchStateCode
// The reason that the state changed for Windows fast launch for the AMI.
StateTransitionReason *string
// The time that the state changed for Windows fast launch for the 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) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
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 := addProtocolFinalizerMiddlewares(stack, options, "EnableFastLaunch"); 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 = addOpEnableFastLaunchValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opEnableFastLaunch(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_opEnableFastLaunch(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "EnableFastLaunch",
}
}
|
