Class: Aws::IoT::Client

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

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::InstanceProfileCredentials` - Used for loading credentials from an EC2 IMDS on an EC2 instance.

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

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

    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 IMDS instance profile - When used by default, the timeouts are very aggressive. Construct and pass an instance of ‘Aws::InstanceProfileCredentails` to enable retries and extended timeouts.

  • :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 search 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`.

  • :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_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.

  • :disable_host_prefix_injection (Boolean) — default: false —

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

  • :endpoint (String) —

    The client endpoint is normally constructed from the ‘:region` option. You should only configure an `:endpoint` when connecting to test endpoints. This should be avalid 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. Defaults to `false`.

  • :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.

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

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

  • :retry_base_delay (Float) — default: 0.3 —

    The base delay in seconds used by the default backoff function.

  • :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.

    @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 and auth errors from expired credentials.

  • :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.

  • :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.

  • :validate_params (Boolean) — default: true —

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



202
203
204
 
# File 'lib/aws-sdk-iot/client.rb', line 202

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. 



7447
7448
7449
 
# File 'lib/aws-sdk-iot/client.rb', line 7447

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. 



7450
7451
7452
 
# File 'lib/aws-sdk-iot/client.rb', line 7450

def errors_module
  Errors
end

Instance Method Details

#accept_certificate_transfer(params = {}) ⇒ Struct

Accepts a pending certificate transfer. The default state of the certificate is INACTIVE.

To check for pending certificate transfers, call ListCertificates to enumerate your certificates.

Examples:

Request syntax with placeholder values


resp = client.accept_certificate_transfer({
  certificate_id: "CertificateId", # required
  set_as_active: false,
})

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_id (required, String) —

    The ID of the certificate. (The last part of the certificate ARN contains the certificate ID.)

  • :set_as_active (Boolean) —

    Specifies whether the certificate is active.

Returns:

  • (Struct) —

    Returns an empty response.



232
233
234
235
 
# File 'lib/aws-sdk-iot/client.rb', line 232

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

#add_thing_to_billing_group(params = {}) ⇒ Struct

Adds a thing to a billing group.

Examples:

Request syntax with placeholder values


resp = client.add_thing_to_billing_group({
  billing_group_name: "BillingGroupName",
  billing_group_arn: "BillingGroupArn",
  thing_name: "ThingName",
  thing_arn: "ThingArn",
})

Parameters:

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

    ({})

Options Hash (params):

  • :billing_group_name (String) —

    The name of the billing group.

  • :billing_group_arn (String) —

    The ARN of the billing group.

  • :thing_name (String) —

    The name of the thing to be added to the billing group.

  • :thing_arn (String) —

    The ARN of the thing to be added to the billing group.

Returns:

  • (Struct) —

    Returns an empty response.



264
265
266
267
 
# File 'lib/aws-sdk-iot/client.rb', line 264

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

#add_thing_to_thing_group(params = {}) ⇒ Struct

Adds a thing to a thing group.

Examples:

Request syntax with placeholder values


resp = client.add_thing_to_thing_group({
  thing_group_name: "ThingGroupName",
  thing_group_arn: "ThingGroupArn",
  thing_name: "ThingName",
  thing_arn: "ThingArn",
  override_dynamic_groups: false,
})

Parameters:

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

    ({})

Options Hash (params):

  • :thing_group_name (String) —

    The name of the group to which you are adding a thing.

  • :thing_group_arn (String) —

    The ARN of the group to which you are adding a thing.

  • :thing_name (String) —

    The name of the thing to add to a group.

  • :thing_arn (String) —

    The ARN of the thing to add to a group.

  • :override_dynamic_groups (Boolean) —

    Override dynamic thing groups with static thing groups when 10-group limit is reached. If a thing belongs to 10 thing groups, and one or more of those groups are dynamic thing groups, adding a thing to a static group removes the thing from the last dynamic group.

Returns:

  • (Struct) —

    Returns an empty response.



303
304
305
306
 
# File 'lib/aws-sdk-iot/client.rb', line 303

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

#associate_targets_with_job(params = {}) ⇒ Types::AssociateTargetsWithJobResponse

Associates a group with a continuous job. The following criteria must be met:

  • The job must have been created with the ‘targetSelection` field set to “CONTINUOUS”.

  • The job status must currently be “IN_PROGRESS”.

  • The total number of targets associated with a job must not exceed 100.

Examples:

Request syntax with placeholder values


resp = client.associate_targets_with_job({
  targets: ["TargetArn"], # required
  job_id: "JobId", # required
  comment: "Comment",
})

Response structure


resp.job_arn #=> String
resp.job_id #=> String
resp.description #=> String

Parameters:

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

    ({})

Options Hash (params):

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

    A list of thing group ARNs that define the targets of the job.

  • :job_id (required, String) —

    The unique identifier you assigned to this job when it was created.

  • :comment (String) —

    An optional comment string describing why the job was associated with the targets.

Returns:



351
352
353
354
 
# File 'lib/aws-sdk-iot/client.rb', line 351

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

#attach_policy(params = {}) ⇒ Struct

Attaches a policy to the specified target.

Examples:

Request syntax with placeholder values


resp = client.attach_policy({
  policy_name: "PolicyName", # required
  target: "PolicyTarget", # required
})

Parameters:

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

    ({})

Options Hash (params):

Returns:

  • (Struct) —

    Returns an empty response.



379
380
381
382
 
# File 'lib/aws-sdk-iot/client.rb', line 379

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

#attach_principal_policy(params = {}) ⇒ Struct

Attaches the specified policy to the specified principal (certificate or other credential).

Note: This API is deprecated. Please use AttachPolicy instead.

Examples:

Request syntax with placeholder values


resp = client.attach_principal_policy({
  policy_name: "PolicyName", # required
  principal: "Principal", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The policy name.

  • :principal (required, String) —

    The principal, which can be a certificate ARN (as returned from the CreateCertificate operation) or an Amazon Cognito ID.

Returns:

  • (Struct) —

    Returns an empty response.



407
408
409
410
 
# File 'lib/aws-sdk-iot/client.rb', line 407

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

#attach_security_profile(params = {}) ⇒ Struct

Associates a Device Defender security profile with a thing group or with this account. Each thing group or account can have up to five security profiles associated with it.

Examples:

Request syntax with placeholder values


resp = client.attach_security_profile({
  security_profile_name: "SecurityProfileName", # required
  security_profile_target_arn: "SecurityProfileTargetArn", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :security_profile_name (required, String) —

    The security profile that is attached.

  • :security_profile_target_arn (required, String) —

    The ARN of the target (thing group) to which the security profile is attached.

Returns:

  • (Struct) —

    Returns an empty response.



434
435
436
437
 
# File 'lib/aws-sdk-iot/client.rb', line 434

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

#attach_thing_principal(params = {}) ⇒ Struct

Attaches the specified principal to the specified thing.

Examples:

Request syntax with placeholder values


resp = client.attach_thing_principal({
  thing_name: "ThingName", # required
  principal: "Principal", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (required, String) —

    The name of the thing.

  • :principal (required, String) —

    The principal, such as a certificate or other credential.

Returns:

  • (Struct) —

    Returns an empty response.



458
459
460
461
 
# File 'lib/aws-sdk-iot/client.rb', line 458

def attach_thing_principal(params = {}, options = {})
  req = build_request(:attach_thing_principal, 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: {}) 


7425
7426
7427
7428
7429
7430
7431
7432
7433
7434
7435
7436
 
# File 'lib/aws-sdk-iot/client.rb', line 7425

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-iot'
  context[:gem_version] = '1.22.0'
  Seahorse::Client::Request.new(handlers, context)
end

#cancel_audit_task(params = {}) ⇒ Struct

Cancels an audit that is in progress. The audit can be either scheduled or on-demand. If the audit is not in progress, an “InvalidRequestException” occurs.

Examples:

Request syntax with placeholder values


resp = client.cancel_audit_task({
  task_id: "AuditTaskId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :task_id (required, String) —

    The ID of the audit you want to cancel. You can only cancel an audit that is “IN_PROGRESS”.

Returns:

  • (Struct) —

    Returns an empty response.



481
482
483
484
 
# File 'lib/aws-sdk-iot/client.rb', line 481

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

#cancel_certificate_transfer(params = {}) ⇒ Struct

Cancels a pending transfer for the specified certificate.

Note Only the transfer source account can use this operation to cancel a transfer. (Transfer destinations can use RejectCertificateTransfer instead.) After transfer, AWS IoT returns the certificate to the source account in the INACTIVE state. After the destination account has accepted the transfer, the transfer cannot be cancelled.

After a certificate transfer is cancelled, the status of the certificate changes from PENDING_TRANSFER to INACTIVE.

Examples:

Request syntax with placeholder values


resp = client.cancel_certificate_transfer({
  certificate_id: "CertificateId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_id (required, String) —

    The ID of the certificate. (The last part of the certificate ARN contains the certificate ID.)

Returns:

  • (Struct) —

    Returns an empty response.



512
513
514
515
 
# File 'lib/aws-sdk-iot/client.rb', line 512

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

#cancel_job(params = {}) ⇒ Types::CancelJobResponse

Cancels a job.

Examples:

Request syntax with placeholder values


resp = client.cancel_job({
  job_id: "JobId", # required
  reason_code: "ReasonCode",
  comment: "Comment",
  force: false,
})

Response structure


resp.job_arn #=> String
resp.job_id #=> String
resp.description #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :job_id (required, String) —

    The unique identifier you assigned to this job when it was created.

  • :reason_code (String) — default: Optional —

    A reason code string that explains why the job was canceled.

  • :comment (String) —

    An optional comment string describing why the job was canceled.

  • :force (Boolean) — default: Optional —

    If ‘true` job executions with status “IN_PROGRESS” and “QUEUED” are canceled, otherwise only job executions with status “QUEUED” are canceled. The default is `false`.

    Canceling a job which is “IN_PROGRESS”, will cause a device which is executing the job to be unable to update the job execution status. Use caution and ensure that each device executing a job which is canceled is able to recover to a valid state.

Returns:



561
562
563
564
 
# File 'lib/aws-sdk-iot/client.rb', line 561

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

#cancel_job_execution(params = {}) ⇒ Struct

Cancels the execution of a job for a given thing.

Examples:

Request syntax with placeholder values


resp = client.cancel_job_execution({
  job_id: "JobId", # required
  thing_name: "ThingName", # required
  force: false,
  expected_version: 1,
  status_details: {
    "DetailsKey" => "DetailsValue",
  },
})

Parameters:

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

    ({})

Options Hash (params):

  • :job_id (required, String) —

    The ID of the job to be canceled.

  • :thing_name (required, String) —

    The name of the thing whose execution of the job will be canceled.

  • :force (Boolean) — default: Optional —

    If ‘true` the job execution will be canceled if it has status IN_PROGRESS or QUEUED, otherwise the job execution will be canceled only if it has status QUEUED. If you attempt to cancel a job execution that is IN_PROGRESS, and you do not set `force` to `true`, then an `InvalidStateTransitionException` will be thrown. The default is `false`.

    Canceling a job execution which is “IN_PROGRESS”, will cause the device to be unable to update the job execution status. Use caution and ensure that the device is able to recover to a valid state.

  • :expected_version (Integer) — default: Optional —

    The expected current version of the job execution. Each time you update the job execution, its version is incremented. If the version of the job execution stored in Jobs does not match, the update is rejected with a VersionMismatch error, and an ErrorResponse that contains the current job execution status data is returned. (This makes it unnecessary to perform a separate DescribeJobExecution request in order to obtain the job execution status data.)

  • :status_details (Hash<String,String>) —

    A collection of name/value pairs that describe the status of the job execution. If not specified, the statusDetails are unchanged. You can specify at most 10 name/value pairs.

Returns:

  • (Struct) —

    Returns an empty response.



616
617
618
619
 
# File 'lib/aws-sdk-iot/client.rb', line 616

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

#clear_default_authorizer(params = {}) ⇒ Struct

Clears the default authorizer.

Parameters:

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

    ({})

Returns:

  • (Struct) —

    Returns an empty response.



627
628
629
630
 
# File 'lib/aws-sdk-iot/client.rb', line 627

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

#create_authorizer(params = {}) ⇒ Types::CreateAuthorizerResponse

Creates an authorizer.

Examples:

Request syntax with placeholder values


resp = client.create_authorizer({
  authorizer_name: "AuthorizerName", # required
  authorizer_function_arn: "AuthorizerFunctionArn", # required
  token_key_name: "TokenKeyName", # required
  token_signing_public_keys: { # required
    "KeyName" => "KeyValue",
  },
  status: "ACTIVE", # accepts ACTIVE, INACTIVE
})

Response structure


resp.authorizer_name #=> String
resp.authorizer_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :authorizer_name (required, String) —

    The authorizer name.

  • :authorizer_function_arn (required, String) —

    The ARN of the authorizer’s Lambda function.

  • :token_key_name (required, String) —

    The name of the token key used to extract the token from the HTTP headers.

  • :token_signing_public_keys (required, Hash<String,String>) —

    The public keys used to verify the digital signature returned by your custom authentication service.

  • :status (String) —

    The status of the create authorizer request.

Returns:



675
676
677
678
 
# File 'lib/aws-sdk-iot/client.rb', line 675

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

#create_billing_group(params = {}) ⇒ Types::CreateBillingGroupResponse

Creates a billing group.

Examples:

Request syntax with placeholder values


resp = client.create_billing_group({
  billing_group_name: "BillingGroupName", # required
  billing_group_properties: {
    billing_group_description: "BillingGroupDescription",
  },
  tags: [
    {
      key: "TagKey",
      value: "TagValue",
    },
  ],
})

Response structure


resp.billing_group_name #=> String
resp.billing_group_arn #=> String
resp.billing_group_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :billing_group_name (required, String) —

    The name you wish to give to the billing group.

  • :billing_group_properties (Types::BillingGroupProperties) —

    The properties of the billing group.

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

    Metadata which can be used to manage the billing group.

Returns:



720
721
722
723
 
# File 'lib/aws-sdk-iot/client.rb', line 720

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

#create_certificate_from_csr(params = {}) ⇒ Types::CreateCertificateFromCsrResponse

Creates an X.509 certificate using the specified certificate signing request.

Note: The CSR must include a public key that is either an RSA key with a length of at least 2048 bits or an ECC key from NIST P-256 or NIST P-384 curves.

Note: Reusing the same certificate signing request (CSR) results in a distinct certificate.

You can create multiple certificates in a batch by creating a directory, copying multiple .csr files into that directory, and then specifying that directory on the command line. The following commands show how to create a batch of certificates given a batch of CSRs.

Assuming a set of CSRs are located inside of the directory my-csr-directory:

On Linux and OS X, the command is:

$ ls my-csr-directory/ | xargs -I {\} aws iot create-certificate-from-csr –certificate-signing-request file://my-csr-directory/{\}

This command lists all of the CSRs in my-csr-directory and pipes each CSR file name to the aws iot create-certificate-from-csr AWS CLI command to create a certificate for the corresponding CSR.

The aws iot create-certificate-from-csr part of the command can also be run in parallel to speed up the certificate creation process:

$ ls my-csr-directory/ | xargs -P 10 -I {\} aws iot create-certificate-from-csr –certificate-signing-request file://my-csr-directory/{\}

On Windows PowerShell, the command to create certificates for all CSRs in my-csr-directory is:

&gt; ls -Name my-csr-directory | %{aws iot create-certificate-from-csr –certificate-signing-request file://my-csr-directory/$_\}

On a Windows command prompt, the command to create certificates for all CSRs in my-csr-directory is:

&gt; forfiles /p my-csr-directory /c “cmd /c aws iot create-certificate-from-csr –certificate-signing-request file://@path”

Examples:

Request syntax with placeholder values


resp = client.create_certificate_from_csr({
  certificate_signing_request: "CertificateSigningRequest", # required
  set_as_active: false,
})

Response structure


resp.certificate_arn #=> String
resp.certificate_id #=> String
resp.certificate_pem #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_signing_request (required, String) —

    The certificate signing request (CSR).

  • :set_as_active (Boolean) —

    Specifies whether the certificate is active.

Returns:



801
802
803
804
 
# File 'lib/aws-sdk-iot/client.rb', line 801

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

#create_dynamic_thing_group(params = {}) ⇒ Types::CreateDynamicThingGroupResponse

Creates a dynamic thing group.

Examples:

Request syntax with placeholder values


resp = client.create_dynamic_thing_group({
  thing_group_name: "ThingGroupName", # required
  thing_group_properties: {
    thing_group_description: "ThingGroupDescription",
    attribute_payload: {
      attributes: {
        "AttributeName" => "AttributeValue",
      },
      merge: false,
    },
  },
  index_name: "IndexName",
  query_string: "QueryString", # required
  query_version: "QueryVersion",
  tags: [
    {
      key: "TagKey",
      value: "TagValue",
    },
  ],
})

Response structure


resp.thing_group_name #=> String
resp.thing_group_arn #=> String
resp.thing_group_id #=> String
resp.index_name #=> String
resp.query_string #=> String
resp.query_version #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :thing_group_name (required, String) —

    The dynamic thing group name to create.

  • :thing_group_properties (Types::ThingGroupProperties) —

    The dynamic thing group properties.

  • :index_name (String) —

    The dynamic thing group index name.

    <note markdown=“1”> Currently one index is supported: “AWS_Things”.

    </note>
  • :query_string (required, String) —

    The dynamic thing group search query string.

    See [Query Syntax] for information about query string syntax.

    [1]: docs.aws.amazon.com/iot/latest/developerguide/query-syntax.html

  • :query_version (String) —

    The dynamic thing group query version.

    <note markdown=“1”> Currently one query version is supported: “2017-09-30”. If not specified, the query version defaults to this value.

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

    Metadata which can be used to manage the dynamic thing group.

Returns:



885
886
887
888
 
# File 'lib/aws-sdk-iot/client.rb', line 885

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

#create_job(params = {}) ⇒ Types::CreateJobResponse

Creates a job.

Examples:

Request syntax with placeholder values


resp = client.create_job({
  job_id: "JobId", # required
  targets: ["TargetArn"], # required
  document_source: "JobDocumentSource",
  document: "JobDocument",
  description: "JobDescription",
  presigned_url_config: {
    role_arn: "RoleArn",
    expires_in_sec: 1,
  },
  target_selection: "CONTINUOUS", # accepts CONTINUOUS, SNAPSHOT
  job_executions_rollout_config: {
    maximum_per_minute: 1,
    exponential_rate: {
      base_rate_per_minute: 1, # required
      increment_factor: 1.0, # required
      rate_increase_criteria: { # required
        number_of_notified_things: 1,
        number_of_succeeded_things: 1,
      },
    },
  },
  abort_config: {
    criteria_list: [ # required
      {
        failure_type: "FAILED", # required, accepts FAILED, REJECTED, TIMED_OUT, ALL
        action: "CANCEL", # required, accepts CANCEL
        threshold_percentage: 1.0, # required
        min_number_of_executed_things: 1, # required
      },
    ],
  },
  timeout_config: {
    in_progress_timeout_in_minutes: 1,
  },
  tags: [
    {
      key: "TagKey",
      value: "TagValue",
    },
  ],
})

Response structure


resp.job_arn #=> String
resp.job_id #=> String
resp.description #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :job_id (required, String) —

    A job identifier which must be unique for your AWS account. We recommend using a UUID. Alpha-numeric characters, “-” and “_” are valid for use here.

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

    A list of things and thing groups to which the job should be sent.

  • :document_source (String) —

    An S3 link to the job document.

  • :document (String) —

    The job document.

    <note markdown=“1”> If the job document resides in an S3 bucket, you must use a placeholder link when specifying the document.

    The placeholder link is of the following form:

`$\{aws:iot:s3-presigned-url:https://s3.amazonaws.com/bucket/key\}`

where *bucket* is your bucket name and *key* is the object in the

    bucket to which you are linking.

    </note>
  • :description (String) —

    A short text description of the job.

  • :presigned_url_config (Types::PresignedUrlConfig) —

    Configuration information for pre-signed S3 URLs.

  • :target_selection (String) —

    Specifies whether the job will continue to run (CONTINUOUS), or will be complete after all those things specified as targets have completed the job (SNAPSHOT). If continuous, the job may also be run on a thing when a change is detected in a target. For example, a job will run on a thing when the thing is added to a target group, even after the job was completed by all things originally in the group.

  • :job_executions_rollout_config (Types::JobExecutionsRolloutConfig) —

    Allows you to create a staged rollout of the job.

  • :abort_config (Types::AbortConfig) —

    Allows you to create criteria to abort a job.

  • :timeout_config (Types::TimeoutConfig) —

    Specifies the amount of time each device has to finish its execution of the job. The timer is started when the job execution status is set to ‘IN_PROGRESS`. If the job execution status is not set to another terminal state before the time expires, it will be automatically set to `TIMED_OUT`.

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

    Metadata which can be used to manage the job.

Returns:



1007
1008
1009
1010
 
# File 'lib/aws-sdk-iot/client.rb', line 1007

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

#create_keys_and_certificate(params = {}) ⇒ Types::CreateKeysAndCertificateResponse

Creates a 2048-bit RSA key pair and issues an X.509 certificate using the issued public key.

Note This is the only time AWS IoT issues the private key for this certificate, so it is important to keep it in a secure location.

Examples:

Request syntax with placeholder values


resp = client.create_keys_and_certificate({
  set_as_active: false,
})

Response structure


resp.certificate_arn #=> String
resp.certificate_id #=> String
resp.certificate_pem #=> String
resp.key_pair.public_key #=> String
resp.key_pair.private_key #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :set_as_active (Boolean) —

    Specifies whether the certificate is active.

Returns:



1044
1045
1046
1047
 
# File 'lib/aws-sdk-iot/client.rb', line 1044

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

#create_ota_update(params = {}) ⇒ Types::CreateOTAUpdateResponse

Creates an AWS IoT OTAUpdate on a target group of things or groups.

Examples:

Request syntax with placeholder values


resp = client.create_ota_update({
  ota_update_id: "OTAUpdateId", # required
  description: "OTAUpdateDescription",
  targets: ["Target"], # required
  target_selection: "CONTINUOUS", # accepts CONTINUOUS, SNAPSHOT
  aws_job_executions_rollout_config: {
    maximum_per_minute: 1,
  },
  files: [ # required
    {
      file_name: "FileName",
      file_version: "OTAUpdateFileVersion",
      file_location: {
        stream: {
          stream_id: "StreamId",
          file_id: 1,
        },
        s3_location: {
          bucket: "S3Bucket",
          key: "S3Key",
          version: "S3Version",
        },
      },
      code_signing: {
        aws_signer_job_id: "SigningJobId",
        start_signing_job_parameter: {
          signing_profile_parameter: {
            certificate_arn: "CertificateArn",
            platform: "Platform",
            certificate_path_on_device: "CertificatePathOnDevice",
          },
          signing_profile_name: "SigningProfileName",
          destination: {
            s3_destination: {
              bucket: "S3Bucket",
              prefix: "Prefix",
            },
          },
        },
        custom_code_signing: {
          signature: {
            inline_document: "data",
          },
          certificate_chain: {
            certificate_name: "CertificateName",
            inline_document: "InlineDocument",
          },
          hash_algorithm: "HashAlgorithm",
          signature_algorithm: "SignatureAlgorithm",
        },
      },
      attributes: {
        "AttributeKey" => "Value",
      },
    },
  ],
  role_arn: "RoleArn", # required
  additional_parameters: {
    "AttributeKey" => "Value",
  },
})

Response structure


resp.ota_update_id #=> String
resp.aws_iot_job_id #=> String
resp.ota_update_arn #=> String
resp.aws_iot_job_arn #=> String
resp.ota_update_status #=> String, one of "CREATE_PENDING", "CREATE_IN_PROGRESS", "CREATE_COMPLETE", "CREATE_FAILED"

Parameters:

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

    ({})

Options Hash (params):

  • :ota_update_id (required, String) —

    The ID of the OTA update to be created.

  • :description (String) —

    The description of the OTA update.

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

    The targeted devices to receive OTA updates.

  • :target_selection (String) —

    Specifies whether the update will continue to run (CONTINUOUS), or will be complete after all the things specified as targets have completed the update (SNAPSHOT). If continuous, the update may also be run on a thing when a change is detected in a target. For example, an update will run on a thing when the thing is added to a target group, even after the update was completed by all things originally in the group. Valid values: CONTINUOUS | SNAPSHOT.

  • :aws_job_executions_rollout_config (Types::AwsJobExecutionsRolloutConfig) —

    Configuration for the rollout of OTA updates.

  • :files (required, Array<Types::OTAUpdateFile>) —

    The files to be streamed by the OTA update.

  • :role_arn (required, String) —

    The IAM role that allows access to the AWS IoT Jobs service.

  • :additional_parameters (Hash<String,String>) —

    A list of additional OTA update parameters which are name-value pairs.

Returns:



1163
1164
1165
1166
 
# File 'lib/aws-sdk-iot/client.rb', line 1163

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

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

Creates an AWS IoT policy.

The created policy is the default version for the policy. This operation creates a policy version with a version identifier of 1 and sets 1 as the policy’s default version.

Examples:

Request syntax with placeholder values


resp = client.create_policy({
  policy_name: "PolicyName", # required
  policy_document: "PolicyDocument", # required
})

Response structure


resp.policy_name #=> String
resp.policy_arn #=> String
resp.policy_document #=> String
resp.policy_version_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The policy name.

  • :policy_document (required, String) —

    The JSON document that describes the policy. policyDocument must have a minimum length of 1, with a maximum length of 2048, excluding whitespace.

Returns:



1205
1206
1207
1208
 
# File 'lib/aws-sdk-iot/client.rb', line 1205

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 AWS IoT policy. To update a policy, create a new policy version. A managed policy can have up to five versions. If the policy has five versions, you must use DeletePolicyVersion to delete an existing version before you create a new one.

Optionally, you can set the new version as the policy’s default version. The default version is the operative version (that is, the version that is in effect for the certificates to which the policy is attached).

Examples:

Request syntax with placeholder values


resp = client.create_policy_version({
  policy_name: "PolicyName", # required
  policy_document: "PolicyDocument", # required
  set_as_default: false,
})

Response structure


resp.policy_arn #=> String
resp.policy_document #=> String
resp.policy_version_id #=> String
resp.is_default_version #=> Boolean

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The policy name.

  • :policy_document (required, String) —

    The JSON document that describes the policy. Minimum length of 1. Maximum length of 2048, excluding whitespace.

  • :set_as_default (Boolean) —

    Specifies whether the policy version is set as the default. When this parameter is true, the new policy version becomes the operative version (that is, the version that is in effect for the certificates to which the policy is attached).

Returns:



1258
1259
1260
1261
 
# File 'lib/aws-sdk-iot/client.rb', line 1258

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

#create_role_alias(params = {}) ⇒ Types::CreateRoleAliasResponse

Creates a role alias.

Examples:

Request syntax with placeholder values


resp = client.create_role_alias({
  role_alias: "RoleAlias", # required
  role_arn: "RoleArn", # required
  credential_duration_seconds: 1,
})

Response structure


resp.role_alias #=> String
resp.role_alias_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :role_alias (required, String) —

    The role alias that points to a role ARN. This allows you to change the role without having to update the device.

  • :role_arn (required, String) —

    The role ARN.

  • :credential_duration_seconds (Integer) —

    How long (in seconds) the credentials will be valid.

Returns:



1295
1296
1297
1298
 
# File 'lib/aws-sdk-iot/client.rb', line 1295

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

#create_scheduled_audit(params = {}) ⇒ Types::CreateScheduledAuditResponse

Creates a scheduled audit that is run at a specified time interval.

Examples:

Request syntax with placeholder values


resp = client.create_scheduled_audit({
  frequency: "DAILY", # required, accepts DAILY, WEEKLY, BIWEEKLY, MONTHLY
  day_of_month: "DayOfMonth",
  day_of_week: "SUN", # accepts SUN, MON, TUE, WED, THU, FRI, SAT
  target_check_names: ["AuditCheckName"], # required
  scheduled_audit_name: "ScheduledAuditName", # required
})

Response structure


resp.scheduled_audit_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :frequency (required, String) —

    How often the scheduled audit takes place. Can be one of “DAILY”, “WEEKLY”, “BIWEEKLY” or “MONTHLY”. The actual start time of each audit is determined by the system.

  • :day_of_month (String) —

    The day of the month on which the scheduled audit takes place. Can be “1” through “31” or “LAST”. This field is required if the “frequency” parameter is set to “MONTHLY”. If days 29-31 are specified, and the month does not have that many days, the audit takes place on the “LAST” day of the month.

  • :day_of_week (String) —

    The day of the week on which the scheduled audit takes place. Can be one of “SUN”, “MON”, “TUE”, “WED”, “THU”, “FRI” or “SAT”. This field is required if the “frequency” parameter is set to “WEEKLY” or “BIWEEKLY”.

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

    Which checks are performed during the scheduled audit. Checks must be enabled for your account. (Use ‘DescribeAccountAuditConfiguration` to see the list of all checks including those that are enabled or `UpdateAccountAuditConfiguration` to select which checks are enabled.)

  • :scheduled_audit_name (required, String) —

    The name you want to give to the scheduled audit. (Max. 128 chars)

Returns:



1349
1350
1351
1352
 
# File 'lib/aws-sdk-iot/client.rb', line 1349

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

#create_security_profile(params = {}) ⇒ Types::CreateSecurityProfileResponse

Creates a Device Defender security profile.

Examples:

Request syntax with placeholder values


resp = client.create_security_profile({
  security_profile_name: "SecurityProfileName", # required
  security_profile_description: "SecurityProfileDescription",
  behaviors: [ # required
    {
      name: "BehaviorName", # required
      metric: "BehaviorMetric",
      criteria: {
        comparison_operator: "less-than", # accepts less-than, less-than-equals, greater-than, greater-than-equals, in-cidr-set, not-in-cidr-set, in-port-set, not-in-port-set
        value: {
          count: 1,
          cidrs: ["Cidr"],
          ports: [1],
        },
        duration_seconds: 1,
      },
    },
  ],
  alert_targets: {
    "SNS" => {
      alert_target_arn: "AlertTargetArn", # required
      role_arn: "RoleArn", # required
    },
  },
  tags: [
    {
      key: "TagKey",
      value: "TagValue",
    },
  ],
})

Response structure


resp.security_profile_name #=> String
resp.security_profile_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :security_profile_name (required, String) —

    The name you are giving to the security profile.

  • :security_profile_description (String) —

    A description of the security profile.

  • :behaviors (required, Array<Types::Behavior>) —

    Specifies the behaviors that, when violated by a device (thing), cause an alert.

  • :alert_targets (Hash<String,Types::AlertTarget>) —

    Specifies the destinations to which alerts are sent. (Alerts are always sent to the console.) Alerts are generated when a device (thing) violates a behavior.

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

    Metadata which can be used to manage the security profile.

Returns:



1420
1421
1422
1423
 
# File 'lib/aws-sdk-iot/client.rb', line 1420

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

#create_stream(params = {}) ⇒ Types::CreateStreamResponse

Creates a stream for delivering one or more large files in chunks over MQTT. A stream transports data bytes in chunks or blocks packaged as MQTT messages from a source like S3. You can have one or more files associated with a stream. The total size of a file associated with the stream cannot exceed more than 2 MB. The stream will be created with version 0. If a stream is created with the same streamID as a stream that existed and was deleted within last 90 days, we will resurrect that old stream by incrementing the version by 1.

Examples:

Request syntax with placeholder values


resp = client.create_stream({
  stream_id: "StreamId", # required
  description: "StreamDescription",
  files: [ # required
    {
      file_id: 1,
      s3_location: {
        bucket: "S3Bucket",
        key: "S3Key",
        version: "S3Version",
      },
    },
  ],
  role_arn: "RoleArn", # required
})

Response structure


resp.stream_id #=> String
resp.stream_arn #=> String
resp.description #=> String
resp.stream_version #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :stream_id (required, String) —

    The stream ID.

  • :description (String) —

    A description of the stream.

  • :files (required, Array<Types::StreamFile>) —

    The files to stream.

  • :role_arn (required, String) —

    An IAM role that allows the IoT service principal assumes to access your S3 files.

Returns:



1481
1482
1483
1484
 
# File 'lib/aws-sdk-iot/client.rb', line 1481

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

#create_thing(params = {}) ⇒ Types::CreateThingResponse

Creates a thing record in the registry.

<note markdown=“1”> This is a control plane operation. See [Authorization] for information about authorizing control plane actions.

</note>

[1]: docs.aws.amazon.com/iot/latest/developerguide/authorization.html

Examples:

Request syntax with placeholder values


resp = client.create_thing({
  thing_name: "ThingName", # required
  thing_type_name: "ThingTypeName",
  attribute_payload: {
    attributes: {
      "AttributeName" => "AttributeValue",
    },
    merge: false,
  },
  billing_group_name: "BillingGroupName",
})

Response structure


resp.thing_name #=> String
resp.thing_arn #=> String
resp.thing_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (required, String) —

    The name of the thing to create.

  • :thing_type_name (String) —

    The name of the thing type associated with the new thing.

  • :attribute_payload (Types::AttributePayload) —

    The attribute payload, which consists of up to three name/value pairs in a JSON document. For example:

    ‘“attributes”:{“string1”:“string2”}`

  • :billing_group_name (String) —

    The name of the billing group the thing will be added to.

Returns:



1540
1541
1542
1543
 
# File 'lib/aws-sdk-iot/client.rb', line 1540

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

#create_thing_group(params = {}) ⇒ Types::CreateThingGroupResponse

Create a thing group.

<note markdown=“1”> This is a control plane operation. See [Authorization] for information about authorizing control plane actions.

</note>

[1]: docs.aws.amazon.com/iot/latest/developerguide/authorization.html

Examples:

Request syntax with placeholder values


resp = client.create_thing_group({
  thing_group_name: "ThingGroupName", # required
  parent_group_name: "ThingGroupName",
  thing_group_properties: {
    thing_group_description: "ThingGroupDescription",
    attribute_payload: {
      attributes: {
        "AttributeName" => "AttributeValue",
      },
      merge: false,
    },
  },
  tags: [
    {
      key: "TagKey",
      value: "TagValue",
    },
  ],
})

Response structure


resp.thing_group_name #=> String
resp.thing_group_arn #=> String
resp.thing_group_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :thing_group_name (required, String) —

    The thing group name to create.

  • :parent_group_name (String) —

    The name of the parent thing group.

  • :thing_group_properties (Types::ThingGroupProperties) —

    The thing group properties.

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

    Metadata which can be used to manage the thing group.

Returns:



1604
1605
1606
1607
 
# File 'lib/aws-sdk-iot/client.rb', line 1604

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

#create_thing_type(params = {}) ⇒ Types::CreateThingTypeResponse

Creates a new thing type.

Examples:

Request syntax with placeholder values


resp = client.create_thing_type({
  thing_type_name: "ThingTypeName", # required
  thing_type_properties: {
    thing_type_description: "ThingTypeDescription",
    searchable_attributes: ["AttributeName"],
  },
  tags: [
    {
      key: "TagKey",
      value: "TagValue",
    },
  ],
})

Response structure


resp.thing_type_name #=> String
resp.thing_type_arn #=> String
resp.thing_type_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :thing_type_name (required, String) —

    The name of the thing type.

  • :thing_type_properties (Types::ThingTypeProperties) —

    The ThingTypeProperties for the thing type to create. It contains information about the new thing type including a description, and a list of searchable thing attribute names.

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

    Metadata which can be used to manage the thing type.

Returns:



1652
1653
1654
1655
 
# File 'lib/aws-sdk-iot/client.rb', line 1652

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

#create_topic_rule(params = {}) ⇒ Struct

Creates a rule. Creating rules is an administrator-level action. Any user who has permission to create rules will be able to access data processed by the rule.

Examples:

Request syntax with placeholder values


resp = client.create_topic_rule({
  rule_name: "RuleName", # required
  topic_rule_payload: { # required
    sql: "SQL", # required
    description: "Description",
    actions: [ # required
      {
        dynamo_db: {
          table_name: "TableName", # required
          role_arn: "AwsArn", # required
          operation: "DynamoOperation",
          hash_key_field: "HashKeyField", # required
          hash_key_value: "HashKeyValue", # required
          hash_key_type: "STRING", # accepts STRING, NUMBER
          range_key_field: "RangeKeyField",
          range_key_value: "RangeKeyValue",
          range_key_type: "STRING", # accepts STRING, NUMBER
          payload_field: "PayloadField",
        },
        dynamo_d_bv_2: {
          role_arn: "AwsArn", # required
          put_item: { # required
            table_name: "TableName", # required
          },
        },
        lambda: {
          function_arn: "FunctionArn", # required
        },
        sns: {
          target_arn: "AwsArn", # required
          role_arn: "AwsArn", # required
          message_format: "RAW", # accepts RAW, JSON
        },
        sqs: {
          role_arn: "AwsArn", # required
          queue_url: "QueueUrl", # required
          use_base_64: false,
        },
        kinesis: {
          role_arn: "AwsArn", # required
          stream_name: "StreamName", # required
          partition_key: "PartitionKey",
        },
        republish: {
          role_arn: "AwsArn", # required
          topic: "TopicPattern", # required
        },
        s3: {
          role_arn: "AwsArn", # required
          bucket_name: "BucketName", # required
          key: "Key", # required
          canned_acl: "private", # accepts private, public-read, public-read-write, aws-exec-read, authenticated-read, bucket-owner-read, bucket-owner-full-control, log-delivery-write
        },
        firehose: {
          role_arn: "AwsArn", # required
          delivery_stream_name: "DeliveryStreamName", # required
          separator: "FirehoseSeparator",
        },
        cloudwatch_metric: {
          role_arn: "AwsArn", # required
          metric_namespace: "String", # required
          metric_name: "String", # required
          metric_value: "String", # required
          metric_unit: "String", # required
          metric_timestamp: "String",
        },
        cloudwatch_alarm: {
          role_arn: "AwsArn", # required
          alarm_name: "AlarmName", # required
          state_reason: "StateReason", # required
          state_value: "StateValue", # required
        },
        elasticsearch: {
          role_arn: "AwsArn", # required
          endpoint: "ElasticsearchEndpoint", # required
          index: "ElasticsearchIndex", # required
          type: "ElasticsearchType", # required
          id: "ElasticsearchId", # required
        },
        salesforce: {
          token: "SalesforceToken", # required
          url: "SalesforceEndpoint", # required
        },
        iot_analytics: {
          channel_arn: "AwsArn",
          channel_name: "ChannelName",
          role_arn: "AwsArn",
        },
        iot_events: {
          input_name: "InputName", # required
          message_id: "MessageId",
          role_arn: "AwsArn", # required
        },
        step_functions: {
          execution_name_prefix: "ExecutionNamePrefix",
          state_machine_name: "StateMachineName", # required
          role_arn: "AwsArn", # required
        },
      },
    ],
    rule_disabled: false,
    aws_iot_sql_version: "AwsIotSqlVersion",
    error_action: {
      dynamo_db: {
        table_name: "TableName", # required
        role_arn: "AwsArn", # required
        operation: "DynamoOperation",
        hash_key_field: "HashKeyField", # required
        hash_key_value: "HashKeyValue", # required
        hash_key_type: "STRING", # accepts STRING, NUMBER
        range_key_field: "RangeKeyField",
        range_key_value: "RangeKeyValue",
        range_key_type: "STRING", # accepts STRING, NUMBER
        payload_field: "PayloadField",
      },
      dynamo_d_bv_2: {
        role_arn: "AwsArn", # required
        put_item: { # required
          table_name: "TableName", # required
        },
      },
      lambda: {
        function_arn: "FunctionArn", # required
      },
      sns: {
        target_arn: "AwsArn", # required
        role_arn: "AwsArn", # required
        message_format: "RAW", # accepts RAW, JSON
      },
      sqs: {
        role_arn: "AwsArn", # required
        queue_url: "QueueUrl", # required
        use_base_64: false,
      },
      kinesis: {
        role_arn: "AwsArn", # required
        stream_name: "StreamName", # required
        partition_key: "PartitionKey",
      },
      republish: {
        role_arn: "AwsArn", # required
        topic: "TopicPattern", # required
      },
      s3: {
        role_arn: "AwsArn", # required
        bucket_name: "BucketName", # required
        key: "Key", # required
        canned_acl: "private", # accepts private, public-read, public-read-write, aws-exec-read, authenticated-read, bucket-owner-read, bucket-owner-full-control, log-delivery-write
      },
      firehose: {
        role_arn: "AwsArn", # required
        delivery_stream_name: "DeliveryStreamName", # required
        separator: "FirehoseSeparator",
      },
      cloudwatch_metric: {
        role_arn: "AwsArn", # required
        metric_namespace: "String", # required
        metric_name: "String", # required
        metric_value: "String", # required
        metric_unit: "String", # required
        metric_timestamp: "String",
      },
      cloudwatch_alarm: {
        role_arn: "AwsArn", # required
        alarm_name: "AlarmName", # required
        state_reason: "StateReason", # required
        state_value: "StateValue", # required
      },
      elasticsearch: {
        role_arn: "AwsArn", # required
        endpoint: "ElasticsearchEndpoint", # required
        index: "ElasticsearchIndex", # required
        type: "ElasticsearchType", # required
        id: "ElasticsearchId", # required
      },
      salesforce: {
        token: "SalesforceToken", # required
        url: "SalesforceEndpoint", # required
      },
      iot_analytics: {
        channel_arn: "AwsArn",
        channel_name: "ChannelName",
        role_arn: "AwsArn",
      },
      iot_events: {
        input_name: "InputName", # required
        message_id: "MessageId",
        role_arn: "AwsArn", # required
      },
      step_functions: {
        execution_name_prefix: "ExecutionNamePrefix",
        state_machine_name: "StateMachineName", # required
        role_arn: "AwsArn", # required
      },
    },
  },
  tags: "String",
})

Parameters:

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

    ({})

Options Hash (params):

  • :rule_name (required, String) —

    The name of the rule.

  • :topic_rule_payload (required, Types::TopicRulePayload) —

    The rule payload.

  • :tags (String) —

    Metadata which can be used to manage the topic rule.

    <note markdown=“1”> For URI Request parameters use format: …key1=value1&amp;key2=value2…

    For the CLI command-line parameter use format: --tags

    “key1=value1&amp;key2=value2…”

    For the cli-input-json file use format: "tags":

    “key1=value1&amp;key2=value2…”

    </note>

Returns:

  • (Struct) —

    Returns an empty response.



1886
1887
1888
1889
 
# File 'lib/aws-sdk-iot/client.rb', line 1886

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

#delete_account_audit_configuration(params = {}) ⇒ Struct

Restores the default settings for Device Defender audits for this account. Any configuration data you entered is deleted and all audit checks are reset to disabled.

Examples:

Request syntax with placeholder values


resp = client.({
  delete_scheduled_audits: false,
})

Parameters:

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

    ({})

Options Hash (params):

  • :delete_scheduled_audits (Boolean) —

    If true, all scheduled audits are deleted.

Returns:

  • (Struct) —

    Returns an empty response.



1908
1909
1910
1911
 
# File 'lib/aws-sdk-iot/client.rb', line 1908

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

#delete_authorizer(params = {}) ⇒ Struct

Deletes an authorizer.

Examples:

Request syntax with placeholder values


resp = client.delete_authorizer({
  authorizer_name: "AuthorizerName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :authorizer_name (required, String) —

    The name of the authorizer to delete.

Returns:

  • (Struct) —

    Returns an empty response.



1928
1929
1930
1931
 
# File 'lib/aws-sdk-iot/client.rb', line 1928

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

#delete_billing_group(params = {}) ⇒ Struct

Deletes the billing group.

Examples:

Request syntax with placeholder values


resp = client.delete_billing_group({
  billing_group_name: "BillingGroupName", # required
  expected_version: 1,
})

Parameters:

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

    ({})

Options Hash (params):

  • :billing_group_name (required, String) —

    The name of the billing group.

  • :expected_version (Integer) —

    The expected version of the billing group. If the version of the billing group does not match the expected version specified in the request, the ‘DeleteBillingGroup` request is rejected with a `VersionConflictException`.

Returns:

  • (Struct) —

    Returns an empty response.



1955
1956
1957
1958
 
# File 'lib/aws-sdk-iot/client.rb', line 1955

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

#delete_ca_certificate(params = {}) ⇒ Struct

Deletes a registered CA certificate.

Examples:

Request syntax with placeholder values


resp = client.delete_ca_certificate({
  certificate_id: "CertificateId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_id (required, String) —

    The ID of the certificate to delete. (The last part of the certificate ARN contains the certificate ID.)

Returns:

  • (Struct) —

    Returns an empty response.



1976
1977
1978
1979
 
# File 'lib/aws-sdk-iot/client.rb', line 1976

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

#delete_certificate(params = {}) ⇒ Struct

Deletes the specified certificate.

A certificate cannot be deleted if it has a policy attached to it or if its status is set to ACTIVE. To delete a certificate, first use the DetachPrincipalPolicy API to detach all policies. Next, use the UpdateCertificate API to set the certificate to the INACTIVE status.

Examples:

Request syntax with placeholder values


resp = client.delete_certificate({
  certificate_id: "CertificateId", # required
  force_delete: false,
})

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_id (required, String) —

    The ID of the certificate. (The last part of the certificate ARN contains the certificate ID.)

  • :force_delete (Boolean) —

    Forces a certificate request to be deleted.

Returns:

  • (Struct) —

    Returns an empty response.



2006
2007
2008
2009
 
# File 'lib/aws-sdk-iot/client.rb', line 2006

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

#delete_dynamic_thing_group(params = {}) ⇒ Struct

Deletes a dynamic thing group.

Examples:

Request syntax with placeholder values


resp = client.delete_dynamic_thing_group({
  thing_group_name: "ThingGroupName", # required
  expected_version: 1,
})

Parameters:

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

    ({})

Options Hash (params):

  • :thing_group_name (required, String) —

    The name of the dynamic thing group to delete.

  • :expected_version (Integer) —

    The expected version of the dynamic thing group to delete.

Returns:

  • (Struct) —

    Returns an empty response.



2030
2031
2032
2033
 
# File 'lib/aws-sdk-iot/client.rb', line 2030

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

#delete_job(params = {}) ⇒ Struct

Deletes a job and its related job executions.

Deleting a job may take time, depending on the number of job executions created for the job and various other factors. While the job is being deleted, the status of the job will be shown as “DELETION_IN_PROGRESS”. Attempting to delete or cancel a job whose status is already “DELETION_IN_PROGRESS” will result in an error.

Only 10 jobs may have status “DELETION_IN_PROGRESS” at the same time, or a LimitExceededException will occur.

Examples:

Request syntax with placeholder values


resp = client.delete_job({
  job_id: "JobId", # required
  force: false,
})

Parameters:

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

    ({})

Options Hash (params):

  • :job_id (required, String) —

    The ID of the job to be deleted.

    After a job deletion is completed, you may reuse this jobId when you create a new job. However, this is not recommended, and you must ensure that your devices are not using the jobId to refer to the deleted job.

  • :force (Boolean) — default: Optional —

    When true, you can delete a job which is “IN_PROGRESS”. Otherwise, you can only delete a job which is in a terminal state (“COMPLETED” or “CANCELED”) or an exception will occur. The default is false.

    <note markdown=“1”> Deleting a job which is “IN_PROGRESS”, will cause a device which is executing the job to be unable to access job information or update the job execution status. Use caution and ensure that each device executing a job which is deleted is able to recover to a valid state.

    </note>

Returns:

  • (Struct) —

    Returns an empty response.



2078
2079
2080
2081
 
# File 'lib/aws-sdk-iot/client.rb', line 2078

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

#delete_job_execution(params = {}) ⇒ Struct

Deletes a job execution.

Examples:

Request syntax with placeholder values


resp = client.delete_job_execution({
  job_id: "JobId", # required
  thing_name: "ThingName", # required
  execution_number: 1, # required
  force: false,
})

Parameters:

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

    ({})

Options Hash (params):

  • :job_id (required, String) —

    The ID of the job whose execution on a particular device will be deleted.

  • :thing_name (required, String) —

    The name of the thing whose job execution will be deleted.

  • :execution_number (required, Integer) —

    The ID of the job execution to be deleted. The ‘executionNumber` refers to the execution of a particular job on a particular device.

    Note that once a job execution is deleted, the ‘executionNumber` may be reused by IoT, so be sure you get and use the correct value here.

  • :force (Boolean) — default: Optional —

    When true, you can delete a job execution which is “IN_PROGRESS”. Otherwise, you can only delete a job execution which is in a terminal state (“SUCCEEDED”, “FAILED”, “REJECTED”, “REMOVED” or “CANCELED”) or an exception will occur. The default is false.

    <note markdown=“1”> Deleting a job execution which is “IN_PROGRESS”, will cause the device to be unable to access job information or update the job execution status. Use caution and ensure that the device is able to recover to a valid state.

    </note>

Returns:

  • (Struct) —

    Returns an empty response.



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

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

#delete_ota_update(params = {}) ⇒ Struct

Delete an OTA update.

Examples:

Request syntax with placeholder values


resp = client.delete_ota_update({
  ota_update_id: "OTAUpdateId", # required
  delete_stream: false,
  force_delete_aws_job: false,
})

Parameters:

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

    ({})

Options Hash (params):

  • :ota_update_id (required, String) —

    The OTA update ID to delete.

  • :delete_stream (Boolean) —

    Specifies if the stream associated with an OTA update should be deleted when the OTA update is deleted.

  • :force_delete_aws_job (Boolean) —

    Specifies if the AWS Job associated with the OTA update should be deleted with the OTA update is deleted.

Returns:

  • (Struct) —

    Returns an empty response.



2156
2157
2158
2159
 
# File 'lib/aws-sdk-iot/client.rb', line 2156

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

#delete_policy(params = {}) ⇒ Struct

Deletes the specified policy.

A policy cannot be deleted if it has non-default versions or it is attached to any certificate.

To delete a policy, use the DeletePolicyVersion API to delete all non-default versions of the policy; use the DetachPrincipalPolicy API to detach the policy from any certificate; and then use the DeletePolicy API to delete the policy.

When a policy is deleted using DeletePolicy, its default version is deleted with it.

Examples:

Request syntax with placeholder values


resp = client.delete_policy({
  policy_name: "PolicyName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The name of the policy to delete.

Returns:

  • (Struct) —

    Returns an empty response.



2187
2188
2189
2190
 
# File 'lib/aws-sdk-iot/client.rb', line 2187

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 of the specified policy. You cannot delete the default version of a policy using this API. To delete the default version of a policy, use DeletePolicy. To find out which version of a policy is marked as the default version, use ListPolicyVersions.

Examples:

Request syntax with placeholder values


resp = client.delete_policy_version({
  policy_name: "PolicyName", # required
  policy_version_id: "PolicyVersionId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The name of the policy.

  • :policy_version_id (required, String) —

    The policy version ID.

Returns:

  • (Struct) —

    Returns an empty response.



2215
2216
2217
2218
 
# File 'lib/aws-sdk-iot/client.rb', line 2215

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

#delete_registration_code(params = {}) ⇒ Struct

Deletes a CA certificate registration code.

Parameters:

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

    ({})

Returns:

  • (Struct) —

    Returns an empty response.



2226
2227
2228
2229
 
# File 'lib/aws-sdk-iot/client.rb', line 2226

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

#delete_role_alias(params = {}) ⇒ Struct

Deletes a role alias

Examples:

Request syntax with placeholder values


resp = client.delete_role_alias({
  role_alias: "RoleAlias", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :role_alias (required, String) —

    The role alias to delete.

Returns:

  • (Struct) —

    Returns an empty response.



2246
2247
2248
2249
 
# File 'lib/aws-sdk-iot/client.rb', line 2246

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

#delete_scheduled_audit(params = {}) ⇒ Struct

Deletes a scheduled audit.

Examples:

Request syntax with placeholder values


resp = client.delete_scheduled_audit({
  scheduled_audit_name: "ScheduledAuditName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :scheduled_audit_name (required, String) —

    The name of the scheduled audit you want to delete.

Returns:

  • (Struct) —

    Returns an empty response.



2266
2267
2268
2269
 
# File 'lib/aws-sdk-iot/client.rb', line 2266

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

#delete_security_profile(params = {}) ⇒ Struct

Deletes a Device Defender security profile.

Examples:

Request syntax with placeholder values


resp = client.delete_security_profile({
  security_profile_name: "SecurityProfileName", # required
  expected_version: 1,
})

Parameters:

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

    ({})

Options Hash (params):

  • :security_profile_name (required, String) —

    The name of the security profile to be deleted.

  • :expected_version (Integer) —

    The expected version of the security profile. A new version is generated whenever the security profile is updated. If you specify a value that is different than the actual version, a ‘VersionConflictException` is thrown.

Returns:

  • (Struct) —

    Returns an empty response.



2293
2294
2295
2296
 
# File 'lib/aws-sdk-iot/client.rb', line 2293

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

#delete_stream(params = {}) ⇒ Struct

Deletes a stream.

Examples:

Request syntax with placeholder values


resp = client.delete_stream({
  stream_id: "StreamId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :stream_id (required, String) —

    The stream ID.

Returns:

  • (Struct) —

    Returns an empty response.



2313
2314
2315
2316
 
# File 'lib/aws-sdk-iot/client.rb', line 2313

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

#delete_thing(params = {}) ⇒ Struct

Deletes the specified thing. Returns successfully with no error if the deletion is successful or you specify a thing that doesn’t exist.

Examples:

Request syntax with placeholder values


resp = client.delete_thing({
  thing_name: "ThingName", # required
  expected_version: 1,
})

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (required, String) —

    The name of the thing to delete.

  • :expected_version (Integer) —

    The expected version of the thing record in the registry. If the version of the record in the registry does not match the expected version specified in the request, the ‘DeleteThing` request is rejected with a `VersionConflictException`.

Returns:

  • (Struct) —

    Returns an empty response.



2341
2342
2343
2344
 
# File 'lib/aws-sdk-iot/client.rb', line 2341

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

#delete_thing_group(params = {}) ⇒ Struct

Deletes a thing group.

Examples:

Request syntax with placeholder values


resp = client.delete_thing_group({
  thing_group_name: "ThingGroupName", # required
  expected_version: 1,
})

Parameters:

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

    ({})

Options Hash (params):

  • :thing_group_name (required, String) —

    The name of the thing group to delete.

  • :expected_version (Integer) —

    The expected version of the thing group to delete.

Returns:

  • (Struct) —

    Returns an empty response.



2365
2366
2367
2368
 
# File 'lib/aws-sdk-iot/client.rb', line 2365

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

#delete_thing_type(params = {}) ⇒ Struct

Deletes the specified thing type. You cannot delete a thing type if it has things associated with it. To delete a thing type, first mark it as deprecated by calling DeprecateThingType, then remove any associated things by calling UpdateThing to change the thing type on any associated thing, and finally use DeleteThingType to delete the thing type.

Examples:

Request syntax with placeholder values


resp = client.delete_thing_type({
  thing_type_name: "ThingTypeName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :thing_type_name (required, String) —

    The name of the thing type.

Returns:

  • (Struct) —

    Returns an empty response.



2390
2391
2392
2393
 
# File 'lib/aws-sdk-iot/client.rb', line 2390

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

#delete_topic_rule(params = {}) ⇒ Struct

Deletes the rule.

Examples:

Request syntax with placeholder values


resp = client.delete_topic_rule({
  rule_name: "RuleName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :rule_name (required, String) —

    The name of the rule.

Returns:

  • (Struct) —

    Returns an empty response.



2410
2411
2412
2413
 
# File 'lib/aws-sdk-iot/client.rb', line 2410

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

#delete_v2_logging_level(params = {}) ⇒ Struct

Deletes a logging level.

Examples:

Request syntax with placeholder values


resp = client.delete_v2_logging_level({
  target_type: "DEFAULT", # required, accepts DEFAULT, THING_GROUP
  target_name: "LogTargetName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :target_type (required, String) —

    The type of resource for which you are configuring logging. Must be ‘THING_Group`.

  • :target_name (required, String) —

    The name of the resource for which you are configuring logging.

Returns:

  • (Struct) —

    Returns an empty response.



2435
2436
2437
2438
 
# File 'lib/aws-sdk-iot/client.rb', line 2435

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

#deprecate_thing_type(params = {}) ⇒ Struct

Deprecates a thing type. You can not associate new things with deprecated thing type.

Examples:

Request syntax with placeholder values


resp = client.deprecate_thing_type({
  thing_type_name: "ThingTypeName", # required
  undo_deprecate: false,
})

Parameters:

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

    ({})

Options Hash (params):

  • :thing_type_name (required, String) —

    The name of the thing type to deprecate.

  • :undo_deprecate (Boolean) —

    Whether to undeprecate a deprecated thing type. If true, the thing type will not be deprecated anymore and you can associate it with things.

Returns:

  • (Struct) —

    Returns an empty response.



2462
2463
2464
2465
 
# File 'lib/aws-sdk-iot/client.rb', line 2462

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

#describe_account_audit_configuration(params = {}) ⇒ Types::DescribeAccountAuditConfigurationResponse

Gets information about the Device Defender audit settings for this account. Settings include how audit notifications are sent and which audit checks are enabled or disabled.

Examples:

Response structure


resp.role_arn #=> String
resp.audit_notification_target_configurations #=> Hash
resp.audit_notification_target_configurations["AuditNotificationType"].target_arn #=> String
resp.audit_notification_target_configurations["AuditNotificationType"].role_arn #=> String
resp.audit_notification_target_configurations["AuditNotificationType"].enabled #=> Boolean
resp.audit_check_configurations #=> Hash
resp.audit_check_configurations["AuditCheckName"].enabled #=> Boolean

Parameters:

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

    ({})

Returns:



2489
2490
2491
2492
 
# File 'lib/aws-sdk-iot/client.rb', line 2489

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

#describe_audit_task(params = {}) ⇒ Types::DescribeAuditTaskResponse

Gets information about a Device Defender audit.

Examples:

Request syntax with placeholder values


resp = client.describe_audit_task({
  task_id: "AuditTaskId", # required
})

Response structure


resp.task_status #=> String, one of "IN_PROGRESS", "COMPLETED", "FAILED", "CANCELED"
resp.task_type #=> String, one of "ON_DEMAND_AUDIT_TASK", "SCHEDULED_AUDIT_TASK"
resp.task_start_time #=> Time
resp.task_statistics.total_checks #=> Integer
resp.task_statistics.in_progress_checks #=> Integer
resp.task_statistics.waiting_for_data_collection_checks #=> Integer
resp.task_statistics.compliant_checks #=> Integer
resp.task_statistics.non_compliant_checks #=> Integer
resp.task_statistics.failed_checks #=> Integer
resp.task_statistics.canceled_checks #=> Integer
resp.scheduled_audit_name #=> String
resp.audit_details #=> Hash
resp.audit_details["AuditCheckName"].check_run_status #=> String, one of "IN_PROGRESS", "WAITING_FOR_DATA_COLLECTION", "CANCELED", "COMPLETED_COMPLIANT", "COMPLETED_NON_COMPLIANT", "FAILED"
resp.audit_details["AuditCheckName"].check_compliant #=> Boolean
resp.audit_details["AuditCheckName"].total_resources_count #=> Integer
resp.audit_details["AuditCheckName"].non_compliant_resources_count #=> Integer
resp.audit_details["AuditCheckName"].error_code #=> String
resp.audit_details["AuditCheckName"].message #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :task_id (required, String) —

    The ID of the audit whose information you want to get.

Returns:



2537
2538
2539
2540
 
# File 'lib/aws-sdk-iot/client.rb', line 2537

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

#describe_authorizer(params = {}) ⇒ Types::DescribeAuthorizerResponse

Describes an authorizer.

Examples:

Request syntax with placeholder values


resp = client.describe_authorizer({
  authorizer_name: "AuthorizerName", # required
})

Response structure


resp.authorizer_description.authorizer_name #=> String
resp.authorizer_description.authorizer_arn #=> String
resp.authorizer_description.authorizer_function_arn #=> String
resp.authorizer_description.token_key_name #=> String
resp.authorizer_description.token_signing_public_keys #=> Hash
resp.authorizer_description.token_signing_public_keys["KeyName"] #=> String
resp.authorizer_description.status #=> String, one of "ACTIVE", "INACTIVE"
resp.authorizer_description.creation_date #=> Time
resp.authorizer_description.last_modified_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :authorizer_name (required, String) —

    The name of the authorizer to describe.

Returns:



2571
2572
2573
2574
 
# File 'lib/aws-sdk-iot/client.rb', line 2571

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

#describe_billing_group(params = {}) ⇒ Types::DescribeBillingGroupResponse

Returns information about a billing group.

Examples:

Request syntax with placeholder values


resp = client.describe_billing_group({
  billing_group_name: "BillingGroupName", # required
})

Response structure


resp.billing_group_name #=> String
resp.billing_group_id #=> String
resp.billing_group_arn #=> String
resp.version #=> Integer
resp.billing_group_properties.billing_group_description #=> String
resp.billing_group_metadata.creation_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :billing_group_name (required, String) —

    The name of the billing group.

Returns:



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

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

#describe_ca_certificate(params = {}) ⇒ Types::DescribeCACertificateResponse

Describes a registered CA certificate.

Examples:

Request syntax with placeholder values


resp = client.describe_ca_certificate({
  certificate_id: "CertificateId", # required
})

Response structure


resp.certificate_description.certificate_arn #=> String
resp.certificate_description.certificate_id #=> String
resp.certificate_description.status #=> String, one of "ACTIVE", "INACTIVE"
resp.certificate_description.certificate_pem #=> String
resp.certificate_description.owned_by #=> String
resp.certificate_description.creation_date #=> Time
resp.certificate_description.auto_registration_status #=> String, one of "ENABLE", "DISABLE"
resp.certificate_description.last_modified_date #=> Time
resp.certificate_description.customer_version #=> Integer
resp.certificate_description.generation_id #=> String
resp.certificate_description.validity.not_before #=> Time
resp.certificate_description.validity.not_after #=> Time
resp.registration_config.template_body #=> String
resp.registration_config.role_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_id (required, String) —

    The CA certificate identifier.

Returns:



2647
2648
2649
2650
 
# File 'lib/aws-sdk-iot/client.rb', line 2647

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

#describe_certificate(params = {}) ⇒ Types::DescribeCertificateResponse

Gets information about the specified certificate.

Examples:

Request syntax with placeholder values


resp = client.describe_certificate({
  certificate_id: "CertificateId", # required
})

Response structure


resp.certificate_description.certificate_arn #=> String
resp.certificate_description.certificate_id #=> String
resp.certificate_description.ca_certificate_id #=> String
resp.certificate_description.status #=> String, one of "ACTIVE", "INACTIVE", "REVOKED", "PENDING_TRANSFER", "REGISTER_INACTIVE", "PENDING_ACTIVATION"
resp.certificate_description.certificate_pem #=> String
resp.certificate_description.owned_by #=> String
resp.certificate_description.previous_owned_by #=> String
resp.certificate_description.creation_date #=> Time
resp.certificate_description.last_modified_date #=> Time
resp.certificate_description.customer_version #=> Integer
resp.certificate_description.transfer_data.transfer_message #=> String
resp.certificate_description.transfer_data.reject_reason #=> String
resp.certificate_description.transfer_data.transfer_date #=> Time
resp.certificate_description.transfer_data.accept_date #=> Time
resp.certificate_description.transfer_data.reject_date #=> Time
resp.certificate_description.generation_id #=> String
resp.certificate_description.validity.not_before #=> Time
resp.certificate_description.validity.not_after #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_id (required, String) —

    The ID of the certificate. (The last part of the certificate ARN contains the certificate ID.)

Returns:



2691
2692
2693
2694
 
# File 'lib/aws-sdk-iot/client.rb', line 2691

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

#describe_default_authorizer(params = {}) ⇒ Types::DescribeDefaultAuthorizerResponse

Describes the default authorizer.

Examples:

Response structure


resp.authorizer_description.authorizer_name #=> String
resp.authorizer_description.authorizer_arn #=> String
resp.authorizer_description.authorizer_function_arn #=> String
resp.authorizer_description.token_key_name #=> String
resp.authorizer_description.token_signing_public_keys #=> Hash
resp.authorizer_description.token_signing_public_keys["KeyName"] #=> String
resp.authorizer_description.status #=> String, one of "ACTIVE", "INACTIVE"
resp.authorizer_description.creation_date #=> Time
resp.authorizer_description.last_modified_date #=> Time

Parameters:

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

    ({})

Returns:



2716
2717
2718
2719
 
# File 'lib/aws-sdk-iot/client.rb', line 2716

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

#describe_endpoint(params = {}) ⇒ Types::DescribeEndpointResponse

Returns a unique endpoint specific to the AWS account making the call.

Examples:

Request syntax with placeholder values


resp = client.describe_endpoint({
  endpoint_type: "EndpointType",
})

Response structure


resp.endpoint_address #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :endpoint_type (String) —

    The endpoint type. Valid endpoint types include:

    • ‘iot:Data` - Returns a VeriSign signed data endpoint.

    ^ ^

    • ‘iot:Data-ATS` - Returns an ATS signed data endpoint.

    ^ ^

    • ‘iot:CredentialProvider` - Returns an AWS IoT credentials provider API endpoint.

    ^ ^

    • ‘iot:Jobs` - Returns an AWS IoT device management Jobs API endpoint.

    ^

Returns:



2762
2763
2764
2765
 
# File 'lib/aws-sdk-iot/client.rb', line 2762

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

#describe_event_configurations(params = {}) ⇒ Types::DescribeEventConfigurationsResponse

Describes event configurations.

Examples:

Response structure


resp.event_configurations #=> Hash
resp.event_configurations["EventType"].enabled #=> Boolean
resp.creation_date #=> Time
resp.last_modified_date #=> Time

Parameters:

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

    ({})

Returns:



2784
2785
2786
2787
 
# File 'lib/aws-sdk-iot/client.rb', line 2784

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

#describe_index(params = {}) ⇒ Types::DescribeIndexResponse

Describes a search index.

Examples:

Request syntax with placeholder values


resp = client.describe_index({
  index_name: "IndexName", # required
})

Response structure


resp.index_name #=> String
resp.index_status #=> String, one of "ACTIVE", "BUILDING", "REBUILDING"
resp.schema #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :index_name (required, String) —

    The index name.

Returns:



2814
2815
2816
2817
 
# File 'lib/aws-sdk-iot/client.rb', line 2814

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

#describe_job(params = {}) ⇒ Types::DescribeJobResponse

Describes a job.

Examples:

Request syntax with placeholder values


resp = client.describe_job({
  job_id: "JobId", # required
})

Response structure


resp.document_source #=> String
resp.job.job_arn #=> String
resp.job.job_id #=> String
resp.job.target_selection #=> String, one of "CONTINUOUS", "SNAPSHOT"
resp.job.status #=> String, one of "IN_PROGRESS", "CANCELED", "COMPLETED", "DELETION_IN_PROGRESS"
resp.job.force_canceled #=> Boolean
resp.job.reason_code #=> String
resp.job.comment #=> String
resp.job.targets #=> Array
resp.job.targets[0] #=> String
resp.job.description #=> String
resp.job.presigned_url_config.role_arn #=> String
resp.job.presigned_url_config.expires_in_sec #=> Integer
resp.job.job_executions_rollout_config.maximum_per_minute #=> Integer
resp.job.job_executions_rollout_config.exponential_rate.base_rate_per_minute #=> Integer
resp.job.job_executions_rollout_config.exponential_rate.increment_factor #=> Float
resp.job.job_executions_rollout_config.exponential_rate.rate_increase_criteria.number_of_notified_things #=> Integer
resp.job.job_executions_rollout_config.exponential_rate.rate_increase_criteria.number_of_succeeded_things #=> Integer
resp.job.abort_config.criteria_list #=> Array
resp.job.abort_config.criteria_list[0].failure_type #=> String, one of "FAILED", "REJECTED", "TIMED_OUT", "ALL"
resp.job.abort_config.criteria_list[0].action #=> String, one of "CANCEL"
resp.job.abort_config.criteria_list[0].threshold_percentage #=> Float
resp.job.abort_config.criteria_list[0].min_number_of_executed_things #=> Integer
resp.job.created_at #=> Time
resp.job.last_updated_at #=> Time
resp.job.completed_at #=> Time
resp.job.job_process_details.processing_targets #=> Array
resp.job.job_process_details.processing_targets[0] #=> String
resp.job.job_process_details.number_of_canceled_things #=> Integer
resp.job.job_process_details.number_of_succeeded_things #=> Integer
resp.job.job_process_details.number_of_failed_things #=> Integer
resp.job.job_process_details.number_of_rejected_things #=> Integer
resp.job.job_process_details.number_of_queued_things #=> Integer
resp.job.job_process_details.number_of_in_progress_things #=> Integer
resp.job.job_process_details.number_of_removed_things #=> Integer
resp.job.job_process_details.number_of_timed_out_things #=> Integer
resp.job.timeout_config.in_progress_timeout_in_minutes #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :job_id (required, String) —

    The unique identifier you assigned to this job when it was created.

Returns:



2877
2878
2879
2880
 
# File 'lib/aws-sdk-iot/client.rb', line 2877

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

#describe_job_execution(params = {}) ⇒ Types::DescribeJobExecutionResponse

Describes a job execution.

Examples:

Request syntax with placeholder values


resp = client.describe_job_execution({
  job_id: "JobId", # required
  thing_name: "ThingName", # required
  execution_number: 1,
})

Response structure


resp.execution.job_id #=> String
resp.execution.status #=> String, one of "QUEUED", "IN_PROGRESS", "SUCCEEDED", "FAILED", "TIMED_OUT", "REJECTED", "REMOVED", "CANCELED"
resp.execution.force_canceled #=> Boolean
resp.execution.status_details.details_map #=> Hash
resp.execution.status_details.details_map["DetailsKey"] #=> String
resp.execution.thing_arn #=> String
resp.execution.queued_at #=> Time
resp.execution.started_at #=> Time
resp.execution.last_updated_at #=> Time
resp.execution.execution_number #=> Integer
resp.execution.version_number #=> Integer
resp.execution.approximate_seconds_before_timed_out #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :job_id (required, String) —

    The unique identifier you assigned to this job when it was created.

  • :thing_name (required, String) —

    The name of the thing on which the job execution is running.

  • :execution_number (Integer) —

    A string (consisting of the digits “0” through “9” which is used to specify a particular job execution on a particular device.

Returns:



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

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

#describe_role_alias(params = {}) ⇒ Types::DescribeRoleAliasResponse

Describes a role alias.

Examples:

Request syntax with placeholder values


resp = client.describe_role_alias({
  role_alias: "RoleAlias", # required
})

Response structure


resp.role_alias_description.role_alias #=> String
resp.role_alias_description.role_alias_arn #=> String
resp.role_alias_description.role_arn #=> String
resp.role_alias_description.owner #=> String
resp.role_alias_description.credential_duration_seconds #=> Integer
resp.role_alias_description.creation_date #=> Time
resp.role_alias_description.last_modified_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :role_alias (required, String) —

    The role alias to describe.

Returns:



2955
2956
2957
2958
 
# File 'lib/aws-sdk-iot/client.rb', line 2955

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

#describe_scheduled_audit(params = {}) ⇒ Types::DescribeScheduledAuditResponse

Gets information about a scheduled audit.

Examples:

Request syntax with placeholder values


resp = client.describe_scheduled_audit({
  scheduled_audit_name: "ScheduledAuditName", # required
})

Response structure


resp.frequency #=> String, one of "DAILY", "WEEKLY", "BIWEEKLY", "MONTHLY"
resp.day_of_month #=> String
resp.day_of_week #=> String, one of "SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"
resp.target_check_names #=> Array
resp.target_check_names[0] #=> String
resp.scheduled_audit_name #=> String
resp.scheduled_audit_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :scheduled_audit_name (required, String) —

    The name of the scheduled audit whose information you want to get.

Returns:



2992
2993
2994
2995
 
# File 'lib/aws-sdk-iot/client.rb', line 2992

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

#describe_security_profile(params = {}) ⇒ Types::DescribeSecurityProfileResponse

Gets information about a Device Defender security profile.

Examples:

Request syntax with placeholder values


resp = client.describe_security_profile({
  security_profile_name: "SecurityProfileName", # required
})

Response structure


resp.security_profile_name #=> String
resp.security_profile_arn #=> String
resp.security_profile_description #=> String
resp.behaviors #=> Array
resp.behaviors[0].name #=> String
resp.behaviors[0].metric #=> String
resp.behaviors[0].criteria.comparison_operator #=> String, one of "less-than", "less-than-equals", "greater-than", "greater-than-equals", "in-cidr-set", "not-in-cidr-set", "in-port-set", "not-in-port-set"
resp.behaviors[0].criteria.value.count #=> Integer
resp.behaviors[0].criteria.value.cidrs #=> Array
resp.behaviors[0].criteria.value.cidrs[0] #=> String
resp.behaviors[0].criteria.value.ports #=> Array
resp.behaviors[0].criteria.value.ports[0] #=> Integer
resp.behaviors[0].criteria.duration_seconds #=> Integer
resp.alert_targets #=> Hash
resp.alert_targets["AlertTargetType"].alert_target_arn #=> String
resp.alert_targets["AlertTargetType"].role_arn #=> String
resp.version #=> Integer
resp.creation_date #=> Time
resp.last_modified_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :security_profile_name (required, String) —

    The name of the security profile whose information you want to get.

Returns:



3043
3044
3045
3046
 
# File 'lib/aws-sdk-iot/client.rb', line 3043

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

#describe_stream(params = {}) ⇒ Types::DescribeStreamResponse

Gets information about a stream.

Examples:

Request syntax with placeholder values


resp = client.describe_stream({
  stream_id: "StreamId", # required
})

Response structure


resp.stream_info.stream_id #=> String
resp.stream_info.stream_arn #=> String
resp.stream_info.stream_version #=> Integer
resp.stream_info.description #=> String
resp.stream_info.files #=> Array
resp.stream_info.files[0].file_id #=> Integer
resp.stream_info.files[0].s3_location.bucket #=> String
resp.stream_info.files[0].s3_location.key #=> String
resp.stream_info.files[0].s3_location.version #=> String
resp.stream_info.created_at #=> Time
resp.stream_info.last_updated_at #=> Time
resp.stream_info.role_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :stream_id (required, String) —

    The stream ID.

Returns:



3080
3081
3082
3083
 
# File 'lib/aws-sdk-iot/client.rb', line 3080

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

#describe_thing(params = {}) ⇒ Types::DescribeThingResponse

Gets information about the specified thing.

Examples:

Request syntax with placeholder values


resp = client.describe_thing({
  thing_name: "ThingName", # required
})

Response structure


resp.default_client_id #=> String
resp.thing_name #=> String
resp.thing_id #=> String
resp.thing_arn #=> String
resp.thing_type_name #=> String
resp.attributes #=> Hash
resp.attributes["AttributeName"] #=> <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
resp.version #=> Integer
resp.billing_group_name #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (required, String) —

    The name of the thing.

Returns:



3121
3122
3123
3124
 
# File 'lib/aws-sdk-iot/client.rb', line 3121

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

#describe_thing_group(params = {}) ⇒ Types::DescribeThingGroupResponse

Describe a thing group.

Examples:

Request syntax with placeholder values


resp = client.describe_thing_group({
  thing_group_name: "ThingGroupName", # required
})

Response structure


resp.thing_group_name #=> String
resp.thing_group_id #=> String
resp.thing_group_arn #=> String
resp.version #=> Integer
resp.thing_group_properties.thing_group_description #=> String
resp.thing_group_properties.attribute_payload.attributes #=> Hash
resp.thing_group_properties.attribute_payload.attributes["AttributeName"] #=> <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
resp.thing_group_properties.attribute_payload.merge #=> Boolean
resp.thing_group_metadata.parent_group_name #=> String
resp.thing_group_metadata.root_to_parent_thing_groups #=> Array
resp.thing_group_metadata.root_to_parent_thing_groups[0].group_name #=> String
resp.thing_group_metadata.root_to_parent_thing_groups[0].group_arn #=> String
resp.thing_group_metadata.creation_date #=> Time
resp.index_name #=> String
resp.query_string #=> String
resp.query_version #=> String
resp.status #=> String, one of "ACTIVE", "BUILDING", "REBUILDING"

Parameters:

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

    ({})

Options Hash (params):

  • :thing_group_name (required, String) —

    The name of the thing group.

Returns:



3172
3173
3174
3175
 
# File 'lib/aws-sdk-iot/client.rb', line 3172

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

#describe_thing_registration_task(params = {}) ⇒ Types::DescribeThingRegistrationTaskResponse

Describes a bulk thing provisioning task.

Examples:

Request syntax with placeholder values


resp = client.describe_thing_registration_task({
  task_id: "TaskId", # required
})

Response structure


resp.task_id #=> String
resp.creation_date #=> Time
resp.last_modified_date #=> Time
resp.template_body #=> String
resp.input_file_bucket #=> String
resp.input_file_key #=> String
resp.role_arn #=> String
resp.status #=> String, one of "InProgress", "Completed", "Failed", "Cancelled", "Cancelling"
resp.message #=> String
resp.success_count #=> Integer
resp.failure_count #=> Integer
resp.percentage_progress #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :task_id (required, String) —

    The task ID.

Returns:



3220
3221
3222
3223
 
# File 'lib/aws-sdk-iot/client.rb', line 3220

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

#describe_thing_type(params = {}) ⇒ Types::DescribeThingTypeResponse

Gets information about the specified thing type.

Examples:

Request syntax with placeholder values


resp = client.describe_thing_type({
  thing_type_name: "ThingTypeName", # required
})

Response structure


resp.thing_type_name #=> String
resp.thing_type_id #=> String
resp.thing_type_arn #=> String
resp.thing_type_properties.thing_type_description #=> String
resp.thing_type_properties.searchable_attributes #=> Array
resp.thing_type_properties.searchable_attributes[0] #=> String
resp.thing_type_metadata.deprecated #=> Boolean
resp.thing_type_metadata.deprecation_date #=> Time
resp.thing_type_metadata.creation_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :thing_type_name (required, String) —

    The name of the thing type.

Returns:



3258
3259
3260
3261
 
# File 'lib/aws-sdk-iot/client.rb', line 3258

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

#detach_policy(params = {}) ⇒ Struct

Detaches a policy from the specified target.

Examples:

Request syntax with placeholder values


resp = client.detach_policy({
  policy_name: "PolicyName", # required
  target: "PolicyTarget", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The policy to detach.

  • :target (required, String) —

    The target from which the policy will be detached.

Returns:

  • (Struct) —

    Returns an empty response.



3282
3283
3284
3285
 
# File 'lib/aws-sdk-iot/client.rb', line 3282

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

#detach_principal_policy(params = {}) ⇒ Struct

Removes the specified policy from the specified certificate.

Note: This API is deprecated. Please use DetachPolicy instead.

Examples:

Request syntax with placeholder values


resp = client.detach_principal_policy({
  policy_name: "PolicyName", # required
  principal: "Principal", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The name of the policy to detach.

  • :principal (required, String) —

    The principal.

    If the principal is a certificate, specify the certificate ARN. If the principal is an Amazon Cognito identity, specify the identity ID.

Returns:

  • (Struct) —

    Returns an empty response.



3311
3312
3313
3314
 
# File 'lib/aws-sdk-iot/client.rb', line 3311

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

#detach_security_profile(params = {}) ⇒ Struct

Disassociates a Device Defender security profile from a thing group or from this account.

Examples:

Request syntax with placeholder values


resp = client.detach_security_profile({
  security_profile_name: "SecurityProfileName", # required
  security_profile_target_arn: "SecurityProfileTargetArn", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :security_profile_name (required, String) —

    The security profile that is detached.

  • :security_profile_target_arn (required, String) —

    The ARN of the thing group from which the security profile is detached.

Returns:

  • (Struct) —

    Returns an empty response.



3337
3338
3339
3340
 
# File 'lib/aws-sdk-iot/client.rb', line 3337

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

#detach_thing_principal(params = {}) ⇒ Struct

Detaches the specified principal from the specified thing.

<note markdown=“1”> This call is asynchronous. It might take several seconds for the detachment to propagate.

</note>

Examples:

Request syntax with placeholder values


resp = client.detach_thing_principal({
  thing_name: "ThingName", # required
  principal: "Principal", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (required, String) —

    The name of the thing.

  • :principal (required, String) —

    If the principal is a certificate, this value must be ARN of the certificate. If the principal is an Amazon Cognito identity, this value must be the ID of the Amazon Cognito identity.

Returns:

  • (Struct) —

    Returns an empty response.



3368
3369
3370
3371
 
# File 'lib/aws-sdk-iot/client.rb', line 3368

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

#disable_topic_rule(params = {}) ⇒ Struct

Disables the rule.

Examples:

Request syntax with placeholder values


resp = client.disable_topic_rule({
  rule_name: "RuleName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :rule_name (required, String) —

    The name of the rule to disable.

Returns:

  • (Struct) —

    Returns an empty response.



3388
3389
3390
3391
 
# File 'lib/aws-sdk-iot/client.rb', line 3388

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

#enable_topic_rule(params = {}) ⇒ Struct

Enables the rule.

Examples:

Request syntax with placeholder values


resp = client.enable_topic_rule({
  rule_name: "RuleName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :rule_name (required, String) —

    The name of the topic rule to enable.

Returns:

  • (Struct) —

    Returns an empty response.



3408
3409
3410
3411
 
# File 'lib/aws-sdk-iot/client.rb', line 3408

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

#get_effective_policies(params = {}) ⇒ Types::GetEffectivePoliciesResponse

Gets a list of the policies that have an effect on the authorization behavior of the specified device when it connects to the AWS IoT device gateway.

Examples:

Request syntax with placeholder values


resp = client.get_effective_policies({
  principal: "Principal",
  cognito_identity_pool_id: "CognitoIdentityPoolId",
  thing_name: "ThingName",
})

Response structure


resp.effective_policies #=> Array
resp.effective_policies[0].policy_name #=> String
resp.effective_policies[0].policy_arn #=> String
resp.effective_policies[0].policy_document #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :principal (String) —

    The principal.

  • :cognito_identity_pool_id (String) —

    The Cognito identity pool ID.

  • :thing_name (String) —

    The thing name.

Returns:



3447
3448
3449
3450
 
# File 'lib/aws-sdk-iot/client.rb', line 3447

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

#get_indexing_configuration(params = {}) ⇒ Types::GetIndexingConfigurationResponse

Gets the search configuration.

Examples:

Response structure


resp.thing_indexing_configuration.thing_indexing_mode #=> String, one of "OFF", "REGISTRY", "REGISTRY_AND_SHADOW"
resp.thing_indexing_configuration.thing_connectivity_indexing_mode #=> String, one of "OFF", "STATUS"
resp.thing_group_indexing_configuration.thing_group_indexing_mode #=> String, one of "OFF", "ON"

Parameters:

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

    ({})

Returns:



3467
3468
3469
3470
 
# File 'lib/aws-sdk-iot/client.rb', line 3467

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

#get_job_document(params = {}) ⇒ Types::GetJobDocumentResponse

Gets a job document.

Examples:

Request syntax with placeholder values


resp = client.get_job_document({
  job_id: "JobId", # required
})

Response structure


resp.document #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :job_id (required, String) —

    The unique identifier you assigned to this job when it was created.

Returns:



3493
3494
3495
3496
 
# File 'lib/aws-sdk-iot/client.rb', line 3493

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

#get_logging_options(params = {}) ⇒ Types::GetLoggingOptionsResponse

Gets the logging options.

NOTE: use of this command is not recommended. Use ‘GetV2LoggingOptions` instead.

Examples:

Response structure


resp.role_arn #=> String
resp.log_level #=> String, one of "DEBUG", "INFO", "ERROR", "WARN", "DISABLED"

Parameters:

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

    ({})

Returns:



3515
3516
3517
3518
 
# File 'lib/aws-sdk-iot/client.rb', line 3515

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

#get_ota_update(params = {}) ⇒ Types::GetOTAUpdateResponse

Gets an OTA update.

Examples:

Request syntax with placeholder values


resp = client.get_ota_update({
  ota_update_id: "OTAUpdateId", # required
})

Response structure


resp.ota_update_info.ota_update_id #=> String
resp.ota_update_info.ota_update_arn #=> String
resp.ota_update_info.creation_date #=> Time
resp.ota_update_info.last_modified_date #=> Time
resp.ota_update_info.description #=> String
resp.ota_update_info.targets #=> Array
resp.ota_update_info.targets[0] #=> String
resp.ota_update_info.aws_job_executions_rollout_config.maximum_per_minute #=> Integer
resp.ota_update_info.target_selection #=> String, one of "CONTINUOUS", "SNAPSHOT"
resp.ota_update_info.ota_update_files #=> Array
resp.ota_update_info.ota_update_files[0].file_name #=> String
resp.ota_update_info.ota_update_files[0].file_version #=> String
resp.ota_update_info.ota_update_files[0].file_location.stream.stream_id #=> String
resp.ota_update_info.ota_update_files[0].file_location.stream.file_id #=> Integer
resp.ota_update_info.ota_update_files[0].file_location.s3_location.bucket #=> String
resp.ota_update_info.ota_update_files[0].file_location.s3_location.key #=> String
resp.ota_update_info.ota_update_files[0].file_location.s3_location.version #=> String
resp.ota_update_info.ota_update_files[0].code_signing.aws_signer_job_id #=> String
resp.ota_update_info.ota_update_files[0].code_signing.start_signing_job_parameter.signing_profile_parameter.certificate_arn #=> String
resp.ota_update_info.ota_update_files[0].code_signing.start_signing_job_parameter.signing_profile_parameter.platform #=> String
resp.ota_update_info.ota_update_files[0].code_signing.start_signing_job_parameter.signing_profile_parameter.certificate_path_on_device #=> String
resp.ota_update_info.ota_update_files[0].code_signing.start_signing_job_parameter.signing_profile_name #=> String
resp.ota_update_info.ota_update_files[0].code_signing.start_signing_job_parameter.destination.s3_destination.bucket #=> String
resp.ota_update_info.ota_update_files[0].code_signing.start_signing_job_parameter.destination.s3_destination.prefix #=> String
resp.ota_update_info.ota_update_files[0].code_signing.custom_code_signing.signature.inline_document #=> String
resp.ota_update_info.ota_update_files[0].code_signing.custom_code_signing.certificate_chain.certificate_name #=> String
resp.ota_update_info.ota_update_files[0].code_signing.custom_code_signing.certificate_chain.inline_document #=> String
resp.ota_update_info.ota_update_files[0].code_signing.custom_code_signing.hash_algorithm #=> String
resp.ota_update_info.ota_update_files[0].code_signing.custom_code_signing.signature_algorithm #=> String
resp.ota_update_info.ota_update_files[0].attributes #=> Hash
resp.ota_update_info.ota_update_files[0].attributes["AttributeKey"] #=> String
resp.ota_update_info.ota_update_status #=> String, one of "CREATE_PENDING", "CREATE_IN_PROGRESS", "CREATE_COMPLETE", "CREATE_FAILED"
resp.ota_update_info.aws_iot_job_id #=> String
resp.ota_update_info.aws_iot_job_arn #=> String
resp.ota_update_info.error_info.code #=> String
resp.ota_update_info.error_info.message #=> String
resp.ota_update_info.additional_parameters #=> Hash
resp.ota_update_info.additional_parameters["AttributeKey"] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :ota_update_id (required, String) —

    The OTA update ID.

Returns:



3578
3579
3580
3581
 
# File 'lib/aws-sdk-iot/client.rb', line 3578

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

#get_policy(params = {}) ⇒ Types::GetPolicyResponse

Gets information about the specified policy with the policy document of the default version.

Examples:

Request syntax with placeholder values


resp = client.get_policy({
  policy_name: "PolicyName", # required
})

Response structure


resp.policy_name #=> String
resp.policy_arn #=> String
resp.policy_document #=> String
resp.default_version_id #=> String
resp.creation_date #=> Time
resp.last_modified_date #=> Time
resp.generation_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The name of the policy.

Returns:



3617
3618
3619
3620
 
# File 'lib/aws-sdk-iot/client.rb', line 3617

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

#get_policy_version(params = {}) ⇒ Types::GetPolicyVersionResponse

Gets information about the specified policy version.

Examples:

Request syntax with placeholder values


resp = client.get_policy_version({
  policy_name: "PolicyName", # required
  policy_version_id: "PolicyVersionId", # required
})

Response structure


resp.policy_arn #=> String
resp.policy_name #=> String
resp.policy_document #=> String
resp.policy_version_id #=> String
resp.is_default_version #=> Boolean
resp.creation_date #=> Time
resp.last_modified_date #=> Time
resp.generation_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The name of the policy.

  • :policy_version_id (required, String) —

    The policy version ID.

Returns:



3661
3662
3663
3664
 
# File 'lib/aws-sdk-iot/client.rb', line 3661

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

#get_registration_code(params = {}) ⇒ Types::GetRegistrationCodeResponse

Gets a registration code used to register a CA certificate with AWS IoT.

Examples:

Response structure


resp.registration_code #=> String

Parameters:

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

    ({})

Returns:



3679
3680
3681
3682
 
# File 'lib/aws-sdk-iot/client.rb', line 3679

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

#get_topic_rule(params = {}) ⇒ Types::GetTopicRuleResponse

Gets information about the rule.

Examples:

Request syntax with placeholder values


resp = client.get_topic_rule({
  rule_name: "RuleName", # required
})

Response structure


resp.rule_arn #=> String
resp.rule.rule_name #=> String
resp.rule.sql #=> String
resp.rule.description #=> String
resp.rule.created_at #=> Time
resp.rule.actions #=> Array
resp.rule.actions[0].dynamo_db.table_name #=> String
resp.rule.actions[0].dynamo_db.role_arn #=> String
resp.rule.actions[0].dynamo_db.operation #=> String
resp.rule.actions[0].dynamo_db.hash_key_field #=> String
resp.rule.actions[0].dynamo_db.hash_key_value #=> String
resp.rule.actions[0].dynamo_db.hash_key_type #=> String, one of "STRING", "NUMBER"
resp.rule.actions[0].dynamo_db.range_key_field #=> String
resp.rule.actions[0].dynamo_db.range_key_value #=> String
resp.rule.actions[0].dynamo_db.range_key_type #=> String, one of "STRING", "NUMBER"
resp.rule.actions[0].dynamo_db.payload_field #=> String
resp.rule.actions[0].dynamo_d_bv_2.role_arn #=> String
resp.rule.actions[0].dynamo_d_bv_2.put_item.table_name #=> String
resp.rule.actions[0].lambda.function_arn #=> String
resp.rule.actions[0].sns.target_arn #=> String
resp.rule.actions[0].sns.role_arn #=> String
resp.rule.actions[0].sns.message_format #=> String, one of "RAW", "JSON"
resp.rule.actions[0].sqs.role_arn #=> String
resp.rule.actions[0].sqs.queue_url #=> String
resp.rule.actions[0].sqs.use_base_64 #=> Boolean
resp.rule.actions[0].kinesis.role_arn #=> String
resp.rule.actions[0].kinesis.stream_name #=> String
resp.rule.actions[0].kinesis.partition_key #=> String
resp.rule.actions[0].republish.role_arn #=> String
resp.rule.actions[0].republish.topic #=> String
resp.rule.actions[0].s3.role_arn #=> String
resp.rule.actions[0].s3.bucket_name #=> String
resp.rule.actions[0].s3.key #=> String
resp.rule.actions[0].s3.canned_acl #=> String, one of "private", "public-read", "public-read-write", "aws-exec-read", "authenticated-read", "bucket-owner-read", "bucket-owner-full-control", "log-delivery-write"
resp.rule.actions[0].firehose.role_arn #=> String
resp.rule.actions[0].firehose.delivery_stream_name #=> String
resp.rule.actions[0].firehose.separator #=> String
resp.rule.actions[0].cloudwatch_metric.role_arn #=> String
resp.rule.actions[0].cloudwatch_metric.metric_namespace #=> String
resp.rule.actions[0].cloudwatch_metric.metric_name #=> String
resp.rule.actions[0].cloudwatch_metric.metric_value #=> String
resp.rule.actions[0].cloudwatch_metric.metric_unit #=> String
resp.rule.actions[0].cloudwatch_metric.metric_timestamp #=> String
resp.rule.actions[0].cloudwatch_alarm.role_arn #=> String
resp.rule.actions[0].cloudwatch_alarm.alarm_name #=> String
resp.rule.actions[0].cloudwatch_alarm.state_reason #=> String
resp.rule.actions[0].cloudwatch_alarm.state_value #=> String
resp.rule.actions[0].elasticsearch.role_arn #=> String
resp.rule.actions[0].elasticsearch.endpoint #=> String
resp.rule.actions[0].elasticsearch.index #=> String
resp.rule.actions[0].elasticsearch.type #=> String
resp.rule.actions[0].elasticsearch.id #=> String
resp.rule.actions[0].salesforce.token #=> String
resp.rule.actions[0].salesforce.url #=> String
resp.rule.actions[0].iot_analytics.channel_arn #=> String
resp.rule.actions[0].iot_analytics.channel_name #=> String
resp.rule.actions[0].iot_analytics.role_arn #=> String
resp.rule.actions[0].iot_events.input_name #=> String
resp.rule.actions[0].iot_events.message_id #=> String
resp.rule.actions[0].iot_events.role_arn #=> String
resp.rule.actions[0].step_functions.execution_name_prefix #=> String
resp.rule.actions[0].step_functions.state_machine_name #=> String
resp.rule.actions[0].step_functions.role_arn #=> String
resp.rule.rule_disabled #=> Boolean
resp.rule.aws_iot_sql_version #=> String
resp.rule.error_action.dynamo_db.table_name #=> String
resp.rule.error_action.dynamo_db.role_arn #=> String
resp.rule.error_action.dynamo_db.operation #=> String
resp.rule.error_action.dynamo_db.hash_key_field #=> String
resp.rule.error_action.dynamo_db.hash_key_value #=> String
resp.rule.error_action.dynamo_db.hash_key_type #=> String, one of "STRING", "NUMBER"
resp.rule.error_action.dynamo_db.range_key_field #=> String
resp.rule.error_action.dynamo_db.range_key_value #=> String
resp.rule.error_action.dynamo_db.range_key_type #=> String, one of "STRING", "NUMBER"
resp.rule.error_action.dynamo_db.payload_field #=> String
resp.rule.error_action.dynamo_d_bv_2.role_arn #=> String
resp.rule.error_action.dynamo_d_bv_2.put_item.table_name #=> String
resp.rule.error_action.lambda.function_arn #=> String
resp.rule.error_action.sns.target_arn #=> String
resp.rule.error_action.sns.role_arn #=> String
resp.rule.error_action.sns.message_format #=> String, one of "RAW", "JSON"
resp.rule.error_action.sqs.role_arn #=> String
resp.rule.error_action.sqs.queue_url #=> String
resp.rule.error_action.sqs.use_base_64 #=> Boolean
resp.rule.error_action.kinesis.role_arn #=> String
resp.rule.error_action.kinesis.stream_name #=> String
resp.rule.error_action.kinesis.partition_key #=> String
resp.rule.error_action.republish.role_arn #=> String
resp.rule.error_action.republish.topic #=> String
resp.rule.error_action.s3.role_arn #=> String
resp.rule.error_action.s3.bucket_name #=> String
resp.rule.error_action.s3.key #=> String
resp.rule.error_action.s3.canned_acl #=> String, one of "private", "public-read", "public-read-write", "aws-exec-read", "authenticated-read", "bucket-owner-read", "bucket-owner-full-control", "log-delivery-write"
resp.rule.error_action.firehose.role_arn #=> String
resp.rule.error_action.firehose.delivery_stream_name #=> String
resp.rule.error_action.firehose.separator #=> String
resp.rule.error_action.cloudwatch_metric.role_arn #=> String
resp.rule.error_action.cloudwatch_metric.metric_namespace #=> String
resp.rule.error_action.cloudwatch_metric.metric_name #=> String
resp.rule.error_action.cloudwatch_metric.metric_value #=> String
resp.rule.error_action.cloudwatch_metric.metric_unit #=> String
resp.rule.error_action.cloudwatch_metric.metric_timestamp #=> String
resp.rule.error_action.cloudwatch_alarm.role_arn #=> String
resp.rule.error_action.cloudwatch_alarm.alarm_name #=> String
resp.rule.error_action.cloudwatch_alarm.state_reason #=> String
resp.rule.error_action.cloudwatch_alarm.state_value #=> String
resp.rule.error_action.elasticsearch.role_arn #=> String
resp.rule.error_action.elasticsearch.endpoint #=> String
resp.rule.error_action.elasticsearch.index #=> String
resp.rule.error_action.elasticsearch.type #=> String
resp.rule.error_action.elasticsearch.id #=> String
resp.rule.error_action.salesforce.token #=> String
resp.rule.error_action.salesforce.url #=> String
resp.rule.error_action.iot_analytics.channel_arn #=> String
resp.rule.error_action.iot_analytics.channel_name #=> String
resp.rule.error_action.iot_analytics.role_arn #=> String
resp.rule.error_action.iot_events.input_name #=> String
resp.rule.error_action.iot_events.message_id #=> String
resp.rule.error_action.iot_events.role_arn #=> String
resp.rule.error_action.step_functions.execution_name_prefix #=> String
resp.rule.error_action.step_functions.state_machine_name #=> String
resp.rule.error_action.step_functions.role_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :rule_name (required, String) —

    The name of the rule.

Returns:



3827
3828
3829
3830
 
# File 'lib/aws-sdk-iot/client.rb', line 3827

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

#get_v2_logging_options(params = {}) ⇒ Types::GetV2LoggingOptionsResponse

Gets the fine grained logging options.

Examples:

Response structure


resp.role_arn #=> String
resp.default_log_level #=> String, one of "DEBUG", "INFO", "ERROR", "WARN", "DISABLED"
resp.disable_all_logs #=> Boolean

Parameters:

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

    ({})

Returns:



3848
3849
3850
3851
 
# File 'lib/aws-sdk-iot/client.rb', line 3848

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

#list_active_violations(params = {}) ⇒ Types::ListActiveViolationsResponse

Lists the active violations for a given Device Defender security profile.

Examples:

Request syntax with placeholder values


resp = client.list_active_violations({
  thing_name: "ThingName",
  security_profile_name: "SecurityProfileName",
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.active_violations #=> Array
resp.active_violations[0].violation_id #=> String
resp.active_violations[0].thing_name #=> String
resp.active_violations[0].security_profile_name #=> String
resp.active_violations[0].behavior.name #=> String
resp.active_violations[0].behavior.metric #=> String
resp.active_violations[0].behavior.criteria.comparison_operator #=> String, one of "less-than", "less-than-equals", "greater-than", "greater-than-equals", "in-cidr-set", "not-in-cidr-set", "in-port-set", "not-in-port-set"
resp.active_violations[0].behavior.criteria.value.count #=> Integer
resp.active_violations[0].behavior.criteria.value.cidrs #=> Array
resp.active_violations[0].behavior.criteria.value.cidrs[0] #=> String
resp.active_violations[0].behavior.criteria.value.ports #=> Array
resp.active_violations[0].behavior.criteria.value.ports[0] #=> Integer
resp.active_violations[0].behavior.criteria.duration_seconds #=> Integer
resp.active_violations[0].last_violation_value.count #=> Integer
resp.active_violations[0].last_violation_value.cidrs #=> Array
resp.active_violations[0].last_violation_value.cidrs[0] #=> String
resp.active_violations[0].last_violation_value.ports #=> Array
resp.active_violations[0].last_violation_value.ports[0] #=> Integer
resp.active_violations[0].last_violation_time #=> Time
resp.active_violations[0].violation_start_time #=> Time
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (String) —

    The name of the thing whose active violations are listed.

  • :security_profile_name (String) —

    The name of the Device Defender security profile for which violations are listed.

  • :next_token (String) —

    The token for the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return at one time.

Returns:



3909
3910
3911
3912
 
# File 'lib/aws-sdk-iot/client.rb', line 3909

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

#list_attached_policies(params = {}) ⇒ Types::ListAttachedPoliciesResponse

Lists the policies attached to the specified thing group.

Examples:

Request syntax with placeholder values


resp = client.list_attached_policies({
  target: "PolicyTarget", # required
  recursive: false,
  marker: "Marker",
  page_size: 1,
})

Response structure


resp.policies #=> Array
resp.policies[0].policy_name #=> String
resp.policies[0].policy_arn #=> String
resp.next_marker #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :target (required, String) —

    The group for which the policies will be listed.

  • :recursive (Boolean) —

    When true, recursively list attached policies.

  • :marker (String) —

    The token to retrieve the next set of results.

  • :page_size (Integer) —

    The maximum number of results to be returned per request.

Returns:



3951
3952
3953
3954
 
# File 'lib/aws-sdk-iot/client.rb', line 3951

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

#list_audit_findings(params = {}) ⇒ Types::ListAuditFindingsResponse

Lists the findings (results) of a Device Defender audit or of the audits performed during a specified time period. (Findings are retained for 180 days.)

Examples:

Request syntax with placeholder values


resp = client.list_audit_findings({
  task_id: "AuditTaskId",
  check_name: "AuditCheckName",
  resource_identifier: {
    device_certificate_id: "CertificateId",
    ca_certificate_id: "CertificateId",
    cognito_identity_pool_id: "CognitoIdentityPoolId",
    client_id: "ClientId",
    policy_version_identifier: {
      policy_name: "PolicyName",
      policy_version_id: "PolicyVersionId",
    },
    account: "AwsAccountId",
  },
  max_results: 1,
  next_token: "NextToken",
  start_time: Time.now,
  end_time: Time.now,
})

Response structure


resp.findings #=> Array
resp.findings[0].task_id #=> String
resp.findings[0].check_name #=> String
resp.findings[0].task_start_time #=> Time
resp.findings[0].finding_time #=> Time
resp.findings[0].severity #=> String, one of "CRITICAL", "HIGH", "MEDIUM", "LOW"
resp.findings[0].non_compliant_resource.resource_type #=> String, one of "DEVICE_CERTIFICATE", "CA_CERTIFICATE", "IOT_POLICY", "COGNITO_IDENTITY_POOL", "CLIENT_ID", "ACCOUNT_SETTINGS"
resp.findings[0].non_compliant_resource.resource_identifier.device_certificate_id #=> String
resp.findings[0].non_compliant_resource.resource_identifier.ca_certificate_id #=> String
resp.findings[0].non_compliant_resource.resource_identifier.cognito_identity_pool_id #=> String
resp.findings[0].non_compliant_resource.resource_identifier.client_id #=> String
resp.findings[0].non_compliant_resource.resource_identifier.policy_version_identifier.policy_name #=> String
resp.findings[0].non_compliant_resource.resource_identifier.policy_version_identifier.policy_version_id #=> String
resp.findings[0].non_compliant_resource.resource_identifier. #=> String
resp.findings[0].non_compliant_resource.additional_info #=> Hash
resp.findings[0].non_compliant_resource.additional_info["String"] #=> String
resp.findings[0].related_resources #=> Array
resp.findings[0].related_resources[0].resource_type #=> String, one of "DEVICE_CERTIFICATE", "CA_CERTIFICATE", "IOT_POLICY", "COGNITO_IDENTITY_POOL", "CLIENT_ID", "ACCOUNT_SETTINGS"
resp.findings[0].related_resources[0].resource_identifier.device_certificate_id #=> String
resp.findings[0].related_resources[0].resource_identifier.ca_certificate_id #=> String
resp.findings[0].related_resources[0].resource_identifier.cognito_identity_pool_id #=> String
resp.findings[0].related_resources[0].resource_identifier.client_id #=> String
resp.findings[0].related_resources[0].resource_identifier.policy_version_identifier.policy_name #=> String
resp.findings[0].related_resources[0].resource_identifier.policy_version_identifier.policy_version_id #=> String
resp.findings[0].related_resources[0].resource_identifier. #=> String
resp.findings[0].related_resources[0].additional_info #=> Hash
resp.findings[0].related_resources[0].additional_info["String"] #=> String
resp.findings[0].reason_for_non_compliance #=> String
resp.findings[0].reason_for_non_compliance_code #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :task_id (String) —

    A filter to limit results to the audit with the specified ID. You must specify either the taskId or the startTime and endTime, but not both.

  • :check_name (String) —

    A filter to limit results to the findings for the specified audit check.

  • :resource_identifier (Types::ResourceIdentifier) —

    Information identifying the non-compliant resource.

  • :max_results (Integer) —

    The maximum number of results to return at one time. The default is 25.

  • :next_token (String) —

    The token for the next set of results.

  • :start_time (Time, DateTime, Date, Integer, String) —

    A filter to limit results to those found after the specified time. You must specify either the startTime and endTime or the taskId, but not both.

  • :end_time (Time, DateTime, Date, Integer, String) —

    A filter to limit results to those found before the specified time. You must specify either the startTime and endTime or the taskId, but not both.

Returns:



4050
4051
4052
4053
 
# File 'lib/aws-sdk-iot/client.rb', line 4050

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

#list_audit_tasks(params = {}) ⇒ Types::ListAuditTasksResponse

Lists the Device Defender audits that have been performed during a given time period.

Examples:

Request syntax with placeholder values


resp = client.list_audit_tasks({
  start_time: Time.now, # required
  end_time: Time.now, # required
  task_type: "ON_DEMAND_AUDIT_TASK", # accepts ON_DEMAND_AUDIT_TASK, SCHEDULED_AUDIT_TASK
  task_status: "IN_PROGRESS", # accepts IN_PROGRESS, COMPLETED, FAILED, CANCELED
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.tasks #=> Array
resp.tasks[0].task_id #=> String
resp.tasks[0].task_status #=> String, one of "IN_PROGRESS", "COMPLETED", "FAILED", "CANCELED"
resp.tasks[0].task_type #=> String, one of "ON_DEMAND_AUDIT_TASK", "SCHEDULED_AUDIT_TASK"
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :start_time (required, Time, DateTime, Date, Integer, String) —

    The beginning of the time period. Note that audit information is retained for a limited time (180 days). Requesting a start time prior to what is retained results in an “InvalidRequestException”.

  • :end_time (required, Time, DateTime, Date, Integer, String) —

    The end of the time period.

  • :task_type (String) —

    A filter to limit the output to the specified type of audit: can be one of “ON_DEMAND_AUDIT_TASK” or “SCHEDULED_AUDITTASK”.

  • :task_status (String) —

    A filter to limit the output to audits with the specified completion status: can be one of “IN_PROGRESS”, “COMPLETED”, “FAILED” or “CANCELED”.

  • :next_token (String) —

    The token for the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return at one time. The default is 25.

Returns:



4108
4109
4110
4111
 
# File 'lib/aws-sdk-iot/client.rb', line 4108

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

#list_authorizers(params = {}) ⇒ Types::ListAuthorizersResponse

Lists the authorizers registered in your account.

Examples:

Request syntax with placeholder values


resp = client.list_authorizers({
  page_size: 1,
  marker: "Marker",
  ascending_order: false,
  status: "ACTIVE", # accepts ACTIVE, INACTIVE
})

Response structure


resp.authorizers #=> Array
resp.authorizers[0].authorizer_name #=> String
resp.authorizers[0].authorizer_arn #=> String
resp.next_marker #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :page_size (Integer) —

    The maximum number of results to return at one time.

  • :marker (String) —

    A marker used to get the next set of results.

  • :ascending_order (Boolean) —

    Return the list of authorizers in ascending alphabetical order.

  • :status (String) —

    The status of the list authorizers request.

Returns:



4150
4151
4152
4153
 
# File 'lib/aws-sdk-iot/client.rb', line 4150

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

#list_billing_groups(params = {}) ⇒ Types::ListBillingGroupsResponse

Lists the billing groups you have created.

Examples:

Request syntax with placeholder values


resp = client.list_billing_groups({
  next_token: "NextToken",
  max_results: 1,
  name_prefix_filter: "BillingGroupName",
})

Response structure


resp.billing_groups #=> Array
resp.billing_groups[0].group_name #=> String
resp.billing_groups[0].group_arn #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :next_token (String) —

    The token to retrieve the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return per request.

  • :name_prefix_filter (String) —

    Limit the results to billing groups whose names have the given prefix.

Returns:



4188
4189
4190
4191
 
# File 'lib/aws-sdk-iot/client.rb', line 4188

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

#list_ca_certificates(params = {}) ⇒ Types::ListCACertificatesResponse

Lists the CA certificates registered for your AWS account.

The results are paginated with a default page size of 25. You can use the returned marker to retrieve additional results.

Examples:

Request syntax with placeholder values


resp = client.list_ca_certificates({
  page_size: 1,
  marker: "Marker",
  ascending_order: false,
})

Response structure


resp.certificates #=> Array
resp.certificates[0].certificate_arn #=> String
resp.certificates[0].certificate_id #=> String
resp.certificates[0].status #=> String, one of "ACTIVE", "INACTIVE"
resp.certificates[0].creation_date #=> Time
resp.next_marker #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :page_size (Integer) —

    The result page size.

  • :marker (String) —

    The marker for the next set of results.

  • :ascending_order (Boolean) —

    Determines the order of the results.

Returns:



4231
4232
4233
4234
 
# File 'lib/aws-sdk-iot/client.rb', line 4231

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

#list_certificates(params = {}) ⇒ Types::ListCertificatesResponse

Lists the certificates registered in your AWS account.

The results are paginated with a default page size of 25. You can use the returned marker to retrieve additional results.

Examples:

Request syntax with placeholder values


resp = client.list_certificates({
  page_size: 1,
  marker: "Marker",
  ascending_order: false,
})

Response structure


resp.certificates #=> Array
resp.certificates[0].certificate_arn #=> String
resp.certificates[0].certificate_id #=> String
resp.certificates[0].status #=> String, one of "ACTIVE", "INACTIVE", "REVOKED", "PENDING_TRANSFER", "REGISTER_INACTIVE", "PENDING_ACTIVATION"
resp.certificates[0].creation_date #=> Time
resp.next_marker #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :page_size (Integer) —

    The result page size.

  • :marker (String) —

    The marker for the next set of results.

  • :ascending_order (Boolean) —

    Specifies the order for results. If True, the results are returned in ascending order, based on the creation date.

Returns:



4275
4276
4277
4278
 
# File 'lib/aws-sdk-iot/client.rb', line 4275

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

#list_certificates_by_ca(params = {}) ⇒ Types::ListCertificatesByCAResponse

List the device certificates signed by the specified CA certificate.

Examples:

Request syntax with placeholder values


resp = client.list_certificates_by_ca({
  ca_certificate_id: "CertificateId", # required
  page_size: 1,
  marker: "Marker",
  ascending_order: false,
})

Response structure


resp.certificates #=> Array
resp.certificates[0].certificate_arn #=> String
resp.certificates[0].certificate_id #=> String
resp.certificates[0].status #=> String, one of "ACTIVE", "INACTIVE", "REVOKED", "PENDING_TRANSFER", "REGISTER_INACTIVE", "PENDING_ACTIVATION"
resp.certificates[0].creation_date #=> Time
resp.next_marker #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :ca_certificate_id (required, String) —

    The ID of the CA certificate. This operation will list all registered device certificate that were signed by this CA certificate.

  • :page_size (Integer) —

    The result page size.

  • :marker (String) —

    The marker for the next set of results.

  • :ascending_order (Boolean) —

    Specifies the order for results. If True, the results are returned in ascending order, based on the creation date.

Returns:



4321
4322
4323
4324
 
# File 'lib/aws-sdk-iot/client.rb', line 4321

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

#list_indices(params = {}) ⇒ Types::ListIndicesResponse

Lists the search indices.

Examples:

Request syntax with placeholder values


resp = client.list_indices({
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.index_names #=> Array
resp.index_names[0] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :next_token (String) —

    The token used to get the next set of results, or null if there are no additional results.

  • :max_results (Integer) —

    The maximum number of results to return at one time.

Returns:



4355
4356
4357
4358
 
# File 'lib/aws-sdk-iot/client.rb', line 4355

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

#list_job_executions_for_job(params = {}) ⇒ Types::ListJobExecutionsForJobResponse

Lists the job executions for a job.

Examples:

Request syntax with placeholder values


resp = client.list_job_executions_for_job({
  job_id: "JobId", # required
  status: "QUEUED", # accepts QUEUED, IN_PROGRESS, SUCCEEDED, FAILED, TIMED_OUT, REJECTED, REMOVED, CANCELED
  max_results: 1,
  next_token: "NextToken",
})

Response structure


resp.execution_summaries #=> Array
resp.execution_summaries[0].thing_arn #=> String
resp.execution_summaries[0].job_execution_summary.status #=> String, one of "QUEUED", "IN_PROGRESS", "SUCCEEDED", "FAILED", "TIMED_OUT", "REJECTED", "REMOVED", "CANCELED"
resp.execution_summaries[0].job_execution_summary.queued_at #=> Time
resp.execution_summaries[0].job_execution_summary.started_at #=> Time
resp.execution_summaries[0].job_execution_summary.last_updated_at #=> Time
resp.execution_summaries[0].job_execution_summary.execution_number #=> Integer
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :job_id (required, String) —

    The unique identifier you assigned to this job when it was created.

  • :status (String) —

    The status of the job.

  • :max_results (Integer) —

    The maximum number of results to be returned per request.

  • :next_token (String) —

    The token to retrieve the next set of results.

Returns:



4401
4402
4403
4404
 
# File 'lib/aws-sdk-iot/client.rb', line 4401

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

#list_job_executions_for_thing(params = {}) ⇒ Types::ListJobExecutionsForThingResponse

Lists the job executions for the specified thing.

Examples:

Request syntax with placeholder values


resp = client.list_job_executions_for_thing({
  thing_name: "ThingName", # required
  status: "QUEUED", # accepts QUEUED, IN_PROGRESS, SUCCEEDED, FAILED, TIMED_OUT, REJECTED, REMOVED, CANCELED
  max_results: 1,
  next_token: "NextToken",
})

Response structure


resp.execution_summaries #=> Array
resp.execution_summaries[0].job_id #=> String
resp.execution_summaries[0].job_execution_summary.status #=> String, one of "QUEUED", "IN_PROGRESS", "SUCCEEDED", "FAILED", "TIMED_OUT", "REJECTED", "REMOVED", "CANCELED"
resp.execution_summaries[0].job_execution_summary.queued_at #=> Time
resp.execution_summaries[0].job_execution_summary.started_at #=> Time
resp.execution_summaries[0].job_execution_summary.last_updated_at #=> Time
resp.execution_summaries[0].job_execution_summary.execution_number #=> Integer
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (required, String) —

    The thing name.

  • :status (String) —

    An optional filter that lets you search for jobs that have the specified status.

  • :max_results (Integer) —

    The maximum number of results to be returned per request.

  • :next_token (String) —

    The token to retrieve the next set of results.

Returns:



4448
4449
4450
4451
 
# File 'lib/aws-sdk-iot/client.rb', line 4448

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

#list_jobs(params = {}) ⇒ Types::ListJobsResponse

Lists jobs.

Examples:

Request syntax with placeholder values


resp = client.list_jobs({
  status: "IN_PROGRESS", # accepts IN_PROGRESS, CANCELED, COMPLETED, DELETION_IN_PROGRESS
  target_selection: "CONTINUOUS", # accepts CONTINUOUS, SNAPSHOT
  max_results: 1,
  next_token: "NextToken",
  thing_group_name: "ThingGroupName",
  thing_group_id: "ThingGroupId",
})

Response structure


resp.jobs #=> Array
resp.jobs[0].job_arn #=> String
resp.jobs[0].job_id #=> String
resp.jobs[0].thing_group_id #=> String
resp.jobs[0].target_selection #=> String, one of "CONTINUOUS", "SNAPSHOT"
resp.jobs[0].status #=> String, one of "IN_PROGRESS", "CANCELED", "COMPLETED", "DELETION_IN_PROGRESS"
resp.jobs[0].created_at #=> Time
resp.jobs[0].last_updated_at #=> Time
resp.jobs[0].completed_at #=> Time
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :status (String) —

    An optional filter that lets you search for jobs that have the specified status.

  • :target_selection (String) —

    Specifies whether the job will continue to run (CONTINUOUS), or will be complete after all those things specified as targets have completed the job (SNAPSHOT). If continuous, the job may also be run on a thing when a change is detected in a target. For example, a job will run on a thing when the thing is added to a target group, even after the job was completed by all things originally in the group.

  • :max_results (Integer) —

    The maximum number of results to return per request.

  • :next_token (String) —

    The token to retrieve the next set of results.

  • :thing_group_name (String) —

    A filter that limits the returned jobs to those for the specified group.

  • :thing_group_id (String) —

    A filter that limits the returned jobs to those for the specified group.

Returns:



4512
4513
4514
4515
 
# File 'lib/aws-sdk-iot/client.rb', line 4512

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

#list_ota_updates(params = {}) ⇒ Types::ListOTAUpdatesResponse

Lists OTA updates.

Examples:

Request syntax with placeholder values


resp = client.list_ota_updates({
  max_results: 1,
  next_token: "NextToken",
  ota_update_status: "CREATE_PENDING", # accepts CREATE_PENDING, CREATE_IN_PROGRESS, CREATE_COMPLETE, CREATE_FAILED
})

Response structure


resp.ota_updates #=> Array
resp.ota_updates[0].ota_update_id #=> String
resp.ota_updates[0].ota_update_arn #=> String
resp.ota_updates[0].creation_date #=> Time
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (Integer) —

    The maximum number of results to return at one time.

  • :next_token (String) —

    A token used to retrieve the next set of results.

  • :ota_update_status (String) —

    The OTA update job status.

Returns:



4551
4552
4553
4554
 
# File 'lib/aws-sdk-iot/client.rb', line 4551

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

#list_outgoing_certificates(params = {}) ⇒ Types::ListOutgoingCertificatesResponse

Lists certificates that are being transferred but not yet accepted.

Examples:

Request syntax with placeholder values


resp = client.list_outgoing_certificates({
  page_size: 1,
  marker: "Marker",
  ascending_order: false,
})

Response structure


resp.outgoing_certificates #=> Array
resp.outgoing_certificates[0].certificate_arn #=> String
resp.outgoing_certificates[0].certificate_id #=> String
resp.outgoing_certificates[0].transferred_to #=> String
resp.outgoing_certificates[0].transfer_date #=> Time
resp.outgoing_certificates[0].transfer_message #=> String
resp.outgoing_certificates[0].creation_date #=> Time
resp.next_marker #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :page_size (Integer) —

    The result page size.

  • :marker (String) —

    The marker for the next set of results.

  • :ascending_order (Boolean) —

    Specifies the order for results. If True, the results are returned in ascending order, based on the creation date.

Returns:



4594
4595
4596
4597
 
# File 'lib/aws-sdk-iot/client.rb', line 4594

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

#list_policies(params = {}) ⇒ Types::ListPoliciesResponse

Lists your policies.

Examples:

Request syntax with placeholder values


resp = client.list_policies({
  marker: "Marker",
  page_size: 1,
  ascending_order: false,
})

Response structure


resp.policies #=> Array
resp.policies[0].policy_name #=> String
resp.policies[0].policy_arn #=> String
resp.next_marker #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :marker (String) —

    The marker for the next set of results.

  • :page_size (Integer) —

    The result page size.

  • :ascending_order (Boolean) —

    Specifies the order for results. If true, the results are returned in ascending creation order.

Returns:



4633
4634
4635
4636
 
# File 'lib/aws-sdk-iot/client.rb', line 4633

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

#list_policy_principals(params = {}) ⇒ Types::ListPolicyPrincipalsResponse

Lists the principals associated with the specified policy.

Note: This API is deprecated. Please use ListTargetsForPolicy instead.

Examples:

Request syntax with placeholder values


resp = client.list_policy_principals({
  policy_name: "PolicyName", # required
  marker: "Marker",
  page_size: 1,
  ascending_order: false,
})

Response structure


resp.principals #=> Array
resp.principals[0] #=> String
resp.next_marker #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The policy name.

  • :marker (String) —

    The marker for the next set of results.

  • :page_size (Integer) —

    The result page size.

  • :ascending_order (Boolean) —

    Specifies the order for results. If true, the results are returned in ascending creation order.

Returns:



4678
4679
4680
4681
 
# File 'lib/aws-sdk-iot/client.rb', line 4678

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

#list_policy_versions(params = {}) ⇒ Types::ListPolicyVersionsResponse

Lists the versions of the specified policy and identifies the default version.

Examples:

Request syntax with placeholder values


resp = client.list_policy_versions({
  policy_name: "PolicyName", # required
})

Response structure


resp.policy_versions #=> Array
resp.policy_versions[0].version_id #=> String
resp.policy_versions[0].is_default_version #=> Boolean
resp.policy_versions[0].create_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The policy name.

Returns:



4708
4709
4710
4711
 
# File 'lib/aws-sdk-iot/client.rb', line 4708

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

#list_principal_policies(params = {}) ⇒ Types::ListPrincipalPoliciesResponse

Lists the policies attached to the specified principal. If you use an Cognito identity, the ID must be in [AmazonCognito Identity format].

Note: This API is deprecated. Please use ListAttachedPolicies instead.

[1]: docs.aws.amazon.com/cognitoidentity/latest/APIReference/API_GetCredentialsForIdentity.html#API_GetCredentialsForIdentity_RequestSyntax

Examples:

Request syntax with placeholder values


resp = client.list_principal_policies({
  principal: "Principal", # required
  marker: "Marker",
  page_size: 1,
  ascending_order: false,
})

Response structure


resp.policies #=> Array
resp.policies[0].policy_name #=> String
resp.policies[0].policy_arn #=> String
resp.next_marker #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :principal (required, String) —

    The principal.

  • :marker (String) —

    The marker for the next set of results.

  • :page_size (Integer) —

    The result page size.

  • :ascending_order (Boolean) —

    Specifies the order for results. If true, results are returned in ascending creation order.

Returns:



4760
4761
4762
4763
 
# File 'lib/aws-sdk-iot/client.rb', line 4760

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

#list_principal_things(params = {}) ⇒ Types::ListPrincipalThingsResponse

Lists the things associated with the specified principal.

Examples:

Request syntax with placeholder values


resp = client.list_principal_things({
  next_token: "NextToken",
  max_results: 1,
  principal: "Principal", # required
})

Response structure


resp.things #=> Array
resp.things[0] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :next_token (String) —

    The token to retrieve the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return in this operation.

  • :principal (required, String) —

    The principal.

Returns:



4797
4798
4799
4800
 
# File 'lib/aws-sdk-iot/client.rb', line 4797

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

#list_role_aliases(params = {}) ⇒ Types::ListRoleAliasesResponse

Lists the role aliases registered in your account.

Examples:

Request syntax with placeholder values


resp = client.list_role_aliases({
  page_size: 1,
  marker: "Marker",
  ascending_order: false,
})

Response structure


resp.role_aliases #=> Array
resp.role_aliases[0] #=> String
resp.next_marker #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :page_size (Integer) —

    The maximum number of results to return at one time.

  • :marker (String) —

    A marker used to get the next set of results.

  • :ascending_order (Boolean) —

    Return the list of role aliases in ascending alphabetical order.

Returns:



4834
4835
4836
4837
 
# File 'lib/aws-sdk-iot/client.rb', line 4834

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

#list_scheduled_audits(params = {}) ⇒ Types::ListScheduledAuditsResponse

Lists all of your scheduled audits.

Examples:

Request syntax with placeholder values


resp = client.list_scheduled_audits({
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.scheduled_audits #=> Array
resp.scheduled_audits[0].scheduled_audit_name #=> String
resp.scheduled_audits[0].scheduled_audit_arn #=> String
resp.scheduled_audits[0].frequency #=> String, one of "DAILY", "WEEKLY", "BIWEEKLY", "MONTHLY"
resp.scheduled_audits[0].day_of_month #=> String
resp.scheduled_audits[0].day_of_week #=> String, one of "SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :next_token (String) —

    The token for the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return at one time. The default is 25.

Returns:



4872
4873
4874
4875
 
# File 'lib/aws-sdk-iot/client.rb', line 4872

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

#list_security_profiles(params = {}) ⇒ Types::ListSecurityProfilesResponse

Lists the Device Defender security profiles you have created. You can use filters to list only those security profiles associated with a thing group or only those associated with your account.

Examples:

Request syntax with placeholder values


resp = client.list_security_profiles({
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.security_profile_identifiers #=> Array
resp.security_profile_identifiers[0].name #=> String
resp.security_profile_identifiers[0].arn #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :next_token (String) —

    The token for the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return at one time.

Returns:



4908
4909
4910
4911
 
# File 'lib/aws-sdk-iot/client.rb', line 4908

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

#list_security_profiles_for_target(params = {}) ⇒ Types::ListSecurityProfilesForTargetResponse

Lists the Device Defender security profiles attached to a target (thing group).

Examples:

Request syntax with placeholder values


resp = client.list_security_profiles_for_target({
  next_token: "NextToken",
  max_results: 1,
  recursive: false,
  security_profile_target_arn: "SecurityProfileTargetArn", # required
})

Response structure


resp.security_profile_target_mappings #=> Array
resp.security_profile_target_mappings[0].security_profile_identifier.name #=> String
resp.security_profile_target_mappings[0].security_profile_identifier.arn #=> String
resp.security_profile_target_mappings[0].target.arn #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :next_token (String) —

    The token for the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return at one time.

  • :recursive (Boolean) —

    If true, return child groups as well.

  • :security_profile_target_arn (required, String) —

    The ARN of the target (thing group) whose attached security profiles you want to get.

Returns:



4953
4954
4955
4956
 
# File 'lib/aws-sdk-iot/client.rb', line 4953

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

#list_streams(params = {}) ⇒ Types::ListStreamsResponse

Lists all of the streams in your AWS account.

Examples:

Request syntax with placeholder values


resp = client.list_streams({
  max_results: 1,
  next_token: "NextToken",
  ascending_order: false,
})

Response structure


resp.streams #=> Array
resp.streams[0].stream_id #=> String
resp.streams[0].stream_arn #=> String
resp.streams[0].stream_version #=> Integer
resp.streams[0].description #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :max_results (Integer) —

    The maximum number of results to return at a time.

  • :next_token (String) —

    A token used to get the next set of results.

  • :ascending_order (Boolean) —

    Set to true to return the list of streams in ascending order.

Returns:



4993
4994
4995
4996
 
# File 'lib/aws-sdk-iot/client.rb', line 4993

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

#list_tags_for_resource(params = {}) ⇒ Types::ListTagsForResourceResponse

Lists the tags (metadata) you have assigned to the resource.

Examples:

Request syntax with placeholder values


resp = client.list_tags_for_resource({
  resource_arn: "ResourceArn", # required
  next_token: "NextToken",
})

Response structure


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

Parameters:

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

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The ARN of the resource.

  • :next_token (String) —

    The token to retrieve the next set of results.

Returns:



5027
5028
5029
5030
 
# File 'lib/aws-sdk-iot/client.rb', line 5027

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

#list_targets_for_policy(params = {}) ⇒ Types::ListTargetsForPolicyResponse

List targets for the specified policy.

Examples:

Request syntax with placeholder values


resp = client.list_targets_for_policy({
  policy_name: "PolicyName", # required
  marker: "Marker",
  page_size: 1,
})

Response structure


resp.targets #=> Array
resp.targets[0] #=> String
resp.next_marker #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The policy name.

  • :marker (String) —

    A marker used to get the next set of results.

  • :page_size (Integer) —

    The maximum number of results to return at one time.

Returns:



5064
5065
5066
5067
 
# File 'lib/aws-sdk-iot/client.rb', line 5064

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

#list_targets_for_security_profile(params = {}) ⇒ Types::ListTargetsForSecurityProfileResponse

Lists the targets (thing groups) associated with a given Device Defender security profile.

Examples:

Request syntax with placeholder values


resp = client.list_targets_for_security_profile({
  security_profile_name: "SecurityProfileName", # required
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.security_profile_targets #=> Array
resp.security_profile_targets[0].arn #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :security_profile_name (required, String) —

    The security profile.

  • :next_token (String) —

    The token for the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return at one time.

Returns:



5102
5103
5104
5105
 
# File 'lib/aws-sdk-iot/client.rb', line 5102

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

#list_thing_groups(params = {}) ⇒ Types::ListThingGroupsResponse

List the thing groups in your account.

Examples:

Request syntax with placeholder values


resp = client.list_thing_groups({
  next_token: "NextToken",
  max_results: 1,
  parent_group: "ThingGroupName",
  name_prefix_filter: "ThingGroupName",
  recursive: false,
})

Response structure


resp.thing_groups #=> Array
resp.thing_groups[0].group_name #=> String
resp.thing_groups[0].group_arn #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :next_token (String) —

    The token to retrieve the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return at one time.

  • :parent_group (String) —

    A filter that limits the results to those with the specified parent group.

  • :name_prefix_filter (String) —

    A filter that limits the results to those with the specified name prefix.

  • :recursive (Boolean) —

    If true, return child groups as well.

Returns:



5150
5151
5152
5153
 
# File 'lib/aws-sdk-iot/client.rb', line 5150

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

#list_thing_groups_for_thing(params = {}) ⇒ Types::ListThingGroupsForThingResponse

List the thing groups to which the specified thing belongs.

Examples:

Request syntax with placeholder values


resp = client.list_thing_groups_for_thing({
  thing_name: "ThingName", # required
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.thing_groups #=> Array
resp.thing_groups[0].group_name #=> String
resp.thing_groups[0].group_arn #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (required, String) —

    The thing name.

  • :next_token (String) —

    The token to retrieve the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return at one time.

Returns:



5188
5189
5190
5191
 
# File 'lib/aws-sdk-iot/client.rb', line 5188

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

#list_thing_principals(params = {}) ⇒ Types::ListThingPrincipalsResponse

Lists the principals associated with the specified thing.

Examples:

Request syntax with placeholder values


resp = client.list_thing_principals({
  thing_name: "ThingName", # required
})

Response structure


resp.principals #=> Array
resp.principals[0] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (required, String) —

    The name of the thing.

Returns:



5215
5216
5217
5218
 
# File 'lib/aws-sdk-iot/client.rb', line 5215

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

#list_thing_registration_task_reports(params = {}) ⇒ Types::ListThingRegistrationTaskReportsResponse

Information about the thing registration tasks.

Examples:

Request syntax with placeholder values


resp = client.list_thing_registration_task_reports({
  task_id: "TaskId", # required
  report_type: "ERRORS", # required, accepts ERRORS, RESULTS
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.resource_links #=> Array
resp.resource_links[0] #=> String
resp.report_type #=> String, one of "ERRORS", "RESULTS"
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :task_id (required, String) —

    The id of the task.

  • :report_type (required, String) —

    The type of task report.

  • :next_token (String) —

    The token to retrieve the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return per request.

Returns:



5258
5259
5260
5261
 
# File 'lib/aws-sdk-iot/client.rb', line 5258

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

#list_thing_registration_tasks(params = {}) ⇒ Types::ListThingRegistrationTasksResponse

List bulk thing provisioning tasks.

Examples:

Request syntax with placeholder values


resp = client.list_thing_registration_tasks({
  next_token: "NextToken",
  max_results: 1,
  status: "InProgress", # accepts InProgress, Completed, Failed, Cancelled, Cancelling
})

Response structure


resp.task_ids #=> Array
resp.task_ids[0] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :next_token (String) —

    The token to retrieve the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return at one time.

  • :status (String) —

    The status of the bulk thing provisioning task.

Returns:



5295
5296
5297
5298
 
# File 'lib/aws-sdk-iot/client.rb', line 5295

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

#list_thing_types(params = {}) ⇒ Types::ListThingTypesResponse

Lists the existing thing types.

Examples:

Request syntax with placeholder values


resp = client.list_thing_types({
  next_token: "NextToken",
  max_results: 1,
  thing_type_name: "ThingTypeName",
})

Response structure


resp.thing_types #=> Array
resp.thing_types[0].thing_type_name #=> String
resp.thing_types[0].thing_type_arn #=> String
resp.thing_types[0].thing_type_properties.thing_type_description #=> String
resp.thing_types[0].thing_type_properties.searchable_attributes #=> Array
resp.thing_types[0].thing_type_properties.searchable_attributes[0] #=> String
resp.thing_types[0].thing_type_metadata.deprecated #=> Boolean
resp.thing_types[0].thing_type_metadata.deprecation_date #=> Time
resp.thing_types[0].thing_type_metadata.creation_date #=> Time
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :next_token (String) —

    The token to retrieve the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return in this operation.

  • :thing_type_name (String) —

    The name of the thing type.

Returns:



5339
5340
5341
5342
 
# File 'lib/aws-sdk-iot/client.rb', line 5339

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

#list_things(params = {}) ⇒ Types::ListThingsResponse

Lists your things. Use the attributeName and attributeValue parameters to filter your things. For example, calling ‘ListThings` with attributeName=Color and attributeValue=Red retrieves all things in the registry that contain an attribute Color with the value Red.

Examples:

Request syntax with placeholder values


resp = client.list_things({
  next_token: "NextToken",
  max_results: 1,
  attribute_name: "AttributeName",
  attribute_value: "AttributeValue",
  thing_type_name: "ThingTypeName",
})

Response structure


resp.things #=> Array
resp.things[0].thing_name #=> String
resp.things[0].thing_type_name #=> String
resp.things[0].thing_arn #=> String
resp.things[0].attributes #=> Hash
resp.things[0].attributes["AttributeName"] #=> <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
resp.things[0].version #=> Integer
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :next_token (String) —

    The token to retrieve the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return in this operation.

  • :attribute_name (String) —

    The attribute name used to search for things.

  • :attribute_value (String) —

    The attribute value used to search for things.

  • :thing_type_name (String) —

    The name of the thing type used to search for things.

Returns:



5393
5394
5395
5396
 
# File 'lib/aws-sdk-iot/client.rb', line 5393

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

#list_things_in_billing_group(params = {}) ⇒ Types::ListThingsInBillingGroupResponse

Lists the things you have added to the given billing group.

Examples:

Request syntax with placeholder values


resp = client.list_things_in_billing_group({
  billing_group_name: "BillingGroupName", # required
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.things #=> Array
resp.things[0] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :billing_group_name (required, String) —

    The name of the billing group.

  • :next_token (String) —

    The token to retrieve the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return per request.

Returns:



5430
5431
5432
5433
 
# File 'lib/aws-sdk-iot/client.rb', line 5430

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

#list_things_in_thing_group(params = {}) ⇒ Types::ListThingsInThingGroupResponse

Lists the things in the specified group.

Examples:

Request syntax with placeholder values


resp = client.list_things_in_thing_group({
  thing_group_name: "ThingGroupName", # required
  recursive: false,
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.things #=> Array
resp.things[0] #=> String
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :thing_group_name (required, String) —

    The thing group name.

  • :recursive (Boolean) —

    When true, list things in this thing group and in all child groups as well.

  • :next_token (String) —

    The token to retrieve the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return at one time.

Returns:



5472
5473
5474
5475
 
# File 'lib/aws-sdk-iot/client.rb', line 5472

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

#list_topic_rules(params = {}) ⇒ Types::ListTopicRulesResponse

Lists the rules for the specific topic.

Examples:

Request syntax with placeholder values


resp = client.list_topic_rules({
  topic: "Topic",
  max_results: 1,
  next_token: "NextToken",
  rule_disabled: false,
})

Response structure


resp.rules #=> Array
resp.rules[0].rule_arn #=> String
resp.rules[0].rule_name #=> String
resp.rules[0].topic_pattern #=> String
resp.rules[0].created_at #=> Time
resp.rules[0].rule_disabled #=> Boolean
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :topic (String) —

    The topic.

  • :max_results (Integer) —

    The maximum number of results to return.

  • :next_token (String) —

    A token used to retrieve the next value.

  • :rule_disabled (Boolean) —

    Specifies whether the rule is disabled.

Returns:



5517
5518
5519
5520
 
# File 'lib/aws-sdk-iot/client.rb', line 5517

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

#list_v2_logging_levels(params = {}) ⇒ Types::ListV2LoggingLevelsResponse

Lists logging levels.

Examples:

Request syntax with placeholder values


resp = client.list_v2_logging_levels({
  target_type: "DEFAULT", # accepts DEFAULT, THING_GROUP
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.log_target_configurations #=> Array
resp.log_target_configurations[0].log_target.target_type #=> String, one of "DEFAULT", "THING_GROUP"
resp.log_target_configurations[0].log_target.target_name #=> String
resp.log_target_configurations[0].log_level #=> String, one of "DEBUG", "INFO", "ERROR", "WARN", "DISABLED"
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :target_type (String) —

    The type of resource for which you are configuring logging. Must be ‘THING_Group`.

  • :next_token (String) —

    The token used to get the next set of results, or null if there are no additional results.

  • :max_results (Integer) —

    The maximum number of results to return at one time.

Returns:



5558
5559
5560
5561
 
# File 'lib/aws-sdk-iot/client.rb', line 5558

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

#list_violation_events(params = {}) ⇒ Types::ListViolationEventsResponse

Lists the Device Defender security profile violations discovered during the given time period. You can use filters to limit the results to those alerts issued for a particular security profile, behavior or thing (device).

Examples:

Request syntax with placeholder values


resp = client.list_violation_events({
  start_time: Time.now, # required
  end_time: Time.now, # required
  thing_name: "ThingName",
  security_profile_name: "SecurityProfileName",
  next_token: "NextToken",
  max_results: 1,
})

Response structure


resp.violation_events #=> Array
resp.violation_events[0].violation_id #=> String
resp.violation_events[0].thing_name #=> String
resp.violation_events[0].security_profile_name #=> String
resp.violation_events[0].behavior.name #=> String
resp.violation_events[0].behavior.metric #=> String
resp.violation_events[0].behavior.criteria.comparison_operator #=> String, one of "less-than", "less-than-equals", "greater-than", "greater-than-equals", "in-cidr-set", "not-in-cidr-set", "in-port-set", "not-in-port-set"
resp.violation_events[0].behavior.criteria.value.count #=> Integer
resp.violation_events[0].behavior.criteria.value.cidrs #=> Array
resp.violation_events[0].behavior.criteria.value.cidrs[0] #=> String
resp.violation_events[0].behavior.criteria.value.ports #=> Array
resp.violation_events[0].behavior.criteria.value.ports[0] #=> Integer
resp.violation_events[0].behavior.criteria.duration_seconds #=> Integer
resp.violation_events[0].metric_value.count #=> Integer
resp.violation_events[0].metric_value.cidrs #=> Array
resp.violation_events[0].metric_value.cidrs[0] #=> String
resp.violation_events[0].metric_value.ports #=> Array
resp.violation_events[0].metric_value.ports[0] #=> Integer
resp.violation_events[0].violation_event_type #=> String, one of "in-alarm", "alarm-cleared", "alarm-invalidated"
resp.violation_events[0].violation_event_time #=> Time
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :start_time (required, Time, DateTime, Date, Integer, String) —

    The start time for the alerts to be listed.

  • :end_time (required, Time, DateTime, Date, Integer, String) —

    The end time for the alerts to be listed.

  • :thing_name (String) —

    A filter to limit results to those alerts caused by the specified thing.

  • :security_profile_name (String) —

    A filter to limit results to those alerts generated by the specified security profile.

  • :next_token (String) —

    The token for the next set of results.

  • :max_results (Integer) —

    The maximum number of results to return at one time.

Returns:



5630
5631
5632
5633
 
# File 'lib/aws-sdk-iot/client.rb', line 5630

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

#register_ca_certificate(params = {}) ⇒ Types::RegisterCACertificateResponse

Registers a CA certificate with AWS IoT. This CA certificate can then be used to sign device certificates, which can be then registered with AWS IoT. You can register up to 10 CA certificates per AWS account that have the same subject field. This enables you to have up to 10 certificate authorities sign your device certificates. If you have more than one CA certificate registered, make sure you pass the CA certificate when you register your device certificates with the RegisterCertificate API.

Examples:

Request syntax with placeholder values


resp = client.register_ca_certificate({
  ca_certificate: "CertificatePem", # required
  verification_certificate: "CertificatePem", # required
  set_as_active: false,
  allow_auto_registration: false,
  registration_config: {
    template_body: "TemplateBody",
    role_arn: "RoleArn",
  },
})

Response structure


resp.certificate_arn #=> String
resp.certificate_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :ca_certificate (required, String) —

    The CA certificate.

  • :verification_certificate (required, String) —

    The private key verification certificate.

  • :set_as_active (Boolean) —

    A boolean value that specifies if the CA certificate is set to active.

  • :allow_auto_registration (Boolean) —

    Allows this CA certificate to be used for auto registration of device certificates.

  • :registration_config (Types::RegistrationConfig) —

    Information about the registration configuration.

Returns:



5685
5686
5687
5688
 
# File 'lib/aws-sdk-iot/client.rb', line 5685

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

#register_certificate(params = {}) ⇒ Types::RegisterCertificateResponse

Registers a device certificate with AWS IoT. If you have more than one CA certificate that has the same subject field, you must specify the CA certificate that was used to sign the device certificate being registered.

Examples:

Request syntax with placeholder values


resp = client.register_certificate({
  certificate_pem: "CertificatePem", # required
  ca_certificate_pem: "CertificatePem",
  set_as_active: false,
  status: "ACTIVE", # accepts ACTIVE, INACTIVE, REVOKED, PENDING_TRANSFER, REGISTER_INACTIVE, PENDING_ACTIVATION
})

Response structure


resp.certificate_arn #=> String
resp.certificate_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_pem (required, String) —

    The certificate data, in PEM format.

  • :ca_certificate_pem (String) —

    The CA certificate used to sign the device certificate being registered.

  • :set_as_active (Boolean) —

    A boolean value that specifies if the CA certificate is set to active.

  • :status (String) —

    The status of the register certificate request.

Returns:



5729
5730
5731
5732
 
# File 'lib/aws-sdk-iot/client.rb', line 5729

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

#register_thing(params = {}) ⇒ Types::RegisterThingResponse

Provisions a thing.

Examples:

Request syntax with placeholder values


resp = client.register_thing({
  template_body: "TemplateBody", # required
  parameters: {
    "Parameter" => "Value",
  },
})

Response structure


resp.certificate_pem #=> String
resp.resource_arns #=> Hash
resp.resource_arns["ResourceLogicalId"] #=> String

Parameters:

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

    ({})

Options Hash (params):

Returns:



5774
5775
5776
5777
 
# File 'lib/aws-sdk-iot/client.rb', line 5774

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

#reject_certificate_transfer(params = {}) ⇒ Struct

Rejects a pending certificate transfer. After AWS IoT rejects a certificate transfer, the certificate status changes from PENDING_TRANSFER to INACTIVE.

To check for pending certificate transfers, call ListCertificates to enumerate your certificates.

This operation can only be called by the transfer destination. After it is called, the certificate will be returned to the source’s account in the INACTIVE state.

Examples:

Request syntax with placeholder values


resp = client.reject_certificate_transfer({
  certificate_id: "CertificateId", # required
  reject_reason: "Message",
})

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_id (required, String) —

    The ID of the certificate. (The last part of the certificate ARN contains the certificate ID.)

  • :reject_reason (String) —

    The reason the certificate transfer was rejected.

Returns:

  • (Struct) —

    Returns an empty response.



5808
5809
5810
5811
 
# File 'lib/aws-sdk-iot/client.rb', line 5808

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

#remove_thing_from_billing_group(params = {}) ⇒ Struct

Removes the given thing from the billing group.

Examples:

Request syntax with placeholder values


resp = client.remove_thing_from_billing_group({
  billing_group_name: "BillingGroupName",
  billing_group_arn: "BillingGroupArn",
  thing_name: "ThingName",
  thing_arn: "ThingArn",
})

Parameters:

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

    ({})

Options Hash (params):

  • :billing_group_name (String) —

    The name of the billing group.

  • :billing_group_arn (String) —

    The ARN of the billing group.

  • :thing_name (String) —

    The name of the thing to be removed from the billing group.

  • :thing_arn (String) —

    The ARN of the thing to be removed from the billing group.

Returns:

  • (Struct) —

    Returns an empty response.



5840
5841
5842
5843
 
# File 'lib/aws-sdk-iot/client.rb', line 5840

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

#remove_thing_from_thing_group(params = {}) ⇒ Struct

Remove the specified thing from the specified group.

Examples:

Request syntax with placeholder values


resp = client.remove_thing_from_thing_group({
  thing_group_name: "ThingGroupName",
  thing_group_arn: "ThingGroupArn",
  thing_name: "ThingName",
  thing_arn: "ThingArn",
})

Parameters:

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

    ({})

Options Hash (params):

  • :thing_group_name (String) —

    The group name.

  • :thing_group_arn (String) —

    The group ARN.

  • :thing_name (String) —

    The name of the thing to remove from the group.

  • :thing_arn (String) —

    The ARN of the thing to remove from the group.

Returns:

  • (Struct) —

    Returns an empty response.



5872
5873
5874
5875
 
# File 'lib/aws-sdk-iot/client.rb', line 5872

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

#replace_topic_rule(params = {}) ⇒ Struct

Replaces the rule. You must specify all parameters for the new rule. Creating rules is an administrator-level action. Any user who has permission to create rules will be able to access data processed by the rule.

Examples:

Request syntax with placeholder values


resp = client.replace_topic_rule({
  rule_name: "RuleName", # required
  topic_rule_payload: { # required
    sql: "SQL", # required
    description: "Description",
    actions: [ # required
      {
        dynamo_db: {
          table_name: "TableName", # required
          role_arn: "AwsArn", # required
          operation: "DynamoOperation",
          hash_key_field: "HashKeyField", # required
          hash_key_value: "HashKeyValue", # required
          hash_key_type: "STRING", # accepts STRING, NUMBER
          range_key_field: "RangeKeyField",
          range_key_value: "RangeKeyValue",
          range_key_type: "STRING", # accepts STRING, NUMBER
          payload_field: "PayloadField",
        },
        dynamo_d_bv_2: {
          role_arn: "AwsArn", # required
          put_item: { # required
            table_name: "TableName", # required
          },
        },
        lambda: {
          function_arn: "FunctionArn", # required
        },
        sns: {
          target_arn: "AwsArn", # required
          role_arn: "AwsArn", # required
          message_format: "RAW", # accepts RAW, JSON
        },
        sqs: {
          role_arn: "AwsArn", # required
          queue_url: "QueueUrl", # required
          use_base_64: false,
        },
        kinesis: {
          role_arn: "AwsArn", # required
          stream_name: "StreamName", # required
          partition_key: "PartitionKey",
        },
        republish: {
          role_arn: "AwsArn", # required
          topic: "TopicPattern", # required
        },
        s3: {
          role_arn: "AwsArn", # required
          bucket_name: "BucketName", # required
          key: "Key", # required
          canned_acl: "private", # accepts private, public-read, public-read-write, aws-exec-read, authenticated-read, bucket-owner-read, bucket-owner-full-control, log-delivery-write
        },
        firehose: {
          role_arn: "AwsArn", # required
          delivery_stream_name: "DeliveryStreamName", # required
          separator: "FirehoseSeparator",
        },
        cloudwatch_metric: {
          role_arn: "AwsArn", # required
          metric_namespace: "String", # required
          metric_name: "String", # required
          metric_value: "String", # required
          metric_unit: "String", # required
          metric_timestamp: "String",
        },
        cloudwatch_alarm: {
          role_arn: "AwsArn", # required
          alarm_name: "AlarmName", # required
          state_reason: "StateReason", # required
          state_value: "StateValue", # required
        },
        elasticsearch: {
          role_arn: "AwsArn", # required
          endpoint: "ElasticsearchEndpoint", # required
          index: "ElasticsearchIndex", # required
          type: "ElasticsearchType", # required
          id: "ElasticsearchId", # required
        },
        salesforce: {
          token: "SalesforceToken", # required
          url: "SalesforceEndpoint", # required
        },
        iot_analytics: {
          channel_arn: "AwsArn",
          channel_name: "ChannelName",
          role_arn: "AwsArn",
        },
        iot_events: {
          input_name: "InputName", # required
          message_id: "MessageId",
          role_arn: "AwsArn", # required
        },
        step_functions: {
          execution_name_prefix: "ExecutionNamePrefix",
          state_machine_name: "StateMachineName", # required
          role_arn: "AwsArn", # required
        },
      },
    ],
    rule_disabled: false,
    aws_iot_sql_version: "AwsIotSqlVersion",
    error_action: {
      dynamo_db: {
        table_name: "TableName", # required
        role_arn: "AwsArn", # required
        operation: "DynamoOperation",
        hash_key_field: "HashKeyField", # required
        hash_key_value: "HashKeyValue", # required
        hash_key_type: "STRING", # accepts STRING, NUMBER
        range_key_field: "RangeKeyField",
        range_key_value: "RangeKeyValue",
        range_key_type: "STRING", # accepts STRING, NUMBER
        payload_field: "PayloadField",
      },
      dynamo_d_bv_2: {
        role_arn: "AwsArn", # required
        put_item: { # required
          table_name: "TableName", # required
        },
      },
      lambda: {
        function_arn: "FunctionArn", # required
      },
      sns: {
        target_arn: "AwsArn", # required
        role_arn: "AwsArn", # required
        message_format: "RAW", # accepts RAW, JSON
      },
      sqs: {
        role_arn: "AwsArn", # required
        queue_url: "QueueUrl", # required
        use_base_64: false,
      },
      kinesis: {
        role_arn: "AwsArn", # required
        stream_name: "StreamName", # required
        partition_key: "PartitionKey",
      },
      republish: {
        role_arn: "AwsArn", # required
        topic: "TopicPattern", # required
      },
      s3: {
        role_arn: "AwsArn", # required
        bucket_name: "BucketName", # required
        key: "Key", # required
        canned_acl: "private", # accepts private, public-read, public-read-write, aws-exec-read, authenticated-read, bucket-owner-read, bucket-owner-full-control, log-delivery-write
      },
      firehose: {
        role_arn: "AwsArn", # required
        delivery_stream_name: "DeliveryStreamName", # required
        separator: "FirehoseSeparator",
      },
      cloudwatch_metric: {
        role_arn: "AwsArn", # required
        metric_namespace: "String", # required
        metric_name: "String", # required
        metric_value: "String", # required
        metric_unit: "String", # required
        metric_timestamp: "String",
      },
      cloudwatch_alarm: {
        role_arn: "AwsArn", # required
        alarm_name: "AlarmName", # required
        state_reason: "StateReason", # required
        state_value: "StateValue", # required
      },
      elasticsearch: {
        role_arn: "AwsArn", # required
        endpoint: "ElasticsearchEndpoint", # required
        index: "ElasticsearchIndex", # required
        type: "ElasticsearchType", # required
        id: "ElasticsearchId", # required
      },
      salesforce: {
        token: "SalesforceToken", # required
        url: "SalesforceEndpoint", # required
      },
      iot_analytics: {
        channel_arn: "AwsArn",
        channel_name: "ChannelName",
        role_arn: "AwsArn",
      },
      iot_events: {
        input_name: "InputName", # required
        message_id: "MessageId",
        role_arn: "AwsArn", # required
      },
      step_functions: {
        execution_name_prefix: "ExecutionNamePrefix",
        state_machine_name: "StateMachineName", # required
        role_arn: "AwsArn", # required
      },
    },
  },
})

Parameters:

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

    ({})

Options Hash (params):

  • :rule_name (required, String) —

    The name of the rule.

  • :topic_rule_payload (required, Types::TopicRulePayload) —

    The rule payload.

Returns:

  • (Struct) —

    Returns an empty response.



6092
6093
6094
6095
 
# File 'lib/aws-sdk-iot/client.rb', line 6092

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

#search_index(params = {}) ⇒ Types::SearchIndexResponse

The query search index.

Examples:

Request syntax with placeholder values


resp = client.search_index({
  index_name: "IndexName",
  query_string: "QueryString", # required
  next_token: "NextToken",
  max_results: 1,
  query_version: "QueryVersion",
})

Response structure


resp.next_token #=> String
resp.things #=> Array
resp.things[0].thing_name #=> String
resp.things[0].thing_id #=> String
resp.things[0].thing_type_name #=> String
resp.things[0].thing_group_names #=> Array
resp.things[0].thing_group_names[0] #=> String
resp.things[0].attributes #=> Hash
resp.things[0].attributes["AttributeName"] #=> <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
resp.things[0].shadow #=> String
resp.things[0].connectivity.connected #=> Boolean
resp.things[0].connectivity.timestamp #=> Integer
resp.thing_groups #=> Array
resp.thing_groups[0].thing_group_name #=> String
resp.thing_groups[0].thing_group_id #=> String
resp.thing_groups[0].thing_group_description #=> String
resp.thing_groups[0].attributes #=> Hash
resp.thing_groups[0].attributes["AttributeName"] #=> <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
resp.thing_groups[0].parent_group_names #=> Array
resp.thing_groups[0].parent_group_names[0] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :index_name (String) —

    The search index name.

  • :query_string (required, String) —

    The search query string.

  • :next_token (String) —

    The token used to get the next set of results, or null if there are no additional results.

  • :max_results (Integer) —

    The maximum number of results to return at one time.

  • :query_version (String) —

    The query version.

Returns:



6156
6157
6158
6159
 
# File 'lib/aws-sdk-iot/client.rb', line 6156

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

#set_default_authorizer(params = {}) ⇒ Types::SetDefaultAuthorizerResponse

Sets the default authorizer. This will be used if a websocket connection is made without specifying an authorizer.

Examples:

Request syntax with placeholder values


resp = client.set_default_authorizer({
  authorizer_name: "AuthorizerName", # required
})

Response structure


resp.authorizer_name #=> String
resp.authorizer_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :authorizer_name (required, String) —

    The authorizer name.

Returns:



6185
6186
6187
6188
 
# File 'lib/aws-sdk-iot/client.rb', line 6185

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

#set_default_policy_version(params = {}) ⇒ Struct

Sets the specified version of the specified policy as the policy’s default (operative) version. This action affects all certificates to which the policy is attached. To list the principals the policy is attached to, use the ListPrincipalPolicy API.

Examples:

Request syntax with placeholder values


resp = client.set_default_policy_version({
  policy_name: "PolicyName", # required
  policy_version_id: "PolicyVersionId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :policy_name (required, String) —

    The policy name.

  • :policy_version_id (required, String) —

    The policy version ID.

Returns:

  • (Struct) —

    Returns an empty response.



6212
6213
6214
6215
 
# File 'lib/aws-sdk-iot/client.rb', line 6212

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

#set_logging_options(params = {}) ⇒ Struct

Sets the logging options.

NOTE: use of this command is not recommended. Use ‘SetV2LoggingOptions` instead.

Examples:

Request syntax with placeholder values


resp = client.set_logging_options({
  logging_options_payload: { # required
    role_arn: "AwsArn", # required
    log_level: "DEBUG", # accepts DEBUG, INFO, ERROR, WARN, DISABLED
  },
})

Parameters:

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

    ({})

Options Hash (params):

Returns:

  • (Struct) —

    Returns an empty response.



6238
6239
6240
6241
 
# File 'lib/aws-sdk-iot/client.rb', line 6238

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

#set_v2_logging_level(params = {}) ⇒ Struct

Sets the logging level.

Examples:

Request syntax with placeholder values


resp = client.set_v2_logging_level({
  log_target: { # required
    target_type: "DEFAULT", # required, accepts DEFAULT, THING_GROUP
    target_name: "LogTargetName",
  },
  log_level: "DEBUG", # required, accepts DEBUG, INFO, ERROR, WARN, DISABLED
})

Parameters:

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

    ({})

Options Hash (params):

  • :log_target (required, Types::LogTarget) —

    The log target.

  • :log_level (required, String) —

    The log level.

Returns:

  • (Struct) —

    Returns an empty response.



6265
6266
6267
6268
 
# File 'lib/aws-sdk-iot/client.rb', line 6265

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

#set_v2_logging_options(params = {}) ⇒ Struct

Sets the logging options for the V2 logging service.

Examples:

Request syntax with placeholder values


resp = client.set_v2_logging_options({
  role_arn: "AwsArn",
  default_log_level: "DEBUG", # accepts DEBUG, INFO, ERROR, WARN, DISABLED
  disable_all_logs: false,
})

Parameters:

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

    ({})

Options Hash (params):

  • :role_arn (String) —

    The ARN of the role that allows IoT to write to Cloudwatch logs.

  • :default_log_level (String) —

    The default logging level.

  • :disable_all_logs (Boolean) —

    If true all logs are disabled. The default is false.

Returns:

  • (Struct) —

    Returns an empty response.



6293
6294
6295
6296
 
# File 'lib/aws-sdk-iot/client.rb', line 6293

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

#start_on_demand_audit_task(params = {}) ⇒ Types::StartOnDemandAuditTaskResponse

Starts an on-demand Device Defender audit.

Examples:

Request syntax with placeholder values


resp = client.start_on_demand_audit_task({
  target_check_names: ["AuditCheckName"], # required
})

Response structure


resp.task_id #=> String

Parameters:

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

    ({})

Options Hash (params):

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

    Which checks are performed during the audit. The checks you specify must be enabled for your account or an exception occurs. Use ‘DescribeAccountAuditConfiguration` to see the list of all checks including those that are enabled or `UpdateAccountAuditConfiguration` to select which checks are enabled.

Returns:



6323
6324
6325
6326
 
# File 'lib/aws-sdk-iot/client.rb', line 6323

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

#start_thing_registration_task(params = {}) ⇒ Types::StartThingRegistrationTaskResponse

Creates a bulk thing provisioning task.

Examples:

Request syntax with placeholder values


resp = client.start_thing_registration_task({
  template_body: "TemplateBody", # required
  input_file_bucket: "RegistryS3BucketName", # required
  input_file_key: "RegistryS3KeyName", # required
  role_arn: "RoleArn", # required
})

Response structure


resp.task_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :template_body (required, String) —

    The provisioning template.

  • :input_file_bucket (required, String) —

    The S3 bucket that contains the input file.

  • :input_file_key (required, String) —

    The name of input file within the S3 bucket. This file contains a newline delimited JSON file. Each line contains the parameter values to provision one device (thing).

  • :role_arn (required, String) —

    The IAM role ARN that grants permission the input file.

Returns:



6363
6364
6365
6366
 
# File 'lib/aws-sdk-iot/client.rb', line 6363

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

#stop_thing_registration_task(params = {}) ⇒ Struct

Cancels a bulk thing provisioning task.

Examples:

Request syntax with placeholder values


resp = client.stop_thing_registration_task({
  task_id: "TaskId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :task_id (required, String) —

    The bulk thing provisioning task ID.

Returns:

  • (Struct) —

    Returns an empty response.



6383
6384
6385
6386
 
# File 'lib/aws-sdk-iot/client.rb', line 6383

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

#tag_resource(params = {}) ⇒ Struct

Adds to or modifies the tags of the given resource. Tags are metadata which can be used to manage a resource.

Examples:

Request syntax with placeholder values


resp = client.tag_resource({
  resource_arn: "ResourceArn", # required
  tags: [ # required
    {
      key: "TagKey",
      value: "TagValue",
    },
  ],
})

Parameters:

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

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The ARN of the resource.

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

    The new or modified tags for the resource.

Returns:

  • (Struct) —

    Returns an empty response.



6413
6414
6415
6416
 
# File 'lib/aws-sdk-iot/client.rb', line 6413

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

#test_authorization(params = {}) ⇒ Types::TestAuthorizationResponse

Tests if a specified principal is authorized to perform an AWS IoT action on a specified resource. Use this to test and debug the authorization behavior of devices that connect to the AWS IoT device gateway.

Examples:

Request syntax with placeholder values


resp = client.test_authorization({
  principal: "Principal",
  cognito_identity_pool_id: "CognitoIdentityPoolId",
  auth_infos: [ # required
    {
      action_type: "PUBLISH", # accepts PUBLISH, SUBSCRIBE, RECEIVE, CONNECT
      resources: ["Resource"],
    },
  ],
  client_id: "ClientId",
  policy_names_to_add: ["PolicyName"],
  policy_names_to_skip: ["PolicyName"],
})

Response structure


resp.auth_results #=> Array
resp.auth_results[0].auth_info.action_type #=> String, one of "PUBLISH", "SUBSCRIBE", "RECEIVE", "CONNECT"
resp.auth_results[0].auth_info.resources #=> Array
resp.auth_results[0].auth_info.resources[0] #=> String
resp.auth_results[0].allowed.policies #=> Array
resp.auth_results[0].allowed.policies[0].policy_name #=> String
resp.auth_results[0].allowed.policies[0].policy_arn #=> String
resp.auth_results[0].denied.implicit_deny.policies #=> Array
resp.auth_results[0].denied.implicit_deny.policies[0].policy_name #=> String
resp.auth_results[0].denied.implicit_deny.policies[0].policy_arn #=> String
resp.auth_results[0].denied.explicit_deny.policies #=> Array
resp.auth_results[0].denied.explicit_deny.policies[0].policy_name #=> String
resp.auth_results[0].denied.explicit_deny.policies[0].policy_arn #=> String
resp.auth_results[0].auth_decision #=> String, one of "ALLOWED", "EXPLICIT_DENY", "IMPLICIT_DENY"
resp.auth_results[0].missing_context_values #=> Array
resp.auth_results[0].missing_context_values[0] #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :principal (String) —

    The principal.

  • :cognito_identity_pool_id (String) —

    The Cognito identity pool ID.

  • :auth_infos (required, Array<Types::AuthInfo>) —

    A list of authorization info objects. Simulating authorization will create a response for each ‘authInfo` object in the list.

  • :client_id (String) —

    The MQTT client ID.

  • :policy_names_to_add (Array<String>) —

    When testing custom authorization, the policies specified here are treated as if they are attached to the principal being authorized.

  • :policy_names_to_skip (Array<String>) —

    When testing custom authorization, the policies specified here are treated as if they are not attached to the principal being authorized.

Returns:



6485
6486
6487
6488
 
# File 'lib/aws-sdk-iot/client.rb', line 6485

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

#test_invoke_authorizer(params = {}) ⇒ Types::TestInvokeAuthorizerResponse

Tests a custom authorization behavior by invoking a specified custom authorizer. Use this to test and debug the custom authorization behavior of devices that connect to the AWS IoT device gateway.

Examples:

Request syntax with placeholder values


resp = client.test_invoke_authorizer({
  authorizer_name: "AuthorizerName", # required
  token: "Token", # required
  token_signature: "TokenSignature", # required
})

Response structure


resp.is_authenticated #=> Boolean
resp.principal_id #=> String
resp.policy_documents #=> Array
resp.policy_documents[0] #=> String
resp.refresh_after_in_seconds #=> Integer
resp.disconnect_after_in_seconds #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :authorizer_name (required, String) —

    The custom authorizer name.

  • :token (required, String) —

    The token returned by your custom authentication service.

  • :token_signature (required, String) —

    The signature made with the token and your custom authentication service’s private key.

Returns:



6531
6532
6533
6534
 
# File 'lib/aws-sdk-iot/client.rb', line 6531

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

#transfer_certificate(params = {}) ⇒ Types::TransferCertificateResponse

Transfers the specified certificate to the specified AWS account.

You can cancel the transfer until it is acknowledged by the recipient.

No notification is sent to the transfer destination’s account. It is up to the caller to notify the transfer target.

The certificate being transferred must not be in the ACTIVE state. You can use the UpdateCertificate API to deactivate it.

The certificate must not have any policies attached to it. You can use the DetachPrincipalPolicy API to detach them.

Examples:

Request syntax with placeholder values


resp = client.transfer_certificate({
  certificate_id: "CertificateId", # required
  target_aws_account: "AwsAccountId", # required
  transfer_message: "Message",
})

Response structure


resp.transferred_certificate_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_id (required, String) —

    The ID of the certificate. (The last part of the certificate ARN contains the certificate ID.)

  • :target_aws_account (required, String) —

    The AWS account.

  • :transfer_message (String) —

    The transfer message.

Returns:



6577
6578
6579
6580
 
# File 'lib/aws-sdk-iot/client.rb', line 6577

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

#untag_resource(params = {}) ⇒ Struct

Removes the given tags (metadata) from the resource.

Examples:

Request syntax with placeholder values


resp = client.untag_resource({
  resource_arn: "ResourceArn", # required
  tag_keys: ["TagKey"], # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The ARN of the resource.

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

    A list of the keys of the tags to be removed from the resource.

Returns:

  • (Struct) —

    Returns an empty response.



6601
6602
6603
6604
 
# File 'lib/aws-sdk-iot/client.rb', line 6601

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

#update_account_audit_configuration(params = {}) ⇒ Struct

Configures or reconfigures the Device Defender audit settings for this account. Settings include how audit notifications are sent and which audit checks are enabled or disabled.

Examples:

Request syntax with placeholder values


resp = client.({
  role_arn: "RoleArn",
  audit_notification_target_configurations: {
    "SNS" => {
      target_arn: "TargetArn",
      role_arn: "RoleArn",
      enabled: false,
    },
  },
  audit_check_configurations: {
    "AuditCheckName" => {
      enabled: false,
    },
  },
})

Parameters:

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

    ({})

Options Hash (params):

  • :role_arn (String) —

    The ARN of the role that grants permission to AWS IoT to access information about your devices, policies, certificates and other items as necessary when performing an audit.

  • :audit_notification_target_configurations (Hash<String,Types::AuditNotificationTarget>) —

    Information about the targets to which audit notifications are sent.

  • :audit_check_configurations (Hash<String,Types::AuditCheckConfiguration>) —

    Specifies which audit checks are enabled and disabled for this account. Use ‘DescribeAccountAuditConfiguration` to see the list of all checks including those that are currently enabled.

    Note that some data collection may begin immediately when certain checks are enabled. When a check is disabled, any data collected so far in relation to the check is deleted.

    You cannot disable a check if it is used by any scheduled audit. You must first delete the check from the scheduled audit or delete the scheduled audit itself.

    On the first call to ‘UpdateAccountAuditConfiguration` this parameter is required and must specify at least one enabled check.

Returns:

  • (Struct) —

    Returns an empty response.



6656
6657
6658
6659
 
# File 'lib/aws-sdk-iot/client.rb', line 6656

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

#update_authorizer(params = {}) ⇒ Types::UpdateAuthorizerResponse

Updates an authorizer.

Examples:

Request syntax with placeholder values


resp = client.update_authorizer({
  authorizer_name: "AuthorizerName", # required
  authorizer_function_arn: "AuthorizerFunctionArn",
  token_key_name: "TokenKeyName",
  token_signing_public_keys: {
    "KeyName" => "KeyValue",
  },
  status: "ACTIVE", # accepts ACTIVE, INACTIVE
})

Response structure


resp.authorizer_name #=> String
resp.authorizer_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :authorizer_name (required, String) —

    The authorizer name.

  • :authorizer_function_arn (String) —

    The ARN of the authorizer’s Lambda function.

  • :token_key_name (String) —

    The key used to extract the token from the HTTP headers.

  • :token_signing_public_keys (Hash<String,String>) —

    The public keys used to verify the token signature.

  • :status (String) —

    The status of the update authorizer request.

Returns:



6702
6703
6704
6705
 
# File 'lib/aws-sdk-iot/client.rb', line 6702

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

#update_billing_group(params = {}) ⇒ Types::UpdateBillingGroupResponse

Updates information about the billing group.

Examples:

Request syntax with placeholder values


resp = client.update_billing_group({
  billing_group_name: "BillingGroupName", # required
  billing_group_properties: { # required
    billing_group_description: "BillingGroupDescription",
  },
  expected_version: 1,
})

Response structure


resp.version #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :billing_group_name (required, String) —

    The name of the billing group.

  • :billing_group_properties (required, Types::BillingGroupProperties) —

    The properties of the billing group.

  • :expected_version (Integer) —

    The expected version of the billing group. If the version of the billing group does not match the expected version specified in the request, the ‘UpdateBillingGroup` request is rejected with a `VersionConflictException`.

Returns:



6741
6742
6743
6744
 
# File 'lib/aws-sdk-iot/client.rb', line 6741

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

#update_ca_certificate(params = {}) ⇒ Struct

Updates a registered CA certificate.

Examples:

Request syntax with placeholder values


resp = client.update_ca_certificate({
  certificate_id: "CertificateId", # required
  new_status: "ACTIVE", # accepts ACTIVE, INACTIVE
  new_auto_registration_status: "ENABLE", # accepts ENABLE, DISABLE
  registration_config: {
    template_body: "TemplateBody",
    role_arn: "RoleArn",
  },
  remove_auto_registration: false,
})

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_id (required, String) —

    The CA certificate identifier.

  • :new_status (String) —

    The updated status of the CA certificate.

    Note: The status value REGISTER_INACTIVE is deprecated and should not be used.

  • :new_auto_registration_status (String) —

    The new value for the auto registration status. Valid values are: “ENABLE” or “DISABLE”.

  • :registration_config (Types::RegistrationConfig) —

    Information about the registration configuration.

  • :remove_auto_registration (Boolean) —

    If true, remove auto registration.

Returns:

  • (Struct) —

    Returns an empty response.



6784
6785
6786
6787
 
# File 'lib/aws-sdk-iot/client.rb', line 6784

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

#update_certificate(params = {}) ⇒ Struct

Updates the status of the specified certificate. This operation is idempotent.

Moving a certificate from the ACTIVE state (including REVOKED) will not disconnect currently connected devices, but these devices will be unable to reconnect.

The ACTIVE state is required to authenticate devices connecting to AWS IoT using a certificate.

Examples:

Request syntax with placeholder values


resp = client.update_certificate({
  certificate_id: "CertificateId", # required
  new_status: "ACTIVE", # required, accepts ACTIVE, INACTIVE, REVOKED, PENDING_TRANSFER, REGISTER_INACTIVE, PENDING_ACTIVATION
})

Parameters:

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

    ({})

Options Hash (params):

  • :certificate_id (required, String) —

    The ID of the certificate. (The last part of the certificate ARN contains the certificate ID.)

  • :new_status (required, String) —

    The new status.

    Note: Setting the status to PENDING_TRANSFER will result in an exception being thrown. PENDING_TRANSFER is a status used internally by AWS IoT. It is not intended for developer use.

    Note: The status value REGISTER_INACTIVE is deprecated and should not be used.

Returns:

  • (Struct) —

    Returns an empty response.



6824
6825
6826
6827
 
# File 'lib/aws-sdk-iot/client.rb', line 6824

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

#update_dynamic_thing_group(params = {}) ⇒ Types::UpdateDynamicThingGroupResponse

Updates a dynamic thing group.

Examples:

Request syntax with placeholder values


resp = client.update_dynamic_thing_group({
  thing_group_name: "ThingGroupName", # required
  thing_group_properties: { # required
    thing_group_description: "ThingGroupDescription",
    attribute_payload: {
      attributes: {
        "AttributeName" => "AttributeValue",
      },
      merge: false,
    },
  },
  expected_version: 1,
  index_name: "IndexName",
  query_string: "QueryString",
  query_version: "QueryVersion",
})

Response structure


resp.version #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :thing_group_name (required, String) —

    The name of the dynamic thing group to update.

  • :thing_group_properties (required, Types::ThingGroupProperties) —

    The dynamic thing group properties to update.

  • :expected_version (Integer) —

    The expected version of the dynamic thing group to update.

  • :index_name (String) —

    The dynamic thing group index to update.

    <note markdown=“1”> Currently one index is supported: ‘AWS_Things’.

    </note>
  • :query_string (String) —

    The dynamic thing group search query string to update.

  • :query_version (String) —

    The dynamic thing group query version to update.

    <note markdown=“1”> Currently one query version is supported: “2017-09-30”. If not specified, the query version defaults to this value.

    </note>

Returns:



6887
6888
6889
6890
 
# File 'lib/aws-sdk-iot/client.rb', line 6887

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

#update_event_configurations(params = {}) ⇒ Struct

Updates the event configurations.

Examples:

Request syntax with placeholder values


resp = client.update_event_configurations({
  event_configurations: {
    "THING" => {
      enabled: false,
    },
  },
})

Parameters:

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

    ({})

Options Hash (params):

Returns:

  • (Struct) —

    Returns an empty response.



6911
6912
6913
6914
 
# File 'lib/aws-sdk-iot/client.rb', line 6911

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

#update_indexing_configuration(params = {}) ⇒ Struct

Updates the search configuration.

Examples:

Request syntax with placeholder values


resp = client.update_indexing_configuration({
  thing_indexing_configuration: {
    thing_indexing_mode: "OFF", # required, accepts OFF, REGISTRY, REGISTRY_AND_SHADOW
    thing_connectivity_indexing_mode: "OFF", # accepts OFF, STATUS
  },
  thing_group_indexing_configuration: {
    thing_group_indexing_mode: "OFF", # required, accepts OFF, ON
  },
})

Parameters:

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

    ({})

Options Hash (params):

Returns:

  • (Struct) —

    Returns an empty response.



6940
6941
6942
6943
 
# File 'lib/aws-sdk-iot/client.rb', line 6940

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

#update_job(params = {}) ⇒ Struct

Updates supported fields of the specified job.

Examples:

Request syntax with placeholder values


resp = client.update_job({
  job_id: "JobId", # required
  description: "JobDescription",
  presigned_url_config: {
    role_arn: "RoleArn",
    expires_in_sec: 1,
  },
  job_executions_rollout_config: {
    maximum_per_minute: 1,
    exponential_rate: {
      base_rate_per_minute: 1, # required
      increment_factor: 1.0, # required
      rate_increase_criteria: { # required
        number_of_notified_things: 1,
        number_of_succeeded_things: 1,
      },
    },
  },
  abort_config: {
    criteria_list: [ # required
      {
        failure_type: "FAILED", # required, accepts FAILED, REJECTED, TIMED_OUT, ALL
        action: "CANCEL", # required, accepts CANCEL
        threshold_percentage: 1.0, # required
        min_number_of_executed_things: 1, # required
      },
    ],
  },
  timeout_config: {
    in_progress_timeout_in_minutes: 1,
  },
})

Parameters:

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

    ({})

Options Hash (params):

  • :job_id (required, String) —

    The ID of the job to be updated.

  • :description (String) —

    A short text description of the job.

  • :presigned_url_config (Types::PresignedUrlConfig) —

    Configuration information for pre-signed S3 URLs.

  • :job_executions_rollout_config (Types::JobExecutionsRolloutConfig) —

    Allows you to create a staged rollout of the job.

  • :abort_config (Types::AbortConfig) —

    Allows you to create criteria to abort a job.

  • :timeout_config (Types::TimeoutConfig) —

    Specifies the amount of time each device has to finish its execution of the job. The timer is started when the job execution status is set to ‘IN_PROGRESS`. If the job execution status is not set to another terminal state before the time expires, it will be automatically set to `TIMED_OUT`.

Returns:

  • (Struct) —

    Returns an empty response.



7008
7009
7010
7011
 
# File 'lib/aws-sdk-iot/client.rb', line 7008

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

#update_role_alias(params = {}) ⇒ Types::UpdateRoleAliasResponse

Updates a role alias.

Examples:

Request syntax with placeholder values


resp = client.update_role_alias({
  role_alias: "RoleAlias", # required
  role_arn: "RoleArn",
  credential_duration_seconds: 1,
})

Response structure


resp.role_alias #=> String
resp.role_alias_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :role_alias (required, String) —

    The role alias to update.

  • :role_arn (String) —

    The role ARN.

  • :credential_duration_seconds (Integer) —

    The number of seconds the credential will be valid.

Returns:



7044
7045
7046
7047
 
# File 'lib/aws-sdk-iot/client.rb', line 7044

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

#update_scheduled_audit(params = {}) ⇒ Types::UpdateScheduledAuditResponse

Updates a scheduled audit, including what checks are performed and how often the audit takes place.

Examples:

Request syntax with placeholder values


resp = client.update_scheduled_audit({
  frequency: "DAILY", # accepts DAILY, WEEKLY, BIWEEKLY, MONTHLY
  day_of_month: "DayOfMonth",
  day_of_week: "SUN", # accepts SUN, MON, TUE, WED, THU, FRI, SAT
  target_check_names: ["AuditCheckName"],
  scheduled_audit_name: "ScheduledAuditName", # required
})

Response structure


resp.scheduled_audit_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :frequency (String) —

    How often the scheduled audit takes place. Can be one of “DAILY”, “WEEKLY”, “BIWEEKLY” or “MONTHLY”. The actual start time of each audit is determined by the system.

  • :day_of_month (String) —

    The day of the month on which the scheduled audit takes place. Can be “1” through “31” or “LAST”. This field is required if the “frequency” parameter is set to “MONTHLY”. If days 29-31 are specified, and the month does not have that many days, the audit takes place on the “LAST” day of the month.

  • :day_of_week (String) —

    The day of the week on which the scheduled audit takes place. Can be one of “SUN”, “MON”, “TUE”, “WED”, “THU”, “FRI” or “SAT”. This field is required if the “frequency” parameter is set to “WEEKLY” or “BIWEEKLY”.

  • :target_check_names (Array<String>) —

    Which checks are performed during the scheduled audit. Checks must be enabled for your account. (Use ‘DescribeAccountAuditConfiguration` to see the list of all checks including those that are enabled or `UpdateAccountAuditConfiguration` to select which checks are enabled.)

  • :scheduled_audit_name (required, String) —

    The name of the scheduled audit. (Max. 128 chars)

Returns:



7099
7100
7101
7102
 
# File 'lib/aws-sdk-iot/client.rb', line 7099

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

#update_security_profile(params = {}) ⇒ Types::UpdateSecurityProfileResponse

Updates a Device Defender security profile.

Examples:

Request syntax with placeholder values


resp = client.update_security_profile({
  security_profile_name: "SecurityProfileName", # required
  security_profile_description: "SecurityProfileDescription",
  behaviors: [
    {
      name: "BehaviorName", # required
      metric: "BehaviorMetric",
      criteria: {
        comparison_operator: "less-than", # accepts less-than, less-than-equals, greater-than, greater-than-equals, in-cidr-set, not-in-cidr-set, in-port-set, not-in-port-set
        value: {
          count: 1,
          cidrs: ["Cidr"],
          ports: [1],
        },
        duration_seconds: 1,
      },
    },
  ],
  alert_targets: {
    "SNS" => {
      alert_target_arn: "AlertTargetArn", # required
      role_arn: "RoleArn", # required
    },
  },
  expected_version: 1,
})

Response structure


resp.security_profile_name #=> String
resp.security_profile_arn #=> String
resp.security_profile_description #=> String
resp.behaviors #=> Array
resp.behaviors[0].name #=> String
resp.behaviors[0].metric #=> String
resp.behaviors[0].criteria.comparison_operator #=> String, one of "less-than", "less-than-equals", "greater-than", "greater-than-equals", "in-cidr-set", "not-in-cidr-set", "in-port-set", "not-in-port-set"
resp.behaviors[0].criteria.value.count #=> Integer
resp.behaviors[0].criteria.value.cidrs #=> Array
resp.behaviors[0].criteria.value.cidrs[0] #=> String
resp.behaviors[0].criteria.value.ports #=> Array
resp.behaviors[0].criteria.value.ports[0] #=> Integer
resp.behaviors[0].criteria.duration_seconds #=> Integer
resp.alert_targets #=> Hash
resp.alert_targets["AlertTargetType"].alert_target_arn #=> String
resp.alert_targets["AlertTargetType"].role_arn #=> String
resp.version #=> Integer
resp.creation_date #=> Time
resp.last_modified_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :security_profile_name (required, String) —

    The name of the security profile you want to update.

  • :security_profile_description (String) —

    A description of the security profile.

  • :behaviors (Array<Types::Behavior>) —

    Specifies the behaviors that, when violated by a device (thing), cause an alert.

  • :alert_targets (Hash<String,Types::AlertTarget>) —

    Where the alerts are sent. (Alerts are always sent to the console.)

  • :expected_version (Integer) —

    The expected version of the security profile. A new version is generated whenever the security profile is updated. If you specify a value that is different than the actual version, a ‘VersionConflictException` is thrown.

Returns:



7189
7190
7191
7192
 
# File 'lib/aws-sdk-iot/client.rb', line 7189

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

#update_stream(params = {}) ⇒ Types::UpdateStreamResponse

Updates an existing stream. The stream version will be incremented by one.

Examples:

Request syntax with placeholder values


resp = client.update_stream({
  stream_id: "StreamId", # required
  description: "StreamDescription",
  files: [
    {
      file_id: 1,
      s3_location: {
        bucket: "S3Bucket",
        key: "S3Key",
        version: "S3Version",
      },
    },
  ],
  role_arn: "RoleArn",
})

Response structure


resp.stream_id #=> String
resp.stream_arn #=> String
resp.description #=> String
resp.stream_version #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :stream_id (required, String) —

    The stream ID.

  • :description (String) —

    The description of the stream.

  • :files (Array<Types::StreamFile>) —

    The files associated with the stream.

  • :role_arn (String) —

    An IAM role that allows the IoT service principal assumes to access your S3 files.

Returns:



7244
7245
7246
7247
 
# File 'lib/aws-sdk-iot/client.rb', line 7244

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

#update_thing(params = {}) ⇒ Struct

Updates the data for a thing.

Examples:

Request syntax with placeholder values


resp = client.update_thing({
  thing_name: "ThingName", # required
  thing_type_name: "ThingTypeName",
  attribute_payload: {
    attributes: {
      "AttributeName" => "AttributeValue",
    },
    merge: false,
  },
  expected_version: 1,
  remove_thing_type: false,
})

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (required, String) —

    The name of the thing to update.

  • :thing_type_name (String) —

    The name of the thing type.

  • :attribute_payload (Types::AttributePayload) —

    A list of thing attributes, a JSON string containing name-value pairs. For example:

    ‘“attributes”:{“name1”:“value2”}`

    This data is used to add new attributes or update existing attributes.

  • :expected_version (Integer) —

    The expected version of the thing record in the registry. If the version of the record in the registry does not match the expected version specified in the request, the ‘UpdateThing` request is rejected with a `VersionConflictException`.

  • :remove_thing_type (Boolean) —

    Remove a thing type association. If true, the association is removed.

Returns:

  • (Struct) —

    Returns an empty response.



7294
7295
7296
7297
 
# File 'lib/aws-sdk-iot/client.rb', line 7294

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

#update_thing_group(params = {}) ⇒ Types::UpdateThingGroupResponse

Update a thing group.

Examples:

Request syntax with placeholder values


resp = client.update_thing_group({
  thing_group_name: "ThingGroupName", # required
  thing_group_properties: { # required
    thing_group_description: "ThingGroupDescription",
    attribute_payload: {
      attributes: {
        "AttributeName" => "AttributeValue",
      },
      merge: false,
    },
  },
  expected_version: 1,
})

Response structure


resp.version #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :thing_group_name (required, String) —

    The thing group to update.

  • :thing_group_properties (required, Types::ThingGroupProperties) —

    The thing group properties.

  • :expected_version (Integer) —

    The expected version of the thing group. If this does not match the version of the thing group being updated, the update will fail.

Returns:



7337
7338
7339
7340
 
# File 'lib/aws-sdk-iot/client.rb', line 7337

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

#update_thing_groups_for_thing(params = {}) ⇒ Struct

Updates the groups to which the thing belongs.

Examples:

Request syntax with placeholder values


resp = client.update_thing_groups_for_thing({
  thing_name: "ThingName",
  thing_groups_to_add: ["ThingGroupName"],
  thing_groups_to_remove: ["ThingGroupName"],
  override_dynamic_groups: false,
})

Parameters:

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

    ({})

Options Hash (params):

  • :thing_name (String) —

    The thing whose group memberships will be updated.

  • :thing_groups_to_add (Array<String>) —

    The groups to which the thing will be added.

  • :thing_groups_to_remove (Array<String>) —

    The groups from which the thing will be removed.

  • :override_dynamic_groups (Boolean) —

    Override dynamic thing groups with static thing groups when 10-group limit is reached. If a thing belongs to 10 thing groups, and one or more of those groups are dynamic thing groups, adding a thing to a static group removes the thing from the last dynamic group.

Returns:

  • (Struct) —

    Returns an empty response.



7372
7373
7374
7375
 
# File 'lib/aws-sdk-iot/client.rb', line 7372

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

#validate_security_profile_behaviors(params = {}) ⇒ Types::ValidateSecurityProfileBehaviorsResponse

Validates a Device Defender security profile behaviors specification.

Examples:

Request syntax with placeholder values


resp = client.validate_security_profile_behaviors({
  behaviors: [ # required
    {
      name: "BehaviorName", # required
      metric: "BehaviorMetric",
      criteria: {
        comparison_operator: "less-than", # accepts less-than, less-than-equals, greater-than, greater-than-equals, in-cidr-set, not-in-cidr-set, in-port-set, not-in-port-set
        value: {
          count: 1,
          cidrs: ["Cidr"],
          ports: [1],
        },
        duration_seconds: 1,
      },
    },
  ],
})

Response structure


resp.valid #=> Boolean
resp.validation_errors #=> Array
resp.validation_errors[0].error_message #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :behaviors (required, Array<Types::Behavior>) —

    Specifies the behaviors that, when violated by a device (thing), cause an alert.

Returns:



7416
7417
7418
7419
 
# File 'lib/aws-sdk-iot/client.rb', line 7416

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

#waiter_names ⇒ 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.

Deprecated. 


7440
7441
7442
 
# File 'lib/aws-sdk-iot/client.rb', line 7440

def waiter_names
  []
end