1package Paws::IAM { 2 use Moose; 3 sub service { 'iam' } 4 sub version { '2010-05-08' } 5 sub flattened_arrays { 0 } 6 7 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::QueryCaller', 'Paws::Net::XMLResponse'; 8 9 has '+region_rules' => (default => sub { 10 my $regioninfo; 11 $regioninfo = [ 12 { 13 constraints => [ 14 [ 15 'region', 16 'startsWith', 17 'cn-' 18 ] 19 ], 20 uri => 'https://{service}.cn-north-1.amazonaws.com.cn' 21 }, 22 { 23 constraints => [ 24 [ 25 'region', 26 'startsWith', 27 'us-gov' 28 ] 29 ], 30 uri => 'https://{service}.us-gov.amazonaws.com' 31 }, 32 { 33 properties => { 34 credentialScope => { 35 region => 'us-east-1' 36 } 37 }, 38 uri => 'https://iam.amazonaws.com' 39 } 40 ]; 41 42 return $regioninfo; 43 }); 44 45 46 sub AddClientIDToOpenIDConnectProvider { 47 my $self = shift; 48 my $call_object = $self->new_with_coercions('Paws::IAM::AddClientIDToOpenIDConnectProvider', @_); 49 return $self->caller->do_call($self, $call_object); 50 } 51 sub AddRoleToInstanceProfile { 52 my $self = shift; 53 my $call_object = $self->new_with_coercions('Paws::IAM::AddRoleToInstanceProfile', @_); 54 return $self->caller->do_call($self, $call_object); 55 } 56 sub AddUserToGroup { 57 my $self = shift; 58 my $call_object = $self->new_with_coercions('Paws::IAM::AddUserToGroup', @_); 59 return $self->caller->do_call($self, $call_object); 60 } 61 sub AttachGroupPolicy { 62 my $self = shift; 63 my $call_object = $self->new_with_coercions('Paws::IAM::AttachGroupPolicy', @_); 64 return $self->caller->do_call($self, $call_object); 65 } 66 sub AttachRolePolicy { 67 my $self = shift; 68 my $call_object = $self->new_with_coercions('Paws::IAM::AttachRolePolicy', @_); 69 return $self->caller->do_call($self, $call_object); 70 } 71 sub AttachUserPolicy { 72 my $self = shift; 73 my $call_object = $self->new_with_coercions('Paws::IAM::AttachUserPolicy', @_); 74 return $self->caller->do_call($self, $call_object); 75 } 76 sub ChangePassword { 77 my $self = shift; 78 my $call_object = $self->new_with_coercions('Paws::IAM::ChangePassword', @_); 79 return $self->caller->do_call($self, $call_object); 80 } 81 sub CreateAccessKey { 82 my $self = shift; 83 my $call_object = $self->new_with_coercions('Paws::IAM::CreateAccessKey', @_); 84 return $self->caller->do_call($self, $call_object); 85 } 86 sub CreateAccountAlias { 87 my $self = shift; 88 my $call_object = $self->new_with_coercions('Paws::IAM::CreateAccountAlias', @_); 89 return $self->caller->do_call($self, $call_object); 90 } 91 sub CreateGroup { 92 my $self = shift; 93 my $call_object = $self->new_with_coercions('Paws::IAM::CreateGroup', @_); 94 return $self->caller->do_call($self, $call_object); 95 } 96 sub CreateInstanceProfile { 97 my $self = shift; 98 my $call_object = $self->new_with_coercions('Paws::IAM::CreateInstanceProfile', @_); 99 return $self->caller->do_call($self, $call_object); 100 } 101 sub CreateLoginProfile { 102 my $self = shift; 103 my $call_object = $self->new_with_coercions('Paws::IAM::CreateLoginProfile', @_); 104 return $self->caller->do_call($self, $call_object); 105 } 106 sub CreateOpenIDConnectProvider { 107 my $self = shift; 108 my $call_object = $self->new_with_coercions('Paws::IAM::CreateOpenIDConnectProvider', @_); 109 return $self->caller->do_call($self, $call_object); 110 } 111 sub CreatePolicy { 112 my $self = shift; 113 my $call_object = $self->new_with_coercions('Paws::IAM::CreatePolicy', @_); 114 return $self->caller->do_call($self, $call_object); 115 } 116 sub CreatePolicyVersion { 117 my $self = shift; 118 my $call_object = $self->new_with_coercions('Paws::IAM::CreatePolicyVersion', @_); 119 return $self->caller->do_call($self, $call_object); 120 } 121 sub CreateRole { 122 my $self = shift; 123 my $call_object = $self->new_with_coercions('Paws::IAM::CreateRole', @_); 124 return $self->caller->do_call($self, $call_object); 125 } 126 sub CreateSAMLProvider { 127 my $self = shift; 128 my $call_object = $self->new_with_coercions('Paws::IAM::CreateSAMLProvider', @_); 129 return $self->caller->do_call($self, $call_object); 130 } 131 sub CreateUser { 132 my $self = shift; 133 my $call_object = $self->new_with_coercions('Paws::IAM::CreateUser', @_); 134 return $self->caller->do_call($self, $call_object); 135 } 136 sub CreateVirtualMFADevice { 137 my $self = shift; 138 my $call_object = $self->new_with_coercions('Paws::IAM::CreateVirtualMFADevice', @_); 139 return $self->caller->do_call($self, $call_object); 140 } 141 sub DeactivateMFADevice { 142 my $self = shift; 143 my $call_object = $self->new_with_coercions('Paws::IAM::DeactivateMFADevice', @_); 144 return $self->caller->do_call($self, $call_object); 145 } 146 sub DeleteAccessKey { 147 my $self = shift; 148 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteAccessKey', @_); 149 return $self->caller->do_call($self, $call_object); 150 } 151 sub DeleteAccountAlias { 152 my $self = shift; 153 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteAccountAlias', @_); 154 return $self->caller->do_call($self, $call_object); 155 } 156 sub DeleteAccountPasswordPolicy { 157 my $self = shift; 158 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteAccountPasswordPolicy', @_); 159 return $self->caller->do_call($self, $call_object); 160 } 161 sub DeleteGroup { 162 my $self = shift; 163 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteGroup', @_); 164 return $self->caller->do_call($self, $call_object); 165 } 166 sub DeleteGroupPolicy { 167 my $self = shift; 168 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteGroupPolicy', @_); 169 return $self->caller->do_call($self, $call_object); 170 } 171 sub DeleteInstanceProfile { 172 my $self = shift; 173 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteInstanceProfile', @_); 174 return $self->caller->do_call($self, $call_object); 175 } 176 sub DeleteLoginProfile { 177 my $self = shift; 178 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteLoginProfile', @_); 179 return $self->caller->do_call($self, $call_object); 180 } 181 sub DeleteOpenIDConnectProvider { 182 my $self = shift; 183 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteOpenIDConnectProvider', @_); 184 return $self->caller->do_call($self, $call_object); 185 } 186 sub DeletePolicy { 187 my $self = shift; 188 my $call_object = $self->new_with_coercions('Paws::IAM::DeletePolicy', @_); 189 return $self->caller->do_call($self, $call_object); 190 } 191 sub DeletePolicyVersion { 192 my $self = shift; 193 my $call_object = $self->new_with_coercions('Paws::IAM::DeletePolicyVersion', @_); 194 return $self->caller->do_call($self, $call_object); 195 } 196 sub DeleteRole { 197 my $self = shift; 198 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteRole', @_); 199 return $self->caller->do_call($self, $call_object); 200 } 201 sub DeleteRolePolicy { 202 my $self = shift; 203 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteRolePolicy', @_); 204 return $self->caller->do_call($self, $call_object); 205 } 206 sub DeleteSAMLProvider { 207 my $self = shift; 208 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteSAMLProvider', @_); 209 return $self->caller->do_call($self, $call_object); 210 } 211 sub DeleteServerCertificate { 212 my $self = shift; 213 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteServerCertificate', @_); 214 return $self->caller->do_call($self, $call_object); 215 } 216 sub DeleteSigningCertificate { 217 my $self = shift; 218 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteSigningCertificate', @_); 219 return $self->caller->do_call($self, $call_object); 220 } 221 sub DeleteSSHPublicKey { 222 my $self = shift; 223 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteSSHPublicKey', @_); 224 return $self->caller->do_call($self, $call_object); 225 } 226 sub DeleteUser { 227 my $self = shift; 228 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteUser', @_); 229 return $self->caller->do_call($self, $call_object); 230 } 231 sub DeleteUserPolicy { 232 my $self = shift; 233 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteUserPolicy', @_); 234 return $self->caller->do_call($self, $call_object); 235 } 236 sub DeleteVirtualMFADevice { 237 my $self = shift; 238 my $call_object = $self->new_with_coercions('Paws::IAM::DeleteVirtualMFADevice', @_); 239 return $self->caller->do_call($self, $call_object); 240 } 241 sub DetachGroupPolicy { 242 my $self = shift; 243 my $call_object = $self->new_with_coercions('Paws::IAM::DetachGroupPolicy', @_); 244 return $self->caller->do_call($self, $call_object); 245 } 246 sub DetachRolePolicy { 247 my $self = shift; 248 my $call_object = $self->new_with_coercions('Paws::IAM::DetachRolePolicy', @_); 249 return $self->caller->do_call($self, $call_object); 250 } 251 sub DetachUserPolicy { 252 my $self = shift; 253 my $call_object = $self->new_with_coercions('Paws::IAM::DetachUserPolicy', @_); 254 return $self->caller->do_call($self, $call_object); 255 } 256 sub EnableMFADevice { 257 my $self = shift; 258 my $call_object = $self->new_with_coercions('Paws::IAM::EnableMFADevice', @_); 259 return $self->caller->do_call($self, $call_object); 260 } 261 sub GenerateCredentialReport { 262 my $self = shift; 263 my $call_object = $self->new_with_coercions('Paws::IAM::GenerateCredentialReport', @_); 264 return $self->caller->do_call($self, $call_object); 265 } 266 sub GetAccessKeyLastUsed { 267 my $self = shift; 268 my $call_object = $self->new_with_coercions('Paws::IAM::GetAccessKeyLastUsed', @_); 269 return $self->caller->do_call($self, $call_object); 270 } 271 sub GetAccountAuthorizationDetails { 272 my $self = shift; 273 my $call_object = $self->new_with_coercions('Paws::IAM::GetAccountAuthorizationDetails', @_); 274 return $self->caller->do_call($self, $call_object); 275 } 276 sub GetAccountPasswordPolicy { 277 my $self = shift; 278 my $call_object = $self->new_with_coercions('Paws::IAM::GetAccountPasswordPolicy', @_); 279 return $self->caller->do_call($self, $call_object); 280 } 281 sub GetAccountSummary { 282 my $self = shift; 283 my $call_object = $self->new_with_coercions('Paws::IAM::GetAccountSummary', @_); 284 return $self->caller->do_call($self, $call_object); 285 } 286 sub GetCredentialReport { 287 my $self = shift; 288 my $call_object = $self->new_with_coercions('Paws::IAM::GetCredentialReport', @_); 289 return $self->caller->do_call($self, $call_object); 290 } 291 sub GetGroup { 292 my $self = shift; 293 my $call_object = $self->new_with_coercions('Paws::IAM::GetGroup', @_); 294 return $self->caller->do_call($self, $call_object); 295 } 296 sub GetGroupPolicy { 297 my $self = shift; 298 my $call_object = $self->new_with_coercions('Paws::IAM::GetGroupPolicy', @_); 299 return $self->caller->do_call($self, $call_object); 300 } 301 sub GetInstanceProfile { 302 my $self = shift; 303 my $call_object = $self->new_with_coercions('Paws::IAM::GetInstanceProfile', @_); 304 return $self->caller->do_call($self, $call_object); 305 } 306 sub GetLoginProfile { 307 my $self = shift; 308 my $call_object = $self->new_with_coercions('Paws::IAM::GetLoginProfile', @_); 309 return $self->caller->do_call($self, $call_object); 310 } 311 sub GetOpenIDConnectProvider { 312 my $self = shift; 313 my $call_object = $self->new_with_coercions('Paws::IAM::GetOpenIDConnectProvider', @_); 314 return $self->caller->do_call($self, $call_object); 315 } 316 sub GetPolicy { 317 my $self = shift; 318 my $call_object = $self->new_with_coercions('Paws::IAM::GetPolicy', @_); 319 return $self->caller->do_call($self, $call_object); 320 } 321 sub GetPolicyVersion { 322 my $self = shift; 323 my $call_object = $self->new_with_coercions('Paws::IAM::GetPolicyVersion', @_); 324 return $self->caller->do_call($self, $call_object); 325 } 326 sub GetRole { 327 my $self = shift; 328 my $call_object = $self->new_with_coercions('Paws::IAM::GetRole', @_); 329 return $self->caller->do_call($self, $call_object); 330 } 331 sub GetRolePolicy { 332 my $self = shift; 333 my $call_object = $self->new_with_coercions('Paws::IAM::GetRolePolicy', @_); 334 return $self->caller->do_call($self, $call_object); 335 } 336 sub GetSAMLProvider { 337 my $self = shift; 338 my $call_object = $self->new_with_coercions('Paws::IAM::GetSAMLProvider', @_); 339 return $self->caller->do_call($self, $call_object); 340 } 341 sub GetServerCertificate { 342 my $self = shift; 343 my $call_object = $self->new_with_coercions('Paws::IAM::GetServerCertificate', @_); 344 return $self->caller->do_call($self, $call_object); 345 } 346 sub GetSSHPublicKey { 347 my $self = shift; 348 my $call_object = $self->new_with_coercions('Paws::IAM::GetSSHPublicKey', @_); 349 return $self->caller->do_call($self, $call_object); 350 } 351 sub GetUser { 352 my $self = shift; 353 my $call_object = $self->new_with_coercions('Paws::IAM::GetUser', @_); 354 return $self->caller->do_call($self, $call_object); 355 } 356 sub GetUserPolicy { 357 my $self = shift; 358 my $call_object = $self->new_with_coercions('Paws::IAM::GetUserPolicy', @_); 359 return $self->caller->do_call($self, $call_object); 360 } 361 sub ListAccessKeys { 362 my $self = shift; 363 my $call_object = $self->new_with_coercions('Paws::IAM::ListAccessKeys', @_); 364 return $self->caller->do_call($self, $call_object); 365 } 366 sub ListAccountAliases { 367 my $self = shift; 368 my $call_object = $self->new_with_coercions('Paws::IAM::ListAccountAliases', @_); 369 return $self->caller->do_call($self, $call_object); 370 } 371 sub ListAttachedGroupPolicies { 372 my $self = shift; 373 my $call_object = $self->new_with_coercions('Paws::IAM::ListAttachedGroupPolicies', @_); 374 return $self->caller->do_call($self, $call_object); 375 } 376 sub ListAttachedRolePolicies { 377 my $self = shift; 378 my $call_object = $self->new_with_coercions('Paws::IAM::ListAttachedRolePolicies', @_); 379 return $self->caller->do_call($self, $call_object); 380 } 381 sub ListAttachedUserPolicies { 382 my $self = shift; 383 my $call_object = $self->new_with_coercions('Paws::IAM::ListAttachedUserPolicies', @_); 384 return $self->caller->do_call($self, $call_object); 385 } 386 sub ListEntitiesForPolicy { 387 my $self = shift; 388 my $call_object = $self->new_with_coercions('Paws::IAM::ListEntitiesForPolicy', @_); 389 return $self->caller->do_call($self, $call_object); 390 } 391 sub ListGroupPolicies { 392 my $self = shift; 393 my $call_object = $self->new_with_coercions('Paws::IAM::ListGroupPolicies', @_); 394 return $self->caller->do_call($self, $call_object); 395 } 396 sub ListGroups { 397 my $self = shift; 398 my $call_object = $self->new_with_coercions('Paws::IAM::ListGroups', @_); 399 return $self->caller->do_call($self, $call_object); 400 } 401 sub ListGroupsForUser { 402 my $self = shift; 403 my $call_object = $self->new_with_coercions('Paws::IAM::ListGroupsForUser', @_); 404 return $self->caller->do_call($self, $call_object); 405 } 406 sub ListInstanceProfiles { 407 my $self = shift; 408 my $call_object = $self->new_with_coercions('Paws::IAM::ListInstanceProfiles', @_); 409 return $self->caller->do_call($self, $call_object); 410 } 411 sub ListInstanceProfilesForRole { 412 my $self = shift; 413 my $call_object = $self->new_with_coercions('Paws::IAM::ListInstanceProfilesForRole', @_); 414 return $self->caller->do_call($self, $call_object); 415 } 416 sub ListMFADevices { 417 my $self = shift; 418 my $call_object = $self->new_with_coercions('Paws::IAM::ListMFADevices', @_); 419 return $self->caller->do_call($self, $call_object); 420 } 421 sub ListOpenIDConnectProviders { 422 my $self = shift; 423 my $call_object = $self->new_with_coercions('Paws::IAM::ListOpenIDConnectProviders', @_); 424 return $self->caller->do_call($self, $call_object); 425 } 426 sub ListPolicies { 427 my $self = shift; 428 my $call_object = $self->new_with_coercions('Paws::IAM::ListPolicies', @_); 429 return $self->caller->do_call($self, $call_object); 430 } 431 sub ListPolicyVersions { 432 my $self = shift; 433 my $call_object = $self->new_with_coercions('Paws::IAM::ListPolicyVersions', @_); 434 return $self->caller->do_call($self, $call_object); 435 } 436 sub ListRolePolicies { 437 my $self = shift; 438 my $call_object = $self->new_with_coercions('Paws::IAM::ListRolePolicies', @_); 439 return $self->caller->do_call($self, $call_object); 440 } 441 sub ListRoles { 442 my $self = shift; 443 my $call_object = $self->new_with_coercions('Paws::IAM::ListRoles', @_); 444 return $self->caller->do_call($self, $call_object); 445 } 446 sub ListSAMLProviders { 447 my $self = shift; 448 my $call_object = $self->new_with_coercions('Paws::IAM::ListSAMLProviders', @_); 449 return $self->caller->do_call($self, $call_object); 450 } 451 sub ListServerCertificates { 452 my $self = shift; 453 my $call_object = $self->new_with_coercions('Paws::IAM::ListServerCertificates', @_); 454 return $self->caller->do_call($self, $call_object); 455 } 456 sub ListSigningCertificates { 457 my $self = shift; 458 my $call_object = $self->new_with_coercions('Paws::IAM::ListSigningCertificates', @_); 459 return $self->caller->do_call($self, $call_object); 460 } 461 sub ListSSHPublicKeys { 462 my $self = shift; 463 my $call_object = $self->new_with_coercions('Paws::IAM::ListSSHPublicKeys', @_); 464 return $self->caller->do_call($self, $call_object); 465 } 466 sub ListUserPolicies { 467 my $self = shift; 468 my $call_object = $self->new_with_coercions('Paws::IAM::ListUserPolicies', @_); 469 return $self->caller->do_call($self, $call_object); 470 } 471 sub ListUsers { 472 my $self = shift; 473 my $call_object = $self->new_with_coercions('Paws::IAM::ListUsers', @_); 474 return $self->caller->do_call($self, $call_object); 475 } 476 sub ListVirtualMFADevices { 477 my $self = shift; 478 my $call_object = $self->new_with_coercions('Paws::IAM::ListVirtualMFADevices', @_); 479 return $self->caller->do_call($self, $call_object); 480 } 481 sub PutGroupPolicy { 482 my $self = shift; 483 my $call_object = $self->new_with_coercions('Paws::IAM::PutGroupPolicy', @_); 484 return $self->caller->do_call($self, $call_object); 485 } 486 sub PutRolePolicy { 487 my $self = shift; 488 my $call_object = $self->new_with_coercions('Paws::IAM::PutRolePolicy', @_); 489 return $self->caller->do_call($self, $call_object); 490 } 491 sub PutUserPolicy { 492 my $self = shift; 493 my $call_object = $self->new_with_coercions('Paws::IAM::PutUserPolicy', @_); 494 return $self->caller->do_call($self, $call_object); 495 } 496 sub RemoveClientIDFromOpenIDConnectProvider { 497 my $self = shift; 498 my $call_object = $self->new_with_coercions('Paws::IAM::RemoveClientIDFromOpenIDConnectProvider', @_); 499 return $self->caller->do_call($self, $call_object); 500 } 501 sub RemoveRoleFromInstanceProfile { 502 my $self = shift; 503 my $call_object = $self->new_with_coercions('Paws::IAM::RemoveRoleFromInstanceProfile', @_); 504 return $self->caller->do_call($self, $call_object); 505 } 506 sub RemoveUserFromGroup { 507 my $self = shift; 508 my $call_object = $self->new_with_coercions('Paws::IAM::RemoveUserFromGroup', @_); 509 return $self->caller->do_call($self, $call_object); 510 } 511 sub ResyncMFADevice { 512 my $self = shift; 513 my $call_object = $self->new_with_coercions('Paws::IAM::ResyncMFADevice', @_); 514 return $self->caller->do_call($self, $call_object); 515 } 516 sub SetDefaultPolicyVersion { 517 my $self = shift; 518 my $call_object = $self->new_with_coercions('Paws::IAM::SetDefaultPolicyVersion', @_); 519 return $self->caller->do_call($self, $call_object); 520 } 521 sub UpdateAccessKey { 522 my $self = shift; 523 my $call_object = $self->new_with_coercions('Paws::IAM::UpdateAccessKey', @_); 524 return $self->caller->do_call($self, $call_object); 525 } 526 sub UpdateAccountPasswordPolicy { 527 my $self = shift; 528 my $call_object = $self->new_with_coercions('Paws::IAM::UpdateAccountPasswordPolicy', @_); 529 return $self->caller->do_call($self, $call_object); 530 } 531 sub UpdateAssumeRolePolicy { 532 my $self = shift; 533 my $call_object = $self->new_with_coercions('Paws::IAM::UpdateAssumeRolePolicy', @_); 534 return $self->caller->do_call($self, $call_object); 535 } 536 sub UpdateGroup { 537 my $self = shift; 538 my $call_object = $self->new_with_coercions('Paws::IAM::UpdateGroup', @_); 539 return $self->caller->do_call($self, $call_object); 540 } 541 sub UpdateLoginProfile { 542 my $self = shift; 543 my $call_object = $self->new_with_coercions('Paws::IAM::UpdateLoginProfile', @_); 544 return $self->caller->do_call($self, $call_object); 545 } 546 sub UpdateOpenIDConnectProviderThumbprint { 547 my $self = shift; 548 my $call_object = $self->new_with_coercions('Paws::IAM::UpdateOpenIDConnectProviderThumbprint', @_); 549 return $self->caller->do_call($self, $call_object); 550 } 551 sub UpdateSAMLProvider { 552 my $self = shift; 553 my $call_object = $self->new_with_coercions('Paws::IAM::UpdateSAMLProvider', @_); 554 return $self->caller->do_call($self, $call_object); 555 } 556 sub UpdateServerCertificate { 557 my $self = shift; 558 my $call_object = $self->new_with_coercions('Paws::IAM::UpdateServerCertificate', @_); 559 return $self->caller->do_call($self, $call_object); 560 } 561 sub UpdateSigningCertificate { 562 my $self = shift; 563 my $call_object = $self->new_with_coercions('Paws::IAM::UpdateSigningCertificate', @_); 564 return $self->caller->do_call($self, $call_object); 565 } 566 sub UpdateSSHPublicKey { 567 my $self = shift; 568 my $call_object = $self->new_with_coercions('Paws::IAM::UpdateSSHPublicKey', @_); 569 return $self->caller->do_call($self, $call_object); 570 } 571 sub UpdateUser { 572 my $self = shift; 573 my $call_object = $self->new_with_coercions('Paws::IAM::UpdateUser', @_); 574 return $self->caller->do_call($self, $call_object); 575 } 576 sub UploadServerCertificate { 577 my $self = shift; 578 my $call_object = $self->new_with_coercions('Paws::IAM::UploadServerCertificate', @_); 579 return $self->caller->do_call($self, $call_object); 580 } 581 sub UploadSigningCertificate { 582 my $self = shift; 583 my $call_object = $self->new_with_coercions('Paws::IAM::UploadSigningCertificate', @_); 584 return $self->caller->do_call($self, $call_object); 585 } 586 sub UploadSSHPublicKey { 587 my $self = shift; 588 my $call_object = $self->new_with_coercions('Paws::IAM::UploadSSHPublicKey', @_); 589 return $self->caller->do_call($self, $call_object); 590 } 591} 5921; 593 594### main pod documentation begin ### 595 596=head1 NAME 597 598Paws::IAM - Perl Interface to AWS AWS Identity and Access Management 599 600=head1 SYNOPSIS 601 602 use Paws; 603 604 my $obj = Paws->service('IAM')->new; 605 my $res = $obj->Method( 606 Arg1 => $val1, 607 Arg2 => [ 'V1', 'V2' ], 608 # if Arg3 is an object, the HashRef will be used as arguments to the constructor 609 # of the arguments type 610 Arg3 => { Att1 => 'Val1' }, 611 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to 612 # the constructor of the arguments type 613 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ], 614 ); 615 616=head1 DESCRIPTION 617 618 619 620AWS Identity and Access Management 621 622AWS Identity and Access Management (IAM) is a web service that you can 623use to manage users and user permissions under your AWS account. This 624guide provides descriptions of IAM actions that you can call 625programmatically. For general information about IAM, see AWS Identity 626and Access Management (IAM). For the user guide for IAM, see Using IAM. 627 628AWS provides SDKs that consist of libraries and sample code for various 629programming languages and platforms (Java, Ruby, .NET, iOS, Android, 630etc.). The SDKs provide a convenient way to create programmatic access 631to IAM and AWS. For example, the SDKs take care of tasks such as 632cryptographically signing requests (see below), managing errors, and 633retrying requests automatically. For information about the AWS SDKs, 634including how to download and install them, see the Tools for Amazon 635Web Services page. 636 637We recommend that you use the AWS SDKs to make programmatic API calls 638to IAM. However, you can also use the IAM Query API to make direct 639calls to the IAM web service. To learn more about the IAM Query API, 640see Making Query Requests in the I<Using IAM> guide. IAM supports GET 641and POST requests for all actions. That is, the API does not require 642you to use GET for some actions and POST for others. However, GET 643requests are subject to the limitation size of a URL. Therefore, for 644operations that require larger sizes, use a POST request. 645 646B<Signing Requests> 647 648Requests must be signed using an access key ID and a secret access key. 649We strongly recommend that you do not use your AWS account access key 650ID and secret access key for everyday work with IAM. You can use the 651access key ID and secret access key for an IAM user or you can use the 652AWS Security Token Service to generate temporary security credentials 653and use those to sign requests. 654 655To sign requests, we recommend that you use Signature Version 4. If you 656have an existing application that uses Signature Version 2, you do not 657have to update it to use Signature Version 4. However, some operations 658now require Signature Version 4. The documentation for operations that 659require version 4 indicate this requirement. 660 661B<Additional Resources> 662 663For more information, see the following: 664 665=over 666 667=item * AWS Security Credentials. This topic provides general 668information about the types of credentials used for accessing AWS. 669 670=item * IAM Best Practices. This topic presents a list of suggestions 671for using the IAM service to help secure your AWS resources. 672 673=item * AWS Security Token Service. This guide describes how to create 674and use temporary security credentials. 675 676=item * Signing AWS API Requests. This set of topics walk you through 677the process of signing a request using an access key ID and secret 678access key. 679 680=back 681 682 683 684 685 686 687 688 689 690 691=head1 METHODS 692 693=head2 AddClientIDToOpenIDConnectProvider(ClientID => Str, OpenIDConnectProviderArn => Str) 694 695Each argument is described in detail in: L<Paws::IAM::AddClientIDToOpenIDConnectProvider> 696 697Returns: nothing 698 699 700 701Adds a new client ID (also known as audience) to the list of client IDs 702already registered for the specified IAM OpenID Connect provider. 703 704This action is idempotent; it does not fail or return an error if you 705add an existing client ID to the provider. 706 707 708 709 710 711 712 713 714 715 716 717=head2 AddRoleToInstanceProfile(InstanceProfileName => Str, RoleName => Str) 718 719Each argument is described in detail in: L<Paws::IAM::AddRoleToInstanceProfile> 720 721Returns: nothing 722 723 724 725Adds the specified role to the specified instance profile. For more 726information about roles, go to Working with Roles. For more information 727about instance profiles, go to About Instance Profiles. 728 729 730 731 732 733 734 735 736 737 738 739=head2 AddUserToGroup(GroupName => Str, UserName => Str) 740 741Each argument is described in detail in: L<Paws::IAM::AddUserToGroup> 742 743Returns: nothing 744 745 746 747Adds the specified user to the specified group. 748 749 750 751 752 753 754 755 756 757 758 759=head2 AttachGroupPolicy(GroupName => Str, PolicyArn => Str) 760 761Each argument is described in detail in: L<Paws::IAM::AttachGroupPolicy> 762 763Returns: nothing 764 765 766 767Attaches the specified managed policy to the specified group. 768 769You use this API to attach a managed policy to a group. To embed an 770inline policy in a group, use PutGroupPolicy. 771 772For more information about policies, refer to Managed Policies and 773Inline Policies in the I<Using IAM> guide. 774 775 776 777 778 779 780 781 782 783 784 785=head2 AttachRolePolicy(PolicyArn => Str, RoleName => Str) 786 787Each argument is described in detail in: L<Paws::IAM::AttachRolePolicy> 788 789Returns: nothing 790 791 792 793Attaches the specified managed policy to the specified role. 794 795When you attach a managed policy to a role, the managed policy is used 796as the role's access (permissions) policy. You cannot use a managed 797policy as the role's trust policy. The role's trust policy is created 798at the same time as the role, using CreateRole. You can update a role's 799trust policy using UpdateAssumeRolePolicy. 800 801Use this API to attach a managed policy to a role. To embed an inline 802policy in a role, use PutRolePolicy. For more information about 803policies, refer to Managed Policies and Inline Policies in the I<Using 804IAM> guide. 805 806 807 808 809 810 811 812 813 814 815 816=head2 AttachUserPolicy(PolicyArn => Str, UserName => Str) 817 818Each argument is described in detail in: L<Paws::IAM::AttachUserPolicy> 819 820Returns: nothing 821 822 823 824Attaches the specified managed policy to the specified user. 825 826You use this API to attach a managed policy to a user. To embed an 827inline policy in a user, use PutUserPolicy. 828 829For more information about policies, refer to Managed Policies and 830Inline Policies in the I<Using IAM> guide. 831 832 833 834 835 836 837 838 839 840 841 842=head2 ChangePassword(NewPassword => Str, OldPassword => Str) 843 844Each argument is described in detail in: L<Paws::IAM::ChangePassword> 845 846Returns: nothing 847 848 849 850Changes the password of the IAM user who is calling this action. The 851root account password is not affected by this action. 852 853To change the password for a different user, see UpdateLoginProfile. 854For more information about modifying passwords, see Managing Passwords 855in the I<Using IAM> guide. 856 857 858 859 860 861 862 863 864 865 866 867=head2 CreateAccessKey([UserName => Str]) 868 869Each argument is described in detail in: L<Paws::IAM::CreateAccessKey> 870 871Returns: a L<Paws::IAM::CreateAccessKeyResponse> instance 872 873 874 875Creates a new AWS secret access key and corresponding AWS access key ID 876for the specified user. The default status for new keys is C<Active>. 877 878If you do not specify a user name, IAM determines the user name 879implicitly based on the AWS access key ID signing the request. Because 880this action works for access keys under the AWS account, you can use 881this action to manage root credentials even if the AWS account has no 882associated users. 883 884For information about limits on the number of keys you can create, see 885Limitations on IAM Entities in the I<Using IAM> guide. 886 887To ensure the security of your AWS account, the secret access key is 888accessible only during key and user creation. You must save the key 889(for example, in a text file) if you want to be able to access it 890again. If a secret key is lost, you can delete the access keys for the 891associated user and then create new keys. 892 893 894 895 896 897 898 899 900 901 902 903=head2 CreateAccountAlias(AccountAlias => Str) 904 905Each argument is described in detail in: L<Paws::IAM::CreateAccountAlias> 906 907Returns: nothing 908 909 910 911Creates an alias for your AWS account. For information about using an 912AWS account alias, see Using an Alias for Your AWS Account ID in the 913I<Using IAM> guide. 914 915 916 917 918 919 920 921 922 923 924 925=head2 CreateGroup(GroupName => Str, [Path => Str]) 926 927Each argument is described in detail in: L<Paws::IAM::CreateGroup> 928 929Returns: a L<Paws::IAM::CreateGroupResponse> instance 930 931 932 933Creates a new group. 934 935For information about the number of groups you can create, see 936Limitations on IAM Entities in the I<Using IAM> guide. 937 938 939 940 941 942 943 944 945 946 947 948=head2 CreateInstanceProfile(InstanceProfileName => Str, [Path => Str]) 949 950Each argument is described in detail in: L<Paws::IAM::CreateInstanceProfile> 951 952Returns: a L<Paws::IAM::CreateInstanceProfileResponse> instance 953 954 955 956Creates a new instance profile. For information about instance 957profiles, go to About Instance Profiles. 958 959For information about the number of instance profiles you can create, 960see Limitations on IAM Entities in the I<Using IAM> guide. 961 962 963 964 965 966 967 968 969 970 971 972=head2 CreateLoginProfile(Password => Str, UserName => Str, [PasswordResetRequired => Bool]) 973 974Each argument is described in detail in: L<Paws::IAM::CreateLoginProfile> 975 976Returns: a L<Paws::IAM::CreateLoginProfileResponse> instance 977 978 979 980Creates a password for the specified user, giving the user the ability 981to access AWS services through the AWS Management Console. For more 982information about managing passwords, see Managing Passwords in the 983I<Using IAM> guide. 984 985 986 987 988 989 990 991 992 993 994 995=head2 CreateOpenIDConnectProvider(ThumbprintList => ArrayRef[Str], Url => Str, [ClientIDList => ArrayRef[Str]]) 996 997Each argument is described in detail in: L<Paws::IAM::CreateOpenIDConnectProvider> 998 999Returns: a L<Paws::IAM::CreateOpenIDConnectProviderResponse> instance 1000 1001 1002 1003Creates an IAM entity to describe an identity provider (IdP) that 1004supports OpenID Connect (OIDC). 1005 1006The OIDC provider that you create with this operation can be used as a 1007principal in a role's trust policy to establish a trust relationship 1008between AWS and the OIDC provider. 1009 1010When you create the IAM OIDC provider, you specify the URL of the OIDC 1011identity provider (IdP) to trust, a list of client IDs (also known as 1012audiences) that identify the application or applications that are 1013allowed to authenticate using the OIDC provider, and a list of 1014thumbprints of the server certificate(s) that the IdP uses. You get all 1015of this information from the OIDC IdP that you want to use for access 1016to AWS. 1017 1018Because trust for the OIDC provider is ultimately derived from the IAM 1019provider that this action creates, it is a best practice to limit 1020access to the CreateOpenIDConnectProvider action to highly-privileged 1021users. 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033=head2 CreatePolicy(PolicyDocument => Str, PolicyName => Str, [Description => Str, Path => Str]) 1034 1035Each argument is described in detail in: L<Paws::IAM::CreatePolicy> 1036 1037Returns: a L<Paws::IAM::CreatePolicyResponse> instance 1038 1039 1040 1041Creates a new managed policy for your AWS account. 1042 1043This operation creates a policy version with a version identifier of 1044C<v1> and sets v1 as the policy's default version. For more information 1045about policy versions, see Versioning for Managed Policies in the 1046I<Using IAM> guide. 1047 1048For more information about managed policies in general, refer to 1049Managed Policies and Inline Policies in the I<Using IAM> guide. 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061=head2 CreatePolicyVersion(PolicyArn => Str, PolicyDocument => Str, [SetAsDefault => Bool]) 1062 1063Each argument is described in detail in: L<Paws::IAM::CreatePolicyVersion> 1064 1065Returns: a L<Paws::IAM::CreatePolicyVersionResponse> instance 1066 1067 1068 1069Creates a new version of the specified managed policy. To update a 1070managed policy, you create a new policy version. A managed policy can 1071have up to five versions. If the policy has five versions, you must 1072delete an existing version using DeletePolicyVersion before you create 1073a new version. 1074 1075Optionally, you can set the new version as the policy's default 1076version. The default version is the operative version; that is, the 1077version that is in effect for the IAM users, groups, and roles that the 1078policy is attached to. 1079 1080For more information about managed policy versions, see Versioning for 1081Managed Policies in the I<Using IAM> guide. 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093=head2 CreateRole(AssumeRolePolicyDocument => Str, RoleName => Str, [Path => Str]) 1094 1095Each argument is described in detail in: L<Paws::IAM::CreateRole> 1096 1097Returns: a L<Paws::IAM::CreateRoleResponse> instance 1098 1099 1100 1101Creates a new role for your AWS account. For more information about 1102roles, go to Working with Roles. For information about limitations on 1103role names and the number of roles you can create, go to Limitations on 1104IAM Entities in the I<Using IAM> guide. 1105 1106The policy in the following example grants permission to an EC2 1107instance to assume the role. 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119=head2 CreateSAMLProvider(Name => Str, SAMLMetadataDocument => Str) 1120 1121Each argument is described in detail in: L<Paws::IAM::CreateSAMLProvider> 1122 1123Returns: a L<Paws::IAM::CreateSAMLProviderResponse> instance 1124 1125 1126 1127Creates an IAM entity to describe an identity provider (IdP) that 1128supports SAML 2.0. 1129 1130The SAML provider that you create with this operation can be used as a 1131principal in a role's trust policy to establish a trust relationship 1132between AWS and a SAML identity provider. You can create an IAM role 1133that supports Web-based single sign-on (SSO) to the AWS Management 1134Console or one that supports API access to AWS. 1135 1136When you create the SAML provider, you upload an a SAML metadata 1137document that you get from your IdP and that includes the issuer's 1138name, expiration information, and keys that can be used to validate the 1139SAML authentication response (assertions) that are received from the 1140IdP. You must generate the metadata document using the identity 1141management software that is used as your organization's IdP. 1142 1143This operation requires Signature Version 4. 1144 1145For more information, see Giving Console Access Using SAML and Creating 1146Temporary Security Credentials for SAML Federation in the I<Using 1147Temporary Credentials> guide. 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159=head2 CreateUser(UserName => Str, [Path => Str]) 1160 1161Each argument is described in detail in: L<Paws::IAM::CreateUser> 1162 1163Returns: a L<Paws::IAM::CreateUserResponse> instance 1164 1165 1166 1167Creates a new user for your AWS account. 1168 1169For information about limitations on the number of users you can 1170create, see Limitations on IAM Entities in the I<Using IAM> guide. 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182=head2 CreateVirtualMFADevice(VirtualMFADeviceName => Str, [Path => Str]) 1183 1184Each argument is described in detail in: L<Paws::IAM::CreateVirtualMFADevice> 1185 1186Returns: a L<Paws::IAM::CreateVirtualMFADeviceResponse> instance 1187 1188 1189 1190Creates a new virtual MFA device for the AWS account. After creating 1191the virtual MFA, use EnableMFADevice to attach the MFA device to an IAM 1192user. For more information about creating and working with virtual MFA 1193devices, go to Using a Virtual MFA Device in the I<Using IAM> guide. 1194 1195For information about limits on the number of MFA devices you can 1196create, see Limitations on Entities in the I<Using IAM> guide. 1197 1198The seed information contained in the QR code and the Base32 string 1199should be treated like any other secret access information, such as 1200your AWS access keys or your passwords. After you provision your 1201virtual device, you should ensure that the information is destroyed 1202following secure procedures. 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214=head2 DeactivateMFADevice(SerialNumber => Str, UserName => Str) 1215 1216Each argument is described in detail in: L<Paws::IAM::DeactivateMFADevice> 1217 1218Returns: nothing 1219 1220 1221 1222Deactivates the specified MFA device and removes it from association 1223with the user name for which it was originally enabled. 1224 1225For more information about creating and working with virtual MFA 1226devices, go to Using a Virtual MFA Device in the I<Using IAM> guide. 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238=head2 DeleteAccessKey(AccessKeyId => Str, [UserName => Str]) 1239 1240Each argument is described in detail in: L<Paws::IAM::DeleteAccessKey> 1241 1242Returns: nothing 1243 1244 1245 1246Deletes the access key associated with the specified user. 1247 1248If you do not specify a user name, IAM determines the user name 1249implicitly based on the AWS access key ID signing the request. Because 1250this action works for access keys under the AWS account, you can use 1251this action to manage root credentials even if the AWS account has no 1252associated users. 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264=head2 DeleteAccountAlias(AccountAlias => Str) 1265 1266Each argument is described in detail in: L<Paws::IAM::DeleteAccountAlias> 1267 1268Returns: nothing 1269 1270 1271 1272Deletes the specified AWS account alias. For information about using an 1273AWS account alias, see Using an Alias for Your AWS Account ID in the 1274I<Using IAM> guide. 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286=head2 DeleteAccountPasswordPolicy( => ) 1287 1288Each argument is described in detail in: L<Paws::IAM::DeleteAccountPasswordPolicy> 1289 1290Returns: nothing 1291 1292 1293 1294Deletes the password policy for the AWS account. 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306=head2 DeleteGroup(GroupName => Str) 1307 1308Each argument is described in detail in: L<Paws::IAM::DeleteGroup> 1309 1310Returns: nothing 1311 1312 1313 1314Deletes the specified group. The group must not contain any users or 1315have any attached policies. 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327=head2 DeleteGroupPolicy(GroupName => Str, PolicyName => Str) 1328 1329Each argument is described in detail in: L<Paws::IAM::DeleteGroupPolicy> 1330 1331Returns: nothing 1332 1333 1334 1335Deletes the specified inline policy that is embedded in the specified 1336group. 1337 1338A group can also have managed policies attached to it. To detach a 1339managed policy from a group, use DetachGroupPolicy. For more 1340information about policies, refer to Managed Policies and Inline 1341Policies in the I<Using IAM> guide. 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353=head2 DeleteInstanceProfile(InstanceProfileName => Str) 1354 1355Each argument is described in detail in: L<Paws::IAM::DeleteInstanceProfile> 1356 1357Returns: nothing 1358 1359 1360 1361Deletes the specified instance profile. The instance profile must not 1362have an associated role. 1363 1364Make sure you do not have any Amazon EC2 instances running with the 1365instance profile you are about to delete. Deleting a role or instance 1366profile that is associated with a running instance will break any 1367applications running on the instance. 1368 1369For more information about instance profiles, go to About Instance 1370Profiles. 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382=head2 DeleteLoginProfile(UserName => Str) 1383 1384Each argument is described in detail in: L<Paws::IAM::DeleteLoginProfile> 1385 1386Returns: nothing 1387 1388 1389 1390Deletes the password for the specified user, which terminates the 1391user's ability to access AWS services through the AWS Management 1392Console. 1393 1394Deleting a user's password does not prevent a user from accessing IAM 1395through the command line interface or the API. To prevent all user 1396access you must also either make the access key inactive or delete it. 1397For more information about making keys inactive or deleting them, see 1398UpdateAccessKey and DeleteAccessKey. 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410=head2 DeleteOpenIDConnectProvider(OpenIDConnectProviderArn => Str) 1411 1412Each argument is described in detail in: L<Paws::IAM::DeleteOpenIDConnectProvider> 1413 1414Returns: nothing 1415 1416 1417 1418Deletes an IAM OpenID Connect identity provider. 1419 1420Deleting an OIDC provider does not update any roles that reference the 1421provider as a principal in their trust policies. Any attempt to assume 1422a role that references a provider that has been deleted will fail. 1423 1424This action is idempotent; it does not fail or return an error if you 1425call the action for a provider that was already deleted. 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437=head2 DeletePolicy(PolicyArn => Str) 1438 1439Each argument is described in detail in: L<Paws::IAM::DeletePolicy> 1440 1441Returns: nothing 1442 1443 1444 1445Deletes the specified managed policy. 1446 1447Before you can delete a managed policy, you must detach the policy from 1448all users, groups, and roles that it is attached to, and you must 1449delete all of the policy's versions. The following steps describe the 1450process for deleting a managed policy: 1451 1452=over 1453 1454=item 1. Detach the policy from all users, groups, and roles that the 1455policy is attached to, using the DetachUserPolicy, DetachGroupPolicy, 1456or DetachRolePolicy APIs. To list all the users, groups, and roles that 1457a policy is attached to, use ListEntitiesForPolicy. 1458 1459=item 2. Delete all versions of the policy using DeletePolicyVersion. 1460To list the policy's versions, use ListPolicyVersions. You cannot use 1461DeletePolicyVersion to delete the version that is marked as the default 1462version. You delete the policy's default version in the next step of 1463the process. 1464 1465=item 3. Delete the policy (this automatically deletes the policy's 1466default version) using this API. 1467 1468=back 1469 1470For information about managed policies, refer to Managed Policies and 1471Inline Policies in the I<Using IAM> guide. 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483=head2 DeletePolicyVersion(PolicyArn => Str, VersionId => Str) 1484 1485Each argument is described in detail in: L<Paws::IAM::DeletePolicyVersion> 1486 1487Returns: nothing 1488 1489 1490 1491Deletes the specified version of the specified managed policy. 1492 1493You cannot delete the default version of a policy using this API. To 1494delete the default version of a policy, use DeletePolicy. To find out 1495which version of a policy is marked as the default version, use 1496ListPolicyVersions. 1497 1498For information about versions for managed policies, refer to 1499Versioning for Managed Policies in the I<Using IAM> guide. 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511=head2 DeleteRole(RoleName => Str) 1512 1513Each argument is described in detail in: L<Paws::IAM::DeleteRole> 1514 1515Returns: nothing 1516 1517 1518 1519Deletes the specified role. The role must not have any policies 1520attached. For more information about roles, go to Working with Roles. 1521 1522Make sure you do not have any Amazon EC2 instances running with the 1523role you are about to delete. Deleting a role or instance profile that 1524is associated with a running instance will break any applications 1525running on the instance. 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537=head2 DeleteRolePolicy(PolicyName => Str, RoleName => Str) 1538 1539Each argument is described in detail in: L<Paws::IAM::DeleteRolePolicy> 1540 1541Returns: nothing 1542 1543 1544 1545Deletes the specified inline policy that is embedded in the specified 1546role. 1547 1548A role can also have managed policies attached to it. To detach a 1549managed policy from a role, use DetachRolePolicy. For more information 1550about policies, refer to Managed Policies and Inline Policies in the 1551I<Using IAM> guide. 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563=head2 DeleteSAMLProvider(SAMLProviderArn => Str) 1564 1565Each argument is described in detail in: L<Paws::IAM::DeleteSAMLProvider> 1566 1567Returns: nothing 1568 1569 1570 1571Deletes a SAML provider. 1572 1573Deleting the provider does not update any roles that reference the SAML 1574provider as a principal in their trust policies. Any attempt to assume 1575a role that references a SAML provider that has been deleted will fail. 1576 1577This operation requires Signature Version 4. 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589=head2 DeleteServerCertificate(ServerCertificateName => Str) 1590 1591Each argument is described in detail in: L<Paws::IAM::DeleteServerCertificate> 1592 1593Returns: nothing 1594 1595 1596 1597Deletes the specified server certificate. 1598 1599If you are using a server certificate with Elastic Load Balancing, 1600deleting the certificate could have implications for your application. 1601If Elastic Load Balancing doesn't detect the deletion of bound 1602certificates, it may continue to use the certificates. This could cause 1603Elastic Load Balancing to stop accepting traffic. We recommend that you 1604remove the reference to the certificate from Elastic Load Balancing 1605before using this command to delete the certificate. For more 1606information, go to DeleteLoadBalancerListeners in the I<Elastic Load 1607Balancing API Reference>. 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619=head2 DeleteSigningCertificate(CertificateId => Str, [UserName => Str]) 1620 1621Each argument is described in detail in: L<Paws::IAM::DeleteSigningCertificate> 1622 1623Returns: nothing 1624 1625 1626 1627Deletes the specified signing certificate associated with the specified 1628user. 1629 1630If you do not specify a user name, IAM determines the user name 1631implicitly based on the AWS access key ID signing the request. Because 1632this action works for access keys under the AWS account, you can use 1633this action to manage root credentials even if the AWS account has no 1634associated users. 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646=head2 DeleteSSHPublicKey(SSHPublicKeyId => Str, UserName => Str) 1647 1648Each argument is described in detail in: L<Paws::IAM::DeleteSSHPublicKey> 1649 1650Returns: nothing 1651 1652 1653 1654Deletes the specified SSH public key. 1655 1656The SSH public key deleted by this action is used only for 1657authenticating the associated IAM user to an AWS CodeCommit repository. 1658For more information about using SSH keys to authenticate to an AWS 1659CodeCommit repository, see Set up AWS CodeCommit for SSH Connections in 1660the I<AWS CodeCommit User Guide>. 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672=head2 DeleteUser(UserName => Str) 1673 1674Each argument is described in detail in: L<Paws::IAM::DeleteUser> 1675 1676Returns: nothing 1677 1678 1679 1680Deletes the specified user. The user must not belong to any groups, 1681have any keys or signing certificates, or have any attached policies. 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693=head2 DeleteUserPolicy(PolicyName => Str, UserName => Str) 1694 1695Each argument is described in detail in: L<Paws::IAM::DeleteUserPolicy> 1696 1697Returns: nothing 1698 1699 1700 1701Deletes the specified inline policy that is embedded in the specified 1702user. 1703 1704A user can also have managed policies attached to it. To detach a 1705managed policy from a user, use DetachUserPolicy. For more information 1706about policies, refer to Managed Policies and Inline Policies in the 1707I<Using IAM> guide. 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719=head2 DeleteVirtualMFADevice(SerialNumber => Str) 1720 1721Each argument is described in detail in: L<Paws::IAM::DeleteVirtualMFADevice> 1722 1723Returns: nothing 1724 1725 1726 1727Deletes a virtual MFA device. 1728 1729You must deactivate a user's virtual MFA device before you can delete 1730it. For information about deactivating MFA devices, see 1731DeactivateMFADevice. 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743=head2 DetachGroupPolicy(GroupName => Str, PolicyArn => Str) 1744 1745Each argument is described in detail in: L<Paws::IAM::DetachGroupPolicy> 1746 1747Returns: nothing 1748 1749 1750 1751Removes the specified managed policy from the specified group. 1752 1753A group can also have inline policies embedded with it. To delete an 1754inline policy, use the DeleteGroupPolicy API. For information about 1755policies, refer to Managed Policies and Inline Policies in the I<Using 1756IAM> guide. 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768=head2 DetachRolePolicy(PolicyArn => Str, RoleName => Str) 1769 1770Each argument is described in detail in: L<Paws::IAM::DetachRolePolicy> 1771 1772Returns: nothing 1773 1774 1775 1776Removes the specified managed policy from the specified role. 1777 1778A role can also have inline policies embedded with it. To delete an 1779inline policy, use the DeleteRolePolicy API. For information about 1780policies, refer to Managed Policies and Inline Policies in the I<Using 1781IAM> guide. 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793=head2 DetachUserPolicy(PolicyArn => Str, UserName => Str) 1794 1795Each argument is described in detail in: L<Paws::IAM::DetachUserPolicy> 1796 1797Returns: nothing 1798 1799 1800 1801Removes the specified managed policy from the specified user. 1802 1803A user can also have inline policies embedded with it. To delete an 1804inline policy, use the DeleteUserPolicy API. For information about 1805policies, refer to Managed Policies and Inline Policies in the I<Using 1806IAM> guide. 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818=head2 EnableMFADevice(AuthenticationCode1 => Str, AuthenticationCode2 => Str, SerialNumber => Str, UserName => Str) 1819 1820Each argument is described in detail in: L<Paws::IAM::EnableMFADevice> 1821 1822Returns: nothing 1823 1824 1825 1826Enables the specified MFA device and associates it with the specified 1827user name. When enabled, the MFA device is required for every 1828subsequent login by the user name associated with the device. 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840=head2 GenerateCredentialReport( => ) 1841 1842Each argument is described in detail in: L<Paws::IAM::GenerateCredentialReport> 1843 1844Returns: a L<Paws::IAM::GenerateCredentialReportResponse> instance 1845 1846 1847 1848Generates a credential report for the AWS account. For more information 1849about the credential report, see Getting Credential Reports in the 1850I<Using IAM> guide. 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862=head2 GetAccessKeyLastUsed(AccessKeyId => Str) 1863 1864Each argument is described in detail in: L<Paws::IAM::GetAccessKeyLastUsed> 1865 1866Returns: a L<Paws::IAM::GetAccessKeyLastUsedResponse> instance 1867 1868 1869 1870Retrieves information about when the specified access key was last 1871used. The information includes the date and time of last use, along 1872with the AWS service and region that were specified in the last request 1873made with that key. 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885=head2 GetAccountAuthorizationDetails([Filter => ArrayRef[Str], Marker => Str, MaxItems => Int]) 1886 1887Each argument is described in detail in: L<Paws::IAM::GetAccountAuthorizationDetails> 1888 1889Returns: a L<Paws::IAM::GetAccountAuthorizationDetailsResponse> instance 1890 1891 1892 1893Retrieves information about all IAM users, groups, roles, and policies 1894in your account, including their relationships to one another. Use this 1895API to obtain a snapshot of the configuration of IAM permissions 1896(users, groups, roles, and policies) in your account. 1897 1898You can optionally filter the results using the C<Filter> parameter. 1899You can paginate the results using the C<MaxItems> and C<Marker> 1900parameters. 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912=head2 GetAccountPasswordPolicy( => ) 1913 1914Each argument is described in detail in: L<Paws::IAM::GetAccountPasswordPolicy> 1915 1916Returns: a L<Paws::IAM::GetAccountPasswordPolicyResponse> instance 1917 1918 1919 1920Retrieves the password policy for the AWS account. For more information 1921about using a password policy, go to Managing an IAM Password Policy. 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933=head2 GetAccountSummary( => ) 1934 1935Each argument is described in detail in: L<Paws::IAM::GetAccountSummary> 1936 1937Returns: a L<Paws::IAM::GetAccountSummaryResponse> instance 1938 1939 1940 1941Retrieves information about IAM entity usage and IAM quotas in the AWS 1942account. 1943 1944For information about limitations on IAM entities, see Limitations on 1945IAM Entities in the I<Using IAM> guide. 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957=head2 GetCredentialReport( => ) 1958 1959Each argument is described in detail in: L<Paws::IAM::GetCredentialReport> 1960 1961Returns: a L<Paws::IAM::GetCredentialReportResponse> instance 1962 1963 1964 1965Retrieves a credential report for the AWS account. For more information 1966about the credential report, see Getting Credential Reports in the 1967I<Using IAM> guide. 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979=head2 GetGroup(GroupName => Str, [Marker => Str, MaxItems => Int]) 1980 1981Each argument is described in detail in: L<Paws::IAM::GetGroup> 1982 1983Returns: a L<Paws::IAM::GetGroupResponse> instance 1984 1985 1986 1987Returns a list of users that are in the specified group. You can 1988paginate the results using the C<MaxItems> and C<Marker> parameters. 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000=head2 GetGroupPolicy(GroupName => Str, PolicyName => Str) 2001 2002Each argument is described in detail in: L<Paws::IAM::GetGroupPolicy> 2003 2004Returns: a L<Paws::IAM::GetGroupPolicyResponse> instance 2005 2006 2007 2008Retrieves the specified inline policy document that is embedded in the 2009specified group. 2010 2011A group can also have managed policies attached to it. To retrieve a 2012managed policy document that is attached to a group, use GetPolicy to 2013determine the policy's default version, then use GetPolicyVersion to 2014retrieve the policy document. 2015 2016For more information about policies, refer to Managed Policies and 2017Inline Policies in the I<Using IAM> guide. 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029=head2 GetInstanceProfile(InstanceProfileName => Str) 2030 2031Each argument is described in detail in: L<Paws::IAM::GetInstanceProfile> 2032 2033Returns: a L<Paws::IAM::GetInstanceProfileResponse> instance 2034 2035 2036 2037Retrieves information about the specified instance profile, including 2038the instance profile's path, GUID, ARN, and role. For more information 2039about instance profiles, go to About Instance Profiles. For more 2040information about ARNs, go to ARNs. 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052=head2 GetLoginProfile(UserName => Str) 2053 2054Each argument is described in detail in: L<Paws::IAM::GetLoginProfile> 2055 2056Returns: a L<Paws::IAM::GetLoginProfileResponse> instance 2057 2058 2059 2060Retrieves the user name and password-creation date for the specified 2061user. If the user has not been assigned a password, the action returns 2062a 404 (C<NoSuchEntity>) error. 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074=head2 GetOpenIDConnectProvider(OpenIDConnectProviderArn => Str) 2075 2076Each argument is described in detail in: L<Paws::IAM::GetOpenIDConnectProvider> 2077 2078Returns: a L<Paws::IAM::GetOpenIDConnectProviderResponse> instance 2079 2080 2081 2082Returns information about the specified OpenID Connect provider. 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094=head2 GetPolicy(PolicyArn => Str) 2095 2096Each argument is described in detail in: L<Paws::IAM::GetPolicy> 2097 2098Returns: a L<Paws::IAM::GetPolicyResponse> instance 2099 2100 2101 2102Retrieves information about the specified managed policy, including the 2103policy's default version and the total number of users, groups, and 2104roles that the policy is attached to. For a list of the specific users, 2105groups, and roles that the policy is attached to, use the 2106ListEntitiesForPolicy API. This API returns metadata about the policy. 2107To retrieve the policy document for a specific version of the policy, 2108use GetPolicyVersion. 2109 2110This API retrieves information about managed policies. To retrieve 2111information about an inline policy that is embedded with a user, group, 2112or role, use the GetUserPolicy, GetGroupPolicy, or GetRolePolicy API. 2113 2114For more information about policies, refer to Managed Policies and 2115Inline Policies in the I<Using IAM> guide. 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127=head2 GetPolicyVersion(PolicyArn => Str, VersionId => Str) 2128 2129Each argument is described in detail in: L<Paws::IAM::GetPolicyVersion> 2130 2131Returns: a L<Paws::IAM::GetPolicyVersionResponse> instance 2132 2133 2134 2135Retrieves information about the specified version of the specified 2136managed policy, including the policy document. 2137 2138To list the available versions for a policy, use ListPolicyVersions. 2139 2140This API retrieves information about managed policies. To retrieve 2141information about an inline policy that is embedded in a user, group, 2142or role, use the GetUserPolicy, GetGroupPolicy, or GetRolePolicy API. 2143 2144For more information about the types of policies, refer to Managed 2145Policies and Inline Policies in the I<Using IAM> guide. 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157=head2 GetRole(RoleName => Str) 2158 2159Each argument is described in detail in: L<Paws::IAM::GetRole> 2160 2161Returns: a L<Paws::IAM::GetRoleResponse> instance 2162 2163 2164 2165Retrieves information about the specified role, including the role's 2166path, GUID, ARN, and the policy granting permission to assume the role. 2167For more information about ARNs, go to ARNs. For more information about 2168roles, go to Working with Roles. 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180=head2 GetRolePolicy(PolicyName => Str, RoleName => Str) 2181 2182Each argument is described in detail in: L<Paws::IAM::GetRolePolicy> 2183 2184Returns: a L<Paws::IAM::GetRolePolicyResponse> instance 2185 2186 2187 2188Retrieves the specified inline policy document that is embedded with 2189the specified role. 2190 2191A role can also have managed policies attached to it. To retrieve a 2192managed policy document that is attached to a role, use GetPolicy to 2193determine the policy's default version, then use GetPolicyVersion to 2194retrieve the policy document. 2195 2196For more information about policies, refer to Managed Policies and 2197Inline Policies in the I<Using IAM> guide. 2198 2199For more information about roles, go to Using Roles to Delegate 2200Permissions and Federate Identities. 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212=head2 GetSAMLProvider(SAMLProviderArn => Str) 2213 2214Each argument is described in detail in: L<Paws::IAM::GetSAMLProvider> 2215 2216Returns: a L<Paws::IAM::GetSAMLProviderResponse> instance 2217 2218 2219 2220Returns the SAML provider metadocument that was uploaded when the 2221provider was created or updated. 2222 2223This operation requires Signature Version 4. 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235=head2 GetServerCertificate(ServerCertificateName => Str) 2236 2237Each argument is described in detail in: L<Paws::IAM::GetServerCertificate> 2238 2239Returns: a L<Paws::IAM::GetServerCertificateResponse> instance 2240 2241 2242 2243Retrieves information about the specified server certificate. 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255=head2 GetSSHPublicKey(Encoding => Str, SSHPublicKeyId => Str, UserName => Str) 2256 2257Each argument is described in detail in: L<Paws::IAM::GetSSHPublicKey> 2258 2259Returns: a L<Paws::IAM::GetSSHPublicKeyResponse> instance 2260 2261 2262 2263Retrieves the specified SSH public key, including metadata about the 2264key. 2265 2266The SSH public key retrieved by this action is used only for 2267authenticating the associated IAM user to an AWS CodeCommit repository. 2268For more information about using SSH keys to authenticate to an AWS 2269CodeCommit repository, see Set up AWS CodeCommit for SSH Connections in 2270the I<AWS CodeCommit User Guide>. 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282=head2 GetUser([UserName => Str]) 2283 2284Each argument is described in detail in: L<Paws::IAM::GetUser> 2285 2286Returns: a L<Paws::IAM::GetUserResponse> instance 2287 2288 2289 2290Retrieves information about the specified user, including the user's 2291creation date, path, unique ID, and ARN. 2292 2293If you do not specify a user name, IAM determines the user name 2294implicitly based on the AWS access key ID used to sign the request. 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306=head2 GetUserPolicy(PolicyName => Str, UserName => Str) 2307 2308Each argument is described in detail in: L<Paws::IAM::GetUserPolicy> 2309 2310Returns: a L<Paws::IAM::GetUserPolicyResponse> instance 2311 2312 2313 2314Retrieves the specified inline policy document that is embedded in the 2315specified user. 2316 2317A user can also have managed policies attached to it. To retrieve a 2318managed policy document that is attached to a user, use GetPolicy to 2319determine the policy's default version, then use GetPolicyVersion to 2320retrieve the policy document. 2321 2322For more information about policies, refer to Managed Policies and 2323Inline Policies in the I<Using IAM> guide. 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335=head2 ListAccessKeys([Marker => Str, MaxItems => Int, UserName => Str]) 2336 2337Each argument is described in detail in: L<Paws::IAM::ListAccessKeys> 2338 2339Returns: a L<Paws::IAM::ListAccessKeysResponse> instance 2340 2341 2342 2343Returns information about the access key IDs associated with the 2344specified user. If there are none, the action returns an empty list. 2345 2346Although each user is limited to a small number of keys, you can still 2347paginate the results using the C<MaxItems> and C<Marker> parameters. 2348 2349If the C<UserName> field is not specified, the UserName is determined 2350implicitly based on the AWS access key ID used to sign the request. 2351Because this action works for access keys under the AWS account, you 2352can use this action to manage root credentials even if the AWS account 2353has no associated users. 2354 2355To ensure the security of your AWS account, the secret access key is 2356accessible only during key and user creation. 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368=head2 ListAccountAliases([Marker => Str, MaxItems => Int]) 2369 2370Each argument is described in detail in: L<Paws::IAM::ListAccountAliases> 2371 2372Returns: a L<Paws::IAM::ListAccountAliasesResponse> instance 2373 2374 2375 2376Lists the account aliases associated with the account. For information 2377about using an AWS account alias, see Using an Alias for Your AWS 2378Account ID in the I<Using IAM> guide. 2379 2380You can paginate the results using the C<MaxItems> and C<Marker> 2381parameters. 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393=head2 ListAttachedGroupPolicies(GroupName => Str, [Marker => Str, MaxItems => Int, PathPrefix => Str]) 2394 2395Each argument is described in detail in: L<Paws::IAM::ListAttachedGroupPolicies> 2396 2397Returns: a L<Paws::IAM::ListAttachedGroupPoliciesResponse> instance 2398 2399 2400 2401Lists all managed policies that are attached to the specified group. 2402 2403A group can also have inline policies embedded with it. To list the 2404inline policies for a group, use the ListGroupPolicies API. For 2405information about policies, refer to Managed Policies and Inline 2406Policies in the I<Using IAM> guide. 2407 2408You can paginate the results using the C<MaxItems> and C<Marker> 2409parameters. You can use the C<PathPrefix> parameter to limit the list 2410of policies to only those matching the specified path prefix. If there 2411are no policies attached to the specified group (or none that match the 2412specified path prefix), the action returns an empty list. 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424=head2 ListAttachedRolePolicies(RoleName => Str, [Marker => Str, MaxItems => Int, PathPrefix => Str]) 2425 2426Each argument is described in detail in: L<Paws::IAM::ListAttachedRolePolicies> 2427 2428Returns: a L<Paws::IAM::ListAttachedRolePoliciesResponse> instance 2429 2430 2431 2432Lists all managed policies that are attached to the specified role. 2433 2434A role can also have inline policies embedded with it. To list the 2435inline policies for a role, use the ListRolePolicies API. For 2436information about policies, refer to Managed Policies and Inline 2437Policies in the I<Using IAM> guide. 2438 2439You can paginate the results using the C<MaxItems> and C<Marker> 2440parameters. You can use the C<PathPrefix> parameter to limit the list 2441of policies to only those matching the specified path prefix. If there 2442are no policies attached to the specified role (or none that match the 2443specified path prefix), the action returns an empty list. 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455=head2 ListAttachedUserPolicies(UserName => Str, [Marker => Str, MaxItems => Int, PathPrefix => Str]) 2456 2457Each argument is described in detail in: L<Paws::IAM::ListAttachedUserPolicies> 2458 2459Returns: a L<Paws::IAM::ListAttachedUserPoliciesResponse> instance 2460 2461 2462 2463Lists all managed policies that are attached to the specified user. 2464 2465A user can also have inline policies embedded with it. To list the 2466inline policies for a user, use the ListUserPolicies API. For 2467information about policies, refer to Managed Policies and Inline 2468Policies in the I<Using IAM> guide. 2469 2470You can paginate the results using the C<MaxItems> and C<Marker> 2471parameters. You can use the C<PathPrefix> parameter to limit the list 2472of policies to only those matching the specified path prefix. If there 2473are no policies attached to the specified group (or none that match the 2474specified path prefix), the action returns an empty list. 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486=head2 ListEntitiesForPolicy(PolicyArn => Str, [EntityFilter => Str, Marker => Str, MaxItems => Int, PathPrefix => Str]) 2487 2488Each argument is described in detail in: L<Paws::IAM::ListEntitiesForPolicy> 2489 2490Returns: a L<Paws::IAM::ListEntitiesForPolicyResponse> instance 2491 2492 2493 2494Lists all users, groups, and roles that the specified managed policy is 2495attached to. 2496 2497You can use the optional C<EntityFilter> parameter to limit the results 2498to a particular type of entity (users, groups, or roles). For example, 2499to list only the roles that are attached to the specified policy, set 2500C<EntityFilter> to C<Role>. 2501 2502You can paginate the results using the C<MaxItems> and C<Marker> 2503parameters. 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515=head2 ListGroupPolicies(GroupName => Str, [Marker => Str, MaxItems => Int]) 2516 2517Each argument is described in detail in: L<Paws::IAM::ListGroupPolicies> 2518 2519Returns: a L<Paws::IAM::ListGroupPoliciesResponse> instance 2520 2521 2522 2523Lists the names of the inline policies that are embedded in the 2524specified group. 2525 2526A group can also have managed policies attached to it. To list the 2527managed policies that are attached to a group, use 2528ListAttachedGroupPolicies. For more information about policies, refer 2529to Managed Policies and Inline Policies in the I<Using IAM> guide. 2530 2531You can paginate the results using the C<MaxItems> and C<Marker> 2532parameters. If there are no inline policies embedded with the specified 2533group, the action returns an empty list. 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545=head2 ListGroups([Marker => Str, MaxItems => Int, PathPrefix => Str]) 2546 2547Each argument is described in detail in: L<Paws::IAM::ListGroups> 2548 2549Returns: a L<Paws::IAM::ListGroupsResponse> instance 2550 2551 2552 2553Lists the groups that have the specified path prefix. 2554 2555You can paginate the results using the C<MaxItems> and C<Marker> 2556parameters. 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568=head2 ListGroupsForUser(UserName => Str, [Marker => Str, MaxItems => Int]) 2569 2570Each argument is described in detail in: L<Paws::IAM::ListGroupsForUser> 2571 2572Returns: a L<Paws::IAM::ListGroupsForUserResponse> instance 2573 2574 2575 2576Lists the groups the specified user belongs to. 2577 2578You can paginate the results using the C<MaxItems> and C<Marker> 2579parameters. 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591=head2 ListInstanceProfiles([Marker => Str, MaxItems => Int, PathPrefix => Str]) 2592 2593Each argument is described in detail in: L<Paws::IAM::ListInstanceProfiles> 2594 2595Returns: a L<Paws::IAM::ListInstanceProfilesResponse> instance 2596 2597 2598 2599Lists the instance profiles that have the specified path prefix. If 2600there are none, the action returns an empty list. For more information 2601about instance profiles, go to About Instance Profiles. 2602 2603You can paginate the results using the C<MaxItems> and C<Marker> 2604parameters. 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616=head2 ListInstanceProfilesForRole(RoleName => Str, [Marker => Str, MaxItems => Int]) 2617 2618Each argument is described in detail in: L<Paws::IAM::ListInstanceProfilesForRole> 2619 2620Returns: a L<Paws::IAM::ListInstanceProfilesForRoleResponse> instance 2621 2622 2623 2624Lists the instance profiles that have the specified associated role. If 2625there are none, the action returns an empty list. For more information 2626about instance profiles, go to About Instance Profiles. 2627 2628You can paginate the results using the C<MaxItems> and C<Marker> 2629parameters. 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641=head2 ListMFADevices([Marker => Str, MaxItems => Int, UserName => Str]) 2642 2643Each argument is described in detail in: L<Paws::IAM::ListMFADevices> 2644 2645Returns: a L<Paws::IAM::ListMFADevicesResponse> instance 2646 2647 2648 2649Lists the MFA devices. If the request includes the user name, then this 2650action lists all the MFA devices associated with the specified user 2651name. If you do not specify a user name, IAM determines the user name 2652implicitly based on the AWS access key ID signing the request. 2653 2654You can paginate the results using the C<MaxItems> and C<Marker> 2655parameters. 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667=head2 ListOpenIDConnectProviders( => ) 2668 2669Each argument is described in detail in: L<Paws::IAM::ListOpenIDConnectProviders> 2670 2671Returns: a L<Paws::IAM::ListOpenIDConnectProvidersResponse> instance 2672 2673 2674 2675Lists information about the OpenID Connect providers in the AWS 2676account. 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688=head2 ListPolicies([Marker => Str, MaxItems => Int, OnlyAttached => Bool, PathPrefix => Str, Scope => Str]) 2689 2690Each argument is described in detail in: L<Paws::IAM::ListPolicies> 2691 2692Returns: a L<Paws::IAM::ListPoliciesResponse> instance 2693 2694 2695 2696Lists all the managed policies that are available to your account, 2697including your own customer managed policies and all AWS managed 2698policies. 2699 2700You can filter the list of policies that is returned using the optional 2701C<OnlyAttached>, C<Scope>, and C<PathPrefix> parameters. For example, 2702to list only the customer managed policies in your AWS account, set 2703C<Scope> to C<Local>. To list only AWS managed policies, set C<Scope> 2704to C<AWS>. 2705 2706You can paginate the results using the C<MaxItems> and C<Marker> 2707parameters. 2708 2709For more information about managed policies, refer to Managed Policies 2710and Inline Policies in the I<Using IAM> guide. 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722=head2 ListPolicyVersions(PolicyArn => Str, [Marker => Str, MaxItems => Int]) 2723 2724Each argument is described in detail in: L<Paws::IAM::ListPolicyVersions> 2725 2726Returns: a L<Paws::IAM::ListPolicyVersionsResponse> instance 2727 2728 2729 2730Lists information about the versions of the specified managed policy, 2731including the version that is set as the policy's default version. 2732 2733For more information about managed policies, refer to Managed Policies 2734and Inline Policies in the I<Using IAM> guide. 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746=head2 ListRolePolicies(RoleName => Str, [Marker => Str, MaxItems => Int]) 2747 2748Each argument is described in detail in: L<Paws::IAM::ListRolePolicies> 2749 2750Returns: a L<Paws::IAM::ListRolePoliciesResponse> instance 2751 2752 2753 2754Lists the names of the inline policies that are embedded in the 2755specified role. 2756 2757A role can also have managed policies attached to it. To list the 2758managed policies that are attached to a role, use 2759ListAttachedRolePolicies. For more information about policies, refer to 2760Managed Policies and Inline Policies in the I<Using IAM> guide. 2761 2762You can paginate the results using the C<MaxItems> and C<Marker> 2763parameters. If there are no inline policies embedded with the specified 2764role, the action returns an empty list. 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776=head2 ListRoles([Marker => Str, MaxItems => Int, PathPrefix => Str]) 2777 2778Each argument is described in detail in: L<Paws::IAM::ListRoles> 2779 2780Returns: a L<Paws::IAM::ListRolesResponse> instance 2781 2782 2783 2784Lists the roles that have the specified path prefix. If there are none, 2785the action returns an empty list. For more information about roles, go 2786to Working with Roles. 2787 2788You can paginate the results using the C<MaxItems> and C<Marker> 2789parameters. 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801=head2 ListSAMLProviders( => ) 2802 2803Each argument is described in detail in: L<Paws::IAM::ListSAMLProviders> 2804 2805Returns: a L<Paws::IAM::ListSAMLProvidersResponse> instance 2806 2807 2808 2809Lists the SAML providers in the account. 2810 2811This operation requires Signature Version 4. 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823=head2 ListServerCertificates([Marker => Str, MaxItems => Int, PathPrefix => Str]) 2824 2825Each argument is described in detail in: L<Paws::IAM::ListServerCertificates> 2826 2827Returns: a L<Paws::IAM::ListServerCertificatesResponse> instance 2828 2829 2830 2831Lists the server certificates that have the specified path prefix. If 2832none exist, the action returns an empty list. 2833 2834You can paginate the results using the C<MaxItems> and C<Marker> 2835parameters. 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847=head2 ListSigningCertificates([Marker => Str, MaxItems => Int, UserName => Str]) 2848 2849Each argument is described in detail in: L<Paws::IAM::ListSigningCertificates> 2850 2851Returns: a L<Paws::IAM::ListSigningCertificatesResponse> instance 2852 2853 2854 2855Returns information about the signing certificates associated with the 2856specified user. If there are none, the action returns an empty list. 2857 2858Although each user is limited to a small number of signing 2859certificates, you can still paginate the results using the C<MaxItems> 2860and C<Marker> parameters. 2861 2862If the C<UserName> field is not specified, the user name is determined 2863implicitly based on the AWS access key ID used to sign the request. 2864Because this action works for access keys under the AWS account, you 2865can use this action to manage root credentials even if the AWS account 2866has no associated users. 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878=head2 ListSSHPublicKeys([Marker => Str, MaxItems => Int, UserName => Str]) 2879 2880Each argument is described in detail in: L<Paws::IAM::ListSSHPublicKeys> 2881 2882Returns: a L<Paws::IAM::ListSSHPublicKeysResponse> instance 2883 2884 2885 2886Returns information about the SSH public keys associated with the 2887specified IAM user. If there are none, the action returns an empty 2888list. 2889 2890The SSH public keys returned by this action are used only for 2891authenticating the IAM user to an AWS CodeCommit repository. For more 2892information about using SSH keys to authenticate to an AWS CodeCommit 2893repository, see Set up AWS CodeCommit for SSH Connections in the I<AWS 2894CodeCommit User Guide>. 2895 2896Although each user is limited to a small number of keys, you can still 2897paginate the results using the C<MaxItems> and C<Marker> parameters. 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909=head2 ListUserPolicies(UserName => Str, [Marker => Str, MaxItems => Int]) 2910 2911Each argument is described in detail in: L<Paws::IAM::ListUserPolicies> 2912 2913Returns: a L<Paws::IAM::ListUserPoliciesResponse> instance 2914 2915 2916 2917Lists the names of the inline policies embedded in the specified user. 2918 2919A user can also have managed policies attached to it. To list the 2920managed policies that are attached to a user, use 2921ListAttachedUserPolicies. For more information about policies, refer to 2922Managed Policies and Inline Policies in the I<Using IAM> guide. 2923 2924You can paginate the results using the C<MaxItems> and C<Marker> 2925parameters. If there are no inline policies embedded with the specified 2926user, the action returns an empty list. 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938=head2 ListUsers([Marker => Str, MaxItems => Int, PathPrefix => Str]) 2939 2940Each argument is described in detail in: L<Paws::IAM::ListUsers> 2941 2942Returns: a L<Paws::IAM::ListUsersResponse> instance 2943 2944 2945 2946Lists the IAM users that have the specified path prefix. If no path 2947prefix is specified, the action returns all users in the AWS account. 2948If there are none, the action returns an empty list. 2949 2950You can paginate the results using the C<MaxItems> and C<Marker> 2951parameters. 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963=head2 ListVirtualMFADevices([AssignmentStatus => Str, Marker => Str, MaxItems => Int]) 2964 2965Each argument is described in detail in: L<Paws::IAM::ListVirtualMFADevices> 2966 2967Returns: a L<Paws::IAM::ListVirtualMFADevicesResponse> instance 2968 2969 2970 2971Lists the virtual MFA devices under the AWS account by assignment 2972status. If you do not specify an assignment status, the action returns 2973a list of all virtual MFA devices. Assignment status can be 2974C<Assigned>, C<Unassigned>, or C<Any>. 2975 2976You can paginate the results using the C<MaxItems> and C<Marker> 2977parameters. 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989=head2 PutGroupPolicy(GroupName => Str, PolicyDocument => Str, PolicyName => Str) 2990 2991Each argument is described in detail in: L<Paws::IAM::PutGroupPolicy> 2992 2993Returns: nothing 2994 2995 2996 2997Adds (or updates) an inline policy document that is embedded in the 2998specified group. 2999 3000A user can also have managed policies attached to it. To attach a 3001managed policy to a group, use AttachGroupPolicy. To create a new 3002managed policy, use CreatePolicy. For information about policies, refer 3003to Managed Policies and Inline Policies in the I<Using IAM> guide. 3004 3005For information about limits on the number of inline policies that you 3006can embed in a group, see Limitations on IAM Entities in the I<Using 3007IAM> guide. 3008 3009Because policy documents can be large, you should use POST rather than 3010GET when calling C<PutGroupPolicy>. For general information about using 3011the Query API with IAM, go to Making Query Requests in the I<Using IAM> 3012guide. 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024=head2 PutRolePolicy(PolicyDocument => Str, PolicyName => Str, RoleName => Str) 3025 3026Each argument is described in detail in: L<Paws::IAM::PutRolePolicy> 3027 3028Returns: nothing 3029 3030 3031 3032Adds (or updates) an inline policy document that is embedded in the 3033specified role. 3034 3035When you embed an inline policy in a role, the inline policy is used as 3036the role's access (permissions) policy. The role's trust policy is 3037created at the same time as the role, using CreateRole. You can update 3038a role's trust policy using UpdateAssumeRolePolicy. For more 3039information about roles, go to Using Roles to Delegate Permissions and 3040Federate Identities. 3041 3042A role can also have a managed policy attached to it. To attach a 3043managed policy to a role, use AttachRolePolicy. To create a new managed 3044policy, use CreatePolicy. For information about policies, refer to 3045Managed Policies and Inline Policies in the I<Using IAM> guide. 3046 3047For information about limits on the number of inline policies that you 3048can embed with a role, see Limitations on IAM Entities in the I<Using 3049IAM> guide. 3050 3051Because policy documents can be large, you should use POST rather than 3052GET when calling C<PutRolePolicy>. For general information about using 3053the Query API with IAM, go to Making Query Requests in the I<Using IAM> 3054guide. 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066=head2 PutUserPolicy(PolicyDocument => Str, PolicyName => Str, UserName => Str) 3067 3068Each argument is described in detail in: L<Paws::IAM::PutUserPolicy> 3069 3070Returns: nothing 3071 3072 3073 3074Adds (or updates) an inline policy document that is embedded in the 3075specified user. 3076 3077A user can also have a managed policy attached to it. To attach a 3078managed policy to a user, use AttachUserPolicy. To create a new managed 3079policy, use CreatePolicy. For information about policies, refer to 3080Managed Policies and Inline Policies in the I<Using IAM> guide. 3081 3082For information about limits on the number of inline policies that you 3083can embed in a user, see Limitations on IAM Entities in the I<Using 3084IAM> guide. 3085 3086Because policy documents can be large, you should use POST rather than 3087GET when calling C<PutUserPolicy>. For general information about using 3088the Query API with IAM, go to Making Query Requests in the I<Using IAM> 3089guide. 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101=head2 RemoveClientIDFromOpenIDConnectProvider(ClientID => Str, OpenIDConnectProviderArn => Str) 3102 3103Each argument is described in detail in: L<Paws::IAM::RemoveClientIDFromOpenIDConnectProvider> 3104 3105Returns: nothing 3106 3107 3108 3109Removes the specified client ID (also known as audience) from the list 3110of client IDs registered for the specified IAM OpenID Connect provider. 3111 3112This action is idempotent; it does not fail or return an error if you 3113try to remove a client ID that was removed previously. 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125=head2 RemoveRoleFromInstanceProfile(InstanceProfileName => Str, RoleName => Str) 3126 3127Each argument is described in detail in: L<Paws::IAM::RemoveRoleFromInstanceProfile> 3128 3129Returns: nothing 3130 3131 3132 3133Removes the specified role from the specified instance profile. 3134 3135Make sure you do not have any Amazon EC2 instances running with the 3136role you are about to remove from the instance profile. Removing a role 3137from an instance profile that is associated with a running instance 3138will break any applications running on the instance. 3139 3140For more information about roles, go to Working with Roles. For more 3141information about instance profiles, go to About Instance Profiles. 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153=head2 RemoveUserFromGroup(GroupName => Str, UserName => Str) 3154 3155Each argument is described in detail in: L<Paws::IAM::RemoveUserFromGroup> 3156 3157Returns: nothing 3158 3159 3160 3161Removes the specified user from the specified group. 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173=head2 ResyncMFADevice(AuthenticationCode1 => Str, AuthenticationCode2 => Str, SerialNumber => Str, UserName => Str) 3174 3175Each argument is described in detail in: L<Paws::IAM::ResyncMFADevice> 3176 3177Returns: nothing 3178 3179 3180 3181Synchronizes the specified MFA device with AWS servers. 3182 3183For more information about creating and working with virtual MFA 3184devices, go to Using a Virtual MFA Device in the I<Using IAM> guide. 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196=head2 SetDefaultPolicyVersion(PolicyArn => Str, VersionId => Str) 3197 3198Each argument is described in detail in: L<Paws::IAM::SetDefaultPolicyVersion> 3199 3200Returns: nothing 3201 3202 3203 3204Sets the specified version of the specified policy as the policy's 3205default (operative) version. 3206 3207This action affects all users, groups, and roles that the policy is 3208attached to. To list the users, groups, and roles that the policy is 3209attached to, use the ListEntitiesForPolicy API. 3210 3211For information about managed policies, refer to Managed Policies and 3212Inline Policies in the I<Using IAM> guide. 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224=head2 UpdateAccessKey(AccessKeyId => Str, Status => Str, [UserName => Str]) 3225 3226Each argument is described in detail in: L<Paws::IAM::UpdateAccessKey> 3227 3228Returns: nothing 3229 3230 3231 3232Changes the status of the specified access key from Active to Inactive, 3233or vice versa. This action can be used to disable a user's key as part 3234of a key rotation work flow. 3235 3236If the C<UserName> field is not specified, the UserName is determined 3237implicitly based on the AWS access key ID used to sign the request. 3238Because this action works for access keys under the AWS account, you 3239can use this action to manage root credentials even if the AWS account 3240has no associated users. 3241 3242For information about rotating keys, see Managing Keys and Certificates 3243in the I<Using IAM> guide. 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255=head2 UpdateAccountPasswordPolicy([AllowUsersToChangePassword => Bool, HardExpiry => Bool, MaxPasswordAge => Int, MinimumPasswordLength => Int, PasswordReusePrevention => Int, RequireLowercaseCharacters => Bool, RequireNumbers => Bool, RequireSymbols => Bool, RequireUppercaseCharacters => Bool]) 3256 3257Each argument is described in detail in: L<Paws::IAM::UpdateAccountPasswordPolicy> 3258 3259Returns: nothing 3260 3261 3262 3263Updates the password policy settings for the AWS account. 3264 3265This action does not support partial updates. No parameters are 3266required, but if you do not specify a parameter, that parameter's value 3267reverts to its default value. See the B<Request Parameters> section for 3268each parameter's default value. 3269 3270For more information about using a password policy, see Managing an IAM 3271Password Policy in the I<Using IAM> guide. 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283=head2 UpdateAssumeRolePolicy(PolicyDocument => Str, RoleName => Str) 3284 3285Each argument is described in detail in: L<Paws::IAM::UpdateAssumeRolePolicy> 3286 3287Returns: nothing 3288 3289 3290 3291Updates the policy that grants an entity permission to assume a role. 3292For more information about roles, go to Using Roles to Delegate 3293Permissions and Federate Identities. 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305=head2 UpdateGroup(GroupName => Str, [NewGroupName => Str, NewPath => Str]) 3306 3307Each argument is described in detail in: L<Paws::IAM::UpdateGroup> 3308 3309Returns: nothing 3310 3311 3312 3313Updates the name and/or the path of the specified group. 3314 3315You should understand the implications of changing a group's path or 3316name. For more information, see Renaming Users and Groups in the 3317I<Using IAM> guide. To change a group name the requester must have 3318appropriate permissions on both the source object and the target 3319object. For example, to change Managers to MGRs, the entity making the 3320request must have permission on Managers and MGRs, or must have 3321permission on all (*). For more information about permissions, see 3322Permissions and Policies. 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334=head2 UpdateLoginProfile(UserName => Str, [Password => Str, PasswordResetRequired => Bool]) 3335 3336Each argument is described in detail in: L<Paws::IAM::UpdateLoginProfile> 3337 3338Returns: nothing 3339 3340 3341 3342Changes the password for the specified user. 3343 3344Users can change their own passwords by calling ChangePassword. For 3345more information about modifying passwords, see Managing Passwords in 3346the I<Using IAM> guide. 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358=head2 UpdateOpenIDConnectProviderThumbprint(OpenIDConnectProviderArn => Str, ThumbprintList => ArrayRef[Str]) 3359 3360Each argument is described in detail in: L<Paws::IAM::UpdateOpenIDConnectProviderThumbprint> 3361 3362Returns: nothing 3363 3364 3365 3366Replaces the existing list of server certificate thumbprints with a new 3367list. 3368 3369The list that you pass with this action completely replaces the 3370existing list of thumbprints. (The lists are not merged.) 3371 3372Typically, you need to update a thumbprint only when the identity 3373provider's certificate changes, which occurs rarely. However, if the 3374provider's certificate I<does> change, any attempt to assume an IAM 3375role that specifies the OIDC provider as a principal will fail until 3376the certificate thumbprint is updated. 3377 3378Because trust for the OpenID Connect provider is ultimately derived 3379from the provider's certificate and is validated by the thumbprint, it 3380is a best practice to limit access to the 3381C<UpdateOpenIDConnectProviderThumbprint> action to highly-privileged 3382users. 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394=head2 UpdateSAMLProvider(SAMLMetadataDocument => Str, SAMLProviderArn => Str) 3395 3396Each argument is described in detail in: L<Paws::IAM::UpdateSAMLProvider> 3397 3398Returns: a L<Paws::IAM::UpdateSAMLProviderResponse> instance 3399 3400 3401 3402Updates the metadata document for an existing SAML provider. 3403 3404This operation requires Signature Version 4. 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416=head2 UpdateServerCertificate(ServerCertificateName => Str, [NewPath => Str, NewServerCertificateName => Str]) 3417 3418Each argument is described in detail in: L<Paws::IAM::UpdateServerCertificate> 3419 3420Returns: nothing 3421 3422 3423 3424Updates the name and/or the path of the specified server certificate. 3425 3426You should understand the implications of changing a server 3427certificate's path or name. For more information, see Managing Server 3428Certificates in the I<Using IAM> guide. To change a server certificate 3429name the requester must have appropriate permissions on both the source 3430object and the target object. For example, to change the name from 3431ProductionCert to ProdCert, the entity making the request must have 3432permission on ProductionCert and ProdCert, or must have permission on 3433all (*). For more information about permissions, see Permissions and 3434Policies. 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446=head2 UpdateSigningCertificate(CertificateId => Str, Status => Str, [UserName => Str]) 3447 3448Each argument is described in detail in: L<Paws::IAM::UpdateSigningCertificate> 3449 3450Returns: nothing 3451 3452 3453 3454Changes the status of the specified signing certificate from active to 3455disabled, or vice versa. This action can be used to disable a user's 3456signing certificate as part of a certificate rotation work flow. 3457 3458If the C<UserName> field is not specified, the UserName is determined 3459implicitly based on the AWS access key ID used to sign the request. 3460Because this action works for access keys under the AWS account, you 3461can use this action to manage root credentials even if the AWS account 3462has no associated users. 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474=head2 UpdateSSHPublicKey(SSHPublicKeyId => Str, Status => Str, UserName => Str) 3475 3476Each argument is described in detail in: L<Paws::IAM::UpdateSSHPublicKey> 3477 3478Returns: nothing 3479 3480 3481 3482Sets the status of the specified SSH public key to active or inactive. 3483SSH public keys that are inactive cannot be used for authentication. 3484This action can be used to disable a user's SSH public key as part of a 3485key rotation work flow. 3486 3487The SSH public key affected by this action is used only for 3488authenticating the associated IAM user to an AWS CodeCommit repository. 3489For more information about using SSH keys to authenticate to an AWS 3490CodeCommit repository, see Set up AWS CodeCommit for SSH Connections in 3491the I<AWS CodeCommit User Guide>. 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503=head2 UpdateUser(UserName => Str, [NewPath => Str, NewUserName => Str]) 3504 3505Each argument is described in detail in: L<Paws::IAM::UpdateUser> 3506 3507Returns: nothing 3508 3509 3510 3511Updates the name and/or the path of the specified user. 3512 3513You should understand the implications of changing a user's path or 3514name. For more information, see Renaming Users and Groups in the 3515I<Using IAM> guide. To change a user name the requester must have 3516appropriate permissions on both the source object and the target 3517object. For example, to change Bob to Robert, the entity making the 3518request must have permission on Bob and Robert, or must have permission 3519on all (*). For more information about permissions, see Permissions and 3520Policies. 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532=head2 UploadServerCertificate(CertificateBody => Str, PrivateKey => Str, ServerCertificateName => Str, [CertificateChain => Str, Path => Str]) 3533 3534Each argument is described in detail in: L<Paws::IAM::UploadServerCertificate> 3535 3536Returns: a L<Paws::IAM::UploadServerCertificateResponse> instance 3537 3538 3539 3540Uploads a server certificate entity for the AWS account. The server 3541certificate entity includes a public key certificate, a private key, 3542and an optional certificate chain, which should all be PEM-encoded. 3543 3544For information about the number of server certificates you can upload, 3545see Limitations on IAM Entities in the I<Using IAM> guide. 3546 3547Because the body of the public key certificate, private key, and the 3548certificate chain can be large, you should use POST rather than GET 3549when calling C<UploadServerCertificate>. For information about setting 3550up signatures and authorization through the API, go to Signing AWS API 3551Requests in the I<AWS General Reference>. For general information about 3552using the Query API with IAM, go to Making Query Requests in the 3553I<Using IAM> guide. 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565=head2 UploadSigningCertificate(CertificateBody => Str, [UserName => Str]) 3566 3567Each argument is described in detail in: L<Paws::IAM::UploadSigningCertificate> 3568 3569Returns: a L<Paws::IAM::UploadSigningCertificateResponse> instance 3570 3571 3572 3573Uploads an X.509 signing certificate and associates it with the 3574specified user. Some AWS services use X.509 signing certificates to 3575validate requests that are signed with a corresponding private key. 3576When you upload the certificate, its default status is C<Active>. 3577 3578If the C<UserName> field is not specified, the user name is determined 3579implicitly based on the AWS access key ID used to sign the request. 3580Because this action works for access keys under the AWS account, you 3581can use this action to manage root credentials even if the AWS account 3582has no associated users. 3583 3584Because the body of a X.509 certificate can be large, you should use 3585POST rather than GET when calling C<UploadSigningCertificate>. For 3586information about setting up signatures and authorization through the 3587API, go to Signing AWS API Requests in the I<AWS General Reference>. 3588For general information about using the Query API with IAM, go to 3589Making Query Requests in the I<Using IAM>guide. 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601=head2 UploadSSHPublicKey(SSHPublicKeyBody => Str, UserName => Str) 3602 3603Each argument is described in detail in: L<Paws::IAM::UploadSSHPublicKey> 3604 3605Returns: a L<Paws::IAM::UploadSSHPublicKeyResponse> instance 3606 3607 3608 3609Uploads an SSH public key and associates it with the specified IAM 3610user. 3611 3612The SSH public key uploaded by this action can be used only for 3613authenticating the associated IAM user to an AWS CodeCommit repository. 3614For more information about using SSH keys to authenticate to an AWS 3615CodeCommit repository, see Set up AWS CodeCommit for SSH Connections in 3616the I<AWS CodeCommit User Guide>. 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628=head1 SEE ALSO 3629 3630This service class forms part of L<Paws> 3631 3632=head1 BUGS and CONTRIBUTIONS 3633 3634The source code is located here: https://github.com/pplu/aws-sdk-perl 3635 3636Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues 3637 3638=cut 3639 3640