Class: Aws::IoTAnalytics::Client

Inherits:

Seahorse::Client::Base

• Object
• Seahorse::Client::Base
• Aws::IoTAnalytics::Client

Includes:

ClientStubs

Defined in:

gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb

Overview

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

client = Aws::IoTAnalytics::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

• #batch_put_message(params = {}) ⇒ Types::BatchPutMessageResponse

  Sends messages to a channel.

• #cancel_pipeline_reprocessing(params = {}) ⇒ Struct

  Cancels the reprocessing of data through the pipeline.

• #create_channel(params = {}) ⇒ Types::CreateChannelResponse

  Used to create a channel.

• #create_dataset(params = {}) ⇒ Types::CreateDatasetResponse

  Used to create a dataset.

• #create_dataset_content(params = {}) ⇒ Types::CreateDatasetContentResponse

  Creates the content of a dataset by applying a queryAction (a SQL query) or a containerAction (executing a containerized application).

• #create_datastore(params = {}) ⇒ Types::CreateDatastoreResponse

  Creates a data store, which is a repository for messages.

• #create_pipeline(params = {}) ⇒ Types::CreatePipelineResponse

  Creates a pipeline.

• #delete_channel(params = {}) ⇒ Struct

  Deletes the specified channel.

• #delete_dataset(params = {}) ⇒ Struct

  Deletes the specified dataset.

• #delete_dataset_content(params = {}) ⇒ Struct

  Deletes the content of the specified dataset.

• #delete_datastore(params = {}) ⇒ Struct

  Deletes the specified data store.

• #delete_pipeline(params = {}) ⇒ Struct

  Deletes the specified pipeline.

• #describe_channel(params = {}) ⇒ Types::DescribeChannelResponse

  Retrieves information about a channel.

• #describe_dataset(params = {}) ⇒ Types::DescribeDatasetResponse

  Retrieves information about a dataset.

• #describe_datastore(params = {}) ⇒ Types::DescribeDatastoreResponse

  Retrieves information about a data store.

• #describe_logging_options(params = {}) ⇒ Types::DescribeLoggingOptionsResponse

  Retrieves the current settings of the IoT Analytics logging options.

• #describe_pipeline(params = {}) ⇒ Types::DescribePipelineResponse

  Retrieves information about a pipeline.

• #get_dataset_content(params = {}) ⇒ Types::GetDatasetContentResponse

  Retrieves the contents of a dataset as presigned URIs.

• #list_channels(params = {}) ⇒ Types::ListChannelsResponse

  Retrieves a list of channels.

• #list_dataset_contents(params = {}) ⇒ Types::ListDatasetContentsResponse

  Lists information about dataset contents that have been created.

• #list_datasets(params = {}) ⇒ Types::ListDatasetsResponse

  Retrieves information about datasets.

• #list_datastores(params = {}) ⇒ Types::ListDatastoresResponse

  Retrieves a list of data stores.

• #list_pipelines(params = {}) ⇒ Types::ListPipelinesResponse

  Retrieves a list of pipelines.

• #list_tags_for_resource(params = {}) ⇒ Types::ListTagsForResourceResponse

  Lists the tags (metadata) that you have assigned to the resource.

• #put_logging_options(params = {}) ⇒ Struct

  Sets or updates the IoT Analytics logging options.

• #run_pipeline_activity(params = {}) ⇒ Types::RunPipelineActivityResponse

  Simulates the results of running a pipeline activity on a message payload.

• #sample_channel_data(params = {}) ⇒ Types::SampleChannelDataResponse

  Retrieves a sample of messages from the specified channel ingested during the specified timeframe.

• #start_pipeline_reprocessing(params = {}) ⇒ Types::StartPipelineReprocessingResponse

  Starts the reprocessing of raw message data through the pipeline.

• #tag_resource(params = {}) ⇒ Struct

  Adds to or modifies the tags of the given resource.

• #untag_resource(params = {}) ⇒ Struct

  Removes the given tags (metadata) from the resource.

• #update_channel(params = {}) ⇒ Struct

  Used to update the settings of a channel.

• #update_dataset(params = {}) ⇒ Struct

  Updates the settings of a dataset.

• #update_datastore(params = {}) ⇒ Struct

  Used to update the settings of a data store.

• #update_pipeline(params = {}) ⇒ Struct

  Updates the settings of a pipeline.

Instance Method Summary

• #initialize(options) ⇒ Client constructor

  A new instance of Client.

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

• :plugins (Array<Seahorse::Client::Plugin>) — default: []] —

  A list of plugins to apply to the client. Each plugin is either a class name or an instance of a plugin class.

• :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, :session_token, and :account_id options.
  • ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'], ENV['AWS_SESSION_TOKEN'], and ENV['AWS_ACCOUNT_ID']
  • ~/.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::InstanceProfileCredentials or Aws::ECSCredentials to enable retries and extended timeouts. Instance profile credential fetching can be disabled by setting ENV['AWS_EC2_METADATA_DISABLED'] to true.
• :region (required, String) —

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

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

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

• :adaptive_retry_wait_to_fill (Boolean) — default: true —

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

• :client_side_monitoring (Boolean) — default: false —

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

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

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

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

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

• :client_side_monitoring_port (Integer) — default: 31000 —

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

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

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

• :convert_params (Boolean) — default: true —

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

• :correct_clock_skew (Boolean) — default: true —

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

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

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

• :disable_host_prefix_injection (Boolean) — default: false —

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

• :disable_request_compression (Boolean) — default: false —

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

• :endpoint (String, URI::HTTPS, URI::HTTP) —

  Normally you should not configure the :endpoint option directly. This is normally constructed from the :region option. Configuring :endpoint is normally reserved for connecting to test or custom endpoints. The endpoint should be a URI formatted like:

  'http://example.com'
  'https://example.com'
  'http://example.com:123'
  

• :endpoint_cache_max_entries (Integer) — default: 1000 —

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

• :endpoint_cache_max_threads (Integer) — default: 10 —

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

• :endpoint_cache_poll_interval (Integer) — default: 60 —

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

• :endpoint_discovery (Boolean) — default: false —

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

• :ignore_configured_endpoint_urls (Boolean) —

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

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

  The log formatter.

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

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

• :logger (Logger) —

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

• :max_attempts (Integer) — default: 3 —

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

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

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

• :request_min_compression_size_bytes (Integer) — default: 10240 —

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

• :retry_backoff (Proc) —

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

• :retry_base_delay (Float) — default: 0.3 —

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

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

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

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

• :sdk_ua_app_id (String) —

  A unique and opaque application ID that is appended to the User-Agent header as app/sdk_ua_app_id. It should have a maximum length of 50. This variable is sourced from environment variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.

• :secret_access_key (String)
• :session_token (String)
• :sigv4a_signing_region_set (Array) —

  A list of regions that should be signed with SigV4a signing. When not passed, a default :sigv4a_signing_region_set is searched for in the following locations:

  • Aws.config[:sigv4a_signing_region_set]
  • ENV['AWS_SIGV4A_SIGNING_REGION_SET']
  • ~/.aws/config
• :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.

• :telemetry_provider (Aws::Telemetry::TelemetryProviderBase) — default: Aws::Telemetry::NoOpTelemetryProvider —

  Allows you to provide a telemetry provider, which is used to emit telemetry data. By default, uses NoOpTelemetryProvider which will not record or emit any telemetry data. The SDK supports the following telemetry providers:

  • OpenTelemetry (OTel) - To use the OTel provider, install and require the opentelemetry-sdk gem and then, pass in an instance of a Aws::Telemetry::OTelProvider for telemetry provider.
• :token_provider (Aws::TokenProvider) —

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

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

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

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

• :use_dualstack_endpoint (Boolean) —

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

• :use_fips_endpoint (Boolean) —

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

• :validate_params (Boolean) — default: true —

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

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

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

• :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_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_open_timeout (Float) — default: 15 —

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

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

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

• :http_read_timeout (Float) — default: 60 —

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

• :http_wire_trace (Boolean) — default: false —

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

• :on_chunk_received (Proc) —

  When a Proc object is provided, it will be used as callback when each chunk of the response body is received. It provides three arguments: the chunk, the number of bytes received, and the total number of bytes in the response (or nil if the server did not send a content-length).

• :on_chunk_sent (Proc) —

  When a Proc object is provided, it will be used as callback when each chunk of the request body is sent. It provides three arguments: the chunk, the number of bytes read from the body, and the total number of bytes in the body.

• :raise_response_errors (Boolean) — default: true —

  When true, response errors are raised.

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

• :ssl_ca_store (String) —

  Sets the X509::Store to verify peer certificate.

• :ssl_cert (OpenSSL::X509::Certificate) —

  Sets a client certificate when creating http connections.

• :ssl_key (OpenSSL::PKey) —

  Sets a client key when creating http connections.

• :ssl_timeout (Float) —

  Sets the SSL timeout in seconds

• :ssl_verify_peer (Boolean) — default: true —

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

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 444

def initialize(*args)
  super
end

Instance Method Details

#batch_put_message(params = {}) ⇒ Types::BatchPutMessageResponse

Sends messages to a channel.

Examples:

Request syntax with placeholder values

resp = client.batch_put_message({
  channel_name: "ChannelName", # required
  messages: [ # required
    {
      message_id: "MessageId", # required
      payload: "data", # required
    },
  ],
})

Response structure

resp.batch_put_message_error_entries #=> Array
resp.batch_put_message_error_entries[0].message_id #=> String
resp.batch_put_message_error_entries[0].error_code #=> String
resp.batch_put_message_error_entries[0].error_message #=> String

Parameters:

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

  ({})

Options Hash (params):

• :channel_name (required, String) —

  The name of the channel where the messages are sent.

• :messages (required, Array<Types::Message>) —

  The list of messages to be sent. Each message has the format: \{ "messageId": "string", "payload": "string"\}.

  The field names of message payloads (data) that you send to IoT Analytics:

  • Must contain only alphanumeric characters and undescores (_). No other special characters are allowed.

  • Must begin with an alphabetic character or single underscore (_).

  • Cannot contain hyphens (-).

  • In regular expression terms: "^[A-Za-z_]([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9_])$".

  • Cannot be more than 255 characters.

  • Are case insensitive. (Fields named foo and FOO in the same payload are considered duplicates.)

  For example, {"temp_01": 29\} or {"_temp_01": 29\} are valid, but {"temp-01": 29\}, {"01_temp": 29\} or {"__temp_01": 29\} are invalid in message payloads.

Returns:

• (Types::BatchPutMessageResponse) —

  Returns a response object which responds to the following methods:

  • #batch_put_message_error_entries => Array<Types::BatchPutMessageErrorEntry>

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 506

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

#cancel_pipeline_reprocessing(params = {}) ⇒ Struct

Cancels the reprocessing of data through the pipeline.

Examples:

Request syntax with placeholder values

resp = client.cancel_pipeline_reprocessing({
  pipeline_name: "PipelineName", # required
  reprocessing_id: "ReprocessingId", # required
})

Parameters:

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

  ({})

Options Hash (params):

• :pipeline_name (required, String) —

  The name of pipeline for which data reprocessing is canceled.

• :reprocessing_id (required, String) —

  The ID of the reprocessing task (returned by StartPipelineReprocessing).

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 531

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

#create_channel(params = {}) ⇒ Types::CreateChannelResponse

Used to create a channel. A channel collects data from an MQTT topic and archives the raw, unprocessed messages before publishing the data to a pipeline.

Examples:

Request syntax with placeholder values

resp = client.create_channel({
  channel_name: "ChannelName", # required
  channel_storage: {
    service_managed_s3: {
    },
    customer_managed_s3: {
      bucket: "BucketName", # required
      key_prefix: "S3KeyPrefix",
      role_arn: "RoleArn", # required
    },
  },
  retention_period: {
    unlimited: false,
    number_of_days: 1,
  },
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Response structure

resp.channel_name #=> String
resp.channel_arn #=> String
resp.retention_period.unlimited #=> Boolean
resp.retention_period.number_of_days #=> Integer

Parameters:

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

  ({})

Options Hash (params):

• :channel_name (required, String) —

  The name of the channel.

• :channel_storage (Types::ChannelStorage) —

  Where channel data is stored. You can choose one of serviceManagedS3 or customerManagedS3 storage. If not specified, the default is serviceManagedS3. You can't change this storage option after the channel is created.

• :retention_period (Types::RetentionPeriod) —

  How long, in days, message data is kept for the channel. When customerManagedS3 storage is selected, this parameter is ignored.

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

  Metadata which can be used to manage the channel.

Returns:

• (Types::CreateChannelResponse) —

  Returns a response object which responds to the following methods:

  • #channel_name => String
  • #channel_arn => String
  • #retention_period => Types::RetentionPeriod

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 596

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

#create_dataset(params = {}) ⇒ Types::CreateDatasetResponse

Used to create a dataset. A dataset stores data retrieved from a data store by applying a queryAction (a SQL query) or a containerAction (executing a containerized application). This operation creates the skeleton of a dataset. The dataset can be populated manually by calling CreateDatasetContent or automatically according to a trigger you specify.

Examples:

Request syntax with placeholder values

resp = client.create_dataset({
  dataset_name: "DatasetName", # required
  actions: [ # required
    {
      action_name: "DatasetActionName",
      query_action: {
        sql_query: "SqlQuery", # required
        filters: [
          {
            delta_time: {
              offset_seconds: 1, # required
              time_expression: "TimeExpression", # required
            },
          },
        ],
      },
      container_action: {
        image: "Image", # required
        execution_role_arn: "RoleArn", # required
        resource_configuration: { # required
          compute_type: "ACU_1", # required, accepts ACU_1, ACU_2
          volume_size_in_gb: 1, # required
        },
        variables: [
          {
            name: "VariableName", # required
            string_value: "StringValue",
            double_value: 1.0,
            dataset_content_version_value: {
              dataset_name: "DatasetName", # required
            },
            output_file_uri_value: {
              file_name: "OutputFileName", # required
            },
          },
        ],
      },
    },
  ],
  triggers: [
    {
      schedule: {
        expression: "ScheduleExpression",
      },
      dataset: {
        name: "DatasetName", # required
      },
    },
  ],
  content_delivery_rules: [
    {
      entry_name: "EntryName",
      destination: { # required
        iot_events_destination_configuration: {
          input_name: "IotEventsInputName", # required
          role_arn: "RoleArn", # required
        },
        s3_destination_configuration: {
          bucket: "BucketName", # required
          key: "BucketKeyExpression", # required
          glue_configuration: {
            table_name: "GlueTableName", # required
            database_name: "GlueDatabaseName", # required
          },
          role_arn: "RoleArn", # required
        },
      },
    },
  ],
  retention_period: {
    unlimited: false,
    number_of_days: 1,
  },
  versioning_configuration: {
    unlimited: false,
    max_versions: 1,
  },
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  late_data_rules: [
    {
      rule_name: "LateDataRuleName",
      rule_configuration: { # required
        delta_time_session_window_configuration: {
          timeout_in_minutes: 1, # required
        },
      },
    },
  ],
})

Response structure

resp.dataset_name #=> String
resp.dataset_arn #=> String
resp.retention_period.unlimited #=> Boolean
resp.retention_period.number_of_days #=> Integer

Parameters:

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

  ({})

Options Hash (params):

• :dataset_name (required, String) —

  The name of the dataset.

• :actions (required, Array<Types::DatasetAction>) —

  A list of actions that create the dataset contents.

• :triggers (Array<Types::DatasetTrigger>) —

  A list of triggers. A trigger causes dataset contents to be populated at a specified time interval or when another dataset's contents are created. The list of triggers can be empty or contain up to five DataSetTrigger objects.

• :content_delivery_rules (Array<Types::DatasetContentDeliveryRule>) —

  When dataset contents are created, they are delivered to destinations specified here.

• :retention_period (Types::RetentionPeriod) —

  Optional. How long, in days, versions of dataset contents are kept for the dataset. If not specified or set to null, versions of dataset contents are retained for at most 90 days. The number of versions of dataset contents retained is determined by the versioningConfiguration parameter. For more information, see Keeping Multiple Versions of IoT Analytics datasets in the IoT Analytics User Guide.

• :versioning_configuration (Types::VersioningConfiguration) —

  Optional. How many versions of dataset contents are kept. If not specified or set to null, only the latest version plus the latest succeeded version (if they are different) are kept for the time period specified by the retentionPeriod parameter. For more information, see Keeping Multiple Versions of IoT Analytics datasets in the IoT Analytics User Guide.

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

  Metadata which can be used to manage the dataset.

• :late_data_rules (Array<Types::LateDataRule>) —

  A list of data rules that send notifications to CloudWatch, when data arrives late. To specify lateDataRules, the dataset must use a DeltaTimer filter.

Returns:

• (Types::CreateDatasetResponse) —

  Returns a response object which responds to the following methods:

  • #dataset_name => String
  • #dataset_arn => String
  • #retention_period => Types::RetentionPeriod

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 773

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

#create_dataset_content(params = {}) ⇒ Types::CreateDatasetContentResponse

Creates the content of a dataset by applying a queryAction (a SQL query) or a containerAction (executing a containerized application).

Examples:

Request syntax with placeholder values

resp = client.create_dataset_content({
  dataset_name: "DatasetName", # required
  version_id: "DatasetContentVersion",
})

Response structure

resp.version_id #=> String

Parameters:

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

  ({})

Options Hash (params):

• :dataset_name (required, String) —

  The name of the dataset.

• :version_id (String) —

  The version ID of the dataset content. To specify versionId for a dataset content, the dataset must use a DeltaTimer filter.

Returns:

• (Types::CreateDatasetContentResponse) —

  Returns a response object which responds to the following methods:

  • #version_id => String

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 809

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

#create_datastore(params = {}) ⇒ Types::CreateDatastoreResponse

Creates a data store, which is a repository for messages.

Examples:

Request syntax with placeholder values

resp = client.create_datastore({
  datastore_name: "DatastoreName", # required
  datastore_storage: {
    service_managed_s3: {
    },
    customer_managed_s3: {
      bucket: "BucketName", # required
      key_prefix: "S3KeyPrefix",
      role_arn: "RoleArn", # required
    },
    iot_site_wise_multi_layer_storage: {
      customer_managed_s3_storage: { # required
        bucket: "BucketName", # required
        key_prefix: "S3KeyPrefix",
      },
    },
  },
  retention_period: {
    unlimited: false,
    number_of_days: 1,
  },
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  file_format_configuration: {
    json_configuration: {
    },
    parquet_configuration: {
      schema_definition: {
        columns: [
          {
            name: "ColumnName", # required
            type: "ColumnDataType", # required
          },
        ],
      },
    },
  },
  datastore_partitions: {
    partitions: [
      {
        attribute_partition: {
          attribute_name: "PartitionAttributeName", # required
        },
        timestamp_partition: {
          attribute_name: "PartitionAttributeName", # required
          timestamp_format: "TimestampFormat",
        },
      },
    ],
  },
})

Response structure

resp.datastore_name #=> String
resp.datastore_arn #=> String
resp.retention_period.unlimited #=> Boolean
resp.retention_period.number_of_days #=> Integer

Parameters:

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

  ({})

Options Hash (params):

• :datastore_name (required, String) —

  The name of the data store.

• :datastore_storage (Types::DatastoreStorage) —

  Where data in a data store is stored.. You can choose serviceManagedS3 storage, customerManagedS3 storage, or iotSiteWiseMultiLayerStorage storage. The default is serviceManagedS3. You can't change the choice of Amazon S3 storage after your data store is created.

• :retention_period (Types::RetentionPeriod) —

  How long, in days, message data is kept for the data store. When customerManagedS3 storage is selected, this parameter is ignored.

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

  Metadata which can be used to manage the data store.

• :file_format_configuration (Types::FileFormatConfiguration) —

  Contains the configuration information of file formats. IoT Analytics data stores support JSON and Parquet.

  The default file format is JSON. You can specify only one format.

  You can't change the file format after you create the data store.

• :datastore_partitions (Types::DatastorePartitions) —

  Contains information about the partition dimensions in a data store.

Returns:

• (Types::CreateDatastoreResponse) —

  Returns a response object which responds to the following methods:

  • #datastore_name => String
  • #datastore_arn => String
  • #retention_period => Types::RetentionPeriod

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 921

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

#create_pipeline(params = {}) ⇒ Types::CreatePipelineResponse

Creates a pipeline. A pipeline consumes messages from a channel and allows you to process the messages before storing them in a data store. You must specify both a channel and a datastore activity and, optionally, as many as 23 additional activities in the pipelineActivities array.

Examples:

Request syntax with placeholder values

resp = client.create_pipeline({
  pipeline_name: "PipelineName", # required
  pipeline_activities: [ # required
    {
      channel: {
        name: "ActivityName", # required
        channel_name: "ChannelName", # required
        next: "ActivityName",
      },
      lambda: {
        name: "ActivityName", # required
        lambda_name: "LambdaName", # required
        batch_size: 1, # required
        next: "ActivityName",
      },
      datastore: {
        name: "ActivityName", # required
        datastore_name: "DatastoreName", # required
      },
      add_attributes: {
        name: "ActivityName", # required
        attributes: { # required
          "AttributeName" => "AttributeName",
        },
        next: "ActivityName",
      },
      remove_attributes: {
        name: "ActivityName", # required
        attributes: ["AttributeName"], # required
        next: "ActivityName",
      },
      select_attributes: {
        name: "ActivityName", # required
        attributes: ["AttributeName"], # required
        next: "ActivityName",
      },
      filter: {
        name: "ActivityName", # required
        filter: "FilterExpression", # required
        next: "ActivityName",
      },
      math: {
        name: "ActivityName", # required
        attribute: "AttributeName", # required
        math: "MathExpression", # required
        next: "ActivityName",
      },
      device_registry_enrich: {
        name: "ActivityName", # required
        attribute: "AttributeName", # required
        thing_name: "AttributeName", # required
        role_arn: "RoleArn", # required
        next: "ActivityName",
      },
      device_shadow_enrich: {
        name: "ActivityName", # required
        attribute: "AttributeName", # required
        thing_name: "AttributeName", # required
        role_arn: "RoleArn", # required
        next: "ActivityName",
      },
    },
  ],
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Response structure

resp.pipeline_name #=> String
resp.pipeline_arn #=> String

Parameters:

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

  ({})

Options Hash (params):

• :pipeline_name (required, String) —

  The name of the pipeline.

• :pipeline_activities (required, Array<Types::PipelineActivity>) —

  A list of PipelineActivity objects. Activities perform transformations on your messages, such as removing, renaming or adding message attributes; filtering messages based on attribute values; invoking your Lambda unctions on messages for advanced processing; or performing mathematical transformations to normalize device data.

  The list can be 2-25 PipelineActivity objects and must contain both a channel and a datastore activity. Each entry in the list must contain only one activity. For example:

  pipelineActivities = [ \{ "channel": \{ ... \} \}, \{ "lambda": \{ ... \} \}, ... ]

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

  Metadata which can be used to manage the pipeline.

Returns:

• (Types::CreatePipelineResponse) —

  Returns a response object which responds to the following methods:

  • #pipeline_name => String
  • #pipeline_arn => String

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1037

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

#delete_channel(params = {}) ⇒ Struct

Deletes the specified channel.

Examples:

Request syntax with placeholder values

resp = client.delete_channel({
  channel_name: "ChannelName", # required
})

Parameters:

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

  ({})

Options Hash (params):

• :channel_name (required, String) —

  The name of the channel to delete.

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1057

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

#delete_dataset(params = {}) ⇒ Struct

Deletes the specified dataset.

You do not have to delete the content of the dataset before you perform this operation.

Examples:

Request syntax with placeholder values

resp = client.delete_dataset({
  dataset_name: "DatasetName", # required
})

Parameters:

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

  ({})

Options Hash (params):

• :dataset_name (required, String) —

  The name of the dataset to delete.

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1080

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

#delete_dataset_content(params = {}) ⇒ Struct

Deletes the content of the specified dataset.

Examples:

Request syntax with placeholder values

resp = client.delete_dataset_content({
  dataset_name: "DatasetName", # required
  version_id: "DatasetContentVersion",
})

Parameters:

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

  ({})

Options Hash (params):

• :dataset_name (required, String) —

  The name of the dataset whose content is deleted.

• :version_id (String) —

  The version of the dataset whose content is deleted. You can also use the strings "$LATEST" or "$LATEST_SUCCEEDED" to delete the latest or latest successfully completed data set. If not specified, "$LATEST_SUCCEEDED" is the default.

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1107

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

#delete_datastore(params = {}) ⇒ Struct

Deletes the specified data store.

Examples:

Request syntax with placeholder values

resp = client.delete_datastore({
  datastore_name: "DatastoreName", # required
})

Parameters:

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

  ({})

Options Hash (params):

• :datastore_name (required, String) —

  The name of the data store to delete.

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1127

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

#delete_pipeline(params = {}) ⇒ Struct

Deletes the specified pipeline.

Examples:

Request syntax with placeholder values

resp = client.delete_pipeline({
  pipeline_name: "PipelineName", # required
})

Parameters:

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

  ({})

Options Hash (params):

• :pipeline_name (required, String) —

  The name of the pipeline to delete.

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1147

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

#describe_channel(params = {}) ⇒ Types::DescribeChannelResponse

Retrieves information about a channel.

Examples:

Request syntax with placeholder values

resp = client.describe_channel({
  channel_name: "ChannelName", # required
  include_statistics: false,
})

Response structure

resp.channel.name #=> String
resp.channel.storage.customer_managed_s3.bucket #=> String
resp.channel.storage.customer_managed_s3.key_prefix #=> String
resp.channel.storage.customer_managed_s3.role_arn #=> String
resp.channel.arn #=> String
resp.channel.status #=> String, one of "CREATING", "ACTIVE", "DELETING"
resp.channel.retention_period.unlimited #=> Boolean
resp.channel.retention_period.number_of_days #=> Integer
resp.channel.creation_time #=> Time
resp.channel.last_update_time #=> Time
resp.channel.last_message_arrival_time #=> Time
resp.statistics.size.estimated_size_in_bytes #=> Float
resp.statistics.size.estimated_on #=> Time

Parameters:

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

  ({})

Options Hash (params):

• :channel_name (required, String) —

  The name of the channel whose information is retrieved.

• :include_statistics (Boolean) —

  If true, additional statistical information about the channel is included in the response. This feature can't be used with a channel whose S3 storage is customer-managed.

Returns:

• (Types::DescribeChannelResponse) —

  Returns a response object which responds to the following methods:

  • #channel => Types::Channel
  • #statistics => Types::ChannelStatistics

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1192

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

#describe_dataset(params = {}) ⇒ Types::DescribeDatasetResponse

Retrieves information about a dataset.

Examples:

Request syntax with placeholder values

resp = client.describe_dataset({
  dataset_name: "DatasetName", # required
})

Response structure

resp.dataset.name #=> String
resp.dataset.arn #=> String
resp.dataset.actions #=> Array
resp.dataset.actions[0].action_name #=> String
resp.dataset.actions[0].query_action.sql_query #=> String
resp.dataset.actions[0].query_action.filters #=> Array
resp.dataset.actions[0].query_action.filters[0].delta_time.offset_seconds #=> Integer
resp.dataset.actions[0].query_action.filters[0].delta_time.time_expression #=> String
resp.dataset.actions[0].container_action.image #=> String
resp.dataset.actions[0].container_action.execution_role_arn #=> String
resp.dataset.actions[0].container_action.resource_configuration.compute_type #=> String, one of "ACU_1", "ACU_2"
resp.dataset.actions[0].container_action.resource_configuration.volume_size_in_gb #=> Integer
resp.dataset.actions[0].container_action.variables #=> Array
resp.dataset.actions[0].container_action.variables[0].name #=> String
resp.dataset.actions[0].container_action.variables[0].string_value #=> String
resp.dataset.actions[0].container_action.variables[0].double_value #=> Float
resp.dataset.actions[0].container_action.variables[0].dataset_content_version_value.dataset_name #=> String
resp.dataset.actions[0].container_action.variables[0].output_file_uri_value.file_name #=> String
resp.dataset.triggers #=> Array
resp.dataset.triggers[0].schedule.expression #=> String
resp.dataset.triggers[0].dataset.name #=> String
resp.dataset.content_delivery_rules #=> Array
resp.dataset.content_delivery_rules[0].entry_name #=> String
resp.dataset.content_delivery_rules[0].destination.iot_events_destination_configuration.input_name #=> String
resp.dataset.content_delivery_rules[0].destination.iot_events_destination_configuration.role_arn #=> String
resp.dataset.content_delivery_rules[0].destination.s3_destination_configuration.bucket #=> String
resp.dataset.content_delivery_rules[0].destination.s3_destination_configuration.key #=> String
resp.dataset.content_delivery_rules[0].destination.s3_destination_configuration.glue_configuration.table_name #=> String
resp.dataset.content_delivery_rules[0].destination.s3_destination_configuration.glue_configuration.database_name #=> String
resp.dataset.content_delivery_rules[0].destination.s3_destination_configuration.role_arn #=> String
resp.dataset.status #=> String, one of "CREATING", "ACTIVE", "DELETING"
resp.dataset.creation_time #=> Time
resp.dataset.last_update_time #=> Time
resp.dataset.retention_period.unlimited #=> Boolean
resp.dataset.retention_period.number_of_days #=> Integer
resp.dataset.versioning_configuration.unlimited #=> Boolean
resp.dataset.versioning_configuration.max_versions #=> Integer
resp.dataset.late_data_rules #=> Array
resp.dataset.late_data_rules[0].rule_name #=> String
resp.dataset.late_data_rules[0].rule_configuration.delta_time_session_window_configuration.timeout_in_minutes #=> Integer

Parameters:

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

  ({})

Options Hash (params):

• :dataset_name (required, String) —

  The name of the dataset whose information is retrieved.

Returns:

• (Types::DescribeDatasetResponse) —

  Returns a response object which responds to the following methods:

  • #dataset => Types::Dataset

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1257

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

#describe_datastore(params = {}) ⇒ Types::DescribeDatastoreResponse

Retrieves information about a data store.

Examples:

Request syntax with placeholder values

resp = client.describe_datastore({
  datastore_name: "DatastoreName", # required
  include_statistics: false,
})

Response structure

resp.datastore.name #=> String
resp.datastore.storage.customer_managed_s3.bucket #=> String
resp.datastore.storage.customer_managed_s3.key_prefix #=> String
resp.datastore.storage.customer_managed_s3.role_arn #=> String
resp.datastore.storage.iot_site_wise_multi_layer_storage.customer_managed_s3_storage.bucket #=> String
resp.datastore.storage.iot_site_wise_multi_layer_storage.customer_managed_s3_storage.key_prefix #=> String
resp.datastore.arn #=> String
resp.datastore.status #=> String, one of "CREATING", "ACTIVE", "DELETING"
resp.datastore.retention_period.unlimited #=> Boolean
resp.datastore.retention_period.number_of_days #=> Integer
resp.datastore.creation_time #=> Time
resp.datastore.last_update_time #=> Time
resp.datastore.last_message_arrival_time #=> Time
resp.datastore.file_format_configuration.parquet_configuration.schema_definition.columns #=> Array
resp.datastore.file_format_configuration.parquet_configuration.schema_definition.columns[0].name #=> String
resp.datastore.file_format_configuration.parquet_configuration.schema_definition.columns[0].type #=> String
resp.datastore.datastore_partitions.partitions #=> Array
resp.datastore.datastore_partitions.partitions[0].attribute_partition.attribute_name #=> String
resp.datastore.datastore_partitions.partitions[0].timestamp_partition.attribute_name #=> String
resp.datastore.datastore_partitions.partitions[0].timestamp_partition.timestamp_format #=> String
resp.statistics.size.estimated_size_in_bytes #=> Float
resp.statistics.size.estimated_on #=> Time

Parameters:

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

  ({})

Options Hash (params):

• :datastore_name (required, String) —

  The name of the data store

• :include_statistics (Boolean) —

  If true, additional statistical information about the data store is included in the response. This feature can't be used with a data store whose S3 storage is customer-managed.

Returns:

• (Types::DescribeDatastoreResponse) —

  Returns a response object which responds to the following methods:

  • #datastore => Types::Datastore
  • #statistics => Types::DatastoreStatistics

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1311

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

#describe_logging_options(params = {}) ⇒ Types::DescribeLoggingOptionsResponse

Retrieves the current settings of the IoT Analytics logging options.

Examples:

Response structure

resp.logging_options.role_arn #=> String
resp.logging_options.level #=> String, one of "ERROR"
resp.logging_options.enabled #=> Boolean

Parameters:

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

  ({})

Returns:

• (Types::DescribeLoggingOptionsResponse) —

  Returns a response object which responds to the following methods:

  • #logging_options => Types::LoggingOptions

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1330

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

#describe_pipeline(params = {}) ⇒ Types::DescribePipelineResponse

Retrieves information about a pipeline.

Examples:

Request syntax with placeholder values

resp = client.describe_pipeline({
  pipeline_name: "PipelineName", # required
})

Response structure

resp.pipeline.name #=> String
resp.pipeline.arn #=> String
resp.pipeline.activities #=> Array
resp.pipeline.activities[0].channel.name #=> String
resp.pipeline.activities[0].channel.channel_name #=> String
resp.pipeline.activities[0].channel.next #=> String
resp.pipeline.activities[0].lambda.name #=> String
resp.pipeline.activities[0].lambda.lambda_name #=> String
resp.pipeline.activities[0].lambda.batch_size #=> Integer
resp.pipeline.activities[0].lambda.next #=> String
resp.pipeline.activities[0].datastore.name #=> String
resp.pipeline.activities[0].datastore.datastore_name #=> String
resp.pipeline.activities[0].add_attributes.name #=> String
resp.pipeline.activities[0].add_attributes.attributes #=> Hash
resp.pipeline.activities[0].add_attributes.attributes["AttributeName"] #=> String
resp.pipeline.activities[0].add_attributes.next #=> String
resp.pipeline.activities[0].remove_attributes.name #=> String
resp.pipeline.activities[0].remove_attributes.attributes #=> Array
resp.pipeline.activities[0].remove_attributes.attributes[0] #=> String
resp.pipeline.activities[0].remove_attributes.next #=> String
resp.pipeline.activities[0].select_attributes.name #=> String
resp.pipeline.activities[0].select_attributes.attributes #=> Array
resp.pipeline.activities[0].select_attributes.attributes[0] #=> String
resp.pipeline.activities[0].select_attributes.next #=> String
resp.pipeline.activities[0].filter.name #=> String
resp.pipeline.activities[0].filter.filter #=> String
resp.pipeline.activities[0].filter.next #=> String
resp.pipeline.activities[0].math.name #=> String
resp.pipeline.activities[0].math.attribute #=> String
resp.pipeline.activities[0].math.math #=> String
resp.pipeline.activities[0].math.next #=> String
resp.pipeline.activities[0].device_registry_enrich.name #=> String
resp.pipeline.activities[0].device_registry_enrich.attribute #=> String
resp.pipeline.activities[0].device_registry_enrich.thing_name #=> String
resp.pipeline.activities[0].device_registry_enrich.role_arn #=> String
resp.pipeline.activities[0].device_registry_enrich.next #=> String
resp.pipeline.activities[0].device_shadow_enrich.name #=> String
resp.pipeline.activities[0].device_shadow_enrich.attribute #=> String
resp.pipeline.activities[0].device_shadow_enrich.thing_name #=> String
resp.pipeline.activities[0].device_shadow_enrich.role_arn #=> String
resp.pipeline.activities[0].device_shadow_enrich.next #=> String
resp.pipeline.reprocessing_summaries #=> Array
resp.pipeline.reprocessing_summaries[0].id #=> String
resp.pipeline.reprocessing_summaries[0].status #=> String, one of "RUNNING", "SUCCEEDED", "CANCELLED", "FAILED"
resp.pipeline.reprocessing_summaries[0].creation_time #=> Time
resp.pipeline.creation_time #=> Time
resp.pipeline.last_update_time #=> Time

Parameters:

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

  ({})

Options Hash (params):

• :pipeline_name (required, String) —

  The name of the pipeline whose information is retrieved.

Returns:

• (Types::DescribePipelineResponse) —

  Returns a response object which responds to the following methods:

  • #pipeline => Types::Pipeline

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1402

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

#get_dataset_content(params = {}) ⇒ Types::GetDatasetContentResponse

Retrieves the contents of a dataset as presigned URIs.

Examples:

Request syntax with placeholder values

resp = client.get_dataset_content({
  dataset_name: "DatasetName", # required
  version_id: "DatasetContentVersion",
})

Response structure

resp.data.entries #=> Array
resp.data.entries[0].entry_name #=> String
resp.data.entries[0].data_uri #=> String
resp.timestamp #=> Time
resp.status.state #=> String, one of "CREATING", "SUCCEEDED", "FAILED"
resp.status.reason #=> String

Parameters:

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

  ({})

Options Hash (params):

• :dataset_name (required, String) —

  The name of the dataset whose contents are retrieved.

• :version_id (String) —

  The version of the dataset whose contents are retrieved. You can also use the strings "$LATEST" or "$LATEST_SUCCEEDED" to retrieve the contents of the latest or latest successfully completed dataset. If not specified, "$LATEST_SUCCEEDED" is the default.

Returns:

• (Types::GetDatasetContentResponse) —

  Returns a response object which responds to the following methods:

  • #data.entries => Array<Types::DatasetEntry> (This method conflicts with a method on Response, call it through the data member)
  • #timestamp => Time
  • #status => Types::DatasetContentStatus

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1442

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

#list_channels(params = {}) ⇒ Types::ListChannelsResponse

Retrieves a list of channels.

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

Examples:

Request syntax with placeholder values

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

Response structure

resp.channel_summaries #=> Array
resp.channel_summaries[0].channel_name #=> String
resp.channel_summaries[0].channel_storage.customer_managed_s3.bucket #=> String
resp.channel_summaries[0].channel_storage.customer_managed_s3.key_prefix #=> String
resp.channel_summaries[0].channel_storage.customer_managed_s3.role_arn #=> String
resp.channel_summaries[0].status #=> String, one of "CREATING", "ACTIVE", "DELETING"
resp.channel_summaries[0].creation_time #=> Time
resp.channel_summaries[0].last_update_time #=> Time
resp.channel_summaries[0].last_message_arrival_time #=> Time
resp.next_token #=> String

Parameters:

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

  ({})

Options Hash (params):

• :next_token (String) —

  The token for the next set of results.

• :max_results (Integer) —

  The maximum number of results to return in this request.

  The default value is 100.

Returns:

• (Types::ListChannelsResponse) —

  Returns a response object which responds to the following methods:

  • #channel_summaries => Array<Types::ChannelSummary>
  • #next_token => String

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1486

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

#list_dataset_contents(params = {}) ⇒ Types::ListDatasetContentsResponse

Lists information about dataset contents that have been created.

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

Examples:

Request syntax with placeholder values

resp = client.list_dataset_contents({
  dataset_name: "DatasetName", # required
  next_token: "NextToken",
  max_results: 1,
  scheduled_on_or_after: Time.now,
  scheduled_before: Time.now,
})

Response structure

resp.dataset_content_summaries #=> Array
resp.dataset_content_summaries[0].version #=> String
resp.dataset_content_summaries[0].status.state #=> String, one of "CREATING", "SUCCEEDED", "FAILED"
resp.dataset_content_summaries[0].status.reason #=> String
resp.dataset_content_summaries[0].creation_time #=> Time
resp.dataset_content_summaries[0].schedule_time #=> Time
resp.dataset_content_summaries[0].completion_time #=> Time
resp.next_token #=> String

Parameters:

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

  ({})

Options Hash (params):

• :dataset_name (required, String) —

  The name of the dataset whose contents information you want to list.

• :next_token (String) —

  The token for the next set of results.

• :max_results (Integer) —

  The maximum number of results to return in this request.

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

  A filter to limit results to those dataset contents whose creation is scheduled on or after the given time. See the field triggers.schedule in the CreateDataset request. (timestamp)

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

  A filter to limit results to those dataset contents whose creation is scheduled before the given time. See the field triggers.schedule in the CreateDataset request. (timestamp)

Returns:

• (Types::ListDatasetContentsResponse) —

  Returns a response object which responds to the following methods:

  • #dataset_content_summaries => Array<Types::DatasetContentSummary>
  • #next_token => String

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1542

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

#list_datasets(params = {}) ⇒ Types::ListDatasetsResponse

Retrieves information about datasets.

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

Examples:

Request syntax with placeholder values

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

Response structure

resp.dataset_summaries #=> Array
resp.dataset_summaries[0].dataset_name #=> String
resp.dataset_summaries[0].status #=> String, one of "CREATING", "ACTIVE", "DELETING"
resp.dataset_summaries[0].creation_time #=> Time
resp.dataset_summaries[0].last_update_time #=> Time
resp.dataset_summaries[0].triggers #=> Array
resp.dataset_summaries[0].triggers[0].schedule.expression #=> String
resp.dataset_summaries[0].triggers[0].dataset.name #=> String
resp.dataset_summaries[0].actions #=> Array
resp.dataset_summaries[0].actions[0].action_name #=> String
resp.dataset_summaries[0].actions[0].action_type #=> String, one of "QUERY", "CONTAINER"
resp.next_token #=> String

Parameters:

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

  ({})

Options Hash (params):

• :next_token (String) —

  The token for the next set of results.

• :max_results (Integer) —

  The maximum number of results to return in this request.

  The default value is 100.

Returns:

• (Types::ListDatasetsResponse) —

  Returns a response object which responds to the following methods:

  • #dataset_summaries => Array<Types::DatasetSummary>
  • #next_token => String

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1588

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

#list_datastores(params = {}) ⇒ Types::ListDatastoresResponse

Retrieves a list of data stores.

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

Examples:

Request syntax with placeholder values

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

Response structure

resp.datastore_summaries #=> Array
resp.datastore_summaries[0].datastore_name #=> String
resp.datastore_summaries[0].datastore_storage.customer_managed_s3.bucket #=> String
resp.datastore_summaries[0].datastore_storage.customer_managed_s3.key_prefix #=> String
resp.datastore_summaries[0].datastore_storage.customer_managed_s3.role_arn #=> String
resp.datastore_summaries[0].datastore_storage.iot_site_wise_multi_layer_storage.customer_managed_s3_storage.bucket #=> String
resp.datastore_summaries[0].datastore_storage.iot_site_wise_multi_layer_storage.customer_managed_s3_storage.key_prefix #=> String
resp.datastore_summaries[0].status #=> String, one of "CREATING", "ACTIVE", "DELETING"
resp.datastore_summaries[0].creation_time #=> Time
resp.datastore_summaries[0].last_update_time #=> Time
resp.datastore_summaries[0].last_message_arrival_time #=> Time
resp.datastore_summaries[0].file_format_type #=> String, one of "JSON", "PARQUET"
resp.datastore_summaries[0].datastore_partitions.partitions #=> Array
resp.datastore_summaries[0].datastore_partitions.partitions[0].attribute_partition.attribute_name #=> String
resp.datastore_summaries[0].datastore_partitions.partitions[0].timestamp_partition.attribute_name #=> String
resp.datastore_summaries[0].datastore_partitions.partitions[0].timestamp_partition.timestamp_format #=> String
resp.next_token #=> String

Parameters:

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

  ({})

Options Hash (params):

• :next_token (String) —

  The token for the next set of results.

• :max_results (Integer) —

  The maximum number of results to return in this request.

  The default value is 100.

Returns:

• (Types::ListDatastoresResponse) —

  Returns a response object which responds to the following methods:

  • #datastore_summaries => Array<Types::DatastoreSummary>
  • #next_token => String

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1639

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

#list_pipelines(params = {}) ⇒ Types::ListPipelinesResponse

Retrieves a list of pipelines.

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

Examples:

Request syntax with placeholder values

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

Response structure

resp.pipeline_summaries #=> Array
resp.pipeline_summaries[0].pipeline_name #=> String
resp.pipeline_summaries[0].reprocessing_summaries #=> Array
resp.pipeline_summaries[0].reprocessing_summaries[0].id #=> String
resp.pipeline_summaries[0].reprocessing_summaries[0].status #=> String, one of "RUNNING", "SUCCEEDED", "CANCELLED", "FAILED"
resp.pipeline_summaries[0].reprocessing_summaries[0].creation_time #=> Time
resp.pipeline_summaries[0].creation_time #=> Time
resp.pipeline_summaries[0].last_update_time #=> Time
resp.next_token #=> String

Parameters:

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

  ({})

Options Hash (params):

• :next_token (String) —

  The token for the next set of results.

• :max_results (Integer) —

  The maximum number of results to return in this request.

  The default value is 100.

Returns:

• (Types::ListPipelinesResponse) —

  Returns a response object which responds to the following methods:

  • #pipeline_summaries => Array<Types::PipelineSummary>
  • #next_token => String

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1682

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

#list_tags_for_resource(params = {}) ⇒ Types::ListTagsForResourceResponse

Lists the tags (metadata) that you have assigned to the resource.

Examples:

Request syntax with placeholder values

resp = client.list_tags_for_resource({
  resource_arn: "ResourceArn", # required
})

Response structure

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

Parameters:

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

  ({})

Options Hash (params):

• :resource_arn (required, String) —

  The ARN of the resource whose tags you want to list.

Returns:

• (Types::ListTagsForResourceResponse) —

  Returns a response object which responds to the following methods:

  • #tags => Array<Types::Tag>

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1710

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

#put_logging_options(params = {}) ⇒ Struct

Sets or updates the IoT Analytics logging options.

If you update the value of any loggingOptions field, it takes up to one minute for the change to take effect. Also, if you change the policy attached to the role you specified in the roleArn field (for example, to correct an invalid policy), it takes up to five minutes for that change to take effect.

Examples:

Request syntax with placeholder values

resp = client.put_logging_options({
  logging_options: { # required
    role_arn: "RoleArn", # required
    level: "ERROR", # required, accepts ERROR
    enabled: false, # required
  },
})

Parameters:

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

  ({})

Options Hash (params):

• :logging_options (required, Types::LoggingOptions) —

  The new values of the IoT Analytics logging options.

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1740

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

#run_pipeline_activity(params = {}) ⇒ Types::RunPipelineActivityResponse

Simulates the results of running a pipeline activity on a message payload.

Examples:

Request syntax with placeholder values

resp = client.run_pipeline_activity({
  pipeline_activity: { # required
    channel: {
      name: "ActivityName", # required
      channel_name: "ChannelName", # required
      next: "ActivityName",
    },
    lambda: {
      name: "ActivityName", # required
      lambda_name: "LambdaName", # required
      batch_size: 1, # required
      next: "ActivityName",
    },
    datastore: {
      name: "ActivityName", # required
      datastore_name: "DatastoreName", # required
    },
    add_attributes: {
      name: "ActivityName", # required
      attributes: { # required
        "AttributeName" => "AttributeName",
      },
      next: "ActivityName",
    },
    remove_attributes: {
      name: "ActivityName", # required
      attributes: ["AttributeName"], # required
      next: "ActivityName",
    },
    select_attributes: {
      name: "ActivityName", # required
      attributes: ["AttributeName"], # required
      next: "ActivityName",
    },
    filter: {
      name: "ActivityName", # required
      filter: "FilterExpression", # required
      next: "ActivityName",
    },
    math: {
      name: "ActivityName", # required
      attribute: "AttributeName", # required
      math: "MathExpression", # required
      next: "ActivityName",
    },
    device_registry_enrich: {
      name: "ActivityName", # required
      attribute: "AttributeName", # required
      thing_name: "AttributeName", # required
      role_arn: "RoleArn", # required
      next: "ActivityName",
    },
    device_shadow_enrich: {
      name: "ActivityName", # required
      attribute: "AttributeName", # required
      thing_name: "AttributeName", # required
      role_arn: "RoleArn", # required
      next: "ActivityName",
    },
  },
  payloads: ["data"], # required
})

Response structure

resp.payloads #=> Array
resp.payloads[0] #=> String
resp.log_result #=> String

Parameters:

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

  ({})

Options Hash (params):

• :pipeline_activity (required, Types::PipelineActivity) —

  The pipeline activity that is run. This must not be a channel activity or a data store activity because these activities are used in a pipeline only to load the original message and to store the (possibly) transformed message. If a Lambda activity is specified, only short-running Lambda functions (those with a timeout of less than 30 seconds or less) can be used.

• :payloads (required, Array<String, StringIO, File>) —

  The sample message payloads on which the pipeline activity is run.

Returns:

• (Types::RunPipelineActivityResponse) —

  Returns a response object which responds to the following methods:

  • #payloads => Array<String>
  • #log_result => String

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1837

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

#sample_channel_data(params = {}) ⇒ Types::SampleChannelDataResponse

Retrieves a sample of messages from the specified channel ingested during the specified timeframe. Up to 10 messages can be retrieved.

Examples:

Request syntax with placeholder values

resp = client.sample_channel_data({
  channel_name: "ChannelName", # required
  max_messages: 1,
  start_time: Time.now,
  end_time: Time.now,
})

Response structure

resp.payloads #=> Array
resp.payloads[0] #=> String

Parameters:

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

  ({})

Options Hash (params):

• :channel_name (required, String) —

  The name of the channel whose message samples are retrieved.

• :max_messages (Integer) —

  The number of sample messages to be retrieved. The limit is 10. The default is also 10.

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

  The start of the time window from which sample messages are retrieved.

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

  The end of the time window from which sample messages are retrieved.

Returns:

• (Types::SampleChannelDataResponse) —

  Returns a response object which responds to the following methods:

  • #payloads => Array<String>

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1878

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

#start_pipeline_reprocessing(params = {}) ⇒ Types::StartPipelineReprocessingResponse

Starts the reprocessing of raw message data through the pipeline.

Examples:

Request syntax with placeholder values

resp = client.start_pipeline_reprocessing({
  pipeline_name: "PipelineName", # required
  start_time: Time.now,
  end_time: Time.now,
  channel_messages: {
    s3_paths: ["S3PathChannelMessage"],
  },
})

Response structure

resp.reprocessing_id #=> String

Parameters:

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

  ({})

Options Hash (params):

• :pipeline_name (required, String) —

  The name of the pipeline on which to start reprocessing.

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

  The start time (inclusive) of raw message data that is reprocessed.

  If you specify a value for the startTime parameter, you must not use the channelMessages object.

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

  The end time (exclusive) of raw message data that is reprocessed.

  If you specify a value for the endTime parameter, you must not use the channelMessages object.

• :channel_messages (Types::ChannelMessages) —

  Specifies one or more sets of channel messages that you want to reprocess.

  If you use the channelMessages object, you must not specify a value for startTime and endTime.

Returns:

• (Types::StartPipelineReprocessingResponse) —

  Returns a response object which responds to the following methods:

  • #reprocessing_id => String

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1928

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

#tag_resource(params = {}) ⇒ Struct

Adds to or modifies the tags of the given resource. Tags are metadata that can be used to manage a resource.

Examples:

Request syntax with placeholder values

resp = client.tag_resource({
  resource_arn: "ResourceArn", # required
  tags: [ # required
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Parameters:

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

  ({})

Options Hash (params):

• :resource_arn (required, String) —

  The ARN of the resource whose tags you want to modify.

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

  The new or modified tags for the resource.

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1958

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

#untag_resource(params = {}) ⇒ Struct

Removes the given tags (metadata) from the resource.

Examples:

Request syntax with placeholder values

resp = client.untag_resource({
  resource_arn: "ResourceArn", # required
  tag_keys: ["TagKey"], # required
})

Parameters:

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

  ({})

Options Hash (params):

• :resource_arn (required, String) —

  The ARN of the resource whose tags you want to remove.

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

  The keys of those tags which you want to remove.

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 1982

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

#update_channel(params = {}) ⇒ Struct

Used to update the settings of a channel.

Examples:

Request syntax with placeholder values

resp = client.update_channel({
  channel_name: "ChannelName", # required
  channel_storage: {
    service_managed_s3: {
    },
    customer_managed_s3: {
      bucket: "BucketName", # required
      key_prefix: "S3KeyPrefix",
      role_arn: "RoleArn", # required
    },
  },
  retention_period: {
    unlimited: false,
    number_of_days: 1,
  },
})

Parameters:

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

  ({})

Options Hash (params):

• :channel_name (required, String) —

  The name of the channel to be updated.

• :channel_storage (Types::ChannelStorage) —

  Where channel data is stored. You can choose one of serviceManagedS3 or customerManagedS3 storage. If not specified, the default is serviceManagedS3. You can't change this storage option after the channel is created.

• :retention_period (Types::RetentionPeriod) —

  How long, in days, message data is kept for the channel. The retention period can't be updated if the channel's Amazon S3 storage is customer-managed.

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 2026

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

#update_dataset(params = {}) ⇒ Struct

Updates the settings of a dataset.

Examples:

Request syntax with placeholder values

resp = client.update_dataset({
  dataset_name: "DatasetName", # required
  actions: [ # required
    {
      action_name: "DatasetActionName",
      query_action: {
        sql_query: "SqlQuery", # required
        filters: [
          {
            delta_time: {
              offset_seconds: 1, # required
              time_expression: "TimeExpression", # required
            },
          },
        ],
      },
      container_action: {
        image: "Image", # required
        execution_role_arn: "RoleArn", # required
        resource_configuration: { # required
          compute_type: "ACU_1", # required, accepts ACU_1, ACU_2
          volume_size_in_gb: 1, # required
        },
        variables: [
          {
            name: "VariableName", # required
            string_value: "StringValue",
            double_value: 1.0,
            dataset_content_version_value: {
              dataset_name: "DatasetName", # required
            },
            output_file_uri_value: {
              file_name: "OutputFileName", # required
            },
          },
        ],
      },
    },
  ],
  triggers: [
    {
      schedule: {
        expression: "ScheduleExpression",
      },
      dataset: {
        name: "DatasetName", # required
      },
    },
  ],
  content_delivery_rules: [
    {
      entry_name: "EntryName",
      destination: { # required
        iot_events_destination_configuration: {
          input_name: "IotEventsInputName", # required
          role_arn: "RoleArn", # required
        },
        s3_destination_configuration: {
          bucket: "BucketName", # required
          key: "BucketKeyExpression", # required
          glue_configuration: {
            table_name: "GlueTableName", # required
            database_name: "GlueDatabaseName", # required
          },
          role_arn: "RoleArn", # required
        },
      },
    },
  ],
  retention_period: {
    unlimited: false,
    number_of_days: 1,
  },
  versioning_configuration: {
    unlimited: false,
    max_versions: 1,
  },
  late_data_rules: [
    {
      rule_name: "LateDataRuleName",
      rule_configuration: { # required
        delta_time_session_window_configuration: {
          timeout_in_minutes: 1, # required
        },
      },
    },
  ],
})

Parameters:

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

  ({})

Options Hash (params):

• :dataset_name (required, String) —

  The name of the dataset to update.

• :actions (required, Array<Types::DatasetAction>) —

  A list of DatasetAction objects.

• :triggers (Array<Types::DatasetTrigger>) —

  A list of DatasetTrigger objects. The list can be empty or can contain up to five DatasetTrigger objects.

• :content_delivery_rules (Array<Types::DatasetContentDeliveryRule>) —

  When dataset contents are created, they are delivered to destinations specified here.

• :retention_period (Types::RetentionPeriod) —

  How long, in days, dataset contents are kept for the dataset.

• :versioning_configuration (Types::VersioningConfiguration) —

  Optional. How many versions of dataset contents are kept. If not specified or set to null, only the latest version plus the latest succeeded version (if they are different) are kept for the time period specified by the retentionPeriod parameter. For more information, see Keeping Multiple Versions of IoT Analytics datasets in the IoT Analytics User Guide.

• :late_data_rules (Array<Types::LateDataRule>) —

  A list of data rules that send notifications to CloudWatch, when data arrives late. To specify lateDataRules, the dataset must use a DeltaTimer filter.

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 2166

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

#update_datastore(params = {}) ⇒ Struct

Used to update the settings of a data store.

Examples:

Request syntax with placeholder values

resp = client.update_datastore({
  datastore_name: "DatastoreName", # required
  retention_period: {
    unlimited: false,
    number_of_days: 1,
  },
  datastore_storage: {
    service_managed_s3: {
    },
    customer_managed_s3: {
      bucket: "BucketName", # required
      key_prefix: "S3KeyPrefix",
      role_arn: "RoleArn", # required
    },
    iot_site_wise_multi_layer_storage: {
      customer_managed_s3_storage: { # required
        bucket: "BucketName", # required
        key_prefix: "S3KeyPrefix",
      },
    },
  },
  file_format_configuration: {
    json_configuration: {
    },
    parquet_configuration: {
      schema_definition: {
        columns: [
          {
            name: "ColumnName", # required
            type: "ColumnDataType", # required
          },
        ],
      },
    },
  },
})

Parameters:

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

  ({})

Options Hash (params):

• :datastore_name (required, String) —

  The name of the data store to be updated.

• :retention_period (Types::RetentionPeriod) —

  How long, in days, message data is kept for the data store. The retention period can't be updated if the data store's Amazon S3 storage is customer-managed.

• :datastore_storage (Types::DatastoreStorage) —

  Where data in a data store is stored.. You can choose serviceManagedS3 storage, customerManagedS3 storage, or iotSiteWiseMultiLayerStorage storage. The default is serviceManagedS3. You can't change the choice of Amazon S3 storage after your data store is created.

• :file_format_configuration (Types::FileFormatConfiguration) —

  Contains the configuration information of file formats. IoT Analytics data stores support JSON and Parquet.

  The default file format is JSON. You can specify only one format.

  You can't change the file format after you create the data store.

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 2243

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

#update_pipeline(params = {}) ⇒ Struct

Updates the settings of a pipeline. You must specify both a channel and a datastore activity and, optionally, as many as 23 additional activities in the pipelineActivities array.

Examples:

Request syntax with placeholder values

resp = client.update_pipeline({
  pipeline_name: "PipelineName", # required
  pipeline_activities: [ # required
    {
      channel: {
        name: "ActivityName", # required
        channel_name: "ChannelName", # required
        next: "ActivityName",
      },
      lambda: {
        name: "ActivityName", # required
        lambda_name: "LambdaName", # required
        batch_size: 1, # required
        next: "ActivityName",
      },
      datastore: {
        name: "ActivityName", # required
        datastore_name: "DatastoreName", # required
      },
      add_attributes: {
        name: "ActivityName", # required
        attributes: { # required
          "AttributeName" => "AttributeName",
        },
        next: "ActivityName",
      },
      remove_attributes: {
        name: "ActivityName", # required
        attributes: ["AttributeName"], # required
        next: "ActivityName",
      },
      select_attributes: {
        name: "ActivityName", # required
        attributes: ["AttributeName"], # required
        next: "ActivityName",
      },
      filter: {
        name: "ActivityName", # required
        filter: "FilterExpression", # required
        next: "ActivityName",
      },
      math: {
        name: "ActivityName", # required
        attribute: "AttributeName", # required
        math: "MathExpression", # required
        next: "ActivityName",
      },
      device_registry_enrich: {
        name: "ActivityName", # required
        attribute: "AttributeName", # required
        thing_name: "AttributeName", # required
        role_arn: "RoleArn", # required
        next: "ActivityName",
      },
      device_shadow_enrich: {
        name: "ActivityName", # required
        attribute: "AttributeName", # required
        thing_name: "AttributeName", # required
        role_arn: "RoleArn", # required
        next: "ActivityName",
      },
    },
  ],
})

Parameters:

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

  ({})

Options Hash (params):

• :pipeline_name (required, String) —

  The name of the pipeline to update.

• :pipeline_activities (required, Array<Types::PipelineActivity>) —

  A list of PipelineActivity objects. Activities perform transformations on your messages, such as removing, renaming or adding message attributes; filtering messages based on attribute values; invoking your Lambda functions on messages for advanced processing; or performing mathematical transformations to normalize device data.

  The list can be 2-25 PipelineActivity objects and must contain both a channel and a datastore activity. Each entry in the list must contain only one activity. For example:

  pipelineActivities = [ \{ "channel": \{ ... \} \}, \{ "lambda": \{ ... \} \}, ... ]

Returns:

• (Struct) —

  Returns an empty response.

# File 'gems/aws-sdk-iotanalytics/lib/aws-sdk-iotanalytics/client.rb', line 2340

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