Class: Aws::IoT::Client

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

Overview

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

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

For details on configuring region and credentials see the developer guide.

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

Instance Attribute Summary

Attributes inherited from Seahorse::Client::Base

#config, #handlers

API Operations collapse

Instance Method Summary collapse

Methods included from ClientStubs

#api_requests, #stub_data, #stub_responses

Methods inherited from Seahorse::Client::Base

add_plugin, api, clear_plugins, define, new, #operation_names, plugins, remove_plugin, set_api, set_plugins

Methods included from Seahorse::Client::HandlerBuilder

#handle, #handle_request, #handle_response

Constructor Details

#initialize(options) ⇒ Client

Returns a new instance of Client.

Parameters:

  • options (Hash)

Options Hash (options):

  • :credentials (required, Aws::CredentialProvider)

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

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

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

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

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

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

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

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

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

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

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

    • Aws.config[:credentials]
    • The :access_key_id, :secret_access_key, and :session_token options.
    • ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY']
    • ~/.aws/credentials
    • ~/.aws/config
    • EC2/ECS IMDS instance profile - When used by default, the timeouts are very aggressive. Construct and pass an instance of Aws::InstanceProfileCredentails or Aws::ECSCredentials to enable retries and extended timeouts.
  • :region (required, String)

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

    • Aws.config[:region]
    • ENV['AWS_REGION']
    • ENV['AMAZON_REGION']
    • ENV['AWS_DEFAULT_REGION']
    • ~/.aws/credentials
    • ~/.aws/config
  • :access_key_id (String)
  • :active_endpoint_cache (Boolean) — default: false

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

  • :adaptive_retry_wait_to_fill (Boolean) — default: true

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

  • :client_side_monitoring (Boolean) — default: false

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

  • :client_side_monitoring_client_id (String) — default: ""

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

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

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

  • :client_side_monitoring_port (Integer) — default: 31000

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

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

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

  • :convert_params (Boolean) — default: true

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

  • :correct_clock_skew (Boolean) — default: true

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

  • :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 or custom endpoints. This should be a valid HTTP(S) URI.

  • :endpoint_cache_max_entries (Integer) — default: 1000

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

  • :endpoint_cache_max_threads (Integer) — default: 10

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

  • :endpoint_cache_poll_interval (Integer) — default: 60

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

  • :endpoint_discovery (Boolean) — default: false

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

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

    The log formatter.

  • :log_level (Symbol) — default: :info

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

  • :logger (Logger)

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

  • :max_attempts (Integer) — default: 3

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

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

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

  • :retry_backoff (Proc)

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

  • :retry_base_delay (Float) — default: 0.3

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

  • :retry_jitter (Symbol) — default: :none

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

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

  • :retry_limit (Integer) — default: 3

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

  • :retry_max_delay (Integer) — default: 0

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

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

    Specifies which retry algorithm to use. Values are:

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

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

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

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

  • :http_proxy (URI::HTTP, String)

    A proxy to send requests through. Formatted like 'http://proxy.com:123'.

  • :http_open_timeout (Float) — default: 15

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

  • :http_read_timeout (Integer) — default: 60

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

  • :http_idle_timeout (Float) — default: 5

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

  • :http_continue_timeout (Float) — default: 1

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

  • :http_wire_trace (Boolean) — default: false

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

  • :ssl_verify_peer (Boolean) — default: true

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

  • :ssl_ca_bundle (String)

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

  • :ssl_ca_directory (String)

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



324
325
326
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 324

def initialize(*args)
  super
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.



354
355
356
357
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 354

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.



386
387
388
389
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 386

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.



425
426
427
428
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 425

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

Examples:

Request syntax with placeholder values


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

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.

  • :namespace_id (String)

    The namespace used to indicate that a job is a customer-managed job.

    When you specify a value for this parameter, AWS IoT Core sends jobs notifications to MQTT topics that contain the value in the following format.

    $aws/things/THING_NAME/jobs/JOB_ID/notify-namespace-NAMESPACE_ID/

    The namespaceId feature is in public preview.

Returns:



487
488
489
490
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 487

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):

  • :policy_name (required, String)

    The name of the policy to attach.

  • :target (required, String)

    The identity to which the policy is attached.

Returns:

  • (Struct)

    Returns an empty response.



515
516
517
518
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 515

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.



543
544
545
546
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 543

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



570
571
572
573
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 570

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. A principal can be X.509 certificates, IAM users, groups, and roles, Amazon Cognito identities or federated identities.

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, which can be a certificate ARN (as returned from the CreateCertificate operation) or an Amazon Cognito ID.

Returns:

  • (Struct)

    Returns an empty response.



597
598
599
600
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 597

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

#cancel_audit_mitigation_actions_task(params = {}) ⇒ Struct

Cancels a mitigation action task that is in progress. If the task is not in progress, an InvalidRequestException occurs.

Examples:

Request syntax with placeholder values


resp = client.cancel_audit_mitigation_actions_task({
  task_id: "MitigationActionsTaskId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :task_id (required, String)

    The unique identifier for the task that you want to cancel.

Returns:

  • (Struct)

    Returns an empty response.



618
619
620
621
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 618

def cancel_audit_mitigation_actions_task(params = {}, options = {})
  req = build_request(:cancel_audit_mitigation_actions_task, params)
  req.send_request(options)
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 isn't 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.



641
642
643
644
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 641

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.



672
673
674
675
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 672

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

#cancel_detect_mitigation_actions_task(params = {}) ⇒ Struct

Cancels a Device Defender ML Detect mitigation action.

Examples:

Request syntax with placeholder values


resp = client.cancel_detect_mitigation_actions_task({
  task_id: "MitigationActionsTaskId", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :task_id (required, String)

    The unique identifier of the task.

Returns:

  • (Struct)

    Returns an empty response.



692
693
694
695
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 692

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



741
742
743
744
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 741

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.



796
797
798
799
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 796

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.



807
808
809
810
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 807

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

#confirm_topic_rule_destination(params = {}) ⇒ Struct

Confirms a topic rule destination. When you create a rule requiring a destination, AWS IoT sends a confirmation message to the endpoint or base address you specify. The message includes a token which you pass back when calling ConfirmTopicRuleDestination to confirm that you own or have access to the endpoint.

Examples:

Request syntax with placeholder values


resp = client.confirm_topic_rule_destination({
  confirmation_token: "ConfirmationToken", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :confirmation_token (required, String)

    The token used to confirm ownership or access to the topic rule confirmation URL.

Returns:

  • (Struct)

    Returns an empty response.



832
833
834
835
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 832

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

#create_audit_suppression(params = {}) ⇒ Struct

Creates a Device Defender audit suppression.

Examples:

Request syntax with placeholder values


resp = client.create_audit_suppression({
  check_name: "AuditCheckName", # required
  resource_identifier: { # required
    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",
    iam_role_arn: "RoleArn",
    role_alias_arn: "RoleAliasArn",
  },
  expiration_date: Time.now,
  suppress_indefinitely: false,
  description: "AuditDescription",
  client_request_token: "ClientRequestToken", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :check_name (required, String)

    An audit check name. Checks must be enabled for your account. (Use DescribeAccountAuditConfiguration to see the list of all checks, including those that are enabled or use UpdateAccountAuditConfiguration to select which checks are enabled.)

  • :resource_identifier (required, Types::ResourceIdentifier)

    Information that identifies the noncompliant resource.

  • :expiration_date (Time, DateTime, Date, Integer, String)

    The epoch timestamp in seconds at which this suppression expires.

  • :suppress_indefinitely (Boolean)

    Indicates whether a suppression should exist indefinitely or not.

  • :description (String)

    The description of the audit suppression.

  • :client_request_token (required, String)

    The epoch timestamp in seconds at which this suppression expires.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:

  • (Struct)

    Returns an empty response.



890
891
892
893
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 890

def create_audit_suppression(params = {}, options = {})
  req = build_request(:create_audit_suppression, 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",
  token_signing_public_keys: {
    "KeyName" => "KeyValue",
  },
  status: "ACTIVE", # accepts ACTIVE, INACTIVE
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue",
    },
  ],
  signing_disabled: false,
})

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 (String)

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

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

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

    Metadata which can be used to manage the custom authorizer.

    For URI Request parameters use format: ...key1=value1&key2=value2...

    For the CLI command-line parameter use format: &&tags "key1=value1&key2=value2..."

    For the cli-input-json file use format: "tags": "key1=value1&key2=value2..."

  • :signing_disabled (Boolean)

    Specifies whether AWS IoT validates the token signature in an authorization request.

Returns:



963
964
965
966
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 963

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", # required
      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:



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

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:

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

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



1089
1090
1091
1092
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 1089

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

#create_custom_metric(params = {}) ⇒ Types::CreateCustomMetricResponse

Use this API to define a Custom Metric published by your devices to Device Defender.

Examples:

Request syntax with placeholder values


resp = client.create_custom_metric({
  metric_name: "MetricName", # required
  display_name: "CustomMetricDisplayName",
  metric_type: "string-list", # required, accepts string-list, ip-address-list, number-list, number
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue",
    },
  ],
  client_request_token: "ClientRequestToken", # required
})

Response structure


resp.metric_name #=> String
resp.metric_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :metric_name (required, String)

    The name of the custom metric. This will be used in the metric report submitted from the device/thing. Shouldn't begin with aws:. Cannot be updated once defined.

  • :display_name (String)

    Field represents a friendly name in the console for the custom metric; it doesn't have to be unique. Don't use this name as the metric identifier in the device metric report. Can be updated once defined.

  • :metric_type (required, String)

    The type of the custom metric. Types include string-list, ip-address-list, number-list, and number.

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

    Metadata that can be used to manage the custom metric.

  • :client_request_token (required, String)

    Each custom metric must have a unique client request token. If you try to create a new custom metric that already exists with a different token, an exception occurs. If you omit this value, AWS SDKs will automatically generate a unique client request.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:



1150
1151
1152
1153
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 1150

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

#create_dimension(params = {}) ⇒ Types::CreateDimensionResponse

Create a dimension that you can use to limit the scope of a metric used in a security profile for AWS IoT Device Defender. For example, using a TOPIC_FILTER dimension, you can narrow down the scope of the metric only to MQTT topics whose name match the pattern specified in the dimension.

Examples:

Request syntax with placeholder values


resp = client.create_dimension({
  name: "DimensionName", # required
  type: "TOPIC_FILTER", # required, accepts TOPIC_FILTER
  string_values: ["DimensionStringValue"], # required
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue",
    },
  ],
  client_request_token: "ClientRequestToken", # required
})

Response structure


resp.name #=> String
resp.arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String)

    A unique identifier for the dimension. Choose something that describes the type and value to make it easy to remember what it does.

  • :type (required, String)

    Specifies the type of dimension. Supported types: TOPIC_FILTER.

  • :string_values (required, Array<String>)

    Specifies the value or list of values for the dimension. For TOPIC_FILTER dimensions, this is a pattern used to match the MQTT topic (for example, "admin/#").

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

    Metadata that can be used to manage the dimension.

  • :client_request_token (required, String)

    Each dimension must have a unique client request token. If you try to create a new dimension with the same token as a dimension that already exists, an exception occurs. If you omit this value, AWS SDKs will automatically generate a unique client request.

    A suitable default value is auto-generated. You should normally not need to pass this option.**

Returns:



1212
1213
1214
1215
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 1212

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

#create_domain_configuration(params = {}) ⇒ Types::CreateDomainConfigurationResponse

Creates a domain configuration.

The domain configuration feature is in public preview and is subject to change.

Examples:

Request syntax with placeholder values


resp = client.create_domain_configuration({
  domain_configuration_name: "DomainConfigurationName", # required
  domain_name: "DomainName",
  server_certificate_arns: ["AcmCertificateArn"],
  validation_certificate_arn: "AcmCertificateArn",
  authorizer_config: {
    default_authorizer_name: "AuthorizerName",
    allow_authorizer_override: false,
  },
  service_type: "DATA", # accepts DATA, CREDENTIAL_PROVIDER, JOBS
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue",
    },
  ],
})

Response structure


resp.domain_configuration_name #=> String
resp.domain_configuration_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :domain_configuration_name (required, String)

    The name of the domain configuration. This value must be unique to a region.

  • :domain_name (String)

    The name of the domain.

  • :server_certificate_arns (Array<String>)

    The ARNs of the certificates that AWS IoT passes to the device during the TLS handshake. Currently you can specify only one certificate ARN. This value is not required for AWS-managed domains.

  • :validation_certificate_arn (String)

    The certificate used to validate the server certificate and prove domain name ownership. This certificate must be signed by a public certificate authority. This value is not required for AWS-managed domains.

  • :authorizer_config (Types::AuthorizerConfig)

    An object that specifies the authorization service for a domain.

  • :service_type (String)

    The type of service delivered by the endpoint.

    AWS IoT Core currently supports only the DATA service type.

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

    Metadata which can be used to manage the domain configuration.

    For URI Request parameters use format: ...key1=value1&key2=value2...

    For the CLI command-line parameter use format: &&tags "key1=value1&key2=value2..."

    For the cli-input-json file use format: "tags": "key1=value1&key2=value2..."

Returns:



1298
1299
1300
1301
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 1298

def create_domain_configuration(params = {}, options = {})
  req = build_request(:create_domain_configuration, 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", # required
      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.

    Currently one index is supported: "AWS_Things".

  • :query_string (required, String)

    The dynamic thing group search query string.

    See Query Syntax for information about query string syntax.

  • :query_version (String)

    The dynamic thing group query version.

    Currently one query version is supported: "2017-09-30". If not specified, the query version defaults to this value.

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

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

Returns:



1382
1383
1384
1385
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 1382

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", # required
      value: "TagValue",
    },
  ],
  namespace_id: "NamespaceId",
})

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.

    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.

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

  • :namespace_id (String)

    The namespace used to indicate that a job is a customer-managed job.

    When you specify a value for this parameter, AWS IoT Core sends jobs notifications to MQTT topics that contain the value in the following format.

    $aws/things/THING_NAME/jobs/JOB_ID/notify-namespace-NAMESPACE_ID/

    The namespaceId feature is in public preview.

Returns:



1518
1519
1520
1521
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 1518

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. You can also call CreateKeysAndCertificate over MQTT from a device, for more information, see Provisioning MQTT API.

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:



1561
1562
1563
1564
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 1561

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

#create_mitigation_action(params = {}) ⇒ Types::CreateMitigationActionResponse

Defines an action that can be applied to audit findings by using StartAuditMitigationActionsTask. Only certain types of mitigation actions can be applied to specific check names. For more information, see Mitigation actions. Each mitigation action can apply only one type of change.

Examples:

Request syntax with placeholder values


resp = client.create_mitigation_action({
  action_name: "MitigationActionName", # required
  role_arn: "RoleArn", # required
  action_params: { # required
    update_device_certificate_params: {
      action: "DEACTIVATE", # required, accepts DEACTIVATE
    },
    update_ca_certificate_params: {
      action: "DEACTIVATE", # required, accepts DEACTIVATE
    },
    add_things_to_thing_group_params: {
      thing_group_names: ["ThingGroupName"], # required
      override_dynamic_groups: false,
    },
    replace_default_policy_version_params: {
      template_name: "BLANK_POLICY", # required, accepts BLANK_POLICY
    },
    enable_io_t_logging_params: {
      role_arn_for_logging: "RoleArn", # required
      log_level: "DEBUG", # required, accepts DEBUG, INFO, ERROR, WARN, DISABLED
    },
    publish_finding_to_sns_params: {
      topic_arn: "SnsTopicArn", # required
    },
  },
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue",
    },
  ],
})

Response structure


resp.action_arn #=> String
resp.action_id #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :action_name (required, String)

    A friendly name for the action. Choose a friendly name that accurately describes the action (for example, EnableLoggingAction).

  • :role_arn (required, String)

    The ARN of the IAM role that is used to apply the mitigation action.

  • :action_params (required, Types::MitigationActionParams)

    Defines the type of action and the parameters for that action.

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

    Metadata that can be used to manage the mitigation action.

Returns:



1636
1637
1638
1639
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 1636

def create_mitigation_action(params = {}, options = {})
  req = build_request(:create_mitigation_action, 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
  protocols: ["MQTT"], # accepts MQTT, HTTP
  target_selection: "CONTINUOUS", # accepts CONTINUOUS, SNAPSHOT
  aws_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,
      },
    },
  },
  aws_job_presigned_url_config: {
    expires_in_sec: 1,
  },
  aws_job_abort_config: {
    abort_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
      },
    ],
  },
  aws_job_timeout_config: {
    in_progress_timeout_in_minutes: 1,
  },
  files: [ # required
    {
      file_name: "FileName",
      file_type: 1,
      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",
  },
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue",
    },
  ],
})

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 devices targeted to receive OTA updates.

  • :protocols (Array<String>)

    The protocol used to transfer the OTA update image. Valid values are [HTTP], [MQTT], [HTTP, MQTT]. When both HTTP and MQTT are specified, the target device can choose the protocol.

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

  • :aws_job_presigned_url_config (Types::AwsJobPresignedUrlConfig)

    Configuration information for pre-signed URLs.

  • :aws_job_abort_config (Types::AwsJobAbortConfig)

    The criteria that determine when and how a job abort takes place.

  • :aws_job_timeout_config (Types::AwsJobTimeoutConfig)

    Specifies the amount of time each device has to finish its execution of the job. A 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 timer expires, it will be automatically set to TIMED_OUT.

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

    The files to be streamed by the OTA update.

  • :role_arn (required, String)

    The IAM role that grants AWS IoT access to the Amazon S3, AWS IoT jobs and AWS Code Signing resources to create an OTA update job.

  • :additional_parameters (Hash<String,String>)

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

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

    Metadata which can be used to manage updates.

Returns:



1809
1810
1811
1812
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 1809

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
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue",
    },
  ],
})

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.

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

    Metadata which can be used to manage the policy.

    For URI Request parameters use format: ...key1=value1&key2=value2...

    For the CLI command-line parameter use format: &&tags "key1=value1&key2=value2..."

    For the cli-input-json file use format: "tags": "key1=value1&key2=value2..."

Returns:



1871
1872
1873
1874
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 1871

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:



1924
1925
1926
1927
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 1924

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

#create_provisioning_claim(params = {}) ⇒ Types::CreateProvisioningClaimResponse

Creates a provisioning claim.

Examples:

Request syntax with placeholder values


resp = client.create_provisioning_claim({
  template_name: "TemplateName", # required
})

Response structure


resp.certificate_id #=> String
resp.certificate_pem #=> String
resp.key_pair.public_key #=> String
resp.key_pair.private_key #=> String
resp.expiration #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :template_name (required, String)

    The name of the provisioning template to use.

Returns:



1957
1958
1959
1960
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 1957

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

#create_provisioning_template(params = {}) ⇒ Types::CreateProvisioningTemplateResponse

Creates a fleet provisioning template.

Examples:

Request syntax with placeholder values


resp = client.create_provisioning_template({
  template_name: "TemplateName", # required
  description: "TemplateDescription",
  template_body: "TemplateBody", # required
  enabled: false,
  provisioning_role_arn: "RoleArn", # required
  pre_provisioning_hook: {
    payload_version: "PayloadVersion",
    target_arn: "TargetArn", # required
  },
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue",
    },
  ],
})

Response structure


resp.template_arn #=> String
resp.template_name #=> String
resp.default_version_id #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :template_name (required, String)

    The name of the fleet provisioning template.

  • :description (String)

    The description of the fleet provisioning template.

  • :template_body (required, String)

    The JSON formatted contents of the fleet provisioning template.

  • :enabled (Boolean)

    True to enable the fleet provisioning template, otherwise false.

  • :provisioning_role_arn (required, String)

    The role ARN for the role associated with the fleet provisioning template. This IoT role grants permission to provision a device.

  • :pre_provisioning_hook (Types::ProvisioningHook)

    Creates a pre-provisioning hook template.

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

    Metadata which can be used to manage the fleet provisioning template.

    For URI Request parameters use format: ...key1=value1&key2=value2...

    For the CLI command-line parameter use format: &&tags "key1=value1&key2=value2..."

    For the cli-input-json file use format: "tags": "key1=value1&key2=value2..."

Returns:



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

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

#create_provisioning_template_version(params = {}) ⇒ Types::CreateProvisioningTemplateVersionResponse

Creates a new version of a fleet provisioning template.

Examples:

Request syntax with placeholder values


resp = client.create_provisioning_template_version({
  template_name: "TemplateName", # required
  template_body: "TemplateBody", # required
  set_as_default: false,
})

Response structure


resp.template_arn #=> String
resp.template_name #=> String
resp.version_id #=> Integer
resp.is_default_version #=> Boolean

Parameters:

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

    ({})

Options Hash (params):

  • :template_name (required, String)

    The name of the fleet provisioning template.

  • :template_body (required, String)

    The JSON formatted contents of the fleet provisioning template.

  • :set_as_default (Boolean)

    Sets a fleet provision template version as the default version.

Returns:



2071
2072
2073
2074
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 2071

def create_provisioning_template_version(params = {}, options = {})
  req = build_request(:create_provisioning_template_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,
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue",
    },
  ],
})

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.

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

    Metadata which can be used to manage the role alias.

    For URI Request parameters use format: ...key1=value1&key2=value2...

    For the CLI command-line parameter use format: &&tags "key1=value1&key2=value2..."

    For the cli-input-json file use format: "tags": "key1=value1&key2=value2..."

Returns:



2128
2129
2130
2131
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 2128

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
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue",
    },
  ],
})

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, either DAILY, WEEKLY, BIWEEKLY or MONTHLY. The 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. This can be "1" through "31" or "LAST". This field is required if the "frequency" parameter is set to MONTHLY. If days 29 to 31 are specified, and the month doesn't 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, either 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 use 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)

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

    Metadata that can be used to manage the scheduled audit.

Returns:



2191
2192
2193
2194
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 2191

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: [
    {
      name: "BehaviorName", # required
      metric: "BehaviorMetric",
      metric_dimension: {
        dimension_name: "DimensionName", # required
        operator: "IN", # accepts IN, NOT_IN
      },
      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, in-set, not-in-set
        value: {
          count: 1,
          cidrs: ["Cidr"],
          ports: [1],
          number: 1.0,
          numbers: [1.0],
          strings: ["stringValue"],
        },
        duration_seconds: 1,
        consecutive_datapoints_to_alarm: 1,
        consecutive_datapoints_to_clear: 1,
        statistical_threshold: {
          statistic: "EvaluationStatistic",
        },
        ml_detection_config: {
          confidence_level: "LOW", # required, accepts LOW, MEDIUM, HIGH
        },
      },
      suppress_alerts: false,
    },
  ],
  alert_targets: {
    "SNS" => {
      alert_target_arn: "AlertTargetArn", # required
      role_arn: "RoleArn", # required
    },
  },
  additional_metrics_to_retain: ["BehaviorMetric"],
  additional_metrics_to_retain_v2: [
    {
      metric: "BehaviorMetric", # required
      metric_dimension: {
        dimension_name: "DimensionName", # required
        operator: "IN", # accepts IN, NOT_IN
      },
    },
  ],
  tags: [
    {
      key: "TagKey", # required
      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 (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.

  • :additional_metrics_to_retain (Array<String>)

    Please use CreateSecurityProfileRequest$additionalMetricsToRetainV2 instead.

    A list of metrics whose data is retained (stored). By default, data is retained for any metric used in the profile's behaviors, but it is also retained for any metric specified here. Can be used with custom metrics; cannot be used with dimensions.

  • :additional_metrics_to_retain_v2 (Array<Types::MetricToRetain>)

    A list of metrics whose data is retained (stored). By default, data is retained for any metric used in the profile's behaviors, but it is also retained for any metric specified here. Can be used with custom metrics; cannot be used with dimensions.

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

    Metadata that can be used to manage the security profile.

Returns:



2303
2304
2305
2306
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 2303

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.

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
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue",
    },
  ],
})

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.

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

    Metadata which can be used to manage streams.

Returns:



2369
2370
2371
2372
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 2369

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. If this call is made multiple times using the same thing name and configuration, the call will succeed. If this call is made with the same thing name but different configuration a ResourceAlreadyExistsException is thrown.

This is a control plane operation. See Authorization for information about authorizing control plane actions.

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.

    You can't change a thing's name after you create it. To change a thing's name, you must create a new thing, give it the new name, and then delete the old thing.

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



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

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.

This is a control plane operation. See Authorization for information about authorizing control plane actions.

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", # required
      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:



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

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", # required
      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:



2547
2548
2549
2550
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 2547

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
          qos: 1,
        },
        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",
          batch_mode: false,
        },
        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
        },
        cloudwatch_logs: {
          role_arn: "AwsArn", # required
          log_group_name: "LogGroupName", # 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",
          batch_mode: false,
          role_arn: "AwsArn",
        },
        iot_events: {
          input_name: "InputName", # required
          message_id: "MessageId",
          batch_mode: false,
          role_arn: "AwsArn", # required
        },
        iot_site_wise: {
          put_asset_property_value_entries: [ # required
            {
              entry_id: "AssetPropertyEntryId",
              asset_id: "AssetId",
              property_id: "AssetPropertyId",
              property_alias: "AssetPropertyAlias",
              property_values: [ # required
                {
                  value: { # required
                    string_value: "AssetPropertyStringValue",
                    integer_value: "AssetPropertyIntegerValue",
                    double_value: "AssetPropertyDoubleValue",
                    boolean_value: "AssetPropertyBooleanValue",
                  },
                  timestamp: { # required
                    time_in_seconds: "AssetPropertyTimeInSeconds", # required
                    offset_in_nanos: "AssetPropertyOffsetInNanos",
                  },
                  quality: "AssetPropertyQuality",
                },
              ],
            },
          ],
          role_arn: "AwsArn", # required
        },
        step_functions: {
          execution_name_prefix: "ExecutionNamePrefix",
          state_machine_name: "StateMachineName", # required
          role_arn: "AwsArn", # required
        },
        timestream: {
          role_arn: "AwsArn", # required
          database_name: "TimestreamDatabaseName", # required
          table_name: "TimestreamTableName", # required
          dimensions: [ # required
            {
              name: "TimestreamDimensionName", # required
              value: "TimestreamDimensionValue", # required
            },
          ],
          timestamp: {
            value: "TimestreamTimestampValue", # required
            unit: "TimestreamTimestampUnit", # required
          },
        },
        http: {
          url: "Url", # required
          confirmation_url: "Url",
          headers: [
            {
              key: "HeaderKey", # required
              value: "HeaderValue", # required
            },
          ],
          auth: {
            sigv4: {
              signing_region: "SigningRegion", # required
              service_name: "ServiceName", # required
              role_arn: "AwsArn", # required
            },
          },
        },
        kafka: {
          destination_arn: "AwsArn", # required
          topic: "String", # required
          key: "String",
          partition: "String",
          client_properties: { # required
            "String" => "String",
          },
        },
      },
    ],
    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
        qos: 1,
      },
      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",
        batch_mode: false,
      },
      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
      },
      cloudwatch_logs: {
        role_arn: "AwsArn", # required
        log_group_name: "LogGroupName", # 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",
        batch_mode: false,
        role_arn: "AwsArn",
      },
      iot_events: {
        input_name: "InputName", # required
        message_id: "MessageId",
        batch_mode: false,
        role_arn: "AwsArn", # required
      },
      iot_site_wise: {
        put_asset_property_value_entries: [ # required
          {
            entry_id: "AssetPropertyEntryId",
            asset_id: "AssetId",
            property_id: "AssetPropertyId",
            property_alias: "AssetPropertyAlias",
            property_values: [ # required
              {
                value: { # required
                  string_value: "AssetPropertyStringValue",
                  integer_value: "AssetPropertyIntegerValue",
                  double_value: "AssetPropertyDoubleValue",
                  boolean_value: "AssetPropertyBooleanValue",
                },
                timestamp: { # required
                  time_in_seconds: "AssetPropertyTimeInSeconds", # required
                  offset_in_nanos: "AssetPropertyOffsetInNanos",
                },
                quality: "AssetPropertyQuality",
              },
            ],
          },
        ],
        role_arn: "AwsArn", # required
      },
      step_functions: {
        execution_name_prefix: "ExecutionNamePrefix",
        state_machine_name: "StateMachineName", # required
        role_arn: "AwsArn", # required
      },
      timestream: {
        role_arn: "AwsArn", # required
        database_name: "TimestreamDatabaseName", # required
        table_name: "TimestreamTableName", # required
        dimensions: [ # required
          {
            name: "TimestreamDimensionName", # required
            value: "TimestreamDimensionValue", # required
          },
        ],
        timestamp: {
          value: "TimestreamTimestampValue", # required
          unit: "TimestreamTimestampUnit", # required
        },
      },
      http: {
        url: "Url", # required
        confirmation_url: "Url",
        headers: [
          {
            key: "HeaderKey", # required
            value: "HeaderValue", # required
          },
        ],
        auth: {
          sigv4: {
            signing_region: "SigningRegion", # required
            service_name: "ServiceName", # required
            role_arn: "AwsArn", # required
          },
        },
      },
      kafka: {
        destination_arn: "AwsArn", # required
        topic: "String", # required
        key: "String",
        partition: "String",
        client_properties: { # required
          "String" => "String",
        },
      },
    },
  },
  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.

    For URI Request parameters use format: ...key1=value1&key2=value2...

    For the CLI command-line parameter use format: --tags "key1=value1&key2=value2..."

    For the cli-input-json file use format: "tags": "key1=value1&key2=value2..."

Returns:

  • (Struct)

    Returns an empty response.



2931
2932
2933
2934
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 2931

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

#create_topic_rule_destination(params = {}) ⇒ Types::CreateTopicRuleDestinationResponse

Creates a topic rule destination. The destination must be confirmed prior to use.

Examples:

Request syntax with placeholder values


resp = client.create_topic_rule_destination({
  destination_configuration: { # required
    http_url_configuration: {
      confirmation_url: "Url", # required
    },
    vpc_configuration: {
      subnet_ids: ["SubnetId"], # required
      security_groups: ["SecurityGroupId"],
      vpc_id: "VpcId", # required
      role_arn: "AwsArn", # required
    },
  },
})

Response structure


resp.topic_rule_destination.arn #=> String
resp.topic_rule_destination.status #=> String, one of "ENABLED", "IN_PROGRESS", "DISABLED", "ERROR", "DELETING"
resp.topic_rule_destination.created_at #=> Time
resp.topic_rule_destination.last_updated_at #=> Time
resp.topic_rule_destination.status_reason #=> String
resp.topic_rule_destination.http_url_properties.confirmation_url #=> String
resp.topic_rule_destination.vpc_properties.subnet_ids #=> Array
resp.topic_rule_destination.vpc_properties.subnet_ids[0] #=> String
resp.topic_rule_destination.vpc_properties.security_groups #=> Array
resp.topic_rule_destination.vpc_properties.security_groups[0] #=> String
resp.topic_rule_destination.vpc_properties.vpc_id #=> String
resp.topic_rule_destination.vpc_properties.role_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

Returns:



2979
2980
2981
2982
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 2979

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



3001
3002
3003
3004
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3001

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

#delete_audit_suppression(params = {}) ⇒ Struct

Deletes a Device Defender audit suppression.

Examples:

Request syntax with placeholder values


resp = client.delete_audit_suppression({
  check_name: "AuditCheckName", # required
  resource_identifier: { # required
    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",
    iam_role_arn: "RoleArn",
    role_alias_arn: "RoleAliasArn",
  },
})

Parameters:

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

    ({})

Options Hash (params):

  • :check_name (required, String)

    An audit check name. Checks must be enabled for your account. (Use DescribeAccountAuditConfiguration to see the list of all checks, including those that are enabled or use UpdateAccountAuditConfiguration to select which checks are enabled.)

  • :resource_identifier (required, Types::ResourceIdentifier)

    Information that identifies the noncompliant resource.

Returns:

  • (Struct)

    Returns an empty response.



3040
3041
3042
3043
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3040

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



3060
3061
3062
3063
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3060

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.



3087
3088
3089
3090
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3087

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.



3108
3109
3110
3111
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3108

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 or IoT thing 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 the deletion of a certificate if it is inactive and is not attached to an IoT thing.

Returns:

  • (Struct)

    Returns an empty response.



3140
3141
3142
3143
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3140

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

#delete_custom_metric(params = {}) ⇒ Struct

Before you can delete a custom metric, you must first remove the custom metric from all security profiles it's a part of. The security profile associated with the custom metric can be found using the ListSecurityProfiles API with metricName set to your custom metric name.

Deletes a Device Defender detect custom metric.

Examples:

Request syntax with placeholder values


resp = client.delete_custom_metric({
  metric_name: "MetricName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :metric_name (required, String)

    The name of the custom metric.

Returns:

  • (Struct)

    Returns an empty response.



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

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

#delete_dimension(params = {}) ⇒ Struct

Removes the specified dimension from your AWS account.

Examples:

Request syntax with placeholder values


resp = client.delete_dimension({
  name: "DimensionName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String)

    The unique identifier for the dimension that you want to delete.

Returns:

  • (Struct)

    Returns an empty response.



3192
3193
3194
3195
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3192

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

#delete_domain_configuration(params = {}) ⇒ Struct

Deletes the specified domain configuration.

The domain configuration feature is in public preview and is subject to change.

Examples:

Request syntax with placeholder values


resp = client.delete_domain_configuration({
  domain_configuration_name: "DomainConfigurationName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :domain_configuration_name (required, String)

    The name of the domain configuration to be deleted.

Returns:

  • (Struct)

    Returns an empty response.



3217
3218
3219
3220
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3217

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



3241
3242
3243
3244
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3241

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,
  namespace_id: "NamespaceId",
})

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.

    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.

  • :namespace_id (String)

    The namespace used to indicate that a job is a customer-managed job.

    When you specify a value for this parameter, AWS IoT Core sends jobs notifications to MQTT topics that contain the value in the following format.

    $aws/things/THING_NAME/jobs/JOB_ID/notify-namespace-NAMESPACE_ID/

    The namespaceId feature is in public preview.

Returns:

  • (Struct)

    Returns an empty response.



3303
3304
3305
3306
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3303

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,
  namespace_id: "NamespaceId",
})

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.

    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.

  • :namespace_id (String)

    The namespace used to indicate that a job is a customer-managed job.

    When you specify a value for this parameter, AWS IoT Core sends jobs notifications to MQTT topics that contain the value in the following format.

    $aws/things/THING_NAME/jobs/JOB_ID/notify-namespace-NAMESPACE_ID/

    The namespaceId feature is in public preview.

Returns:

  • (Struct)

    Returns an empty response.



3365
3366
3367
3368
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3365

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

#delete_mitigation_action(params = {}) ⇒ Struct

Deletes a defined mitigation action from your AWS account.

Examples:

Request syntax with placeholder values


resp = client.delete_mitigation_action({
  action_name: "MitigationActionName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :action_name (required, String)

    The name of the mitigation action that you want to delete.

Returns:

  • (Struct)

    Returns an empty response.



3385
3386
3387
3388
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3385

def delete_mitigation_action(params = {}, options = {})
  req = build_request(:delete_mitigation_action, 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 ID of the OTA update to delete.

  • :delete_stream (Boolean)

    When true, the stream created by the OTAUpdate process is deleted when the OTA update is deleted. Ignored if the stream specified in the OTAUpdate is supplied by the user.

  • :force_delete_aws_job (Boolean)

    When true, deletes the AWS job created by the OTAUpdate process even if it is "IN_PROGRESS". Otherwise, if the job is not in a terminal state ("COMPLETED" or "CANCELED") an exception will occur. The default is false.

Returns:

  • (Struct)

    Returns an empty response.



3418
3419
3420
3421
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3418

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.



3449
3450
3451
3452
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3449

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.



3477
3478
3479
3480
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3477

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

#delete_provisioning_template(params = {}) ⇒ Struct

Deletes a fleet provisioning template.

Examples:

Request syntax with placeholder values


resp = client.delete_provisioning_template({
  template_name: "TemplateName", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :template_name (required, String)

    The name of the fleet provision template to delete.

Returns:

  • (Struct)

    Returns an empty response.



3497
3498
3499
3500
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3497

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

#delete_provisioning_template_version(params = {}) ⇒ Struct

Deletes a fleet provisioning template version.

Examples:

Request syntax with placeholder values


resp = client.delete_provisioning_template_version({
  template_name: "TemplateName", # required
  version_id: 1, # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :template_name (required, String)

    The name of the fleet provisioning template version to delete.

  • :version_id (required, Integer)

    The fleet provisioning template version ID to delete.

Returns:

  • (Struct)

    Returns an empty response.



3521
3522
3523
3524
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3521

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



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

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.



3552
3553
3554
3555
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3552

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.



3572
3573
3574
3575
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3572

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 from the actual version, a VersionConflictException is thrown.

Returns:

  • (Struct)

    Returns an empty response.



3599
3600
3601
3602
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3599

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.



3619
3620
3621
3622
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3619

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.



3647
3648
3649
3650
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3647

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.



3671
3672
3673
3674
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3671

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.



3696
3697
3698
3699
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3696

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.



3716
3717
3718
3719
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3716

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

#delete_topic_rule_destination(params = {}) ⇒ Struct

Deletes a topic rule destination.

Examples:

Request syntax with placeholder values


resp = client.delete_topic_rule_destination({
  arn: "AwsArn", # required
})

Parameters:

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

    ({})

Options Hash (params):

  • :arn (required, String)

    The ARN of the topic rule destination to delete.

Returns:

  • (Struct)

    Returns an empty response.



3736
3737
3738
3739
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3736

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



3761
3762
3763
3764
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3761

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.



3788
3789
3790
3791
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3788

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:



3815
3816
3817
3818
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3815

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

#describe_audit_finding(params = {}) ⇒ Types::DescribeAuditFindingResponse

Gets information about a single audit finding. Properties include the reason for noncompliance, the severity of the issue, and the start time when the audit that returned the finding.

Examples:

Request syntax with placeholder values


resp = client.describe_audit_finding({
  finding_id: "FindingId", # required
})

Response structure


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

Parameters:

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

    ({})

Options Hash (params):

  • :finding_id (required, String)

    A unique identifier for a single audit finding. You can use this identifier to apply mitigation actions to the finding.

Returns:



3877
3878
3879
3880
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3877

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

#describe_audit_mitigation_actions_task(params = {}) ⇒ Types::DescribeAuditMitigationActionsTaskResponse

Gets information about an audit mitigation task that is used to apply mitigation actions to a set of audit findings. Properties include the actions being applied, the audit checks to which they're being applied, the task status, and aggregated task statistics.

Examples:

Request syntax with placeholder values


resp = client.describe_audit_mitigation_actions_task({
  task_id: "MitigationActionsTaskId", # required
})

Response structure


resp.task_status #=> String, one of "IN_PROGRESS", "COMPLETED", "FAILED", "CANCELED"
resp.start_time #=> Time
resp.end_time #=> Time
resp.task_statistics #=> Hash
resp.task_statistics["AuditCheckName"].total_findings_count #=> Integer
resp.task_statistics["AuditCheckName"].failed_findings_count #=> Integer
resp.task_statistics["AuditCheckName"].succeeded_findings_count #=> Integer
resp.task_statistics["AuditCheckName"].skipped_findings_count #=> Integer
resp.task_statistics["AuditCheckName"].canceled_findings_count #=> Integer
resp.target.audit_task_id #=> String
resp.target.finding_ids #=> Array
resp.target.finding_ids[0] #=> String
resp.target.audit_check_to_reason_code_filter #=> Hash
resp.target.audit_check_to_reason_code_filter["AuditCheckName"] #=> Array
resp.target.audit_check_to_reason_code_filter["AuditCheckName"][0] #=> String
resp.audit_check_to_actions_mapping #=> Hash
resp.audit_check_to_actions_mapping["AuditCheckName"] #=> Array
resp.audit_check_to_actions_mapping["AuditCheckName"][0] #=> String
resp.actions_definition #=> Array
resp.actions_definition[0].name #=> String
resp.actions_definition[0].id #=> String
resp.actions_definition[0].role_arn #=> String
resp.actions_definition[0].action_params.update_device_certificate_params.action #=> String, one of "DEACTIVATE"
resp.actions_definition[0].action_params.update_ca_certificate_params.action #=> String, one of "DEACTIVATE"
resp.actions_definition[0].action_params.add_things_to_thing_group_params.thing_group_names #=> Array
resp.actions_definition[0].action_params.add_things_to_thing_group_params.thing_group_names[0] #=> String
resp.actions_definition[0].action_params.add_things_to_thing_group_params.override_dynamic_groups #=> Boolean
resp.actions_definition[0].action_params.replace_default_policy_version_params.template_name #=> String, one of "BLANK_POLICY"
resp.actions_definition[0].action_params.enable_io_t_logging_params.role_arn_for_logging #=> String
resp.actions_definition[0].action_params.enable_io_t_logging_params.log_level #=> String, one of "DEBUG", "INFO", "ERROR", "WARN", "DISABLED"
resp.actions_definition[0].action_params.publish_finding_to_sns_params.topic_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :task_id (required, String)

    The unique identifier for the audit mitigation task.

Returns:



3942
3943
3944
3945
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 3942

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

#describe_audit_suppression(params = {}) ⇒ Types::DescribeAuditSuppressionResponse

Gets information about a Device Defender audit suppression.

Examples:

Request syntax with placeholder values


resp = client.describe_audit_suppression({
  check_name: "AuditCheckName", # required
  resource_identifier: { # required
    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",
    iam_role_arn: "RoleArn",
    role_alias_arn: "RoleAliasArn",
  },
})

Response structure


resp.check_name #=> String
resp.resource_identifier.device_certificate_id #=> String
resp.resource_identifier.ca_certificate_id #=> String
resp.resource_identifier.cognito_identity_pool_id #=> String
resp.resource_identifier.client_id #=> String
resp.resource_identifier.policy_version_identifier.policy_name #=> String
resp.resource_identifier.policy_version_identifier.policy_version_id #=> String
resp.resource_identifier. #=> String
resp.resource_identifier.iam_role_arn #=> String
resp.resource_identifier.role_alias_arn #=> String
resp.expiration_date #=> Time
resp.suppress_indefinitely #=> Boolean
resp.description #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :check_name (required, String)

    An audit check name. Checks must be enabled for your account. (Use DescribeAccountAuditConfiguration to see the list of all checks, including those that are enabled or use UpdateAccountAuditConfiguration to select which checks are enabled.)

  • :resource_identifier (required, Types::ResourceIdentifier)

    Information that identifies the noncompliant resource.

Returns:



4003
4004
4005
4006
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4003

def describe_audit_suppression(params = {}, options = {})
  req = build_request(:describe_audit_suppression, 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"].suppressed_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:



4052
4053
4054
4055
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4052

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
resp.authorizer_description.signing_disabled #=> Boolean

Parameters:

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

    ({})

Options Hash (params):

  • :authorizer_name (required, String)

    The name of the authorizer to describe.

Returns:



4087
4088
4089
4090
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4087

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..creation_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :billing_group_name (required, String)

    The name of the billing group.

Returns:



4123
4124
4125
4126
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4123

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:



4163
4164
4165
4166
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4163

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
resp.certificate_description.certificate_mode #=> String, one of "DEFAULT", "SNI_ONLY"

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:



4208
4209
4210
4211
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4208

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

#describe_custom_metric(params = {}) ⇒ Types::DescribeCustomMetricResponse

Gets information about a Device Defender detect custom metric.

Examples:

Request syntax with placeholder values


resp = client.describe_custom_metric({
  metric_name: "MetricName", # required
})

Response structure


resp.metric_name #=> String
resp.metric_arn #=> String
resp.metric_type #=> String, one of "string-list", "ip-address-list", "number-list", "number"
resp.display_name #=> String
resp.creation_date #=> Time
resp.last_modified_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :metric_name (required, String)

    The name of the custom metric.

Returns:



4244
4245
4246
4247
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4244

def describe_custom_metric(params = {}, options = {})
  req = build_request(:describe_custom_metric, 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
resp.authorizer_description.signing_disabled #=> Boolean

Parameters:

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

    ({})

Returns:



4270
4271
4272
4273
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4270

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

#describe_detect_mitigation_actions_task(params = {}) ⇒ Types::DescribeDetectMitigationActionsTaskResponse

Gets information about a Device Defender ML Detect mitigation action.

Examples:

Request syntax with placeholder values


resp = client.describe_detect_mitigation_actions_task({
  task_id: "MitigationActionsTaskId", # required
})

Response structure


resp.task_summary.task_id #=> String
resp.task_summary.task_status #=> String, one of "IN_PROGRESS", "SUCCESSFUL", "FAILED", "CANCELED"
resp.task_summary.task_start_time #=> Time
resp.task_summary.task_end_time #=> Time
resp.task_summary.target.violation_ids #=> Array
resp.task_summary.target.violation_ids[0] #=> String
resp.task_summary.target.security_profile_name #=> String
resp.task_summary.target.behavior_name #=> String
resp.task_summary.violation_event_occurrence_range.start_time #=> Time
resp.task_summary.violation_event_occurrence_range.end_time #=> Time
resp.task_summary.only_active_violations_included #=> Boolean
resp.task_summary.suppressed_alerts_included #=> Boolean
resp.task_summary.actions_definition #=> Array
resp.task_summary.actions_definition[0].name #=> String
resp.task_summary.actions_definition[0].id #=> String
resp.task_summary.actions_definition[0].role_arn #=> String
resp.task_summary.actions_definition[0].action_params.update_device_certificate_params.action #=> String, one of "DEACTIVATE"
resp.task_summary.actions_definition[0].action_params.update_ca_certificate_params.action #=> String, one of "DEACTIVATE"
resp.task_summary.actions_definition[0].action_params.add_things_to_thing_group_params.thing_group_names #=> Array
resp.task_summary.actions_definition[0].action_params.add_things_to_thing_group_params.thing_group_names[0] #=> String
resp.task_summary.actions_definition[0].action_params.add_things_to_thing_group_params.override_dynamic_groups #=> Boolean
resp.task_summary.actions_definition[0].action_params.replace_default_policy_version_params.template_name #=> String, one of "BLANK_POLICY"
resp.task_summary.actions_definition[0].action_params.enable_io_t_logging_params.role_arn_for_logging #=> String
resp.task_summary.actions_definition[0].action_params.enable_io_t_logging_params.log_level #=> String, one of "DEBUG", "INFO", "ERROR", "WARN", "DISABLED"
resp.task_summary.actions_definition[0].action_params.publish_finding_to_sns_params.topic_arn #=> String
resp.task_summary.task_statistics.actions_executed #=> Integer
resp.task_summary.task_statistics.actions_skipped #=> Integer
resp.task_summary.task_statistics.actions_failed #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :task_id (required, String)

    The unique identifier of the task.

Returns:



4323
4324
4325
4326
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4323

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

#describe_dimension(params = {}) ⇒ Types::DescribeDimensionResponse

Provides details about a dimension that is defined in your AWS account.

Examples:

Request syntax with placeholder values


resp = client.describe_dimension({
  name: "DimensionName", # required
})

Response structure


resp.name #=> String
resp.arn #=> String
resp.type #=> String, one of "TOPIC_FILTER"
resp.string_values #=> Array
resp.string_values[0] #=> String
resp.creation_date #=> Time
resp.last_modified_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :name (required, String)

    The unique identifier for the dimension.

Returns:



4361
4362
4363
4364
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4361

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

#describe_domain_configuration(params = {}) ⇒ Types::DescribeDomainConfigurationResponse

Gets summary information about a domain configuration.

The domain configuration feature is in public preview and is subject to change.

Examples:

Request syntax with placeholder values


resp = client.describe_domain_configuration({
  domain_configuration_name: "ReservedDomainConfigurationName", # required
})

Response structure


resp.domain_configuration_name #=> String
resp.domain_configuration_arn #=> String
resp.domain_name #=> String
resp.server_certificates #=> Array
resp.server_certificates[0].server_certificate_arn #=> String
resp.server_certificates[0].server_certificate_status #=> String, one of "INVALID", "VALID"
resp.server_certificates[0].server_certificate_status_detail #=> String
resp.authorizer_config.default_authorizer_name #=> String
resp.authorizer_config.allow_authorizer_override #=> Boolean
resp.domain_configuration_status #=> String, one of "ENABLED", "DISABLED"
resp.service_type #=> String, one of "DATA", "CREDENTIAL_PROVIDER", "JOBS"
resp.domain_type #=> String, one of "ENDPOINT", "AWS_MANAGED", "CUSTOMER_MANAGED"
resp.last_status_change_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :domain_configuration_name (required, String)

    The name of the domain configuration.

Returns:



4412
4413
4414
4415
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4412

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

    ^

    We strongly recommend that customers use the newer iot:Data-ATS endpoint type to avoid issues related to the widespread distrust of Symantec certificate authorities.

Returns:



4462
4463
4464
4465
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4462

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:



4484
4485
4486
4487
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4484

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:



4514
4515
4516
4517
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4514

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
resp.job.namespace_id #=> 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:



4578
4579
4580
4581
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4578

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:



4624
4625
4626
4627
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4624

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

#describe_mitigation_action(params = {}) ⇒ Types::DescribeMitigationActionResponse

Gets information about a mitigation action.

Examples:

Request syntax with placeholder values


resp = client.describe_mitigation_action({
  action_name: "MitigationActionName", # required
})

Response structure


resp.action_name #=> String
resp.action_type #=> String, one of "UPDATE_DEVICE_CERTIFICATE", "UPDATE_CA_CERTIFICATE", "ADD_THINGS_TO_THING_GROUP", "REPLACE_DEFAULT_POLICY_VERSION", "ENABLE_IOT_LOGGING", "PUBLISH_FINDING_TO_SNS"
resp.action_arn #=> String
resp.action_id #=> String
resp.role_arn #=> String
resp.action_params.update_device_certificate_params.action #=> String, one of "DEACTIVATE"
resp.action_params.update_ca_certificate_params.action #=> String, one of "DEACTIVATE"
resp.action_params.add_things_to_thing_group_params.thing_group_names #=> Array
resp.action_params.add_things_to_thing_group_params.thing_group_names[0] #=> String
resp.action_params.add_things_to_thing_group_params.override_dynamic_groups #=> Boolean
resp.action_params.replace_default_policy_version_params.template_name #=> String, one of "BLANK_POLICY"
resp.action_params.enable_io_t_logging_params.role_arn_for_logging #=> String
resp.action_params.enable_io_t_logging_params.log_level #=> String, one of "DEBUG", "INFO", "ERROR", "WARN", "DISABLED"
resp.action_params.publish_finding_to_sns_params.topic_arn #=> String
resp.creation_date #=> Time
resp.last_modified_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :action_name (required, String)

    The friendly name that uniquely identifies the mitigation action.

Returns:



4672
4673
4674
4675
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4672

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

#describe_provisioning_template(params = {}) ⇒ Types::DescribeProvisioningTemplateResponse

Returns information about a fleet provisioning template.

Examples:

Request syntax with placeholder values


resp = client.describe_provisioning_template({
  template_name: "TemplateName", # required
})

Response structure


resp.template_arn #=> String
resp.template_name #=> String
resp.description #=> String
resp.creation_date #=> Time
resp.last_modified_date #=> Time
resp.default_version_id #=> Integer
resp.template_body #=> String
resp.enabled #=> Boolean
resp.provisioning_role_arn #=> String
resp.pre_provisioning_hook.payload_version #=> String
resp.pre_provisioning_hook.target_arn #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :template_name (required, String)

    The name of the fleet provisioning template.

Returns:



4717
4718
4719
4720
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4717

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

#describe_provisioning_template_version(params = {}) ⇒ Types::DescribeProvisioningTemplateVersionResponse

Returns information about a fleet provisioning template version.

Examples:

Request syntax with placeholder values


resp = client.describe_provisioning_template_version({
  template_name: "TemplateName", # required
  version_id: 1, # required
})

Response structure


resp.version_id #=> Integer
resp.creation_date #=> Time
resp.template_body #=> String
resp.is_default_version #=> Boolean

Parameters:

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

    ({})

Options Hash (params):

  • :template_name (required, String)

    The template name.

  • :version_id (required, Integer)

    The fleet provisioning template version ID.

Returns:



4753
4754
4755
4756
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4753

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



4785
4786
4787
4788
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4785

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:



4822
4823
4824
4825
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4822

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].metric_dimension.dimension_name #=> String
resp.behaviors[0].metric_dimension.operator #=> String, one of "IN", "NOT_IN"
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", "in-set", "not-in-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.value.number #=> Float
resp.behaviors[0].criteria.value.numbers #=> Array
resp.behaviors[0].criteria.value.numbers[0] #=> Float
resp.behaviors[0].criteria.value.strings #=> Array
resp.behaviors[0].criteria.value.strings[0] #=> String
resp.behaviors[0].criteria.duration_seconds #=> Integer
resp.behaviors[0].criteria.consecutive_datapoints_to_alarm #=> Integer
resp.behaviors[0].criteria.consecutive_datapoints_to_clear #=> Integer
resp.behaviors[0].criteria.statistical_threshold.statistic #=> String
resp.behaviors[0].criteria.ml_detection_config.confidence_level #=> String, one of "LOW", "MEDIUM", "HIGH"
resp.behaviors[0].suppress_alerts #=> Boolean
resp.alert_targets #=> Hash
resp.alert_targets["AlertTargetType"].alert_target_arn #=> String
resp.alert_targets["AlertTargetType"].role_arn #=> String
resp.additional_metrics_to_retain #=> Array
resp.additional_metrics_to_retain[0] #=> String
resp.additional_metrics_to_retain_v2 #=> Array
resp.additional_metrics_to_retain_v2[0].metric #=> String
resp.additional_metrics_to_retain_v2[0].metric_dimension.dimension_name #=> String
resp.additional_metrics_to_retain_v2[0].metric_dimension.operator #=> String, one of "IN", "NOT_IN"
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:



4893
4894
4895
4896
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4893

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:



4930
4931
4932
4933
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4930

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:



4971
4972
4973
4974
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 4971

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..parent_group_name #=> String
resp..root_to_parent_thing_groups #=> Array
resp..root_to_parent_thing_groups[0].group_name #=> String
resp..root_to_parent_thing_groups[0].group_arn #=> String
resp..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:



5022
5023
5024
5025
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 5022

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:



5070
5071
5072
5073
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 5070

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..deprecated #=> Boolean
resp..deprecation_date #=> Time
resp..creation_date #=> Time

Parameters:

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

    ({})

Options Hash (params):

  • :thing_type_name (required, String)

    The name of the thing type.

Returns:



5108
5109
5110
5111
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 5108

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.



5132
5133
5134
5135
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 5132

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.

    Valid principals are CertificateArn (arn:aws:iot:region:accountId:cert/certificateId), thingGroupArn (arn:aws:iot:region:accountId:thinggroup/groupName) and CognitoId (region:id).

Returns:

  • (Struct)

    Returns an empty response.



5164
5165
5166
5167
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 5164

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.



5190
5191
5192
5193
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 5190

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. A principal can be X.509 certificates, IAM users, groups, and roles, Amazon Cognito identities or federated identities.

This call is asynchronous. It might take several seconds for the detachment to propagate.

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.



5223
5224
5225
5226
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 5223

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.



5243
5244
5245
5246
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 5243

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.



5263
5264
5265
5266
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 5263

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

#get_behavior_model_training_summaries(params = {}) ⇒ Types::GetBehaviorModelTrainingSummariesResponse

Returns a Device Defender's ML Detect Security Profile training model's status.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


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

Response structure


resp.summaries #=> Array
resp.summaries[0].security_profile_name #=> String
resp.summaries[0].behavior_name #=> String
resp.summaries[0].training_data_collection_start_date #=> Time
resp.summaries[0].model_status #=> String, one of "PENDING_BUILD", "ACTIVE", "EXPIRED"
resp.summaries[0].datapoints_collection_percentage #=> Float
resp.summaries[0].last_model_refresh_date #=> Time
resp.next_token #=> String

Parameters:

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

    ({})

Options Hash (params):

  • :security_profile_name (String)

    The name of the security profile.

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

Returns:



5309
5310
5311
5312
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 5309

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

#get_cardinality(params = {}) ⇒ Types::GetCardinalityResponse

Returns the approximate count of unique values that match the query.

Examples:

Request syntax with placeholder values


resp = client.get_cardinality({
  index_name: "IndexName",
  query_string: "QueryString", # required
  aggregation_field: "AggregationField",
  query_version: "QueryVersion",
})

Response structure


resp.cardinality #=> Integer

Parameters:

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

    ({})

Options Hash (params):

  • :index_name (String)

    The name of the index to search.

  • :query_string (required, String)

    The search query.

  • :aggregation_field (String)

    The field to aggregate.

  • :query_version (String)

    The query version.

Returns:



5347
5348
5349
5350
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 5347

def get_cardinality(params = {}, options = {})
  req = build_request(:get_cardinality, 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. Valid principals are CertificateArn (arn:aws:iot:region:accountId:cert/certificateId), thingGroupArn (arn:aws:iot:region:accountId:thinggroup/groupName) and CognitoId (region:id).

  • :cognito_identity_pool_id (String)

    The Cognito identity pool ID.

  • :thing_name (String)

    The thing name.

Returns:



5390
5391
5392
5393
# File 'gems/aws-sdk-iot/lib/aws-sdk-iot/client.rb', line 5390

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 indexing 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_indexing_configuration.managed_fields #=> Array
resp.thing_indexing_configuration.managed_fields[0].name #=> String
resp.thing_indexing_configuration.managed_fields[0].type #=> String, one of "Number", "String", "Boolean"
resp.thing_indexing_configuration.custom_fields #=> Array
resp.thing_indexing_configuration.custom_fields[0].name #=> String
resp.thing_indexing_configuration.custom_fields[0].type #=> String, one of "Number", "String", "Boolean"
resp.thing_group_indexing_configuration.thing_group_indexing_mode #=> String, one of "OFF", "ON"
resp.