kinesisfirehose

package
v0.0.92 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 4, 2023 License: Apache-2.0 Imports: 16 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func DeliveryStream_IsConstruct 

func DeliveryStream_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Returns: true if `x` is an object created from a class which extends `Construct`. Deprecated: use `x instanceof Construct` instead.

func DeliveryStream_IsOwnedResource 

func DeliveryStream_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise.

func DeliveryStream_IsResource 

func DeliveryStream_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource.

func NewAppendDelimiterProcessor_Override 

func NewAppendDelimiterProcessor_Override(a AppendDelimiterProcessor, options *AppendDelimiterProcessorOptions)

func NewBackupConfiguration_Override 

func NewBackupConfiguration_Override(b BackupConfiguration, options *BackupConfigurationOptions)

func NewBufferingConfiguration_Override 

func NewBufferingConfiguration_Override(b BufferingConfiguration, options *BufferingConfigurationOptions)

func NewCloudWatchLoggingConfiguration_Override 

func NewCloudWatchLoggingConfiguration_Override(c CloudWatchLoggingConfiguration, options *CloudWatchLoggingConfigurationOptions)

func NewCustomProcessor_Override 

func NewCustomProcessor_Override(c CustomProcessor, options *CustomProcessorOptions)

func NewDataFormatConversion_Override 

func NewDataFormatConversion_Override(d DataFormatConversion, options *DataFormatConversionOptions)

func NewDeliveryStreamDestination_Override 

func NewDeliveryStreamDestination_Override(d DeliveryStreamDestination)

func NewDeliveryStreamProcessor_Override 

func NewDeliveryStreamProcessor_Override(d DeliveryStreamProcessor, options *DeliveryStreamProcessorOptions)

func NewDeliveryStream_Override 

func NewDeliveryStream_Override(d DeliveryStream, scope constructs.Construct, id *string, props *DeliveryStreamProps)

func NewDynamicPartitioning_Override 

func NewDynamicPartitioning_Override(d DynamicPartitioning, options *CommonPartitioningOptions)

func NewExtendedS3Destination_Override 

func NewExtendedS3Destination_Override(e ExtendedS3Destination, bucket awss3.IBucket, options *ExtendedS3DestinationOptions)

func NewHiveJsonInputSerDe_Override 

func NewHiveJsonInputSerDe_Override(h HiveJsonInputSerDe, options *HiveJsonInputSerDeOptions)

func NewHttpEndpointDestination_Override 

func NewHttpEndpointDestination_Override(h HttpEndpointDestination, url *string, options *HttpEndpointDestinationOptions)

func NewInputFormat_Override 

func NewInputFormat_Override(i InputFormat)

func NewJsonPartitioningSource_Override 

func NewJsonPartitioningSource_Override(j JsonPartitioningSource, options *JsonPartitioningOptions)

func NewJsonQuery_Override 

func NewJsonQuery_Override(j JsonQuery, fields *map[string]*string)

func NewLambdaPartitioningSource_Override 

func NewLambdaPartitioningSource_Override(l LambdaPartitioningSource, options *LambdaPartitioningOptions)

func NewLambdaProcessor_Override 

func NewLambdaProcessor_Override(l LambdaProcessor, options *LambdaProcessorOptions)

func NewMetaDataExtractionQuery_Override 

func NewMetaDataExtractionQuery_Override(m MetaDataExtractionQuery, query *string)

func NewMetadataExtractionProcessor_Override 

func NewMetadataExtractionProcessor_Override(m MetadataExtractionProcessor, options *MetadataExtractionProcessorOptions)

func NewOpenxJsonInputSerDe_Override 

func NewOpenxJsonInputSerDe_Override(o OpenxJsonInputSerDe, options *OpenxJsonInputSerDeOptions)

func NewOrcOutputSerDe_Override 

func NewOrcOutputSerDe_Override(o OrcOutputSerDe, options *OrcOutputSerDeOptions)

func NewOutputFormat_Override 

func NewOutputFormat_Override(o OutputFormat)

func NewParquetOutputSerDe_Override 

func NewParquetOutputSerDe_Override(p ParquetOutputSerDe, options *ParquetOutputSerDeOptions)

func NewProcessorConfiguration_Override 

func NewProcessorConfiguration_Override(p ProcessorConfiguration, options *ProcessorConfigurationOptions)

func NewRecordDeaggregationProcessor_Override 

func NewRecordDeaggregationProcessor_Override(r RecordDeaggregationProcessor, options *RecordDeaggregationProcessorOptions)

func NewS3Destination_Override 

func NewS3Destination_Override(s S3Destination, bucket awss3.IBucket, options *S3DestinationOptions)

Types

type AppendDelimiterProcessor 

type AppendDelimiterProcessor interface {
	DeliveryStreamProcessor
	Delimiter() *string
	ProcessorType() ProcessorType
	AddProcessorParameter(name *string, value *string)
	Bind(_scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_ProcessorProperty
}

func NewAppendDelimiterProcessor 

func NewAppendDelimiterProcessor(options *AppendDelimiterProcessorOptions) AppendDelimiterProcessor

type AppendDelimiterProcessorOptions 

type AppendDelimiterProcessorOptions struct {
	Delimiter *string `field:"required" json:"delimiter" yaml:"delimiter"`
}

type BackupConfiguration 

type BackupConfiguration interface {
	Destination() IDeliveryStreamBackupDestination
	Enabled() *bool
	Bind(scope constructs.IConstruct) *BackupConfigurationResult
}

func NewBackupConfiguration 

func NewBackupConfiguration(options *BackupConfigurationOptions) BackupConfiguration

type BackupConfigurationOptions 

type BackupConfigurationOptions struct {
	Destination IDeliveryStreamBackupDestination `field:"required" json:"destination" yaml:"destination"`
	Enabled     *bool                            `field:"optional" json:"enabled" yaml:"enabled"`
}

type BackupConfigurationResult 

type BackupConfigurationResult struct {
	S3BackupConfiguration *awskinesisfirehose.CfnDeliveryStream_S3DestinationConfigurationProperty `field:"required" json:"s3BackupConfiguration" yaml:"s3BackupConfiguration"`
	S3BackupMode          *string                                                                  `field:"optional" json:"s3BackupMode" yaml:"s3BackupMode"`
}

type BufferingConfiguration 

type BufferingConfiguration interface {
	Interval() awscdk.Duration
	SizeInMb() *float64
	Bind(_scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_BufferingHintsProperty
}

func NewBufferingConfiguration 

func NewBufferingConfiguration(options *BufferingConfigurationOptions) BufferingConfiguration

type BufferingConfigurationOptions 

type BufferingConfigurationOptions struct {
	Interval awscdk.Duration `field:"optional" json:"interval" yaml:"interval"`
	SizeInMb *float64        `field:"optional" json:"sizeInMb" yaml:"sizeInMb"`
}

type CloudWatchLoggingConfiguration 

type CloudWatchLoggingConfiguration interface {
	Enabled() *bool
	LogGroup() awslogs.ILogGroup
	LogStream() awslogs.ILogStream
	Bind(scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_CloudWatchLoggingOptionsProperty
}

func NewCloudWatchLoggingConfiguration 

func NewCloudWatchLoggingConfiguration(options *CloudWatchLoggingConfigurationOptions) CloudWatchLoggingConfiguration

type CloudWatchLoggingConfigurationOptions 

type CloudWatchLoggingConfigurationOptions struct {
	Enabled   *bool              `field:"optional" json:"enabled" yaml:"enabled"`
	LogGroup  awslogs.ILogGroup  `field:"optional" json:"logGroup" yaml:"logGroup"`
	LogStream awslogs.ILogStream `field:"optional" json:"logStream" yaml:"logStream"`
}

type CommonPartitioningOptions 

type CommonPartitioningOptions struct {
	Enabled       *bool           `field:"optional" json:"enabled" yaml:"enabled"`
	RetryInterval awscdk.Duration `field:"optional" json:"retryInterval" yaml:"retryInterval"`
}

type ContentEncoding 

type ContentEncoding string
const (
	ContentEncoding_GZIP ContentEncoding = "GZIP"
	ContentEncoding_NONE ContentEncoding = "NONE"
)

type CustomProcessor 

type CustomProcessor interface {
	DeliveryStreamProcessor
	ProcessorType() ProcessorType
	AddParameter(name *string, value *string)
	AddProcessorParameter(name *string, value *string)
	Bind(_scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_ProcessorProperty
}

func NewCustomProcessor 

func NewCustomProcessor(options *CustomProcessorOptions) CustomProcessor

type CustomProcessorOptions 

type CustomProcessorOptions struct {
	ProcessorType ProcessorType       `field:"required" json:"processorType" yaml:"processorType"`
	Parameters    *map[string]*string `field:"optional" json:"parameters" yaml:"parameters"`
}

type DataFormatConversion 

type DataFormatConversion interface {
	CatalogId() *string
	Database() glue.Database
	Enabled() *bool
	InputFormat() InputFormat
	OutputFormat() OutputFormat
	Region() *string
	Role() awsiam.IRole
	Table() glue.Table
	Version() TableVersion
	Bind(scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_DataFormatConversionConfigurationProperty
}

func NewDataFormatConversion 

func NewDataFormatConversion(options *DataFormatConversionOptions) DataFormatConversion

type DataFormatConversionOptions 

type DataFormatConversionOptions struct {
	Database     glue.Database `field:"required" json:"database" yaml:"database"`
	InputFormat  InputFormat   `field:"required" json:"inputFormat" yaml:"inputFormat"`
	OutputFormat OutputFormat  `field:"required" json:"outputFormat" yaml:"outputFormat"`
	Table        glue.Table    `field:"required" json:"table" yaml:"table"`
	CatalogId    *string       `field:"optional" json:"catalogId" yaml:"catalogId"`
	Enabled      *bool         `field:"optional" json:"enabled" yaml:"enabled"`
	Region       *string       `field:"optional" json:"region" yaml:"region"`
	Role         awsiam.IRole  `field:"optional" json:"role" yaml:"role"`
	Version      TableVersion  `field:"optional" json:"version" yaml:"version"`
}

type DelimitedDeaggregationOptions 

type DelimitedDeaggregationOptions struct {
	Delimiter *string `field:"required" json:"delimiter" yaml:"delimiter"`
}

type DeliveryStream 

type DeliveryStream interface {
	awscdk.Resource
	IDeliveryStream
	// The network connections associated with this resource.
	Connections() awsec2.Connections
	DeliveryStreamArn() *string
	DeliveryStreamName() *string
	Destination() DeliveryStreamDestination
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	GrantPrincipal() awsiam.IPrincipal
	Name() *string
	// The tree node.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	PhysicalName() *string
	Resource() awskinesisfirehose.CfnDeliveryStream
	// The stack in which this resource is defined.
	Stack() awscdk.Stack
	StreamType() DeliveryStreamType
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	GetResourceNameAttribute(nameAttr *string) *string
	Grant(grantee awsiam.IGrantable, actions ...*string) awsiam.Grant
	GrantPutRecords(grantee awsiam.IGrantable) awsiam.Grant
	Metric(metricName *string, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	MetricBackupToS3Bytes(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	MetricBackupToS3DataFreshness(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	MetricBackupToS3Records(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	MetricIncomingBytes(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	MetricIncomingRecords(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Returns a string representation of this construct.
	ToString() *string
}

func NewDeliveryStream 

func NewDeliveryStream(scope constructs.Construct, id *string, props *DeliveryStreamProps) DeliveryStream

type DeliveryStreamAttributes 

type DeliveryStreamAttributes struct {
	DeliveryStreamArn  *string      `field:"optional" json:"deliveryStreamArn" yaml:"deliveryStreamArn"`
	DeliveryStreamName *string      `field:"optional" json:"deliveryStreamName" yaml:"deliveryStreamName"`
	Role               awsiam.IRole `field:"optional" json:"role" yaml:"role"`
}

type DeliveryStreamDestination 

type DeliveryStreamDestination interface {
	Role() awsiam.IRole
	Bind(scope constructs.IConstruct) *DeliveryStreamDestinationConfiguration
}

type DeliveryStreamDestinationConfiguration 

type DeliveryStreamDestinationConfiguration struct {
	AmazonopensearchserviceDestinationConfiguration *awskinesisfirehose.CfnDeliveryStream_AmazonopensearchserviceDestinationConfigurationProperty `` /* 126-byte string literal not displayed */
	ElasticsearchDestinationConfiguration           *awskinesisfirehose.CfnDeliveryStream_ElasticsearchDestinationConfigurationProperty           `field:"optional" json:"elasticsearchDestinationConfiguration" yaml:"elasticsearchDestinationConfiguration"`
	ExtendedS3DestinationConfiguration              *awskinesisfirehose.CfnDeliveryStream_ExtendedS3DestinationConfigurationProperty              `field:"optional" json:"extendedS3DestinationConfiguration" yaml:"extendedS3DestinationConfiguration"`
	HttpEndpointDestinationConfiguration            *awskinesisfirehose.CfnDeliveryStream_HttpEndpointDestinationConfigurationProperty            `field:"optional" json:"httpEndpointDestinationConfiguration" yaml:"httpEndpointDestinationConfiguration"`
	RedshiftDestinationConfiguration                *awskinesisfirehose.CfnDeliveryStream_RedshiftDestinationConfigurationProperty                `field:"optional" json:"redshiftDestinationConfiguration" yaml:"redshiftDestinationConfiguration"`
	S3DestinationConfiguration                      *awskinesisfirehose.CfnDeliveryStream_S3DestinationConfigurationProperty                      `field:"optional" json:"s3DestinationConfiguration" yaml:"s3DestinationConfiguration"`
	SplunkDestinationConfiguration                  *awskinesisfirehose.CfnDeliveryStream_SplunkDestinationConfigurationProperty                  `field:"optional" json:"splunkDestinationConfiguration" yaml:"splunkDestinationConfiguration"`
}

type DeliveryStreamProcessor 

type DeliveryStreamProcessor interface {
	ProcessorType() ProcessorType
	AddProcessorParameter(name *string, value *string)
	Bind(_scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_ProcessorProperty
}

func NewDeliveryStreamProcessor 

func NewDeliveryStreamProcessor(options *DeliveryStreamProcessorOptions) DeliveryStreamProcessor

type DeliveryStreamProcessorOptions 

type DeliveryStreamProcessorOptions struct {
	ProcessorType ProcessorType       `field:"required" json:"processorType" yaml:"processorType"`
	Parameters    *map[string]*string `field:"optional" json:"parameters" yaml:"parameters"`
}

type DeliveryStreamProps 

type DeliveryStreamProps struct {
	// The AWS account ID this resource belongs to.
	// Default: - the resource is in the same account as the stack it belongs to.
	//
	Account *string `field:"optional" json:"account" yaml:"account"`
	// ARN to deduce region and account from.
	//
	// The ARN is parsed and the account and region are taken from the ARN.
	// This should be used for imported resources.
	//
	// Cannot be supplied together with either `account` or `region`.
	// Default: - take environment from `account`, `region` parameters, or use Stack environment.
	//
	EnvironmentFromArn *string `field:"optional" json:"environmentFromArn" yaml:"environmentFromArn"`
	// The value passed in by users to the physical name prop of the resource.
	//
	// - `undefined` implies that a physical name will be allocated by
	//   CloudFormation during deployment.
	// - a concrete value implies a specific physical name
	// - `PhysicalName.GENERATE_IF_NEEDED` is a marker that indicates that a physical will only be generated
	//   by the CDK if it is needed for cross-environment references. Otherwise, it will be allocated by CloudFormation.
	// Default: - The physical name will be allocated by CloudFormation at deployment time.
	//
	PhysicalName *string `field:"optional" json:"physicalName" yaml:"physicalName"`
	// The AWS region this resource belongs to.
	// Default: - the resource is in the same region as the stack it belongs to.
	//
	Region      *string                   `field:"optional" json:"region" yaml:"region"`
	Destination DeliveryStreamDestination `field:"required" json:"destination" yaml:"destination"`
	Name        *string                   `field:"optional" json:"name" yaml:"name"`
	StreamType  DeliveryStreamType        `field:"optional" json:"streamType" yaml:"streamType"`
}

type DeliveryStreamType 

type DeliveryStreamType string
const (
	DeliveryStreamType_DIRECT_PUT               DeliveryStreamType = "DIRECT_PUT"
	DeliveryStreamType_KINESIS_STREAM_AS_SOURCE DeliveryStreamType = "KINESIS_STREAM_AS_SOURCE"
)

type DynamicPartitioning 

type DynamicPartitioning interface {
	Enabled() *bool
	RetryInterval() awscdk.Duration
	Bind(_scope constructs.IConstruct) *DynamicPartitioningConfiguration
}

func NewDynamicPartitioning 

func NewDynamicPartitioning(options *CommonPartitioningOptions) DynamicPartitioning

type DynamicPartitioningConfiguration 

type DynamicPartitioningConfiguration struct {
	PartitioningConfiguration *awskinesisfirehose.CfnDeliveryStream_DynamicPartitioningConfigurationProperty `field:"required" json:"partitioningConfiguration" yaml:"partitioningConfiguration"`
	Processors                *[]DeliveryStreamProcessor                                                     `field:"optional" json:"processors" yaml:"processors"`
}

type ExtendedS3Destination 

type ExtendedS3Destination interface {
	S3Destination
	BackupConfiguration() BackupConfiguration
	Bucket() awss3.IBucket
	Buffering() BufferingConfiguration
	CloudwatchLoggingConfiguration() CloudWatchLoggingConfiguration
	CompressionFormat() S3CompressionFormat
	DataFormatConversion() DataFormatConversion
	DynamicPartitioning() DynamicPartitioning
	EncryptionEnabled() *bool
	EncryptionKey() awskms.IKey
	ErrorOutputPrefix() *string
	KeyPrefix() *string
	ProcessingEnabled() *bool
	ProcessorConfiguration() ProcessorConfiguration
	Processors() *[]DeliveryStreamProcessor
	Role() awsiam.IRole
	AddProcessor(processor DeliveryStreamProcessor) ExtendedS3Destination
	Bind(scope constructs.IConstruct) *DeliveryStreamDestinationConfiguration
	BuildConfiguration(scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_S3DestinationConfigurationProperty
	RenderBackupConfiguration(scope constructs.IConstruct, enabled *bool) *BackupConfigurationResult
	RenderProcessorConfiguration(scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_ProcessingConfigurationProperty
}

func NewExtendedS3Destination 

func NewExtendedS3Destination(bucket awss3.IBucket, options *ExtendedS3DestinationOptions) ExtendedS3Destination

type ExtendedS3DestinationOptions 

type ExtendedS3DestinationOptions struct {
	Buffering                      BufferingConfiguration         `field:"optional" json:"buffering" yaml:"buffering"`
	CloudwatchLoggingConfiguration CloudWatchLoggingConfiguration `field:"optional" json:"cloudwatchLoggingConfiguration" yaml:"cloudwatchLoggingConfiguration"`
	CompressionFormat              S3CompressionFormat            `field:"optional" json:"compressionFormat" yaml:"compressionFormat"`
	EncryptionEnabled              *bool                          `field:"optional" json:"encryptionEnabled" yaml:"encryptionEnabled"`
	EncryptionKey                  awskms.IKey                    `field:"optional" json:"encryptionKey" yaml:"encryptionKey"`
	ErrorOutputPrefix              *string                        `field:"optional" json:"errorOutputPrefix" yaml:"errorOutputPrefix"`
	KeyPrefix                      *string                        `field:"optional" json:"keyPrefix" yaml:"keyPrefix"`
	Role                           awsiam.IRole                   `field:"optional" json:"role" yaml:"role"`
	BackupConfiguration            BackupConfiguration            `field:"optional" json:"backupConfiguration" yaml:"backupConfiguration"`
	DataFormatConversion           DataFormatConversion           `field:"optional" json:"dataFormatConversion" yaml:"dataFormatConversion"`
	DynamicPartitioning            DynamicPartitioning            `field:"optional" json:"dynamicPartitioning" yaml:"dynamicPartitioning"`
	ProcessorConfiguration         ProcessorConfiguration         `field:"optional" json:"processorConfiguration" yaml:"processorConfiguration"`
}

type HiveJsonInputSerDe 

type HiveJsonInputSerDe interface {
	InputFormat
	AddTimestampFormat(format *string) HiveJsonInputSerDe
	Bind(_scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_InputFormatConfigurationProperty
}

func HiveJsonInputSerDe_HiveJson 

func HiveJsonInputSerDe_HiveJson(options *HiveJsonInputSerDeOptions) HiveJsonInputSerDe

func InputFormat_HiveJson 

func InputFormat_HiveJson(options *HiveJsonInputSerDeOptions) HiveJsonInputSerDe

func NewHiveJsonInputSerDe 

func NewHiveJsonInputSerDe(options *HiveJsonInputSerDeOptions) HiveJsonInputSerDe

func OpenxJsonInputSerDe_HiveJson 

func OpenxJsonInputSerDe_HiveJson(options *HiveJsonInputSerDeOptions) HiveJsonInputSerDe

type HiveJsonInputSerDeOptions 

type HiveJsonInputSerDeOptions struct {
	TimestampFormats *[]*string `field:"optional" json:"timestampFormats" yaml:"timestampFormats"`
}

type HttpEndpointDestination 

type HttpEndpointDestination interface {
	DeliveryStreamDestination
	AccessKey() awscdk.SecretValue
	BackupConfiguration() BackupConfiguration
	Buffering() BufferingConfiguration
	CloudwatchLoggingConfiguration() CloudWatchLoggingConfiguration
	CommonAttributes() *map[string]*string
	ContentEncoding() ContentEncoding
	EndpointName() *string
	EndpointUrl() *string
	ProcessingEnabled() *bool
	ProcessorConfiguration() ProcessorConfiguration
	RetryDuration() awscdk.Duration
	Role() awsiam.IRole
	AddCommonAttribute(name *string, value *string) HttpEndpointDestination
	AddProcessor(processor DeliveryStreamProcessor) HttpEndpointDestination
	Bind(scope constructs.IConstruct) *DeliveryStreamDestinationConfiguration
	BuildBackupConfiguration(scope constructs.IConstruct) BackupConfiguration
	GetOrCreateRole(scope constructs.IConstruct) awsiam.IRole
	RenderProcessorConfiguration(scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_ProcessingConfigurationProperty
}

func NewHttpEndpointDestination 

func NewHttpEndpointDestination(url *string, options *HttpEndpointDestinationOptions) HttpEndpointDestination

type HttpEndpointDestinationOptions 

type HttpEndpointDestinationOptions struct {
	AccessKey                      awscdk.SecretValue             `field:"optional" json:"accessKey" yaml:"accessKey"`
	BackupConfiguration            BackupConfiguration            `field:"optional" json:"backupConfiguration" yaml:"backupConfiguration"`
	Buffering                      BufferingConfiguration         `field:"optional" json:"buffering" yaml:"buffering"`
	CloudwatchLoggingConfiguration CloudWatchLoggingConfiguration `field:"optional" json:"cloudwatchLoggingConfiguration" yaml:"cloudwatchLoggingConfiguration"`
	CommonAttributes               *map[string]*string            `field:"optional" json:"commonAttributes" yaml:"commonAttributes"`
	ContentEncoding                ContentEncoding                `field:"optional" json:"contentEncoding" yaml:"contentEncoding"`
	EndpointName                   *string                        `field:"optional" json:"endpointName" yaml:"endpointName"`
	ProcessorConfiguration         ProcessorConfiguration         `field:"optional" json:"processorConfiguration" yaml:"processorConfiguration"`
	RetryDuration                  awscdk.Duration                `field:"optional" json:"retryDuration" yaml:"retryDuration"`
}

type IDeliveryStream 

type IDeliveryStream interface {
	awsec2.IConnectable
	awsiam.IGrantable
	awscdk.IResource
	Grant(grantee awsiam.IGrantable, actions ...*string) awsiam.Grant
	GrantPutRecords(grantee awsiam.IGrantable) awsiam.Grant
	Metric(metricName *string, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	MetricBackupToS3Bytes(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	MetricBackupToS3DataFreshness(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	MetricBackupToS3Records(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	MetricIncomingBytes(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	MetricIncomingRecords(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	DeliveryStreamArn() *string
	DeliveryStreamName() *string
}

func DeliveryStream_FromDeliveryStreamArn 

func DeliveryStream_FromDeliveryStreamArn(scope constructs.Construct, id *string, deliveryStreamArn *string) IDeliveryStream

func DeliveryStream_FromDeliveryStreamAttributes 

func DeliveryStream_FromDeliveryStreamAttributes(scope constructs.Construct, id *string, attrs *DeliveryStreamAttributes) IDeliveryStream

func DeliveryStream_FromDeliveryStreamName 

func DeliveryStream_FromDeliveryStreamName(scope constructs.Construct, id *string, deliveryStreamName *string) IDeliveryStream

type IDeliveryStreamBackupDestination 

type IDeliveryStreamBackupDestination interface {
	RenderBackupConfiguration(scope constructs.IConstruct, enabled *bool) *BackupConfigurationResult
}

type InputFormat 

type InputFormat interface {
	Bind(scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_InputFormatConfigurationProperty
}

type JsonParsingEngine 

type JsonParsingEngine string
const (
	JsonParsingEngine_JQ_1_6 JsonParsingEngine = "JQ_1_6"
)

type JsonPartitioningOptions 

type JsonPartitioningOptions struct {
	Enabled       *bool               `field:"optional" json:"enabled" yaml:"enabled"`
	RetryInterval awscdk.Duration     `field:"optional" json:"retryInterval" yaml:"retryInterval"`
	Partitions    *map[string]*string `field:"required" json:"partitions" yaml:"partitions"`
}

type JsonPartitioningSource 

type JsonPartitioningSource interface {
	DynamicPartitioning
	Enabled() *bool
	RetryInterval() awscdk.Duration
	AddPartition(name *string, query *string)
	Bind(scope constructs.IConstruct) *DynamicPartitioningConfiguration
}

func DynamicPartitioning_FromJson 

func DynamicPartitioning_FromJson(options *JsonPartitioningOptions) JsonPartitioningSource

func JsonPartitioningSource_FromJson 

func JsonPartitioningSource_FromJson(options *JsonPartitioningOptions) JsonPartitioningSource

func LambdaPartitioningSource_FromJson 

func LambdaPartitioningSource_FromJson(options *JsonPartitioningOptions) JsonPartitioningSource

func NewJsonPartitioningSource 

func NewJsonPartitioningSource(options *JsonPartitioningOptions) JsonPartitioningSource

type JsonQuery 

type JsonQuery interface {
	MetaDataExtractionQuery
	Query() *string
	SetQuery(val *string)
	AddField(name *string, query *string) JsonQuery
	Render() *string
}

func JsonQuery_Jq 

func JsonQuery_Jq(fields *map[string]*string) JsonQuery

func MetaDataExtractionQuery_Jq 

func MetaDataExtractionQuery_Jq(fields *map[string]*string) JsonQuery

func NewJsonQuery 

func NewJsonQuery(fields *map[string]*string) JsonQuery

type LambdaPartitioningOptions 

type LambdaPartitioningOptions struct {
	Enabled        *bool               `field:"optional" json:"enabled" yaml:"enabled"`
	RetryInterval  awscdk.Duration     `field:"optional" json:"retryInterval" yaml:"retryInterval"`
	LambdaFunction awslambda.IFunction `field:"required" json:"lambdaFunction" yaml:"lambdaFunction"`
}

type LambdaPartitioningSource 

type LambdaPartitioningSource interface {
	DynamicPartitioning
	Enabled() *bool
	LambdaFunction() awslambda.IFunction
	RetryInterval() awscdk.Duration
	Bind(scope constructs.IConstruct) *DynamicPartitioningConfiguration
}

func DynamicPartitioning_FromLambda 

func DynamicPartitioning_FromLambda(options *LambdaPartitioningOptions) LambdaPartitioningSource

func JsonPartitioningSource_FromLambda 

func JsonPartitioningSource_FromLambda(options *LambdaPartitioningOptions) LambdaPartitioningSource

func LambdaPartitioningSource_FromLambda 

func LambdaPartitioningSource_FromLambda(options *LambdaPartitioningOptions) LambdaPartitioningSource

func NewLambdaPartitioningSource 

func NewLambdaPartitioningSource(options *LambdaPartitioningOptions) LambdaPartitioningSource

type LambdaProcessor 

type LambdaProcessor interface {
	DeliveryStreamProcessor
	LambdaFunction() awslambda.IFunction
	ProcessorType() ProcessorType
	AddProcessorParameter(name *string, value *string)
	Bind(_scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_ProcessorProperty
}

func NewLambdaProcessor 

func NewLambdaProcessor(options *LambdaProcessorOptions) LambdaProcessor

type LambdaProcessorOptions 

type LambdaProcessorOptions struct {
	LambdaFunction awslambda.IFunction `field:"required" json:"lambdaFunction" yaml:"lambdaFunction"`
}

type MetaDataExtractionQuery 

type MetaDataExtractionQuery interface {
	Query() *string
	SetQuery(val *string)
	Render() *string
}

func JsonQuery_Of 

func JsonQuery_Of(query *string) MetaDataExtractionQuery

func MetaDataExtractionQuery_Of 

func MetaDataExtractionQuery_Of(query *string) MetaDataExtractionQuery

func NewMetaDataExtractionQuery 

func NewMetaDataExtractionQuery(query *string) MetaDataExtractionQuery

type MetadataExtractionProcessor 

type MetadataExtractionProcessor interface {
	DeliveryStreamProcessor
	Engine() JsonParsingEngine
	ProcessorType() ProcessorType
	Query() MetaDataExtractionQuery
	AddProcessorParameter(name *string, value *string)
	Bind(_scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_ProcessorProperty
}

func NewMetadataExtractionProcessor 

func NewMetadataExtractionProcessor(options *MetadataExtractionProcessorOptions) MetadataExtractionProcessor

type MetadataExtractionProcessorOptions 

type MetadataExtractionProcessorOptions struct {
	Query  MetaDataExtractionQuery `field:"required" json:"query" yaml:"query"`
	Engine JsonParsingEngine       `field:"optional" json:"engine" yaml:"engine"`
}

type OpenxJsonInputSerDe 

type OpenxJsonInputSerDe interface {
	InputFormat
	CaseInsensitive() *bool
	ConvertDotsToUnderscores() *bool
	AddColumnKeyMapping(columnName *string, jsonKey *string) OpenxJsonInputSerDe
	Bind(_scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_InputFormatConfigurationProperty
}

func HiveJsonInputSerDe_OpenxJson 

func HiveJsonInputSerDe_OpenxJson(options *OpenxJsonInputSerDeOptions) OpenxJsonInputSerDe

func InputFormat_OpenxJson 

func InputFormat_OpenxJson(options *OpenxJsonInputSerDeOptions) OpenxJsonInputSerDe

func NewOpenxJsonInputSerDe 

func NewOpenxJsonInputSerDe(options *OpenxJsonInputSerDeOptions) OpenxJsonInputSerDe

func OpenxJsonInputSerDe_OpenxJson 

func OpenxJsonInputSerDe_OpenxJson(options *OpenxJsonInputSerDeOptions) OpenxJsonInputSerDe

type OpenxJsonInputSerDeOptions 

type OpenxJsonInputSerDeOptions struct {
	CaseInsensitive          *bool               `field:"optional" json:"caseInsensitive" yaml:"caseInsensitive"`
	ColumnKeyMappings        *map[string]*string `field:"optional" json:"columnKeyMappings" yaml:"columnKeyMappings"`
	ConvertDotsToUnderscores *bool               `field:"optional" json:"convertDotsToUnderscores" yaml:"convertDotsToUnderscores"`
}

type OrcCompressionFormat 

type OrcCompressionFormat string
const (
	OrcCompressionFormat_NONE   OrcCompressionFormat = "NONE"
	OrcCompressionFormat_SNAPPY OrcCompressionFormat = "SNAPPY"
	OrcCompressionFormat_ZLIB   OrcCompressionFormat = "ZLIB"
)

type OrcFormatVersion 

type OrcFormatVersion string
const (
	OrcFormatVersion_V0_11 OrcFormatVersion = "V0_11"
	OrcFormatVersion_V0_12 OrcFormatVersion = "V0_12"
)

type OrcOutputSerDe 

type OrcOutputSerDe interface {
	OutputFormat
	BlockSizeBytes() *float64
	BloomFilterColumns() *[]*string
	BloomFilterFalsePositiveProbability() *float64
	Compression() OrcCompressionFormat
	DictionaryKeyThreshold() *float64
	EnablePadding() *bool
	FormatVersion() OrcFormatVersion
	PaddingTolerance() *float64
	RowIndexStride() *float64
	StripeSizeBytes() *float64
	AddBloomFilterColumn(column *string) OrcOutputSerDe
	Bind(_scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_OutputFormatConfigurationProperty
}

func NewOrcOutputSerDe 

func NewOrcOutputSerDe(options *OrcOutputSerDeOptions) OrcOutputSerDe

func OrcOutputSerDe_Orc 

func OrcOutputSerDe_Orc(options *OrcOutputSerDeOptions) OrcOutputSerDe

func OutputFormat_Orc 

func OutputFormat_Orc(options *OrcOutputSerDeOptions) OrcOutputSerDe

func ParquetOutputSerDe_Orc 

func ParquetOutputSerDe_Orc(options *OrcOutputSerDeOptions) OrcOutputSerDe

type OrcOutputSerDeOptions 

type OrcOutputSerDeOptions struct {
	BlockSizeBytes                      *float64             `field:"optional" json:"blockSizeBytes" yaml:"blockSizeBytes"`
	BloomFilterColumns                  *[]*string           `field:"optional" json:"bloomFilterColumns" yaml:"bloomFilterColumns"`
	BloomFilterFalsePositiveProbability *float64             `field:"optional" json:"bloomFilterFalsePositiveProbability" yaml:"bloomFilterFalsePositiveProbability"`
	Compression                         OrcCompressionFormat `field:"optional" json:"compression" yaml:"compression"`
	DictionaryKeyThreshold              *float64             `field:"optional" json:"dictionaryKeyThreshold" yaml:"dictionaryKeyThreshold"`
	EnablePadding                       *bool                `field:"optional" json:"enablePadding" yaml:"enablePadding"`
	FormatVersion                       OrcFormatVersion     `field:"optional" json:"formatVersion" yaml:"formatVersion"`
	PaddingTolerance                    *float64             `field:"optional" json:"paddingTolerance" yaml:"paddingTolerance"`
	RowIndexStride                      *float64             `field:"optional" json:"rowIndexStride" yaml:"rowIndexStride"`
	StripeSizeBytes                     *float64             `field:"optional" json:"stripeSizeBytes" yaml:"stripeSizeBytes"`
}

type OutputFormat 

type OutputFormat interface {
	Bind(scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_OutputFormatConfigurationProperty
}

type ParquetCompressionFormat 

type ParquetCompressionFormat string
const (
	ParquetCompressionFormat_GZIP         ParquetCompressionFormat = "GZIP"
	ParquetCompressionFormat_SNAPPY       ParquetCompressionFormat = "SNAPPY"
	ParquetCompressionFormat_UNCOMPRESSED ParquetCompressionFormat = "UNCOMPRESSED"
)

type ParquetOutputSerDe 

type ParquetOutputSerDe interface {
	OutputFormat
	BlockSizeBytes() *float64
	Compression() ParquetCompressionFormat
	EnableDictionaryCompression() *bool
	MaxPaddingBytes() *float64
	PageSizeBytes() *float64
	WriterVersion() ParquetWriterVersion
	Bind(_scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_OutputFormatConfigurationProperty
}

func NewParquetOutputSerDe 

func NewParquetOutputSerDe(options *ParquetOutputSerDeOptions) ParquetOutputSerDe

func OrcOutputSerDe_Parquet 

func OrcOutputSerDe_Parquet(options *ParquetOutputSerDeOptions) ParquetOutputSerDe

func OutputFormat_Parquet 

func OutputFormat_Parquet(options *ParquetOutputSerDeOptions) ParquetOutputSerDe

func ParquetOutputSerDe_Parquet 

func ParquetOutputSerDe_Parquet(options *ParquetOutputSerDeOptions) ParquetOutputSerDe

type ParquetOutputSerDeOptions 

type ParquetOutputSerDeOptions struct {
	BlockSizeBytes              *float64                 `field:"optional" json:"blockSizeBytes" yaml:"blockSizeBytes"`
	Compression                 ParquetCompressionFormat `field:"optional" json:"compression" yaml:"compression"`
	EnableDictionaryCompression *bool                    `field:"optional" json:"enableDictionaryCompression" yaml:"enableDictionaryCompression"`
	MaxPaddingBytes             *float64                 `field:"optional" json:"maxPaddingBytes" yaml:"maxPaddingBytes"`
	PageSizeBytes               *float64                 `field:"optional" json:"pageSizeBytes" yaml:"pageSizeBytes"`
	WriterVersion               ParquetWriterVersion     `field:"optional" json:"writerVersion" yaml:"writerVersion"`
}

type ParquetWriterVersion 

type ParquetWriterVersion string
const (
	ParquetWriterVersion_V1 ParquetWriterVersion = "V1"
	ParquetWriterVersion_V2 ParquetWriterVersion = "V2"
)

type ProcessorConfiguration 

type ProcessorConfiguration interface {
	Enabled() *bool
	Processors() *[]DeliveryStreamProcessor
	Bind(_scope constructs.IConstruct) *ProcessorConfigurationResult
}

func NewProcessorConfiguration 

func NewProcessorConfiguration(options *ProcessorConfigurationOptions) ProcessorConfiguration

type ProcessorConfigurationOptions 

type ProcessorConfigurationOptions struct {
	Enabled    *bool                      `field:"optional" json:"enabled" yaml:"enabled"`
	Processors *[]DeliveryStreamProcessor `field:"optional" json:"processors" yaml:"processors"`
}

type ProcessorConfigurationResult 

type ProcessorConfigurationResult struct {
	Processors *[]DeliveryStreamProcessor `field:"required" json:"processors" yaml:"processors"`
	Enabled    *bool                      `field:"optional" json:"enabled" yaml:"enabled"`
}

type ProcessorType 

type ProcessorType interface {
	// The name of the processor to apply to the delivery stream.
	Name() *string
}

func ProcessorType_APPEND_DELIMITER_TO_RECORD 

func ProcessorType_APPEND_DELIMITER_TO_RECORD() ProcessorType

func ProcessorType_LAMBDA 

func ProcessorType_LAMBDA() ProcessorType

func ProcessorType_METADATA_EXTRACTION 

func ProcessorType_METADATA_EXTRACTION() ProcessorType

func ProcessorType_Of 

func ProcessorType_Of(name *string) ProcessorType

func ProcessorType_RECORD_DEAGGREGATION 

func ProcessorType_RECORD_DEAGGREGATION() ProcessorType

type RecordDeaggregationProcessor 

type RecordDeaggregationProcessor interface {
	DeliveryStreamProcessor
	Delimiter() *string
	ProcessorType() ProcessorType
	SubRecordType() SubRecordType
	AddProcessorParameter(name *string, value *string)
	Bind(_scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_ProcessorProperty
}

func NewRecordDeaggregationProcessor 

func NewRecordDeaggregationProcessor(options *RecordDeaggregationProcessorOptions) RecordDeaggregationProcessor

func RecordDeaggregationProcessor_Delimited 

func RecordDeaggregationProcessor_Delimited(options *DelimitedDeaggregationOptions) RecordDeaggregationProcessor

func RecordDeaggregationProcessor_Json 

func RecordDeaggregationProcessor_Json() RecordDeaggregationProcessor

type RecordDeaggregationProcessorOptions 

type RecordDeaggregationProcessorOptions struct {
	SubRecordType SubRecordType `field:"required" json:"subRecordType" yaml:"subRecordType"`
	Delimiter     *string       `field:"optional" json:"delimiter" yaml:"delimiter"`
}

type S3CompressionFormat 

type S3CompressionFormat string
const (
	S3CompressionFormat_GZIP          S3CompressionFormat = "GZIP"
	S3CompressionFormat_HADOOP_SNAPPY S3CompressionFormat = "HADOOP_SNAPPY"
	S3CompressionFormat_SNAPPY        S3CompressionFormat = "SNAPPY"
	S3CompressionFormat_UNCOMPRESSED  S3CompressionFormat = "UNCOMPRESSED"
	S3CompressionFormat_ZIP           S3CompressionFormat = "ZIP"
)

type S3Destination 

type S3Destination interface {
	DeliveryStreamDestination
	IDeliveryStreamBackupDestination
	Bucket() awss3.IBucket
	Buffering() BufferingConfiguration
	CloudwatchLoggingConfiguration() CloudWatchLoggingConfiguration
	CompressionFormat() S3CompressionFormat
	EncryptionEnabled() *bool
	EncryptionKey() awskms.IKey
	ErrorOutputPrefix() *string
	KeyPrefix() *string
	Role() awsiam.IRole
	Bind(scope constructs.IConstruct) *DeliveryStreamDestinationConfiguration
	BuildConfiguration(scope constructs.IConstruct) *awskinesisfirehose.CfnDeliveryStream_S3DestinationConfigurationProperty
	RenderBackupConfiguration(scope constructs.IConstruct, enabled *bool) *BackupConfigurationResult
}

func NewS3Destination 

func NewS3Destination(bucket awss3.IBucket, options *S3DestinationOptions) S3Destination

type S3DestinationOptions 

type S3DestinationOptions struct {
	Buffering                      BufferingConfiguration         `field:"optional" json:"buffering" yaml:"buffering"`
	CloudwatchLoggingConfiguration CloudWatchLoggingConfiguration `field:"optional" json:"cloudwatchLoggingConfiguration" yaml:"cloudwatchLoggingConfiguration"`
	CompressionFormat              S3CompressionFormat            `field:"optional" json:"compressionFormat" yaml:"compressionFormat"`
	EncryptionEnabled              *bool                          `field:"optional" json:"encryptionEnabled" yaml:"encryptionEnabled"`
	EncryptionKey                  awskms.IKey                    `field:"optional" json:"encryptionKey" yaml:"encryptionKey"`
	ErrorOutputPrefix              *string                        `field:"optional" json:"errorOutputPrefix" yaml:"errorOutputPrefix"`
	KeyPrefix                      *string                        `field:"optional" json:"keyPrefix" yaml:"keyPrefix"`
	Role                           awsiam.IRole                   `field:"optional" json:"role" yaml:"role"`
}

type SubRecordType 

type SubRecordType interface {
	Name() *string
}

func SubRecordType_DELIMITED 

func SubRecordType_DELIMITED() SubRecordType

func SubRecordType_JSON 

func SubRecordType_JSON() SubRecordType

func SubRecordType_Of 

func SubRecordType_Of(name *string) SubRecordType

type TableVersion 

type TableVersion interface {
	Version() *string
}

func TableVersion_Fixed 

func TableVersion_Fixed(version *float64) TableVersion

func TableVersion_LATEST 

func TableVersion_LATEST() TableVersion

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.