blib/lib/Paws/GameLift.pm untested

filter: Statementstmt 0.0% 0 / 700 Branchbran 0.0% 0 / 80 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 122 Podpod 0.0% 0 / 121 totaltotal 0.0% 0 / 1023 CC 41 SCAR 17.4
CC
41
Cov
0%
DescribeAllFleetAttributes
12.0
DescribeAllFleetCapacity
12.0
DescribeAllFleetEvents
12.0
CRAP 5.7
1 package Paws::GameLift;
2 use Moose;
3 sub service { 'gamelift' }
4 sub signing_name { 'gamelift' }
5 sub version { '2015-10-01' }
6 sub target_prefix { 'GameLift' }
7 sub json_version { "1.1" }
8 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 has retry => (is => 'ro', isa => 'HashRef', default => sub {
10 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 });
12 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
13 ] });
14  
15 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
16  
17
18 sub AcceptMatch {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::GameLift::AcceptMatch', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub ClaimGameServer {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::GameLift::ClaimGameServer', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub CreateAlias {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::GameLift::CreateAlias', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub CreateBuild {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::GameLift::CreateBuild', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub CreateFleet {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::GameLift::CreateFleet', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub CreateFleetLocations {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::GameLift::CreateFleetLocations', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub CreateGameServerGroup {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::GameLift::CreateGameServerGroup', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub CreateGameSession {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::GameLift::CreateGameSession', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub CreateGameSessionQueue {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::GameLift::CreateGameSessionQueue', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub CreateMatchmakingConfiguration {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::GameLift::CreateMatchmakingConfiguration', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub CreateMatchmakingRuleSet {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::GameLift::CreateMatchmakingRuleSet', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub CreatePlayerSession {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::GameLift::CreatePlayerSession', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub CreatePlayerSessions {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::GameLift::CreatePlayerSessions', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub CreateScript {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::GameLift::CreateScript', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub CreateVpcPeeringAuthorization {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::GameLift::CreateVpcPeeringAuthorization', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub CreateVpcPeeringConnection {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::GameLift::CreateVpcPeeringConnection', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub DeleteAlias {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::GameLift::DeleteAlias', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub DeleteBuild {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::GameLift::DeleteBuild', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub DeleteFleet {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::GameLift::DeleteFleet', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub DeleteFleetLocations {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::GameLift::DeleteFleetLocations', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub DeleteGameServerGroup {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::GameLift::DeleteGameServerGroup', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub DeleteGameSessionQueue {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::GameLift::DeleteGameSessionQueue', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub DeleteMatchmakingConfiguration {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::GameLift::DeleteMatchmakingConfiguration', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133 sub DeleteMatchmakingRuleSet {
134 my $self = shift;
135 my $call_object = $self->new_with_coercions('Paws::GameLift::DeleteMatchmakingRuleSet', @_);
136 return $self->caller->do_call($self, $call_object);
137 }
138 sub DeleteScalingPolicy {
139 my $self = shift;
140 my $call_object = $self->new_with_coercions('Paws::GameLift::DeleteScalingPolicy', @_);
141 return $self->caller->do_call($self, $call_object);
142 }
143 sub DeleteScript {
144 my $self = shift;
145 my $call_object = $self->new_with_coercions('Paws::GameLift::DeleteScript', @_);
146 return $self->caller->do_call($self, $call_object);
147 }
148 sub DeleteVpcPeeringAuthorization {
149 my $self = shift;
150 my $call_object = $self->new_with_coercions('Paws::GameLift::DeleteVpcPeeringAuthorization', @_);
151 return $self->caller->do_call($self, $call_object);
152 }
153 sub DeleteVpcPeeringConnection {
154 my $self = shift;
155 my $call_object = $self->new_with_coercions('Paws::GameLift::DeleteVpcPeeringConnection', @_);
156 return $self->caller->do_call($self, $call_object);
157 }
158 sub DeregisterGameServer {
159 my $self = shift;
160 my $call_object = $self->new_with_coercions('Paws::GameLift::DeregisterGameServer', @_);
161 return $self->caller->do_call($self, $call_object);
162 }
163 sub DescribeAlias {
164 my $self = shift;
165 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeAlias', @_);
166 return $self->caller->do_call($self, $call_object);
167 }
168 sub DescribeBuild {
169 my $self = shift;
170 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeBuild', @_);
171 return $self->caller->do_call($self, $call_object);
172 }
173 sub DescribeEC2InstanceLimits {
174 my $self = shift;
175 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeEC2InstanceLimits', @_);
176 return $self->caller->do_call($self, $call_object);
177 }
178 sub DescribeFleetAttributes {
179 my $self = shift;
180 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeFleetAttributes', @_);
181 return $self->caller->do_call($self, $call_object);
182 }
183 sub DescribeFleetCapacity {
184 my $self = shift;
185 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeFleetCapacity', @_);
186 return $self->caller->do_call($self, $call_object);
187 }
188 sub DescribeFleetEvents {
189 my $self = shift;
190 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeFleetEvents', @_);
191 return $self->caller->do_call($self, $call_object);
192 }
193 sub DescribeFleetLocationAttributes {
194 my $self = shift;
195 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeFleetLocationAttributes', @_);
196 return $self->caller->do_call($self, $call_object);
197 }
198 sub DescribeFleetLocationCapacity {
199 my $self = shift;
200 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeFleetLocationCapacity', @_);
201 return $self->caller->do_call($self, $call_object);
202 }
203 sub DescribeFleetLocationUtilization {
204 my $self = shift;
205 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeFleetLocationUtilization', @_);
206 return $self->caller->do_call($self, $call_object);
207 }
208 sub DescribeFleetPortSettings {
209 my $self = shift;
210 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeFleetPortSettings', @_);
211 return $self->caller->do_call($self, $call_object);
212 }
213 sub DescribeFleetUtilization {
214 my $self = shift;
215 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeFleetUtilization', @_);
216 return $self->caller->do_call($self, $call_object);
217 }
218 sub DescribeGameServer {
219 my $self = shift;
220 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeGameServer', @_);
221 return $self->caller->do_call($self, $call_object);
222 }
223 sub DescribeGameServerGroup {
224 my $self = shift;
225 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeGameServerGroup', @_);
226 return $self->caller->do_call($self, $call_object);
227 }
228 sub DescribeGameServerInstances {
229 my $self = shift;
230 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeGameServerInstances', @_);
231 return $self->caller->do_call($self, $call_object);
232 }
233 sub DescribeGameSessionDetails {
234 my $self = shift;
235 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeGameSessionDetails', @_);
236 return $self->caller->do_call($self, $call_object);
237 }
238 sub DescribeGameSessionPlacement {
239 my $self = shift;
240 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeGameSessionPlacement', @_);
241 return $self->caller->do_call($self, $call_object);
242 }
243 sub DescribeGameSessionQueues {
244 my $self = shift;
245 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeGameSessionQueues', @_);
246 return $self->caller->do_call($self, $call_object);
247 }
248 sub DescribeGameSessions {
249 my $self = shift;
250 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeGameSessions', @_);
251 return $self->caller->do_call($self, $call_object);
252 }
253 sub DescribeInstances {
254 my $self = shift;
255 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeInstances', @_);
256 return $self->caller->do_call($self, $call_object);
257 }
258 sub DescribeMatchmaking {
259 my $self = shift;
260 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeMatchmaking', @_);
261 return $self->caller->do_call($self, $call_object);
262 }
263 sub DescribeMatchmakingConfigurations {
264 my $self = shift;
265 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeMatchmakingConfigurations', @_);
266 return $self->caller->do_call($self, $call_object);
267 }
268 sub DescribeMatchmakingRuleSets {
269 my $self = shift;
270 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeMatchmakingRuleSets', @_);
271 return $self->caller->do_call($self, $call_object);
272 }
273 sub DescribePlayerSessions {
274 my $self = shift;
275 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribePlayerSessions', @_);
276 return $self->caller->do_call($self, $call_object);
277 }
278 sub DescribeRuntimeConfiguration {
279 my $self = shift;
280 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeRuntimeConfiguration', @_);
281 return $self->caller->do_call($self, $call_object);
282 }
283 sub DescribeScalingPolicies {
284 my $self = shift;
285 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeScalingPolicies', @_);
286 return $self->caller->do_call($self, $call_object);
287 }
288 sub DescribeScript {
289 my $self = shift;
290 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeScript', @_);
291 return $self->caller->do_call($self, $call_object);
292 }
293 sub DescribeVpcPeeringAuthorizations {
294 my $self = shift;
295 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeVpcPeeringAuthorizations', @_);
296 return $self->caller->do_call($self, $call_object);
297 }
298 sub DescribeVpcPeeringConnections {
299 my $self = shift;
300 my $call_object = $self->new_with_coercions('Paws::GameLift::DescribeVpcPeeringConnections', @_);
301 return $self->caller->do_call($self, $call_object);
302 }
303 sub GetGameSessionLogUrl {
304 my $self = shift;
305 my $call_object = $self->new_with_coercions('Paws::GameLift::GetGameSessionLogUrl', @_);
306 return $self->caller->do_call($self, $call_object);
307 }
308 sub GetInstanceAccess {
309 my $self = shift;
310 my $call_object = $self->new_with_coercions('Paws::GameLift::GetInstanceAccess', @_);
311 return $self->caller->do_call($self, $call_object);
312 }
313 sub ListAliases {
314 my $self = shift;
315 my $call_object = $self->new_with_coercions('Paws::GameLift::ListAliases', @_);
316 return $self->caller->do_call($self, $call_object);
317 }
318 sub ListBuilds {
319 my $self = shift;
320 my $call_object = $self->new_with_coercions('Paws::GameLift::ListBuilds', @_);
321 return $self->caller->do_call($self, $call_object);
322 }
323 sub ListFleets {
324 my $self = shift;
325 my $call_object = $self->new_with_coercions('Paws::GameLift::ListFleets', @_);
326 return $self->caller->do_call($self, $call_object);
327 }
328 sub ListGameServerGroups {
329 my $self = shift;
330 my $call_object = $self->new_with_coercions('Paws::GameLift::ListGameServerGroups', @_);
331 return $self->caller->do_call($self, $call_object);
332 }
333 sub ListGameServers {
334 my $self = shift;
335 my $call_object = $self->new_with_coercions('Paws::GameLift::ListGameServers', @_);
336 return $self->caller->do_call($self, $call_object);
337 }
338 sub ListScripts {
339 my $self = shift;
340 my $call_object = $self->new_with_coercions('Paws::GameLift::ListScripts', @_);
341 return $self->caller->do_call($self, $call_object);
342 }
343 sub ListTagsForResource {
344 my $self = shift;
345 my $call_object = $self->new_with_coercions('Paws::GameLift::ListTagsForResource', @_);
346 return $self->caller->do_call($self, $call_object);
347 }
348 sub PutScalingPolicy {
349 my $self = shift;
350 my $call_object = $self->new_with_coercions('Paws::GameLift::PutScalingPolicy', @_);
351 return $self->caller->do_call($self, $call_object);
352 }
353 sub RegisterGameServer {
354 my $self = shift;
355 my $call_object = $self->new_with_coercions('Paws::GameLift::RegisterGameServer', @_);
356 return $self->caller->do_call($self, $call_object);
357 }
358 sub RequestUploadCredentials {
359 my $self = shift;
360 my $call_object = $self->new_with_coercions('Paws::GameLift::RequestUploadCredentials', @_);
361 return $self->caller->do_call($self, $call_object);
362 }
363 sub ResolveAlias {
364 my $self = shift;
365 my $call_object = $self->new_with_coercions('Paws::GameLift::ResolveAlias', @_);
366 return $self->caller->do_call($self, $call_object);
367 }
368 sub ResumeGameServerGroup {
369 my $self = shift;
370 my $call_object = $self->new_with_coercions('Paws::GameLift::ResumeGameServerGroup', @_);
371 return $self->caller->do_call($self, $call_object);
372 }
373 sub SearchGameSessions {
374 my $self = shift;
375 my $call_object = $self->new_with_coercions('Paws::GameLift::SearchGameSessions', @_);
376 return $self->caller->do_call($self, $call_object);
377 }
378 sub StartFleetActions {
379 my $self = shift;
380 my $call_object = $self->new_with_coercions('Paws::GameLift::StartFleetActions', @_);
381 return $self->caller->do_call($self, $call_object);
382 }
383 sub StartGameSessionPlacement {
384 my $self = shift;
385 my $call_object = $self->new_with_coercions('Paws::GameLift::StartGameSessionPlacement', @_);
386 return $self->caller->do_call($self, $call_object);
387 }
388 sub StartMatchBackfill {
389 my $self = shift;
390 my $call_object = $self->new_with_coercions('Paws::GameLift::StartMatchBackfill', @_);
391 return $self->caller->do_call($self, $call_object);
392 }
393 sub StartMatchmaking {
394 my $self = shift;
395 my $call_object = $self->new_with_coercions('Paws::GameLift::StartMatchmaking', @_);
396 return $self->caller->do_call($self, $call_object);
397 }
398 sub StopFleetActions {
399 my $self = shift;
400 my $call_object = $self->new_with_coercions('Paws::GameLift::StopFleetActions', @_);
401 return $self->caller->do_call($self, $call_object);
402 }
403 sub StopGameSessionPlacement {
404 my $self = shift;
405 my $call_object = $self->new_with_coercions('Paws::GameLift::StopGameSessionPlacement', @_);
406 return $self->caller->do_call($self, $call_object);
407 }
408 sub StopMatchmaking {
409 my $self = shift;
410 my $call_object = $self->new_with_coercions('Paws::GameLift::StopMatchmaking', @_);
411 return $self->caller->do_call($self, $call_object);
412 }
413 sub SuspendGameServerGroup {
414 my $self = shift;
415 my $call_object = $self->new_with_coercions('Paws::GameLift::SuspendGameServerGroup', @_);
416 return $self->caller->do_call($self, $call_object);
417 }
418 sub TagResource {
419 my $self = shift;
420 my $call_object = $self->new_with_coercions('Paws::GameLift::TagResource', @_);
421 return $self->caller->do_call($self, $call_object);
422 }
423 sub UntagResource {
424 my $self = shift;
425 my $call_object = $self->new_with_coercions('Paws::GameLift::UntagResource', @_);
426 return $self->caller->do_call($self, $call_object);
427 }
428 sub UpdateAlias {
429 my $self = shift;
430 my $call_object = $self->new_with_coercions('Paws::GameLift::UpdateAlias', @_);
431 return $self->caller->do_call($self, $call_object);
432 }
433 sub UpdateBuild {
434 my $self = shift;
435 my $call_object = $self->new_with_coercions('Paws::GameLift::UpdateBuild', @_);
436 return $self->caller->do_call($self, $call_object);
437 }
438 sub UpdateFleetAttributes {
439 my $self = shift;
440 my $call_object = $self->new_with_coercions('Paws::GameLift::UpdateFleetAttributes', @_);
441 return $self->caller->do_call($self, $call_object);
442 }
443 sub UpdateFleetCapacity {
444 my $self = shift;
445 my $call_object = $self->new_with_coercions('Paws::GameLift::UpdateFleetCapacity', @_);
446 return $self->caller->do_call($self, $call_object);
447 }
448 sub UpdateFleetPortSettings {
449 my $self = shift;
450 my $call_object = $self->new_with_coercions('Paws::GameLift::UpdateFleetPortSettings', @_);
451 return $self->caller->do_call($self, $call_object);
452 }
453 sub UpdateGameServer {
454 my $self = shift;
455 my $call_object = $self->new_with_coercions('Paws::GameLift::UpdateGameServer', @_);
456 return $self->caller->do_call($self, $call_object);
457 }
458 sub UpdateGameServerGroup {
459 my $self = shift;
460 my $call_object = $self->new_with_coercions('Paws::GameLift::UpdateGameServerGroup', @_);
461 return $self->caller->do_call($self, $call_object);
462 }
463 sub UpdateGameSession {
464 my $self = shift;
465 my $call_object = $self->new_with_coercions('Paws::GameLift::UpdateGameSession', @_);
466 return $self->caller->do_call($self, $call_object);
467 }
468 sub UpdateGameSessionQueue {
469 my $self = shift;
470 my $call_object = $self->new_with_coercions('Paws::GameLift::UpdateGameSessionQueue', @_);
471 return $self->caller->do_call($self, $call_object);
472 }
473 sub UpdateMatchmakingConfiguration {
474 my $self = shift;
475 my $call_object = $self->new_with_coercions('Paws::GameLift::UpdateMatchmakingConfiguration', @_);
476 return $self->caller->do_call($self, $call_object);
477 }
478 sub UpdateRuntimeConfiguration {
479 my $self = shift;
480 my $call_object = $self->new_with_coercions('Paws::GameLift::UpdateRuntimeConfiguration', @_);
481 return $self->caller->do_call($self, $call_object);
482 }
483 sub UpdateScript {
484 my $self = shift;
485 my $call_object = $self->new_with_coercions('Paws::GameLift::UpdateScript', @_);
486 return $self->caller->do_call($self, $call_object);
487 }
488 sub ValidateMatchmakingRuleSet {
489 my $self = shift;
490 my $call_object = $self->new_with_coercions('Paws::GameLift::ValidateMatchmakingRuleSet', @_);
491 return $self->caller->do_call($self, $call_object);
492 }
493
494 sub DescribeAllFleetAttributes {
495 my $self = shift;
496  
497 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
498 my $result = $self->DescribeFleetAttributes(@_);
499 my $next_result = $result;
500  
501 if (not defined $callback) {
502 while ($next_result->NextToken) {
503 $next_result = $self->DescribeFleetAttributes(@_, NextToken => $next_result->NextToken);
504 push @{ $result->FleetAttributes }, @{ $next_result->FleetAttributes };
505 }
506 return $result;
507 } else {
508 while ($result->NextToken) {
509 $callback->($_ => 'FleetAttributes') foreach (@{ $result->FleetAttributes });
510 $result = $self->DescribeFleetAttributes(@_, NextToken => $result->NextToken);
511 }
512 $callback->($_ => 'FleetAttributes') foreach (@{ $result->FleetAttributes });
513 }
514  
515 return undef
516 }
517 sub DescribeAllFleetCapacity {
518 my $self = shift;
519  
520 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
521 my $result = $self->DescribeFleetCapacity(@_);
522 my $next_result = $result;
523  
524 if (not defined $callback) {
525 while ($next_result->NextToken) {
526 $next_result = $self->DescribeFleetCapacity(@_, NextToken => $next_result->NextToken);
527 push @{ $result->FleetCapacity }, @{ $next_result->FleetCapacity };
528 }
529 return $result;
530 } else {
531 while ($result->NextToken) {
532 $callback->($_ => 'FleetCapacity') foreach (@{ $result->FleetCapacity });
533 $result = $self->DescribeFleetCapacity(@_, NextToken => $result->NextToken);
534 }
535 $callback->($_ => 'FleetCapacity') foreach (@{ $result->FleetCapacity });
536 }
537  
538 return undef
539 }
540 sub DescribeAllFleetEvents {
541 my $self = shift;
542  
543 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
544 my $result = $self->DescribeFleetEvents(@_);
545 my $next_result = $result;
546  
547 if (not defined $callback) {
548 while ($next_result->NextToken) {
549 $next_result = $self->DescribeFleetEvents(@_, NextToken => $next_result->NextToken);
550 push @{ $result->Events }, @{ $next_result->Events };
551 }
552 return $result;
553 } else {
554 while ($result->NextToken) {
555 $callback->($_ => 'Events') foreach (@{ $result->Events });
556 $result = $self->DescribeFleetEvents(@_, NextToken => $result->NextToken);
557 }
558 $callback->($_ => 'Events') foreach (@{ $result->Events });
559 }
560  
561 return undef
562 }
563 sub DescribeAllFleetUtilization {
564 my $self = shift;
565  
566 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
567 my $result = $self->DescribeFleetUtilization(@_);
568 my $next_result = $result;
569  
570 if (not defined $callback) {
571 while ($next_result->NextToken) {
572 $next_result = $self->DescribeFleetUtilization(@_, NextToken => $next_result->NextToken);
573 push @{ $result->FleetUtilization }, @{ $next_result->FleetUtilization };
574 }
575 return $result;
576 } else {
577 while ($result->NextToken) {
578 $callback->($_ => 'FleetUtilization') foreach (@{ $result->FleetUtilization });
579 $result = $self->DescribeFleetUtilization(@_, NextToken => $result->NextToken);
580 }
581 $callback->($_ => 'FleetUtilization') foreach (@{ $result->FleetUtilization });
582 }
583  
584 return undef
585 }
586 sub DescribeAllGameServerInstances {
587 my $self = shift;
588  
589 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
590 my $result = $self->DescribeGameServerInstances(@_);
591 my $next_result = $result;
592  
593 if (not defined $callback) {
594 while ($next_result->NextToken) {
595 $next_result = $self->DescribeGameServerInstances(@_, NextToken => $next_result->NextToken);
596 push @{ $result->GameServerInstances }, @{ $next_result->GameServerInstances };
597 }
598 return $result;
599 } else {
600 while ($result->NextToken) {
601 $callback->($_ => 'GameServerInstances') foreach (@{ $result->GameServerInstances });
602 $result = $self->DescribeGameServerInstances(@_, NextToken => $result->NextToken);
603 }
604 $callback->($_ => 'GameServerInstances') foreach (@{ $result->GameServerInstances });
605 }
606  
607 return undef
608 }
609 sub DescribeAllGameSessionDetails {
610 my $self = shift;
611  
612 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
613 my $result = $self->DescribeGameSessionDetails(@_);
614 my $next_result = $result;
615  
616 if (not defined $callback) {
617 while ($next_result->NextToken) {
618 $next_result = $self->DescribeGameSessionDetails(@_, NextToken => $next_result->NextToken);
619 push @{ $result->GameSessionDetails }, @{ $next_result->GameSessionDetails };
620 }
621 return $result;
622 } else {
623 while ($result->NextToken) {
624 $callback->($_ => 'GameSessionDetails') foreach (@{ $result->GameSessionDetails });
625 $result = $self->DescribeGameSessionDetails(@_, NextToken => $result->NextToken);
626 }
627 $callback->($_ => 'GameSessionDetails') foreach (@{ $result->GameSessionDetails });
628 }
629  
630 return undef
631 }
632 sub DescribeAllGameSessionQueues {
633 my $self = shift;
634  
635 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
636 my $result = $self->DescribeGameSessionQueues(@_);
637 my $next_result = $result;
638  
639 if (not defined $callback) {
640 while ($next_result->NextToken) {
641 $next_result = $self->DescribeGameSessionQueues(@_, NextToken => $next_result->NextToken);
642 push @{ $result->GameSessionQueues }, @{ $next_result->GameSessionQueues };
643 }
644 return $result;
645 } else {
646 while ($result->NextToken) {
647 $callback->($_ => 'GameSessionQueues') foreach (@{ $result->GameSessionQueues });
648 $result = $self->DescribeGameSessionQueues(@_, NextToken => $result->NextToken);
649 }
650 $callback->($_ => 'GameSessionQueues') foreach (@{ $result->GameSessionQueues });
651 }
652  
653 return undef
654 }
655 sub DescribeAllGameSessions {
656 my $self = shift;
657  
658 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
659 my $result = $self->DescribeGameSessions(@_);
660 my $next_result = $result;
661  
662 if (not defined $callback) {
663 while ($next_result->NextToken) {
664 $next_result = $self->DescribeGameSessions(@_, NextToken => $next_result->NextToken);
665 push @{ $result->GameSessions }, @{ $next_result->GameSessions };
666 }
667 return $result;
668 } else {
669 while ($result->NextToken) {
670 $callback->($_ => 'GameSessions') foreach (@{ $result->GameSessions });
671 $result = $self->DescribeGameSessions(@_, NextToken => $result->NextToken);
672 }
673 $callback->($_ => 'GameSessions') foreach (@{ $result->GameSessions });
674 }
675  
676 return undef
677 }
678 sub DescribeAllInstances {
679 my $self = shift;
680  
681 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
682 my $result = $self->DescribeInstances(@_);
683 my $next_result = $result;
684  
685 if (not defined $callback) {
686 while ($next_result->NextToken) {
687 $next_result = $self->DescribeInstances(@_, NextToken => $next_result->NextToken);
688 push @{ $result->Instances }, @{ $next_result->Instances };
689 }
690 return $result;
691 } else {
692 while ($result->NextToken) {
693 $callback->($_ => 'Instances') foreach (@{ $result->Instances });
694 $result = $self->DescribeInstances(@_, NextToken => $result->NextToken);
695 }
696 $callback->($_ => 'Instances') foreach (@{ $result->Instances });
697 }
698  
699 return undef
700 }
701 sub DescribeAllMatchmakingConfigurations {
702 my $self = shift;
703  
704 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
705 my $result = $self->DescribeMatchmakingConfigurations(@_);
706 my $next_result = $result;
707  
708 if (not defined $callback) {
709 while ($next_result->NextToken) {
710 $next_result = $self->DescribeMatchmakingConfigurations(@_, NextToken => $next_result->NextToken);
711 push @{ $result->Configurations }, @{ $next_result->Configurations };
712 }
713 return $result;
714 } else {
715 while ($result->NextToken) {
716 $callback->($_ => 'Configurations') foreach (@{ $result->Configurations });
717 $result = $self->DescribeMatchmakingConfigurations(@_, NextToken => $result->NextToken);
718 }
719 $callback->($_ => 'Configurations') foreach (@{ $result->Configurations });
720 }
721  
722 return undef
723 }
724 sub DescribeAllMatchmakingRuleSets {
725 my $self = shift;
726  
727 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
728 my $result = $self->DescribeMatchmakingRuleSets(@_);
729 my $next_result = $result;
730  
731 if (not defined $callback) {
732 while ($next_result->NextToken) {
733 $next_result = $self->DescribeMatchmakingRuleSets(@_, NextToken => $next_result->NextToken);
734 push @{ $result->RuleSets }, @{ $next_result->RuleSets };
735 }
736 return $result;
737 } else {
738 while ($result->NextToken) {
739 $callback->($_ => 'RuleSets') foreach (@{ $result->RuleSets });
740 $result = $self->DescribeMatchmakingRuleSets(@_, NextToken => $result->NextToken);
741 }
742 $callback->($_ => 'RuleSets') foreach (@{ $result->RuleSets });
743 }
744  
745 return undef
746 }
747 sub DescribeAllPlayerSessions {
748 my $self = shift;
749  
750 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
751 my $result = $self->DescribePlayerSessions(@_);
752 my $next_result = $result;
753  
754 if (not defined $callback) {
755 while ($next_result->NextToken) {
756 $next_result = $self->DescribePlayerSessions(@_, NextToken => $next_result->NextToken);
757 push @{ $result->PlayerSessions }, @{ $next_result->PlayerSessions };
758 }
759 return $result;
760 } else {
761 while ($result->NextToken) {
762 $callback->($_ => 'PlayerSessions') foreach (@{ $result->PlayerSessions });
763 $result = $self->DescribePlayerSessions(@_, NextToken => $result->NextToken);
764 }
765 $callback->($_ => 'PlayerSessions') foreach (@{ $result->PlayerSessions });
766 }
767  
768 return undef
769 }
770 sub DescribeAllScalingPolicies {
771 my $self = shift;
772  
773 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
774 my $result = $self->DescribeScalingPolicies(@_);
775 my $next_result = $result;
776  
777 if (not defined $callback) {
778 while ($next_result->NextToken) {
779 $next_result = $self->DescribeScalingPolicies(@_, NextToken => $next_result->NextToken);
780 push @{ $result->ScalingPolicies }, @{ $next_result->ScalingPolicies };
781 }
782 return $result;
783 } else {
784 while ($result->NextToken) {
785 $callback->($_ => 'ScalingPolicies') foreach (@{ $result->ScalingPolicies });
786 $result = $self->DescribeScalingPolicies(@_, NextToken => $result->NextToken);
787 }
788 $callback->($_ => 'ScalingPolicies') foreach (@{ $result->ScalingPolicies });
789 }
790  
791 return undef
792 }
793 sub ListAllAliases {
794 my $self = shift;
795  
796 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
797 my $result = $self->ListAliases(@_);
798 my $next_result = $result;
799  
800 if (not defined $callback) {
801 while ($next_result->NextToken) {
802 $next_result = $self->ListAliases(@_, NextToken => $next_result->NextToken);
803 push @{ $result->Aliases }, @{ $next_result->Aliases };
804 }
805 return $result;
806 } else {
807 while ($result->NextToken) {
808 $callback->($_ => 'Aliases') foreach (@{ $result->Aliases });
809 $result = $self->ListAliases(@_, NextToken => $result->NextToken);
810 }
811 $callback->($_ => 'Aliases') foreach (@{ $result->Aliases });
812 }
813  
814 return undef
815 }
816 sub ListAllBuilds {
817 my $self = shift;
818  
819 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
820 my $result = $self->ListBuilds(@_);
821 my $next_result = $result;
822  
823 if (not defined $callback) {
824 while ($next_result->NextToken) {
825 $next_result = $self->ListBuilds(@_, NextToken => $next_result->NextToken);
826 push @{ $result->Builds }, @{ $next_result->Builds };
827 }
828 return $result;
829 } else {
830 while ($result->NextToken) {
831 $callback->($_ => 'Builds') foreach (@{ $result->Builds });
832 $result = $self->ListBuilds(@_, NextToken => $result->NextToken);
833 }
834 $callback->($_ => 'Builds') foreach (@{ $result->Builds });
835 }
836  
837 return undef
838 }
839 sub ListAllFleets {
840 my $self = shift;
841  
842 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
843 my $result = $self->ListFleets(@_);
844 my $next_result = $result;
845  
846 if (not defined $callback) {
847 while ($next_result->NextToken) {
848 $next_result = $self->ListFleets(@_, NextToken => $next_result->NextToken);
849 push @{ $result->FleetIds }, @{ $next_result->FleetIds };
850 }
851 return $result;
852 } else {
853 while ($result->NextToken) {
854 $callback->($_ => 'FleetIds') foreach (@{ $result->FleetIds });
855 $result = $self->ListFleets(@_, NextToken => $result->NextToken);
856 }
857 $callback->($_ => 'FleetIds') foreach (@{ $result->FleetIds });
858 }
859  
860 return undef
861 }
862 sub ListAllGameServerGroups {
863 my $self = shift;
864  
865 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
866 my $result = $self->ListGameServerGroups(@_);
867 my $next_result = $result;
868  
869 if (not defined $callback) {
870 while ($next_result->NextToken) {
871 $next_result = $self->ListGameServerGroups(@_, NextToken => $next_result->NextToken);
872 push @{ $result->GameServerGroups }, @{ $next_result->GameServerGroups };
873 }
874 return $result;
875 } else {
876 while ($result->NextToken) {
877 $callback->($_ => 'GameServerGroups') foreach (@{ $result->GameServerGroups });
878 $result = $self->ListGameServerGroups(@_, NextToken => $result->NextToken);
879 }
880 $callback->($_ => 'GameServerGroups') foreach (@{ $result->GameServerGroups });
881 }
882  
883 return undef
884 }
885 sub ListAllGameServers {
886 my $self = shift;
887  
888 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
889 my $result = $self->ListGameServers(@_);
890 my $next_result = $result;
891  
892 if (not defined $callback) {
893 while ($next_result->NextToken) {
894 $next_result = $self->ListGameServers(@_, NextToken => $next_result->NextToken);
895 push @{ $result->GameServers }, @{ $next_result->GameServers };
896 }
897 return $result;
898 } else {
899 while ($result->NextToken) {
900 $callback->($_ => 'GameServers') foreach (@{ $result->GameServers });
901 $result = $self->ListGameServers(@_, NextToken => $result->NextToken);
902 }
903 $callback->($_ => 'GameServers') foreach (@{ $result->GameServers });
904 }
905  
906 return undef
907 }
908 sub ListAllScripts {
909 my $self = shift;
910  
911 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
912 my $result = $self->ListScripts(@_);
913 my $next_result = $result;
914  
915 if (not defined $callback) {
916 while ($next_result->NextToken) {
917 $next_result = $self->ListScripts(@_, NextToken => $next_result->NextToken);
918 push @{ $result->Scripts }, @{ $next_result->Scripts };
919 }
920 return $result;
921 } else {
922 while ($result->NextToken) {
923 $callback->($_ => 'Scripts') foreach (@{ $result->Scripts });
924 $result = $self->ListScripts(@_, NextToken => $result->NextToken);
925 }
926 $callback->($_ => 'Scripts') foreach (@{ $result->Scripts });
927 }
928  
929 return undef
930 }
931 sub SearchAllGameSessions {
932 my $self = shift;
933  
934 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
935 my $result = $self->SearchGameSessions(@_);
936 my $next_result = $result;
937  
938 if (not defined $callback) {
939 while ($next_result->NextToken) {
940 $next_result = $self->SearchGameSessions(@_, NextToken => $next_result->NextToken);
941 push @{ $result->GameSessions }, @{ $next_result->GameSessions };
942 }
943 return $result;
944 } else {
945 while ($result->NextToken) {
946 $callback->($_ => 'GameSessions') foreach (@{ $result->GameSessions });
947 $result = $self->SearchGameSessions(@_, NextToken => $result->NextToken);
948 }
949 $callback->($_ => 'GameSessions') foreach (@{ $result->GameSessions });
950 }
951  
952 return undef
953 }
954  
955  
956 sub operations { qw/AcceptMatch ClaimGameServer CreateAlias CreateBuild CreateFleet CreateFleetLocations CreateGameServerGroup CreateGameSession CreateGameSessionQueue CreateMatchmakingConfiguration CreateMatchmakingRuleSet CreatePlayerSession CreatePlayerSessions CreateScript CreateVpcPeeringAuthorization CreateVpcPeeringConnection DeleteAlias DeleteBuild DeleteFleet DeleteFleetLocations DeleteGameServerGroup DeleteGameSessionQueue DeleteMatchmakingConfiguration DeleteMatchmakingRuleSet DeleteScalingPolicy DeleteScript DeleteVpcPeeringAuthorization DeleteVpcPeeringConnection DeregisterGameServer DescribeAlias DescribeBuild DescribeEC2InstanceLimits DescribeFleetAttributes DescribeFleetCapacity DescribeFleetEvents DescribeFleetLocationAttributes DescribeFleetLocationCapacity DescribeFleetLocationUtilization DescribeFleetPortSettings DescribeFleetUtilization DescribeGameServer DescribeGameServerGroup DescribeGameServerInstances DescribeGameSessionDetails DescribeGameSessionPlacement DescribeGameSessionQueues DescribeGameSessions DescribeInstances DescribeMatchmaking DescribeMatchmakingConfigurations DescribeMatchmakingRuleSets DescribePlayerSessions DescribeRuntimeConfiguration DescribeScalingPolicies DescribeScript DescribeVpcPeeringAuthorizations DescribeVpcPeeringConnections GetGameSessionLogUrl GetInstanceAccess ListAliases ListBuilds ListFleets ListGameServerGroups ListGameServers ListScripts ListTagsForResource PutScalingPolicy RegisterGameServer RequestUploadCredentials ResolveAlias ResumeGameServerGroup SearchGameSessions StartFleetActions StartGameSessionPlacement StartMatchBackfill StartMatchmaking StopFleetActions StopGameSessionPlacement StopMatchmaking SuspendGameServerGroup TagResource UntagResource UpdateAlias UpdateBuild UpdateFleetAttributes UpdateFleetCapacity UpdateFleetPortSettings UpdateGameServer UpdateGameServerGroup UpdateGameSession UpdateGameSessionQueue UpdateMatchmakingConfiguration UpdateRuntimeConfiguration UpdateScript ValidateMatchmakingRuleSet / }
957  
958 1;
959  
960 ### main pod documentation begin ###
961  
962 =head1 NAME
963  
964 Paws::GameLift - Perl Interface to AWS Amazon GameLift
965  
966 =head1 SYNOPSIS
967  
968 use Paws;
969  
970 my $obj = Paws->service('GameLift');
971 my $res = $obj->Method(
972 Arg1 => $val1,
973 Arg2 => [ 'V1', 'V2' ],
974 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
975 # of the arguments type
976 Arg3 => { Att1 => 'Val1' },
977 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
978 # the constructor of the arguments type
979 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
980 );
981  
982 =head1 DESCRIPTION
983  
984 Amazon GameLift Service
985  
986 GameLift provides solutions for hosting session-based multiplayer game
987 servers in the cloud, including tools for deploying, operating, and
988 scaling game servers. Built on AWS global computing infrastructure,
989 GameLift helps you deliver high-performance, high-reliability, low-cost
990 game servers while dynamically scaling your resource usage to meet
991 player demand.
992  
993 B<About GameLift solutions>
994  
995 Get more information on these GameLift solutions in the GameLift
996 Developer Guide
997 (https://docs.aws.amazon.com/gamelift/latest/developerguide/).
998  
999 =over
1000  
1001 =item *
1002  
1003 GameLift managed hosting -- GameLift offers a fully managed service to
1004 set up and maintain computing machines for hosting, manage game session
1005 and player session life cycle, and handle security, storage, and
1006 performance tracking. You can use automatic scaling tools to balance
1007 player demand and hosting costs, configure your game session management
1008 to minimize player latency, and add FlexMatch for matchmaking.
1009  
1010 =item *
1011  
1012 Managed hosting with Realtime Servers -- With GameLift Realtime
1013 Servers, you can quickly configure and set up ready-to-go game servers
1014 for your game. Realtime Servers provides a game server framework with
1015 core GameLift infrastructure already built in. Then use the full range
1016 of GameLift managed hosting features, including FlexMatch, for your
1017 game.
1018  
1019 =item *
1020  
1021 GameLift FleetIQ -- Use GameLift FleetIQ as a standalone service while
1022 hosting your games using EC2 instances and Auto Scaling groups.
1023 GameLift FleetIQ provides optimizations for game hosting, including
1024 boosting the viability of low-cost Spot Instances gaming. For a
1025 complete solution, pair the GameLift FleetIQ and FlexMatch standalone
1026 services.
1027  
1028 =item *
1029  
1030 GameLift FlexMatch -- Add matchmaking to your game hosting solution.
1031 FlexMatch is a customizable matchmaking service for multiplayer games.
1032 Use FlexMatch as integrated with GameLift managed hosting or
1033 incorporate FlexMatch as a standalone service into your own hosting
1034 solution.
1035  
1036 =back
1037  
1038 B<About this API Reference>
1039  
1040 This reference guide describes the low-level service API for Amazon
1041 GameLift. With each topic in this guide, you can find links to
1042 language-specific SDK guides and the AWS CLI reference. Useful links:
1043  
1044 =over
1045  
1046 =item *
1047  
1048 GameLift API operations listed by tasks
1049 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html)
1050  
1051 =item *
1052  
1053 GameLift tools and resources
1054 (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-components.html)
1055  
1056 =back
1057  
1058  
1059 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01>
1060  
1061  
1062 =head1 METHODS
1063  
1064 =head2 AcceptMatch
1065  
1066 =over
1067  
1068 =item AcceptanceType => Str
1069  
1070 =item PlayerIds => ArrayRef[Str|Undef]
1071  
1072 =item TicketId => Str
1073  
1074  
1075 =back
1076  
1077 Each argument is described in detail in: L<Paws::GameLift::AcceptMatch>
1078  
1079 Returns: a L<Paws::GameLift::AcceptMatchOutput> instance
1080  
1081 Registers a player's acceptance or rejection of a proposed FlexMatch
1082 match. A matchmaking configuration may require player acceptance; if
1083 so, then matches built with that configuration cannot be completed
1084 unless all players accept the proposed match within a specified time
1085 limit.
1086  
1087 When FlexMatch builds a match, all the matchmaking tickets involved in
1088 the proposed match are placed into status C<REQUIRES_ACCEPTANCE>. This
1089 is a trigger for your game to get acceptance from all players in the
1090 ticket. Acceptances are only valid for tickets when they are in this
1091 status; all other acceptances result in an error.
1092  
1093 To register acceptance, specify the ticket ID, a response, and one or
1094 more players. Once all players have registered acceptance, the
1095 matchmaking tickets advance to status C<PLACING>, where a new game
1096 session is created for the match.
1097  
1098 If any player rejects the match, or if acceptances are not received
1099 before a specified timeout, the proposed match is dropped. The
1100 matchmaking tickets are then handled in one of two ways: For tickets
1101 where one or more players rejected the match, the ticket status is
1102 returned to C<SEARCHING> to find a new match. For tickets where one or
1103 more players failed to respond, the ticket status is set to
1104 C<CANCELLED>, and processing is terminated. A new matchmaking request
1105 for these players can be submitted as needed.
1106  
1107 B<Learn more>
1108  
1109 Add FlexMatch to a game client
1110 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-client.html)
1111  
1112 FlexMatch events
1113 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-events.html)
1114 (reference)
1115  
1116 B<Related actions>
1117  
1118 StartMatchmaking | DescribeMatchmaking | StopMatchmaking | AcceptMatch
1119 | StartMatchBackfill | All APIs by task
1120 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
1121  
1122  
1123 =head2 ClaimGameServer
1124  
1125 =over
1126  
1127 =item GameServerGroupName => Str
1128  
1129 =item [GameServerData => Str]
1130  
1131 =item [GameServerId => Str]
1132  
1133  
1134 =back
1135  
1136 Each argument is described in detail in: L<Paws::GameLift::ClaimGameServer>
1137  
1138 Returns: a L<Paws::GameLift::ClaimGameServerOutput> instance
1139  
1140 B<This operation is used with the GameLift FleetIQ solution and game
1141 server groups.>
1142  
1143 Locates an available game server and temporarily reserves it to host
1144 gameplay and players. This operation is called from a game client or
1145 client service (such as a matchmaker) to request hosting resources for
1146 a new game session. In response, GameLift FleetIQ locates an available
1147 game server, places it in C<CLAIMED> status for 60 seconds, and returns
1148 connection information that players can use to connect to the game
1149 server.
1150  
1151 To claim a game server, identify a game server group. You can also
1152 specify a game server ID, although this approach bypasses GameLift
1153 FleetIQ placement optimization. Optionally, include game data to pass
1154 to the game server at the start of a game session, such as a game map
1155 or player information.
1156  
1157 When a game server is successfully claimed, connection information is
1158 returned. A claimed game server's utilization status remains
1159 C<AVAILABLE> while the claim status is set to C<CLAIMED> for up to 60
1160 seconds. This time period gives the game server time to update its
1161 status to C<UTILIZED> (using UpdateGameServer) once players join. If
1162 the game server's status is not updated within 60 seconds, the game
1163 server reverts to unclaimed status and is available to be claimed by
1164 another request. The claim time period is a fixed value and is not
1165 configurable.
1166  
1167 If you try to claim a specific game server, this request will fail in
1168 the following cases:
1169  
1170 =over
1171  
1172 =item *
1173  
1174 If the game server utilization status is C<UTILIZED>.
1175  
1176 =item *
1177  
1178 If the game server claim status is C<CLAIMED>.
1179  
1180 =back
1181  
1182 When claiming a specific game server, this request will succeed even if
1183 the game server is running on an instance in C<DRAINING> status. To
1184 avoid this, first check the instance status by calling
1185 DescribeGameServerInstances.
1186  
1187 B<Learn more>
1188  
1189 GameLift FleetIQ Guide
1190 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
1191  
1192 B<Related actions>
1193  
1194 RegisterGameServer | ListGameServers | ClaimGameServer |
1195 DescribeGameServer | UpdateGameServer | DeregisterGameServer | All APIs
1196 by task
1197 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
1198  
1199  
1200 =head2 CreateAlias
1201  
1202 =over
1203  
1204 =item Name => Str
1205  
1206 =item RoutingStrategy => L<Paws::GameLift::RoutingStrategy>
1207  
1208 =item [Description => Str]
1209  
1210 =item [Tags => ArrayRef[L<Paws::GameLift::Tag>]]
1211  
1212  
1213 =back
1214  
1215 Each argument is described in detail in: L<Paws::GameLift::CreateAlias>
1216  
1217 Returns: a L<Paws::GameLift::CreateAliasOutput> instance
1218  
1219 Creates an alias for a fleet. In most situations, you can use an alias
1220 ID in place of a fleet ID. An alias provides a level of abstraction for
1221 a fleet that is useful when redirecting player traffic from one fleet
1222 to another, such as when updating your game build.
1223  
1224 Amazon GameLift supports two types of routing strategies for aliases:
1225 simple and terminal. A simple alias points to an active fleet. A
1226 terminal alias is used to display messaging or link to a URL instead of
1227 routing players to an active fleet. For example, you might use a
1228 terminal alias when a game version is no longer supported and you want
1229 to direct players to an upgrade site.
1230  
1231 To create a fleet alias, specify an alias name, routing strategy, and
1232 optional description. Each simple alias can point to only one fleet,
1233 but a fleet can have multiple aliases. If successful, a new alias
1234 record is returned, including an alias ID and an ARN. You can reassign
1235 an alias to another fleet by calling C<UpdateAlias>.
1236  
1237 B<Related actions>
1238  
1239 CreateAlias | ListAliases | DescribeAlias | UpdateAlias | DeleteAlias |
1240 ResolveAlias | All APIs by task
1241 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
1242  
1243  
1244 =head2 CreateBuild
1245  
1246 =over
1247  
1248 =item [Name => Str]
1249  
1250 =item [OperatingSystem => Str]
1251  
1252 =item [StorageLocation => L<Paws::GameLift::S3Location>]
1253  
1254 =item [Tags => ArrayRef[L<Paws::GameLift::Tag>]]
1255  
1256 =item [Version => Str]
1257  
1258  
1259 =back
1260  
1261 Each argument is described in detail in: L<Paws::GameLift::CreateBuild>
1262  
1263 Returns: a L<Paws::GameLift::CreateBuildOutput> instance
1264  
1265 Creates a new Amazon GameLift build resource for your game server
1266 binary files. Game server binaries must be combined into a zip file for
1267 use with Amazon GameLift.
1268  
1269 When setting up a new game build for GameLift, we recommend using the
1270 AWS CLI command B< upload-build
1271 (https://docs.aws.amazon.com/cli/latest/reference/gamelift/upload-build.html)
1272 >. This helper command combines two tasks: (1) it uploads your build
1273 files from a file directory to a GameLift Amazon S3 location, and (2)
1274 it creates a new build resource.
1275  
1276 The C<CreateBuild> operation can used in the following scenarios:
1277  
1278 =over
1279  
1280 =item *
1281  
1282 To create a new game build with build files that are in an Amazon S3
1283 location under an AWS account that you control. To use this option, you
1284 must first give Amazon GameLift access to the Amazon S3 bucket. With
1285 permissions in place, call C<CreateBuild> and specify a build name,
1286 operating system, and the Amazon S3 storage location of your game
1287 build.
1288  
1289 =item *
1290  
1291 To directly upload your build files to a GameLift Amazon S3 location.
1292 To use this option, first call C<CreateBuild> and specify a build name
1293 and operating system. This operation creates a new build resource and
1294 also returns an Amazon S3 location with temporary access credentials.
1295 Use the credentials to manually upload your build files to the
1296 specified Amazon S3 location. For more information, see Uploading
1297 Objects
1298 (https://docs.aws.amazon.com/AmazonS3/latest/dev/UploadingObjects.html)
1299 in the I<Amazon S3 Developer Guide>. Build files can be uploaded to the
1300 GameLift Amazon S3 location once only; that can't be updated.
1301  
1302 =back
1303  
1304 If successful, this operation creates a new build resource with a
1305 unique build ID and places it in C<INITIALIZED> status. A build must be
1306 in C<READY> status before you can create fleets with it.
1307  
1308 B<Learn more>
1309  
1310 Uploading Your Game
1311 (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-build-intro.html)
1312  
1313 Create a Build with Files in Amazon S3
1314 (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-build-cli-uploading.html#gamelift-build-cli-uploading-create-build)
1315  
1316 B<Related actions>
1317  
1318 CreateBuild | ListBuilds | DescribeBuild | UpdateBuild | DeleteBuild |
1319 All APIs by task
1320 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
1321  
1322  
1323 =head2 CreateFleet
1324  
1325 =over
1326  
1327 =item EC2InstanceType => Str
1328  
1329 =item Name => Str
1330  
1331 =item [BuildId => Str]
1332  
1333 =item [CertificateConfiguration => L<Paws::GameLift::CertificateConfiguration>]
1334  
1335 =item [Description => Str]
1336  
1337 =item [EC2InboundPermissions => ArrayRef[L<Paws::GameLift::IpPermission>]]
1338  
1339 =item [FleetType => Str]
1340  
1341 =item [InstanceRoleArn => Str]
1342  
1343 =item [Locations => ArrayRef[L<Paws::GameLift::LocationConfiguration>]]
1344  
1345 =item [LogPaths => ArrayRef[Str|Undef]]
1346  
1347 =item [MetricGroups => ArrayRef[Str|Undef]]
1348  
1349 =item [NewGameSessionProtectionPolicy => Str]
1350  
1351 =item [PeerVpcAwsAccountId => Str]
1352  
1353 =item [PeerVpcId => Str]
1354  
1355 =item [ResourceCreationLimitPolicy => L<Paws::GameLift::ResourceCreationLimitPolicy>]
1356  
1357 =item [RuntimeConfiguration => L<Paws::GameLift::RuntimeConfiguration>]
1358  
1359 =item [ScriptId => Str]
1360  
1361 =item [ServerLaunchParameters => Str]
1362  
1363 =item [ServerLaunchPath => Str]
1364  
1365 =item [Tags => ArrayRef[L<Paws::GameLift::Tag>]]
1366  
1367  
1368 =back
1369  
1370 Each argument is described in detail in: L<Paws::GameLift::CreateFleet>
1371  
1372 Returns: a L<Paws::GameLift::CreateFleetOutput> instance
1373  
1374 Creates a fleet of Amazon Elastic Compute Cloud (Amazon EC2) instances
1375 to host your custom game server or Realtime Servers. Use this operation
1376 to configure the computing resources for your fleet and provide
1377 instructions for running game servers on each instance.
1378  
1379 Most GameLift fleets can deploy instances to multiple locations,
1380 including the home Region (where the fleet is created) and an optional
1381 set of remote locations. Fleets that are created in the following AWS
1382 Regions support multiple locations: us-east-1 (N. Virginia), us-west-2
1383 (Oregon), eu-central-1 (Frankfurt), eu-west-1 (Ireland), ap-southeast-2
1384 (Sydney), ap-northeast-1 (Tokyo), and ap-northeast-2 (Seoul). Fleets
1385 that are created in other GameLift Regions can deploy instances in the
1386 fleet's home Region only. All fleet instances use the same
1387 configuration regardless of location; however, you can adjust capacity
1388 settings and turn auto-scaling on/off for each location.
1389  
1390 To create a fleet, choose the hardware for your instances, specify a
1391 game server build or Realtime script to deploy, and provide a runtime
1392 configuration to direct GameLift how to start and run game servers on
1393 each instance in the fleet. Set permissions for inbound traffic to your
1394 game servers, and enable optional features as needed. When creating a
1395 multi-location fleet, provide a list of additional remote locations.
1396  
1397 If successful, this operation creates a new Fleet resource and places
1398 it in C<NEW> status, which prompts GameLift to initiate the fleet
1399 creation workflow
1400 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creation-workflow.html).
1401 You can track fleet creation by checking fleet status using
1402 DescribeFleetAttributes and DescribeFleetLocationAttributes/, or by
1403 monitoring fleet creation events using DescribeFleetEvents. As soon as
1404 the fleet status changes to C<ACTIVE>, you can enable automatic scaling
1405 for the fleet with PutScalingPolicy and set capacity for the home
1406 Region with UpdateFleetCapacity. When the status of each remote
1407 location reaches C<ACTIVE>, you can set capacity by location using
1408 UpdateFleetCapacity.
1409  
1410 B<Learn more>
1411  
1412 Setting up fleets
1413 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
1414  
1415 Debug fleet creation issues
1416 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creating-debug.html#fleets-creating-debug-creation)
1417  
1418 Multi-location fleets
1419 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
1420  
1421 B<Related actions>
1422  
1423 CreateFleet | UpdateFleetCapacity | PutScalingPolicy |
1424 DescribeEC2InstanceLimits | DescribeFleetAttributes |
1425 DescribeFleetLocationAttributes | UpdateFleetAttributes |
1426 StopFleetActions | DeleteFleet | All APIs by task
1427 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
1428  
1429  
1430 =head2 CreateFleetLocations
1431  
1432 =over
1433  
1434 =item FleetId => Str
1435  
1436 =item Locations => ArrayRef[L<Paws::GameLift::LocationConfiguration>]
1437  
1438  
1439 =back
1440  
1441 Each argument is described in detail in: L<Paws::GameLift::CreateFleetLocations>
1442  
1443 Returns: a L<Paws::GameLift::CreateFleetLocationsOutput> instance
1444  
1445 Adds remote locations to a fleet and begins populating the new
1446 locations with EC2 instances. The new instances conform to the fleet's
1447 instance type, auto-scaling, and other configuration settings.
1448  
1449 This operation cannot be used with fleets that don't support remote
1450 locations. Fleets can have multiple locations only if they reside in
1451 AWS Regions that support this feature (see CreateFleet for the complete
1452 list) and were created after the feature was released in March 2021.
1453  
1454 To add fleet locations, specify the fleet to be updated and provide a
1455 list of one or more locations.
1456  
1457 If successful, this operation returns the list of added locations with
1458 their status set to C<NEW>. GameLift initiates the process of starting
1459 an instance in each added location. You can track the status of each
1460 new location by monitoring location creation events using
1461 DescribeFleetEvents. Alternatively, you can poll location status by
1462 calling DescribeFleetLocationAttributes. After a location status
1463 becomes C<ACTIVE>, you can adjust the location's capacity as needed
1464 with UpdateFleetCapacity.
1465  
1466 B<Learn more>
1467  
1468 Setting up fleets
1469 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
1470  
1471 Multi-location fleets
1472 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
1473  
1474 B<Related actions>
1475  
1476 CreateFleetLocations | DescribeFleetLocationAttributes |
1477 DescribeFleetLocationCapacity | DescribeFleetLocationUtilization |
1478 DescribeFleetAttributes | DescribeFleetCapacity |
1479 DescribeFleetUtilization | UpdateFleetCapacity | StopFleetActions |
1480 DeleteFleetLocations | All APIs by task
1481 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
1482  
1483  
1484 =head2 CreateGameServerGroup
1485  
1486 =over
1487  
1488 =item GameServerGroupName => Str
1489  
1490 =item InstanceDefinitions => ArrayRef[L<Paws::GameLift::InstanceDefinition>]
1491  
1492 =item LaunchTemplate => L<Paws::GameLift::LaunchTemplateSpecification>
1493  
1494 =item MaxSize => Int
1495  
1496 =item MinSize => Int
1497  
1498 =item RoleArn => Str
1499  
1500 =item [AutoScalingPolicy => L<Paws::GameLift::GameServerGroupAutoScalingPolicy>]
1501  
1502 =item [BalancingStrategy => Str]
1503  
1504 =item [GameServerProtectionPolicy => Str]
1505  
1506 =item [Tags => ArrayRef[L<Paws::GameLift::Tag>]]
1507  
1508 =item [VpcSubnets => ArrayRef[Str|Undef]]
1509  
1510  
1511 =back
1512  
1513 Each argument is described in detail in: L<Paws::GameLift::CreateGameServerGroup>
1514  
1515 Returns: a L<Paws::GameLift::CreateGameServerGroupOutput> instance
1516  
1517 B<This operation is used with the GameLift FleetIQ solution and game
1518 server groups.>
1519  
1520 Creates a GameLift FleetIQ game server group for managing game hosting
1521 on a collection of Amazon EC2 instances for game hosting. This
1522 operation creates the game server group, creates an Auto Scaling group
1523 in your AWS account, and establishes a link between the two groups. You
1524 can view the status of your game server groups in the GameLift console.
1525 Game server group metrics and events are emitted to Amazon CloudWatch.
1526  
1527 Before creating a new game server group, you must have the following:
1528  
1529 =over
1530  
1531 =item *
1532  
1533 An Amazon EC2 launch template that specifies how to launch Amazon EC2
1534 instances with your game server build. For more information, see
1535 Launching an Instance from a Launch Template
1536 (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html)
1537 in the I<Amazon EC2 User Guide>.
1538  
1539 =item *
1540  
1541 An IAM role that extends limited access to your AWS account to allow
1542 GameLift FleetIQ to create and interact with the Auto Scaling group.
1543 For more information, see Create IAM roles for cross-service
1544 interaction
1545 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-iam-permissions-roles.html)
1546 in the I<GameLift FleetIQ Developer Guide>.
1547  
1548 =back
1549  
1550 To create a new game server group, specify a unique group name, IAM
1551 role and Amazon EC2 launch template, and provide a list of instance
1552 types that can be used in the group. You must also set initial maximum
1553 and minimum limits on the group's instance count. You can optionally
1554 set an Auto Scaling policy with target tracking based on a GameLift
1555 FleetIQ metric.
1556  
1557 Once the game server group and corresponding Auto Scaling group are
1558 created, you have full access to change the Auto Scaling group's
1559 configuration as needed. Several properties that are set when creating
1560 a game server group, including maximum/minimum size and auto-scaling
1561 policy settings, must be updated directly in the Auto Scaling group.
1562 Keep in mind that some Auto Scaling group properties are periodically
1563 updated by GameLift FleetIQ as part of its balancing activities to
1564 optimize for availability and cost.
1565  
1566 B<Learn more>
1567  
1568 GameLift FleetIQ Guide
1569 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
1570  
1571 B<Related actions>
1572  
1573 CreateGameServerGroup | ListGameServerGroups | DescribeGameServerGroup
1574 | UpdateGameServerGroup | DeleteGameServerGroup | ResumeGameServerGroup
1575 | SuspendGameServerGroup | DescribeGameServerInstances | All APIs by
1576 task
1577 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
1578  
1579  
1580 =head2 CreateGameSession
1581  
1582 =over
1583  
1584 =item MaximumPlayerSessionCount => Int
1585  
1586 =item [AliasId => Str]
1587  
1588 =item [CreatorId => Str]
1589  
1590 =item [FleetId => Str]
1591  
1592 =item [GameProperties => ArrayRef[L<Paws::GameLift::GameProperty>]]
1593  
1594 =item [GameSessionData => Str]
1595  
1596 =item [GameSessionId => Str]
1597  
1598 =item [IdempotencyToken => Str]
1599  
1600 =item [Location => Str]
1601  
1602 =item [Name => Str]
1603  
1604  
1605 =back
1606  
1607 Each argument is described in detail in: L<Paws::GameLift::CreateGameSession>
1608  
1609 Returns: a L<Paws::GameLift::CreateGameSessionOutput> instance
1610  
1611 Creates a multiplayer game session for players in a specific fleet
1612 location. This operation prompts an available server process to start a
1613 game session and retrieves connection information for the new game
1614 session. As an alternative, consider using the GameLift game session
1615 placement feature with
1616  
1617 with StartGameSessionPlacement, which uses FleetIQ algorithms and
1618 queues to optimize the placement process.
1619  
1620 When creating a game session, you specify exactly where you want to
1621 place it and provide a set of game session configuration settings. The
1622 fleet must be in C<ACTIVE> status before a game session can be created
1623 in it.
1624  
1625 This operation can be used in the following ways:
1626  
1627 =over
1628  
1629 =item *
1630  
1631 To create a game session on an instance in a fleet's home Region,
1632 provide a fleet or alias ID along with your game session configuration.
1633  
1634 =item *
1635  
1636 To create a game session on an instance in a fleet's remote location,
1637 provide a fleet or alias ID and a location name, along with your game
1638 session configuration.
1639  
1640 =back
1641  
1642 If successful, a workflow is initiated to start a new game session. A
1643 C<GameSession> object is returned containing the game session
1644 configuration and status. When the status is C<ACTIVE>, game session
1645 connection information is provided and player sessions can be created
1646 for the game session. By default, newly created game sessions are open
1647 to new players. You can restrict new player access by using
1648 UpdateGameSession to change the game session's player session creation
1649 policy.
1650  
1651 Game session logs are retained for all active game sessions for 14
1652 days. To access the logs, call GetGameSessionLogUrl to download the log
1653 files.
1654  
1655 I<Available in GameLift Local.>
1656  
1657 B<Learn more>
1658  
1659 Start a game session
1660 (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)
1661  
1662 B<Related actions>
1663  
1664 CreateGameSession | DescribeGameSessions | DescribeGameSessionDetails |
1665 SearchGameSessions | UpdateGameSession | GetGameSessionLogUrl |
1666 StartGameSessionPlacement | DescribeGameSessionPlacement |
1667 StopGameSessionPlacement | All APIs by task
1668 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
1669  
1670  
1671 =head2 CreateGameSessionQueue
1672  
1673 =over
1674  
1675 =item Name => Str
1676  
1677 =item [CustomEventData => Str]
1678  
1679 =item [Destinations => ArrayRef[L<Paws::GameLift::GameSessionQueueDestination>]]
1680  
1681 =item [FilterConfiguration => L<Paws::GameLift::FilterConfiguration>]
1682  
1683 =item [NotificationTarget => Str]
1684  
1685 =item [PlayerLatencyPolicies => ArrayRef[L<Paws::GameLift::PlayerLatencyPolicy>]]
1686  
1687 =item [PriorityConfiguration => L<Paws::GameLift::PriorityConfiguration>]
1688  
1689 =item [Tags => ArrayRef[L<Paws::GameLift::Tag>]]
1690  
1691 =item [TimeoutInSeconds => Int]
1692  
1693  
1694 =back
1695  
1696 Each argument is described in detail in: L<Paws::GameLift::CreateGameSessionQueue>
1697  
1698 Returns: a L<Paws::GameLift::CreateGameSessionQueueOutput> instance
1699  
1700 Creates a placement queue that processes requests for new game
1701 sessions. A queue uses FleetIQ algorithms to determine the best
1702 placement locations and find an available game server there, then
1703 prompts the game server process to start a new game session.
1704  
1705 A game session queue is configured with a set of destinations (GameLift
1706 fleets or aliases), which determine the locations where the queue can
1707 place new game sessions. These destinations can span multiple fleet
1708 types (Spot and On-Demand), instance types, and AWS Regions. If the
1709 queue includes multi-location fleets, the queue is able to place game
1710 sessions in all of a fleet's remote locations. You can opt to filter
1711 out individual locations if needed.
1712  
1713 The queue configuration also determines how FleetIQ selects the best
1714 available placement for a new game session. Before searching for an
1715 available game server, FleetIQ first prioritizes the queue's
1716 destinations and locations, with the best placement locations on top.
1717 You can set up the queue to use the FleetIQ default prioritization or
1718 provide an alternate set of priorities.
1719  
1720 To create a new queue, provide a name, timeout value, and a list of
1721 destinations. Optionally, specify a sort configuration and/or a filter,
1722 and define a set of latency cap policies. You can also include the ARN
1723 for an Amazon Simple Notification Service (SNS) topic to receive
1724 notifications of game session placement activity. Notifications using
1725 SNS or CloudWatch events is the preferred way to track placement
1726 activity.
1727  
1728 If successful, a new C<GameSessionQueue> object is returned with an
1729 assigned queue ARN. New game session requests, which are submitted to
1730 the queue with StartGameSessionPlacement or StartMatchmaking, reference
1731 a queue's name or ARN.
1732  
1733 B<Learn more>
1734  
1735 Design a game session queue
1736 (https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-design.html)
1737  
1738 Create a game session queue
1739 (https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-creating.html)
1740  
1741 B<Related actions>
1742  
1743 CreateGameSessionQueue | DescribeGameSessionQueues |
1744 UpdateGameSessionQueue | DeleteGameSessionQueue | All APIs by task
1745 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
1746  
1747  
1748 =head2 CreateMatchmakingConfiguration
1749  
1750 =over
1751  
1752 =item AcceptanceRequired => Bool
1753  
1754 =item Name => Str
1755  
1756 =item RequestTimeoutSeconds => Int
1757  
1758 =item RuleSetName => Str
1759  
1760 =item [AcceptanceTimeoutSeconds => Int]
1761  
1762 =item [AdditionalPlayerCount => Int]
1763  
1764 =item [BackfillMode => Str]
1765  
1766 =item [CustomEventData => Str]
1767  
1768 =item [Description => Str]
1769  
1770 =item [FlexMatchMode => Str]
1771  
1772 =item [GameProperties => ArrayRef[L<Paws::GameLift::GameProperty>]]
1773  
1774 =item [GameSessionData => Str]
1775  
1776 =item [GameSessionQueueArns => ArrayRef[Str|Undef]]
1777  
1778 =item [NotificationTarget => Str]
1779  
1780 =item [Tags => ArrayRef[L<Paws::GameLift::Tag>]]
1781  
1782  
1783 =back
1784  
1785 Each argument is described in detail in: L<Paws::GameLift::CreateMatchmakingConfiguration>
1786  
1787 Returns: a L<Paws::GameLift::CreateMatchmakingConfigurationOutput> instance
1788  
1789 Defines a new matchmaking configuration for use with FlexMatch. Whether
1790 your are using FlexMatch with GameLift hosting or as a standalone
1791 matchmaking service, the matchmaking configuration sets out rules for
1792 matching players and forming teams. If you're also using GameLift
1793 hosting, it defines how to start game sessions for each match. Your
1794 matchmaking system can use multiple configurations to handle different
1795 game scenarios. All matchmaking requests (StartMatchmaking or
1796 StartMatchBackfill) identify the matchmaking configuration to use and
1797 provide player attributes consistent with that configuration.
1798  
1799 To create a matchmaking configuration, you must provide the following:
1800 configuration name and FlexMatch mode (with or without GameLift
1801 hosting); a rule set that specifies how to evaluate players and find
1802 acceptable matches; whether player acceptance is required; and the
1803 maximum time allowed for a matchmaking attempt. When using FlexMatch
1804 with GameLift hosting, you also need to identify the game session queue
1805 to use when starting a game session for the match.
1806  
1807 In addition, you must set up an Amazon Simple Notification Service
1808 (SNS) topic to receive matchmaking notifications. Provide the topic ARN
1809 in the matchmaking configuration. An alternative method, continuously
1810 polling ticket status with DescribeMatchmaking, is only suitable for
1811 games in development with low matchmaking usage.
1812  
1813 B<Learn more>
1814  
1815 Design a FlexMatch matchmaker
1816 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-configuration.html)
1817  
1818 Set up FlexMatch event notification
1819 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-notification.html)
1820  
1821 B<Related actions>
1822  
1823 CreateMatchmakingConfiguration | DescribeMatchmakingConfigurations |
1824 UpdateMatchmakingConfiguration | DeleteMatchmakingConfiguration |
1825 CreateMatchmakingRuleSet | DescribeMatchmakingRuleSets |
1826 ValidateMatchmakingRuleSet | DeleteMatchmakingRuleSet | All APIs by
1827 task
1828 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
1829  
1830  
1831 =head2 CreateMatchmakingRuleSet
1832  
1833 =over
1834  
1835 =item Name => Str
1836  
1837 =item RuleSetBody => Str
1838  
1839 =item [Tags => ArrayRef[L<Paws::GameLift::Tag>]]
1840  
1841  
1842 =back
1843  
1844 Each argument is described in detail in: L<Paws::GameLift::CreateMatchmakingRuleSet>
1845  
1846 Returns: a L<Paws::GameLift::CreateMatchmakingRuleSetOutput> instance
1847  
1848 Creates a new rule set for FlexMatch matchmaking. A rule set describes
1849 the type of match to create, such as the number and size of teams. It
1850 also sets the parameters for acceptable player matches, such as minimum
1851 skill level or character type. A rule set is used by a
1852 MatchmakingConfiguration.
1853  
1854 To create a matchmaking rule set, provide unique rule set name and the
1855 rule set body in JSON format. Rule sets must be defined in the same
1856 Region as the matchmaking configuration they are used with.
1857  
1858 Since matchmaking rule sets cannot be edited, it is a good idea to
1859 check the rule set syntax using ValidateMatchmakingRuleSet before
1860 creating a new rule set.
1861  
1862 B<Learn more>
1863  
1864 =over
1865  
1866 =item *
1867  
1868 Build a rule set
1869 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-rulesets.html)
1870  
1871 =item *
1872  
1873 Design a matchmaker
1874 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-configuration.html)
1875  
1876 =item *
1877  
1878 Matchmaking with FlexMatch
1879 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-intro.html)
1880  
1881 =back
1882  
1883 B<Related actions>
1884  
1885 CreateMatchmakingConfiguration | DescribeMatchmakingConfigurations |
1886 UpdateMatchmakingConfiguration | DeleteMatchmakingConfiguration |
1887 CreateMatchmakingRuleSet | DescribeMatchmakingRuleSets |
1888 ValidateMatchmakingRuleSet | DeleteMatchmakingRuleSet | All APIs by
1889 task
1890 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
1891  
1892  
1893 =head2 CreatePlayerSession
1894  
1895 =over
1896  
1897 =item GameSessionId => Str
1898  
1899 =item PlayerId => Str
1900  
1901 =item [PlayerData => Str]
1902  
1903  
1904 =back
1905  
1906 Each argument is described in detail in: L<Paws::GameLift::CreatePlayerSession>
1907  
1908 Returns: a L<Paws::GameLift::CreatePlayerSessionOutput> instance
1909  
1910 Reserves an open player slot in a game session for a player. New player
1911 sessions can be created in any game session with an open slot that is
1912 in C<ACTIVE> status and has a player creation policy of C<ACCEPT_ALL>.
1913 You can add a group of players to a game session with
1914 CreatePlayerSessions.
1915  
1916 To create a player session, specify a game session ID, player ID, and
1917 optionally a set of player data.
1918  
1919 If successful, a slot is reserved in the game session for the player
1920 and a new PlayerSession object is returned with a player session ID.
1921 The player references the player session ID when sending a connection
1922 request to the game session, and the game server can use it to validate
1923 the player reservation with the GameLift service. Player sessions
1924 cannot be updated.
1925  
1926 I<Available in Amazon GameLift Local.>
1927  
1928 B<Related actions>
1929  
1930 CreatePlayerSession | CreatePlayerSessions | DescribePlayerSessions |
1931 StartGameSessionPlacement | DescribeGameSessionPlacement | All APIs by
1932 task
1933 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
1934  
1935  
1936 =head2 CreatePlayerSessions
1937  
1938 =over
1939  
1940 =item GameSessionId => Str
1941  
1942 =item PlayerIds => ArrayRef[Str|Undef]
1943  
1944 =item [PlayerDataMap => L<Paws::GameLift::PlayerDataMap>]
1945  
1946  
1947 =back
1948  
1949 Each argument is described in detail in: L<Paws::GameLift::CreatePlayerSessions>
1950  
1951 Returns: a L<Paws::GameLift::CreatePlayerSessionsOutput> instance
1952  
1953 Reserves open slots in a game session for a group of players. New
1954 player sessions can be created in any game session with an open slot
1955 that is in C<ACTIVE> status and has a player creation policy of
1956 C<ACCEPT_ALL>. To add a single player to a game session, use
1957 CreatePlayerSession.
1958  
1959 To create player sessions, specify a game session ID and a list of
1960 player IDs. Optionally, provide a set of player data for each player
1961 ID.
1962  
1963 If successful, a slot is reserved in the game session for each player,
1964 and new PlayerSession objects are returned with player session IDs.
1965 Each player references their player session ID when sending a
1966 connection request to the game session, and the game server can use it
1967 to validate the player reservation with the GameLift service. Player
1968 sessions cannot be updated.
1969  
1970 I<Available in Amazon GameLift Local.>
1971  
1972 B<Related actions>
1973  
1974 CreatePlayerSession | CreatePlayerSessions | DescribePlayerSessions |
1975 StartGameSessionPlacement | DescribeGameSessionPlacement | All APIs by
1976 task
1977 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
1978  
1979  
1980 =head2 CreateScript
1981  
1982 =over
1983  
1984 =item [Name => Str]
1985  
1986 =item [StorageLocation => L<Paws::GameLift::S3Location>]
1987  
1988 =item [Tags => ArrayRef[L<Paws::GameLift::Tag>]]
1989  
1990 =item [Version => Str]
1991  
1992 =item [ZipFile => Str]
1993  
1994  
1995 =back
1996  
1997 Each argument is described in detail in: L<Paws::GameLift::CreateScript>
1998  
1999 Returns: a L<Paws::GameLift::CreateScriptOutput> instance
2000  
2001 Creates a new script record for your Realtime Servers script. Realtime
2002 scripts are JavaScript that provide configuration settings and optional
2003 custom game logic for your game. The script is deployed when you create
2004 a Realtime Servers fleet to host your game sessions. Script logic is
2005 executed during an active game session.
2006  
2007 To create a new script record, specify a script name and provide the
2008 script file(s). The script files and all dependencies must be zipped
2009 into a single file. You can pull the zip file from either of these
2010 locations:
2011  
2012 =over
2013  
2014 =item *
2015  
2016 A locally available directory. Use the I<ZipFile> parameter for this
2017 option.
2018  
2019 =item *
2020  
2021 An Amazon Simple Storage Service (Amazon S3) bucket under your AWS
2022 account. Use the I<StorageLocation> parameter for this option. You'll
2023 need to have an Identity Access Management (IAM) role that allows the
2024 Amazon GameLift service to access your S3 bucket.
2025  
2026 =back
2027  
2028 If the call is successful, a new script record is created with a unique
2029 script ID. If the script file is provided as a local file, the file is
2030 uploaded to an Amazon GameLift-owned S3 bucket and the script record's
2031 storage location reflects this location. If the script file is provided
2032 as an S3 bucket, Amazon GameLift accesses the file at this storage
2033 location as needed for deployment.
2034  
2035 B<Learn more>
2036  
2037 Amazon GameLift Realtime Servers
2038 (https://docs.aws.amazon.com/gamelift/latest/developerguide/realtime-intro.html)
2039  
2040 Set Up a Role for Amazon GameLift Access
2041 (https://docs.aws.amazon.com/gamelift/latest/developerguide/setting-up-role.html)
2042  
2043 B<Related actions>
2044  
2045 CreateScript | ListScripts | DescribeScript | UpdateScript |
2046 DeleteScript | All APIs by task
2047 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2048  
2049  
2050 =head2 CreateVpcPeeringAuthorization
2051  
2052 =over
2053  
2054 =item GameLiftAwsAccountId => Str
2055  
2056 =item PeerVpcId => Str
2057  
2058  
2059 =back
2060  
2061 Each argument is described in detail in: L<Paws::GameLift::CreateVpcPeeringAuthorization>
2062  
2063 Returns: a L<Paws::GameLift::CreateVpcPeeringAuthorizationOutput> instance
2064  
2065 Requests authorization to create or delete a peer connection between
2066 the VPC for your Amazon GameLift fleet and a virtual private cloud
2067 (VPC) in your AWS account. VPC peering enables the game servers on your
2068 fleet to communicate directly with other AWS resources. Once you've
2069 received authorization, call CreateVpcPeeringConnection to establish
2070 the peering connection. For more information, see VPC Peering with
2071 Amazon GameLift Fleets
2072 (https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html).
2073  
2074 You can peer with VPCs that are owned by any AWS account you have
2075 access to, including the account that you use to manage your Amazon
2076 GameLift fleets. You cannot peer with VPCs that are in different
2077 Regions.
2078  
2079 To request authorization to create a connection, call this operation
2080 from the AWS account with the VPC that you want to peer to your Amazon
2081 GameLift fleet. For example, to enable your game servers to retrieve
2082 data from a DynamoDB table, use the account that manages that DynamoDB
2083 resource. Identify the following values: (1) The ID of the VPC that you
2084 want to peer with, and (2) the ID of the AWS account that you use to
2085 manage Amazon GameLift. If successful, VPC peering is authorized for
2086 the specified VPC.
2087  
2088 To request authorization to delete a connection, call this operation
2089 from the AWS account with the VPC that is peered with your Amazon
2090 GameLift fleet. Identify the following values: (1) VPC ID that you want
2091 to delete the peering connection for, and (2) ID of the AWS account
2092 that you use to manage Amazon GameLift.
2093  
2094 The authorization remains valid for 24 hours unless it is canceled by a
2095 call to DeleteVpcPeeringAuthorization. You must create or delete the
2096 peering connection while the authorization is valid.
2097  
2098 B<Related actions>
2099  
2100 CreateVpcPeeringAuthorization | DescribeVpcPeeringAuthorizations |
2101 DeleteVpcPeeringAuthorization | CreateVpcPeeringConnection |
2102 DescribeVpcPeeringConnections | DeleteVpcPeeringConnection | All APIs
2103 by task
2104 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2105  
2106  
2107 =head2 CreateVpcPeeringConnection
2108  
2109 =over
2110  
2111 =item FleetId => Str
2112  
2113 =item PeerVpcAwsAccountId => Str
2114  
2115 =item PeerVpcId => Str
2116  
2117  
2118 =back
2119  
2120 Each argument is described in detail in: L<Paws::GameLift::CreateVpcPeeringConnection>
2121  
2122 Returns: a L<Paws::GameLift::CreateVpcPeeringConnectionOutput> instance
2123  
2124 Establishes a VPC peering connection between a virtual private cloud
2125 (VPC) in an AWS account with the VPC for your Amazon GameLift fleet.
2126 VPC peering enables the game servers on your fleet to communicate
2127 directly with other AWS resources. You can peer with VPCs in any AWS
2128 account that you have access to, including the account that you use to
2129 manage your Amazon GameLift fleets. You cannot peer with VPCs that are
2130 in different Regions. For more information, see VPC Peering with Amazon
2131 GameLift Fleets
2132 (https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html).
2133  
2134 Before calling this operation to establish the peering connection, you
2135 first need to call CreateVpcPeeringAuthorization and identify the VPC
2136 you want to peer with. Once the authorization for the specified VPC is
2137 issued, you have 24 hours to establish the connection. These two
2138 operations handle all tasks necessary to peer the two VPCs, including
2139 acceptance, updating routing tables, etc.
2140  
2141 To establish the connection, call this operation from the AWS account
2142 that is used to manage the Amazon GameLift fleets. Identify the
2143 following values: (1) The ID of the fleet you want to be enable a VPC
2144 peering connection for; (2) The AWS account with the VPC that you want
2145 to peer with; and (3) The ID of the VPC you want to peer with. This
2146 operation is asynchronous. If successful, a VpcPeeringConnection
2147 request is created. You can use continuous polling to track the
2148 request's status using DescribeVpcPeeringConnections, or by monitoring
2149 fleet events for success or failure using DescribeFleetEvents.
2150  
2151 B<Related actions>
2152  
2153 CreateVpcPeeringAuthorization | DescribeVpcPeeringAuthorizations |
2154 DeleteVpcPeeringAuthorization | CreateVpcPeeringConnection |
2155 DescribeVpcPeeringConnections | DeleteVpcPeeringConnection | All APIs
2156 by task
2157 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2158  
2159  
2160 =head2 DeleteAlias
2161  
2162 =over
2163  
2164 =item AliasId => Str
2165  
2166  
2167 =back
2168  
2169 Each argument is described in detail in: L<Paws::GameLift::DeleteAlias>
2170  
2171 Returns: nothing
2172  
2173 Deletes an alias. This operation removes all record of the alias. Game
2174 clients attempting to access a server process using the deleted alias
2175 receive an error. To delete an alias, specify the alias ID to be
2176 deleted.
2177  
2178 B<Related actions>
2179  
2180 CreateAlias | ListAliases | DescribeAlias | UpdateAlias | DeleteAlias |
2181 ResolveAlias | All APIs by task
2182 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2183  
2184  
2185 =head2 DeleteBuild
2186  
2187 =over
2188  
2189 =item BuildId => Str
2190  
2191  
2192 =back
2193  
2194 Each argument is described in detail in: L<Paws::GameLift::DeleteBuild>
2195  
2196 Returns: nothing
2197  
2198 Deletes a build. This operation permanently deletes the build resource
2199 and any uploaded build files. Deleting a build does not affect the
2200 status of any active fleets using the build, but you can no longer
2201 create new fleets with the deleted build.
2202  
2203 To delete a build, specify the build ID.
2204  
2205 B<Learn more>
2206  
2207 Upload a Custom Server Build
2208 (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-build-intro.html)
2209  
2210 B<Related actions>
2211  
2212 CreateBuild | ListBuilds | DescribeBuild | UpdateBuild | DeleteBuild |
2213 All APIs by task
2214 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2215  
2216  
2217 =head2 DeleteFleet
2218  
2219 =over
2220  
2221 =item FleetId => Str
2222  
2223  
2224 =back
2225  
2226 Each argument is described in detail in: L<Paws::GameLift::DeleteFleet>
2227  
2228 Returns: nothing
2229  
2230 Deletes all resources and information related a fleet. Any current
2231 fleet instances, including those in remote locations, are shut down.
2232 You don't need to call C<DeleteFleetLocations> separately.
2233  
2234 If the fleet being deleted has a VPC peering connection, you first need
2235 to get a valid authorization (good for 24 hours) by calling
2236 CreateVpcPeeringAuthorization. You do not need to explicitly delete the
2237 VPC peering connection--this is done as part of the delete fleet
2238 process.
2239  
2240 To delete a fleet, specify the fleet ID to be terminated. During the
2241 deletion process the fleet status is changed to C<DELETING>. When
2242 completed, the status switches to C<TERMINATED> and the fleet event
2243 C<FLEET_DELETED> is sent.
2244  
2245 B<Learn more>
2246  
2247 Setting up GameLift Fleets
2248 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
2249  
2250 B<Related actions>
2251  
2252 CreateFleetLocations | UpdateFleetAttributes | UpdateFleetCapacity |
2253 UpdateFleetPortSettings | UpdateRuntimeConfiguration | StopFleetActions
2254 | StartFleetActions | PutScalingPolicy | DeleteFleet |
2255 DeleteFleetLocations | DeleteScalingPolicy | All APIs by task
2256 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2257  
2258  
2259 =head2 DeleteFleetLocations
2260  
2261 =over
2262  
2263 =item FleetId => Str
2264  
2265 =item Locations => ArrayRef[Str|Undef]
2266  
2267  
2268 =back
2269  
2270 Each argument is described in detail in: L<Paws::GameLift::DeleteFleetLocations>
2271  
2272 Returns: a L<Paws::GameLift::DeleteFleetLocationsOutput> instance
2273  
2274 Removes locations from a multi-location fleet. When deleting a
2275 location, all game server process and all instances that are still
2276 active in the location are shut down.
2277  
2278 To delete fleet locations, identify the fleet ID and provide a list of
2279 the locations to be deleted.
2280  
2281 If successful, GameLift sets the location status to C<DELETING>, and
2282 begins to shut down existing server processes and terminate instances
2283 in each location being deleted. When completed, the location status
2284 changes to C<TERMINATED>.
2285  
2286 B<Learn more>
2287  
2288 Setting up GameLift fleets
2289 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
2290  
2291 B<Related actions>
2292  
2293 CreateFleetLocations | DescribeFleetLocationAttributes |
2294 DescribeFleetLocationCapacity | DescribeFleetLocationUtilization |
2295 DescribeFleetAttributes | DescribeFleetCapacity |
2296 DescribeFleetUtilization | UpdateFleetCapacity | StopFleetActions |
2297 DeleteFleetLocations | All APIs by task
2298 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2299  
2300  
2301 =head2 DeleteGameServerGroup
2302  
2303 =over
2304  
2305 =item GameServerGroupName => Str
2306  
2307 =item [DeleteOption => Str]
2308  
2309  
2310 =back
2311  
2312 Each argument is described in detail in: L<Paws::GameLift::DeleteGameServerGroup>
2313  
2314 Returns: a L<Paws::GameLift::DeleteGameServerGroupOutput> instance
2315  
2316 B<This operation is used with the GameLift FleetIQ solution and game
2317 server groups.>
2318  
2319 Terminates a game server group and permanently deletes the game server
2320 group record. You have several options for how these resources are
2321 impacted when deleting the game server group. Depending on the type of
2322 delete operation selected, this operation might affect these resources:
2323  
2324 =over
2325  
2326 =item *
2327  
2328 The game server group
2329  
2330 =item *
2331  
2332 The corresponding Auto Scaling group
2333  
2334 =item *
2335  
2336 All game servers that are currently running in the group
2337  
2338 =back
2339  
2340 To delete a game server group, identify the game server group to delete
2341 and specify the type of delete operation to initiate. Game server
2342 groups can only be deleted if they are in C<ACTIVE> or C<ERROR> status.
2343  
2344 If the delete request is successful, a series of operations are kicked
2345 off. The game server group status is changed to C<DELETE_SCHEDULED>,
2346 which prevents new game servers from being registered and stops
2347 automatic scaling activity. Once all game servers in the game server
2348 group are deregistered, GameLift FleetIQ can begin deleting resources.
2349 If any of the delete operations fail, the game server group is placed
2350 in C<ERROR> status.
2351  
2352 GameLift FleetIQ emits delete events to Amazon CloudWatch.
2353  
2354 B<Learn more>
2355  
2356 GameLift FleetIQ Guide
2357 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
2358  
2359 B<Related actions>
2360  
2361 CreateGameServerGroup | ListGameServerGroups | DescribeGameServerGroup
2362 | UpdateGameServerGroup | DeleteGameServerGroup | ResumeGameServerGroup
2363 | SuspendGameServerGroup | DescribeGameServerInstances | All APIs by
2364 task
2365 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
2366  
2367  
2368 =head2 DeleteGameSessionQueue
2369  
2370 =over
2371  
2372 =item Name => Str
2373  
2374  
2375 =back
2376  
2377 Each argument is described in detail in: L<Paws::GameLift::DeleteGameSessionQueue>
2378  
2379 Returns: a L<Paws::GameLift::DeleteGameSessionQueueOutput> instance
2380  
2381 Deletes a game session queue. Once a queue is successfully deleted,
2382 unfulfilled StartGameSessionPlacement requests that reference the queue
2383 will fail. To delete a queue, specify the queue name.
2384  
2385 B<Learn more>
2386  
2387 Using Multi-Region Queues
2388 (https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-intro.html)
2389  
2390 B<Related actions>
2391  
2392 CreateGameSessionQueue | DescribeGameSessionQueues |
2393 UpdateGameSessionQueue | DeleteGameSessionQueue | All APIs by task
2394 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2395  
2396  
2397 =head2 DeleteMatchmakingConfiguration
2398  
2399 =over
2400  
2401 =item Name => Str
2402  
2403  
2404 =back
2405  
2406 Each argument is described in detail in: L<Paws::GameLift::DeleteMatchmakingConfiguration>
2407  
2408 Returns: a L<Paws::GameLift::DeleteMatchmakingConfigurationOutput> instance
2409  
2410 Permanently removes a FlexMatch matchmaking configuration. To delete,
2411 specify the configuration name. A matchmaking configuration cannot be
2412 deleted if it is being used in any active matchmaking tickets.
2413  
2414 B<Related actions>
2415  
2416 CreateMatchmakingConfiguration | DescribeMatchmakingConfigurations |
2417 UpdateMatchmakingConfiguration | DeleteMatchmakingConfiguration |
2418 CreateMatchmakingRuleSet | DescribeMatchmakingRuleSets |
2419 ValidateMatchmakingRuleSet | DeleteMatchmakingRuleSet | All APIs by
2420 task
2421 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2422  
2423  
2424 =head2 DeleteMatchmakingRuleSet
2425  
2426 =over
2427  
2428 =item Name => Str
2429  
2430  
2431 =back
2432  
2433 Each argument is described in detail in: L<Paws::GameLift::DeleteMatchmakingRuleSet>
2434  
2435 Returns: a L<Paws::GameLift::DeleteMatchmakingRuleSetOutput> instance
2436  
2437 Deletes an existing matchmaking rule set. To delete the rule set,
2438 provide the rule set name. Rule sets cannot be deleted if they are
2439 currently being used by a matchmaking configuration.
2440  
2441 B<Learn more>
2442  
2443 =over
2444  
2445 =item *
2446  
2447 Build a rule set
2448 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-rulesets.html)
2449  
2450 =back
2451  
2452 B<Related actions>
2453  
2454 CreateMatchmakingConfiguration | DescribeMatchmakingConfigurations |
2455 UpdateMatchmakingConfiguration | DeleteMatchmakingConfiguration |
2456 CreateMatchmakingRuleSet | DescribeMatchmakingRuleSets |
2457 ValidateMatchmakingRuleSet | DeleteMatchmakingRuleSet | All APIs by
2458 task
2459 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2460  
2461  
2462 =head2 DeleteScalingPolicy
2463  
2464 =over
2465  
2466 =item FleetId => Str
2467  
2468 =item Name => Str
2469  
2470  
2471 =back
2472  
2473 Each argument is described in detail in: L<Paws::GameLift::DeleteScalingPolicy>
2474  
2475 Returns: nothing
2476  
2477 Deletes a fleet scaling policy. Once deleted, the policy is no longer
2478 in force and GameLift removes all record of it. To delete a scaling
2479 policy, specify both the scaling policy name and the fleet ID it is
2480 associated with.
2481  
2482 To temporarily suspend scaling policies, call StopFleetActions. This
2483 operation suspends all policies for the fleet.
2484  
2485 B<Related actions>
2486  
2487 DescribeFleetCapacity | UpdateFleetCapacity | DescribeEC2InstanceLimits
2488 | PutScalingPolicy | DescribeScalingPolicies | DeleteScalingPolicy |
2489 StopFleetActions | StartFleetActions | All APIs by task
2490 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2491  
2492  
2493 =head2 DeleteScript
2494  
2495 =over
2496  
2497 =item ScriptId => Str
2498  
2499  
2500 =back
2501  
2502 Each argument is described in detail in: L<Paws::GameLift::DeleteScript>
2503  
2504 Returns: nothing
2505  
2506 Deletes a Realtime script. This operation permanently deletes the
2507 script record. If script files were uploaded, they are also deleted
2508 (files stored in an S3 bucket are not deleted).
2509  
2510 To delete a script, specify the script ID. Before deleting a script, be
2511 sure to terminate all fleets that are deployed with the script being
2512 deleted. Fleet instances periodically check for script updates, and if
2513 the script record no longer exists, the instance will go into an error
2514 state and be unable to host game sessions.
2515  
2516 B<Learn more>
2517  
2518 Amazon GameLift Realtime Servers
2519 (https://docs.aws.amazon.com/gamelift/latest/developerguide/realtime-intro.html)
2520  
2521 B<Related actions>
2522  
2523 CreateScript | ListScripts | DescribeScript | UpdateScript |
2524 DeleteScript | All APIs by task
2525 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2526  
2527  
2528 =head2 DeleteVpcPeeringAuthorization
2529  
2530 =over
2531  
2532 =item GameLiftAwsAccountId => Str
2533  
2534 =item PeerVpcId => Str
2535  
2536  
2537 =back
2538  
2539 Each argument is described in detail in: L<Paws::GameLift::DeleteVpcPeeringAuthorization>
2540  
2541 Returns: a L<Paws::GameLift::DeleteVpcPeeringAuthorizationOutput> instance
2542  
2543 Cancels a pending VPC peering authorization for the specified VPC. If
2544 you need to delete an existing VPC peering connection, call
2545 DeleteVpcPeeringConnection.
2546  
2547 B<Related actions>
2548  
2549 CreateVpcPeeringAuthorization | DescribeVpcPeeringAuthorizations |
2550 DeleteVpcPeeringAuthorization | CreateVpcPeeringConnection |
2551 DescribeVpcPeeringConnections | DeleteVpcPeeringConnection | All APIs
2552 by task
2553 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2554  
2555  
2556 =head2 DeleteVpcPeeringConnection
2557  
2558 =over
2559  
2560 =item FleetId => Str
2561  
2562 =item VpcPeeringConnectionId => Str
2563  
2564  
2565 =back
2566  
2567 Each argument is described in detail in: L<Paws::GameLift::DeleteVpcPeeringConnection>
2568  
2569 Returns: a L<Paws::GameLift::DeleteVpcPeeringConnectionOutput> instance
2570  
2571 Removes a VPC peering connection. To delete the connection, you must
2572 have a valid authorization for the VPC peering connection that you want
2573 to delete. You can check for an authorization by calling
2574 DescribeVpcPeeringAuthorizations or request a new one using
2575 CreateVpcPeeringAuthorization.
2576  
2577 Once a valid authorization exists, call this operation from the AWS
2578 account that is used to manage the Amazon GameLift fleets. Identify the
2579 connection to delete by the connection ID and fleet ID. If successful,
2580 the connection is removed.
2581  
2582 B<Related actions>
2583  
2584 CreateVpcPeeringAuthorization | DescribeVpcPeeringAuthorizations |
2585 DeleteVpcPeeringAuthorization | CreateVpcPeeringConnection |
2586 DescribeVpcPeeringConnections | DeleteVpcPeeringConnection | All APIs
2587 by task
2588 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2589  
2590  
2591 =head2 DeregisterGameServer
2592  
2593 =over
2594  
2595 =item GameServerGroupName => Str
2596  
2597 =item GameServerId => Str
2598  
2599  
2600 =back
2601  
2602 Each argument is described in detail in: L<Paws::GameLift::DeregisterGameServer>
2603  
2604 Returns: nothing
2605  
2606 B<This operation is used with the GameLift FleetIQ solution and game
2607 server groups.>
2608  
2609 Removes the game server from a game server group. As a result of this
2610 operation, the deregistered game server can no longer be claimed and
2611 will not be returned in a list of active game servers.
2612  
2613 To deregister a game server, specify the game server group and game
2614 server ID. If successful, this operation emits a CloudWatch event with
2615 termination timestamp and reason.
2616  
2617 B<Learn more>
2618  
2619 GameLift FleetIQ Guide
2620 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
2621  
2622 B<Related actions>
2623  
2624 RegisterGameServer | ListGameServers | ClaimGameServer |
2625 DescribeGameServer | UpdateGameServer | DeregisterGameServer | All APIs
2626 by task
2627 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
2628  
2629  
2630 =head2 DescribeAlias
2631  
2632 =over
2633  
2634 =item AliasId => Str
2635  
2636  
2637 =back
2638  
2639 Each argument is described in detail in: L<Paws::GameLift::DescribeAlias>
2640  
2641 Returns: a L<Paws::GameLift::DescribeAliasOutput> instance
2642  
2643 Retrieves properties for an alias. This operation returns all alias
2644 metadata and settings. To get an alias's target fleet ID only, use
2645 C<ResolveAlias>.
2646  
2647 To get alias properties, specify the alias ID. If successful, the
2648 requested alias record is returned.
2649  
2650 B<Related actions>
2651  
2652 CreateAlias | ListAliases | DescribeAlias | UpdateAlias | DeleteAlias |
2653 ResolveAlias | All APIs by task
2654 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2655  
2656  
2657 =head2 DescribeBuild
2658  
2659 =over
2660  
2661 =item BuildId => Str
2662  
2663  
2664 =back
2665  
2666 Each argument is described in detail in: L<Paws::GameLift::DescribeBuild>
2667  
2668 Returns: a L<Paws::GameLift::DescribeBuildOutput> instance
2669  
2670 Retrieves properties for a custom game build. To request a build
2671 resource, specify a build ID. If successful, an object containing the
2672 build properties is returned.
2673  
2674 B<Learn more>
2675  
2676 Upload a Custom Server Build
2677 (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-build-intro.html)
2678  
2679 B<Related actions>
2680  
2681 CreateBuild | ListBuilds | DescribeBuild | UpdateBuild | DeleteBuild |
2682 All APIs by task
2683 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2684  
2685  
2686 =head2 DescribeEC2InstanceLimits
2687  
2688 =over
2689  
2690 =item [EC2InstanceType => Str]
2691  
2692 =item [Location => Str]
2693  
2694  
2695 =back
2696  
2697 Each argument is described in detail in: L<Paws::GameLift::DescribeEC2InstanceLimits>
2698  
2699 Returns: a L<Paws::GameLift::DescribeEC2InstanceLimitsOutput> instance
2700  
2701 The GameLift service limits and current utilization for an AWS Region
2702 or location. Instance limits control the number of instances, per
2703 instance type, per location, that your AWS account can use. Learn more
2704 at Amazon EC2 Instance Types
2705 (http://aws.amazon.com/ec2/instance-types/). The information returned
2706 includes the maximum number of instances allowed and your account's
2707 current usage across all fleets. This information can affect your
2708 ability to scale your GameLift fleets. You can request a limit increase
2709 for your account by using the B<Service limits> page in the GameLift
2710 console.
2711  
2712 Instance limits differ based on whether the instances are deployed in a
2713 fleet's home Region or in a remote location. For remote locations,
2714 limits also differ based on the combination of home Region and remote
2715 location. All requests must specify an AWS Region (either explicitly or
2716 as your default settings). To get the limit for a remote location, you
2717 must also specify the location. For example, the following requests all
2718 return different results:
2719  
2720 =over
2721  
2722 =item *
2723  
2724 Request specifies the Region C<ap-northeast-1> with no location. The
2725 result is limits and usage data on all instance types that are deployed
2726 in C<us-east-2>, by all of the fleets that reside in C<ap-northeast-1>.
2727  
2728 =item *
2729  
2730 Request specifies the Region C<us-east-1> with location
2731 C<ca-central-1>. The result is limits and usage data on all instance
2732 types that are deployed in C<ca-central-1>, by all of the fleets that
2733 reside in C<us-east-2>. These limits do not affect fleets in any other
2734 Regions that deploy instances to C<ca-central-1>.
2735  
2736 =item *
2737  
2738 Request specifies the Region C<eu-west-1> with location
2739 C<ca-central-1>. The result is limits and usage data on all instance
2740 types that are deployed in C<ca-central-1>, by all of the fleets that
2741 reside in C<eu-west-1>.
2742  
2743 =back
2744  
2745 This operation can be used in the following ways:
2746  
2747 =over
2748  
2749 =item *
2750  
2751 To get limit and usage data for all instance types that are deployed in
2752 an AWS Region by fleets that reside in the same Region: Specify the
2753 Region only. Optionally, specify a single instance type to retrieve
2754 information for.
2755  
2756 =item *
2757  
2758 To get limit and usage data for all instance types that are deployed to
2759 a remote location by fleets that reside in different AWS Region:
2760 Provide both the AWS Region and the remote location. Optionally,
2761 specify a single instance type to retrieve information for.
2762  
2763 =back
2764  
2765 If successful, an C<EC2InstanceLimits> object is returned with limits
2766 and usage data for each requested instance type.
2767  
2768 B<Learn more>
2769  
2770 Setting up GameLift fleets
2771 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
2772  
2773 B<Related actions>
2774  
2775 CreateFleet | UpdateFleetCapacity | PutScalingPolicy |
2776 DescribeEC2InstanceLimits | DescribeFleetAttributes |
2777 DescribeFleetLocationAttributes | UpdateFleetAttributes |
2778 StopFleetActions | DeleteFleet | All APIs by task
2779 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2780  
2781  
2782 =head2 DescribeFleetAttributes
2783  
2784 =over
2785  
2786 =item [FleetIds => ArrayRef[Str|Undef]]
2787  
2788 =item [Limit => Int]
2789  
2790 =item [NextToken => Str]
2791  
2792  
2793 =back
2794  
2795 Each argument is described in detail in: L<Paws::GameLift::DescribeFleetAttributes>
2796  
2797 Returns: a L<Paws::GameLift::DescribeFleetAttributesOutput> instance
2798  
2799 Retrieves core fleet-wide properties, including the computing hardware
2800 and deployment configuration for all instances in the fleet.
2801  
2802 This operation can be used in the following ways:
2803  
2804 =over
2805  
2806 =item *
2807  
2808 To get attributes for one or more specific fleets, provide a list of
2809 fleet IDs or fleet ARNs.
2810  
2811 =item *
2812  
2813 To get attributes for all fleets, do not provide a fleet identifier.
2814  
2815 =back
2816  
2817 When requesting attributes for multiple fleets, use the pagination
2818 parameters to retrieve results as a set of sequential pages.
2819  
2820 If successful, a C<FleetAttributes> object is returned for each fleet
2821 requested, unless the fleet identifier is not found.
2822  
2823 Some API operations limit the number of fleet IDs that allowed in one
2824 request. If a request exceeds this limit, the request fails and the
2825 error message contains the maximum allowed number.
2826  
2827 B<Learn more>
2828  
2829 Setting up GameLift fleets
2830 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
2831  
2832 B<Related actions>
2833  
2834 ListFleets | DescribeEC2InstanceLimits | DescribeFleetAttributes |
2835 DescribeFleetCapacity | DescribeFleetEvents |
2836 DescribeFleetLocationAttributes | DescribeFleetPortSettings |
2837 DescribeFleetUtilization | DescribeRuntimeConfiguration |
2838 DescribeScalingPolicies | All APIs by task
2839 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2840  
2841  
2842 =head2 DescribeFleetCapacity
2843  
2844 =over
2845  
2846 =item [FleetIds => ArrayRef[Str|Undef]]
2847  
2848 =item [Limit => Int]
2849  
2850 =item [NextToken => Str]
2851  
2852  
2853 =back
2854  
2855 Each argument is described in detail in: L<Paws::GameLift::DescribeFleetCapacity>
2856  
2857 Returns: a L<Paws::GameLift::DescribeFleetCapacityOutput> instance
2858  
2859 Retrieves the resource capacity settings for one or more fleets. The
2860 data returned includes the current fleet capacity (number of EC2
2861 instances), and settings that can control how capacity scaling. For
2862 fleets with remote locations, this operation retrieves data for the
2863 fleet's home Region only. See DescribeFleetLocationCapacity to get
2864 capacity settings for a fleet's remote locations.
2865  
2866 This operation can be used in the following ways:
2867  
2868 =over
2869  
2870 =item *
2871  
2872 To get capacity data for one or more specific fleets, provide a list of
2873 fleet IDs or fleet ARNs.
2874  
2875 =item *
2876  
2877 To get capacity data for all fleets, do not provide a fleet identifier.
2878  
2879 =back
2880  
2881 When requesting multiple fleets, use the pagination parameters to
2882 retrieve results as a set of sequential pages.
2883  
2884 If successful, a FleetCapacity object is returned for each requested
2885 fleet ID. Each FleetCapacity object includes a C<Location> property,
2886 which is set to the fleet's home Region. When a list of fleet IDs is
2887 provided, attribute objects are returned only for fleets that currently
2888 exist.
2889  
2890 Some API operations may limit the number of fleet IDs that are allowed
2891 in one request. If a request exceeds this limit, the request fails and
2892 the error message includes the maximum allowed.
2893  
2894 B<Learn more>
2895  
2896 Setting up GameLift fleets
2897 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
2898  
2899 GameLift metrics for fleets
2900 (https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html#gamelift-metrics-fleet)
2901  
2902 B<Related actions>
2903  
2904 ListFleets | DescribeEC2InstanceLimits | DescribeFleetAttributes |
2905 DescribeFleetCapacity | DescribeFleetEvents |
2906 DescribeFleetLocationAttributes | DescribeFleetPortSettings |
2907 DescribeFleetUtilization | DescribeRuntimeConfiguration |
2908 DescribeScalingPolicies | All APIs by task
2909 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2910  
2911  
2912 =head2 DescribeFleetEvents
2913  
2914 =over
2915  
2916 =item FleetId => Str
2917  
2918 =item [EndTime => Str]
2919  
2920 =item [Limit => Int]
2921  
2922 =item [NextToken => Str]
2923  
2924 =item [StartTime => Str]
2925  
2926  
2927 =back
2928  
2929 Each argument is described in detail in: L<Paws::GameLift::DescribeFleetEvents>
2930  
2931 Returns: a L<Paws::GameLift::DescribeFleetEventsOutput> instance
2932  
2933 Retrieves entries from a fleet's event log. Fleet events are initiated
2934 by changes in status, such as during fleet creation and termination,
2935 changes in capacity, etc. If a fleet has multiple locations, events are
2936 also initiated by changes to status and capacity in remote locations.
2937  
2938 You can specify a time range to limit the result set. Use the
2939 pagination parameters to retrieve results as a set of sequential pages.
2940  
2941 If successful, a collection of event log entries matching the request
2942 are returned.
2943  
2944 B<Learn more>
2945  
2946 Setting up GameLift fleets
2947 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
2948  
2949 B<Related actions>
2950  
2951 ListFleets | DescribeEC2InstanceLimits | DescribeFleetAttributes |
2952 DescribeFleetCapacity | DescribeFleetEvents |
2953 DescribeFleetLocationAttributes | DescribeFleetPortSettings |
2954 DescribeFleetUtilization | DescribeRuntimeConfiguration |
2955 DescribeScalingPolicies | All APIs by task
2956 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
2957  
2958  
2959 =head2 DescribeFleetLocationAttributes
2960  
2961 =over
2962  
2963 =item FleetId => Str
2964  
2965 =item [Limit => Int]
2966  
2967 =item [Locations => ArrayRef[Str|Undef]]
2968  
2969 =item [NextToken => Str]
2970  
2971  
2972 =back
2973  
2974 Each argument is described in detail in: L<Paws::GameLift::DescribeFleetLocationAttributes>
2975  
2976 Returns: a L<Paws::GameLift::DescribeFleetLocationAttributesOutput> instance
2977  
2978 Retrieves information on a fleet's remote locations, including
2979 life-cycle status and any suspended fleet activity.
2980  
2981 This operation can be used in the following ways:
2982  
2983 =over
2984  
2985 =item *
2986  
2987 To get data for specific locations, provide a fleet identifier and a
2988 list of locations. Location data is returned in the order that it is
2989 requested.
2990  
2991 =item *
2992  
2993 To get data for all locations, provide a fleet identifier only.
2994 Location data is returned in no particular order.
2995  
2996 =back
2997  
2998 When requesting attributes for multiple locations, use the pagination
2999 parameters to retrieve results as a set of sequential pages.
3000  
3001 If successful, a C<LocationAttributes> object is returned for each
3002 requested location. If the fleet does not have a requested location, no
3003 information is returned. This operation does not return the home
3004 Region. To get information on a fleet's home Region, call
3005 C<DescribeFleetAttributes>.
3006  
3007 B<Learn more>
3008  
3009 Setting up GameLift fleets
3010 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
3011  
3012 B<Related actions>
3013  
3014 CreateFleetLocations | DescribeFleetLocationAttributes |
3015 DescribeFleetLocationCapacity | DescribeFleetLocationUtilization |
3016 DescribeFleetAttributes | DescribeFleetCapacity |
3017 DescribeFleetUtilization | UpdateFleetCapacity | StopFleetActions |
3018 DeleteFleetLocations | All APIs by task
3019 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3020  
3021  
3022 =head2 DescribeFleetLocationCapacity
3023  
3024 =over
3025  
3026 =item FleetId => Str
3027  
3028 =item Location => Str
3029  
3030  
3031 =back
3032  
3033 Each argument is described in detail in: L<Paws::GameLift::DescribeFleetLocationCapacity>
3034  
3035 Returns: a L<Paws::GameLift::DescribeFleetLocationCapacityOutput> instance
3036  
3037 Retrieves the resource capacity settings for a fleet location. The data
3038 returned includes the current capacity (number of EC2 instances) and
3039 some scaling settings for the requested fleet location. Use this
3040 operation to retrieve capacity information for a fleet's remote
3041 location or home Region (you can also retrieve home Region capacity by
3042 calling C<DescribeFleetCapacity>).
3043  
3044 To retrieve capacity data, identify a fleet and location.
3045  
3046 If successful, a C<FleetCapacity> object is returned for the requested
3047 fleet location.
3048  
3049 B<Learn more>
3050  
3051 Setting up GameLift fleets
3052 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
3053  
3054 GameLift metrics for fleets
3055 (https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html#gamelift-metrics-fleet)
3056  
3057 B<Related actions>
3058  
3059 CreateFleetLocations | DescribeFleetLocationAttributes |
3060 DescribeFleetLocationCapacity | DescribeFleetLocationUtilization |
3061 DescribeFleetAttributes | DescribeFleetCapacity |
3062 DescribeFleetUtilization | UpdateFleetCapacity | StopFleetActions |
3063 DeleteFleetLocations | All APIs by task
3064 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3065  
3066  
3067 =head2 DescribeFleetLocationUtilization
3068  
3069 =over
3070  
3071 =item FleetId => Str
3072  
3073 =item Location => Str
3074  
3075  
3076 =back
3077  
3078 Each argument is described in detail in: L<Paws::GameLift::DescribeFleetLocationUtilization>
3079  
3080 Returns: a L<Paws::GameLift::DescribeFleetLocationUtilizationOutput> instance
3081  
3082 Retrieves current usage data for a fleet location. Utilization data
3083 provides a snapshot of current game hosting activity at the requested
3084 location. Use this operation to retrieve utilization information for a
3085 fleet's remote location or home Region (you can also retrieve home
3086 Region utilization by calling C<DescribeFleetUtilization>).
3087  
3088 To retrieve utilization data, identify a fleet and location.
3089  
3090 If successful, a C<FleetUtilization> object is returned for the
3091 requested fleet location.
3092  
3093 B<Learn more>
3094  
3095 Setting up GameLift fleets
3096 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
3097  
3098 GameLift metrics for fleets
3099 (https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html#gamelift-metrics-fleet)
3100  
3101 B<Related actions>
3102  
3103 CreateFleetLocations | DescribeFleetLocationAttributes |
3104 DescribeFleetLocationCapacity | DescribeFleetLocationUtilization |
3105 DescribeFleetAttributes | DescribeFleetCapacity |
3106 DescribeFleetUtilization | UpdateFleetCapacity | StopFleetActions |
3107 DeleteFleetLocations | All APIs by task
3108 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3109  
3110  
3111 =head2 DescribeFleetPortSettings
3112  
3113 =over
3114  
3115 =item FleetId => Str
3116  
3117 =item [Location => Str]
3118  
3119  
3120 =back
3121  
3122 Each argument is described in detail in: L<Paws::GameLift::DescribeFleetPortSettings>
3123  
3124 Returns: a L<Paws::GameLift::DescribeFleetPortSettingsOutput> instance
3125  
3126 Retrieves a fleet's inbound connection permissions. Connection
3127 permissions specify the range of IP addresses and port settings that
3128 incoming traffic can use to access server processes in the fleet. Game
3129 sessions that are running on instances in the fleet must use
3130 connections that fall in this range.
3131  
3132 This operation can be used in the following ways:
3133  
3134 =over
3135  
3136 =item *
3137  
3138 To retrieve the inbound connection permissions for a fleet, identify
3139 the fleet's unique identifier.
3140  
3141 =item *
3142  
3143 To check the status of recent updates to a fleet remote location,
3144 specify the fleet ID and a location. Port setting updates can take time
3145 to propagate across all locations.
3146  
3147 =back
3148  
3149 If successful, a set of IpPermission objects is returned for the
3150 requested fleet ID. When a location is specified, a pending status is
3151 included. If the requested fleet has been deleted, the result set is
3152 empty.
3153  
3154 B<Learn more>
3155  
3156 Setting up GameLift fleets
3157 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
3158  
3159 B<Related actions>
3160  
3161 ListFleets | DescribeEC2InstanceLimits | DescribeFleetAttributes |
3162 DescribeFleetCapacity | DescribeFleetEvents |
3163 DescribeFleetLocationAttributes | DescribeFleetPortSettings |
3164 DescribeFleetUtilization | DescribeRuntimeConfiguration |
3165 DescribeScalingPolicies | All APIs by task
3166 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3167  
3168  
3169 =head2 DescribeFleetUtilization
3170  
3171 =over
3172  
3173 =item [FleetIds => ArrayRef[Str|Undef]]
3174  
3175 =item [Limit => Int]
3176  
3177 =item [NextToken => Str]
3178  
3179  
3180 =back
3181  
3182 Each argument is described in detail in: L<Paws::GameLift::DescribeFleetUtilization>
3183  
3184 Returns: a L<Paws::GameLift::DescribeFleetUtilizationOutput> instance
3185  
3186 Retrieves utilization statistics for one or more fleets. Utilization
3187 data provides a snapshot of how the fleet's hosting resources are
3188 currently being used. For fleets with remote locations, this operation
3189 retrieves data for the fleet's home Region only. See
3190 DescribeFleetLocationUtilization to get utilization statistics for a
3191 fleet's remote locations.
3192  
3193 This operation can be used in the following ways:
3194  
3195 =over
3196  
3197 =item *
3198  
3199 To get utilization data for one or more specific fleets, provide a list
3200 of fleet IDs or fleet ARNs.
3201  
3202 =item *
3203  
3204 To get utilization data for all fleets, do not provide a fleet
3205 identifier.
3206  
3207 =back
3208  
3209 When requesting multiple fleets, use the pagination parameters to
3210 retrieve results as a set of sequential pages.
3211  
3212 If successful, a FleetUtilization object is returned for each requested
3213 fleet ID, unless the fleet identifier is not found. Each fleet
3214 utilization object includes a C<Location> property, which is set to the
3215 fleet's home Region.
3216  
3217 Some API operations may limit the number of fleet IDs allowed in one
3218 request. If a request exceeds this limit, the request fails and the
3219 error message includes the maximum allowed.
3220  
3221 B<Learn more>
3222  
3223 Setting up GameLift Fleets
3224 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
3225  
3226 GameLift Metrics for Fleets
3227 (https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html#gamelift-metrics-fleet)
3228  
3229 B<Related actions>
3230  
3231 ListFleets | DescribeEC2InstanceLimits | DescribeFleetAttributes |
3232 DescribeFleetCapacity | DescribeFleetEvents |
3233 DescribeFleetLocationAttributes | DescribeFleetPortSettings |
3234 DescribeFleetUtilization | DescribeRuntimeConfiguration |
3235 DescribeScalingPolicies | All APIs by task
3236 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3237  
3238  
3239 =head2 DescribeGameServer
3240  
3241 =over
3242  
3243 =item GameServerGroupName => Str
3244  
3245 =item GameServerId => Str
3246  
3247  
3248 =back
3249  
3250 Each argument is described in detail in: L<Paws::GameLift::DescribeGameServer>
3251  
3252 Returns: a L<Paws::GameLift::DescribeGameServerOutput> instance
3253  
3254 B<This operation is used with the GameLift FleetIQ solution and game
3255 server groups.>
3256  
3257 Retrieves information for a registered game server. Information
3258 includes game server status, health check info, and the instance that
3259 the game server is running on.
3260  
3261 To retrieve game server information, specify the game server ID. If
3262 successful, the requested game server object is returned.
3263  
3264 B<Learn more>
3265  
3266 GameLift FleetIQ Guide
3267 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
3268  
3269 B<Related actions>
3270  
3271 RegisterGameServer | ListGameServers | ClaimGameServer |
3272 DescribeGameServer | UpdateGameServer | DeregisterGameServer | All APIs
3273 by task
3274 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
3275  
3276  
3277 =head2 DescribeGameServerGroup
3278  
3279 =over
3280  
3281 =item GameServerGroupName => Str
3282  
3283  
3284 =back
3285  
3286 Each argument is described in detail in: L<Paws::GameLift::DescribeGameServerGroup>
3287  
3288 Returns: a L<Paws::GameLift::DescribeGameServerGroupOutput> instance
3289  
3290 B<This operation is used with the GameLift FleetIQ solution and game
3291 server groups.>
3292  
3293 Retrieves information on a game server group. This operation returns
3294 only properties related to GameLift FleetIQ. To view or update
3295 properties for the corresponding Auto Scaling group, such as launch
3296 template, auto scaling policies, and maximum/minimum group size, access
3297 the Auto Scaling group directly.
3298  
3299 To get attributes for a game server group, provide a group name or ARN
3300 value. If successful, a GameServerGroup object is returned.
3301  
3302 B<Learn more>
3303  
3304 GameLift FleetIQ Guide
3305 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
3306  
3307 B<Related actions>
3308  
3309 CreateGameServerGroup | ListGameServerGroups | DescribeGameServerGroup
3310 | UpdateGameServerGroup | DeleteGameServerGroup | ResumeGameServerGroup
3311 | SuspendGameServerGroup | DescribeGameServerInstances | All APIs by
3312 task
3313 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
3314  
3315  
3316 =head2 DescribeGameServerInstances
3317  
3318 =over
3319  
3320 =item GameServerGroupName => Str
3321  
3322 =item [InstanceIds => ArrayRef[Str|Undef]]
3323  
3324 =item [Limit => Int]
3325  
3326 =item [NextToken => Str]
3327  
3328  
3329 =back
3330  
3331 Each argument is described in detail in: L<Paws::GameLift::DescribeGameServerInstances>
3332  
3333 Returns: a L<Paws::GameLift::DescribeGameServerInstancesOutput> instance
3334  
3335 B<This operation is used with the GameLift FleetIQ solution and game
3336 server groups.>
3337  
3338 Retrieves status information about the Amazon EC2 instances associated
3339 with a GameLift FleetIQ game server group. Use this operation to detect
3340 when instances are active or not available to host new game servers. If
3341 you are looking for instance configuration information, call
3342 DescribeGameServerGroup or access the corresponding Auto Scaling group
3343 properties.
3344  
3345 To request status for all instances in the game server group, provide a
3346 game server group ID only. To request status for specific instances,
3347 provide the game server group ID and one or more instance IDs. Use the
3348 pagination parameters to retrieve results in sequential segments. If
3349 successful, a collection of C<GameServerInstance> objects is returned.
3350  
3351 This operation is not designed to be called with every game server
3352 claim request; this practice can cause you to exceed your API limit,
3353 which results in errors. Instead, as a best practice, cache the results
3354 and refresh your cache no more than once every 10 seconds.
3355  
3356 B<Learn more>
3357  
3358 GameLift FleetIQ Guide
3359 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
3360  
3361 B<Related actions>
3362  
3363 CreateGameServerGroup | ListGameServerGroups | DescribeGameServerGroup
3364 | UpdateGameServerGroup | DeleteGameServerGroup | ResumeGameServerGroup
3365 | SuspendGameServerGroup | DescribeGameServerInstances | All APIs by
3366 task
3367 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
3368  
3369  
3370 =head2 DescribeGameSessionDetails
3371  
3372 =over
3373  
3374 =item [AliasId => Str]
3375  
3376 =item [FleetId => Str]
3377  
3378 =item [GameSessionId => Str]
3379  
3380 =item [Limit => Int]
3381  
3382 =item [Location => Str]
3383  
3384 =item [NextToken => Str]
3385  
3386 =item [StatusFilter => Str]
3387  
3388  
3389 =back
3390  
3391 Each argument is described in detail in: L<Paws::GameLift::DescribeGameSessionDetails>
3392  
3393 Returns: a L<Paws::GameLift::DescribeGameSessionDetailsOutput> instance
3394  
3395 Retrieves additional game session properties, including the game
3396 session protection policy in force, a set of one or more game sessions
3397 in a specific fleet location. You can optionally filter the results by
3398 current game session status. Alternatively, use SearchGameSessions to
3399 request a set of active game sessions that are filtered by certain
3400 criteria. To retrieve all game session properties, use
3401 DescribeGameSessions.
3402  
3403 This operation can be used in the following ways:
3404  
3405 =over
3406  
3407 =item *
3408  
3409 To retrieve details for all game sessions that are currently running on
3410 all locations in a fleet, provide a fleet or alias ID, with an optional
3411 status filter. This approach returns details from the fleet's home
3412 Region and all remote locations.
3413  
3414 =item *
3415  
3416 To retrieve details for all game sessions that are currently running on
3417 a specific fleet location, provide a fleet or alias ID and a location
3418 name, with optional status filter. The location can be the fleet's home
3419 Region or any remote location.
3420  
3421 =item *
3422  
3423 To retrieve details for a specific game session, provide the game
3424 session ID. This approach looks for the game session ID in all fleets
3425 that reside in the AWS Region defined in the request.
3426  
3427 =back
3428  
3429 Use the pagination parameters to retrieve results as a set of
3430 sequential pages.
3431  
3432 If successful, a C<GameSessionDetail> object is returned for each game
3433 session that matches the request.
3434  
3435 B<Learn more>
3436  
3437 Find a game session
3438 (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-client-api.html#gamelift-sdk-client-api-find)
3439  
3440 B<Related actions>
3441  
3442 CreateGameSession | DescribeGameSessions | DescribeGameSessionDetails |
3443 SearchGameSessions | UpdateGameSession | GetGameSessionLogUrl |
3444 StartGameSessionPlacement | DescribeGameSessionPlacement |
3445 StopGameSessionPlacement | All APIs by task
3446 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3447  
3448  
3449 =head2 DescribeGameSessionPlacement
3450  
3451 =over
3452  
3453 =item PlacementId => Str
3454  
3455  
3456 =back
3457  
3458 Each argument is described in detail in: L<Paws::GameLift::DescribeGameSessionPlacement>
3459  
3460 Returns: a L<Paws::GameLift::DescribeGameSessionPlacementOutput> instance
3461  
3462 Retrieves information, including current status, about a game session
3463 placement request.
3464  
3465 To get game session placement details, specify the placement ID.
3466  
3467 If successful, a GameSessionPlacement object is returned.
3468  
3469 B<Related actions>
3470  
3471 CreateGameSession | DescribeGameSessions | DescribeGameSessionDetails |
3472 SearchGameSessions | UpdateGameSession | GetGameSessionLogUrl |
3473 StartGameSessionPlacement | DescribeGameSessionPlacement |
3474 StopGameSessionPlacement | All APIs by task
3475 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3476  
3477  
3478 =head2 DescribeGameSessionQueues
3479  
3480 =over
3481  
3482 =item [Limit => Int]
3483  
3484 =item [Names => ArrayRef[Str|Undef]]
3485  
3486 =item [NextToken => Str]
3487  
3488  
3489 =back
3490  
3491 Each argument is described in detail in: L<Paws::GameLift::DescribeGameSessionQueues>
3492  
3493 Returns: a L<Paws::GameLift::DescribeGameSessionQueuesOutput> instance
3494  
3495 Retrieves the properties for one or more game session queues. When
3496 requesting multiple queues, use the pagination parameters to retrieve
3497 results as a set of sequential pages. If successful, a GameSessionQueue
3498 object is returned for each requested queue. When specifying a list of
3499 queues, objects are returned only for queues that currently exist in
3500 the Region.
3501  
3502 B<Learn more>
3503  
3504 View Your Queues
3505 (https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-console.html)
3506  
3507 B<Related actions>
3508  
3509 CreateGameSessionQueue | DescribeGameSessionQueues |
3510 UpdateGameSessionQueue | DeleteGameSessionQueue | All APIs by task
3511 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3512  
3513  
3514 =head2 DescribeGameSessions
3515  
3516 =over
3517  
3518 =item [AliasId => Str]
3519  
3520 =item [FleetId => Str]
3521  
3522 =item [GameSessionId => Str]
3523  
3524 =item [Limit => Int]
3525  
3526 =item [Location => Str]
3527  
3528 =item [NextToken => Str]
3529  
3530 =item [StatusFilter => Str]
3531  
3532  
3533 =back
3534  
3535 Each argument is described in detail in: L<Paws::GameLift::DescribeGameSessions>
3536  
3537 Returns: a L<Paws::GameLift::DescribeGameSessionsOutput> instance
3538  
3539 Retrieves a set of one or more game sessions in a specific fleet
3540 location. You can optionally filter the results by current game session
3541 status. Alternatively, use SearchGameSessions to request a set of
3542 active game sessions that are filtered by certain criteria. To retrieve
3543 the protection policy for game sessions, use
3544 DescribeGameSessionDetails.
3545  
3546 This operation can be used in the following ways:
3547  
3548 =over
3549  
3550 =item *
3551  
3552 To retrieve all game sessions that are currently running on all
3553 locations in a fleet, provide a fleet or alias ID, with an optional
3554 status filter. This approach returns all game sessions in the fleet's
3555 home Region and all remote locations.
3556  
3557 =item *
3558  
3559 To retrieve all game sessions that are currently running on a specific
3560 fleet location, provide a fleet or alias ID and a location name, with
3561 optional status filter. The location can be the fleet's home Region or
3562 any remote location.
3563  
3564 =item *
3565  
3566 To retrieve a specific game session, provide the game session ID. This
3567 approach looks for the game session ID in all fleets that reside in the
3568 AWS Region defined in the request.
3569  
3570 =back
3571  
3572 Use the pagination parameters to retrieve results as a set of
3573 sequential pages.
3574  
3575 If successful, a C<GameSession> object is returned for each game
3576 session that matches the request.
3577  
3578 I<Available in GameLift Local.>
3579  
3580 B<Learn more>
3581  
3582 Find a game session
3583 (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-client-api.html#gamelift-sdk-client-api-find)
3584  
3585 B<Related actions>
3586  
3587 CreateGameSession | DescribeGameSessions | DescribeGameSessionDetails |
3588 SearchGameSessions | UpdateGameSession | GetGameSessionLogUrl |
3589 StartGameSessionPlacement | DescribeGameSessionPlacement |
3590 StopGameSessionPlacement | All APIs by task
3591 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3592  
3593  
3594 =head2 DescribeInstances
3595  
3596 =over
3597  
3598 =item FleetId => Str
3599  
3600 =item [InstanceId => Str]
3601  
3602 =item [Limit => Int]
3603  
3604 =item [Location => Str]
3605  
3606 =item [NextToken => Str]
3607  
3608  
3609 =back
3610  
3611 Each argument is described in detail in: L<Paws::GameLift::DescribeInstances>
3612  
3613 Returns: a L<Paws::GameLift::DescribeInstancesOutput> instance
3614  
3615 Retrieves information about a fleet's instances, including instance
3616 IDs, connection data, and status.
3617  
3618 This operation can be used in the following ways:
3619  
3620 =over
3621  
3622 =item *
3623  
3624 To get information on all instances that are deployed to a fleet's home
3625 Region, provide the fleet ID.
3626  
3627 =item *
3628  
3629 To get information on all instances that are deployed to a fleet's
3630 remote location, provide the fleet ID and location name.
3631  
3632 =item *
3633  
3634 To get information on a specific instance in a fleet, provide the fleet
3635 ID and instance ID.
3636  
3637 =back
3638  
3639 Use the pagination parameters to retrieve results as a set of
3640 sequential pages.
3641  
3642 If successful, an C<Instance> object is returned for each requested
3643 instance. Instances are not returned in any particular order.
3644  
3645 B<Learn more>
3646  
3647 Remotely Access Fleet Instances
3648 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-remote-access.html)
3649  
3650 Debug Fleet Issues
3651 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creating-debug.html)
3652  
3653 B<Related actions>
3654  
3655 DescribeInstances | GetInstanceAccess | DescribeEC2InstanceLimits | All
3656 APIs by task
3657 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3658  
3659  
3660 =head2 DescribeMatchmaking
3661  
3662 =over
3663  
3664 =item TicketIds => ArrayRef[Str|Undef]
3665  
3666  
3667 =back
3668  
3669 Each argument is described in detail in: L<Paws::GameLift::DescribeMatchmaking>
3670  
3671 Returns: a L<Paws::GameLift::DescribeMatchmakingOutput> instance
3672  
3673 Retrieves one or more matchmaking tickets. Use this operation to
3674 retrieve ticket information, including--after a successful match is
3675 made--connection information for the resulting new game session.
3676  
3677 To request matchmaking tickets, provide a list of up to 10 ticket IDs.
3678 If the request is successful, a ticket object is returned for each
3679 requested ID that currently exists.
3680  
3681 This operation is not designed to be continually called to track
3682 matchmaking ticket status. This practice can cause you to exceed your
3683 API limit, which results in errors. Instead, as a best practice, set up
3684 an Amazon Simple Notification Service (SNS) to receive notifications,
3685 and provide the topic ARN in the matchmaking configuration.
3686 Continuously poling ticket status with DescribeMatchmaking should only
3687 be used for games in development with low matchmaking usage.
3688  
3689 B<Learn more>
3690  
3691 Add FlexMatch to a game client
3692 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-client.html)
3693  
3694 Set Up FlexMatch event notification
3695 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-notification.html)
3696  
3697 B<Related actions>
3698  
3699 StartMatchmaking | DescribeMatchmaking | StopMatchmaking | AcceptMatch
3700 | StartMatchBackfill | All APIs by task
3701 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3702  
3703  
3704 =head2 DescribeMatchmakingConfigurations
3705  
3706 =over
3707  
3708 =item [Limit => Int]
3709  
3710 =item [Names => ArrayRef[Str|Undef]]
3711  
3712 =item [NextToken => Str]
3713  
3714 =item [RuleSetName => Str]
3715  
3716  
3717 =back
3718  
3719 Each argument is described in detail in: L<Paws::GameLift::DescribeMatchmakingConfigurations>
3720  
3721 Returns: a L<Paws::GameLift::DescribeMatchmakingConfigurationsOutput> instance
3722  
3723 Retrieves the details of FlexMatch matchmaking configurations.
3724  
3725 This operation offers the following options: (1) retrieve all
3726 matchmaking configurations, (2) retrieve configurations for a specified
3727 list, or (3) retrieve all configurations that use a specified rule set
3728 name. When requesting multiple items, use the pagination parameters to
3729 retrieve results as a set of sequential pages.
3730  
3731 If successful, a configuration is returned for each requested name.
3732 When specifying a list of names, only configurations that currently
3733 exist are returned.
3734  
3735 B<Learn more>
3736  
3737 Setting up FlexMatch matchmakers
3738 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/matchmaker-build.html)
3739  
3740 B<Related actions>
3741  
3742 CreateMatchmakingConfiguration | DescribeMatchmakingConfigurations |
3743 UpdateMatchmakingConfiguration | DeleteMatchmakingConfiguration |
3744 CreateMatchmakingRuleSet | DescribeMatchmakingRuleSets |
3745 ValidateMatchmakingRuleSet | DeleteMatchmakingRuleSet | All APIs by
3746 task
3747 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3748  
3749  
3750 =head2 DescribeMatchmakingRuleSets
3751  
3752 =over
3753  
3754 =item [Limit => Int]
3755  
3756 =item [Names => ArrayRef[Str|Undef]]
3757  
3758 =item [NextToken => Str]
3759  
3760  
3761 =back
3762  
3763 Each argument is described in detail in: L<Paws::GameLift::DescribeMatchmakingRuleSets>
3764  
3765 Returns: a L<Paws::GameLift::DescribeMatchmakingRuleSetsOutput> instance
3766  
3767 Retrieves the details for FlexMatch matchmaking rule sets. You can
3768 request all existing rule sets for the Region, or provide a list of one
3769 or more rule set names. When requesting multiple items, use the
3770 pagination parameters to retrieve results as a set of sequential pages.
3771 If successful, a rule set is returned for each requested name.
3772  
3773 B<Learn more>
3774  
3775 =over
3776  
3777 =item *
3778  
3779 Build a rule set
3780 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-rulesets.html)
3781  
3782 =back
3783  
3784 B<Related actions>
3785  
3786 CreateMatchmakingConfiguration | DescribeMatchmakingConfigurations |
3787 UpdateMatchmakingConfiguration | DeleteMatchmakingConfiguration |
3788 CreateMatchmakingRuleSet | DescribeMatchmakingRuleSets |
3789 ValidateMatchmakingRuleSet | DeleteMatchmakingRuleSet | All APIs by
3790 task
3791 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3792  
3793  
3794 =head2 DescribePlayerSessions
3795  
3796 =over
3797  
3798 =item [GameSessionId => Str]
3799  
3800 =item [Limit => Int]
3801  
3802 =item [NextToken => Str]
3803  
3804 =item [PlayerId => Str]
3805  
3806 =item [PlayerSessionId => Str]
3807  
3808 =item [PlayerSessionStatusFilter => Str]
3809  
3810  
3811 =back
3812  
3813 Each argument is described in detail in: L<Paws::GameLift::DescribePlayerSessions>
3814  
3815 Returns: a L<Paws::GameLift::DescribePlayerSessionsOutput> instance
3816  
3817 Retrieves properties for one or more player sessions.
3818  
3819 This action can be used in the following ways:
3820  
3821 =over
3822  
3823 =item *
3824  
3825 To retrieve a specific player session, provide the player session ID
3826 only.
3827  
3828 =item *
3829  
3830 To retrieve all player sessions in a game session, provide the game
3831 session ID only.
3832  
3833 =item *
3834  
3835 To retrieve all player sessions for a specific player, provide a player
3836 ID only.
3837  
3838 =back
3839  
3840 To request player sessions, specify either a player session ID, game
3841 session ID, or player ID. You can filter this request by player session
3842 status. Use the pagination parameters to retrieve results as a set of
3843 sequential pages.
3844  
3845 If successful, a C<PlayerSession> object is returned for each session
3846 that matches the request.
3847  
3848 I<Available in Amazon GameLift Local.>
3849  
3850 B<Related actions>
3851  
3852 CreatePlayerSession | CreatePlayerSessions | DescribePlayerSessions |
3853 StartGameSessionPlacement | DescribeGameSessionPlacement | All APIs by
3854 task
3855 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3856  
3857  
3858 =head2 DescribeRuntimeConfiguration
3859  
3860 =over
3861  
3862 =item FleetId => Str
3863  
3864  
3865 =back
3866  
3867 Each argument is described in detail in: L<Paws::GameLift::DescribeRuntimeConfiguration>
3868  
3869 Returns: a L<Paws::GameLift::DescribeRuntimeConfigurationOutput> instance
3870  
3871 Retrieves a fleet's runtime configuration settings. The runtime
3872 configuration tells GameLift which server processes to run (and how) on
3873 each instance in the fleet.
3874  
3875 To get the runtime configuration that is currently in forces for a
3876 fleet, provide the fleet ID.
3877  
3878 If successful, a RuntimeConfiguration object is returned for the
3879 requested fleet. If the requested fleet has been deleted, the result
3880 set is empty.
3881  
3882 B<Learn more>
3883  
3884 Setting up GameLift fleets
3885 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
3886  
3887 Running multiple processes on a fleet
3888 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-multiprocess.html)
3889  
3890 B<Related actions>
3891  
3892 ListFleets | DescribeEC2InstanceLimits | DescribeFleetAttributes |
3893 DescribeFleetCapacity | DescribeFleetEvents |
3894 DescribeFleetLocationAttributes | DescribeFleetPortSettings |
3895 DescribeFleetUtilization | DescribeRuntimeConfiguration |
3896 DescribeScalingPolicies | All APIs by task
3897 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3898  
3899  
3900 =head2 DescribeScalingPolicies
3901  
3902 =over
3903  
3904 =item FleetId => Str
3905  
3906 =item [Limit => Int]
3907  
3908 =item [Location => Str]
3909  
3910 =item [NextToken => Str]
3911  
3912 =item [StatusFilter => Str]
3913  
3914  
3915 =back
3916  
3917 Each argument is described in detail in: L<Paws::GameLift::DescribeScalingPolicies>
3918  
3919 Returns: a L<Paws::GameLift::DescribeScalingPoliciesOutput> instance
3920  
3921 Retrieves all scaling policies applied to a fleet.
3922  
3923 To get a fleet's scaling policies, specify the fleet ID. You can filter
3924 this request by policy status, such as to retrieve only active scaling
3925 policies. Use the pagination parameters to retrieve results as a set of
3926 sequential pages. If successful, set of ScalingPolicy objects is
3927 returned for the fleet.
3928  
3929 A fleet may have all of its scaling policies suspended
3930 (StopFleetActions). This operation does not affect the status of the
3931 scaling policies, which remains ACTIVE. To see whether a fleet's
3932 scaling policies are in force or suspended, call
3933 DescribeFleetAttributes and check the stopped actions.
3934  
3935 B<Related actions>
3936  
3937 DescribeFleetCapacity | UpdateFleetCapacity | DescribeEC2InstanceLimits
3938 | PutScalingPolicy | DescribeScalingPolicies | DeleteScalingPolicy |
3939 StopFleetActions | StartFleetActions | All APIs by task
3940 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3941  
3942  
3943 =head2 DescribeScript
3944  
3945 =over
3946  
3947 =item ScriptId => Str
3948  
3949  
3950 =back
3951  
3952 Each argument is described in detail in: L<Paws::GameLift::DescribeScript>
3953  
3954 Returns: a L<Paws::GameLift::DescribeScriptOutput> instance
3955  
3956 Retrieves properties for a Realtime script.
3957  
3958 To request a script record, specify the script ID. If successful, an
3959 object containing the script properties is returned.
3960  
3961 B<Learn more>
3962  
3963 Amazon GameLift Realtime Servers
3964 (https://docs.aws.amazon.com/gamelift/latest/developerguide/realtime-intro.html)
3965  
3966 B<Related actions>
3967  
3968 CreateScript | ListScripts | DescribeScript | UpdateScript |
3969 DeleteScript | All APIs by task
3970 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3971  
3972  
3973 =head2 DescribeVpcPeeringAuthorizations
3974  
3975  
3976  
3977  
3978  
3979  
3980 Each argument is described in detail in: L<Paws::GameLift::DescribeVpcPeeringAuthorizations>
3981  
3982 Returns: a L<Paws::GameLift::DescribeVpcPeeringAuthorizationsOutput> instance
3983  
3984 Retrieves valid VPC peering authorizations that are pending for the AWS
3985 account. This operation returns all VPC peering authorizations and
3986 requests for peering. This includes those initiated and received by
3987 this account.
3988  
3989 B<Related actions>
3990  
3991 CreateVpcPeeringAuthorization | DescribeVpcPeeringAuthorizations |
3992 DeleteVpcPeeringAuthorization | CreateVpcPeeringConnection |
3993 DescribeVpcPeeringConnections | DeleteVpcPeeringConnection | All APIs
3994 by task
3995 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
3996  
3997  
3998 =head2 DescribeVpcPeeringConnections
3999  
4000 =over
4001  
4002 =item [FleetId => Str]
4003  
4004  
4005 =back
4006  
4007 Each argument is described in detail in: L<Paws::GameLift::DescribeVpcPeeringConnections>
4008  
4009 Returns: a L<Paws::GameLift::DescribeVpcPeeringConnectionsOutput> instance
4010  
4011 Retrieves information on VPC peering connections. Use this operation to
4012 get peering information for all fleets or for one specific fleet ID.
4013  
4014 To retrieve connection information, call this operation from the AWS
4015 account that is used to manage the Amazon GameLift fleets. Specify a
4016 fleet ID or leave the parameter empty to retrieve all connection
4017 records. If successful, the retrieved information includes both active
4018 and pending connections. Active connections identify the IpV4 CIDR
4019 block that the VPC uses to connect.
4020  
4021 B<Related actions>
4022  
4023 CreateVpcPeeringAuthorization | DescribeVpcPeeringAuthorizations |
4024 DeleteVpcPeeringAuthorization | CreateVpcPeeringConnection |
4025 DescribeVpcPeeringConnections | DeleteVpcPeeringConnection | All APIs
4026 by task
4027 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4028  
4029  
4030 =head2 GetGameSessionLogUrl
4031  
4032 =over
4033  
4034 =item GameSessionId => Str
4035  
4036  
4037 =back
4038  
4039 Each argument is described in detail in: L<Paws::GameLift::GetGameSessionLogUrl>
4040  
4041 Returns: a L<Paws::GameLift::GetGameSessionLogUrlOutput> instance
4042  
4043 Retrieves the location of stored game session logs for a specified game
4044 session. When a game session is terminated, GameLift automatically
4045 stores the logs in Amazon S3 and retains them for 14 days. Use this URL
4046 to download the logs.
4047  
4048 See the AWS Service Limits
4049 (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_gamelift)
4050 page for maximum log file sizes. Log files that exceed this limit are
4051 not saved.
4052  
4053 B<Related actions>
4054  
4055 CreateGameSession | DescribeGameSessions | DescribeGameSessionDetails |
4056 SearchGameSessions | UpdateGameSession | GetGameSessionLogUrl |
4057 StartGameSessionPlacement | DescribeGameSessionPlacement |
4058 StopGameSessionPlacement | All APIs by task
4059 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4060  
4061  
4062 =head2 GetInstanceAccess
4063  
4064 =over
4065  
4066 =item FleetId => Str
4067  
4068 =item InstanceId => Str
4069  
4070  
4071 =back
4072  
4073 Each argument is described in detail in: L<Paws::GameLift::GetInstanceAccess>
4074  
4075 Returns: a L<Paws::GameLift::GetInstanceAccessOutput> instance
4076  
4077 Requests remote access to a fleet instance. Remote access is useful for
4078 debugging, gathering benchmarking data, or observing activity in real
4079 time.
4080  
4081 To remotely access an instance, you need credentials that match the
4082 operating system of the instance. For a Windows instance, GameLift
4083 returns a user name and password as strings for use with a Windows
4084 Remote Desktop client. For a Linux instance, GameLift returns a user
4085 name and RSA private key, also as strings, for use with an SSH client.
4086 The private key must be saved in the proper format to a C<.pem> file
4087 before using. If you're making this request using the AWS CLI, saving
4088 the secret can be handled as part of the C<GetInstanceAccess> request,
4089 as shown in one of the examples for this operation.
4090  
4091 To request access to a specific instance, specify the IDs of both the
4092 instance and the fleet it belongs to. You can retrieve a fleet's
4093 instance IDs by calling DescribeInstances. If successful, an
4094 InstanceAccess object is returned that contains the instance's IP
4095 address and a set of credentials.
4096  
4097 B<Learn more>
4098  
4099 Remotely Access Fleet Instances
4100 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-remote-access.html)
4101  
4102 Debug Fleet Issues
4103 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creating-debug.html)
4104  
4105 B<Related actions>
4106  
4107 DescribeInstances | GetInstanceAccess | DescribeEC2InstanceLimits | All
4108 APIs by task
4109 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4110  
4111  
4112 =head2 ListAliases
4113  
4114 =over
4115  
4116 =item [Limit => Int]
4117  
4118 =item [Name => Str]
4119  
4120 =item [NextToken => Str]
4121  
4122 =item [RoutingStrategyType => Str]
4123  
4124  
4125 =back
4126  
4127 Each argument is described in detail in: L<Paws::GameLift::ListAliases>
4128  
4129 Returns: a L<Paws::GameLift::ListAliasesOutput> instance
4130  
4131 Retrieves all aliases for this AWS account. You can filter the result
4132 set by alias name and/or routing strategy type. Use the pagination
4133 parameters to retrieve results in sequential pages.
4134  
4135 Returned aliases are not listed in any particular order.
4136  
4137 B<Related actions>
4138  
4139 CreateAlias | ListAliases | DescribeAlias | UpdateAlias | DeleteAlias |
4140 ResolveAlias | All APIs by task
4141 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4142  
4143  
4144 =head2 ListBuilds
4145  
4146 =over
4147  
4148 =item [Limit => Int]
4149  
4150 =item [NextToken => Str]
4151  
4152 =item [Status => Str]
4153  
4154  
4155 =back
4156  
4157 Each argument is described in detail in: L<Paws::GameLift::ListBuilds>
4158  
4159 Returns: a L<Paws::GameLift::ListBuildsOutput> instance
4160  
4161 Retrieves build resources for all builds associated with the AWS
4162 account in use. You can limit results to builds that are in a specific
4163 status by using the C<Status> parameter. Use the pagination parameters
4164 to retrieve results in a set of sequential pages.
4165  
4166 Build resources are not listed in any particular order.
4167  
4168 B<Learn more>
4169  
4170 Upload a Custom Server Build
4171 (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-build-intro.html)
4172  
4173 B<Related actions>
4174  
4175 CreateBuild | ListBuilds | DescribeBuild | UpdateBuild | DeleteBuild |
4176 All APIs by task
4177 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4178  
4179  
4180 =head2 ListFleets
4181  
4182 =over
4183  
4184 =item [BuildId => Str]
4185  
4186 =item [Limit => Int]
4187  
4188 =item [NextToken => Str]
4189  
4190 =item [ScriptId => Str]
4191  
4192  
4193 =back
4194  
4195 Each argument is described in detail in: L<Paws::GameLift::ListFleets>
4196  
4197 Returns: a L<Paws::GameLift::ListFleetsOutput> instance
4198  
4199 Retrieves a collection of fleet resources in an AWS Region. You can
4200 call this operation to get fleets in a previously selected default
4201 Region (see
4202 https://docs.aws.amazon.com/credref/latest/refdocs/setting-global-region.html
4203 (https://docs.aws.amazon.com/credref/latest/refdocs/setting-global-region.html)or
4204 specify a Region in your request. You can filter the result set to find
4205 only those fleets that are deployed with a specific build or script.
4206 For fleets that have multiple locations, this operation retrieves
4207 fleets based on their home Region only.
4208  
4209 This operation can be used in the following ways:
4210  
4211 =over
4212  
4213 =item *
4214  
4215 To get a list of all fleets in a Region, don't provide a build or
4216 script identifier.
4217  
4218 =item *
4219  
4220 To get a list of all fleets where a specific custom game build is
4221 deployed, provide the build ID.
4222  
4223 =item *
4224  
4225 To get a list of all Realtime Servers fleets with a specific
4226 configuration script, provide the script ID.
4227  
4228 =back
4229  
4230 Use the pagination parameters to retrieve results as a set of
4231 sequential pages.
4232  
4233 If successful, a list of fleet IDs that match the request parameters is
4234 returned. A NextToken value is also returned if there are more result
4235 pages to retrieve.
4236  
4237 Fleet resources are not listed in a particular order.
4238  
4239 B<Learn more>
4240  
4241 Setting up GameLift fleets
4242 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
4243  
4244 B<Related actions>
4245  
4246 CreateFleet | UpdateFleetCapacity | PutScalingPolicy |
4247 DescribeEC2InstanceLimits | DescribeFleetAttributes |
4248 DescribeFleetLocationAttributes | UpdateFleetAttributes |
4249 StopFleetActions | DeleteFleet | All APIs by task
4250 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4251  
4252  
4253 =head2 ListGameServerGroups
4254  
4255 =over
4256  
4257 =item [Limit => Int]
4258  
4259 =item [NextToken => Str]
4260  
4261  
4262 =back
4263  
4264 Each argument is described in detail in: L<Paws::GameLift::ListGameServerGroups>
4265  
4266 Returns: a L<Paws::GameLift::ListGameServerGroupsOutput> instance
4267  
4268 B<This operation is used with the GameLift FleetIQ solution and game
4269 server groups.>
4270  
4271 Retrieves information on all game servers groups that exist in the
4272 current AWS account for the selected Region. Use the pagination
4273 parameters to retrieve results in a set of sequential segments.
4274  
4275 B<Learn more>
4276  
4277 GameLift FleetIQ Guide
4278 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
4279  
4280 B<Related actions>
4281  
4282 CreateGameServerGroup | ListGameServerGroups | DescribeGameServerGroup
4283 | UpdateGameServerGroup | DeleteGameServerGroup | ResumeGameServerGroup
4284 | SuspendGameServerGroup | DescribeGameServerInstances | All APIs by
4285 task
4286 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
4287  
4288  
4289 =head2 ListGameServers
4290  
4291 =over
4292  
4293 =item GameServerGroupName => Str
4294  
4295 =item [Limit => Int]
4296  
4297 =item [NextToken => Str]
4298  
4299 =item [SortOrder => Str]
4300  
4301  
4302 =back
4303  
4304 Each argument is described in detail in: L<Paws::GameLift::ListGameServers>
4305  
4306 Returns: a L<Paws::GameLift::ListGameServersOutput> instance
4307  
4308 B<This operation is used with the GameLift FleetIQ solution and game
4309 server groups.>
4310  
4311 Retrieves information on all game servers that are currently active in
4312 a specified game server group. You can opt to sort the list by game
4313 server age. Use the pagination parameters to retrieve results in a set
4314 of sequential segments.
4315  
4316 B<Learn more>
4317  
4318 GameLift FleetIQ Guide
4319 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
4320  
4321 B<Related actions>
4322  
4323 RegisterGameServer | ListGameServers | ClaimGameServer |
4324 DescribeGameServer | UpdateGameServer | DeregisterGameServer | All APIs
4325 by task
4326 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
4327  
4328  
4329 =head2 ListScripts
4330  
4331 =over
4332  
4333 =item [Limit => Int]
4334  
4335 =item [NextToken => Str]
4336  
4337  
4338 =back
4339  
4340 Each argument is described in detail in: L<Paws::GameLift::ListScripts>
4341  
4342 Returns: a L<Paws::GameLift::ListScriptsOutput> instance
4343  
4344 Retrieves script records for all Realtime scripts that are associated
4345 with the AWS account in use.
4346  
4347 B<Learn more>
4348  
4349 Amazon GameLift Realtime Servers
4350 (https://docs.aws.amazon.com/gamelift/latest/developerguide/realtime-intro.html)
4351  
4352 B<Related actions>
4353  
4354 CreateScript | ListScripts | DescribeScript | UpdateScript |
4355 DeleteScript | All APIs by task
4356 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4357  
4358  
4359 =head2 ListTagsForResource
4360  
4361 =over
4362  
4363 =item ResourceARN => Str
4364  
4365  
4366 =back
4367  
4368 Each argument is described in detail in: L<Paws::GameLift::ListTagsForResource>
4369  
4370 Returns: a L<Paws::GameLift::ListTagsForResourceResponse> instance
4371  
4372 Retrieves all tags that are assigned to a GameLift resource. Resource
4373 tags are used to organize AWS resources for a range of purposes. This
4374 operation handles the permissions necessary to manage tags for the
4375 following GameLift resource types:
4376  
4377 =over
4378  
4379 =item *
4380  
4381 Build
4382  
4383 =item *
4384  
4385 Script
4386  
4387 =item *
4388  
4389 Fleet
4390  
4391 =item *
4392  
4393 Alias
4394  
4395 =item *
4396  
4397 GameSessionQueue
4398  
4399 =item *
4400  
4401 MatchmakingConfiguration
4402  
4403 =item *
4404  
4405 MatchmakingRuleSet
4406  
4407 =back
4408  
4409 To list tags for a resource, specify the unique ARN value for the
4410 resource.
4411  
4412 B<Learn more>
4413  
4414 Tagging AWS Resources
4415 (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in the
4416 I<AWS General Reference>
4417  
4418 AWS Tagging Strategies
4419 (http://aws.amazon.com/answers/account-management/aws-tagging-strategies/)
4420  
4421 B<Related actions>
4422  
4423 TagResource | UntagResource | ListTagsForResource | All APIs by task
4424 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4425  
4426  
4427 =head2 PutScalingPolicy
4428  
4429 =over
4430  
4431 =item FleetId => Str
4432  
4433 =item MetricName => Str
4434  
4435 =item Name => Str
4436  
4437 =item [ComparisonOperator => Str]
4438  
4439 =item [EvaluationPeriods => Int]
4440  
4441 =item [PolicyType => Str]
4442  
4443 =item [ScalingAdjustment => Int]
4444  
4445 =item [ScalingAdjustmentType => Str]
4446  
4447 =item [TargetConfiguration => L<Paws::GameLift::TargetConfiguration>]
4448  
4449 =item [Threshold => Num]
4450  
4451  
4452 =back
4453  
4454 Each argument is described in detail in: L<Paws::GameLift::PutScalingPolicy>
4455  
4456 Returns: a L<Paws::GameLift::PutScalingPolicyOutput> instance
4457  
4458 Creates or updates a scaling policy for a fleet. Scaling policies are
4459 used to automatically scale a fleet's hosting capacity to meet player
4460 demand. An active scaling policy instructs Amazon GameLift to track a
4461 fleet metric and automatically change the fleet's capacity when a
4462 certain threshold is reached. There are two types of scaling policies:
4463 target-based and rule-based. Use a target-based policy to quickly and
4464 efficiently manage fleet scaling; this option is the most commonly
4465 used. Use rule-based policies when you need to exert fine-grained
4466 control over auto-scaling.
4467  
4468 Fleets can have multiple scaling policies of each type in force at the
4469 same time; you can have one target-based policy, one or multiple
4470 rule-based scaling policies, or both. We recommend caution, however,
4471 because multiple auto-scaling policies can have unintended
4472 consequences.
4473  
4474 You can temporarily suspend all scaling policies for a fleet by calling
4475 StopFleetActions with the fleet action AUTO_SCALING. To resume scaling
4476 policies, call StartFleetActions with the same fleet action. To stop
4477 just one scaling policy--or to permanently remove it, you must delete
4478 the policy with DeleteScalingPolicy.
4479  
4480 Learn more about how to work with auto-scaling in Set Up Fleet
4481 Automatic Scaling
4482 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-autoscaling.html).
4483  
4484 B<Target-based policy>
4485  
4486 A target-based policy tracks a single metric:
4487 PercentAvailableGameSessions. This metric tells us how much of a
4488 fleet's hosting capacity is ready to host game sessions but is not
4489 currently in use. This is the fleet's buffer; it measures the
4490 additional player demand that the fleet could handle at current
4491 capacity. With a target-based policy, you set your ideal buffer size
4492 and leave it to Amazon GameLift to take whatever action is needed to
4493 maintain that target.
4494  
4495 For example, you might choose to maintain a 10% buffer for a fleet that
4496 has the capacity to host 100 simultaneous game sessions. This policy
4497 tells Amazon GameLift to take action whenever the fleet's available
4498 capacity falls below or rises above 10 game sessions. Amazon GameLift
4499 will start new instances or stop unused instances in order to return to
4500 the 10% buffer.
4501  
4502 To create or update a target-based policy, specify a fleet ID and name,
4503 and set the policy type to "TargetBased". Specify the metric to track
4504 (PercentAvailableGameSessions) and reference a TargetConfiguration
4505 object with your desired buffer value. Exclude all other parameters. On
4506 a successful request, the policy name is returned. The scaling policy
4507 is automatically in force as soon as it's successfully created. If the
4508 fleet's auto-scaling actions are temporarily suspended, the new policy
4509 will be in force once the fleet actions are restarted.
4510  
4511 B<Rule-based policy>
4512  
4513 A rule-based policy tracks specified fleet metric, sets a threshold
4514 value, and specifies the type of action to initiate when triggered.
4515 With a rule-based policy, you can select from several available fleet
4516 metrics. Each policy specifies whether to scale up or scale down (and
4517 by how much), so you need one policy for each type of action.
4518  
4519 For example, a policy may make the following statement: "If the
4520 percentage of idle instances is greater than 20% for more than 15
4521 minutes, then reduce the fleet capacity by 10%."
4522  
4523 A policy's rule statement has the following structure:
4524  
4525 If C<[MetricName]> is C<[ComparisonOperator]> C<[Threshold]> for
4526 C<[EvaluationPeriods]> minutes, then C<[ScalingAdjustmentType]> to/by
4527 C<[ScalingAdjustment]>.
4528  
4529 To implement the example, the rule statement would look like this:
4530  
4531 If C<[PercentIdleInstances]> is C<[GreaterThanThreshold]> C<[20]> for
4532 C<[15]> minutes, then C<[PercentChangeInCapacity]> to/by C<[10]>.
4533  
4534 To create or update a scaling policy, specify a unique combination of
4535 name and fleet ID, and set the policy type to "RuleBased". Specify the
4536 parameter values for a policy rule statement. On a successful request,
4537 the policy name is returned. Scaling policies are automatically in
4538 force as soon as they're successfully created. If the fleet's
4539 auto-scaling actions are temporarily suspended, the new policy will be
4540 in force once the fleet actions are restarted.
4541  
4542 B<Related actions>
4543  
4544 DescribeFleetCapacity | UpdateFleetCapacity | DescribeEC2InstanceLimits
4545 | PutScalingPolicy | DescribeScalingPolicies | DeleteScalingPolicy |
4546 StopFleetActions | StartFleetActions | All APIs by task
4547 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4548  
4549  
4550 =head2 RegisterGameServer
4551  
4552 =over
4553  
4554 =item GameServerGroupName => Str
4555  
4556 =item GameServerId => Str
4557  
4558 =item InstanceId => Str
4559  
4560 =item [ConnectionInfo => Str]
4561  
4562 =item [GameServerData => Str]
4563  
4564  
4565 =back
4566  
4567 Each argument is described in detail in: L<Paws::GameLift::RegisterGameServer>
4568  
4569 Returns: a L<Paws::GameLift::RegisterGameServerOutput> instance
4570  
4571 B<This operation is used with the GameLift FleetIQ solution and game
4572 server groups.>
4573  
4574 Creates a new game server resource and notifies GameLift FleetIQ that
4575 the game server is ready to host gameplay and players. This operation
4576 is called by a game server process that is running on an instance in a
4577 game server group. Registering game servers enables GameLift FleetIQ to
4578 track available game servers and enables game clients and services to
4579 claim a game server for a new game session.
4580  
4581 To register a game server, identify the game server group and instance
4582 where the game server is running, and provide a unique identifier for
4583 the game server. You can also include connection and game server data.
4584 When a game client or service requests a game server by calling
4585 ClaimGameServer, this information is returned in the response.
4586  
4587 Once a game server is successfully registered, it is put in status
4588 C<AVAILABLE>. A request to register a game server may fail if the
4589 instance it is running on is in the process of shutting down as part of
4590 instance balancing or scale-down activity.
4591  
4592 B<Learn more>
4593  
4594 GameLift FleetIQ Guide
4595 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
4596  
4597 B<Related actions>
4598  
4599 RegisterGameServer | ListGameServers | ClaimGameServer |
4600 DescribeGameServer | UpdateGameServer | DeregisterGameServer | All APIs
4601 by task
4602 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
4603  
4604  
4605 =head2 RequestUploadCredentials
4606  
4607 =over
4608  
4609 =item BuildId => Str
4610  
4611  
4612 =back
4613  
4614 Each argument is described in detail in: L<Paws::GameLift::RequestUploadCredentials>
4615  
4616 Returns: a L<Paws::GameLift::RequestUploadCredentialsOutput> instance
4617  
4618 Retrieves a fresh set of credentials for use when uploading a new set
4619 of game build files to Amazon GameLift's Amazon S3. This is done as
4620 part of the build creation process; see CreateBuild.
4621  
4622 To request new credentials, specify the build ID as returned with an
4623 initial C<CreateBuild> request. If successful, a new set of credentials
4624 are returned, along with the S3 storage location associated with the
4625 build ID.
4626  
4627 B<Learn more>
4628  
4629 Create a Build with Files in S3
4630 (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-build-cli-uploading.html#gamelift-build-cli-uploading-create-build)
4631  
4632 B<Related actions>
4633  
4634 CreateBuild | ListBuilds | DescribeBuild | UpdateBuild | DeleteBuild |
4635 All APIs by task
4636 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4637  
4638  
4639 =head2 ResolveAlias
4640  
4641 =over
4642  
4643 =item AliasId => Str
4644  
4645  
4646 =back
4647  
4648 Each argument is described in detail in: L<Paws::GameLift::ResolveAlias>
4649  
4650 Returns: a L<Paws::GameLift::ResolveAliasOutput> instance
4651  
4652 Retrieves the fleet ID that an alias is currently pointing to.
4653  
4654 B<Related actions>
4655  
4656 CreateAlias | ListAliases | DescribeAlias | UpdateAlias | DeleteAlias |
4657 ResolveAlias | All APIs by task
4658 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4659  
4660  
4661 =head2 ResumeGameServerGroup
4662  
4663 =over
4664  
4665 =item GameServerGroupName => Str
4666  
4667 =item ResumeActions => ArrayRef[Str|Undef]
4668  
4669  
4670 =back
4671  
4672 Each argument is described in detail in: L<Paws::GameLift::ResumeGameServerGroup>
4673  
4674 Returns: a L<Paws::GameLift::ResumeGameServerGroupOutput> instance
4675  
4676 B<This operation is used with the GameLift FleetIQ solution and game
4677 server groups.>
4678  
4679 Reinstates activity on a game server group after it has been suspended.
4680 A game server group might be suspended by theSuspendGameServerGroup
4681 operation, or it might be suspended involuntarily due to a
4682 configuration problem. In the second case, you can manually resume
4683 activity on the group once the configuration problem has been resolved.
4684 Refer to the game server group status and status reason for more
4685 information on why group activity is suspended.
4686  
4687 To resume activity, specify a game server group ARN and the type of
4688 activity to be resumed. If successful, a GameServerGroup object is
4689 returned showing that the resumed activity is no longer listed in
4690 C<SuspendedActions>.
4691  
4692 B<Learn more>
4693  
4694 GameLift FleetIQ Guide
4695 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
4696  
4697 B<Related actions>
4698  
4699 CreateGameServerGroup | ListGameServerGroups | DescribeGameServerGroup
4700 | UpdateGameServerGroup | DeleteGameServerGroup | ResumeGameServerGroup
4701 | SuspendGameServerGroup | DescribeGameServerInstances | All APIs by
4702 task
4703 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
4704  
4705  
4706 =head2 SearchGameSessions
4707  
4708 =over
4709  
4710 =item [AliasId => Str]
4711  
4712 =item [FilterExpression => Str]
4713  
4714 =item [FleetId => Str]
4715  
4716 =item [Limit => Int]
4717  
4718 =item [Location => Str]
4719  
4720 =item [NextToken => Str]
4721  
4722 =item [SortExpression => Str]
4723  
4724  
4725 =back
4726  
4727 Each argument is described in detail in: L<Paws::GameLift::SearchGameSessions>
4728  
4729 Returns: a L<Paws::GameLift::SearchGameSessionsOutput> instance
4730  
4731 Retrieves all active game sessions that match a set of search criteria
4732 and sorts them into a specified order.
4733  
4734 When searching for game sessions, you specify exactly where you want to
4735 search and provide a search filter expression, a sort expression, or
4736 both. A search request can search only one fleet, but it can search all
4737 of a fleet's locations.
4738  
4739 This operation can be used in the following ways:
4740  
4741 =over
4742  
4743 =item *
4744  
4745 To search all game sessions that are currently running on all locations
4746 in a fleet, provide a fleet or alias ID. This approach returns game
4747 sessions in the fleet's home Region and all remote locations that fit
4748 the search criteria.
4749  
4750 =item *
4751  
4752 To search all game sessions that are currently running on a specific
4753 fleet location, provide a fleet or alias ID and a location name. For
4754 location, you can specify a fleet's home Region or any remote location.
4755  
4756 =back
4757  
4758 Use the pagination parameters to retrieve results as a set of
4759 sequential pages.
4760  
4761 If successful, a C<GameSession> object is returned for each game
4762 session that matches the request. Search finds game sessions that are
4763 in C<ACTIVE> status only. To retrieve information on game sessions in
4764 other statuses, use DescribeGameSessions.
4765  
4766 You can search or sort by the following game session attributes:
4767  
4768 =over
4769  
4770 =item *
4771  
4772 B<gameSessionId> -- A unique identifier for the game session. You can
4773 use either a C<GameSessionId> or C<GameSessionArn> value.
4774  
4775 =item *
4776  
4777 B<gameSessionName> -- Name assigned to a game session. This value is
4778 set when requesting a new game session with CreateGameSession or
4779 updating with UpdateGameSession. Game session names do not need to be
4780 unique to a game session.
4781  
4782 =item *
4783  
4784 B<gameSessionProperties> -- Custom data defined in a game session's
4785 C<GameProperty> parameter. C<GameProperty> values are stored as
4786 key:value pairs; the filter expression must indicate the key and a
4787 string to search the data values for. For example, to search for game
4788 sessions with custom data containing the key:value pair
4789 "gameMode:brawl", specify the following:
4790 C<gameSessionProperties.gameMode = "brawl">. All custom data values are
4791 searched as strings.
4792  
4793 =item *
4794  
4795 B<maximumSessions> -- Maximum number of player sessions allowed for a
4796 game session. This value is set when requesting a new game session with
4797 CreateGameSession or updating with UpdateGameSession.
4798  
4799 =item *
4800  
4801 B<creationTimeMillis> -- Value indicating when a game session was
4802 created. It is expressed in Unix time as milliseconds.
4803  
4804 =item *
4805  
4806 B<playerSessionCount> -- Number of players currently connected to a
4807 game session. This value changes rapidly as players join the session or
4808 drop out.
4809  
4810 =item *
4811  
4812 B<hasAvailablePlayerSessions> -- Boolean value indicating whether a
4813 game session has reached its maximum number of players. It is highly
4814 recommended that all search requests include this filter attribute to
4815 optimize search performance and return only sessions that players can
4816 join.
4817  
4818 =back
4819  
4820 Returned values for C<playerSessionCount> and
4821 C<hasAvailablePlayerSessions> change quickly as players join sessions
4822 and others drop out. Results should be considered a snapshot in time.
4823 Be sure to refresh search results often, and handle sessions that fill
4824 up before a player can join.
4825  
4826 B<Related actions>
4827  
4828 CreateGameSession | DescribeGameSessions | DescribeGameSessionDetails |
4829 SearchGameSessions | UpdateGameSession | GetGameSessionLogUrl |
4830 StartGameSessionPlacement | DescribeGameSessionPlacement |
4831 StopGameSessionPlacement | All APIs by task
4832 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4833  
4834  
4835 =head2 StartFleetActions
4836  
4837 =over
4838  
4839 =item Actions => ArrayRef[Str|Undef]
4840  
4841 =item FleetId => Str
4842  
4843 =item [Location => Str]
4844  
4845  
4846 =back
4847  
4848 Each argument is described in detail in: L<Paws::GameLift::StartFleetActions>
4849  
4850 Returns: a L<Paws::GameLift::StartFleetActionsOutput> instance
4851  
4852 Resumes certain types of activity on fleet instances that were
4853 suspended with StopFleetActions. For multi-location fleets, fleet
4854 actions are managed separately for each location. Currently, this
4855 operation is used to restart a fleet's auto-scaling activity.
4856  
4857 This operation can be used in the following ways:
4858  
4859 =over
4860  
4861 =item *
4862  
4863 To restart actions on instances in the fleet's home Region, provide a
4864 fleet ID and the type of actions to resume.
4865  
4866 =item *
4867  
4868 To restart actions on instances in one of the fleet's remote locations,
4869 provide a fleet ID, a location name, and the type of actions to resume.
4870  
4871 =back
4872  
4873 If successful, GameLift once again initiates scaling events as
4874 triggered by the fleet's scaling policies. If actions on the fleet
4875 location were never stopped, this operation will have no effect. You
4876 can view a fleet's stopped actions using DescribeFleetAttributes or
4877 DescribeFleetLocationAttributes.
4878  
4879 B<Learn more>
4880  
4881 Setting up GameLift fleets
4882 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
4883  
4884 B<Related actions>
4885  
4886 CreateFleet | UpdateFleetCapacity | PutScalingPolicy |
4887 DescribeEC2InstanceLimits | DescribeFleetAttributes |
4888 DescribeFleetLocationAttributes | UpdateFleetAttributes |
4889 StopFleetActions | DeleteFleet | All APIs by task
4890 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4891  
4892  
4893 =head2 StartGameSessionPlacement
4894  
4895 =over
4896  
4897 =item GameSessionQueueName => Str
4898  
4899 =item MaximumPlayerSessionCount => Int
4900  
4901 =item PlacementId => Str
4902  
4903 =item [DesiredPlayerSessions => ArrayRef[L<Paws::GameLift::DesiredPlayerSession>]]
4904  
4905 =item [GameProperties => ArrayRef[L<Paws::GameLift::GameProperty>]]
4906  
4907 =item [GameSessionData => Str]
4908  
4909 =item [GameSessionName => Str]
4910  
4911 =item [PlayerLatencies => ArrayRef[L<Paws::GameLift::PlayerLatency>]]
4912  
4913  
4914 =back
4915  
4916 Each argument is described in detail in: L<Paws::GameLift::StartGameSessionPlacement>
4917  
4918 Returns: a L<Paws::GameLift::StartGameSessionPlacementOutput> instance
4919  
4920 Places a request for a new game session in a queue (see
4921 CreateGameSessionQueue). When processing a placement request, Amazon
4922 GameLift searches for available resources on the queue's destinations,
4923 scanning each until it finds resources or the placement request times
4924 out.
4925  
4926 A game session placement request can also request player sessions. When
4927 a new game session is successfully created, Amazon GameLift creates a
4928 player session for each player included in the request.
4929  
4930 When placing a game session, by default Amazon GameLift tries each
4931 fleet in the order they are listed in the queue configuration. Ideally,
4932 a queue's destinations are listed in preference order.
4933  
4934 Alternatively, when requesting a game session with players, you can
4935 also provide latency data for each player in relevant Regions. Latency
4936 data indicates the performance lag a player experiences when connected
4937 to a fleet in the Region. Amazon GameLift uses latency data to reorder
4938 the list of destinations to place the game session in a Region with
4939 minimal lag. If latency data is provided for multiple players, Amazon
4940 GameLift calculates each Region's average lag for all players and
4941 reorders to get the best game play across all players.
4942  
4943 To place a new game session request, specify the following:
4944  
4945 =over
4946  
4947 =item *
4948  
4949 The queue name and a set of game session properties and settings
4950  
4951 =item *
4952  
4953 A unique ID (such as a UUID) for the placement. You use this ID to
4954 track the status of the placement request
4955  
4956 =item *
4957  
4958 (Optional) A set of player data and a unique player ID for each player
4959 that you are joining to the new game session (player data is optional,
4960 but if you include it, you must also provide a unique ID for each
4961 player)
4962  
4963 =item *
4964  
4965 Latency data for all players (if you want to optimize game play for the
4966 players)
4967  
4968 =back
4969  
4970 If successful, a new game session placement is created.
4971  
4972 To track the status of a placement request, call
4973 DescribeGameSessionPlacement and check the request's status. If the
4974 status is C<FULFILLED>, a new game session has been created and a game
4975 session ARN and Region are referenced. If the placement request times
4976 out, you can resubmit the request or retry it with a different queue.
4977  
4978 B<Related actions>
4979  
4980 CreateGameSession | DescribeGameSessions | DescribeGameSessionDetails |
4981 SearchGameSessions | UpdateGameSession | GetGameSessionLogUrl |
4982 StartGameSessionPlacement | DescribeGameSessionPlacement |
4983 StopGameSessionPlacement | All APIs by task
4984 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
4985  
4986  
4987 =head2 StartMatchBackfill
4988  
4989 =over
4990  
4991 =item ConfigurationName => Str
4992  
4993 =item Players => ArrayRef[L<Paws::GameLift::Player>]
4994  
4995 =item [GameSessionArn => Str]
4996  
4997 =item [TicketId => Str]
4998  
4999  
5000 =back
5001  
5002 Each argument is described in detail in: L<Paws::GameLift::StartMatchBackfill>
5003  
5004 Returns: a L<Paws::GameLift::StartMatchBackfillOutput> instance
5005  
5006 Finds new players to fill open slots in currently running game
5007 sessions. The backfill match process is essentially identical to the
5008 process of forming new matches. Backfill requests use the same
5009 matchmaker that was used to make the original match, and they provide
5010 matchmaking data for all players currently in the game session.
5011 FlexMatch uses this information to select new players so that
5012 backfilled match continues to meet the original match requirements.
5013  
5014 When using FlexMatch with GameLift managed hosting, you can request a
5015 backfill match from a client service by calling this operation with a
5016 GameSession identifier. You also have the option of making backfill
5017 requests directly from your game server. In response to a request,
5018 FlexMatch creates player sessions for the new players, updates the
5019 C<GameSession> resource, and sends updated matchmaking data to the game
5020 server. You can request a backfill match at any point after a game
5021 session is started. Each game session can have only one active backfill
5022 request at a time; a subsequent request automatically replaces the
5023 earlier request.
5024  
5025 When using FlexMatch as a standalone component, request a backfill
5026 match by calling this operation without a game session identifier. As
5027 with newly formed matches, matchmaking results are returned in a
5028 matchmaking event so that your game can update the game session that is
5029 being backfilled.
5030  
5031 To request a backfill match, specify a unique ticket ID, the original
5032 matchmaking configuration, and matchmaking data for all current players
5033 in the game session being backfilled. Optionally, specify the
5034 C<GameSession> ARN. If successful, a match backfill ticket is created
5035 and returned with status set to QUEUED. Track the status of backfill
5036 tickets using the same method for tracking tickets for new matches.
5037  
5038 B<Learn more>
5039  
5040 Backfill existing games with FlexMatch
5041 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-backfill.html)
5042  
5043 Matchmaking events
5044 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-events.html)
5045 (reference)
5046  
5047 How GameLift FlexMatch works
5048 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/gamelift-match.html)
5049  
5050 B<Related actions>
5051  
5052 StartMatchmaking | DescribeMatchmaking | StopMatchmaking | AcceptMatch
5053 | StartMatchBackfill | All APIs by task
5054 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5055  
5056  
5057 =head2 StartMatchmaking
5058  
5059 =over
5060  
5061 =item ConfigurationName => Str
5062  
5063 =item Players => ArrayRef[L<Paws::GameLift::Player>]
5064  
5065 =item [TicketId => Str]
5066  
5067  
5068 =back
5069  
5070 Each argument is described in detail in: L<Paws::GameLift::StartMatchmaking>
5071  
5072 Returns: a L<Paws::GameLift::StartMatchmakingOutput> instance
5073  
5074 Uses FlexMatch to create a game match for a group of players based on
5075 custom matchmaking rules. With games that use GameLift managed hosting,
5076 this operation also triggers GameLift to find hosting resources and
5077 start a new game session for the new match. Each matchmaking request
5078 includes information on one or more players and specifies the FlexMatch
5079 matchmaker to use. When a request is for multiple players, FlexMatch
5080 attempts to build a match that includes all players in the request,
5081 placing them in the same team and finding additional players as needed
5082 to fill the match.
5083  
5084 To start matchmaking, provide a unique ticket ID, specify a matchmaking
5085 configuration, and include the players to be matched. You must also
5086 include any player attributes that are required by the matchmaking
5087 configuration's rule set. If successful, a matchmaking ticket is
5088 returned with status set to C<QUEUED>.
5089  
5090 Track matchmaking events to respond as needed and acquire game session
5091 connection information for successfully completed matches. Ticket
5092 status updates are tracked using event notification through Amazon
5093 Simple Notification Service (SNS), which is defined in the matchmaking
5094 configuration.
5095  
5096 B<Learn more>
5097  
5098 Add FlexMatch to a game client
5099 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-client.html)
5100  
5101 Set Up FlexMatch event notification
5102 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-notification.html)
5103  
5104 How GameLift FlexMatch works
5105 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/gamelift-match.html)
5106  
5107 B<Related actions>
5108  
5109 StartMatchmaking | DescribeMatchmaking | StopMatchmaking | AcceptMatch
5110 | StartMatchBackfill | All APIs by task
5111 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5112  
5113  
5114 =head2 StopFleetActions
5115  
5116 =over
5117  
5118 =item Actions => ArrayRef[Str|Undef]
5119  
5120 =item FleetId => Str
5121  
5122 =item [Location => Str]
5123  
5124  
5125 =back
5126  
5127 Each argument is described in detail in: L<Paws::GameLift::StopFleetActions>
5128  
5129 Returns: a L<Paws::GameLift::StopFleetActionsOutput> instance
5130  
5131 Suspends certain types of activity in a fleet location. Currently, this
5132 operation is used to stop auto-scaling activity. For multi-location
5133 fleets, fleet actions are managed separately for each location.
5134  
5135 Stopping fleet actions has several potential purposes. It allows you to
5136 temporarily stop auto-scaling activity but retain your scaling policies
5137 for use in the future. For multi-location fleets, you can set up
5138 fleet-wide auto-scaling, and then opt out of it for certain locations.
5139  
5140 This operation can be used in the following ways:
5141  
5142 =over
5143  
5144 =item *
5145  
5146 To stop actions on instances in the fleet's home Region, provide a
5147 fleet ID and the type of actions to suspend.
5148  
5149 =item *
5150  
5151 To stop actions on instances in one of the fleet's remote locations,
5152 provide a fleet ID, a location name, and the type of actions to
5153 suspend.
5154  
5155 =back
5156  
5157 If successful, GameLift no longer initiates scaling events except in
5158 response to manual changes using UpdateFleetCapacity. You can view a
5159 fleet's stopped actions using DescribeFleetAttributes or
5160 DescribeFleetLocationAttributes. Suspended activity can be restarted
5161 using StartFleetActions.
5162  
5163 B<Learn more>
5164  
5165 Setting up GameLift Fleets
5166 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
5167  
5168 B<Related actions>
5169  
5170 CreateFleet | UpdateFleetCapacity | PutScalingPolicy |
5171 DescribeEC2InstanceLimits | DescribeFleetAttributes |
5172 DescribeFleetLocationAttributes | UpdateFleetAttributes |
5173 StopFleetActions | DeleteFleet | All APIs by task
5174 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5175  
5176  
5177 =head2 StopGameSessionPlacement
5178  
5179 =over
5180  
5181 =item PlacementId => Str
5182  
5183  
5184 =back
5185  
5186 Each argument is described in detail in: L<Paws::GameLift::StopGameSessionPlacement>
5187  
5188 Returns: a L<Paws::GameLift::StopGameSessionPlacementOutput> instance
5189  
5190 Cancels a game session placement that is in C<PENDING> status. To stop
5191 a placement, provide the placement ID values. If successful, the
5192 placement is moved to C<CANCELLED> status.
5193  
5194 B<Related actions>
5195  
5196 CreateGameSession | DescribeGameSessions | DescribeGameSessionDetails |
5197 SearchGameSessions | UpdateGameSession | GetGameSessionLogUrl |
5198 StartGameSessionPlacement | DescribeGameSessionPlacement |
5199 StopGameSessionPlacement | All APIs by task
5200 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5201  
5202  
5203 =head2 StopMatchmaking
5204  
5205 =over
5206  
5207 =item TicketId => Str
5208  
5209  
5210 =back
5211  
5212 Each argument is described in detail in: L<Paws::GameLift::StopMatchmaking>
5213  
5214 Returns: a L<Paws::GameLift::StopMatchmakingOutput> instance
5215  
5216 Cancels a matchmaking ticket or match backfill ticket that is currently
5217 being processed. To stop the matchmaking operation, specify the ticket
5218 ID. If successful, work on the ticket is stopped, and the ticket status
5219 is changed to C<CANCELLED>.
5220  
5221 This call is also used to turn off automatic backfill for an individual
5222 game session. This is for game sessions that are created with a
5223 matchmaking configuration that has automatic backfill enabled. The
5224 ticket ID is included in the C<MatchmakerData> of an updated game
5225 session object, which is provided to the game server.
5226  
5227 If the operation is successful, the service sends back an empty JSON
5228 struct with the HTTP 200 response (not an empty HTTP body).
5229  
5230 B<Learn more>
5231  
5232 Add FlexMatch to a game client
5233 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-client.html)
5234  
5235 B<Related actions>
5236  
5237 StartMatchmaking | DescribeMatchmaking | StopMatchmaking | AcceptMatch
5238 | StartMatchBackfill | All APIs by task
5239 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5240  
5241  
5242 =head2 SuspendGameServerGroup
5243  
5244 =over
5245  
5246 =item GameServerGroupName => Str
5247  
5248 =item SuspendActions => ArrayRef[Str|Undef]
5249  
5250  
5251 =back
5252  
5253 Each argument is described in detail in: L<Paws::GameLift::SuspendGameServerGroup>
5254  
5255 Returns: a L<Paws::GameLift::SuspendGameServerGroupOutput> instance
5256  
5257 B<This operation is used with the GameLift FleetIQ solution and game
5258 server groups.>
5259  
5260 Temporarily stops activity on a game server group without terminating
5261 instances or the game server group. You can restart activity by calling
5262 ResumeGameServerGroup. You can suspend the following activity:
5263  
5264 =over
5265  
5266 =item *
5267  
5268 B<Instance type replacement> - This activity evaluates the current game
5269 hosting viability of all Spot instance types that are defined for the
5270 game server group. It updates the Auto Scaling group to remove
5271 nonviable Spot Instance types, which have a higher chance of game
5272 server interruptions. It then balances capacity across the remaining
5273 viable Spot Instance types. When this activity is suspended, the Auto
5274 Scaling group continues with its current balance, regardless of
5275 viability. Instance protection, utilization metrics, and capacity
5276 scaling activities continue to be active.
5277  
5278 =back
5279  
5280 To suspend activity, specify a game server group ARN and the type of
5281 activity to be suspended. If successful, a GameServerGroup object is
5282 returned showing that the activity is listed in C<SuspendedActions>.
5283  
5284 B<Learn more>
5285  
5286 GameLift FleetIQ Guide
5287 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
5288  
5289 B<Related actions>
5290  
5291 CreateGameServerGroup | ListGameServerGroups | DescribeGameServerGroup
5292 | UpdateGameServerGroup | DeleteGameServerGroup | ResumeGameServerGroup
5293 | SuspendGameServerGroup | DescribeGameServerInstances | All APIs by
5294 task
5295 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
5296  
5297  
5298 =head2 TagResource
5299  
5300 =over
5301  
5302 =item ResourceARN => Str
5303  
5304 =item Tags => ArrayRef[L<Paws::GameLift::Tag>]
5305  
5306  
5307 =back
5308  
5309 Each argument is described in detail in: L<Paws::GameLift::TagResource>
5310  
5311 Returns: a L<Paws::GameLift::TagResourceResponse> instance
5312  
5313 Assigns a tag to a GameLift resource. AWS resource tags provide an
5314 additional management tool set. You can use tags to organize resources,
5315 create IAM permissions policies to manage access to groups of
5316 resources, customize AWS cost breakdowns, etc. This operation handles
5317 the permissions necessary to manage tags for the following GameLift
5318 resource types:
5319  
5320 =over
5321  
5322 =item *
5323  
5324 Build
5325  
5326 =item *
5327  
5328 Script
5329  
5330 =item *
5331  
5332 Fleet
5333  
5334 =item *
5335  
5336 Alias
5337  
5338 =item *
5339  
5340 GameSessionQueue
5341  
5342 =item *
5343  
5344 MatchmakingConfiguration
5345  
5346 =item *
5347  
5348 MatchmakingRuleSet
5349  
5350 =back
5351  
5352 To add a tag to a resource, specify the unique ARN value for the
5353 resource and provide a tag list containing one or more tags. The
5354 operation succeeds even if the list includes tags that are already
5355 assigned to the specified resource.
5356  
5357 B<Learn more>
5358  
5359 Tagging AWS Resources
5360 (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in the
5361 I<AWS General Reference>
5362  
5363 AWS Tagging Strategies
5364 (http://aws.amazon.com/answers/account-management/aws-tagging-strategies/)
5365  
5366 B<Related actions>
5367  
5368 TagResource | UntagResource | ListTagsForResource | All APIs by task
5369 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5370  
5371  
5372 =head2 UntagResource
5373  
5374 =over
5375  
5376 =item ResourceARN => Str
5377  
5378 =item TagKeys => ArrayRef[Str|Undef]
5379  
5380  
5381 =back
5382  
5383 Each argument is described in detail in: L<Paws::GameLift::UntagResource>
5384  
5385 Returns: a L<Paws::GameLift::UntagResourceResponse> instance
5386  
5387 Removes a tag that is assigned to a GameLift resource. Resource tags
5388 are used to organize AWS resources for a range of purposes. This
5389 operation handles the permissions necessary to manage tags for the
5390 following GameLift resource types:
5391  
5392 =over
5393  
5394 =item *
5395  
5396 Build
5397  
5398 =item *
5399  
5400 Script
5401  
5402 =item *
5403  
5404 Fleet
5405  
5406 =item *
5407  
5408 Alias
5409  
5410 =item *
5411  
5412 GameSessionQueue
5413  
5414 =item *
5415  
5416 MatchmakingConfiguration
5417  
5418 =item *
5419  
5420 MatchmakingRuleSet
5421  
5422 =back
5423  
5424 To remove a tag from a resource, specify the unique ARN value for the
5425 resource and provide a string list containing one or more tags to be
5426 removed. This operation succeeds even if the list includes tags that
5427 are not currently assigned to the specified resource.
5428  
5429 B<Learn more>
5430  
5431 Tagging AWS Resources
5432 (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in the
5433 I<AWS General Reference>
5434  
5435 AWS Tagging Strategies
5436 (http://aws.amazon.com/answers/account-management/aws-tagging-strategies/)
5437  
5438 B<Related actions>
5439  
5440 TagResource | UntagResource | ListTagsForResource | All APIs by task
5441 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5442  
5443  
5444 =head2 UpdateAlias
5445  
5446 =over
5447  
5448 =item AliasId => Str
5449  
5450 =item [Description => Str]
5451  
5452 =item [Name => Str]
5453  
5454 =item [RoutingStrategy => L<Paws::GameLift::RoutingStrategy>]
5455  
5456  
5457 =back
5458  
5459 Each argument is described in detail in: L<Paws::GameLift::UpdateAlias>
5460  
5461 Returns: a L<Paws::GameLift::UpdateAliasOutput> instance
5462  
5463 Updates properties for an alias. To update properties, specify the
5464 alias ID to be updated and provide the information to be changed. To
5465 reassign an alias to another fleet, provide an updated routing
5466 strategy. If successful, the updated alias record is returned.
5467  
5468 B<Related actions>
5469  
5470 CreateAlias | ListAliases | DescribeAlias | UpdateAlias | DeleteAlias |
5471 ResolveAlias | All APIs by task
5472 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5473  
5474  
5475 =head2 UpdateBuild
5476  
5477 =over
5478  
5479 =item BuildId => Str
5480  
5481 =item [Name => Str]
5482  
5483 =item [Version => Str]
5484  
5485  
5486 =back
5487  
5488 Each argument is described in detail in: L<Paws::GameLift::UpdateBuild>
5489  
5490 Returns: a L<Paws::GameLift::UpdateBuildOutput> instance
5491  
5492 Updates metadata in a build resource, including the build name and
5493 version. To update the metadata, specify the build ID to update and
5494 provide the new values. If successful, a build object containing the
5495 updated metadata is returned.
5496  
5497 B<Learn more>
5498  
5499 Upload a Custom Server Build
5500 (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-build-intro.html)
5501  
5502 B<Related actions>
5503  
5504 CreateBuild | ListBuilds | DescribeBuild | UpdateBuild | DeleteBuild |
5505 All APIs by task
5506 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5507  
5508  
5509 =head2 UpdateFleetAttributes
5510  
5511 =over
5512  
5513 =item FleetId => Str
5514  
5515 =item [Description => Str]
5516  
5517 =item [MetricGroups => ArrayRef[Str|Undef]]
5518  
5519 =item [Name => Str]
5520  
5521 =item [NewGameSessionProtectionPolicy => Str]
5522  
5523 =item [ResourceCreationLimitPolicy => L<Paws::GameLift::ResourceCreationLimitPolicy>]
5524  
5525  
5526 =back
5527  
5528 Each argument is described in detail in: L<Paws::GameLift::UpdateFleetAttributes>
5529  
5530 Returns: a L<Paws::GameLift::UpdateFleetAttributesOutput> instance
5531  
5532 Updates a fleet's mutable attributes, including game session protection
5533 and resource creation limits.
5534  
5535 To update fleet attributes, specify the fleet ID and the property
5536 values that you want to change.
5537  
5538 If successful, an updated C<FleetAttributes> object is returned.
5539  
5540 B<Learn more>
5541  
5542 Setting up GameLift fleets
5543 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
5544  
5545 B<Related actions>
5546  
5547 CreateFleetLocations | UpdateFleetAttributes | UpdateFleetCapacity |
5548 UpdateFleetPortSettings | UpdateRuntimeConfiguration | StopFleetActions
5549 | StartFleetActions | PutScalingPolicy | DeleteFleet |
5550 DeleteFleetLocations | DeleteScalingPolicy | All APIs by task
5551 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5552  
5553  
5554 =head2 UpdateFleetCapacity
5555  
5556 =over
5557  
5558 =item FleetId => Str
5559  
5560 =item [DesiredInstances => Int]
5561  
5562 =item [Location => Str]
5563  
5564 =item [MaxSize => Int]
5565  
5566 =item [MinSize => Int]
5567  
5568  
5569 =back
5570  
5571 Each argument is described in detail in: L<Paws::GameLift::UpdateFleetCapacity>
5572  
5573 Returns: a L<Paws::GameLift::UpdateFleetCapacityOutput> instance
5574  
5575 Updates capacity settings for a fleet. For fleets with multiple
5576 locations, use this operation to manage capacity settings in each
5577 location individually. Fleet capacity determines the number of game
5578 sessions and players that can be hosted based on the fleet
5579 configuration. Use this operation to set the following fleet capacity
5580 properties:
5581  
5582 =over
5583  
5584 =item *
5585  
5586 Minimum/maximum size: Set hard limits on fleet capacity. GameLift
5587 cannot set the fleet's capacity to a value outside of this range,
5588 whether the capacity is changed manually or through automatic scaling.
5589  
5590 =item *
5591  
5592 Desired capacity: Manually set the number of EC2 instances to be
5593 maintained in a fleet location. Before changing a fleet's desired
5594 capacity, you may want to call DescribeEC2InstanceLimits to get the
5595 maximum capacity of the fleet's EC2 instance type. Alternatively,
5596 consider using automatic scaling to adjust capacity based on player
5597 demand.
5598  
5599 =back
5600  
5601 This operation can be used in the following ways:
5602  
5603 =over
5604  
5605 =item *
5606  
5607 To update capacity for a fleet's home Region, or if the fleet has no
5608 remote locations, omit the C<Location> parameter. The fleet must be in
5609 C<ACTIVE> status.
5610  
5611 =item *
5612  
5613 To update capacity for a fleet's remote location, include the
5614 C<Location> parameter set to the location to be updated. The location
5615 must be in C<ACTIVE> status.
5616  
5617 =back
5618  
5619 If successful, capacity settings are updated immediately. In response a
5620 change in desired capacity, GameLift initiates steps to start new
5621 instances or terminate existing instances in the requested fleet
5622 location. This continues until the location's active instance count
5623 matches the new desired instance count. You can track a fleet's current
5624 capacity by calling DescribeFleetCapacity or
5625 DescribeFleetLocationCapacity. If the requested desired instance count
5626 is higher than the instance type's limit, the C<LimitExceeded>
5627 exception occurs.
5628  
5629 B<Learn more>
5630  
5631 Scaling fleet capacity
5632 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-manage-capacity.html)
5633  
5634 B<Related actions>
5635  
5636 CreateFleetLocations | UpdateFleetAttributes | UpdateFleetCapacity |
5637 UpdateFleetPortSettings | UpdateRuntimeConfiguration | StopFleetActions
5638 | StartFleetActions | PutScalingPolicy | DeleteFleet |
5639 DeleteFleetLocations | DeleteScalingPolicy | All APIs by task
5640 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5641  
5642  
5643 =head2 UpdateFleetPortSettings
5644  
5645 =over
5646  
5647 =item FleetId => Str
5648  
5649 =item [InboundPermissionAuthorizations => ArrayRef[L<Paws::GameLift::IpPermission>]]
5650  
5651 =item [InboundPermissionRevocations => ArrayRef[L<Paws::GameLift::IpPermission>]]
5652  
5653  
5654 =back
5655  
5656 Each argument is described in detail in: L<Paws::GameLift::UpdateFleetPortSettings>
5657  
5658 Returns: a L<Paws::GameLift::UpdateFleetPortSettingsOutput> instance
5659  
5660 Updates permissions that allow inbound traffic to connect to game
5661 sessions that are being hosted on instances in the fleet.
5662  
5663 To update settings, specify the fleet ID to be updated and specify the
5664 changes to be made. List the permissions you want to add in
5665 C<InboundPermissionAuthorizations>, and permissions you want to remove
5666 in C<InboundPermissionRevocations>. Permissions to be removed must
5667 match existing fleet permissions.
5668  
5669 If successful, the fleet ID for the updated fleet is returned. For
5670 fleets with remote locations, port setting updates can take time to
5671 propagate across all locations. You can check the status of updates in
5672 each location by calling C<DescribeFleetPortSettings> with a location
5673 name.
5674  
5675 B<Learn more>
5676  
5677 Setting up GameLift fleets
5678 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
5679  
5680 B<Related actions>
5681  
5682 CreateFleetLocations | UpdateFleetAttributes | UpdateFleetCapacity |
5683 UpdateFleetPortSettings | UpdateRuntimeConfiguration | StopFleetActions
5684 | StartFleetActions | PutScalingPolicy | DeleteFleet |
5685 DeleteFleetLocations | DeleteScalingPolicy | All APIs by task
5686 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5687  
5688  
5689 =head2 UpdateGameServer
5690  
5691 =over
5692  
5693 =item GameServerGroupName => Str
5694  
5695 =item GameServerId => Str
5696  
5697 =item [GameServerData => Str]
5698  
5699 =item [HealthCheck => Str]
5700  
5701 =item [UtilizationStatus => Str]
5702  
5703  
5704 =back
5705  
5706 Each argument is described in detail in: L<Paws::GameLift::UpdateGameServer>
5707  
5708 Returns: a L<Paws::GameLift::UpdateGameServerOutput> instance
5709  
5710 B<This operation is used with the GameLift FleetIQ solution and game
5711 server groups.>
5712  
5713 Updates information about a registered game server to help GameLift
5714 FleetIQ to track game server availability. This operation is called by
5715 a game server process that is running on an instance in a game server
5716 group.
5717  
5718 Use this operation to update the following types of game server
5719 information. You can make all three types of updates in the same
5720 request:
5721  
5722 =over
5723  
5724 =item *
5725  
5726 To update the game server's utilization status, identify the game
5727 server and game server group and specify the current utilization
5728 status. Use this status to identify when game servers are currently
5729 hosting games and when they are available to be claimed.
5730  
5731 =item *
5732  
5733 To report health status, identify the game server and game server group
5734 and set health check to C<HEALTHY>. If a game server does not report
5735 health status for a certain length of time, the game server is no
5736 longer considered healthy. As a result, it will be eventually
5737 deregistered from the game server group to avoid affecting utilization
5738 metrics. The best practice is to report health every 60 seconds.
5739  
5740 =item *
5741  
5742 To change game server metadata, provide updated game server data.
5743  
5744 =back
5745  
5746 Once a game server is successfully updated, the relevant statuses and
5747 timestamps are updated.
5748  
5749 B<Learn more>
5750  
5751 GameLift FleetIQ Guide
5752 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
5753  
5754 B<Related actions>
5755  
5756 RegisterGameServer | ListGameServers | ClaimGameServer |
5757 DescribeGameServer | UpdateGameServer | DeregisterGameServer | All APIs
5758 by task
5759 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
5760  
5761  
5762 =head2 UpdateGameServerGroup
5763  
5764 =over
5765  
5766 =item GameServerGroupName => Str
5767  
5768 =item [BalancingStrategy => Str]
5769  
5770 =item [GameServerProtectionPolicy => Str]
5771  
5772 =item [InstanceDefinitions => ArrayRef[L<Paws::GameLift::InstanceDefinition>]]
5773  
5774 =item [RoleArn => Str]
5775  
5776  
5777 =back
5778  
5779 Each argument is described in detail in: L<Paws::GameLift::UpdateGameServerGroup>
5780  
5781 Returns: a L<Paws::GameLift::UpdateGameServerGroupOutput> instance
5782  
5783 B<This operation is used with the GameLift FleetIQ solution and game
5784 server groups.>
5785  
5786 Updates GameLift FleetIQ-specific properties for a game server group.
5787 Many Auto Scaling group properties are updated on the Auto Scaling
5788 group directly, including the launch template, Auto Scaling policies,
5789 and maximum/minimum/desired instance counts.
5790  
5791 To update the game server group, specify the game server group ID and
5792 provide the updated values. Before applying the updates, the new values
5793 are validated to ensure that GameLift FleetIQ can continue to perform
5794 instance balancing activity. If successful, a GameServerGroup object is
5795 returned.
5796  
5797 B<Learn more>
5798  
5799 GameLift FleetIQ Guide
5800 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html)
5801  
5802 B<Related actions>
5803  
5804 CreateGameServerGroup | ListGameServerGroups | DescribeGameServerGroup
5805 | UpdateGameServerGroup | DeleteGameServerGroup | ResumeGameServerGroup
5806 | SuspendGameServerGroup | DescribeGameServerInstances | All APIs by
5807 task
5808 (https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html)
5809  
5810  
5811 =head2 UpdateGameSession
5812  
5813 =over
5814  
5815 =item GameSessionId => Str
5816  
5817 =item [MaximumPlayerSessionCount => Int]
5818  
5819 =item [Name => Str]
5820  
5821 =item [PlayerSessionCreationPolicy => Str]
5822  
5823 =item [ProtectionPolicy => Str]
5824  
5825  
5826 =back
5827  
5828 Each argument is described in detail in: L<Paws::GameLift::UpdateGameSession>
5829  
5830 Returns: a L<Paws::GameLift::UpdateGameSessionOutput> instance
5831  
5832 Updates the mutable properties of a game session.
5833  
5834 To update a game session, specify the game session ID and the values
5835 you want to change.
5836  
5837 If successful, the updated C<GameSession> object is returned.
5838  
5839 B<Related actions>
5840  
5841 CreateGameSession | DescribeGameSessions | DescribeGameSessionDetails |
5842 SearchGameSessions | UpdateGameSession | GetGameSessionLogUrl |
5843 StartGameSessionPlacement | DescribeGameSessionPlacement |
5844 StopGameSessionPlacement | All APIs by task
5845 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5846  
5847  
5848 =head2 UpdateGameSessionQueue
5849  
5850 =over
5851  
5852 =item Name => Str
5853  
5854 =item [CustomEventData => Str]
5855  
5856 =item [Destinations => ArrayRef[L<Paws::GameLift::GameSessionQueueDestination>]]
5857  
5858 =item [FilterConfiguration => L<Paws::GameLift::FilterConfiguration>]
5859  
5860 =item [NotificationTarget => Str]
5861  
5862 =item [PlayerLatencyPolicies => ArrayRef[L<Paws::GameLift::PlayerLatencyPolicy>]]
5863  
5864 =item [PriorityConfiguration => L<Paws::GameLift::PriorityConfiguration>]
5865  
5866 =item [TimeoutInSeconds => Int]
5867  
5868  
5869 =back
5870  
5871 Each argument is described in detail in: L<Paws::GameLift::UpdateGameSessionQueue>
5872  
5873 Returns: a L<Paws::GameLift::UpdateGameSessionQueueOutput> instance
5874  
5875 Updates the configuration of a game session queue, which determines how
5876 the queue processes new game session requests. To update settings,
5877 specify the queue name to be updated and provide the new settings. When
5878 updating destinations, provide a complete list of destinations.
5879  
5880 B<Learn more>
5881  
5882 Using Multi-Region Queues
5883 (https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-intro.html)
5884  
5885 B<Related actions>
5886  
5887 CreateGameSessionQueue | DescribeGameSessionQueues |
5888 UpdateGameSessionQueue | DeleteGameSessionQueue | All APIs by task
5889 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5890  
5891  
5892 =head2 UpdateMatchmakingConfiguration
5893  
5894 =over
5895  
5896 =item Name => Str
5897  
5898 =item [AcceptanceRequired => Bool]
5899  
5900 =item [AcceptanceTimeoutSeconds => Int]
5901  
5902 =item [AdditionalPlayerCount => Int]
5903  
5904 =item [BackfillMode => Str]
5905  
5906 =item [CustomEventData => Str]
5907  
5908 =item [Description => Str]
5909  
5910 =item [FlexMatchMode => Str]
5911  
5912 =item [GameProperties => ArrayRef[L<Paws::GameLift::GameProperty>]]
5913  
5914 =item [GameSessionData => Str]
5915  
5916 =item [GameSessionQueueArns => ArrayRef[Str|Undef]]
5917  
5918 =item [NotificationTarget => Str]
5919  
5920 =item [RequestTimeoutSeconds => Int]
5921  
5922 =item [RuleSetName => Str]
5923  
5924  
5925 =back
5926  
5927 Each argument is described in detail in: L<Paws::GameLift::UpdateMatchmakingConfiguration>
5928  
5929 Returns: a L<Paws::GameLift::UpdateMatchmakingConfigurationOutput> instance
5930  
5931 Updates settings for a FlexMatch matchmaking configuration. These
5932 changes affect all matches and game sessions that are created after the
5933 update. To update settings, specify the configuration name to be
5934 updated and provide the new settings.
5935  
5936 B<Learn more>
5937  
5938 Design a FlexMatch matchmaker
5939 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-configuration.html)
5940  
5941 B<Related actions>
5942  
5943 CreateMatchmakingConfiguration | DescribeMatchmakingConfigurations |
5944 UpdateMatchmakingConfiguration | DeleteMatchmakingConfiguration |
5945 CreateMatchmakingRuleSet | DescribeMatchmakingRuleSets |
5946 ValidateMatchmakingRuleSet | DeleteMatchmakingRuleSet | All APIs by
5947 task
5948 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5949  
5950  
5951 =head2 UpdateRuntimeConfiguration
5952  
5953 =over
5954  
5955 =item FleetId => Str
5956  
5957 =item RuntimeConfiguration => L<Paws::GameLift::RuntimeConfiguration>
5958  
5959  
5960 =back
5961  
5962 Each argument is described in detail in: L<Paws::GameLift::UpdateRuntimeConfiguration>
5963  
5964 Returns: a L<Paws::GameLift::UpdateRuntimeConfigurationOutput> instance
5965  
5966 Updates the current runtime configuration for the specified fleet,
5967 which tells GameLift how to launch server processes on all instances in
5968 the fleet. You can update a fleet's runtime configuration at any time
5969 after the fleet is created; it does not need to be in C<ACTIVE> status.
5970  
5971 To update runtime configuration, specify the fleet ID and provide a
5972 C<RuntimeConfiguration> with an updated set of server process
5973 configurations.
5974  
5975 If successful, the fleet's runtime configuration settings are updated.
5976 Each instance in the fleet regularly checks for and retrieves updated
5977 runtime configurations. Instances immediately begin complying with the
5978 new configuration by launching new server processes or not replacing
5979 existing processes when they shut down. Updating a fleet's runtime
5980 configuration never affects existing server processes.
5981  
5982 B<Learn more>
5983  
5984 Setting up GameLift fleets
5985 (https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html)
5986  
5987 B<Related actions>
5988  
5989 CreateFleetLocations | UpdateFleetAttributes | UpdateFleetCapacity |
5990 UpdateFleetPortSettings | UpdateRuntimeConfiguration | StopFleetActions
5991 | StartFleetActions | PutScalingPolicy | DeleteFleet |
5992 DeleteFleetLocations | DeleteScalingPolicy | All APIs by task
5993 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
5994  
5995  
5996 =head2 UpdateScript
5997  
5998 =over
5999  
6000 =item ScriptId => Str
6001  
6002 =item [Name => Str]
6003  
6004 =item [StorageLocation => L<Paws::GameLift::S3Location>]
6005  
6006 =item [Version => Str]
6007  
6008 =item [ZipFile => Str]
6009  
6010  
6011 =back
6012  
6013 Each argument is described in detail in: L<Paws::GameLift::UpdateScript>
6014  
6015 Returns: a L<Paws::GameLift::UpdateScriptOutput> instance
6016  
6017 Updates Realtime script metadata and content.
6018  
6019 To update script metadata, specify the script ID and provide updated
6020 name and/or version values.
6021  
6022 To update script content, provide an updated zip file by pointing to
6023 either a local file or an Amazon S3 bucket location. You can use either
6024 method regardless of how the original script was uploaded. Use the
6025 I<Version> parameter to track updates to the script.
6026  
6027 If the call is successful, the updated metadata is stored in the script
6028 record and a revised script is uploaded to the Amazon GameLift service.
6029 Once the script is updated and acquired by a fleet instance, the new
6030 version is used for all new game sessions.
6031  
6032 B<Learn more>
6033  
6034 Amazon GameLift Realtime Servers
6035 (https://docs.aws.amazon.com/gamelift/latest/developerguide/realtime-intro.html)
6036  
6037 B<Related actions>
6038  
6039 CreateScript | ListScripts | DescribeScript | UpdateScript |
6040 DeleteScript | All APIs by task
6041 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
6042  
6043  
6044 =head2 ValidateMatchmakingRuleSet
6045  
6046 =over
6047  
6048 =item RuleSetBody => Str
6049  
6050  
6051 =back
6052  
6053 Each argument is described in detail in: L<Paws::GameLift::ValidateMatchmakingRuleSet>
6054  
6055 Returns: a L<Paws::GameLift::ValidateMatchmakingRuleSetOutput> instance
6056  
6057 Validates the syntax of a matchmaking rule or rule set. This operation
6058 checks that the rule set is using syntactically correct JSON and that
6059 it conforms to allowed property expressions. To validate syntax,
6060 provide a rule set JSON string.
6061  
6062 B<Learn more>
6063  
6064 =over
6065  
6066 =item *
6067  
6068 Build a rule set
6069 (https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-rulesets.html)
6070  
6071 =back
6072  
6073 B<Related actions>
6074  
6075 CreateMatchmakingConfiguration | DescribeMatchmakingConfigurations |
6076 UpdateMatchmakingConfiguration | DeleteMatchmakingConfiguration |
6077 CreateMatchmakingRuleSet | DescribeMatchmakingRuleSets |
6078 ValidateMatchmakingRuleSet | DeleteMatchmakingRuleSet | All APIs by
6079 task
6080 (https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets)
6081  
6082  
6083  
6084  
6085 =head1 PAGINATORS
6086  
6087 Paginator methods are helpers that repetively call methods that return partial results
6088  
6089 =head2 DescribeAllFleetAttributes(sub { },[FleetIds => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
6090  
6091 =head2 DescribeAllFleetAttributes([FleetIds => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
6092  
6093  
6094 If passed a sub as first parameter, it will call the sub for each element found in :
6095  
6096 - FleetAttributes, passing the object as the first parameter, and the string 'FleetAttributes' as the second parameter
6097  
6098 If not, it will return a a L<Paws::GameLift::DescribeFleetAttributesOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6099  
6100  
6101 =head2 DescribeAllFleetCapacity(sub { },[FleetIds => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
6102  
6103 =head2 DescribeAllFleetCapacity([FleetIds => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
6104  
6105  
6106 If passed a sub as first parameter, it will call the sub for each element found in :
6107  
6108 - FleetCapacity, passing the object as the first parameter, and the string 'FleetCapacity' as the second parameter
6109  
6110 If not, it will return a a L<Paws::GameLift::DescribeFleetCapacityOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6111  
6112  
6113 =head2 DescribeAllFleetEvents(sub { },FleetId => Str, [EndTime => Str, Limit => Int, NextToken => Str, StartTime => Str])
6114  
6115 =head2 DescribeAllFleetEvents(FleetId => Str, [EndTime => Str, Limit => Int, NextToken => Str, StartTime => Str])
6116  
6117  
6118 If passed a sub as first parameter, it will call the sub for each element found in :
6119  
6120 - Events, passing the object as the first parameter, and the string 'Events' as the second parameter
6121  
6122 If not, it will return a a L<Paws::GameLift::DescribeFleetEventsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6123  
6124  
6125 =head2 DescribeAllFleetUtilization(sub { },[FleetIds => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
6126  
6127 =head2 DescribeAllFleetUtilization([FleetIds => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
6128  
6129  
6130 If passed a sub as first parameter, it will call the sub for each element found in :
6131  
6132 - FleetUtilization, passing the object as the first parameter, and the string 'FleetUtilization' as the second parameter
6133  
6134 If not, it will return a a L<Paws::GameLift::DescribeFleetUtilizationOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6135  
6136  
6137 =head2 DescribeAllGameServerInstances(sub { },GameServerGroupName => Str, [InstanceIds => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
6138  
6139 =head2 DescribeAllGameServerInstances(GameServerGroupName => Str, [InstanceIds => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
6140  
6141  
6142 If passed a sub as first parameter, it will call the sub for each element found in :
6143  
6144 - GameServerInstances, passing the object as the first parameter, and the string 'GameServerInstances' as the second parameter
6145  
6146 If not, it will return a a L<Paws::GameLift::DescribeGameServerInstancesOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6147  
6148  
6149 =head2 DescribeAllGameSessionDetails(sub { },[AliasId => Str, FleetId => Str, GameSessionId => Str, Limit => Int, Location => Str, NextToken => Str, StatusFilter => Str])
6150  
6151 =head2 DescribeAllGameSessionDetails([AliasId => Str, FleetId => Str, GameSessionId => Str, Limit => Int, Location => Str, NextToken => Str, StatusFilter => Str])
6152  
6153  
6154 If passed a sub as first parameter, it will call the sub for each element found in :
6155  
6156 - GameSessionDetails, passing the object as the first parameter, and the string 'GameSessionDetails' as the second parameter
6157  
6158 If not, it will return a a L<Paws::GameLift::DescribeGameSessionDetailsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6159  
6160  
6161 =head2 DescribeAllGameSessionQueues(sub { },[Limit => Int, Names => ArrayRef[Str|Undef], NextToken => Str])
6162  
6163 =head2 DescribeAllGameSessionQueues([Limit => Int, Names => ArrayRef[Str|Undef], NextToken => Str])
6164  
6165  
6166 If passed a sub as first parameter, it will call the sub for each element found in :
6167  
6168 - GameSessionQueues, passing the object as the first parameter, and the string 'GameSessionQueues' as the second parameter
6169  
6170 If not, it will return a a L<Paws::GameLift::DescribeGameSessionQueuesOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6171  
6172  
6173 =head2 DescribeAllGameSessions(sub { },[AliasId => Str, FleetId => Str, GameSessionId => Str, Limit => Int, Location => Str, NextToken => Str, StatusFilter => Str])
6174  
6175 =head2 DescribeAllGameSessions([AliasId => Str, FleetId => Str, GameSessionId => Str, Limit => Int, Location => Str, NextToken => Str, StatusFilter => Str])
6176  
6177  
6178 If passed a sub as first parameter, it will call the sub for each element found in :
6179  
6180 - GameSessions, passing the object as the first parameter, and the string 'GameSessions' as the second parameter
6181  
6182 If not, it will return a a L<Paws::GameLift::DescribeGameSessionsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6183  
6184  
6185 =head2 DescribeAllInstances(sub { },FleetId => Str, [InstanceId => Str, Limit => Int, Location => Str, NextToken => Str])
6186  
6187 =head2 DescribeAllInstances(FleetId => Str, [InstanceId => Str, Limit => Int, Location => Str, NextToken => Str])
6188  
6189  
6190 If passed a sub as first parameter, it will call the sub for each element found in :
6191  
6192 - Instances, passing the object as the first parameter, and the string 'Instances' as the second parameter
6193  
6194 If not, it will return a a L<Paws::GameLift::DescribeInstancesOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6195  
6196  
6197 =head2 DescribeAllMatchmakingConfigurations(sub { },[Limit => Int, Names => ArrayRef[Str|Undef], NextToken => Str, RuleSetName => Str])
6198  
6199 =head2 DescribeAllMatchmakingConfigurations([Limit => Int, Names => ArrayRef[Str|Undef], NextToken => Str, RuleSetName => Str])
6200  
6201  
6202 If passed a sub as first parameter, it will call the sub for each element found in :
6203  
6204 - Configurations, passing the object as the first parameter, and the string 'Configurations' as the second parameter
6205  
6206 If not, it will return a a L<Paws::GameLift::DescribeMatchmakingConfigurationsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6207  
6208  
6209 =head2 DescribeAllMatchmakingRuleSets(sub { },[Limit => Int, Names => ArrayRef[Str|Undef], NextToken => Str])
6210  
6211 =head2 DescribeAllMatchmakingRuleSets([Limit => Int, Names => ArrayRef[Str|Undef], NextToken => Str])
6212  
6213  
6214 If passed a sub as first parameter, it will call the sub for each element found in :
6215  
6216 - RuleSets, passing the object as the first parameter, and the string 'RuleSets' as the second parameter
6217  
6218 If not, it will return a a L<Paws::GameLift::DescribeMatchmakingRuleSetsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6219  
6220  
6221 =head2 DescribeAllPlayerSessions(sub { },[GameSessionId => Str, Limit => Int, NextToken => Str, PlayerId => Str, PlayerSessionId => Str, PlayerSessionStatusFilter => Str])
6222  
6223 =head2 DescribeAllPlayerSessions([GameSessionId => Str, Limit => Int, NextToken => Str, PlayerId => Str, PlayerSessionId => Str, PlayerSessionStatusFilter => Str])
6224  
6225  
6226 If passed a sub as first parameter, it will call the sub for each element found in :
6227  
6228 - PlayerSessions, passing the object as the first parameter, and the string 'PlayerSessions' as the second parameter
6229  
6230 If not, it will return a a L<Paws::GameLift::DescribePlayerSessionsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6231  
6232  
6233 =head2 DescribeAllScalingPolicies(sub { },FleetId => Str, [Limit => Int, Location => Str, NextToken => Str, StatusFilter => Str])
6234  
6235 =head2 DescribeAllScalingPolicies(FleetId => Str, [Limit => Int, Location => Str, NextToken => Str, StatusFilter => Str])
6236  
6237  
6238 If passed a sub as first parameter, it will call the sub for each element found in :
6239  
6240 - ScalingPolicies, passing the object as the first parameter, and the string 'ScalingPolicies' as the second parameter
6241  
6242 If not, it will return a a L<Paws::GameLift::DescribeScalingPoliciesOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6243  
6244  
6245 =head2 ListAllAliases(sub { },[Limit => Int, Name => Str, NextToken => Str, RoutingStrategyType => Str])
6246  
6247 =head2 ListAllAliases([Limit => Int, Name => Str, NextToken => Str, RoutingStrategyType => Str])
6248  
6249  
6250 If passed a sub as first parameter, it will call the sub for each element found in :
6251  
6252 - Aliases, passing the object as the first parameter, and the string 'Aliases' as the second parameter
6253  
6254 If not, it will return a a L<Paws::GameLift::ListAliasesOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6255  
6256  
6257 =head2 ListAllBuilds(sub { },[Limit => Int, NextToken => Str, Status => Str])
6258  
6259 =head2 ListAllBuilds([Limit => Int, NextToken => Str, Status => Str])
6260  
6261  
6262 If passed a sub as first parameter, it will call the sub for each element found in :
6263  
6264 - Builds, passing the object as the first parameter, and the string 'Builds' as the second parameter
6265  
6266 If not, it will return a a L<Paws::GameLift::ListBuildsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6267  
6268  
6269 =head2 ListAllFleets(sub { },[BuildId => Str, Limit => Int, NextToken => Str, ScriptId => Str])
6270  
6271 =head2 ListAllFleets([BuildId => Str, Limit => Int, NextToken => Str, ScriptId => Str])
6272  
6273  
6274 If passed a sub as first parameter, it will call the sub for each element found in :
6275  
6276 - FleetIds, passing the object as the first parameter, and the string 'FleetIds' as the second parameter
6277  
6278 If not, it will return a a L<Paws::GameLift::ListFleetsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6279  
6280  
6281 =head2 ListAllGameServerGroups(sub { },[Limit => Int, NextToken => Str])
6282  
6283 =head2 ListAllGameServerGroups([Limit => Int, NextToken => Str])
6284  
6285  
6286 If passed a sub as first parameter, it will call the sub for each element found in :
6287  
6288 - GameServerGroups, passing the object as the first parameter, and the string 'GameServerGroups' as the second parameter
6289  
6290 If not, it will return a a L<Paws::GameLift::ListGameServerGroupsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6291  
6292  
6293 =head2 ListAllGameServers(sub { },GameServerGroupName => Str, [Limit => Int, NextToken => Str, SortOrder => Str])
6294  
6295 =head2 ListAllGameServers(GameServerGroupName => Str, [Limit => Int, NextToken => Str, SortOrder => Str])
6296  
6297  
6298 If passed a sub as first parameter, it will call the sub for each element found in :
6299  
6300 - GameServers, passing the object as the first parameter, and the string 'GameServers' as the second parameter
6301  
6302 If not, it will return a a L<Paws::GameLift::ListGameServersOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6303  
6304  
6305 =head2 ListAllScripts(sub { },[Limit => Int, NextToken => Str])
6306  
6307 =head2 ListAllScripts([Limit => Int, NextToken => Str])
6308  
6309  
6310 If passed a sub as first parameter, it will call the sub for each element found in :
6311  
6312 - Scripts, passing the object as the first parameter, and the string 'Scripts' as the second parameter
6313  
6314 If not, it will return a a L<Paws::GameLift::ListScriptsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6315  
6316  
6317 =head2 SearchAllGameSessions(sub { },[AliasId => Str, FilterExpression => Str, FleetId => Str, Limit => Int, Location => Str, NextToken => Str, SortExpression => Str])
6318  
6319 =head2 SearchAllGameSessions([AliasId => Str, FilterExpression => Str, FleetId => Str, Limit => Int, Location => Str, NextToken => Str, SortExpression => Str])
6320  
6321  
6322 If passed a sub as first parameter, it will call the sub for each element found in :
6323  
6324 - GameSessions, passing the object as the first parameter, and the string 'GameSessions' as the second parameter
6325  
6326 If not, it will return a a L<Paws::GameLift::SearchGameSessionsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
6327  
6328  
6329  
6330  
6331  
6332 =head1 SEE ALSO
6333  
6334 This service class forms part of L<Paws>
6335  
6336 =head1 BUGS and CONTRIBUTIONS
6337  
6338 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
6339  
6340 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
6341  
6342 =cut
6343