Class: Aws::IAM::Client

Inherits:
Seahorse::Client::Base
  • Object
show all
Includes:
ClientStubs
Defined in:
lib/aws-sdk-iam/client.rb

Overview

An API client for IAM. To construct a client, you need to configure a ‘:region` and `:credentials`.

client = Aws::IAM::Client.new(
  region: region_name,
  credentials: credentials,
  # ...
)

For details on configuring region and credentials see the [developer guide](/sdk-for-ruby/v3/developer-guide/setup-config.html).

See #initialize for a full list of supported configuration options.

Class Attribute Summary collapse

API Operations collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ Client

Returns a new instance of Client.

Parameters:

  • options (Hash)

Options Hash (options):

  • :credentials (required, Aws::CredentialProvider) —

    Your AWS credentials. This can be an instance of any one of the following classes:

    • ‘Aws::Credentials` - Used for configuring static, non-refreshing credentials.

    • ‘Aws::SharedCredentials` - Used for loading static credentials from a shared file, such as `~/.aws/config`.

    • ‘Aws::AssumeRoleCredentials` - Used when you need to assume a role.

    • ‘Aws::AssumeRoleWebIdentityCredentials` - Used when you need to assume a role after providing credentials via the web.

    • ‘Aws::SSOCredentials` - Used for loading credentials from AWS SSO using an access token generated from `aws login`.

    • ‘Aws::ProcessCredentials` - Used for loading credentials from a process that outputs to stdout.

    • ‘Aws::InstanceProfileCredentials` - Used for loading credentials from an EC2 IMDS on an EC2 instance.

    • ‘Aws::ECSCredentials` - Used for loading credentials from instances running in ECS.

    • ‘Aws::CognitoIdentityCredentials` - Used for loading credentials from the Cognito Identity service.

    When ‘:credentials` are not configured directly, the following locations will be searched for credentials:

    • ‘Aws.config`

    • The ‘:access_key_id`, `:secret_access_key`, and `:session_token` options.

    • ENV, ENV

    • ‘~/.aws/credentials`

    • ‘~/.aws/config`

    • EC2/ECS IMDS instance profile - When used by default, the timeouts are very aggressive. Construct and pass an instance of ‘Aws::InstanceProfileCredentails` or `Aws::ECSCredentials` to enable retries and extended timeouts. Instance profile credential fetching can be disabled by setting ENV to true.

  • :region (required, String) —

    The AWS region to connect to. The configured ‘:region` is used to determine the service `:endpoint`. When not passed, a default `:region` is searched for in the following locations:

  • :access_key_id (String)
  • :active_endpoint_cache (Boolean) — default: false —

    When set to ‘true`, a thread polling for endpoints will be running in the background every 60 secs (default). Defaults to `false`.

  • :adaptive_retry_wait_to_fill (Boolean) — default: true —

    Used only in ‘adaptive` retry mode. When true, the request will sleep until there is sufficent client side capacity to retry the request. When false, the request will raise a `RetryCapacityNotAvailableError` and will not retry instead of sleeping.

  • :client_side_monitoring (Boolean) — default: false —

    When ‘true`, client-side metrics will be collected for all API requests from this client.

  • :client_side_monitoring_client_id (String) — default: "" —

    Allows you to provide an identifier for this client which will be attached to all generated client side metrics. Defaults to an empty string.

  • :client_side_monitoring_host (String) — default: "127.0.0.1" —

    Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_port (Integer) — default: 31000 —

    Required for publishing client metrics. The port that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_publisher (Aws::ClientSideMonitoring::Publisher) — default: Aws::ClientSideMonitoring::Publisher —

    Allows you to provide a custom client-side monitoring publisher class. By default, will use the Client Side Monitoring Agent Publisher.

  • :convert_params (Boolean) — default: true —

    When ‘true`, an attempt is made to coerce request parameters into the required types.

  • :correct_clock_skew (Boolean) — default: true —

    Used only in ‘standard` and adaptive retry modes. Specifies whether to apply a clock skew correction and retry requests with skewed client clocks.

  • :defaults_mode (String) — default: "legacy" —

    See DefaultsModeConfiguration for a list of the accepted modes and the configuration defaults that are included.

  • :disable_host_prefix_injection (Boolean) — default: false —

    Set to true to disable SDK automatically adding host prefix to default service endpoint when available.

  • :disable_request_compression (Boolean) — default: false —

    When set to ‘true’ the request body will not be compressed for supported operations.

  • :endpoint (String) —

    The client endpoint is normally constructed from the ‘:region` option. You should only configure an `:endpoint` when connecting to test or custom endpoints. This should be a valid HTTP(S) URI.

  • :endpoint_cache_max_entries (Integer) — default: 1000 —

    Used for the maximum size limit of the LRU cache storing endpoints data for endpoint discovery enabled operations. Defaults to 1000.

  • :endpoint_cache_max_threads (Integer) — default: 10 —

    Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.

  • :endpoint_cache_poll_interval (Integer) — default: 60 —

    When :endpoint_discovery and :active_endpoint_cache is enabled, Use this option to config the time interval in seconds for making requests fetching endpoints information. Defaults to 60 sec.

  • :endpoint_discovery (Boolean) — default: false —

    When set to ‘true`, endpoint discovery will be enabled for operations when available.

  • :ignore_configured_endpoint_urls (Boolean) —

    Setting to true disables use of endpoint URLs provided via environment variables and the shared configuration file.

  • :log_formatter (Aws::Log::Formatter) — default: Aws::Log::Formatter.default —

    The log formatter.

  • :log_level (Symbol) — default: :info —

    The log level to send messages to the ‘:logger` at.

  • :logger (Logger) —

    The Logger instance to send log messages to. If this option is not set, logging will be disabled.

  • :max_attempts (Integer) — default: 3 —

    An integer representing the maximum number attempts that will be made for a single request, including the initial attempt. For example, setting this value to 5 will result in a request being retried up to 4 times. Used in ‘standard` and `adaptive` retry modes.

  • :profile (String) — default: "default" —

    Used when loading credentials from the shared credentials file at HOME/.aws/credentials. When not specified, ‘default’ is used.

  • :request_min_compression_size_bytes (Integer) — default: 10240 —

    The minimum size in bytes that triggers compression for request bodies. The value must be non-negative integer value between 0 and 10485780 bytes inclusive.

  • :retry_backoff (Proc) —

    A proc or lambda used for backoff. Defaults to 2**retries * retry_base_delay. This option is only used in the ‘legacy` retry mode.

  • :retry_base_delay (Float) — default: 0.3 —

    The base delay in seconds used by the default backoff function. This option is only used in the ‘legacy` retry mode.

  • :retry_jitter (Symbol) — default: :none —

    A delay randomiser function used by the default backoff function. Some predefined functions can be referenced by name - :none, :equal, :full, otherwise a Proc that takes and returns a number. This option is only used in the ‘legacy` retry mode.

    @see www.awsarchitectureblog.com/2015/03/backoff.html

  • :retry_limit (Integer) — default: 3 —

    The maximum number of times to retry failed requests. Only ~ 500 level server errors and certain ~ 400 level client errors are retried. Generally, these are throttling errors, data checksum errors, networking errors, timeout errors, auth errors, endpoint discovery, and errors from expired credentials. This option is only used in the ‘legacy` retry mode.

  • :retry_max_delay (Integer) — default: 0 —

    The maximum number of seconds to delay between retries (0 for no limit) used by the default backoff function. This option is only used in the ‘legacy` retry mode.

  • :retry_mode (String) — default: "legacy" —

    Specifies which retry algorithm to use. Values are:

    • ‘legacy` - The pre-existing retry behavior. This is default value if no retry mode is provided.

    • ‘standard` - A standardized set of retry rules across the AWS SDKs. This includes support for retry quotas, which limit the number of unsuccessful retries a client can make.

    • ‘adaptive` - An experimental retry mode that includes all the functionality of `standard` mode along with automatic client side throttling. This is a provisional mode that may change behavior in the future.

  • :sdk_ua_app_id (String) —

    A unique and opaque application ID that is appended to the User-Agent header as app/<sdk_ua_app_id>. It should have a maximum length of 50.

  • :secret_access_key (String)
  • :session_token (String)
  • :stub_responses (Boolean) — default: false —

    Causes the client to return stubbed responses. By default fake responses are generated and returned. You can specify the response data to return or errors to raise by calling ClientStubs#stub_responses. See ClientStubs for more information.

    ** Please note ** When response stubbing is enabled, no HTTP requests are made, and retries are disabled.

  • :token_provider (Aws::TokenProvider) —

    A Bearer Token Provider. This can be an instance of any one of the following classes:

    • ‘Aws::StaticTokenProvider` - Used for configuring static, non-refreshing tokens.

    • ‘Aws::SSOTokenProvider` - Used for loading tokens from AWS SSO using an access token generated from `aws login`.

    When ‘:token_provider` is not configured directly, the `Aws::TokenProviderChain` will be used to search for tokens configured for your profile in shared configuration files.

  • :use_dualstack_endpoint (Boolean) —

    When set to ‘true`, dualstack enabled endpoints (with `.aws` TLD) will be used if available.

  • :use_fips_endpoint (Boolean) —

    When set to ‘true`, fips compatible endpoints will be used if available. When a `fips` region is used, the region is normalized and this config is set to `true`.

  • :validate_params (Boolean) — default: true —

    When ‘true`, request parameters are validated before sending the request.

  • :endpoint_provider (Aws::IAM::EndpointProvider) —

    The endpoint provider used to resolve endpoints. Any object that responds to ‘#resolve_endpoint(parameters)` where `parameters` is a Struct similar to `Aws::IAM::EndpointParameters`

  • :http_proxy (URI::HTTP, String) —

    A proxy to send requests through. Formatted like ‘proxy.com:123’.

  • :http_open_timeout (Float) — default: 15 —

    The number of seconds to wait when opening a HTTP session before raising a ‘Timeout::Error`.

  • :http_read_timeout (Float) — default: 60 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_idle_timeout (Float) — default: 5 —

    The number of seconds a connection is allowed to sit idle before it is considered stale. Stale connections are closed and removed from the pool before making a request.

  • :http_continue_timeout (Float) — default: 1 —

    The number of seconds to wait for a 100-continue response before sending the request body. This option has no effect unless the request has “Expect” header set to “100-continue”. Defaults to ‘nil` which disables this behaviour. This value can safely be set per request on the session.

  • :ssl_timeout (Float) — default: nil —

    Sets the SSL timeout in seconds.

  • :http_wire_trace (Boolean) — default: false —

    When ‘true`, HTTP debug output will be sent to the `:logger`.

  • :ssl_verify_peer (Boolean) — default: true —

    When ‘true`, SSL peer certificates are verified when establishing a connection.

  • :ssl_ca_bundle (String) —

    Full path to the SSL certificate authority bundle file that should be used when verifying peer certificates. If you do not pass ‘:ssl_ca_bundle` or `:ssl_ca_directory` the the system default will be used if available.

  • :ssl_ca_directory (String) —

    Full path of the directory that contains the unbundled SSL certificate authority files for verifying peer certificates. If you do not pass ‘:ssl_ca_bundle` or `:ssl_ca_directory` the the system default will be used if available.



385
386
387
 
# File 'lib/aws-sdk-iam/client.rb', line 385

def initialize(*args)
  super
end

Class Attribute Details

.identifier ⇒ Object (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



13602
13603
13604
 
# File 'lib/aws-sdk-iam/client.rb', line 13602

def identifier
  @identifier
end

Class Method Details

.errors_module ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



13605
13606
13607
 
# File 'lib/aws-sdk-iam/client.rb', line 13605

def errors_module
  Errors
end

Instance Method Details

#add_client_id_to_open_id_connect_provider(params = {}) ⇒ Struct

Adds a new client ID (also known as audience) to the list of client IDs already registered for the specified IAM OpenID Connect (OIDC) provider resource.

This operation is idempotent; it does not fail or return an error if you add an existing client ID to the provider.

Examples:

Example: To add a client ID (audience) to an Open-ID Connect (OIDC) provider


# The following add-client-id-to-open-id-connect-provider command adds the client ID my-application-ID to the OIDC
# provider named server.example.com:

resp = client.add_client_id_to_open_id_connect_provider({
  client_id: "my-application-ID", 
  open_id_connect_provider_arn: "arn:aws:iam::123456789012:oidc-provider/server.example.com", 
})

Request syntax with placeholder values


resp = client.add_client_id_to_open_id_connect_provider({
  open_id_connect_provider_arn: "arnType", # required
  client_id: "clientIDType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :open_id_connect_provider_arn (required, String) —

    The Amazon Resource Name (ARN) of the IAM OpenID Connect (OIDC) provider resource to add the client ID to. You can get a list of OIDC provider ARNs by using the ListOpenIDConnectProviders operation.

  • :client_id (required, String) —

    The client ID (also known as audience) to add to the IAM OpenID Connect provider resource.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



431
432
433
434
 
# File 'lib/aws-sdk-iam/client.rb', line 431

def add_client_id_to_open_id_connect_provider(params = {}, options = {})
  req = build_request(:add_client_id_to_open_id_connect_provider, params)
  req.send_request(options)
end

#add_role_to_instance_profile(params = {}) ⇒ Struct

Adds the specified IAM role to the specified instance profile. An instance profile can contain only one role, and this quota cannot be increased. You can remove the existing role and then add a different role to an instance profile. You must then wait for the change to appear across all of Amazon Web Services because of [eventual consistency]. To force the change, you must [disassociate the instance profile] and then [associate the instance profile], or you can stop your instance and then restart it.

<note markdown=“1”> The caller of this operation must be granted the ‘PassRole` permission on the IAM role by a permissions policy.

</note>

For more information about roles, see [IAM roles] in the *IAM User Guide*. For more information about instance profiles, see [Using instance profiles] in the *IAM User Guide*.

[1]: en.wikipedia.org/wiki/Eventual_consistency [2]: docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html [3]: docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html [4]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html [5]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html

Examples:

Example: To add a role to an instance profile


# The following command adds the role named S3Access to the instance profile named Webserver:

resp = client.add_role_to_instance_profile({
  instance_profile_name: "Webserver", 
  role_name: "S3Access", 
})

Request syntax with placeholder values


resp = client.add_role_to_instance_profile({
  instance_profile_name: "instanceProfileNameType", # required
  role_name: "roleNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :instance_profile_name (required, String) —

    The name of the instance profile to update.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :role_name (required, String) —

    The name of the role to add.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



509
510
511
512
 
# File 'lib/aws-sdk-iam/client.rb', line 509

def add_role_to_instance_profile(params = {}, options = {})
  req = build_request(:add_role_to_instance_profile, params)
  req.send_request(options)
end

#add_user_to_group(params = {}) ⇒ Struct

Adds the specified user to the specified group.

Examples:

Example: To add a user to an IAM group


# The following command adds an IAM user named Bob to the IAM group named Admins:

resp = client.add_user_to_group({
  group_name: "Admins", 
  user_name: "Bob", 
})

Request syntax with placeholder values


resp = client.add_user_to_group({
  group_name: "groupNameType", # required
  user_name: "existingUserNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :group_name (required, String) —

    The name of the group to update.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :user_name (required, String) —

    The name of the user to add.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



563
564
565
566
 
# File 'lib/aws-sdk-iam/client.rb', line 563

def add_user_to_group(params = {}, options = {})
  req = build_request(:add_user_to_group, params)
  req.send_request(options)
end

#attach_group_policy(params = {}) ⇒ Struct

Attaches the specified managed policy to the specified IAM group.

You use this operation to attach a managed policy to a group. To embed an inline policy in a group, use [ ‘PutGroupPolicy` ][1].

As a best practice, you can validate your IAM policies. To learn more, see [Validating IAM policies] in the *IAM User Guide*.

For more information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/APIReference/API_PutGroupPolicy.html [2]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_policy-validator.html [3]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

Examples:

Example: To attach a managed policy to an IAM group


# The following command attaches the AWS managed policy named ReadOnlyAccess to the IAM group named Finance.

resp = client.attach_group_policy({
  group_name: "Finance", 
  policy_arn: "arn:aws:iam::aws:policy/ReadOnlyAccess", 
})

Request syntax with placeholder values


resp = client.attach_group_policy({
  group_name: "groupNameType", # required
  policy_arn: "arnType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :group_name (required, String) —

    The name (friendly name, not ARN) of the group to attach the policy to.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the IAM policy you want to attach.

    For more information about ARNs, see [Amazon Resource Names (ARNs)] in the *Amazon Web Services General Reference*.

    [1]: docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



631
632
633
634
 
# File 'lib/aws-sdk-iam/client.rb', line 631

def attach_group_policy(params = {}, options = {})
  req = build_request(:attach_group_policy, params)
  req.send_request(options)
end

#attach_role_policy(params = {}) ⇒ Struct

Attaches the specified managed policy to the specified IAM role. When you attach a managed policy to a role, the managed policy becomes part of the role’s permission (access) policy.

<note markdown=“1”> You cannot use a managed policy as the role’s trust policy. The role’s trust policy is created at the same time as the role, using [ ‘CreateRole` ][1]. You can update a role’s trust policy using [ ‘UpdateAssumerolePolicy` ][2].

</note>

Use this operation to attach a managed policy to a role. To embed an inline policy in a role, use [ ‘PutRolePolicy` ][3]. For more information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

As a best practice, you can validate your IAM policies. To learn more, see [Validating IAM policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html [2]: docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateAssumeRolePolicy.html [3]: docs.aws.amazon.com/IAM/latest/APIReference/API_PutRolePolicy.html [4]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html [5]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_policy-validator.html

Examples:

Example: To attach a managed policy to an IAM role


# The following command attaches the AWS managed policy named ReadOnlyAccess to the IAM role named ReadOnlyRole.

resp = client.attach_role_policy({
  policy_arn: "arn:aws:iam::aws:policy/ReadOnlyAccess", 
  role_name: "ReadOnlyRole", 
})

Request syntax with placeholder values


resp = client.attach_role_policy({
  role_name: "roleNameType", # required
  policy_arn: "arnType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :role_name (required, String) —

    The name (friendly name, not ARN) of the role to attach the policy to.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the IAM policy you want to attach.

    For more information about ARNs, see [Amazon Resource Names (ARNs)] in the *Amazon Web Services General Reference*.

    [1]: docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



708
709
710
711
 
# File 'lib/aws-sdk-iam/client.rb', line 708

def attach_role_policy(params = {}, options = {})
  req = build_request(:attach_role_policy, params)
  req.send_request(options)
end

#attach_user_policy(params = {}) ⇒ Struct

Attaches the specified managed policy to the specified user.

You use this operation to attach a managed policy to a user. To embed an inline policy in a user, use [ ‘PutUserPolicy` ][1].

As a best practice, you can validate your IAM policies. To learn more, see [Validating IAM policies] in the *IAM User Guide*.

For more information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/APIReference/API_PutUserPolicy.html [2]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_policy-validator.html [3]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

Examples:

Example: To attach a managed policy to an IAM user


# The following command attaches the AWS managed policy named AdministratorAccess to the IAM user named Alice.

resp = client.attach_user_policy({
  policy_arn: "arn:aws:iam::aws:policy/AdministratorAccess", 
  user_name: "Alice", 
})

Request syntax with placeholder values


resp = client.attach_user_policy({
  user_name: "userNameType", # required
  policy_arn: "arnType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name (friendly name, not ARN) of the IAM user to attach the policy to.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the IAM policy you want to attach.

    For more information about ARNs, see [Amazon Resource Names (ARNs)] in the *Amazon Web Services General Reference*.

    [1]: docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



776
777
778
779
 
# File 'lib/aws-sdk-iam/client.rb', line 776

def attach_user_policy(params = {}, options = {})
  req = build_request(:attach_user_policy, params)
  req.send_request(options)
end

#build_request(operation_name, params = {}) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

  • params ({}) (defaults to: {}) 


13461
13462
13463
13464
13465
13466
13467
13468
13469
13470
13471
13472
 
# File 'lib/aws-sdk-iam/client.rb', line 13461

def build_request(operation_name, params = {})
  handlers = @handlers.for(operation_name)
  context = Seahorse::Client::RequestContext.new(
    operation_name: operation_name,
    operation: config.api.operation(operation_name),
    client: self,
    params: params,
    config: config)
  context[:gem_name] = 'aws-sdk-iam'
  context[:gem_version] = '1.91.0'
  Seahorse::Client::Request.new(handlers, context)
end

#change_password(params = {}) ⇒ Struct

Changes the password of the IAM user who is calling this operation. This operation can be performed using the CLI, the Amazon Web Services API, or the **My Security Credentials** page in the Amazon Web Services Management Console. The Amazon Web Services account root user password is not affected by this operation.

Use UpdateLoginProfile to use the CLI, the Amazon Web Services API, or the Users page in the IAM console to change the password for any IAM user. For more information about modifying passwords, see

Managing passwords][1

in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingLogins.html

Examples:

Example: To change the password for your IAM user


# The following command changes the password for the current IAM user.

resp = client.change_password({
  new_password: "]35d/{pB9Fo9wJ", 
  old_password: "3s0K_;xh4~8XXI", 
})

Request syntax with placeholder values


resp = client.change_password({
  old_password: "passwordType", # required
  new_password: "passwordType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :old_password (required, String) —

    The IAM user’s current password.

  • :new_password (required, String) —

    The new password. The new password must conform to the Amazon Web Services account’s password policy, if one exists.

    The [regex pattern] that is used to validate this parameter is a string of characters. That string can include almost any printable ASCII character from the space (‘u0020`) through the end of the ASCII character range (`u00FF`). You can also include the tab (`u0009`), line feed (`u000A`), and carriage return (`u000D`) characters. Any of these characters are valid in a password. However, many tools, such as the Amazon Web Services Management Console, might restrict the ability to type certain characters because they have special meaning within that tool.

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



840
841
842
843
 
# File 'lib/aws-sdk-iam/client.rb', line 840

def change_password(params = {}, options = {})
  req = build_request(:change_password, params)
  req.send_request(options)
end

#create_access_key(params = {}) ⇒ Types::CreateAccessKeyResponse

Creates a new Amazon Web Services secret access key and corresponding Amazon Web Services access key ID for the specified user. The default status for new keys is ‘Active`.

If you do not specify a user name, IAM determines the user name implicitly based on the Amazon Web Services access key ID signing the request. This operation works for access keys under the Amazon Web Services account. Consequently, you can use this operation to manage Amazon Web Services account root user credentials. This is true even if the Amazon Web Services account has no associated users.

For information about quotas on the number of keys you can create, see

IAM and STS quotas][1

in the *IAM User Guide*.

To ensure the security of your Amazon Web Services account, the secret access key is accessible only during key and user creation. You must save the key (for example, in a text file) if you want to be able to access it again. If a secret key is lost, you can delete the access keys for the associated user and then create new keys.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html

Examples:

Example: To create an access key for an IAM user


# The following command creates an access key (access key ID and secret access key) for the IAM user named Bob.

resp = client.create_access_key({
  user_name: "Bob", 
})

resp.to_h outputs the following:
{
  access_key: {
    access_key_id: "AKIAIOSFODNN7EXAMPLE", 
    create_date: Time.parse("2015-03-09T18:39:23.411Z"), 
    secret_access_key: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYzEXAMPLEKEY", 
    status: "Active", 
    user_name: "Bob", 
  }, 
}

Request syntax with placeholder values


resp = client.create_access_key({
  user_name: "existingUserNameType",
})

Response structure


resp.access_key.user_name #=> String
resp.access_key.access_key_id #=> String
resp.access_key.status #=> String, one of "Active", "Inactive"
resp.access_key.secret_access_key #=> String
resp.access_key.create_date #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (String) —

    The name of the IAM user that the new key will belong to.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



923
924
925
926
 
# File 'lib/aws-sdk-iam/client.rb', line 923

def create_access_key(params = {}, options = {})
  req = build_request(:create_access_key, params)
  req.send_request(options)
end

#create_account_alias(params = {}) ⇒ Struct

Creates an alias for your Amazon Web Services account. For information about using an Amazon Web Services account alias, see [Creating, deleting, and listing an Amazon Web Services account alias] in the *Amazon Web Services Sign-In User Guide*.

[1]: docs.aws.amazon.com/signin/latest/userguide/CreateAccountAlias.html

Examples:

Example: To create an account alias


# The following command associates the alias examplecorp to your AWS account.

resp = client.({
  account_alias: "examplecorp", 
})

Request syntax with placeholder values


resp = client.({
  account_alias: "accountAliasType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :account_alias (required, String) —

    The account alias to create.

    This parameter allows (through its [regex pattern]) a string of characters consisting of lowercase letters, digits, and dashes. You cannot start or finish with a dash, nor can you have two dashes in a row.

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



970
971
972
973
 
# File 'lib/aws-sdk-iam/client.rb', line 970

def (params = {}, options = {})
  req = build_request(:create_account_alias, params)
  req.send_request(options)
end

#create_group(params = {}) ⇒ Types::CreateGroupResponse

Creates a new group.

For information about the number of groups you can create, see [IAM and STS quotas] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html

Examples:

Example: To create an IAM group


# The following command creates an IAM group named Admins.

resp = client.create_group({
  group_name: "Admins", 
})

resp.to_h outputs the following:
{
  group: {
    arn: "arn:aws:iam::123456789012:group/Admins", 
    create_date: Time.parse("2015-03-09T20:30:24.940Z"), 
    group_id: "AIDGPMS9RO4H3FEXAMPLE", 
    group_name: "Admins", 
    path: "/", 
  }, 
}

Request syntax with placeholder values


resp = client.create_group({
  path: "pathType",
  group_name: "groupNameType", # required
})

Response structure


resp.group.path #=> String
resp.group.group_name #=> String
resp.group.group_id #=> String
resp.group.arn #=> String
resp.group.create_date #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :path (String) —

    The path to the group. For more information about paths, see [IAM identifiers] in the *IAM User Guide*.

    This parameter is optional. If it is not included, it defaults to a slash (/).

    This parameter allows (through its [regex pattern]) a string of characters consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes. In addition, it can contain any ASCII character from the ! (‘u0021`) through the DEL character (`u007F`), including most punctuation characters, digits, and upper and lowercased letters.

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html [2]: wikipedia.org/wiki/regex

  • :group_name (required, String) —

    The name of the group to create. Do not include the path in this value.

    IAM user, group, role, and policy names must be unique within the account. Names are not distinguished by case. For example, you cannot create resources named both “MyResource” and “myresource”.

Returns:

See Also:



1054
1055
1056
1057
 
# File 'lib/aws-sdk-iam/client.rb', line 1054

def create_group(params = {}, options = {})
  req = build_request(:create_group, params)
  req.send_request(options)
end

#create_instance_profile(params = {}) ⇒ Types::CreateInstanceProfileResponse

Creates a new instance profile. For information about instance profiles, see [Using roles for applications on Amazon EC2] in the *IAM User Guide*, and [Instance profiles] in the *Amazon EC2 User Guide*.

For information about the number of instance profiles you can create, see [IAM object quotas] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html [2]: docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#ec2-instance-profile [3]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html

Examples:

Example: To create an instance profile


# The following command creates an instance profile named Webserver that is ready to have a role attached and then be
# associated with an EC2 instance.

resp = client.create_instance_profile({
  instance_profile_name: "Webserver", 
})

resp.to_h outputs the following:
{
  instance_profile: {
    arn: "arn:aws:iam::123456789012:instance-profile/Webserver", 
    create_date: Time.parse("2015-03-09T20:33:19.626Z"), 
    instance_profile_id: "AIPAJMBYC7DLSPEXAMPLE", 
    instance_profile_name: "Webserver", 
    path: "/", 
    roles: [
    ], 
  }, 
}

Request syntax with placeholder values


resp = client.create_instance_profile({
  instance_profile_name: "instanceProfileNameType", # required
  path: "pathType",
  tags: [
    {
      key: "tagKeyType", # required
      value: "tagValueType", # required
    },
  ],
})

Response structure


resp.instance_profile.path #=> String
resp.instance_profile.instance_profile_name #=> String
resp.instance_profile.instance_profile_id #=> String
resp.instance_profile.arn #=> String
resp.instance_profile.create_date #=> Time
resp.instance_profile.roles #=> Array
resp.instance_profile.roles[0].path #=> String
resp.instance_profile.roles[0].role_name #=> String
resp.instance_profile.roles[0].role_id #=> String
resp.instance_profile.roles[0].arn #=> String
resp.instance_profile.roles[0].create_date #=> Time
resp.instance_profile.roles[0].assume_role_policy_document #=> String
resp.instance_profile.roles[0].description #=> String
resp.instance_profile.roles[0].max_session_duration #=> Integer
resp.instance_profile.roles[0].permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.instance_profile.roles[0].permissions_boundary.permissions_boundary_arn #=> String
resp.instance_profile.roles[0].tags #=> Array
resp.instance_profile.roles[0].tags[0].key #=> String
resp.instance_profile.roles[0].tags[0].value #=> String
resp.instance_profile.roles[0].role_last_used.last_used_date #=> Time
resp.instance_profile.roles[0].role_last_used.region #=> String
resp.instance_profile.tags #=> Array
resp.instance_profile.tags[0].key #=> String
resp.instance_profile.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :instance_profile_name (required, String) —

    The name of the instance profile to create.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :path (String) —

    The path to the instance profile. For more information about paths, see [IAM Identifiers] in the *IAM User Guide*.

    This parameter is optional. If it is not included, it defaults to a slash (/).

    This parameter allows (through its [regex pattern]) a string of characters consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes. In addition, it can contain any ASCII character from the ! (‘u0021`) through the DEL character (`u007F`), including most punctuation characters, digits, and upper and lowercased letters.

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html [2]: wikipedia.org/wiki/regex

  • :tags (Array<Types::Tag>) —

    A list of tags that you want to attach to the newly created IAM instance profile. Each tag consists of a key name and an associated value. For more information about tagging, see [Tagging IAM resources] in the *IAM User Guide*.

    <note markdown=“1”> If any one of the tags is invalid or if you exceed the allowed maximum number of tags, then the entire request fails and the resource is not created.

    </note>

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html

Returns:

See Also:



1191
1192
1193
1194
 
# File 'lib/aws-sdk-iam/client.rb', line 1191

def create_instance_profile(params = {}, options = {})
  req = build_request(:create_instance_profile, params)
  req.send_request(options)
end

#create_login_profile(params = {}) ⇒ Types::CreateLoginProfileResponse

Creates a password for the specified IAM user. A password allows an IAM user to access Amazon Web Services services through the Amazon Web Services Management Console.

You can use the CLI, the Amazon Web Services API, or the Users page in the IAM console to create a password for any IAM user. Use ChangePassword to update your own existing password in the **My Security Credentials** page in the Amazon Web Services Management Console.

For more information about managing passwords, see [Managing passwords] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingLogins.html

Examples:

Example: To create an instance profile


# The following command changes IAM user Bob's password and sets the flag that required Bob to change the password the
# next time he signs in.

resp = client.({
  password: "h]6EszR}vJ*m", 
  password_reset_required: true, 
  user_name: "Bob", 
})

resp.to_h outputs the following:
{
  login_profile: {
    create_date: Time.parse("2015-03-10T20:55:40.274Z"), 
    password_reset_required: true, 
    user_name: "Bob", 
  }, 
}

Request syntax with placeholder values


resp = client.({
  user_name: "userNameType", # required
  password: "passwordType", # required
  password_reset_required: false,
})

Response structure


resp..user_name #=> String
resp..create_date #=> Time
resp..password_reset_required #=> Boolean

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name of the IAM user to create a password for. The user must already exist.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :password (required, String) —

    The new password for the user.

    The [regex pattern] that is used to validate this parameter is a string of characters. That string can include almost any printable ASCII character from the space (‘u0020`) through the end of the ASCII character range (`u00FF`). You can also include the tab (`u0009`), line feed (`u000A`), and carriage return (`u000D`) characters. Any of these characters are valid in a password. However, many tools, such as the Amazon Web Services Management Console, might restrict the ability to type certain characters because they have special meaning within that tool.

    [1]: wikipedia.org/wiki/regex

  • :password_reset_required (Boolean) —

    Specifies whether the user is required to set a new password on next sign-in.

Returns:

See Also:



1290
1291
1292
1293
 
# File 'lib/aws-sdk-iam/client.rb', line 1290

def (params = {}, options = {})
  req = build_request(:create_login_profile, params)
  req.send_request(options)
end

#create_open_id_connect_provider(params = {}) ⇒ Types::CreateOpenIDConnectProviderResponse

Creates an IAM entity to describe an identity provider (IdP) that supports [OpenID Connect (OIDC)].

The OIDC provider that you create with this operation can be used as a principal in a role’s trust policy. Such a policy establishes a trust relationship between Amazon Web Services and the OIDC provider.

If you are using an OIDC identity provider from Google, Facebook, or Amazon Cognito, you don’t need to create a separate IAM identity provider. These OIDC identity providers are already built-in to Amazon Web Services and are available for your use. Instead, you can move directly to creating new roles using your identity provider. To learn more, see [Creating a role for web identity or OpenID connect federation] in the *IAM User Guide*.

When you create the IAM OIDC provider, you specify the following:

  • The URL of the OIDC identity provider (IdP) to trust

  • A list of client IDs (also known as audiences) that identify the application or applications allowed to authenticate using the OIDC provider

  • A list of tags that are attached to the specified IAM OIDC provider

  • A list of thumbprints of one or more server certificates that the IdP uses

You get all of this information from the OIDC IdP you want to use to access Amazon Web Services.

<note markdown=“1”> Amazon Web Services secures communication with some OIDC identity providers (IdPs) through our library of trusted root certificate authorities (CAs) instead of using a certificate thumbprint to verify your IdP server certificate. These OIDC IdPs include Auth0, GitHub, Google, and those that use an Amazon S3 bucket to host a JSON Web Key Set (JWKS) endpoint. In these cases, your legacy thumbprint remains in your configuration, but is no longer used for validation.

</note>

<note markdown=“1”> The trust for the OIDC provider is derived from the IAM provider that this operation creates. Therefore, it is best to limit access to the CreateOpenIDConnectProvider operation to highly privileged users.

</note>

[1]: openid.net/connect/ [2]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html

Examples:

Example: To create an instance profile


# The following example defines a new OIDC provider in IAM with a client ID of my-application-id and pointing at the
# server with a URL of https://server.example.com.

resp = client.create_open_id_connect_provider({
  client_id_list: [
    "my-application-id", 
  ], 
  thumbprint_list: [
    "3768084dfb3d2b68b7897bf5f565da8efEXAMPLE", 
  ], 
  url: "https://server.example.com", 
})

resp.to_h outputs the following:
{
  open_id_connect_provider_arn: "arn:aws:iam::123456789012:oidc-provider/server.example.com", 
}

Request syntax with placeholder values


resp = client.create_open_id_connect_provider({
  url: "OpenIDConnectProviderUrlType", # required
  client_id_list: ["clientIDType"],
  thumbprint_list: ["thumbprintType"], # required
  tags: [
    {
      key: "tagKeyType", # required
      value: "tagValueType", # required
    },
  ],
})

Response structure


resp.open_id_connect_provider_arn #=> String
resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :url (required, String) —

    The URL of the identity provider. The URL must begin with ‘https://` and should correspond to the `iss` claim in the provider’s OpenID Connect ID tokens. Per the OIDC standard, path components are allowed but query parameters are not. Typically the URL consists of only a hostname, like ‘server.example.org` or `example.com`. The URL should not contain a port number.

    You cannot register the same provider multiple times in a single Amazon Web Services account. If you try to submit a URL that has already been used for an OpenID Connect provider in the Amazon Web Services account, you will get an error.

  • :client_id_list (Array<String>) —

    Provides a list of client IDs, also known as audiences. When a mobile or web app registers with an OpenID Connect provider, they establish a value that identifies the application. This is the value that’s sent as the ‘client_id` parameter on OAuth requests.

    You can register multiple client IDs with the same provider. For example, you might have multiple applications that use the same OIDC provider. You cannot register more than 100 client IDs with a single IAM OIDC provider.

    There is no defined format for a client ID. The ‘CreateOpenIDConnectProviderRequest` operation accepts client IDs up to 255 characters long.

  • :thumbprint_list (required, Array<String>) —

    A list of server certificate thumbprints for the OpenID Connect (OIDC) identity provider’s server certificates. Typically this list includes only one entry. However, IAM lets you have up to five thumbprints for an OIDC provider. This lets you maintain multiple thumbprints if the identity provider is rotating certificates.

    The server certificate thumbprint is the hex-encoded SHA-1 hash value of the X.509 certificate used by the domain where the OpenID Connect provider makes its keys available. It is always a 40-character string.

    You must provide at least one thumbprint when creating an IAM OIDC provider. For example, assume that the OIDC provider is ‘server.example.com` and the provider stores its keys at keys.server.example.com/openid-connect. In that case, the thumbprint string would be the hex-encoded SHA-1 hash value of the certificate used by `keys.server.example.com.`

    For more information about obtaining the OIDC provider thumbprint, see

    Obtaining the thumbprint for an OpenID Connect provider][1

    in the

    *IAM user Guide*.

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/identity-providers-oidc-obtain-thumbprint.html

  • :tags (Array<Types::Tag>) —

    A list of tags that you want to attach to the new IAM OpenID Connect (OIDC) provider. Each tag consists of a key name and an associated value. For more information about tagging, see [Tagging IAM resources] in the *IAM User Guide*.

    <note markdown=“1”> If any one of the tags is invalid or if you exceed the allowed maximum number of tags, then the entire request fails and the resource is not created.

    </note>

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html

Returns:

See Also:



1468
1469
1470
1471
 
# File 'lib/aws-sdk-iam/client.rb', line 1468

def create_open_id_connect_provider(params = {}, options = {})
  req = build_request(:create_open_id_connect_provider, params)
  req.send_request(options)
end

#create_policy(params = {}) ⇒ Types::CreatePolicyResponse

Creates a new managed policy for your Amazon Web Services account.

This operation creates a policy version with a version identifier of ‘v1` and sets v1 as the policy’s default version. For more information about policy versions, see [Versioning for managed policies] in the *IAM User Guide*.

As a best practice, you can validate your IAM policies. To learn more, see [Validating IAM policies] in the *IAM User Guide*.

For more information about managed policies in general, see [Managed policies and inline policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html [2]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_policy-validator.html [3]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

Examples:

Request syntax with placeholder values


resp = client.create_policy({
  policy_name: "policyNameType", # required
  path: "policyPathType",
  policy_document: "policyDocumentType", # required
  description: "policyDescriptionType",
  tags: [
    {
      key: "tagKeyType", # required
      value: "tagValueType", # required
    },
  ],
})

Response structure


resp.policy.policy_name #=> String
resp.policy.policy_id #=> String
resp.policy.arn #=> String
resp.policy.path #=> String
resp.policy.default_version_id #=> String
resp.policy.attachment_count #=> Integer
resp.policy.permissions_boundary_usage_count #=> Integer
resp.policy.is_attachable #=> Boolean
resp.policy.description #=> String
resp.policy.create_date #=> Time
resp.policy.update_date #=> Time
resp.policy.tags #=> Array
resp.policy.tags[0].key #=> String
resp.policy.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The friendly name of the policy.

    IAM user, group, role, and policy names must be unique within the account. Names are not distinguished by case. For example, you cannot create resources named both “MyResource” and “myresource”.

  • :path (String) —

    The path for the policy.

    For more information about paths, see [IAM identifiers] in the *IAM User Guide*.

    This parameter is optional. If it is not included, it defaults to a slash (/).

    This parameter allows (through its [regex pattern]) a string of characters consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes. In addition, it can contain any ASCII character from the ! (‘u0021`) through the DEL character (`u007F`), including most punctuation characters, digits, and upper and lowercased letters.

    <note markdown=“1”> You cannot use an asterisk (*) in the path name.

    </note>

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html [2]: wikipedia.org/wiki/regex

  • :policy_document (required, String) —

    The JSON policy document that you want to use as the content for the new policy.

    You must provide policies in JSON format in IAM. However, for CloudFormation templates formatted in YAML, you can provide the policy in JSON or YAML format. CloudFormation always converts a YAML policy to JSON format before submitting it to IAM.

    The maximum length of the policy document that you can pass in this operation, including whitespace, is listed below. To view the maximum character counts of a managed policy with no whitespaces, see [IAM and STS character quotas].

    To learn more about JSON policy grammar, see [Grammar of the IAM JSON policy language] in the *IAM User Guide*.

    The [regex pattern] used to validate this parameter is a string of characters consisting of the following:

    • Any printable ASCII character ranging from the space character (‘u0020`) through the end of the ASCII character range

    • The printable characters in the Basic Latin and Latin-1 Supplement character set (through ‘u00FF`)

    • The special characters tab (‘u0009`), line feed (`u000A`), and carriage return (`u000D`)

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html#reference_iam-quotas-entity-length [2]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_grammar.html [3]: wikipedia.org/wiki/regex

  • :description (String) —

    A friendly description of the policy.

    Typically used to store information about the permissions defined in the policy. For example, “Grants access to production DynamoDB tables.”

    The policy description is immutable. After a value is assigned, it cannot be changed.

  • :tags (Array<Types::Tag>) —

    A list of tags that you want to attach to the new IAM customer managed policy. Each tag consists of a key name and an associated value. For more information about tagging, see [Tagging IAM resources] in the *IAM User Guide*.

    <note markdown=“1”> If any one of the tags is invalid or if you exceed the allowed maximum number of tags, then the entire request fails and the resource is not created.

    </note>

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html

Returns:

See Also:



1625
1626
1627
1628
 
# File 'lib/aws-sdk-iam/client.rb', line 1625

def create_policy(params = {}, options = {})
  req = build_request(:create_policy, params)
  req.send_request(options)
end

#create_policy_version(params = {}) ⇒ Types::CreatePolicyVersionResponse

Creates a new version of the specified managed policy. To update a managed policy, you create a new policy version. A managed policy can have up to five versions. If the policy has five versions, you must delete an existing version using DeletePolicyVersion before you create a new version.

Optionally, you can set the new version as the policy’s default version. The default version is the version that is in effect for the IAM users, groups, and roles to which the policy is attached.

For more information about managed policy versions, see [Versioning for managed policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html

Examples:

Request syntax with placeholder values


resp = client.create_policy_version({
  policy_arn: "arnType", # required
  policy_document: "policyDocumentType", # required
  set_as_default: false,
})

Response structure


resp.policy_version.document #=> String
resp.policy_version.version_id #=> String
resp.policy_version.is_default_version #=> Boolean
resp.policy_version.create_date #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the IAM policy to which you want to add a new version.

    For more information about ARNs, see [Amazon Resource Names (ARNs)] in the *Amazon Web Services General Reference*.

    [1]: docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html

  • :policy_document (required, String) —

    The JSON policy document that you want to use as the content for this new version of the policy.

    You must provide policies in JSON format in IAM. However, for CloudFormation templates formatted in YAML, you can provide the policy in JSON or YAML format. CloudFormation always converts a YAML policy to JSON format before submitting it to IAM.

    The maximum length of the policy document that you can pass in this operation, including whitespace, is listed below. To view the maximum character counts of a managed policy with no whitespaces, see [IAM and STS character quotas].

    The [regex pattern] used to validate this parameter is a string of characters consisting of the following:

    • Any printable ASCII character ranging from the space character (‘u0020`) through the end of the ASCII character range

    • The printable characters in the Basic Latin and Latin-1 Supplement character set (through ‘u00FF`)

    • The special characters tab (‘u0009`), line feed (`u000A`), and carriage return (`u000D`)

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html#reference_iam-quotas-entity-length [2]: wikipedia.org/wiki/regex

  • :set_as_default (Boolean) —

    Specifies whether to set this version as the policy’s default version.

    When this parameter is ‘true`, the new policy version becomes the operative version. That is, it becomes the version that is in effect for the IAM users, groups, and roles that the policy is attached to.

    For more information about managed policy versions, see [Versioning for managed policies] in the *IAM User Guide*.

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html

Returns:

See Also:



1727
1728
1729
1730
 
# File 'lib/aws-sdk-iam/client.rb', line 1727

def create_policy_version(params = {}, options = {})
  req = build_request(:create_policy_version, params)
  req.send_request(options)
end

#create_role(params = {}) ⇒ Types::CreateRoleResponse

Creates a new role for your Amazon Web Services account.

For more information about roles, see [IAM roles] in the *IAM User Guide*. For information about quotas for role names and the number of roles you can create, see [IAM and STS quotas] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html [2]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html

Examples:

Example: To create an IAM role


# The following command creates a role named Test-Role and attaches a trust policy that you must convert from JSON to a
# string. Upon success, the response includes the same policy as a URL-encoded JSON string.

resp = client.create_role({
  assume_role_policy_document: "<Stringified-JSON>", 
  path: "/", 
  role_name: "Test-Role", 
})

resp.to_h outputs the following:
{
  role: {
    arn: "arn:aws:iam::123456789012:role/Test-Role", 
    assume_role_policy_document: "<URL-encoded-JSON>", 
    create_date: Time.parse("2013-06-07T20:43:32.821Z"), 
    path: "/", 
    role_id: "AKIAIOSFODNN7EXAMPLE", 
    role_name: "Test-Role", 
  }, 
}

Request syntax with placeholder values


resp = client.create_role({
  path: "pathType",
  role_name: "roleNameType", # required
  assume_role_policy_document: "policyDocumentType", # required
  description: "roleDescriptionType",
  max_session_duration: 1,
  permissions_boundary: "arnType",
  tags: [
    {
      key: "tagKeyType", # required
      value: "tagValueType", # required
    },
  ],
})

Response structure


resp.role.path #=> String
resp.role.role_name #=> String
resp.role.role_id #=> String
resp.role.arn #=> String
resp.role.create_date #=> Time
resp.role.assume_role_policy_document #=> String
resp.role.description #=> String
resp.role.max_session_duration #=> Integer
resp.role.permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.role.permissions_boundary.permissions_boundary_arn #=> String
resp.role.tags #=> Array
resp.role.tags[0].key #=> String
resp.role.tags[0].value #=> String
resp.role.role_last_used.last_used_date #=> Time
resp.role.role_last_used.region #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :path (String) —

    The path to the role. For more information about paths, see [IAM Identifiers] in the *IAM User Guide*.

    This parameter is optional. If it is not included, it defaults to a slash (/).

    This parameter allows (through its [regex pattern]) a string of characters consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes. In addition, it can contain any ASCII character from the ! (‘u0021`) through the DEL character (`u007F`), including most punctuation characters, digits, and upper and lowercased letters.

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html [2]: wikipedia.org/wiki/regex

  • :role_name (required, String) —

    The name of the role to create.

    IAM user, group, role, and policy names must be unique within the account. Names are not distinguished by case. For example, you cannot create resources named both “MyResource” and “myresource”.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :assume_role_policy_document (required, String) —

    The trust relationship policy document that grants an entity permission to assume the role.

    In IAM, you must provide a JSON policy that has been converted to a string. However, for CloudFormation templates formatted in YAML, you can provide the policy in JSON or YAML format. CloudFormation always converts a YAML policy to JSON format before submitting it to IAM.

    The [regex pattern] used to validate this parameter is a string of characters consisting of the following:

    • Any printable ASCII character ranging from the space character (‘u0020`) through the end of the ASCII character range

    • The printable characters in the Basic Latin and Latin-1 Supplement character set (through ‘u00FF`)

    • The special characters tab (‘u0009`), line feed (`u000A`), and carriage return (`u000D`)

    Upon success, the response includes the same trust policy in JSON format.

    [1]: wikipedia.org/wiki/regex

  • :description (String) —

    A description of the role.

  • :max_session_duration (Integer) —

    The maximum session duration (in seconds) that you want to set for the specified role. If you do not specify a value for this setting, the default value of one hour is applied. This setting can have a value from 1 hour to 12 hours.

    Anyone who assumes the role from the CLI or API can use the ‘DurationSeconds` API parameter or the `duration-seconds` CLI parameter to request a longer session. The `MaxSessionDuration` setting determines the maximum duration that can be requested using the `DurationSeconds` parameter. If users don’t specify a value for the ‘DurationSeconds` parameter, their security credentials are valid for one hour by default. This applies when you use the `AssumeRole*` API operations or the `assume-role*` CLI operations but does not apply when you use those operations to create a console URL. For more information, see [Using IAM roles] in the *IAM User Guide*.

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html

  • :permissions_boundary (String) —

    The ARN of the managed policy that is used to set the permissions boundary for the role.

    A permissions boundary policy defines the maximum permissions that identity-based policies can grant to an entity, but does not grant permissions. Permissions boundaries do not define the maximum permissions that a resource-based policy can grant to an entity. To learn more, see [Permissions boundaries for IAM entities] in the *IAM User Guide*.

    For more information about policy types, see [Policy types ][2] in the *IAM User Guide*.

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html [2]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policy-types

  • :tags (Array<Types::Tag>) —

    A list of tags that you want to attach to the new role. Each tag consists of a key name and an associated value. For more information about tagging, see [Tagging IAM resources] in the *IAM User Guide*.

    <note markdown=“1”> If any one of the tags is invalid or if you exceed the allowed maximum number of tags, then the entire request fails and the resource is not created.

    </note>

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html

Returns:

See Also:



1932
1933
1934
1935
 
# File 'lib/aws-sdk-iam/client.rb', line 1932

def create_role(params = {}, options = {})
  req = build_request(:create_role, params)
  req.send_request(options)
end

#create_saml_provider(params = {}) ⇒ Types::CreateSAMLProviderResponse

Creates an IAM resource that describes an identity provider (IdP) that supports SAML 2.0.

The SAML provider resource that you create with this operation can be used as a principal in an IAM role’s trust policy. Such a policy can enable federated users who sign in using the SAML IdP to assume the role. You can create an IAM role that supports Web-based single sign-on (SSO) to the Amazon Web Services Management Console or one that supports API access to Amazon Web Services.

When you create the SAML provider resource, you upload a SAML metadata document that you get from your IdP. That document includes the issuer’s name, expiration information, and keys that can be used to validate the SAML authentication response (assertions) that the IdP sends. You must generate the metadata document using the identity management software that is used as your organization’s IdP.

<note markdown=“1”> This operation requires [Signature Version 4].

</note>

For more information, see [Enabling SAML 2.0 federated users to access the Amazon Web Services Management Console] and [About SAML 2.0-based federation] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/general/latest/gr/signature-version-4.html [2]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-saml.html [3]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html

Examples:

Request syntax with placeholder values


resp = client.create_saml_provider({
  saml_metadata_document: "SAMLMetadataDocumentType", # required
  name: "SAMLProviderNameType", # required
  tags: [
    {
      key: "tagKeyType", # required
      value: "tagValueType", # required
    },
  ],
})

Response structure


resp.saml_provider_arn #=> String
resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :saml_metadata_document (required, String) —

    An XML document generated by an identity provider (IdP) that supports SAML 2.0. The document includes the issuer’s name, expiration information, and keys that can be used to validate the SAML authentication response (assertions) that are received from the IdP. You must generate the metadata document using the identity management software that is used as your organization’s IdP.

    For more information, see [About SAML 2.0-based federation] in the *IAM User Guide*

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html

  • :name (required, String) —

    The name of the provider to create.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :tags (Array<Types::Tag>) —

    A list of tags that you want to attach to the new IAM SAML provider. Each tag consists of a key name and an associated value. For more information about tagging, see [Tagging IAM resources] in the *IAM User Guide*.

    <note markdown=“1”> If any one of the tags is invalid or if you exceed the allowed maximum number of tags, then the entire request fails and the resource is not created.

    </note>

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html

Returns:

See Also:



2040
2041
2042
2043
 
# File 'lib/aws-sdk-iam/client.rb', line 2040

def create_saml_provider(params = {}, options = {})
  req = build_request(:create_saml_provider, params)
  req.send_request(options)
end

#create_service_linked_role(params = {}) ⇒ Types::CreateServiceLinkedRoleResponse

Creates an IAM role that is linked to a specific Amazon Web Services service. The service controls the attached policies and when the role can be deleted. This helps ensure that the service is not broken by an unexpectedly changed or deleted role, which could put your Amazon Web Services resources into an unknown state. Allowing the service to control the role helps improve service stability and proper cleanup when a service and its role are no longer needed. For more information, see [Using service-linked roles] in the *IAM User Guide*.

To attach a policy to this service-linked role, you must make the request using the Amazon Web Services service that depends on this role.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html

Examples:

Request syntax with placeholder values


resp = client.create_service_linked_role({
  aws_service_name: "groupNameType", # required
  description: "roleDescriptionType",
  custom_suffix: "customSuffixType",
})

Response structure


resp.role.path #=> String
resp.role.role_name #=> String
resp.role.role_id #=> String
resp.role.arn #=> String
resp.role.create_date #=> Time
resp.role.assume_role_policy_document #=> String
resp.role.description #=> String
resp.role.max_session_duration #=> Integer
resp.role.permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.role.permissions_boundary.permissions_boundary_arn #=> String
resp.role.tags #=> Array
resp.role.tags[0].key #=> String
resp.role.tags[0].value #=> String
resp.role.role_last_used.last_used_date #=> Time
resp.role.role_last_used.region #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :aws_service_name (required, String) —

    The service principal for the Amazon Web Services service to which this role is attached. You use a string similar to a URL but without the http:// in front. For example: ‘elasticbeanstalk.amazonaws.com`.

    Service principals are unique and case-sensitive. To find the exact service principal for your service-linked role, see [Amazon Web Services services that work with IAM] in the *IAM User Guide*. Look for the services that have Yes in the **Service-Linked Role** column. Choose the Yes link to view the service-linked role documentation for that service.

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html

  • :description (String) —

    The description of the role.

  • :custom_suffix (String) —

    A string that you provide, which is combined with the service-provided prefix to form the complete role name. If you make multiple requests for the same service, then you must supply a different ‘CustomSuffix` for each request. Otherwise the request fails with a duplicate role name error. For example, you could add `-1` or `-debug` to the suffix.

    Some services do not support the ‘CustomSuffix` parameter. If you provide an optional suffix and the operation fails, try the operation again without the suffix.

Returns:

See Also:



2127
2128
2129
2130
 
# File 'lib/aws-sdk-iam/client.rb', line 2127

def create_service_linked_role(params = {}, options = {})
  req = build_request(:create_service_linked_role, params)
  req.send_request(options)
end

#create_service_specific_credential(params = {}) ⇒ Types::CreateServiceSpecificCredentialResponse

Generates a set of credentials consisting of a user name and password that can be used to access the service specified in the request. These credentials are generated by IAM, and can be used only for the specified service.

You can have a maximum of two sets of service-specific credentials for each supported service per user.

You can create service-specific credentials for CodeCommit and Amazon Keyspaces (for Apache Cassandra).

You can reset the password to a new service-generated value by calling ResetServiceSpecificCredential.

For more information about service-specific credentials, see [Using IAM with CodeCommit: Git credentials, SSH keys, and Amazon Web Services access keys] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_ssh-keys.html

Examples:

Request syntax with placeholder values


resp = client.create_service_specific_credential({
  user_name: "userNameType", # required
  service_name: "serviceName", # required
})

Response structure


resp.service_specific_credential.create_date #=> Time
resp.service_specific_credential.service_name #=> String
resp.service_specific_credential.service_user_name #=> String
resp.service_specific_credential.service_password #=> String
resp.service_specific_credential.service_specific_credential_id #=> String
resp.service_specific_credential.user_name #=> String
resp.service_specific_credential.status #=> String, one of "Active", "Inactive"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name of the IAM user that is to be associated with the credentials. The new service-specific credentials have the same permissions as the associated user except that they can be used only to access the specified service.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :service_name (required, String) —

    The name of the Amazon Web Services service that is to be associated with the credentials. The service you specify here is the only service that can be accessed using these credentials.

Returns:

See Also:



2199
2200
2201
2202
 
# File 'lib/aws-sdk-iam/client.rb', line 2199

def create_service_specific_credential(params = {}, options = {})
  req = build_request(:create_service_specific_credential, params)
  req.send_request(options)
end

#create_user(params = {}) ⇒ Types::CreateUserResponse

Creates a new IAM user for your Amazon Web Services account.

For information about quotas for the number of IAM users you can create, see [IAM and STS quotas] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html

Examples:

Example: To create an IAM user


# The following create-user command creates an IAM user named Bob in the current account.

resp = client.create_user({
  user_name: "Bob", 
})

resp.to_h outputs the following:
{
  user: {
    arn: "arn:aws:iam::123456789012:user/Bob", 
    create_date: Time.parse("2013-06-08T03:20:41.270Z"), 
    path: "/", 
    user_id: "AKIAIOSFODNN7EXAMPLE", 
    user_name: "Bob", 
  }, 
}

Request syntax with placeholder values


resp = client.create_user({
  path: "pathType",
  user_name: "userNameType", # required
  permissions_boundary: "arnType",
  tags: [
    {
      key: "tagKeyType", # required
      value: "tagValueType", # required
    },
  ],
})

Response structure


resp.user.path #=> String
resp.user.user_name #=> String
resp.user.user_id #=> String
resp.user.arn #=> String
resp.user.create_date #=> Time
resp.user.password_last_used #=> Time
resp.user.permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.user.permissions_boundary.permissions_boundary_arn #=> String
resp.user.tags #=> Array
resp.user.tags[0].key #=> String
resp.user.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :path (String) —

    The path for the user name. For more information about paths, see [IAM identifiers] in the *IAM User Guide*.

    This parameter is optional. If it is not included, it defaults to a slash (/).

    This parameter allows (through its [regex pattern]) a string of characters consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes. In addition, it can contain any ASCII character from the ! (‘u0021`) through the DEL character (`u007F`), including most punctuation characters, digits, and upper and lowercased letters.

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html [2]: wikipedia.org/wiki/regex

  • :user_name (required, String) —

    The name of the user to create.

    IAM user, group, role, and policy names must be unique within the account. Names are not distinguished by case. For example, you cannot create resources named both “MyResource” and “myresource”.

  • :permissions_boundary (String) —

    The ARN of the managed policy that is used to set the permissions boundary for the user.

    A permissions boundary policy defines the maximum permissions that identity-based policies can grant to an entity, but does not grant permissions. Permissions boundaries do not define the maximum permissions that a resource-based policy can grant to an entity. To learn more, see [Permissions boundaries for IAM entities] in the *IAM User Guide*.

    For more information about policy types, see [Policy types ][2] in the *IAM User Guide*.

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html [2]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policy-types

  • :tags (Array<Types::Tag>) —

    A list of tags that you want to attach to the new user. Each tag consists of a key name and an associated value. For more information about tagging, see [Tagging IAM resources] in the *IAM User Guide*.

    <note markdown=“1”> If any one of the tags is invalid or if you exceed the allowed maximum number of tags, then the entire request fails and the resource is not created.

    </note>

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html

Returns:

See Also:



2329
2330
2331
2332
 
# File 'lib/aws-sdk-iam/client.rb', line 2329

def create_user(params = {}, options = {})
  req = build_request(:create_user, params)
  req.send_request(options)
end

#create_virtual_mfa_device(params = {}) ⇒ Types::CreateVirtualMFADeviceResponse

Creates a new virtual MFA device for the Amazon Web Services account. After creating the virtual MFA, use EnableMFADevice to attach the MFA device to an IAM user. For more information about creating and working with virtual MFA devices, see [Using a virtual MFA device] in the *IAM User Guide*.

For information about the maximum number of MFA devices you can create, see [IAM and STS quotas] in the *IAM User Guide*.

The seed information contained in the QR code and the Base32 string should be treated like any other secret access information. In other words, protect the seed information as you would your Amazon Web Services access keys or your passwords. After you provision your virtual device, you should ensure that the information is destroyed following secure procedures.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/Using_VirtualMFA.html [2]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html

Examples:

Request syntax with placeholder values


resp = client.create_virtual_mfa_device({
  path: "pathType",
  virtual_mfa_device_name: "virtualMFADeviceName", # required
  tags: [
    {
      key: "tagKeyType", # required
      value: "tagValueType", # required
    },
  ],
})

Response structure


resp.virtual_mfa_device.serial_number #=> String
resp.virtual_mfa_device.base_32_string_seed #=> String
resp.virtual_mfa_device.qr_code_png #=> String
resp.virtual_mfa_device.user.path #=> String
resp.virtual_mfa_device.user.user_name #=> String
resp.virtual_mfa_device.user.user_id #=> String
resp.virtual_mfa_device.user.arn #=> String
resp.virtual_mfa_device.user.create_date #=> Time
resp.virtual_mfa_device.user.password_last_used #=> Time
resp.virtual_mfa_device.user.permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.virtual_mfa_device.user.permissions_boundary.permissions_boundary_arn #=> String
resp.virtual_mfa_device.user.tags #=> Array
resp.virtual_mfa_device.user.tags[0].key #=> String
resp.virtual_mfa_device.user.tags[0].value #=> String
resp.virtual_mfa_device.enable_date #=> Time
resp.virtual_mfa_device.tags #=> Array
resp.virtual_mfa_device.tags[0].key #=> String
resp.virtual_mfa_device.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :path (String) —

    The path for the virtual MFA device. For more information about paths, see [IAM identifiers] in the *IAM User Guide*.

    This parameter is optional. If it is not included, it defaults to a slash (/).

    This parameter allows (through its [regex pattern]) a string of characters consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes. In addition, it can contain any ASCII character from the ! (‘u0021`) through the DEL character (`u007F`), including most punctuation characters, digits, and upper and lowercased letters.

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html [2]: wikipedia.org/wiki/regex

  • :virtual_mfa_device_name (required, String) —

    The name of the virtual MFA device, which must be unique. Use with path to uniquely identify a virtual MFA device.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :tags (Array<Types::Tag>) —

    A list of tags that you want to attach to the new IAM virtual MFA device. Each tag consists of a key name and an associated value. For more information about tagging, see [Tagging IAM resources] in the *IAM User Guide*.

    <note markdown=“1”> If any one of the tags is invalid or if you exceed the allowed maximum number of tags, then the entire request fails and the resource is not created.

    </note>

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html

Returns:

See Also:



2445
2446
2447
2448
 
# File 'lib/aws-sdk-iam/client.rb', line 2445

def create_virtual_mfa_device(params = {}, options = {})
  req = build_request(:create_virtual_mfa_device, params)
  req.send_request(options)
end

#deactivate_mfa_device(params = {}) ⇒ Struct

Deactivates the specified MFA device and removes it from association with the user name for which it was originally enabled.

For more information about creating and working with virtual MFA devices, see [Enabling a virtual multi-factor authentication (MFA) device] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/Using_VirtualMFA.html

Examples:

Request syntax with placeholder values


resp = client.deactivate_mfa_device({
  user_name: "existingUserNameType", # required
  serial_number: "serialNumberType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name of the user whose MFA device you want to deactivate.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :serial_number (required, String) —

    The serial number that uniquely identifies the MFA device. For virtual MFA devices, the serial number is the device ARN.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters:

    ,.@:/-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2499
2500
2501
2502
 
# File 'lib/aws-sdk-iam/client.rb', line 2499

def deactivate_mfa_device(params = {}, options = {})
  req = build_request(:deactivate_mfa_device, params)
  req.send_request(options)
end

#delete_access_key(params = {}) ⇒ Struct

Deletes the access key pair associated with the specified IAM user.

If you do not specify a user name, IAM determines the user name implicitly based on the Amazon Web Services access key ID signing the request. This operation works for access keys under the Amazon Web Services account. Consequently, you can use this operation to manage Amazon Web Services account root user credentials even if the Amazon Web Services account has no associated users.

Examples:

Example: To delete an access key for an IAM user


# The following command deletes one access key (access key ID and secret access key) assigned to the IAM user named Bob.

resp = client.delete_access_key({
  access_key_id: "AKIDPMS9RO4H3FEXAMPLE", 
  user_name: "Bob", 
})

Request syntax with placeholder values


resp = client.delete_access_key({
  user_name: "existingUserNameType",
  access_key_id: "accessKeyIdType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (String) —

    The name of the user whose access key pair you want to delete.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :access_key_id (required, String) —

    The access key ID for the access key ID and secret access key you want to delete.

    This parameter allows (through its [regex pattern]) a string of characters that can consist of any upper or lowercased letter or digit.

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2560
2561
2562
2563
 
# File 'lib/aws-sdk-iam/client.rb', line 2560

def delete_access_key(params = {}, options = {})
  req = build_request(:delete_access_key, params)
  req.send_request(options)
end

#delete_account_alias(params = {}) ⇒ Struct

Deletes the specified Amazon Web Services account alias. For information about using an Amazon Web Services account alias, see [Creating, deleting, and listing an Amazon Web Services account alias] in the *Amazon Web Services Sign-In User Guide*.

[1]: docs.aws.amazon.com/signin/latest/userguide/CreateAccountAlias.html

Examples:

Example: To delete an account alias


# The following command removes the alias mycompany from the current AWS account:

resp = client.({
  account_alias: "mycompany", 
})

Request syntax with placeholder values


resp = client.({
  account_alias: "accountAliasType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :account_alias (required, String) —

    The name of the account alias to delete.

    This parameter allows (through its [regex pattern]) a string of characters consisting of lowercase letters, digits, and dashes. You cannot start or finish with a dash, nor can you have two dashes in a row.

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2607
2608
2609
2610
 
# File 'lib/aws-sdk-iam/client.rb', line 2607

def (params = {}, options = {})
  req = build_request(:delete_account_alias, params)
  req.send_request(options)
end

#delete_account_password_policy(params = {}) ⇒ Struct

Deletes the password policy for the Amazon Web Services account. There are no parameters.

Examples:

Example: To delete the current account password policy


# The following command removes the password policy from the current AWS account:

resp = client.({
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2629
2630
2631
2632
 
# File 'lib/aws-sdk-iam/client.rb', line 2629

def (params = {}, options = {})
  req = build_request(:delete_account_password_policy, params)
  req.send_request(options)
end

#delete_group(params = {}) ⇒ Struct

Deletes the specified IAM group. The group must not contain any users or have any attached policies.

Examples:

Request syntax with placeholder values


resp = client.delete_group({
  group_name: "groupNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :group_name (required, String) —

    The name of the IAM group to delete.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2661
2662
2663
2664
 
# File 'lib/aws-sdk-iam/client.rb', line 2661

def delete_group(params = {}, options = {})
  req = build_request(:delete_group, params)
  req.send_request(options)
end

#delete_group_policy(params = {}) ⇒ Struct

Deletes the specified inline policy that is embedded in the specified IAM group.

A group can also have managed policies attached to it. To detach a managed policy from a group, use DetachGroupPolicy. For more information about policies, refer to [Managed policies and inline policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

Examples:

Example: To delete a policy from an IAM group


# The following command deletes the policy named ExamplePolicy from the group named Admins:

resp = client.delete_group_policy({
  group_name: "Admins", 
  policy_name: "ExamplePolicy", 
})

Request syntax with placeholder values


resp = client.delete_group_policy({
  group_name: "groupNameType", # required
  policy_name: "policyNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :group_name (required, String) —

    The name (friendly name, not ARN) identifying the group that the policy is embedded in.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :policy_name (required, String) —

    The name identifying the policy document to delete.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2726
2727
2728
2729
 
# File 'lib/aws-sdk-iam/client.rb', line 2726

def delete_group_policy(params = {}, options = {})
  req = build_request(:delete_group_policy, params)
  req.send_request(options)
end

#delete_instance_profile(params = {}) ⇒ Struct

Deletes the specified instance profile. The instance profile must not have an associated role.

Make sure that you do not have any Amazon EC2 instances running with the instance profile you are about to delete. Deleting a role or instance profile that is associated with a running instance will break any applications running on the instance.

For more information about instance profiles, see [Using instance profiles] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html

Examples:

Example: To delete an instance profile


# The following command deletes the instance profile named ExampleInstanceProfile

resp = client.delete_instance_profile({
  instance_profile_name: "ExampleInstanceProfile", 
})

Request syntax with placeholder values


resp = client.delete_instance_profile({
  instance_profile_name: "instanceProfileNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :instance_profile_name (required, String) —

    The name of the instance profile to delete.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2779
2780
2781
2782
 
# File 'lib/aws-sdk-iam/client.rb', line 2779

def delete_instance_profile(params = {}, options = {})
  req = build_request(:delete_instance_profile, params)
  req.send_request(options)
end

#delete_login_profile(params = {}) ⇒ Struct

Deletes the password for the specified IAM user, For more information, see [Managing passwords for IAM users].

You can use the CLI, the Amazon Web Services API, or the Users page in the IAM console to delete a password for any IAM user. You can use ChangePassword to update, but not delete, your own password in the **My Security Credentials** page in the Amazon Web Services Management Console.

Deleting a user’s password does not prevent a user from accessing Amazon Web Services through the command line interface or the API. To prevent all user access, you must also either make any access keys inactive or delete them. For more information about making keys inactive or deleting them, see UpdateAccessKey and DeleteAccessKey.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_passwords_admin-change-user.html

Examples:

Example: To delete a password for an IAM user


# The following command deletes the password for the IAM user named Bob.

resp = client.({
  user_name: "Bob", 
})

Request syntax with placeholder values


resp = client.({
  user_name: "userNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name of the user whose password you want to delete.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2836
2837
2838
2839
 
# File 'lib/aws-sdk-iam/client.rb', line 2836

def (params = {}, options = {})
  req = build_request(:delete_login_profile, params)
  req.send_request(options)
end

#delete_open_id_connect_provider(params = {}) ⇒ Struct

Deletes an OpenID Connect identity provider (IdP) resource object in IAM.

Deleting an IAM OIDC provider resource does not update any roles that reference the provider as a principal in their trust policies. Any attempt to assume a role that references a deleted provider fails.

This operation is idempotent; it does not fail or return an error if you call the operation for a provider that does not exist.

Examples:

Request syntax with placeholder values


resp = client.delete_open_id_connect_provider({
  open_id_connect_provider_arn: "arnType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :open_id_connect_provider_arn (required, String) —

    The Amazon Resource Name (ARN) of the IAM OpenID Connect provider resource object to delete. You can get a list of OpenID Connect provider resource ARNs by using the ListOpenIDConnectProviders operation.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2869
2870
2871
2872
 
# File 'lib/aws-sdk-iam/client.rb', line 2869

def delete_open_id_connect_provider(params = {}, options = {})
  req = build_request(:delete_open_id_connect_provider, params)
  req.send_request(options)
end

#delete_policy(params = {}) ⇒ Struct

Deletes the specified managed policy.

Before you can delete a managed policy, you must first detach the policy from all users, groups, and roles that it is attached to. In addition, you must delete all the policy’s versions. The following steps describe the process for deleting a managed policy:

  • Detach the policy from all users, groups, and roles that the policy is attached to, using DetachUserPolicy, DetachGroupPolicy, or DetachRolePolicy. To list all the users, groups, and roles that a policy is attached to, use ListEntitiesForPolicy.

  • Delete all versions of the policy using DeletePolicyVersion. To list the policy’s versions, use ListPolicyVersions. You cannot use DeletePolicyVersion to delete the version that is marked as the default version. You delete the policy’s default version in the next step of the process.

  • Delete the policy (this automatically deletes the policy’s default version) using this operation.

For information about managed policies, see [Managed policies and inline policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

Examples:

Request syntax with placeholder values


resp = client.delete_policy({
  policy_arn: "arnType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2924
2925
2926
2927
 
# File 'lib/aws-sdk-iam/client.rb', line 2924

def delete_policy(params = {}, options = {})
  req = build_request(:delete_policy, params)
  req.send_request(options)
end

#delete_policy_version(params = {}) ⇒ Struct

Deletes the specified version from the specified managed policy.

You cannot delete the default version from a policy using this operation. To delete the default version from a policy, use DeletePolicy. To find out which version of a policy is marked as the default version, use ListPolicyVersions.

For information about versions for managed policies, see [Versioning for managed policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html

Examples:

Request syntax with placeholder values


resp = client.delete_policy_version({
  policy_arn: "arnType", # required
  version_id: "policyVersionIdType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2983
2984
2985
2986
 
# File 'lib/aws-sdk-iam/client.rb', line 2983

def delete_policy_version(params = {}, options = {})
  req = build_request(:delete_policy_version, params)
  req.send_request(options)
end

#delete_role(params = {}) ⇒ Struct

Deletes the specified role. Unlike the Amazon Web Services Management Console, when you delete a role programmatically, you must delete the items attached to the role manually, or the deletion fails. For more information, see [Deleting an IAM role]. Before attempting to delete a role, remove the following attached items:

  • Inline policies (DeleteRolePolicy)

  • Attached managed policies (DetachRolePolicy)

  • Instance profile (RemoveRoleFromInstanceProfile)

  • Optional – Delete instance profile after detaching from role for resource clean up (DeleteInstanceProfile)

Make sure that you do not have any Amazon EC2 instances running with the role you are about to delete. Deleting a role or instance profile that is associated with a running instance will break any applications running on the instance.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html#roles-managingrole-deleting-cli

Examples:

Example: To delete an IAM role


# The following command removes the role named Test-Role.

resp = client.delete_role({
  role_name: "Test-Role", 
})

Request syntax with placeholder values


resp = client.delete_role({
  role_name: "roleNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :role_name (required, String) —

    The name of the role to delete.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3045
3046
3047
3048
 
# File 'lib/aws-sdk-iam/client.rb', line 3045

def delete_role(params = {}, options = {})
  req = build_request(:delete_role, params)
  req.send_request(options)
end

#delete_role_permissions_boundary(params = {}) ⇒ Struct

Deletes the permissions boundary for the specified IAM role.

You cannot set the boundary for a service-linked role.

Deleting the permissions boundary for a role might increase its permissions. For example, it might allow anyone who assumes the role to perform all the actions granted in its permissions policies.

Examples:

Request syntax with placeholder values


resp = client.delete_role_permissions_boundary({
  role_name: "roleNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :role_name (required, String) —

    The name (friendly name, not ARN) of the IAM role from which you want to remove the permissions boundary.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3074
3075
3076
3077
 
# File 'lib/aws-sdk-iam/client.rb', line 3074

def delete_role_permissions_boundary(params = {}, options = {})
  req = build_request(:delete_role_permissions_boundary, params)
  req.send_request(options)
end

#delete_role_policy(params = {}) ⇒ Struct

Deletes the specified inline policy that is embedded in the specified IAM role.

A role can also have managed policies attached to it. To detach a managed policy from a role, use DetachRolePolicy. For more information about policies, refer to [Managed policies and inline policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

Examples:

Example: To remove a policy from an IAM role


# The following command removes the policy named ExamplePolicy from the role named Test-Role.

resp = client.delete_role_policy({
  policy_name: "ExamplePolicy", 
  role_name: "Test-Role", 
})

Request syntax with placeholder values


resp = client.delete_role_policy({
  role_name: "roleNameType", # required
  policy_name: "policyNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :role_name (required, String) —

    The name (friendly name, not ARN) identifying the role that the policy is embedded in.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :policy_name (required, String) —

    The name of the inline policy to delete from the specified IAM role.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3139
3140
3141
3142
 
# File 'lib/aws-sdk-iam/client.rb', line 3139

def delete_role_policy(params = {}, options = {})
  req = build_request(:delete_role_policy, params)
  req.send_request(options)
end

#delete_saml_provider(params = {}) ⇒ Struct

Deletes a SAML provider resource in IAM.

Deleting the provider resource from IAM does not update any roles that reference the SAML provider resource’s ARN as a principal in their trust policies. Any attempt to assume a role that references a non-existent provider resource ARN fails.

<note markdown=“1”> This operation requires [Signature Version 4].

</note>

[1]: docs.aws.amazon.com/general/latest/gr/signature-version-4.html

Examples:

Request syntax with placeholder values


resp = client.delete_saml_provider({
  saml_provider_arn: "arnType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :saml_provider_arn (required, String) —

    The Amazon Resource Name (ARN) of the SAML provider to delete.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3174
3175
3176
3177
 
# File 'lib/aws-sdk-iam/client.rb', line 3174

def delete_saml_provider(params = {}, options = {})
  req = build_request(:delete_saml_provider, params)
  req.send_request(options)
end

#delete_server_certificate(params = {}) ⇒ Struct

Deletes the specified server certificate.

For more information about working with server certificates, see

Working with server certificates][1

in the *IAM User Guide*. This

topic also includes a list of Amazon Web Services services that can use the server certificates that you manage with IAM.

If you are using a server certificate with Elastic Load Balancing, deleting the certificate could have implications for your application. If Elastic Load Balancing doesn’t detect the deletion of bound certificates, it may continue to use the certificates. This could cause Elastic Load Balancing to stop accepting traffic. We recommend that you remove the reference to the certificate from Elastic Load Balancing before using this command to delete the certificate. For more information, see [DeleteLoadBalancerListeners] in the *Elastic Load Balancing API Reference*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html [2]: docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_DeleteLoadBalancerListeners.html

Examples:

Request syntax with placeholder values


resp = client.delete_server_certificate({
  server_certificate_name: "serverCertificateNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :server_certificate_name (required, String) —

    The name of the server certificate you want to delete.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3278
3279
3280
3281
 
# File 'lib/aws-sdk-iam/client.rb', line 3278

def delete_server_certificate(params = {}, options = {})
  req = build_request(:delete_server_certificate, params)
  req.send_request(options)
end

#delete_service_linked_role(params = {}) ⇒ Types::DeleteServiceLinkedRoleResponse

Submits a service-linked role deletion request and returns a ‘DeletionTaskId`, which you can use to check the status of the deletion. Before you call this operation, confirm that the role has no active sessions and that any resources used by the role in the linked service are deleted. If you call this operation more than once for the same service-linked role and an earlier deletion task is not complete, then the `DeletionTaskId` of the earlier request is returned.

If you submit a deletion request for a service-linked role whose linked service is still accessing a resource, then the deletion task fails. If it fails, the GetServiceLinkedRoleDeletionStatus operation returns the reason for the failure, usually including the resources that must be deleted. To delete the service-linked role, you must first remove those resources from the linked service and then submit the deletion request again. Resources are specific to the service that is linked to the role. For more information about removing resources from a service, see the [Amazon Web Services documentation] for your service.

For more information about service-linked roles, see [Roles terms and concepts: Amazon Web Services service-linked role] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/ [2]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role

Examples:

Request syntax with placeholder values


resp = client.delete_service_linked_role({
  role_name: "roleNameType", # required
})

Response structure


resp.deletion_task_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :role_name (required, String) —

    The name of the service-linked role to be deleted.

Returns:

See Also:



3332
3333
3334
3335
 
# File 'lib/aws-sdk-iam/client.rb', line 3332

def delete_service_linked_role(params = {}, options = {})
  req = build_request(:delete_service_linked_role, params)
  req.send_request(options)
end

#delete_service_specific_credential(params = {}) ⇒ Struct

Deletes the specified service-specific credential.

Examples:

Request syntax with placeholder values


resp = client.delete_service_specific_credential({
  user_name: "userNameType",
  service_specific_credential_id: "serviceSpecificCredentialId", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (String) —

    The name of the IAM user associated with the service-specific credential. If this value is not specified, then the operation assumes the user whose credentials are used to call the operation.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :service_specific_credential_id (required, String) —

    The unique identifier of the service-specific credential. You can get this value by calling ListServiceSpecificCredentials.

    This parameter allows (through its [regex pattern]) a string of characters that can consist of any upper or lowercased letter or digit.

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3378
3379
3380
3381
 
# File 'lib/aws-sdk-iam/client.rb', line 3378

def delete_service_specific_credential(params = {}, options = {})
  req = build_request(:delete_service_specific_credential, params)
  req.send_request(options)
end

#delete_signing_certificate(params = {}) ⇒ Struct

Deletes a signing certificate associated with the specified IAM user.

If you do not specify a user name, IAM determines the user name implicitly based on the Amazon Web Services access key ID signing the request. This operation works for access keys under the Amazon Web Services account. Consequently, you can use this operation to manage Amazon Web Services account root user credentials even if the Amazon Web Services account has no associated IAM users.

Examples:

Example: To delete a signing certificate for an IAM user


# The following command deletes the specified signing certificate for the IAM user named Anika.

resp = client.delete_signing_certificate({
  certificate_id: "TA7SMP42TDN5Z26OBPJE7EXAMPLE", 
  user_name: "Anika", 
})

Request syntax with placeholder values


resp = client.delete_signing_certificate({
  user_name: "existingUserNameType",
  certificate_id: "certificateIdType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (String) —

    The name of the user the signing certificate belongs to.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :certificate_id (required, String) —

    The ID of the signing certificate to delete.

    The format of this parameter, as described by its [regex] pattern, is a string of characters that can be upper- or lower-cased letters or digits.

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3438
3439
3440
3441
 
# File 'lib/aws-sdk-iam/client.rb', line 3438

def delete_signing_certificate(params = {}, options = {})
  req = build_request(:delete_signing_certificate, params)
  req.send_request(options)
end

#delete_ssh_public_key(params = {}) ⇒ Struct

Deletes the specified SSH public key.

The SSH public key deleted by this operation is used only for authenticating the associated IAM user to an CodeCommit repository. For more information about using SSH keys to authenticate to an CodeCommit repository, see [Set up CodeCommit for SSH connections] in the *CodeCommit User Guide*.

[1]: docs.aws.amazon.com/codecommit/latest/userguide/setting-up-credentials-ssh.html

Examples:

Request syntax with placeholder values


resp = client.delete_ssh_public_key({
  user_name: "userNameType", # required
  ssh_public_key_id: "publicKeyIdType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name of the IAM user associated with the SSH public key.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :ssh_public_key_id (required, String) —

    The unique identifier for the SSH public key.

    This parameter allows (through its [regex pattern]) a string of characters that can consist of any upper or lowercased letter or digit.

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3227
3228
3229
3230
 
# File 'lib/aws-sdk-iam/client.rb', line 3227

def delete_ssh_public_key(params = {}, options = {})
  req = build_request(:delete_ssh_public_key, params)
  req.send_request(options)
end

#delete_user(params = {}) ⇒ Struct

Deletes the specified IAM user. Unlike the Amazon Web Services Management Console, when you delete a user programmatically, you must delete the items attached to the user manually, or the deletion fails. For more information, see [Deleting an IAM user]. Before attempting to delete a user, remove the following items:

  • Password (DeleteLoginProfile)

  • Access keys (DeleteAccessKey)

  • Signing certificate (DeleteSigningCertificate)

  • SSH public key (DeleteSSHPublicKey)

  • Git credentials (DeleteServiceSpecificCredential)

  • Multi-factor authentication (MFA) device (DeactivateMFADevice, DeleteVirtualMFADevice)

  • Inline policies (DeleteUserPolicy)

  • Attached managed policies (DetachUserPolicy)

  • Group memberships (RemoveUserFromGroup)

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_users_manage.html#id_users_deleting_cli

Examples:

Example: To delete an IAM user


# The following command removes the IAM user named Bob from the current account.

resp = client.delete_user({
  user_name: "Bob", 
})

Request syntax with placeholder values


resp = client.delete_user({
  user_name: "existingUserNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name of the user to delete.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3505
3506
3507
3508
 
# File 'lib/aws-sdk-iam/client.rb', line 3505

def delete_user(params = {}, options = {})
  req = build_request(:delete_user, params)
  req.send_request(options)
end

#delete_user_permissions_boundary(params = {}) ⇒ Struct

Deletes the permissions boundary for the specified IAM user.

Deleting the permissions boundary for a user might increase its permissions by allowing the user to perform all the actions granted in its permissions policies.

Examples:

Request syntax with placeholder values


resp = client.delete_user_permissions_boundary({
  user_name: "userNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name (friendly name, not ARN) of the IAM user from which you want to remove the permissions boundary.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3532
3533
3534
3535
 
# File 'lib/aws-sdk-iam/client.rb', line 3532

def delete_user_permissions_boundary(params = {}, options = {})
  req = build_request(:delete_user_permissions_boundary, params)
  req.send_request(options)
end

#delete_user_policy(params = {}) ⇒ Struct

Deletes the specified inline policy that is embedded in the specified IAM user.

A user can also have managed policies attached to it. To detach a managed policy from a user, use DetachUserPolicy. For more information about policies, refer to [Managed policies and inline policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

Examples:

Example: To remove a policy from an IAM user


# The following delete-user-policy command removes the specified policy from the IAM user named Juan:

resp = client.delete_user_policy({
  policy_name: "ExamplePolicy", 
  user_name: "Juan", 
})

Request syntax with placeholder values


resp = client.delete_user_policy({
  user_name: "existingUserNameType", # required
  policy_name: "policyNameType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name (friendly name, not ARN) identifying the user that the policy is embedded in.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :policy_name (required, String) —

    The name identifying the policy document to delete.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3597
3598
3599
3600
 
# File 'lib/aws-sdk-iam/client.rb', line 3597

def delete_user_policy(params = {}, options = {})
  req = build_request(:delete_user_policy, params)
  req.send_request(options)
end

#delete_virtual_mfa_device(params = {}) ⇒ Struct

Deletes a virtual MFA device.

<note markdown=“1”> You must deactivate a user’s virtual MFA device before you can delete it. For information about deactivating MFA devices, see DeactivateMFADevice.

</note>

Examples:

Example: To remove a virtual MFA device


# The following delete-virtual-mfa-device command removes the specified MFA device from the current AWS account.

resp = client.delete_virtual_mfa_device({
  serial_number: "arn:aws:iam::123456789012:mfa/ExampleName", 
})

Request syntax with placeholder values


resp = client.delete_virtual_mfa_device({
  serial_number: "serialNumberType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :serial_number (required, String) —

    The serial number that uniquely identifies the MFA device. For virtual MFA devices, the serial number is the same as the ARN.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters:

    ,.@:/-

    [1]: wikipedia.org/wiki/regex

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3644
3645
3646
3647
 
# File 'lib/aws-sdk-iam/client.rb', line 3644

def delete_virtual_mfa_device(params = {}, options = {})
  req = build_request(:delete_virtual_mfa_device, params)
  req.send_request(options)
end

#detach_group_policy(params = {}) ⇒ Struct

Removes the specified managed policy from the specified IAM group.

A group can also have inline policies embedded with it. To delete an inline policy, use DeleteGroupPolicy. For information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

Examples:

Request syntax with placeholder values


resp = client.detach_group_policy({
  group_name: "groupNameType", # required
  policy_arn: "arnType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :group_name (required, String) —

    The name (friendly name, not ARN) of the IAM group to detach the policy from.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the IAM policy you want to detach.

    For more information about ARNs, see [Amazon Resource Names (ARNs)] in the *Amazon Web Services General Reference*.

    [1]: docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3695
3696
3697
3698
 
# File 'lib/aws-sdk-iam/client.rb', line 3695

def detach_group_policy(params = {}, options = {})
  req = build_request(:detach_group_policy, params)
  req.send_request(options)
end

#detach_role_policy(params = {}) ⇒ Struct

Removes the specified managed policy from the specified role.

A role can also have inline policies embedded with it. To delete an inline policy, use DeleteRolePolicy. For information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

Examples:

Request syntax with placeholder values


resp = client.detach_role_policy({
  role_name: "roleNameType", # required
  policy_arn: "arnType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :role_name (required, String) —

    The name (friendly name, not ARN) of the IAM role to detach the policy from.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the IAM policy you want to detach.

    For more information about ARNs, see [Amazon Resource Names (ARNs)] in the *Amazon Web Services General Reference*.

    [1]: docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3746
3747
3748
3749
 
# File 'lib/aws-sdk-iam/client.rb', line 3746

def detach_role_policy(params = {}, options = {})
  req = build_request(:detach_role_policy, params)
  req.send_request(options)
end

#detach_user_policy(params = {}) ⇒ Struct

Removes the specified managed policy from the specified user.

A user can also have inline policies embedded with it. To delete an inline policy, use DeleteUserPolicy. For information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

Examples:

Request syntax with placeholder values


resp = client.detach_user_policy({
  user_name: "userNameType", # required
  policy_arn: "arnType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name (friendly name, not ARN) of the IAM user to detach the policy from.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the IAM policy you want to detach.

    For more information about ARNs, see [Amazon Resource Names (ARNs)] in the *Amazon Web Services General Reference*.

    [1]: docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3797
3798
3799
3800
 
# File 'lib/aws-sdk-iam/client.rb', line 3797

def detach_user_policy(params = {}, options = {})
  req = build_request(:detach_user_policy, params)
  req.send_request(options)
end

#enable_mfa_device(params = {}) ⇒ Struct

Enables the specified MFA device and associates it with the specified IAM user. When enabled, the MFA device is required for every subsequent login by the IAM user associated with the device.

Examples:

Request syntax with placeholder values


resp = client.enable_mfa_device({
  user_name: "existingUserNameType", # required
  serial_number: "serialNumberType", # required
  authentication_code_1: "authenticationCodeType", # required
  authentication_code_2: "authenticationCodeType", # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name of the IAM user for whom you want to enable the MFA device.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :serial_number (required, String) —

    The serial number that uniquely identifies the MFA device. For virtual MFA devices, the serial number is the device ARN.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters:

    ,.@:/-

    [1]: wikipedia.org/wiki/regex

  • :authentication_code_1 (required, String) —

    An authentication code emitted by the device.

    The format for this parameter is a string of six digits.

    Submit your request immediately after generating the authentication codes. If you generate the codes and then wait too long to submit the request, the MFA device successfully associates with the user but the MFA device becomes out of sync. This happens because time-based one-time passwords (TOTP) expire after a short period of time. If this happens, you can [resync the device].

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_sync.html

  • :authentication_code_2 (required, String) —

    A subsequent authentication code emitted by the device.

    The format for this parameter is a string of six digits.

    Submit your request immediately after generating the authentication codes. If you generate the codes and then wait too long to submit the request, the MFA device successfully associates with the user but the MFA device becomes out of sync. This happens because time-based one-time passwords (TOTP) expire after a short period of time. If this happens, you can [resync the device].

    [1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_sync.html

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



3878
3879
3880
3881
 
# File 'lib/aws-sdk-iam/client.rb', line 3878

def enable_mfa_device(params = {}, options = {})
  req = build_request(:enable_mfa_device, params)
  req.send_request(options)
end

#generate_credential_report(params = {}) ⇒ Types::GenerateCredentialReportResponse

Generates a credential report for the Amazon Web Services account. For more information about the credential report, see [Getting credential reports] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/credential-reports.html

Examples:

Response structure


resp.state #=> String, one of "STARTED", "INPROGRESS", "COMPLETE"
resp.description #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:

See Also:



3905
3906
3907
3908
 
# File 'lib/aws-sdk-iam/client.rb', line 3905

def generate_credential_report(params = {}, options = {})
  req = build_request(:generate_credential_report, params)
  req.send_request(options)
end

#generate_organizations_access_report(params = {}) ⇒ Types::GenerateOrganizationsAccessReportResponse

Generates a report for service last accessed data for Organizations. You can generate a report for any entities (organization root, organizational unit, or account) or policies in your organization.

To call this operation, you must be signed in using your Organizations management account credentials. You can use your long-term IAM user or root user credentials, or temporary credentials from assuming an IAM role. SCPs must be enabled for your organization root. You must have the required IAM and Organizations permissions. For more information, see [Refining permissions using service last accessed data] in the *IAM User Guide*.

You can generate a service last accessed data report for entities by specifying only the entity’s path. This data includes a list of services that are allowed by any service control policies (SCPs) that apply to the entity.

You can generate a service last accessed data report for a policy by specifying an entity’s path and an optional Organizations policy ID. This data includes a list of services that are allowed by the specified SCP.

For each service in both report types, the data includes the most recent account activity that the policy allows to account principals in the entity or the entity’s children. For important information about the data, reporting period, permissions required, troubleshooting, and supported Regions see [Reducing permissions using service last accessed data] in the *IAM User Guide*.

The data includes all attempts to access Amazon Web Services, not just the successful ones. This includes all attempts that were made using the Amazon Web Services Management Console, the Amazon Web Services API through any of the SDKs, or any of the command line tools. An unexpected entry in the service last accessed data does not mean that an account has been compromised, because the request might have been denied. Refer to your CloudTrail logs as the authoritative source for information about all API calls and whether they were successful or denied access. For more information, see [Logging IAM events with CloudTrail] in the *IAM User Guide*.

This operation returns a ‘JobId`. Use this parameter in the ` GetOrganizationsAccessReport ` operation to check the status of the report generation. To check the status of this request, use the `JobId` parameter in the ` GetOrganizationsAccessReport ` operation and test the `JobStatus` response parameter. When the job is complete, you can retrieve the report.

To generate a service last accessed data report for entities, specify an entity path without specifying the optional Organizations policy ID. The type of entity that you specify determines the data returned in the report.

  • Root – When you specify the organizations root as the entity, the resulting report lists all of the services allowed by SCPs that are attached to your root. For each service, the report includes data for all accounts in your organization except the management account, because the management account is not limited by SCPs.

  • OU – When you specify an organizational unit (OU) as the entity, the resulting report lists all of the services allowed by SCPs that are attached to the OU and its parents. For each service, the report includes data for all accounts in the OU or its children. This data excludes the management account, because the management account is not limited by SCPs.

  • **management account** – When you specify the management account, the resulting report lists all Amazon Web Services services, because the management account is not limited by SCPs. For each service, the report includes data for only the management account.

  • Account – When you specify another account as the entity, the resulting report lists all of the services allowed by SCPs that are attached to the account and its parents. For each service, the report includes data for only the specified account.

To generate a service last accessed data report for policies, specify an entity path and the optional Organizations policy ID. The type of entity that you specify determines the data returned for each service.

  • Root – When you specify the root entity and a policy ID, the resulting report lists all of the services that are allowed by the specified SCP. For each service, the report includes data for all accounts in your organization to which the SCP applies. This data excludes the management account, because the management account is not limited by SCPs. If the SCP is not attached to any entities in the organization, then the report will return a list of services with no data.

  • OU – When you specify an OU entity and a policy ID, the resulting report lists all of the services that are allowed by the specified SCP. For each service, the report includes data for all accounts in the OU or its children to which the SCP applies. This means that other accounts outside the OU that are affected by the SCP might not be included in the data. This data excludes the management account, because the management account is not limited by SCPs. If the SCP is not attached to the OU or one of its children, the report will return a list of services with no data.

  • **management account** – When you specify the management account, the resulting report lists all Amazon Web Services services, because the management account is not limited by SCPs. If you specify a policy ID in the CLI or API, the policy is ignored. For each service, the report includes data for only the management account.

  • Account – When you specify another account entity and a policy ID, the resulting report lists all of the services that are allowed by the specified SCP. For each service, the report includes data for only the specified account. This means that other accounts in the organization that are affected by the SCP might not be included in the data. If the SCP is not attached to the account, the report will return a list of services with no data.

<note markdown=“1”> Service last accessed data does not use other policy types when determining whether a principal could access a service. These other policy types include identity-based policies, resource-based policies, access control lists, IAM permissions boundaries, and STS assume role policies. It only applies SCP logic. For more about the evaluation of policy types, see [Evaluating policies] in the *IAM User Guide*.

</note>

For more information about service last accessed data, see [Reducing policy scope by viewing user activity] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html [2]: docs.aws.amazon.com/IAM/latest/UserGuide/cloudtrail-integration.html [3]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-basics

Examples:

Example: To generate a service last accessed data report for an organizational unit


# The following operation generates a report for the organizational unit ou-rge0-awexample

resp = client.generate_organizations_access_report({
  entity_path: "o-a1b2c3d4e5/r-f6g7h8i9j0example/ou-1a2b3c-k9l8m7n6o5example", 
})

resp.to_h outputs the following:
{
  job_id: "examplea-1234-b567-cde8-90fg123abcd4", 
}

Request syntax with placeholder values


resp = client.generate_organizations_access_report({
  entity_path: "organizationsEntityPathType", # required
  organizations_policy_id: "organizationsPolicyIdType",
})

Response structure


resp.job_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :entity_path (required, String) —

    The path of the Organizations entity (root, OU, or account). You can build an entity path using the known structure of your organization. For example, assume that your account ID is ‘123456789012` and its parent OU ID is `ou-rge0-awsabcde`. The organization root ID is `r-f6g7h8i9j0example` and your organization ID is `o-a1b2c3d4e5`. Your entity path is `o-a1b2c3d4e5/r-f6g7h8i9j0example/ou-rge0-awsabcde/123456789012`.

  • :organizations_policy_id (String) —

    The identifier of the Organizations service control policy (SCP). This parameter is optional.

    This ID is used to generate information about when an account principal that is limited by the SCP attempted to access an Amazon Web Services service.

Returns:

See Also:



4090
4091
4092
4093
 
# File 'lib/aws-sdk-iam/client.rb', line 4090

def generate_organizations_access_report(params = {}, options = {})
  req = build_request(:generate_organizations_access_report, params)
  req.send_request(options)
end

#generate_service_last_accessed_details(params = {}) ⇒ Types::GenerateServiceLastAccessedDetailsResponse

Generates a report that includes details about when an IAM resource (user, group, role, or policy) was last used in an attempt to access Amazon Web Services services. Recent activity usually appears within four hours. IAM reports activity for at least the last 400 days, or less if your Region began supporting this feature within the last year. For more information, see [Regions where data is tracked]. For more information about services and actions for which action last accessed information is displayed, see [IAM action last accessed information services and actions].

The service last accessed data includes all attempts to access an Amazon Web Services API, not just the successful ones. This includes all attempts that were made using the Amazon Web Services Management Console, the Amazon Web Services API through any of the SDKs, or any of the command line tools. An unexpected entry in the service last accessed data does not mean that your account has been compromised, because the request might have been denied. Refer to your CloudTrail logs as the authoritative source for information about all API calls and whether they were successful or denied access. For more information, see [Logging IAM events with CloudTrail] in the *IAM User Guide*.

The ‘GenerateServiceLastAccessedDetails` operation returns a `JobId`. Use this parameter in the following operations to retrieve the following details from your report:

  • GetServiceLastAccessedDetails – Use this operation for users, groups, roles, or policies to list every Amazon Web Services service that the resource could access using permissions policies. For each service, the response includes information about the most recent access attempt.

    The ‘JobId` returned by `GenerateServiceLastAccessedDetail` must be used by the same role within a session, or by the same user when used to call `GetServiceLastAccessedDetail`.

  • GetServiceLastAccessedDetailsWithEntities – Use this operation for groups and policies to list information about the associated entities (users or roles) that attempted to access a specific Amazon Web Services service.

To check the status of the ‘GenerateServiceLastAccessedDetails` request, use the `JobId` parameter in the same operations and test the `JobStatus` response parameter.

For additional information about the permissions policies that allow an identity (user, group, or role) to access specific services, use the ListPoliciesGrantingServiceAccess operation.

<note markdown=“1”> Service last accessed data does not use other policy types when determining whether a resource could access a service. These other policy types include resource-based policies, access control lists, Organizations policies, IAM permissions boundaries, and STS assume role policies. It only applies permissions policy logic. For more about the evaluation of policy types, see [Evaluating policies] in the *IAM User Guide*.

</note>

For more information about service and action last accessed data, see

Reducing permissions using service last accessed data][5

in the *IAM

User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#access-advisor_tracking-period [2]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor-action-last-accessed.html [3]: docs.aws.amazon.com/IAM/latest/UserGuide/cloudtrail-integration.html [4]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-basics [5]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html

Examples:

Example: To generate a service last accessed data report for a policy


# The following operation generates a report for the policy: ExamplePolicy1

resp = client.generate_service_last_accessed_details({
  arn: "arn:aws:iam::123456789012:policy/ExamplePolicy1", 
})

resp.to_h outputs the following:
{
  job_id: "examplef-1305-c245-eba4-71fe298bcda7", 
}

Request syntax with placeholder values


resp = client.generate_service_last_accessed_details({
  arn: "arnType", # required
  granularity: "SERVICE_LEVEL", # accepts SERVICE_LEVEL, ACTION_LEVEL
})

Response structure


resp.job_id #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :arn (required, String) —

    The ARN of the IAM resource (user, group, role, or managed policy) used to generate information about when the resource was last used in an attempt to access an Amazon Web Services service.

  • :granularity (String) —

    The level of detail that you want to generate. You can specify whether you want to generate information about the last attempt to access services or actions. If you specify service-level granularity, this operation generates only service data. If you specify action-level granularity, it generates service and action data. If you don’t include this optional parameter, the operation generates service data.

Returns:

See Also:



4212
4213
4214
4215
 
# File 'lib/aws-sdk-iam/client.rb', line 4212

def generate_service_last_accessed_details(params = {}, options = {})
  req = build_request(:generate_service_last_accessed_details, params)
  req.send_request(options)
end

#get_access_key_last_used(params = {}) ⇒ Types::GetAccessKeyLastUsedResponse

Retrieves information about when the specified access key was last used. The information includes the date and time of last use, along with the Amazon Web Services service and Region that were specified in the last request made with that key.

Examples:

Request syntax with placeholder values


resp = client.get_access_key_last_used({
  access_key_id: "accessKeyIdType", # required
})

Response structure


resp.user_name #=> String
resp.access_key_last_used.last_used_date #=> Time
resp.access_key_last_used.service_name #=> String
resp.access_key_last_used.region #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :access_key_id (required, String) —

    The identifier of an access key.

    This parameter allows (through its [regex pattern]) a string of characters that can consist of any upper or lowercased letter or digit.

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



4255
4256
4257
4258
 
# File 'lib/aws-sdk-iam/client.rb', line 4255

def get_access_key_last_used(params = {}, options = {})
  req = build_request(:get_access_key_last_used, params)
  req.send_request(options)
end

#get_account_authorization_details(params = {}) ⇒ Types::GetAccountAuthorizationDetailsResponse

Retrieves information about all IAM users, groups, roles, and policies in your Amazon Web Services account, including their relationships to one another. Use this operation to obtain a snapshot of the configuration of IAM permissions (users, groups, roles, and policies) in your account.

<note markdown=“1”> Policies returned by this operation are URL-encoded compliant with [RFC 3986]. You can use a URL decoding method to convert the policy back to plain JSON text. For example, if you use Java, you can use the ‘decode` method of the `java.net.URLDecoder` utility class in the Java SDK. Other languages and SDKs provide similar functionality.

</note>

You can optionally filter the results using the ‘Filter` parameter. You can paginate the results using the `MaxItems` and `Marker` parameters.

[1]: tools.ietf.org/html/rfc3986

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.({
  filter: ["User"], # accepts User, Role, Group, LocalManagedPolicy, AWSManagedPolicy
  max_items: 1,
  marker: "markerType",
})

Response structure


resp.user_detail_list #=> Array
resp.user_detail_list[0].path #=> String
resp.user_detail_list[0].user_name #=> String
resp.user_detail_list[0].user_id #=> String
resp.user_detail_list[0].arn #=> String
resp.user_detail_list[0].create_date #=> Time
resp.user_detail_list[0].user_policy_list #=> Array
resp.user_detail_list[0].user_policy_list[0].policy_name #=> String
resp.user_detail_list[0].user_policy_list[0].policy_document #=> String
resp.user_detail_list[0].group_list #=> Array
resp.user_detail_list[0].group_list[0] #=> String
resp.user_detail_list[0].attached_managed_policies #=> Array
resp.user_detail_list[0].attached_managed_policies[0].policy_name #=> String
resp.user_detail_list[0].attached_managed_policies[0].policy_arn #=> String
resp.user_detail_list[0].permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.user_detail_list[0].permissions_boundary.permissions_boundary_arn #=> String
resp.user_detail_list[0].tags #=> Array
resp.user_detail_list[0].tags[0].key #=> String
resp.user_detail_list[0].tags[0].value #=> String
resp.group_detail_list #=> Array
resp.group_detail_list[0].path #=> String
resp.group_detail_list[0].group_name #=> String
resp.group_detail_list[0].group_id #=> String
resp.group_detail_list[0].arn #=> String
resp.group_detail_list[0].create_date #=> Time
resp.group_detail_list[0].group_policy_list #=> Array
resp.group_detail_list[0].group_policy_list[0].policy_name #=> String
resp.group_detail_list[0].group_policy_list[0].policy_document #=> String
resp.group_detail_list[0].attached_managed_policies #=> Array
resp.group_detail_list[0].attached_managed_policies[0].policy_name #=> String
resp.group_detail_list[0].attached_managed_policies[0].policy_arn #=> String
resp.role_detail_list #=> Array
resp.role_detail_list[0].path #=> String
resp.role_detail_list[0].role_name #=> String
resp.role_detail_list[0].role_id #=> String
resp.role_detail_list[0].arn #=> String
resp.role_detail_list[0].create_date #=> Time
resp.role_detail_list[0].assume_role_policy_document #=> String
resp.role_detail_list[0].instance_profile_list #=> Array
resp.role_detail_list[0].instance_profile_list[0].path #=> String
resp.role_detail_list[0].instance_profile_list[0].instance_profile_name #=> String
resp.role_detail_list[0].instance_profile_list[0].instance_profile_id #=> String
resp.role_detail_list[0].instance_profile_list[0].arn #=> String
resp.role_detail_list[0].instance_profile_list[0].create_date #=> Time
resp.role_detail_list[0].instance_profile_list[0].roles #=> Array
resp.role_detail_list[0].instance_profile_list[0].roles[0].path #=> String
resp.role_detail_list[0].instance_profile_list[0].roles[0].role_name #=> String
resp.role_detail_list[0].instance_profile_list[0].roles[0].role_id #=> String
resp.role_detail_list[0].instance_profile_list[0].roles[0].arn #=> String
resp.role_detail_list[0].instance_profile_list[0].roles[0].create_date #=> Time
resp.role_detail_list[0].instance_profile_list[0].roles[0].assume_role_policy_document #=> String
resp.role_detail_list[0].instance_profile_list[0].roles[0].description #=> String
resp.role_detail_list[0].instance_profile_list[0].roles[0].max_session_duration #=> Integer
resp.role_detail_list[0].instance_profile_list[0].roles[0].permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.role_detail_list[0].instance_profile_list[0].roles[0].permissions_boundary.permissions_boundary_arn #=> String
resp.role_detail_list[0].instance_profile_list[0].roles[0].tags #=> Array
resp.role_detail_list[0].instance_profile_list[0].roles[0].tags[0].key #=> String
resp.role_detail_list[0].instance_profile_list[0].roles[0].tags[0].value #=> String
resp.role_detail_list[0].instance_profile_list[0].roles[0].role_last_used.last_used_date #=> Time
resp.role_detail_list[0].instance_profile_list[0].roles[0].role_last_used.region #=> String
resp.role_detail_list[0].instance_profile_list[0].tags #=> Array
resp.role_detail_list[0].instance_profile_list[0].tags[0].key #=> String
resp.role_detail_list[0].instance_profile_list[0].tags[0].value #=> String
resp.role_detail_list[0].role_policy_list #=> Array
resp.role_detail_list[0].role_policy_list[0].policy_name #=> String
resp.role_detail_list[0].role_policy_list[0].policy_document #=> String
resp.role_detail_list[0].attached_managed_policies #=> Array
resp.role_detail_list[0].attached_managed_policies[0].policy_name #=> String
resp.role_detail_list[0].attached_managed_policies[0].policy_arn #=> String
resp.role_detail_list[0].permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.role_detail_list[0].permissions_boundary.permissions_boundary_arn #=> String
resp.role_detail_list[0].tags #=> Array
resp.role_detail_list[0].tags[0].key #=> String
resp.role_detail_list[0].tags[0].value #=> String
resp.role_detail_list[0].role_last_used.last_used_date #=> Time
resp.role_detail_list[0].role_last_used.region #=> String
resp.policies #=> Array
resp.policies[0].policy_name #=> String
resp.policies[0].policy_id #=> String
resp.policies[0].arn #=> String
resp.policies[0].path #=> String
resp.policies[0].default_version_id #=> String
resp.policies[0].attachment_count #=> Integer
resp.policies[0].permissions_boundary_usage_count #=> Integer
resp.policies[0].is_attachable #=> Boolean
resp.policies[0].description #=> String
resp.policies[0].create_date #=> Time
resp.policies[0].update_date #=> Time
resp.policies[0].policy_version_list #=> Array
resp.policies[0].policy_version_list[0].document #=> String
resp.policies[0].policy_version_list[0].version_id #=> String
resp.policies[0].policy_version_list[0].is_default_version #=> Boolean
resp.policies[0].policy_version_list[0].create_date #=> Time
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :filter (Array<String>) —

    A list of entity types used to filter the results. Only the entities that match the types you specify are included in the output. Use the value ‘LocalManagedPolicy` to include customer managed policies.

    The format for this parameter is a comma-separated (if more than one) list of strings. Each string value in the list must be one of the valid values listed below.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

Returns:

See Also:



4429
4430
4431
4432
 
# File 'lib/aws-sdk-iam/client.rb', line 4429

def (params = {}, options = {})
  req = build_request(:get_account_authorization_details, params)
  req.send_request(options)
end

#get_account_password_policy(params = {}) ⇒ Types::GetAccountPasswordPolicyResponse

Retrieves the password policy for the Amazon Web Services account. This tells you the complexity requirements and mandatory rotation periods for the IAM user passwords in your account. For more information about using a password policy, see [Managing an IAM password policy].

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingPasswordPolicies.html

Examples:

Example: To see the current account password policy


# The following command displays details about the password policy for the current AWS account.

resp = client.({
})

resp.to_h outputs the following:
{
  password_policy: {
    allow_users_to_change_password: false, 
    expire_passwords: false, 
    hard_expiry: false, 
    max_password_age: 90, 
    minimum_password_length: 8, 
    password_reuse_prevention: 12, 
    require_lowercase_characters: false, 
    require_numbers: true, 
    require_symbols: true, 
    require_uppercase_characters: false, 
  }, 
}

Response structure


resp.password_policy.minimum_password_length #=> Integer
resp.password_policy.require_symbols #=> Boolean
resp.password_policy.require_numbers #=> Boolean
resp.password_policy.require_uppercase_characters #=> Boolean
resp.password_policy.require_lowercase_characters #=> Boolean
resp.password_policy.allow_users_to_change_password #=> Boolean
resp.password_policy.expire_passwords #=> Boolean
resp.password_policy.max_password_age #=> Integer
resp.password_policy.password_reuse_prevention #=> Integer
resp.password_policy.hard_expiry #=> Boolean

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:

See Also:



4489
4490
4491
4492
 
# File 'lib/aws-sdk-iam/client.rb', line 4489

def (params = {}, options = {})
  req = build_request(:get_account_password_policy, params)
  req.send_request(options)
end

#get_account_summary(params = {}) ⇒ Types::GetAccountSummaryResponse

Retrieves information about IAM entity usage and IAM quotas in the Amazon Web Services account.

For information about IAM quotas, see [IAM and STS quotas] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html

Examples:

Example: To get information about IAM entity quotas and usage in the current account


# The following command returns information about the IAM entity quotas and usage in the current AWS account.

resp = client.({
})

resp.to_h outputs the following:
{
  summary_map: {
    "AccessKeysPerUserQuota" => 2, 
    "AccountAccessKeysPresent" => 1, 
    "AccountMFAEnabled" => 0, 
    "AccountSigningCertificatesPresent" => 0, 
    "AttachedPoliciesPerGroupQuota" => 10, 
    "AttachedPoliciesPerRoleQuota" => 10, 
    "AttachedPoliciesPerUserQuota" => 10, 
    "GlobalEndpointTokenVersion" => 2, 
    "GroupPolicySizeQuota" => 5120, 
    "Groups" => 15, 
    "GroupsPerUserQuota" => 10, 
    "GroupsQuota" => 100, 
    "MFADevices" => 6, 
    "MFADevicesInUse" => 3, 
    "Policies" => 8, 
    "PoliciesQuota" => 1000, 
    "PolicySizeQuota" => 5120, 
    "PolicyVersionsInUse" => 22, 
    "PolicyVersionsInUseQuota" => 10000, 
    "ServerCertificates" => 1, 
    "ServerCertificatesQuota" => 20, 
    "SigningCertificatesPerUserQuota" => 2, 
    "UserPolicySizeQuota" => 2048, 
    "Users" => 27, 
    "UsersQuota" => 5000, 
    "VersionsPerPolicyQuota" => 5, 
  }, 
}

Response structure


resp.summary_map #=> Hash
resp.summary_map["summaryKeyType"] #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:

See Also:



4557
4558
4559
4560
 
# File 'lib/aws-sdk-iam/client.rb', line 4557

def (params = {}, options = {})
  req = build_request(:get_account_summary, params)
  req.send_request(options)
end

#get_context_keys_for_custom_policy(params = {}) ⇒ Types::GetContextKeysForPolicyResponse

Gets a list of all of the context keys referenced in the input policies. The policies are supplied as a list of one or more strings. To get the context keys from policies associated with an IAM user, group, or role, use GetContextKeysForPrincipalPolicy.

Context keys are variables maintained by Amazon Web Services and its services that provide details about the context of an API query request. Context keys can be evaluated by testing against a value specified in an IAM policy. Use ‘GetContextKeysForCustomPolicy` to understand what key names and values you must supply when you call SimulateCustomPolicy. Note that all parameters are shown in unencoded form here for clarity but must be URL encoded to be included as a part of a real HTML request.

Examples:

Request syntax with placeholder values


resp = client.get_context_keys_for_custom_policy({
  policy_input_list: ["policyDocumentType"], # required
})

Response structure


resp.context_key_names #=> Array
resp.context_key_names[0] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_input_list (required, Array<String>) —

    A list of policies for which you want the list of context keys referenced in those policies. Each document is specified as a string containing the complete, valid JSON text of an IAM policy.

    The [regex pattern] used to validate this parameter is a string of characters consisting of the following:

    • Any printable ASCII character ranging from the space character (‘u0020`) through the end of the ASCII character range

    • The printable characters in the Basic Latin and Latin-1 Supplement character set (through ‘u00FF`)

    • The special characters tab (‘u0009`), line feed (`u000A`), and carriage return (`u000D`)

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



4616
4617
4618
4619
 
# File 'lib/aws-sdk-iam/client.rb', line 4616

def get_context_keys_for_custom_policy(params = {}, options = {})
  req = build_request(:get_context_keys_for_custom_policy, params)
  req.send_request(options)
end

#get_context_keys_for_principal_policy(params = {}) ⇒ Types::GetContextKeysForPolicyResponse

Gets a list of all of the context keys referenced in all the IAM policies that are attached to the specified IAM entity. The entity can be an IAM user, group, or role. If you specify a user, then the request also includes all of the policies attached to groups that the user is a member of.

You can optionally include a list of one or more additional policies, specified as strings. If you want to include only a list of policies by string, use GetContextKeysForCustomPolicy instead.

Note: This operation discloses information about the permissions granted to other users. If you do not want users to see other user’s permissions, then consider allowing them to use GetContextKeysForCustomPolicy instead.

Context keys are variables maintained by Amazon Web Services and its services that provide details about the context of an API query request. Context keys can be evaluated by testing against a value in an IAM policy. Use GetContextKeysForPrincipalPolicy to understand what key names and values you must supply when you call SimulatePrincipalPolicy.

Examples:

Request syntax with placeholder values


resp = client.get_context_keys_for_principal_policy({
  policy_source_arn: "arnType", # required
  policy_input_list: ["policyDocumentType"],
})

Response structure


resp.context_key_names #=> Array
resp.context_key_names[0] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_source_arn (required, String) —

    The ARN of a user, group, or role whose policies contain the context keys that you want listed. If you specify a user, the list includes context keys that are found in all policies that are attached to the user. The list also includes all groups that the user is a member of. If you pick a group or a role, then it includes only those context keys that are found in policies attached to that entity. Note that all parameters are shown in unencoded form here for clarity, but must be URL encoded to be included as a part of a real HTML request.

    For more information about ARNs, see [Amazon Resource Names (ARNs)] in the *Amazon Web Services General Reference*.

    [1]: docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html

  • :policy_input_list (Array<String>) —

    An optional list of additional policies for which you want the list of context keys that are referenced.

    The [regex pattern] used to validate this parameter is a string of characters consisting of the following:

    • Any printable ASCII character ranging from the space character (‘u0020`) through the end of the ASCII character range

    • The printable characters in the Basic Latin and Latin-1 Supplement character set (through ‘u00FF`)

    • The special characters tab (‘u0009`), line feed (`u000A`), and carriage return (`u000D`)

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



4700
4701
4702
4703
 
# File 'lib/aws-sdk-iam/client.rb', line 4700

def get_context_keys_for_principal_policy(params = {}, options = {})
  req = build_request(:get_context_keys_for_principal_policy, params)
  req.send_request(options)
end

#get_credential_report(params = {}) ⇒ Types::GetCredentialReportResponse

Retrieves a credential report for the Amazon Web Services account. For more information about the credential report, see [Getting credential reports] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/credential-reports.html

Examples:

Response structure


resp.content #=> String
resp.report_format #=> String, one of "text/csv"
resp.generated_time #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:

See Also:



4729
4730
4731
4732
 
# File 'lib/aws-sdk-iam/client.rb', line 4729

def get_credential_report(params = {}, options = {})
  req = build_request(:get_credential_report, params)
  req.send_request(options)
end

#get_group(params = {}) ⇒ Types::GetGroupResponse

Returns a list of IAM users that are in the specified IAM group. You can paginate the results using the ‘MaxItems` and `Marker` parameters.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.get_group({
  group_name: "groupNameType", # required
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.group.path #=> String
resp.group.group_name #=> String
resp.group.group_id #=> String
resp.group.arn #=> String
resp.group.create_date #=> Time
resp.users #=> Array
resp.users[0].path #=> String
resp.users[0].user_name #=> String
resp.users[0].user_id #=> String
resp.users[0].arn #=> String
resp.users[0].create_date #=> Time
resp.users[0].password_last_used #=> Time
resp.users[0].permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.users[0].permissions_boundary.permissions_boundary_arn #=> String
resp.users[0].tags #=> Array
resp.users[0].tags[0].key #=> String
resp.users[0].tags[0].value #=> String
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :group_name (required, String) —

    The name of the group.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



4809
4810
4811
4812
 
# File 'lib/aws-sdk-iam/client.rb', line 4809

def get_group(params = {}, options = {})
  req = build_request(:get_group, params)
  req.send_request(options)
end

#get_group_policy(params = {}) ⇒ Types::GetGroupPolicyResponse

Retrieves the specified inline policy document that is embedded in the specified IAM group.

<note markdown=“1”> Policies returned by this operation are URL-encoded compliant with [RFC 3986]. You can use a URL decoding method to convert the policy back to plain JSON text. For example, if you use Java, you can use the ‘decode` method of the `java.net.URLDecoder` utility class in the Java SDK. Other languages and SDKs provide similar functionality.

</note>

An IAM group can also have managed policies attached to it. To retrieve a managed policy document that is attached to a group, use GetPolicy to determine the policy’s default version, then use GetPolicyVersion to retrieve the policy document.

For more information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

[1]: tools.ietf.org/html/rfc3986 [2]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

Examples:

Request syntax with placeholder values


resp = client.get_group_policy({
  group_name: "groupNameType", # required
  policy_name: "policyNameType", # required
})

Response structure


resp.group_name #=> String
resp.policy_name #=> String
resp.policy_document #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :group_name (required, String) —

    The name of the group the policy is associated with.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :policy_name (required, String) —

    The name of the policy document to get.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



4885
4886
4887
4888
 
# File 'lib/aws-sdk-iam/client.rb', line 4885

def get_group_policy(params = {}, options = {})
  req = build_request(:get_group_policy, params)
  req.send_request(options)
end

#get_instance_profile(params = {}) ⇒ Types::GetInstanceProfileResponse

Retrieves information about the specified instance profile, including the instance profile’s path, GUID, ARN, and role. For more information about instance profiles, see [Using instance profiles] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html

The following waiters are defined for this operation (see #wait_until for detailed usage):

* instance_profile_exists

Examples:

Example: To get information about an instance profile


# The following command gets information about the instance profile named ExampleInstanceProfile.

resp = client.get_instance_profile({
  instance_profile_name: "ExampleInstanceProfile", 
})

resp.to_h outputs the following:
{
  instance_profile: {
    arn: "arn:aws:iam::336924118301:instance-profile/ExampleInstanceProfile", 
    create_date: Time.parse("2013-06-12T23:52:02Z"), 
    instance_profile_id: "AID2MAB8DPLSRHEXAMPLE", 
    instance_profile_name: "ExampleInstanceProfile", 
    path: "/", 
    roles: [
      {
        arn: "arn:aws:iam::336924118301:role/Test-Role", 
        assume_role_policy_document: "<URL-encoded-JSON>", 
        create_date: Time.parse("2013-01-09T06:33:26Z"), 
        path: "/", 
        role_id: "AIDGPMS9RO4H3FEXAMPLE", 
        role_name: "Test-Role", 
      }, 
    ], 
  }, 
}

Request syntax with placeholder values


resp = client.get_instance_profile({
  instance_profile_name: "instanceProfileNameType", # required
})

Response structure


resp.instance_profile.path #=> String
resp.instance_profile.instance_profile_name #=> String
resp.instance_profile.instance_profile_id #=> String
resp.instance_profile.arn #=> String
resp.instance_profile.create_date #=> Time
resp.instance_profile.roles #=> Array
resp.instance_profile.roles[0].path #=> String
resp.instance_profile.roles[0].role_name #=> String
resp.instance_profile.roles[0].role_id #=> String
resp.instance_profile.roles[0].arn #=> String
resp.instance_profile.roles[0].create_date #=> Time
resp.instance_profile.roles[0].assume_role_policy_document #=> String
resp.instance_profile.roles[0].description #=> String
resp.instance_profile.roles[0].max_session_duration #=> Integer
resp.instance_profile.roles[0].permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.instance_profile.roles[0].permissions_boundary.permissions_boundary_arn #=> String
resp.instance_profile.roles[0].tags #=> Array
resp.instance_profile.roles[0].tags[0].key #=> String
resp.instance_profile.roles[0].tags[0].value #=> String
resp.instance_profile.roles[0].role_last_used.last_used_date #=> Time
resp.instance_profile.roles[0].role_last_used.region #=> String
resp.instance_profile.tags #=> Array
resp.instance_profile.tags[0].key #=> String
resp.instance_profile.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :instance_profile_name (required, String) —

    The name of the instance profile to get information about.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



4987
4988
4989
4990
 
# File 'lib/aws-sdk-iam/client.rb', line 4987

def get_instance_profile(params = {}, options = {})
  req = build_request(:get_instance_profile, params)
  req.send_request(options)
end

#get_login_profile(params = {}) ⇒ Types::GetLoginProfileResponse

Retrieves the user name for the specified IAM user. A login profile is created when you create a password for the user to access the Amazon Web Services Management Console. If the user does not exist or does not have a password, the operation returns a 404 (‘NoSuchEntity`) error.

If you create an IAM user with access to the console, the ‘CreateDate` reflects the date you created the initial password for the user.

If you create an IAM user with programmatic access, and then later add a password for the user to access the Amazon Web Services Management Console, the ‘CreateDate` reflects the initial password creation date. A user with programmatic access does not have a login profile unless you create a password for the user to access the Amazon Web Services Management Console.

Examples:

Example: To get password information for an IAM user


# The following command gets information about the password for the IAM user named Anika.

resp = client.({
  user_name: "Anika", 
})

resp.to_h outputs the following:
{
  login_profile: {
    create_date: Time.parse("2012-09-21T23:03:39Z"), 
    user_name: "Anika", 
  }, 
}

Request syntax with placeholder values


resp = client.({
  user_name: "userNameType", # required
})

Response structure


resp..user_name #=> String
resp..create_date #=> Time
resp..password_reset_required #=> Boolean

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name of the user whose login profile you want to retrieve.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



5057
5058
5059
5060
 
# File 'lib/aws-sdk-iam/client.rb', line 5057

def (params = {}, options = {})
  req = build_request(:get_login_profile, params)
  req.send_request(options)
end

#get_mfa_device(params = {}) ⇒ Types::GetMFADeviceResponse

Retrieves information about an MFA device for a specified user.

Examples:

Request syntax with placeholder values


resp = client.get_mfa_device({
  serial_number: "serialNumberType", # required
  user_name: "userNameType",
})

Response structure


resp.user_name #=> String
resp.serial_number #=> String
resp.enable_date #=> Time
resp.certifications #=> Hash
resp.certifications["CertificationKeyType"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:

See Also:



5101
5102
5103
5104
 
# File 'lib/aws-sdk-iam/client.rb', line 5101

def get_mfa_device(params = {}, options = {})
  req = build_request(:get_mfa_device, params)
  req.send_request(options)
end

#get_open_id_connect_provider(params = {}) ⇒ Types::GetOpenIDConnectProviderResponse

Returns information about the specified OpenID Connect (OIDC) provider resource object in IAM.

Examples:

Request syntax with placeholder values


resp = client.get_open_id_connect_provider({
  open_id_connect_provider_arn: "arnType", # required
})

Response structure


resp.url #=> String
resp.client_id_list #=> Array
resp.client_id_list[0] #=> String
resp.thumbprint_list #=> Array
resp.thumbprint_list[0] #=> String
resp.create_date #=> Time
resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :open_id_connect_provider_arn (required, String) —

    The Amazon Resource Name (ARN) of the OIDC provider resource object in IAM to get information for. You can get a list of OIDC provider resource ARNs by using the ListOpenIDConnectProviders operation.

    For more information about ARNs, see [Amazon Resource Names (ARNs)] in the *Amazon Web Services General Reference*.

    [1]: docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html

Returns:

See Also:



5151
5152
5153
5154
 
# File 'lib/aws-sdk-iam/client.rb', line 5151

def get_open_id_connect_provider(params = {}, options = {})
  req = build_request(:get_open_id_connect_provider, params)
  req.send_request(options)
end

#get_organizations_access_report(params = {}) ⇒ Types::GetOrganizationsAccessReportResponse

Retrieves the service last accessed data report for Organizations that was previously generated using the ‘ GenerateOrganizationsAccessReport ` operation. This operation retrieves the status of your report job and the report contents.

Depending on the parameters that you passed when you generated the report, the data returned could include different information. For details, see GenerateOrganizationsAccessReport.

To call this operation, you must be signed in to the management account in your organization. SCPs must be enabled for your organization root. You must have permissions to perform this operation. For more information, see [Refining permissions using service last accessed data] in the *IAM User Guide*.

For each service that principals in an account (root user, IAM users, or IAM roles) could access using SCPs, the operation returns details about the most recent access attempt. If there was no attempt, the service is listed without details about the most recent attempt to access the service. If the operation fails, it returns the reason that it failed.

By default, the list is sorted by service namespace.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html

Examples:

Example: To get details from a previously generated organizational unit report


# The following operation gets details about the report with the job ID: examplea-1234-b567-cde8-90fg123abcd4

resp = client.get_organizations_access_report({
  job_id: "examplea-1234-b567-cde8-90fg123abcd4", 
})

resp.to_h outputs the following:
{
  access_details: [
    {
      entity_path: "o-a1b2c3d4e5/r-f6g7h8i9j0example/ou-1a2b3c-k9l8m7n6o5example/111122223333", 
      last_authenticated_time: Time.parse("2019-05-25T16:29:52Z"), 
      region: "us-east-1", 
      service_name: "Amazon DynamoDB", 
      service_namespace: "dynamodb", 
      total_authenticated_entities: 2, 
    }, 
    {
      entity_path: "o-a1b2c3d4e5/r-f6g7h8i9j0example/ou-1a2b3c-k9l8m7n6o5example/123456789012", 
      last_authenticated_time: Time.parse("2019-06-15T13:12:06Z"), 
      region: "us-east-1", 
      service_name: "AWS Identity and Access Management", 
      service_namespace: "iam", 
      total_authenticated_entities: 4, 
    }, 
    {
      service_name: "Amazon Simple Storage Service", 
      service_namespace: "s3", 
      total_authenticated_entities: 0, 
    }, 
  ], 
  is_truncated: false, 
  job_completion_date: Time.parse("2019-06-18T19:47:35.241Z"), 
  job_creation_date: Time.parse("2019-06-18T19:47:31.466Z"), 
  job_status: "COMPLETED", 
  number_of_services_accessible: 3, 
  number_of_services_not_accessed: 1, 
}

Request syntax with placeholder values


resp = client.get_organizations_access_report({
  job_id: "jobIDType", # required
  max_items: 1,
  marker: "markerType",
  sort_key: "SERVICE_NAMESPACE_ASCENDING", # accepts SERVICE_NAMESPACE_ASCENDING, SERVICE_NAMESPACE_DESCENDING, LAST_AUTHENTICATED_TIME_ASCENDING, LAST_AUTHENTICATED_TIME_DESCENDING
})

Response structure


resp.job_status #=> String, one of "IN_PROGRESS", "COMPLETED", "FAILED"
resp.job_creation_date #=> Time
resp.job_completion_date #=> Time
resp.number_of_services_accessible #=> Integer
resp.number_of_services_not_accessed #=> Integer
resp.access_details #=> Array
resp.access_details[0].service_name #=> String
resp.access_details[0].service_namespace #=> String
resp.access_details[0].region #=> String
resp.access_details[0].entity_path #=> String
resp.access_details[0].last_authenticated_time #=> Time
resp.access_details[0].total_authenticated_entities #=> Integer
resp.is_truncated #=> Boolean
resp.marker #=> String
resp.error_details.message #=> String
resp.error_details.code #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_id (required, String) —

    The identifier of the request generated by the GenerateOrganizationsAccessReport operation.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :sort_key (String) —

    The key that is used to sort the results. If you choose the namespace key, the results are returned in alphabetical order. If you choose the time key, the results are sorted numerically by the date and time.

Returns:

See Also:



5296
5297
5298
5299
 
# File 'lib/aws-sdk-iam/client.rb', line 5296

def get_organizations_access_report(params = {}, options = {})
  req = build_request(:get_organizations_access_report, params)
  req.send_request(options)
end

#get_policy(params = {}) ⇒ Types::GetPolicyResponse

Retrieves information about the specified managed policy, including the policy’s default version and the total number of IAM users, groups, and roles to which the policy is attached. To retrieve the list of the specific users, groups, and roles that the policy is attached to, use ListEntitiesForPolicy. This operation returns metadata about the policy. To retrieve the actual policy document for a specific version of the policy, use GetPolicyVersion.

This operation retrieves information about managed policies. To retrieve information about an inline policy that is embedded with an IAM user, group, or role, use GetUserPolicy, GetGroupPolicy, or GetRolePolicy.

For more information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

The following waiters are defined for this operation (see #wait_until for detailed usage):

* policy_exists

Examples:

Request syntax with placeholder values


resp = client.get_policy({
  policy_arn: "arnType", # required
})

Response structure


resp.policy.policy_name #=> String
resp.policy.policy_id #=> String
resp.policy.arn #=> String
resp.policy.path #=> String
resp.policy.default_version_id #=> String
resp.policy.attachment_count #=> Integer
resp.policy.permissions_boundary_usage_count #=> Integer
resp.policy.is_attachable #=> Boolean
resp.policy.description #=> String
resp.policy.create_date #=> Time
resp.policy.update_date #=> Time
resp.policy.tags #=> Array
resp.policy.tags[0].key #=> String
resp.policy.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:

See Also:



5368
5369
5370
5371
 
# File 'lib/aws-sdk-iam/client.rb', line 5368

def get_policy(params = {}, options = {})
  req = build_request(:get_policy, params)
  req.send_request(options)
end

#get_policy_version(params = {}) ⇒ Types::GetPolicyVersionResponse

Retrieves information about the specified version of the specified managed policy, including the policy document.

<note markdown=“1”> Policies returned by this operation are URL-encoded compliant with [RFC 3986]. You can use a URL decoding method to convert the policy back to plain JSON text. For example, if you use Java, you can use the ‘decode` method of the `java.net.URLDecoder` utility class in the Java SDK. Other languages and SDKs provide similar functionality.

</note>

To list the available versions for a policy, use ListPolicyVersions.

This operation retrieves information about managed policies. To retrieve information about an inline policy that is embedded in a user, group, or role, use GetUserPolicy, GetGroupPolicy, or GetRolePolicy.

For more information about the types of policies, see [Managed policies and inline policies] in the *IAM User Guide*.

For more information about managed policy versions, see [Versioning for managed policies] in the *IAM User Guide*.

[1]: tools.ietf.org/html/rfc3986 [2]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html [3]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html

Examples:

Request syntax with placeholder values


resp = client.get_policy_version({
  policy_arn: "arnType", # required
  version_id: "policyVersionIdType", # required
})

Response structure


resp.policy_version.document #=> String
resp.policy_version.version_id #=> String
resp.policy_version.is_default_version #=> Boolean
resp.policy_version.create_date #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the managed policy that you want information about.

    For more information about ARNs, see [Amazon Resource Names (ARNs)] in the *Amazon Web Services General Reference*.

    [1]: docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html

  • :version_id (required, String) —

    Identifies the policy version to retrieve.

    This parameter allows (through its [regex pattern]) a string of characters that consists of the lowercase letter ‘v’ followed by one or two digits, and optionally followed by a period ‘.’ and a string of letters and digits.

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



5448
5449
5450
5451
 
# File 'lib/aws-sdk-iam/client.rb', line 5448

def get_policy_version(params = {}, options = {})
  req = build_request(:get_policy_version, params)
  req.send_request(options)
end

#get_role(params = {}) ⇒ Types::GetRoleResponse

Retrieves information about the specified role, including the role’s path, GUID, ARN, and the role’s trust policy that grants permission to assume the role. For more information about roles, see [IAM roles] in the *IAM User Guide*.

<note markdown=“1”> Policies returned by this operation are URL-encoded compliant with [RFC 3986]. You can use a URL decoding method to convert the policy back to plain JSON text. For example, if you use Java, you can use the ‘decode` method of the `java.net.URLDecoder` utility class in the Java SDK. Other languages and SDKs provide similar functionality.

</note>

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html [2]: tools.ietf.org/html/rfc3986

The following waiters are defined for this operation (see #wait_until for detailed usage):

* role_exists

Examples:

Example: To get information about an IAM role


# The following command gets information about the role named Test-Role.

resp = client.get_role({
  role_name: "Test-Role", 
})

resp.to_h outputs the following:
{
  role: {
    arn: "arn:aws:iam::123456789012:role/Test-Role", 
    assume_role_policy_document: "<URL-encoded-JSON>", 
    create_date: Time.parse("2013-04-18T05:01:58Z"), 
    max_session_duration: 3600, 
    path: "/", 
    role_id: "AROADBQP57FF2AEXAMPLE", 
    role_last_used: {
      last_used_date: Time.parse("2019-11-18T05:01:58Z"), 
      region: "us-east-1", 
    }, 
    role_name: "Test-Role", 
  }, 
}

Request syntax with placeholder values


resp = client.get_role({
  role_name: "roleNameType", # required
})

Response structure


resp.role.path #=> String
resp.role.role_name #=> String
resp.role.role_id #=> String
resp.role.arn #=> String
resp.role.create_date #=> Time
resp.role.assume_role_policy_document #=> String
resp.role.description #=> String
resp.role.max_session_duration #=> Integer
resp.role.permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.role.permissions_boundary.permissions_boundary_arn #=> String
resp.role.tags #=> Array
resp.role.tags[0].key #=> String
resp.role.tags[0].value #=> String
resp.role.role_last_used.last_used_date #=> Time
resp.role.role_last_used.region #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :role_name (required, String) —

    The name of the IAM role to get information about.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



5546
5547
5548
5549
 
# File 'lib/aws-sdk-iam/client.rb', line 5546

def get_role(params = {}, options = {})
  req = build_request(:get_role, params)
  req.send_request(options)
end

#get_role_policy(params = {}) ⇒ Types::GetRolePolicyResponse

Retrieves the specified inline policy document that is embedded with the specified IAM role.

<note markdown=“1”> Policies returned by this operation are URL-encoded compliant with [RFC 3986]. You can use a URL decoding method to convert the policy back to plain JSON text. For example, if you use Java, you can use the ‘decode` method of the `java.net.URLDecoder` utility class in the Java SDK. Other languages and SDKs provide similar functionality.

</note>

An IAM role can also have managed policies attached to it. To retrieve a managed policy document that is attached to a role, use GetPolicy to determine the policy’s default version, then use GetPolicyVersion to retrieve the policy document.

For more information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

For more information about roles, see [IAM roles] in the *IAM User Guide*.

[1]: tools.ietf.org/html/rfc3986 [2]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html [3]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html

Examples:

Request syntax with placeholder values


resp = client.get_role_policy({
  role_name: "roleNameType", # required
  policy_name: "policyNameType", # required
})

Response structure


resp.role_name #=> String
resp.policy_name #=> String
resp.policy_document #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :role_name (required, String) —

    The name of the role associated with the policy.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :policy_name (required, String) —

    The name of the policy document to get.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



5626
5627
5628
5629
 
# File 'lib/aws-sdk-iam/client.rb', line 5626

def get_role_policy(params = {}, options = {})
  req = build_request(:get_role_policy, params)
  req.send_request(options)
end

#get_saml_provider(params = {}) ⇒ Types::GetSAMLProviderResponse

Returns the SAML provider metadocument that was uploaded when the IAM SAML provider resource object was created or updated.

<note markdown=“1”> This operation requires [Signature Version 4].

</note>

[1]: docs.aws.amazon.com/general/latest/gr/signature-version-4.html

Examples:

Request syntax with placeholder values


resp = client.get_saml_provider({
  saml_provider_arn: "arnType", # required
})

Response structure


resp.saml_metadata_document #=> String
resp.create_date #=> Time
resp.valid_until #=> Time
resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

Returns:

See Also:



5679
5680
5681
5682
 
# File 'lib/aws-sdk-iam/client.rb', line 5679

def get_saml_provider(params = {}, options = {})
  req = build_request(:get_saml_provider, params)
  req.send_request(options)
end

#get_server_certificate(params = {}) ⇒ Types::GetServerCertificateResponse

Retrieves information about the specified server certificate stored in IAM.

For more information about working with server certificates, see

Working with server certificates][1

in the *IAM User Guide*. This

topic includes a list of Amazon Web Services services that can use the server certificates that you manage with IAM.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html

Examples:

Request syntax with placeholder values


resp = client.get_server_certificate({
  server_certificate_name: "serverCertificateNameType", # required
})

Response structure


resp.server_certificate.server_certificate_metadata.path #=> String
resp.server_certificate.server_certificate_metadata.server_certificate_name #=> String
resp.server_certificate.server_certificate_metadata.server_certificate_id #=> String
resp.server_certificate.server_certificate_metadata.arn #=> String
resp.server_certificate.server_certificate_metadata.upload_date #=> Time
resp.server_certificate.server_certificate_metadata.expiration #=> Time
resp.server_certificate.certificate_body #=> String
resp.server_certificate.certificate_chain #=> String
resp.server_certificate.tags #=> Array
resp.server_certificate.tags[0].key #=> String
resp.server_certificate.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :server_certificate_name (required, String) —

    The name of the server certificate you want to retrieve information about.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



5808
5809
5810
5811
 
# File 'lib/aws-sdk-iam/client.rb', line 5808

def get_server_certificate(params = {}, options = {})
  req = build_request(:get_server_certificate, params)
  req.send_request(options)
end

#get_service_last_accessed_details(params = {}) ⇒ Types::GetServiceLastAccessedDetailsResponse

Retrieves a service last accessed report that was created using the ‘GenerateServiceLastAccessedDetails` operation. You can use the `JobId` parameter in `GetServiceLastAccessedDetails` to retrieve the status of your report job. When the report is complete, you can retrieve the generated report. The report includes a list of Amazon Web Services services that the resource (user, group, role, or managed policy) can access.

<note markdown=“1”> Service last accessed data does not use other policy types when determining whether a resource could access a service. These other policy types include resource-based policies, access control lists, Organizations policies, IAM permissions boundaries, and STS assume role policies. It only applies permissions policy logic. For more about the evaluation of policy types, see [Evaluating policies] in the *IAM User Guide*.

</note>

For each service that the resource could access using permissions policies, the operation returns details about the most recent access attempt. If there was no attempt, the service is listed without details about the most recent attempt to access the service. If the operation fails, the ‘GetServiceLastAccessedDetails` operation returns the reason that it failed.

The ‘GetServiceLastAccessedDetails` operation returns a list of services. This list includes the number of entities that have attempted to access the service and the date and time of the last attempt. It also returns the ARN of the following entity, depending on the resource ARN that you used to generate the report:

  • User – Returns the user ARN that you used to generate the report

  • Group – Returns the ARN of the group member (user) that last attempted to access the service

  • Role – Returns the role ARN that you used to generate the report

  • Policy – Returns the ARN of the user or role that last used the policy to attempt to access the service

By default, the list is sorted by service namespace.

If you specified ‘ACTION_LEVEL` granularity when you generated the report, this operation returns service and action last accessed data. This includes the most recent access attempt for each tracked action within a service. Otherwise, this operation returns only service data.

For more information about service and action last accessed data, see

Reducing permissions using service last accessed data][2

in the *IAM

User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-basics [2]: docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html

Examples:

Example: To get details from a previously-generated report


# The following operation gets details about the report with the job ID: examplef-1305-c245-eba4-71fe298bcda7

resp = client.get_service_last_accessed_details({
  job_id: "examplef-1305-c245-eba4-71fe298bcda7", 
})

resp.to_h outputs the following:
{
  is_truncated: false, 
  job_completion_date: Time.parse("2018-10-24T19:47:35.241Z"), 
  job_creation_date: Time.parse("2018-10-24T19:47:31.466Z"), 
  job_status: "COMPLETED", 
  services_last_accessed: [
    {
      last_authenticated: Time.parse("2018-10-24T19:11:00Z"), 
      last_authenticated_entity: "arn:aws:iam::123456789012:user/AWSExampleUser01", 
      service_name: "AWS Identity and Access Management", 
      service_namespace: "iam", 
      total_authenticated_entities: 2, 
    }, 
    {
      service_name: "Amazon Simple Storage Service", 
      service_namespace: "s3", 
      total_authenticated_entities: 0, 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.get_service_last_accessed_details({
  job_id: "jobIDType", # required
  max_items: 1,
  marker: "markerType",
})

Response structure


resp.job_status #=> String, one of "IN_PROGRESS", "COMPLETED", "FAILED"
resp.job_type #=> String, one of "SERVICE_LEVEL", "ACTION_LEVEL"
resp.job_creation_date #=> Time
resp.services_last_accessed #=> Array
resp.services_last_accessed[0].service_name #=> String
resp.services_last_accessed[0].last_authenticated #=> Time
resp.services_last_accessed[0].service_namespace #=> String
resp.services_last_accessed[0].last_authenticated_entity #=> String
resp.services_last_accessed[0].last_authenticated_region #=> String
resp.services_last_accessed[0].total_authenticated_entities #=> Integer
resp.services_last_accessed[0].tracked_actions_last_accessed #=> Array
resp.services_last_accessed[0].tracked_actions_last_accessed[0].action_name #=> String
resp.services_last_accessed[0].tracked_actions_last_accessed[0].last_accessed_entity #=> String
resp.services_last_accessed[0].tracked_actions_last_accessed[0].last_accessed_time #=> Time
resp.services_last_accessed[0].tracked_actions_last_accessed[0].last_accessed_region #=> String
resp.job_completion_date #=> Time
resp.is_truncated #=> Boolean
resp.marker #=> String
resp.error.message #=> String
resp.error.code #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_id (required, String) —

    The ID of the request generated by the GenerateServiceLastAccessedDetails operation. The ‘JobId` returned by `GenerateServiceLastAccessedDetail` must be used by the same role within a session, or by the same user when used to call `GetServiceLastAccessedDetail`.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

Returns:

See Also:



5971
5972
5973
5974
 
# File 'lib/aws-sdk-iam/client.rb', line 5971

def get_service_last_accessed_details(params = {}, options = {})
  req = build_request(:get_service_last_accessed_details, params)
  req.send_request(options)
end

#get_service_last_accessed_details_with_entities(params = {}) ⇒ Types::GetServiceLastAccessedDetailsWithEntitiesResponse

After you generate a group or policy report using the ‘GenerateServiceLastAccessedDetails` operation, you can use the `JobId` parameter in `GetServiceLastAccessedDetailsWithEntities`. This operation retrieves the status of your report job and a list of entities that could have used group or policy permissions to access the specified service.

  • Group – For a group report, this operation returns a list of users in the group that could have used the group’s policies in an attempt to access the service.

  • Policy – For a policy report, this operation returns a list of entities (users or roles) that could have used the policy in an attempt to access the service.

You can also use this operation for user or role reports to retrieve details about those entities.

If the operation fails, the ‘GetServiceLastAccessedDetailsWithEntities` operation returns the reason that it failed.

By default, the list of associated entities is sorted by date, with the most recent access listed first.

Examples:

Example: To get sntity details from a previously-generated report


# The following operation returns details about the entities that attempted to access the IAM service.

resp = client.get_service_last_accessed_details_with_entities({
  job_id: "examplef-1305-c245-eba4-71fe298bcda7", 
  service_namespace: "iam", 
})

resp.to_h outputs the following:
{
  entity_details_list: [
    {
      entity_info: {
        arn: "arn:aws:iam::123456789012:user/AWSExampleUser01", 
        id: "AIDAEX2EXAMPLEB6IGCDC", 
        name: "AWSExampleUser01", 
        path: "/", 
        type: "USER", 
      }, 
      last_authenticated: Time.parse("2018-10-24T19:10:00Z"), 
    }, 
    {
      entity_info: {
        arn: "arn:aws:iam::123456789012:role/AWSExampleRole01", 
        id: "AROAEAEXAMPLEIANXSIU4", 
        name: "AWSExampleRole01", 
        path: "/", 
        type: "ROLE", 
      }, 
    }, 
  ], 
  is_truncated: false, 
  job_completion_date: Time.parse("2018-10-24T19:47:35.241Z"), 
  job_creation_date: Time.parse("2018-10-24T19:47:31.466Z"), 
  job_status: "COMPLETED", 
}

Request syntax with placeholder values


resp = client.get_service_last_accessed_details_with_entities({
  job_id: "jobIDType", # required
  service_namespace: "serviceNamespaceType", # required
  max_items: 1,
  marker: "markerType",
})

Response structure


resp.job_status #=> String, one of "IN_PROGRESS", "COMPLETED", "FAILED"
resp.job_creation_date #=> Time
resp.job_completion_date #=> Time
resp.entity_details_list #=> Array
resp.entity_details_list[0].entity_info.arn #=> String
resp.entity_details_list[0].entity_info.name #=> String
resp.entity_details_list[0].entity_info.type #=> String, one of "USER", "ROLE", "GROUP"
resp.entity_details_list[0].entity_info.id #=> String
resp.entity_details_list[0].entity_info.path #=> String
resp.entity_details_list[0].last_authenticated #=> Time
resp.is_truncated #=> Boolean
resp.marker #=> String
resp.error.message #=> String
resp.error.code #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :job_id (required, String) —

    The ID of the request generated by the ‘GenerateServiceLastAccessedDetails` operation.

  • :service_namespace (required, String) —

    The service namespace for an Amazon Web Services service. Provide the service namespace to learn when the IAM entity last attempted to access the specified service.

    To learn the service namespace for a service, see [Actions, resources, and condition keys for Amazon Web Services services] in the *IAM User Guide*. Choose the name of the service to view details for that service. In the first paragraph, find the service prefix. For example, ‘(service prefix: a4b)`. For more information about service namespaces, see [Amazon Web Services service namespaces] in the *Amazon Web Services General Reference*.

    [1]: docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html [2]: docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#genref-aws-service-namespaces

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

Returns:

See Also:



6119
6120
6121
6122
 
# File 'lib/aws-sdk-iam/client.rb', line 6119

def get_service_last_accessed_details_with_entities(params = {}, options = {})
  req = build_request(:get_service_last_accessed_details_with_entities, params)
  req.send_request(options)
end

#get_service_linked_role_deletion_status(params = {}) ⇒ Types::GetServiceLinkedRoleDeletionStatusResponse

Retrieves the status of your service-linked role deletion. After you use DeleteServiceLinkedRole to submit a service-linked role for deletion, you can use the ‘DeletionTaskId` parameter in `GetServiceLinkedRoleDeletionStatus` to check the status of the deletion. If the deletion fails, this operation returns the reason that it failed, if that information is returned by the service.

Examples:

Request syntax with placeholder values


resp = client.get_service_linked_role_deletion_status({
  deletion_task_id: "DeletionTaskIdType", # required
})

Response structure


resp.status #=> String, one of "SUCCEEDED", "IN_PROGRESS", "FAILED", "NOT_STARTED"
resp.reason.reason #=> String
resp.reason.role_usage_list #=> Array
resp.reason.role_usage_list[0].region #=> String
resp.reason.role_usage_list[0].resources #=> Array
resp.reason.role_usage_list[0].resources[0] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :deletion_task_id (required, String) —

    The deletion task identifier. This identifier is returned by the DeleteServiceLinkedRole operation in the format ‘task/aws-service-role/<service-principal-name>/<role-name>/<task-uuid>`.

Returns:

See Also:



6160
6161
6162
6163
 
# File 'lib/aws-sdk-iam/client.rb', line 6160

def get_service_linked_role_deletion_status(params = {}, options = {})
  req = build_request(:get_service_linked_role_deletion_status, params)
  req.send_request(options)
end

#get_ssh_public_key(params = {}) ⇒ Types::GetSSHPublicKeyResponse

Retrieves the specified SSH public key, including metadata about the key.

The SSH public key retrieved by this operation is used only for authenticating the associated IAM user to an CodeCommit repository. For more information about using SSH keys to authenticate to an CodeCommit repository, see [Set up CodeCommit for SSH connections] in the *CodeCommit User Guide*.

[1]: docs.aws.amazon.com/codecommit/latest/userguide/setting-up-credentials-ssh.html

Examples:

Request syntax with placeholder values


resp = client.get_ssh_public_key({
  user_name: "userNameType", # required
  ssh_public_key_id: "publicKeyIdType", # required
  encoding: "SSH", # required, accepts SSH, PEM
})

Response structure


resp.ssh_public_key.user_name #=> String
resp.ssh_public_key.ssh_public_key_id #=> String
resp.ssh_public_key.fingerprint #=> String
resp.ssh_public_key.ssh_public_key_body #=> String
resp.ssh_public_key.status #=> String, one of "Active", "Inactive"
resp.ssh_public_key.upload_date #=> Time

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name of the IAM user associated with the SSH public key.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :ssh_public_key_id (required, String) —

    The unique identifier for the SSH public key.

    This parameter allows (through its [regex pattern]) a string of characters that can consist of any upper or lowercased letter or digit.

    [1]: wikipedia.org/wiki/regex

  • :encoding (required, String) —

    Specifies the public key encoding format to use in the response. To retrieve the public key in ssh-rsa format, use ‘SSH`. To retrieve the public key in PEM format, use `PEM`.

Returns:

See Also:



5750
5751
5752
5753
 
# File 'lib/aws-sdk-iam/client.rb', line 5750

def get_ssh_public_key(params = {}, options = {})
  req = build_request(:get_ssh_public_key, params)
  req.send_request(options)
end

#get_user(params = {}) ⇒ Types::GetUserResponse

Retrieves information about the specified IAM user, including the user’s creation date, path, unique ID, and ARN.

If you do not specify a user name, IAM determines the user name implicitly based on the Amazon Web Services access key ID used to sign the request to this operation.

The following waiters are defined for this operation (see #wait_until for detailed usage):

* user_exists

Examples:

Example: To get information about an IAM user


# The following command gets information about the IAM user named Bob.

resp = client.get_user({
  user_name: "Bob", 
})

resp.to_h outputs the following:
{
  user: {
    arn: "arn:aws:iam::123456789012:user/Bob", 
    create_date: Time.parse("2012-09-21T23:03:13Z"), 
    path: "/", 
    user_id: "AKIAIOSFODNN7EXAMPLE", 
    user_name: "Bob", 
  }, 
}

Request syntax with placeholder values


resp = client.get_user({
  user_name: "existingUserNameType",
})

Response structure


resp.user.path #=> String
resp.user.user_name #=> String
resp.user.user_id #=> String
resp.user.arn #=> String
resp.user.create_date #=> Time
resp.user.password_last_used #=> Time
resp.user.permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.user.permissions_boundary.permissions_boundary_arn #=> String
resp.user.tags #=> Array
resp.user.tags[0].key #=> String
resp.user.tags[0].value #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (String) —

    The name of the user to get information about.

    This parameter is optional. If it is not included, it defaults to the user making the request. This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



6238
6239
6240
6241
 
# File 'lib/aws-sdk-iam/client.rb', line 6238

def get_user(params = {}, options = {})
  req = build_request(:get_user, params)
  req.send_request(options)
end

#get_user_policy(params = {}) ⇒ Types::GetUserPolicyResponse

Retrieves the specified inline policy document that is embedded in the specified IAM user.

<note markdown=“1”> Policies returned by this operation are URL-encoded compliant with [RFC 3986]. You can use a URL decoding method to convert the policy back to plain JSON text. For example, if you use Java, you can use the ‘decode` method of the `java.net.URLDecoder` utility class in the Java SDK. Other languages and SDKs provide similar functionality.

</note>

An IAM user can also have managed policies attached to it. To retrieve a managed policy document that is attached to a user, use GetPolicy to determine the policy’s default version. Then use GetPolicyVersion to retrieve the policy document.

For more information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

[1]: tools.ietf.org/html/rfc3986 [2]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

Examples:

Request syntax with placeholder values


resp = client.get_user_policy({
  user_name: "existingUserNameType", # required
  policy_name: "policyNameType", # required
})

Response structure


resp.user_name #=> String
resp.policy_name #=> String
resp.policy_document #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name of the user who the policy is associated with.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :policy_name (required, String) —

    The name of the policy document to get.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

Returns:

See Also:



6314
6315
6316
6317
 
# File 'lib/aws-sdk-iam/client.rb', line 6314

def get_user_policy(params = {}, options = {})
  req = build_request(:get_user_policy, params)
  req.send_request(options)
end

#list_access_keys(params = {}) ⇒ Types::ListAccessKeysResponse

Returns information about the access key IDs associated with the specified IAM user. If there is none, the operation returns an empty list.

Although each user is limited to a small number of keys, you can still paginate the results using the ‘MaxItems` and `Marker` parameters.

If the ‘UserName` is not specified, the user name is determined implicitly based on the Amazon Web Services access key ID used to sign the request. If a temporary access key is used, then `UserName` is required. If a long-term key is assigned to the user, then `UserName` is not required.

This operation works for access keys under the Amazon Web Services account. If the Amazon Web Services account has no associated users, the root user returns it’s own access key IDs by running this command.

<note markdown=“1”> To ensure the security of your Amazon Web Services account, the secret access key is accessible only during key and user creation.

</note>

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: To list the access key IDs for an IAM user


# The following command lists the access keys IDs for the IAM user named Alice.

resp = client.list_access_keys({
  user_name: "Alice", 
})

resp.to_h outputs the following:
{
  access_key_metadata: [
    {
      access_key_id: "AKIA111111111EXAMPLE", 
      create_date: Time.parse("2016-12-01T22:19:58Z"), 
      status: "Active", 
      user_name: "Alice", 
    }, 
    {
      access_key_id: "AKIA222222222EXAMPLE", 
      create_date: Time.parse("2016-12-01T22:20:01Z"), 
      status: "Active", 
      user_name: "Alice", 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.list_access_keys({
  user_name: "existingUserNameType",
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.access_key_metadata #=> Array
resp.access_key_metadata[0].user_name #=> String
resp.access_key_metadata[0].access_key_id #=> String
resp.access_key_metadata[0].status #=> String, one of "Active", "Inactive"
resp.access_key_metadata[0].create_date #=> Time
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (String) —

    The name of the user.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



6428
6429
6430
6431
 
# File 'lib/aws-sdk-iam/client.rb', line 6428

def list_access_keys(params = {}, options = {})
  req = build_request(:list_access_keys, params)
  req.send_request(options)
end

#list_account_aliases(params = {}) ⇒ Types::ListAccountAliasesResponse

Lists the account alias associated with the Amazon Web Services account (Note: you can have only one). For information about using an Amazon Web Services account alias, see [Creating, deleting, and listing an Amazon Web Services account alias] in the *Amazon Web Services Sign-In User Guide*.

[1]: docs.aws.amazon.com/signin/latest/userguide/CreateAccountAlias.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: To list account aliases


# The following command lists the aliases for the current account.

resp = client.({
})

resp.to_h outputs the following:
{
  account_aliases: [
    "exmaple-corporation", 
  ], 
}

Request syntax with placeholder values


resp = client.({
  marker: "markerType",
  max_items: 1,
})

Response structure


resp. #=> Array
resp.[0] #=> String
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



6501
6502
6503
6504
 
# File 'lib/aws-sdk-iam/client.rb', line 6501

def (params = {}, options = {})
  req = build_request(:list_account_aliases, params)
  req.send_request(options)
end

#list_attached_group_policies(params = {}) ⇒ Types::ListAttachedGroupPoliciesResponse

Lists all managed policies that are attached to the specified IAM group.

An IAM group can also have inline policies embedded with it. To list the inline policies for a group, use ListGroupPolicies. For information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

You can paginate the results using the ‘MaxItems` and `Marker` parameters. You can use the `PathPrefix` parameter to limit the list of policies to only those matching the specified path prefix. If there are no policies attached to the specified group (or none that match the specified path prefix), the operation returns an empty list.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_attached_group_policies({
  group_name: "groupNameType", # required
  path_prefix: "policyPathType",
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.attached_policies #=> Array
resp.attached_policies[0].policy_name #=> String
resp.attached_policies[0].policy_arn #=> String
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :group_name (required, String) —

    The name (friendly name, not ARN) of the group to list attached policies for.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :path_prefix (String) —

    The path prefix for filtering the results. This parameter is optional. If it is not included, it defaults to a slash (/), listing all policies.

    This parameter allows (through its [regex pattern]) a string of characters consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes. In addition, it can contain any ASCII character from the ! (‘u0021`) through the DEL character (`u007F`), including most punctuation characters, digits, and upper and lowercased letters.

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



6599
6600
6601
6602
 
# File 'lib/aws-sdk-iam/client.rb', line 6599

def list_attached_group_policies(params = {}, options = {})
  req = build_request(:list_attached_group_policies, params)
  req.send_request(options)
end

#list_attached_role_policies(params = {}) ⇒ Types::ListAttachedRolePoliciesResponse

Lists all managed policies that are attached to the specified IAM role.

An IAM role can also have inline policies embedded with it. To list the inline policies for a role, use ListRolePolicies. For information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

You can paginate the results using the ‘MaxItems` and `Marker` parameters. You can use the `PathPrefix` parameter to limit the list of policies to only those matching the specified path prefix. If there are no policies attached to the specified role (or none that match the specified path prefix), the operation returns an empty list.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_attached_role_policies({
  role_name: "roleNameType", # required
  path_prefix: "policyPathType",
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.attached_policies #=> Array
resp.attached_policies[0].policy_name #=> String
resp.attached_policies[0].policy_arn #=> String
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :role_name (required, String) —

    The name (friendly name, not ARN) of the role to list attached policies for.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :path_prefix (String) —

    The path prefix for filtering the results. This parameter is optional. If it is not included, it defaults to a slash (/), listing all policies.

    This parameter allows (through its [regex pattern]) a string of characters consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes. In addition, it can contain any ASCII character from the ! (‘u0021`) through the DEL character (`u007F`), including most punctuation characters, digits, and upper and lowercased letters.

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



6697
6698
6699
6700
 
# File 'lib/aws-sdk-iam/client.rb', line 6697

def list_attached_role_policies(params = {}, options = {})
  req = build_request(:list_attached_role_policies, params)
  req.send_request(options)
end

#list_attached_user_policies(params = {}) ⇒ Types::ListAttachedUserPoliciesResponse

Lists all managed policies that are attached to the specified IAM user.

An IAM user can also have inline policies embedded with it. To list the inline policies for a user, use ListUserPolicies. For information about policies, see [Managed policies and inline policies] in the *IAM User Guide*.

You can paginate the results using the ‘MaxItems` and `Marker` parameters. You can use the `PathPrefix` parameter to limit the list of policies to only those matching the specified path prefix. If there are no policies attached to the specified group (or none that match the specified path prefix), the operation returns an empty list.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_attached_user_policies({
  user_name: "userNameType", # required
  path_prefix: "policyPathType",
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.attached_policies #=> Array
resp.attached_policies[0].policy_name #=> String
resp.attached_policies[0].policy_arn #=> String
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name (friendly name, not ARN) of the user to list attached policies for.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :path_prefix (String) —

    The path prefix for filtering the results. This parameter is optional. If it is not included, it defaults to a slash (/), listing all policies.

    This parameter allows (through its [regex pattern]) a string of characters consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes. In addition, it can contain any ASCII character from the ! (‘u0021`) through the DEL character (`u007F`), including most punctuation characters, digits, and upper and lowercased letters.

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



6795
6796
6797
6798
 
# File 'lib/aws-sdk-iam/client.rb', line 6795

def list_attached_user_policies(params = {}, options = {})
  req = build_request(:list_attached_user_policies, params)
  req.send_request(options)
end

#list_entities_for_policy(params = {}) ⇒ Types::ListEntitiesForPolicyResponse

Lists all IAM users, groups, and roles that the specified managed policy is attached to.

You can use the optional ‘EntityFilter` parameter to limit the results to a particular type of entity (users, groups, or roles). For example, to list only the roles that are attached to the specified policy, set `EntityFilter` to `Role`.

You can paginate the results using the ‘MaxItems` and `Marker` parameters.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_entities_for_policy({
  policy_arn: "arnType", # required
  entity_filter: "User", # accepts User, Role, Group, LocalManagedPolicy, AWSManagedPolicy
  path_prefix: "pathType",
  policy_usage_filter: "PermissionsPolicy", # accepts PermissionsPolicy, PermissionsBoundary
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.policy_groups #=> Array
resp.policy_groups[0].group_name #=> String
resp.policy_groups[0].group_id #=> String
resp.policy_users #=> Array
resp.policy_users[0].user_name #=> String
resp.policy_users[0].user_id #=> String
resp.policy_roles #=> Array
resp.policy_roles[0].role_name #=> String
resp.policy_roles[0].role_id #=> String
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :policy_arn (required, String) —

    The Amazon Resource Name (ARN) of the IAM policy for which you want the versions.

    For more information about ARNs, see [Amazon Resource Names (ARNs)] in the *Amazon Web Services General Reference*.

    [1]: docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html

  • :entity_filter (String) —

    The entity type to use for filtering the results.

    For example, when ‘EntityFilter` is `Role`, only the roles that are attached to the specified policy are returned. This parameter is optional. If it is not included, all attached entities (users, groups, and roles) are returned. The argument for this parameter must be one of the valid values listed below.

  • :path_prefix (String) —

    The path prefix for filtering the results. This parameter is optional. If it is not included, it defaults to a slash (/), listing all entities.

    This parameter allows (through its [regex pattern]) a string of characters consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes. In addition, it can contain any ASCII character from the ! (‘u0021`) through the DEL character (`u007F`), including most punctuation characters, digits, and upper and lowercased letters.

    [1]: wikipedia.org/wiki/regex

  • :policy_usage_filter (String) —

    The policy usage method to use for filtering the results.

    To list only permissions policies, set ‘PolicyUsageFilter` to `PermissionsPolicy`. To list only the policies used to set permissions boundaries, set the value to `PermissionsBoundary`.

    This parameter is optional. If it is not included, all policies are returned.

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



6914
6915
6916
6917
 
# File 'lib/aws-sdk-iam/client.rb', line 6914

def list_entities_for_policy(params = {}, options = {})
  req = build_request(:list_entities_for_policy, params)
  req.send_request(options)
end

#list_group_policies(params = {}) ⇒ Types::ListGroupPoliciesResponse

Lists the names of the inline policies that are embedded in the specified IAM group.

An IAM group can also have managed policies attached to it. To list the managed policies that are attached to a group, use ListAttachedGroupPolicies. For more information about policies, see

Managed policies and inline policies][1

in the *IAM User Guide*.

You can paginate the results using the ‘MaxItems` and `Marker` parameters. If there are no inline policies embedded with the specified group, the operation returns an empty list.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: To list the in-line policies for an IAM group


# The following command lists the names of in-line policies that are embedded in the IAM group named Admins.

resp = client.list_group_policies({
  group_name: "Admins", 
})

resp.to_h outputs the following:
{
  policy_names: [
    "AdminRoot", 
    "KeyPolicy", 
  ], 
}

Request syntax with placeholder values


resp = client.list_group_policies({
  group_name: "groupNameType", # required
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.policy_names #=> Array
resp.policy_names[0] #=> String
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :group_name (required, String) —

    The name of the group to list policies for.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



7008
7009
7010
7011
 
# File 'lib/aws-sdk-iam/client.rb', line 7008

def list_group_policies(params = {}, options = {})
  req = build_request(:list_group_policies, params)
  req.send_request(options)
end

#list_groups(params = {}) ⇒ Types::ListGroupsResponse

Lists the IAM groups that have the specified path prefix.

You can paginate the results using the ‘MaxItems` and `Marker` parameters.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: To list the IAM groups for the current account


# The following command lists the IAM groups in the current account:

resp = client.list_groups({
})

resp.to_h outputs the following:
{
  groups: [
    {
      arn: "arn:aws:iam::123456789012:group/Admins", 
      create_date: Time.parse("2016-12-15T21:40:08.121Z"), 
      group_id: "AGPA1111111111EXAMPLE", 
      group_name: "Admins", 
      path: "/division_abc/subdivision_xyz/", 
    }, 
    {
      arn: "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/engineering/Test", 
      create_date: Time.parse("2016-11-30T14:10:01.156Z"), 
      group_id: "AGP22222222222EXAMPLE", 
      group_name: "Test", 
      path: "/division_abc/subdivision_xyz/product_1234/engineering/", 
    }, 
    {
      arn: "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/Managers", 
      create_date: Time.parse("2016-06-12T20:14:52.032Z"), 
      group_id: "AGPI3333333333EXAMPLE", 
      group_name: "Managers", 
      path: "/division_abc/subdivision_xyz/product_1234/", 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.list_groups({
  path_prefix: "pathPrefixType",
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.groups #=> Array
resp.groups[0].path #=> String
resp.groups[0].group_name #=> String
resp.groups[0].group_id #=> String
resp.groups[0].arn #=> String
resp.groups[0].create_date #=> Time
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :path_prefix (String) —

    The path prefix for filtering the results. For example, the prefix ‘/division_abc/subdivision_xyz/` gets all groups whose path starts with `/division_abc/subdivision_xyz/`.

    This parameter is optional. If it is not included, it defaults to a slash (/), listing all groups. This parameter allows (through its [regex pattern]) a string of characters consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes. In addition, it can contain any ASCII character from the ! (‘u0021`) through the DEL character (`u007F`), including most punctuation characters, digits, and upper and lowercased letters.

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



7118
7119
7120
7121
 
# File 'lib/aws-sdk-iam/client.rb', line 7118

def list_groups(params = {}, options = {})
  req = build_request(:list_groups, params)
  req.send_request(options)
end

#list_groups_for_user(params = {}) ⇒ Types::ListGroupsForUserResponse

Lists the IAM groups that the specified IAM user belongs to.

You can paginate the results using the ‘MaxItems` and `Marker` parameters.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Example: To list the groups that an IAM user belongs to


# The following command displays the groups that the IAM user named Bob belongs to.

resp = client.list_groups_for_user({
  user_name: "Bob", 
})

resp.to_h outputs the following:
{
  groups: [
    {
      arn: "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/engineering/Test", 
      create_date: Time.parse("2016-11-30T14:10:01.156Z"), 
      group_id: "AGP2111111111EXAMPLE", 
      group_name: "Test", 
      path: "/division_abc/subdivision_xyz/product_1234/engineering/", 
    }, 
    {
      arn: "arn:aws:iam::123456789012:group/division_abc/subdivision_xyz/product_1234/Managers", 
      create_date: Time.parse("2016-06-12T20:14:52.032Z"), 
      group_id: "AGPI222222222SEXAMPLE", 
      group_name: "Managers", 
      path: "/division_abc/subdivision_xyz/product_1234/", 
    }, 
  ], 
}

Request syntax with placeholder values


resp = client.list_groups_for_user({
  user_name: "existingUserNameType", # required
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.groups #=> Array
resp.groups[0].path #=> String
resp.groups[0].group_name #=> String
resp.groups[0].group_id #=> String
resp.groups[0].arn #=> String
resp.groups[0].create_date #=> Time
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (required, String) —

    The name of the user to list groups for.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



7217
7218
7219
7220
 
# File 'lib/aws-sdk-iam/client.rb', line 7217

def list_groups_for_user(params = {}, options = {})
  req = build_request(:list_groups_for_user, params)
  req.send_request(options)
end

#list_instance_profile_tags(params = {}) ⇒ Types::ListInstanceProfileTagsResponse

Lists the tags that are attached to the specified IAM instance profile. The returned list of tags is sorted by tag key. For more information about tagging, see [Tagging IAM resources] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_instance_profile_tags({
  instance_profile_name: "instanceProfileNameType", # required
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :instance_profile_name (required, String) —

    The name of the IAM instance profile whose tags you want to see.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



7288
7289
7290
7291
 
# File 'lib/aws-sdk-iam/client.rb', line 7288

def list_instance_profile_tags(params = {}, options = {})
  req = build_request(:list_instance_profile_tags, params)
  req.send_request(options)
end

#list_instance_profiles(params = {}) ⇒ Types::ListInstanceProfilesResponse

Lists the instance profiles that have the specified path prefix. If there are none, the operation returns an empty list. For more information about instance profiles, see [Using instance profiles] in the *IAM User Guide*.

<note markdown=“1”> IAM resource-listing operations return a subset of the available attributes for the resource. For example, this operation does not return tags, even though they are an attribute of the returned object. To view all of the information for an instance profile, see GetInstanceProfile.

</note>

You can paginate the results using the ‘MaxItems` and `Marker` parameters.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_instance_profiles({
  path_prefix: "pathPrefixType",
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.instance_profiles #=> Array
resp.instance_profiles[0].path #=> String
resp.instance_profiles[0].instance_profile_name #=> String
resp.instance_profiles[0].instance_profile_id #=> String
resp.instance_profiles[0].arn #=> String
resp.instance_profiles[0].create_date #=> Time
resp.instance_profiles[0].roles #=> Array
resp.instance_profiles[0].roles[0].path #=> String
resp.instance_profiles[0].roles[0].role_name #=> String
resp.instance_profiles[0].roles[0].role_id #=> String
resp.instance_profiles[0].roles[0].arn #=> String
resp.instance_profiles[0].roles[0].create_date #=> Time
resp.instance_profiles[0].roles[0].assume_role_policy_document #=> String
resp.instance_profiles[0].roles[0].description #=> String
resp.instance_profiles[0].roles[0].max_session_duration #=> Integer
resp.instance_profiles[0].roles[0].permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.instance_profiles[0].roles[0].permissions_boundary.permissions_boundary_arn #=> String
resp.instance_profiles[0].roles[0].tags #=> Array
resp.instance_profiles[0].roles[0].tags[0].key #=> String
resp.instance_profiles[0].roles[0].tags[0].value #=> String
resp.instance_profiles[0].roles[0].role_last_used.last_used_date #=> Time
resp.instance_profiles[0].roles[0].role_last_used.region #=> String
resp.instance_profiles[0].tags #=> Array
resp.instance_profiles[0].tags[0].key #=> String
resp.instance_profiles[0].tags[0].value #=> String
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :path_prefix (String) —

    The path prefix for filtering the results. For example, the prefix ‘/application_abc/component_xyz/` gets all instance profiles whose path starts with `/application_abc/component_xyz/`.

    This parameter is optional. If it is not included, it defaults to a slash (/), listing all instance profiles. This parameter allows (through its [regex pattern]) a string of characters consisting of either a forward slash (/) by itself or a string that must begin and end with forward slashes. In addition, it can contain any ASCII character from the ! (‘u0021`) through the DEL character (`u007F`), including most punctuation characters, digits, and upper and lowercased letters.

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



7398
7399
7400
7401
 
# File 'lib/aws-sdk-iam/client.rb', line 7398

def list_instance_profiles(params = {}, options = {})
  req = build_request(:list_instance_profiles, params)
  req.send_request(options)
end

#list_instance_profiles_for_role(params = {}) ⇒ Types::ListInstanceProfilesForRoleResponse

Lists the instance profiles that have the specified associated IAM role. If there are none, the operation returns an empty list. For more information about instance profiles, go to [Using instance profiles] in the *IAM User Guide*.

You can paginate the results using the ‘MaxItems` and `Marker` parameters.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_instance_profiles_for_role({
  role_name: "roleNameType", # required
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.instance_profiles #=> Array
resp.instance_profiles[0].path #=> String
resp.instance_profiles[0].instance_profile_name #=> String
resp.instance_profiles[0].instance_profile_id #=> String
resp.instance_profiles[0].arn #=> String
resp.instance_profiles[0].create_date #=> Time
resp.instance_profiles[0].roles #=> Array
resp.instance_profiles[0].roles[0].path #=> String
resp.instance_profiles[0].roles[0].role_name #=> String
resp.instance_profiles[0].roles[0].role_id #=> String
resp.instance_profiles[0].roles[0].arn #=> String
resp.instance_profiles[0].roles[0].create_date #=> Time
resp.instance_profiles[0].roles[0].assume_role_policy_document #=> String
resp.instance_profiles[0].roles[0].description #=> String
resp.instance_profiles[0].roles[0].max_session_duration #=> Integer
resp.instance_profiles[0].roles[0].permissions_boundary.permissions_boundary_type #=> String, one of "PermissionsBoundaryPolicy"
resp.instance_profiles[0].roles[0].permissions_boundary.permissions_boundary_arn #=> String
resp.instance_profiles[0].roles[0].tags #=> Array
resp.instance_profiles[0].roles[0].tags[0].key #=> String
resp.instance_profiles[0].roles[0].tags[0].value #=> String
resp.instance_profiles[0].roles[0].role_last_used.last_used_date #=> Time
resp.instance_profiles[0].roles[0].role_last_used.region #=> String
resp.instance_profiles[0].tags #=> Array
resp.instance_profiles[0].tags[0].key #=> String
resp.instance_profiles[0].tags[0].value #=> String
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :role_name (required, String) —

    The name of the role to list instance profiles for.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



7494
7495
7496
7497
 
# File 'lib/aws-sdk-iam/client.rb', line 7494

def list_instance_profiles_for_role(params = {}, options = {})
  req = build_request(:list_instance_profiles_for_role, params)
  req.send_request(options)
end

#list_mfa_device_tags(params = {}) ⇒ Types::ListMFADeviceTagsResponse

Lists the tags that are attached to the specified IAM virtual multi-factor authentication (MFA) device. The returned list of tags is sorted by tag key. For more information about tagging, see [Tagging IAM resources] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_mfa_device_tags({
  serial_number: "serialNumberType", # required
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :serial_number (required, String) —

    The unique identifier for the IAM virtual MFA device whose tags you want to see. For virtual MFA devices, the serial number is the same as the ARN.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



7567
7568
7569
7570
 
# File 'lib/aws-sdk-iam/client.rb', line 7567

def list_mfa_device_tags(params = {}, options = {})
  req = build_request(:list_mfa_device_tags, params)
  req.send_request(options)
end

#list_mfa_devices(params = {}) ⇒ Types::ListMFADevicesResponse

Lists the MFA devices for an IAM user. If the request includes a IAM user name, then this operation lists all the MFA devices associated with the specified user. If you do not specify a user name, IAM determines the user name implicitly based on the Amazon Web Services access key ID signing the request for this operation.

You can paginate the results using the ‘MaxItems` and `Marker` parameters.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_mfa_devices({
  user_name: "existingUserNameType",
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.mfa_devices #=> Array
resp.mfa_devices[0].user_name #=> String
resp.mfa_devices[0].serial_number #=> String
resp.mfa_devices[0].enable_date #=> Time
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :user_name (String) —

    The name of the user whose MFA devices you want to list.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



7639
7640
7641
7642
 
# File 'lib/aws-sdk-iam/client.rb', line 7639

def list_mfa_devices(params = {}, options = {})
  req = build_request(:list_mfa_devices, params)
  req.send_request(options)
end

#list_open_id_connect_provider_tags(params = {}) ⇒ Types::ListOpenIDConnectProviderTagsResponse

Lists the tags that are attached to the specified OpenID Connect (OIDC)-compatible identity provider. The returned list of tags is sorted by tag key. For more information, see [About web identity federation].

For more information about tagging, see [Tagging IAM resources] in the *IAM User Guide*.

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html [2]: docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_open_id_connect_provider_tags({
  open_id_connect_provider_arn: "arnType", # required
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String
resp.is_truncated #=> Boolean
resp.marker #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :open_id_connect_provider_arn (required, String) —

    The ARN of the OpenID Connect (OIDC) identity provider whose tags you want to see.

    This parameter allows (through its [regex pattern]) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-

    [1]: wikipedia.org/wiki/regex

  • :marker (String) —

    Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the ‘Marker` element in the response that you received to indicate where the next call should start.

  • :max_items (Integer) —

    Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the ‘IsTruncated` response element is `true`.

    If you do not include this parameter, the number of items defaults to

    1. Note that IAM might return fewer results, even when there are

    more results available. In that case, the ‘IsTruncated` response element returns `true`, and `Marker` contains a value to include in the subsequent call that tells the service where to continue from.

Returns:

See Also:



7715
7716
7717
7718
 
# File 'lib/aws-sdk-iam/client.rb', line 7715

def list_open_id_connect_provider_tags(params = {}, options = {})
  req = build_request(:list_open_id_connect_provider_tags, params)
  req.send_request(options)
end

#list_open_id_connect_providers(params = {}) ⇒ Types::ListOpenIDConnectProvidersResponse

Lists information about the IAM OpenID Connect (OIDC) provider resource objects defined in the Amazon Web Services account.

<note markdown=“1”> IAM resource-listing operations return a subset of the available attributes for the resource. For example, this operation does not return tags, even though they are an attribute of the returned object. To view all of the information for an OIDC provider, see GetOpenIDConnectProvider.

</note>

Examples:

Response structure


resp.open_id_connect_provider_list #=> Array
resp.open_id_connect_provider_list[0].arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Returns:

See Also:



7744
7745
7746
7747
 
# File 'lib/aws-sdk-iam/client.rb', line 7744

def list_open_id_connect_providers(params = {}, options = {})
  req = build_request(:list_open_id_connect_providers, params)
  req.send_request(options)
end

#list_policies(params = {}) ⇒ Types::ListPoliciesResponse

Lists all the managed policies that are available in your Amazon Web Services account, including your own customer-defined managed policies and all Amazon Web Services managed policies.

You can filter the list of policies that is returned using the optional ‘OnlyAttached`, `Scope`, and `PathPrefix` parameters. For example, to list only the customer managed policies in your Amazon Web Services account, set `Scope` to `Local`. To list only Amazon Web Services managed policies, set `Scope` to `AWS`.

You can paginate the results using the ‘MaxItems` and `Marker` parameters.

For more information about managed policies, see [Managed policies and inline policies] in the *IAM User Guide*.

<note markdown=“1”> IAM resource-listing operations return a subset of the available attributes for the resource. For example, this operation does not return tags, even though they are an attribute of the returned object. To view all of the information for a customer manged policy, see GetPolicy.

</note>

[1]: docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_policies({
  scope: "All", # accepts All, AWS, Local
  only_attached: false,
  path_prefix: "policyPathType",
  policy_usage_filter: "PermissionsPolicy", # accepts PermissionsPolicy, PermissionsBoundary
  marker: "markerType",
  max_items: 1,
})

Response structure


resp.policies #=> Array
resp.policies[0].policy_name #=> String
resp.policies[0].policy_id #=> String
resp.policies[0].arn #=> String
resp.policies[0].path #=> String
resp.policies[0].default_version_id #=> String
resp.policies[0].attachment_count #=> Integer
resp