Skip to content
v2.277.0

CfnDatasetProps Struct ​

Properties for defining a CfnDataset.

Example ​

ts
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import { aws_iotanalytics as iotanalytics } from 'aws-cdk-lib';
const cfnDatasetProps: iotanalytics.CfnDatasetProps = {
  actions: [{
    actionName: 'actionName',

    // the properties below are optional
    containerAction: {
      executionRoleArn: 'executionRoleArn',
      image: 'image',
      resourceConfiguration: {
        computeType: 'computeType',
        volumeSizeInGb: 123,
      },

      // the properties below are optional
      variables: [{
        variableName: 'variableName',

        // the properties below are optional
        datasetContentVersionValue: {
          datasetName: 'datasetName',
        },
        doubleValue: 123,
        outputFileUriValue: {
          fileName: 'fileName',
        },
        stringValue: 'stringValue',
      }],
    },
    queryAction: {
      sqlQuery: 'sqlQuery',

      // the properties below are optional
      filters: [{
        deltaTime: {
          offsetSeconds: 123,
          timeExpression: 'timeExpression',
        },
      }],
    },
  }],

  // the properties below are optional
  contentDeliveryRules: [{
    destination: {
      iotEventsDestinationConfiguration: {
        inputName: 'inputName',
        roleArn: 'roleArn',
      },
      s3DestinationConfiguration: {
        bucket: 'bucket',
        key: 'key',
        roleArn: 'roleArn',

        // the properties below are optional
        glueConfiguration: {
          databaseName: 'databaseName',
          tableName: 'tableName',
        },
      },
    },

    // the properties below are optional
    entryName: 'entryName',
  }],
  datasetName: 'datasetName',
  lateDataRules: [{
    ruleConfiguration: {
      deltaTimeSessionWindowConfiguration: {
        timeoutInMinutes: 123,
      },
    },

    // the properties below are optional
    ruleName: 'ruleName',
  }],
  retentionPeriod: {
    numberOfDays: 123,
    unlimited: false,
  },
  tags: [{
    key: 'key',
    value: 'value',
  }],
  triggers: [{
    schedule: {
      scheduleExpression: 'scheduleExpression',
    },
    triggeringDataset: {
      datasetName: 'datasetName',
    },
  }],
  versioningConfiguration: {
    maxVersions: 123,
    unlimited: false,
  },
};
python
from aws_cdk import CfnTag
# The code below shows an example of how to instantiate this type.
# The values are placeholders you should change.
from aws_cdk import aws_iotanalytics as iotanalytics

cfn_dataset_props = iotanalytics.CfnDatasetProps(
    actions=[iotanalytics.CfnDataset.ActionProperty(
        action_name="actionName",

        # the properties below are optional
        container_action=iotanalytics.CfnDataset.ContainerActionProperty(
            execution_role_arn="executionRoleArn",
            image="image",
            resource_configuration=iotanalytics.CfnDataset.ResourceConfigurationProperty(
                compute_type="computeType",
                volume_size_in_gb=123
            ),

            # the properties below are optional
            variables=[iotanalytics.CfnDataset.VariableProperty(
                variable_name="variableName",

                # the properties below are optional
                dataset_content_version_value=iotanalytics.CfnDataset.DatasetContentVersionValueProperty(
                    dataset_name="datasetName"
                ),
                double_value=123,
                output_file_uri_value=iotanalytics.CfnDataset.OutputFileUriValueProperty(
                    file_name="fileName"
                ),
                string_value="stringValue"
            )]
        ),
        query_action=iotanalytics.CfnDataset.QueryActionProperty(
            sql_query="sqlQuery",

            # the properties below are optional
            filters=[iotanalytics.CfnDataset.FilterProperty(
                delta_time=iotanalytics.CfnDataset.DeltaTimeProperty(
                    offset_seconds=123,
                    time_expression="timeExpression"
                )
            )]
        )
    )],

    # the properties below are optional
    content_delivery_rules=[iotanalytics.CfnDataset.DatasetContentDeliveryRuleProperty(
        destination=iotanalytics.CfnDataset.DatasetContentDeliveryRuleDestinationProperty(
            iot_events_destination_configuration=iotanalytics.CfnDataset.IotEventsDestinationConfigurationProperty(
                input_name="inputName",
                role_arn="roleArn"
            ),
            s3_destination_configuration=iotanalytics.CfnDataset.S3DestinationConfigurationProperty(
                bucket="bucket",
                key="key",
                role_arn="roleArn",

                # the properties below are optional
                glue_configuration=iotanalytics.CfnDataset.GlueConfigurationProperty(
                    database_name="databaseName",
                    table_name="tableName"
                )
            )
        ),

        # the properties below are optional
        entry_name="entryName"
    )],
    dataset_name="datasetName",
    late_data_rules=[iotanalytics.CfnDataset.LateDataRuleProperty(
        rule_configuration=iotanalytics.CfnDataset.LateDataRuleConfigurationProperty(
            delta_time_session_window_configuration=iotanalytics.CfnDataset.DeltaTimeSessionWindowConfigurationProperty(
                timeout_in_minutes=123
            )
        ),

        # the properties below are optional
        rule_name="ruleName"
    )],
    retention_period=iotanalytics.CfnDataset.RetentionPeriodProperty(
        number_of_days=123,
        unlimited=False
    ),
    tags=[CfnTag(
        key="key",
        value="value"
    )],
    triggers=[iotanalytics.CfnDataset.TriggerProperty(
        schedule=iotanalytics.CfnDataset.ScheduleProperty(
            schedule_expression="scheduleExpression"
        ),
        triggering_dataset=iotanalytics.CfnDataset.TriggeringDatasetProperty(
            dataset_name="datasetName"
        )
    )],
    versioning_configuration=iotanalytics.CfnDataset.VersioningConfigurationProperty(
        max_versions=123,
        unlimited=False
    )
)
java
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import software.amazon.awscdk.services.iotanalytics.*;

CfnDatasetProps cfnDatasetProps = CfnDatasetProps.builder()
        .actions(List.of(ActionProperty.builder()
                .actionName("actionName")

                // the properties below are optional
                .containerAction(ContainerActionProperty.builder()
                        .executionRoleArn("executionRoleArn")
                        .image("image")
                        .resourceConfiguration(ResourceConfigurationProperty.builder()
                                .computeType("computeType")
                                .volumeSizeInGb(123)
                                .build())

                        // the properties below are optional
                        .variables(List.of(VariableProperty.builder()
                                .variableName("variableName")

                                // the properties below are optional
                                .datasetContentVersionValue(DatasetContentVersionValueProperty.builder()
                                        .datasetName("datasetName")
                                        .build())
                                .doubleValue(123)
                                .outputFileUriValue(OutputFileUriValueProperty.builder()
                                        .fileName("fileName")
                                        .build())
                                .stringValue("stringValue")
                                .build()))
                        .build())
                .queryAction(QueryActionProperty.builder()
                        .sqlQuery("sqlQuery")

                        // the properties below are optional
                        .filters(List.of(FilterProperty.builder()
                                .deltaTime(DeltaTimeProperty.builder()
                                        .offsetSeconds(123)
                                        .timeExpression("timeExpression")
                                        .build())
                                .build()))
                        .build())
                .build()))

        // the properties below are optional
        .contentDeliveryRules(List.of(DatasetContentDeliveryRuleProperty.builder()
                .destination(DatasetContentDeliveryRuleDestinationProperty.builder()
                        .iotEventsDestinationConfiguration(IotEventsDestinationConfigurationProperty.builder()
                                .inputName("inputName")
                                .roleArn("roleArn")
                                .build())
                        .s3DestinationConfiguration(S3DestinationConfigurationProperty.builder()
                                .bucket("bucket")
                                .key("key")
                                .roleArn("roleArn")

                                // the properties below are optional
                                .glueConfiguration(GlueConfigurationProperty.builder()
                                        .databaseName("databaseName")
                                        .tableName("tableName")
                                        .build())
                                .build())
                        .build())

                // the properties below are optional
                .entryName("entryName")
                .build()))
        .datasetName("datasetName")
        .lateDataRules(List.of(LateDataRuleProperty.builder()
                .ruleConfiguration(LateDataRuleConfigurationProperty.builder()
                        .deltaTimeSessionWindowConfiguration(DeltaTimeSessionWindowConfigurationProperty.builder()
                                .timeoutInMinutes(123)
                                .build())
                        .build())

                // the properties below are optional
                .ruleName("ruleName")
                .build()))
        .retentionPeriod(RetentionPeriodProperty.builder()
                .numberOfDays(123)
                .unlimited(false)
                .build())
        .tags(List.of(CfnTag.builder()
                .key("key")
                .value("value")
                .build()))
        .triggers(List.of(TriggerProperty.builder()
                .schedule(ScheduleProperty.builder()
                        .scheduleExpression("scheduleExpression")
                        .build())
                .triggeringDataset(TriggeringDatasetProperty.builder()
                        .datasetName("datasetName")
                        .build())
                .build()))
        .versioningConfiguration(VersioningConfigurationProperty.builder()
                .maxVersions(123)
                .unlimited(false)
                .build())
        .build();
csharp
// Install: dotnet add package Amazon.CDK.Lib
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
using Amazon.CDK.AWS.IoTAnalytics;

var cfnDatasetProps = new CfnDatasetProps {
    Actions = new [] { new ActionProperty {
        ActionName = "actionName",

        // the properties below are optional
        ContainerAction = new ContainerActionProperty {
            ExecutionRoleArn = "executionRoleArn",
            Image = "image",
            ResourceConfiguration = new ResourceConfigurationProperty {
                ComputeType = "computeType",
                VolumeSizeInGb = 123
            },

            // the properties below are optional
            Variables = new [] { new VariableProperty {
                VariableName = "variableName",

                // the properties below are optional
                DatasetContentVersionValue = new DatasetContentVersionValueProperty {
                    DatasetName = "datasetName"
                },
                DoubleValue = 123,
                OutputFileUriValue = new OutputFileUriValueProperty {
                    FileName = "fileName"
                },
                StringValue = "stringValue"
            } }
        },
        QueryAction = new QueryActionProperty {
            SqlQuery = "sqlQuery",

            // the properties below are optional
            Filters = new [] { new FilterProperty {
                DeltaTime = new DeltaTimeProperty {
                    OffsetSeconds = 123,
                    TimeExpression = "timeExpression"
                }
            } }
        }
    } },

    // the properties below are optional
    ContentDeliveryRules = new [] { new DatasetContentDeliveryRuleProperty {
        Destination = new DatasetContentDeliveryRuleDestinationProperty {
            IotEventsDestinationConfiguration = new IotEventsDestinationConfigurationProperty {
                InputName = "inputName",
                RoleArn = "roleArn"
            },
            S3DestinationConfiguration = new S3DestinationConfigurationProperty {
                Bucket = "bucket",
                Key = "key",
                RoleArn = "roleArn",

                // the properties below are optional
                GlueConfiguration = new GlueConfigurationProperty {
                    DatabaseName = "databaseName",
                    TableName = "tableName"
                }
            }
        },

        // the properties below are optional
        EntryName = "entryName"
    } },
    DatasetName = "datasetName",
    LateDataRules = new [] { new LateDataRuleProperty {
        RuleConfiguration = new LateDataRuleConfigurationProperty {
            DeltaTimeSessionWindowConfiguration = new DeltaTimeSessionWindowConfigurationProperty {
                TimeoutInMinutes = 123
            }
        },

        // the properties below are optional
        RuleName = "ruleName"
    } },
    RetentionPeriod = new RetentionPeriodProperty {
        NumberOfDays = 123,
        Unlimited = false
    },
    Tags = new [] { new CfnTag {
        Key = "key",
        Value = "value"
    } },
    Triggers = new [] { new TriggerProperty {
        Schedule = new ScheduleProperty {
            ScheduleExpression = "scheduleExpression"
        },
        TriggeringDataset = new TriggeringDatasetProperty {
            DatasetName = "datasetName"
        }
    } },
    VersioningConfiguration = new VersioningConfigurationProperty {
        MaxVersions = 123,
        Unlimited = false
    }
};
go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

cfnDatasetProps := &CfnDatasetProps{
	Actions: []interface{}{
		&ActionProperty{
			ActionName: jsii.String("actionName"),

			// the properties below are optional
			ContainerAction: &ContainerActionProperty{
				ExecutionRoleArn: jsii.String("executionRoleArn"),
				Image: jsii.String("image"),
				ResourceConfiguration: &ResourceConfigurationProperty{
					ComputeType: jsii.String("computeType"),
					VolumeSizeInGb: jsii.Number(123),
				},

				// the properties below are optional
				Variables: []interface{}{
					&VariableProperty{
						VariableName: jsii.String("variableName"),

						// the properties below are optional
						DatasetContentVersionValue: &DatasetContentVersionValueProperty{
							DatasetName: jsii.String("datasetName"),
						},
						DoubleValue: jsii.Number(123),
						OutputFileUriValue: &OutputFileUriValueProperty{
							FileName: jsii.String("fileName"),
						},
						StringValue: jsii.String("stringValue"),
					},
				},
			},
			QueryAction: &QueryActionProperty{
				SqlQuery: jsii.String("sqlQuery"),

				// the properties below are optional
				Filters: []interface{}{
					&FilterProperty{
						DeltaTime: &DeltaTimeProperty{
							OffsetSeconds: jsii.Number(123),
							TimeExpression: jsii.String("timeExpression"),
						},
					},
				},
			},
		},
	},

	// the properties below are optional
	ContentDeliveryRules: []interface{}{
		&DatasetContentDeliveryRuleProperty{
			Destination: &DatasetContentDeliveryRuleDestinationProperty{
				IotEventsDestinationConfiguration: &IotEventsDestinationConfigurationProperty{
					InputName: jsii.String("inputName"),
					RoleArn: jsii.String("roleArn"),
				},
				S3DestinationConfiguration: &S3DestinationConfigurationProperty{
					Bucket: jsii.String("bucket"),
					Key: jsii.String("key"),
					RoleArn: jsii.String("roleArn"),

					// the properties below are optional
					GlueConfiguration: &GlueConfigurationProperty{
						DatabaseName: jsii.String("databaseName"),
						TableName: jsii.String("tableName"),
					},
				},
			},

			// the properties below are optional
			EntryName: jsii.String("entryName"),
		},
	},
	DatasetName: jsii.String("datasetName"),
	LateDataRules: []interface{}{
		&LateDataRuleProperty{
			RuleConfiguration: &LateDataRuleConfigurationProperty{
				DeltaTimeSessionWindowConfiguration: &DeltaTimeSessionWindowConfigurationProperty{
					TimeoutInMinutes: jsii.Number(123),
				},
			},

			// the properties below are optional
			RuleName: jsii.String("ruleName"),
		},
	},
	RetentionPeriod: &RetentionPeriodProperty{
		NumberOfDays: jsii.Number(123),
		Unlimited: jsii.Boolean(false),
	},
	Tags: []CfnTag{
		&CfnTag{
			Key: jsii.String("key"),
			Value: jsii.String("value"),
		},
	},
	Triggers: []interface{}{
		&TriggerProperty{
			Schedule: &ScheduleProperty{
				ScheduleExpression: jsii.String("scheduleExpression"),
			},
			TriggeringDataset: &TriggeringDatasetProperty{
				DatasetName: jsii.String("datasetName"),
			},
		},
	},
	VersioningConfiguration: &VersioningConfigurationProperty{
		MaxVersions: jsii.Number(123),
		Unlimited: jsii.Boolean(false),
	},
}

Properties ​

actionsIResolvable | IResolvable | CfnDataset.ActionProperty[]actionstyping.Union[IResolvable, typing.List[typing.Union[IResolvable, ActionProperty]]]actionsIResolvableActionsIResolvableActionsinterface{}required#
The `DatasetAction` objects that automatically create the dataset contents.
contentDeliveryRulesoptionalIResolvable | IResolvable | CfnDataset.DatasetContentDeliveryRuleProperty[]content_delivery_rulesoptionaltyping.Union[IResolvable, typing.List[typing.Union[IResolvable, DatasetContentDeliveryRuleProperty]]]contentDeliveryRulesoptionalIResolvableContentDeliveryRulesoptionalIResolvableContentDeliveryRulesoptionalinterface{}#
When dataset contents are created they are delivered to destinations specified here.
datasetNameoptionalstringdataset_nameoptionalstrdatasetNameoptionalStringDatasetNameoptionalstringDatasetNameoptional*string#
The name of the dataset.
lateDataRulesoptionalIResolvable | IResolvable | CfnDataset.LateDataRuleProperty[]late_data_rulesoptionaltyping.Union[IResolvable, typing.List[typing.Union[IResolvable, LateDataRuleProperty]]]lateDataRulesoptionalIResolvableLateDataRulesoptionalIResolvableLateDataRulesoptionalinterface{}#
A list of data rules that send notifications to CloudWatch, when data arrives late.

To specify lateDataRules , the dataset must use a DeltaTimer filter.

retentionPeriodoptionalIResolvable | CfnDataset.RetentionPeriodPropertyretention_periodoptionaltyping.Union[IResolvable, RetentionPeriodProperty]retentionPeriodoptionalIResolvableRetentionPeriodoptionalIResolvableRetentionPeriodoptionalinterface{}#
Optional.

How long, in days, message data is kept for the dataset.

tagsoptionalCfnTag[]tagsoptionaltyping.List[CfnTag]tagsoptionalList<CfnTag>TagsoptionalCfnTag[]Tagsoptional*[]CfnTag#
Metadata which can be used to manage the data set.

For more information, see Tag .

triggersoptionalIResolvable | IResolvable | CfnDataset.TriggerProperty[]triggersoptionaltyping.Union[IResolvable, typing.List[typing.Union[IResolvable, TriggerProperty]]]triggersoptionalIResolvableTriggersoptionalIResolvableTriggersoptionalinterface{}#
The `DatasetTrigger` objects that specify when the dataset is automatically updated.
versioningConfigurationoptionalIResolvable | CfnDataset.VersioningConfigurationPropertyversioning_configurationoptionaltyping.Union[IResolvable, VersioningConfigurationProperty]versioningConfigurationoptionalIResolvableVersioningConfigurationoptionalIResolvableVersioningConfigurationoptionalinterface{}#
Optional.
notes

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 ITA datasets in the ITA User Guide .