awseventstargets

package
v2.22.0 Latest Latest
Warning

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

 Go to latest Published: Apr 28, 2022 License: Apache-2.0 Imports: 20 Imported by: 12

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NewApiDestination_Override added in v2.13.0 

func NewApiDestination_Override(a ApiDestination, apiDestination awsevents.IApiDestination, props *ApiDestinationProps)

func NewApiGateway_Override 

func NewApiGateway_Override(a ApiGateway, restApi awsapigateway.RestApi, props *ApiGatewayProps)

func NewAwsApi_Override 

func NewAwsApi_Override(a AwsApi, props *AwsApiProps)

func NewBatchJob_Override 

func NewBatchJob_Override(b BatchJob, jobQueueArn *string, jobQueueScope constructs.IConstruct, jobDefinitionArn *string, jobDefinitionScope constructs.IConstruct, props *BatchJobProps)

func NewCloudWatchLogGroup_Override 

func NewCloudWatchLogGroup_Override(c CloudWatchLogGroup, logGroup awslogs.ILogGroup, props *LogGroupProps)

func NewCodeBuildProject_Override 

func NewCodeBuildProject_Override(c CodeBuildProject, project awscodebuild.IProject, props *CodeBuildProjectProps)

func NewCodePipeline_Override 

func NewCodePipeline_Override(c CodePipeline, pipeline awscodepipeline.IPipeline, options *CodePipelineTargetOptions)

func NewEcsTask_Override 

func NewEcsTask_Override(e EcsTask, props *EcsTaskProps)

func NewEventBus_Override 

func NewEventBus_Override(e EventBus, eventBus awsevents.IEventBus, props *EventBusProps)

func NewKinesisFirehoseStream_Override 

func NewKinesisFirehoseStream_Override(k KinesisFirehoseStream, stream awskinesisfirehose.CfnDeliveryStream, props *KinesisFirehoseStreamProps)

func NewKinesisStream_Override 

func NewKinesisStream_Override(k KinesisStream, stream awskinesis.IStream, props *KinesisStreamProps)

func NewLambdaFunction_Override 

func NewLambdaFunction_Override(l LambdaFunction, handler awslambda.IFunction, props *LambdaFunctionProps)

func NewSfnStateMachine_Override 

func NewSfnStateMachine_Override(s SfnStateMachine, machine awsstepfunctions.IStateMachine, props *SfnStateMachineProps)

func NewSnsTopic_Override 

func NewSnsTopic_Override(s SnsTopic, topic awssns.ITopic, props *SnsTopicProps)

func NewSqsQueue_Override 

func NewSqsQueue_Override(s SqsQueue, queue awssqs.IQueue, props *SqsQueueProps)

Types

type ApiDestination added in v2.13.0 

type ApiDestination interface {
	awsevents.IRuleTarget
	// Returns a RuleTarget that can be used to trigger API destinations from an EventBridge event.
	Bind(_rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Use an API Destination rule target.

Example: 

connection := events.NewConnection(this, jsii.String("Connection"), &connectionProps{
	authorization: events.authorization.apiKey(jsii.String("x-api-key"), secretValue.secretsManager(jsii.String("ApiSecretName"))),
	description: jsii.String("Connection with API Key x-api-key"),
})

destination := events.NewApiDestination(this, jsii.String("Destination"), &apiDestinationProps{
	connection: connection,
	endpoint: jsii.String("https://example.com"),
	description: jsii.String("Calling example.com with API key x-api-key"),
})

rule := events.NewRule(this, jsii.String("Rule"), &ruleProps{
	schedule: events.schedule.rate(cdk.duration.minutes(jsii.Number(1))),
	targets: []iRuleTarget{
		targets.NewApiDestination(destination),
	},
})

func NewApiDestination added in v2.13.0 

func NewApiDestination(apiDestination awsevents.IApiDestination, props *ApiDestinationProps) ApiDestination

type ApiDestinationProps added in v2.13.0 

type ApiDestinationProps struct {
	// The SQS queue to be used as deadLetterQueue. Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
	//
	// The events not successfully delivered are automatically retried for a specified period of time,
	// depending on the retry policy of the target.
	// If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
	DeadLetterQueue awssqs.IQueue `json:"deadLetterQueue" yaml:"deadLetterQueue"`
	// The maximum age of a request that Lambda sends to a function for processing.
	//
	// Minimum value of 60.
	// Maximum value of 86400.
	MaxEventAge awscdk.Duration `json:"maxEventAge" yaml:"maxEventAge"`
	// The maximum number of times to retry when the function returns an error.
	//
	// Minimum value of 0.
	// Maximum value of 185.
	RetryAttempts *float64 `json:"retryAttempts" yaml:"retryAttempts"`
	// The event to send.
	Event awsevents.RuleTargetInput `json:"event" yaml:"event"`
	// The role to assume before invoking the target.
	EventRole awsiam.IRole `json:"eventRole" yaml:"eventRole"`
	// Additional headers sent to the API Destination.
	//
	// These are merged with headers specified on the Connection, with
	// the headers on the Connection taking precedence.
	//
	// You can only specify secret values on the Connection.
	HeaderParameters *map[string]*string `json:"headerParameters" yaml:"headerParameters"`
	// Path parameters to insert in place of path wildcards (`*`).
	//
	// If the API destination has a wilcard in the path, these path parts
	// will be inserted in that place.
	PathParameterValues *[]*string `json:"pathParameterValues" yaml:"pathParameterValues"`
	// Additional query string parameters sent to the API Destination.
	//
	// These are merged with headers specified on the Connection, with
	// the headers on the Connection taking precedence.
	//
	// You can only specify secret values on the Connection.
	QueryStringParameters *map[string]*string `json:"queryStringParameters" yaml:"queryStringParameters"`
}

Customize the EventBridge Api Destinations Target.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"import awscdk "github.com/aws/aws-cdk-go/awscdk"import events "github.com/aws/aws-cdk-go/awscdk/aws_events"import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"import awscdk "github.com/aws/aws-cdk-go/awscdk"import iam "github.com/aws/aws-cdk-go/awscdk/aws_iam"import awscdk "github.com/aws/aws-cdk-go/awscdk"import sqs "github.com/aws/aws-cdk-go/awscdk/aws_sqs"

var queue queue
var role role
var ruleTargetInput ruleTargetInput
apiDestinationProps := &apiDestinationProps{
	deadLetterQueue: queue,
	event: ruleTargetInput,
	eventRole: role,
	headerParameters: map[string]*string{
		"headerParametersKey": jsii.String("headerParameters"),
	},
	maxEventAge: cdk.duration.minutes(jsii.Number(30)),
	pathParameterValues: []*string{
		jsii.String("pathParameterValues"),
	},
	queryStringParameters: map[string]*string{
		"queryStringParametersKey": jsii.String("queryStringParameters"),
	},
	retryAttempts: jsii.Number(123),
}

type ApiGateway 

type ApiGateway interface {
	awsevents.IRuleTarget
	RestApi() awsapigateway.RestApi
	// Returns a RuleTarget that can be used to trigger this API Gateway REST APIs as a result from an EventBridge event.
	// See: https://docs.aws.amazon.com/eventbridge/latest/userguide/resource-based-policies-eventbridge.html#sqs-permissions
	//
	Bind(rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Use an API Gateway REST APIs as a target for Amazon EventBridge rules.

Example: 

import api "github.com/aws/aws-cdk-go/awscdk"import lambda "github.com/aws/aws-cdk-go/awscdk"

rule := events.NewRule(this, jsii.String("Rule"), &ruleProps{
	schedule: events.schedule.rate(cdk.duration.minutes(jsii.Number(1))),
})

fn := lambda.NewFunction(this, jsii.String("MyFunc"), &functionProps{
	handler: jsii.String("index.handler"),
	runtime: lambda.runtime_NODEJS_12_X(),
	code: lambda.code.fromInline(jsii.String("exports.handler = e => {}")),
})

restApi := api.NewLambdaRestApi(this, jsii.String("MyRestAPI"), &lambdaRestApiProps{
	handler: fn,
})

dlq := sqs.NewQueue(this, jsii.String("DeadLetterQueue"))

rule.addTarget(
targets.NewApiGateway(restApi, &apiGatewayProps{
	path: jsii.String("/*/test"),
	method: jsii.String("GET"),
	stage: jsii.String("prod"),
	pathParameterValues: []*string{
		jsii.String("path-value"),
	},
	headerParameters: map[string]*string{
		"Header1": jsii.String("header1"),
	},
	queryStringParameters: map[string]*string{
		"QueryParam1": jsii.String("query-param-1"),
	},
	deadLetterQueue: dlq,
}))

func NewApiGateway 

func NewApiGateway(restApi awsapigateway.RestApi, props *ApiGatewayProps) ApiGateway

type ApiGatewayProps 

type ApiGatewayProps struct {
	// The SQS queue to be used as deadLetterQueue. Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
	//
	// The events not successfully delivered are automatically retried for a specified period of time,
	// depending on the retry policy of the target.
	// If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
	DeadLetterQueue awssqs.IQueue `json:"deadLetterQueue" yaml:"deadLetterQueue"`
	// The maximum age of a request that Lambda sends to a function for processing.
	//
	// Minimum value of 60.
	// Maximum value of 86400.
	MaxEventAge awscdk.Duration `json:"maxEventAge" yaml:"maxEventAge"`
	// The maximum number of times to retry when the function returns an error.
	//
	// Minimum value of 0.
	// Maximum value of 185.
	RetryAttempts *float64 `json:"retryAttempts" yaml:"retryAttempts"`
	// The role to assume before invoking the target (i.e., the pipeline) when the given rule is triggered.
	EventRole awsiam.IRole `json:"eventRole" yaml:"eventRole"`
	// The headers to be set when requesting API.
	HeaderParameters *map[string]*string `json:"headerParameters" yaml:"headerParameters"`
	// The method for api resource invoked by the rule.
	Method *string `json:"method" yaml:"method"`
	// The api resource invoked by the rule.
	//
	// We can use wildcards('*') to specify the path. In that case,
	// an equal number of real values must be specified for pathParameterValues.
	Path *string `json:"path" yaml:"path"`
	// The path parameter values to be used to populate to wildcards("*") of requesting api path.
	PathParameterValues *[]*string `json:"pathParameterValues" yaml:"pathParameterValues"`
	// This will be the post request body send to the API.
	PostBody awsevents.RuleTargetInput `json:"postBody" yaml:"postBody"`
	// The query parameters to be set when requesting API.
	QueryStringParameters *map[string]*string `json:"queryStringParameters" yaml:"queryStringParameters"`
	// The deploy stage of api gateway invoked by the rule.
	Stage *string `json:"stage" yaml:"stage"`
}

Customize the API Gateway Event Target.

Example: 

import api "github.com/aws/aws-cdk-go/awscdk"import lambda "github.com/aws/aws-cdk-go/awscdk"

rule := events.NewRule(this, jsii.String("Rule"), &ruleProps{
	schedule: events.schedule.rate(cdk.duration.minutes(jsii.Number(1))),
})

fn := lambda.NewFunction(this, jsii.String("MyFunc"), &functionProps{
	handler: jsii.String("index.handler"),
	runtime: lambda.runtime_NODEJS_12_X(),
	code: lambda.code.fromInline(jsii.String("exports.handler = e => {}")),
})

restApi := api.NewLambdaRestApi(this, jsii.String("MyRestAPI"), &lambdaRestApiProps{
	handler: fn,
})

dlq := sqs.NewQueue(this, jsii.String("DeadLetterQueue"))

rule.addTarget(
targets.NewApiGateway(restApi, &apiGatewayProps{
	path: jsii.String("/*/test"),
	method: jsii.String("GET"),
	stage: jsii.String("prod"),
	pathParameterValues: []*string{
		jsii.String("path-value"),
	},
	headerParameters: map[string]*string{
		"Header1": jsii.String("header1"),
	},
	queryStringParameters: map[string]*string{
		"QueryParam1": jsii.String("query-param-1"),
	},
	deadLetterQueue: dlq,
}))

type AwsApi 

type AwsApi interface {
	awsevents.IRuleTarget
	// Returns a RuleTarget that can be used to trigger this AwsApi as a result from an EventBridge event.
	Bind(rule awsevents.IRule, id *string) *awsevents.RuleTargetConfig
}

Use an AWS Lambda function that makes API calls as an event rule target.

Example: 

import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"import awscdk "github.com/aws/aws-cdk-go/awscdk"import iam "github.com/aws/aws-cdk-go/awscdk/aws_iam"

var parameters interface{}
var policyStatement policyStatement
awsApi := events_targets.NewAwsApi(&awsApiProps{
	action: jsii.String("action"),
	service: jsii.String("service"),

	// the properties below are optional
	apiVersion: jsii.String("apiVersion"),
	catchErrorPattern: jsii.String("catchErrorPattern"),
	parameters: parameters,
	policyStatement: policyStatement,
})

func NewAwsApi 

func NewAwsApi(props *AwsApiProps) AwsApi

type AwsApiInput 

type AwsApiInput struct {
	// The service action to call.
	// See: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/index.html
	//
	Action *string `json:"action" yaml:"action"`
	// The service to call.
	// See: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/index.html
	//
	Service *string `json:"service" yaml:"service"`
	// API version to use for the service.
	// See: https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/locking-api-versions.html
	//
	ApiVersion *string `json:"apiVersion" yaml:"apiVersion"`
	// The regex pattern to use to catch API errors.
	//
	// The `code` property of the
	// `Error` object will be tested against this pattern. If there is a match an
	// error will not be thrown.
	CatchErrorPattern *string `json:"catchErrorPattern" yaml:"catchErrorPattern"`
	// The parameters for the service action.
	// See: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/index.html
	//
	Parameters interface{} `json:"parameters" yaml:"parameters"`
}

Rule target input for an AwsApi target.

Example: 

import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"

var parameters interface{}
awsApiInput := &awsApiInput{
	action: jsii.String("action"),
	service: jsii.String("service"),

	// the properties below are optional
	apiVersion: jsii.String("apiVersion"),
	catchErrorPattern: jsii.String("catchErrorPattern"),
	parameters: parameters,
}

type AwsApiProps 

type AwsApiProps struct {
	// The service action to call.
	// See: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/index.html
	//
	Action *string `json:"action" yaml:"action"`
	// The service to call.
	// See: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/index.html
	//
	Service *string `json:"service" yaml:"service"`
	// API version to use for the service.
	// See: https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/locking-api-versions.html
	//
	ApiVersion *string `json:"apiVersion" yaml:"apiVersion"`
	// The regex pattern to use to catch API errors.
	//
	// The `code` property of the
	// `Error` object will be tested against this pattern. If there is a match an
	// error will not be thrown.
	CatchErrorPattern *string `json:"catchErrorPattern" yaml:"catchErrorPattern"`
	// The parameters for the service action.
	// See: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/index.html
	//
	Parameters interface{} `json:"parameters" yaml:"parameters"`
	// The IAM policy statement to allow the API call.
	//
	// Use only if
	// resource restriction is needed.
	PolicyStatement awsiam.PolicyStatement `json:"policyStatement" yaml:"policyStatement"`
}

Properties for an AwsApi target.

Example: 

import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"import awscdk "github.com/aws/aws-cdk-go/awscdk"import iam "github.com/aws/aws-cdk-go/awscdk/aws_iam"

var parameters interface{}
var policyStatement policyStatement
awsApiProps := &awsApiProps{
	action: jsii.String("action"),
	service: jsii.String("service"),

	// the properties below are optional
	apiVersion: jsii.String("apiVersion"),
	catchErrorPattern: jsii.String("catchErrorPattern"),
	parameters: parameters,
	policyStatement: policyStatement,
}

type BatchJob 

type BatchJob interface {
	awsevents.IRuleTarget
	// Returns a RuleTarget that can be used to trigger queue this batch job as a result from an EventBridge event.
	Bind(rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Use an AWS Batch Job / Queue as an event rule target.

Most likely the code will look something like this: `new BatchJob(jobQueue.jobQueueArn, jobQueue, jobDefinition.jobDefinitionArn, jobDefinition)`

In the future this API will be improved to be fully typed.

Example: 

// Example automatically generated from non-compiling source. May contain errors.
import batch "github.com/aws/aws-cdk-go/awscdk"import awscdk "github.com/aws/aws-cdk-go/awscdk"type ContainerImage awscdk.ContainerImage

jobQueue := batch.NewJobQueue(this, jsii.String("MyQueue"), map[string][]map[string]interface{}{
	"computeEnvironments": []map[string]interface{}{
		map[string]interface{}{
			"computeEnvironment": batch.NewComputeEnvironment(this, jsii.String("ComputeEnvironment"), map[string]*bool{
				"managed": jsii.Boolean(false),
			}),
			"order": jsii.Number(1),
		},
	},
})

jobDefinition := batch.NewJobDefinition(this, jsii.String("MyJob"), map[string]map[string]repositoryImage{
	"container": map[string]repositoryImage{
		"image": ContainerImage.fromRegistry(jsii.String("test-repo")),
	},
})

queue := sqs.NewQueue(this, jsii.String("Queue"))

rule := events.NewRule(this, jsii.String("Rule"), &ruleProps{
	schedule: events.schedule.rate(cdk.duration.hours(jsii.Number(1))),
})

rule.addTarget(targets.NewBatchJob(jobQueue.jobQueueArn, jobQueue, jobDefinition.jobDefinitionArn, jobDefinition, &batchJobProps{
	deadLetterQueue: queue,
	event: events.ruleTargetInput.fromObject(map[string]*string{
		"SomeParam": jsii.String("SomeValue"),
	}),
	retryAttempts: jsii.Number(2),
	maxEventAge: cdk.*duration.hours(jsii.Number(2)),
}))

func NewBatchJob 

func NewBatchJob(jobQueueArn *string, jobQueueScope constructs.IConstruct, jobDefinitionArn *string, jobDefinitionScope constructs.IConstruct, props *BatchJobProps) BatchJob

type BatchJobProps 

type BatchJobProps struct {
	// The SQS queue to be used as deadLetterQueue. Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
	//
	// The events not successfully delivered are automatically retried for a specified period of time,
	// depending on the retry policy of the target.
	// If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
	DeadLetterQueue awssqs.IQueue `json:"deadLetterQueue" yaml:"deadLetterQueue"`
	// The maximum age of a request that Lambda sends to a function for processing.
	//
	// Minimum value of 60.
	// Maximum value of 86400.
	MaxEventAge awscdk.Duration `json:"maxEventAge" yaml:"maxEventAge"`
	// The maximum number of times to retry when the function returns an error.
	//
	// Minimum value of 0.
	// Maximum value of 185.
	RetryAttempts *float64 `json:"retryAttempts" yaml:"retryAttempts"`
	// The number of times to attempt to retry, if the job fails.
	//
	// Valid values are 1–10.
	Attempts *float64 `json:"attempts" yaml:"attempts"`
	// The event to send to the Lambda.
	//
	// This will be the payload sent to the Lambda Function.
	Event awsevents.RuleTargetInput `json:"event" yaml:"event"`
	// The name of the submitted job.
	JobName *string `json:"jobName" yaml:"jobName"`
	// The size of the array, if this is an array batch job.
	//
	// Valid values are integers between 2 and 10,000.
	Size *float64 `json:"size" yaml:"size"`
}

Customize the Batch Job Event Target.

Example: 

// Example automatically generated from non-compiling source. May contain errors.
import batch "github.com/aws/aws-cdk-go/awscdk"import awscdk "github.com/aws/aws-cdk-go/awscdk"type ContainerImage awscdk.ContainerImage

jobQueue := batch.NewJobQueue(this, jsii.String("MyQueue"), map[string][]map[string]interface{}{
	"computeEnvironments": []map[string]interface{}{
		map[string]interface{}{
			"computeEnvironment": batch.NewComputeEnvironment(this, jsii.String("ComputeEnvironment"), map[string]*bool{
				"managed": jsii.Boolean(false),
			}),
			"order": jsii.Number(1),
		},
	},
})

jobDefinition := batch.NewJobDefinition(this, jsii.String("MyJob"), map[string]map[string]repositoryImage{
	"container": map[string]repositoryImage{
		"image": ContainerImage.fromRegistry(jsii.String("test-repo")),
	},
})

queue := sqs.NewQueue(this, jsii.String("Queue"))

rule := events.NewRule(this, jsii.String("Rule"), &ruleProps{
	schedule: events.schedule.rate(cdk.duration.hours(jsii.Number(1))),
})

rule.addTarget(targets.NewBatchJob(jobQueue.jobQueueArn, jobQueue, jobDefinition.jobDefinitionArn, jobDefinition, &batchJobProps{
	deadLetterQueue: queue,
	event: events.ruleTargetInput.fromObject(map[string]*string{
		"SomeParam": jsii.String("SomeValue"),
	}),
	retryAttempts: jsii.Number(2),
	maxEventAge: cdk.*duration.hours(jsii.Number(2)),
}))

type CloudWatchLogGroup 

type CloudWatchLogGroup interface {
	awsevents.IRuleTarget
	// Returns a RuleTarget that can be used to log an event into a CloudWatch LogGroup.
	Bind(_rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Use an AWS CloudWatch LogGroup as an event rule target.

Example: 

import logs "github.com/aws/aws-cdk-go/awscdk"

logGroup := logs.NewLogGroup(this, jsii.String("MyLogGroup"), &logGroupProps{
	logGroupName: jsii.String("MyLogGroup"),
})

rule := events.NewRule(this, jsii.String("rule"), &ruleProps{
	eventPattern: &eventPattern{
		source: []*string{
			jsii.String("aws.ec2"),
		},
	},
})

rule.addTarget(targets.NewCloudWatchLogGroup(logGroup))

func NewCloudWatchLogGroup 

func NewCloudWatchLogGroup(logGroup awslogs.ILogGroup, props *LogGroupProps) CloudWatchLogGroup

type CodeBuildProject 

type CodeBuildProject interface {
	awsevents.IRuleTarget
	// Allows using build projects as event rule targets.
	Bind(_rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Start a CodeBuild build when an Amazon EventBridge rule is triggered.

Example: 

import sns "github.com/aws/aws-cdk-go/awscdk"import targets "github.com/aws/aws-cdk-go/awscdk"

var repo repository
var project pipelineProject
var myTopic topic

// starts a CodeBuild project when a commit is pushed to the "master" branch of the repo
repo.onCommit(jsii.String("CommitToMaster"), &onCommitOptions{
	target: targets.NewCodeBuildProject(project),
	branches: []*string{
		jsii.String("master"),
	},
})

// publishes a message to an Amazon SNS topic when a comment is made on a pull request
rule := repo.onCommentOnPullRequest(jsii.String("CommentOnPullRequest"), &onEventOptions{
	target: targets.NewSnsTopic(myTopic),
})

func NewCodeBuildProject 

func NewCodeBuildProject(project awscodebuild.IProject, props *CodeBuildProjectProps) CodeBuildProject

type CodeBuildProjectProps 

type CodeBuildProjectProps struct {
	// The SQS queue to be used as deadLetterQueue. Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
	//
	// The events not successfully delivered are automatically retried for a specified period of time,
	// depending on the retry policy of the target.
	// If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
	DeadLetterQueue awssqs.IQueue `json:"deadLetterQueue" yaml:"deadLetterQueue"`
	// The maximum age of a request that Lambda sends to a function for processing.
	//
	// Minimum value of 60.
	// Maximum value of 86400.
	MaxEventAge awscdk.Duration `json:"maxEventAge" yaml:"maxEventAge"`
	// The maximum number of times to retry when the function returns an error.
	//
	// Minimum value of 0.
	// Maximum value of 185.
	RetryAttempts *float64 `json:"retryAttempts" yaml:"retryAttempts"`
	// The event to send to CodeBuild.
	//
	// This will be the payload for the StartBuild API.
	Event awsevents.RuleTargetInput `json:"event" yaml:"event"`
	// The role to assume before invoking the target (i.e., the codebuild) when the given rule is triggered.
	EventRole awsiam.IRole `json:"eventRole" yaml:"eventRole"`
}

Customize the CodeBuild Event Target.

Example: 

import codebuild "github.com/aws/aws-cdk-go/awscdk"import codecommit "github.com/aws/aws-cdk-go/awscdk"

repo := codecommit.NewRepository(this, jsii.String("MyRepo"), &repositoryProps{
	repositoryName: jsii.String("aws-cdk-codebuild-events"),
})

project := codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	source: codebuild.source.codeCommit(&codeCommitSourceProps{
		repository: repo,
	}),
})

deadLetterQueue := sqs.NewQueue(this, jsii.String("DeadLetterQueue"))

// trigger a build when a commit is pushed to the repo
onCommitRule := repo.onCommit(jsii.String("OnCommit"), &onCommitOptions{
	target: targets.NewCodeBuildProject(project, &codeBuildProjectProps{
		deadLetterQueue: deadLetterQueue,
	}),
	branches: []*string{
		jsii.String("master"),
	},
})

type CodePipeline 

type CodePipeline interface {
	awsevents.IRuleTarget
	// Returns the rule target specification.
	//
	// NOTE: Do not use the various `inputXxx` options. They can be set in a call to `addTarget`.
	Bind(_rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Allows the pipeline to be used as an EventBridge rule target.

Example: 

import targets "github.com/aws/aws-cdk-go/awscdk"import events "github.com/aws/aws-cdk-go/awscdk"

var pipeline pipeline

// kick off the pipeline every day
rule := events.NewRule(this, jsii.String("Daily"), &ruleProps{
	schedule: events.schedule.rate(duration.days(jsii.Number(1))),
})
rule.addTarget(targets.NewCodePipeline(pipeline))

func NewCodePipeline 

func NewCodePipeline(pipeline awscodepipeline.IPipeline, options *CodePipelineTargetOptions) CodePipeline

type CodePipelineTargetOptions 

type CodePipelineTargetOptions struct {
	// The SQS queue to be used as deadLetterQueue. Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
	//
	// The events not successfully delivered are automatically retried for a specified period of time,
	// depending on the retry policy of the target.
	// If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
	DeadLetterQueue awssqs.IQueue `json:"deadLetterQueue" yaml:"deadLetterQueue"`
	// The maximum age of a request that Lambda sends to a function for processing.
	//
	// Minimum value of 60.
	// Maximum value of 86400.
	MaxEventAge awscdk.Duration `json:"maxEventAge" yaml:"maxEventAge"`
	// The maximum number of times to retry when the function returns an error.
	//
	// Minimum value of 0.
	// Maximum value of 185.
	RetryAttempts *float64 `json:"retryAttempts" yaml:"retryAttempts"`
	// The role to assume before invoking the target (i.e., the pipeline) when the given rule is triggered.
	EventRole awsiam.IRole `json:"eventRole" yaml:"eventRole"`
}

Customization options when creating a {@link CodePipeline} event target.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"import awscdk "github.com/aws/aws-cdk-go/awscdk"import iam "github.com/aws/aws-cdk-go/awscdk/aws_iam"import awscdk "github.com/aws/aws-cdk-go/awscdk"import sqs "github.com/aws/aws-cdk-go/awscdk/aws_sqs"

var queue queue
var role role
codePipelineTargetOptions := &codePipelineTargetOptions{
	deadLetterQueue: queue,
	eventRole: role,
	maxEventAge: cdk.duration.minutes(jsii.Number(30)),
	retryAttempts: jsii.Number(123),
}

type ContainerOverride 

type ContainerOverride struct {
	// Name of the container inside the task definition.
	ContainerName *string `json:"containerName" yaml:"containerName"`
	// Command to run inside the container.
	Command *[]*string `json:"command" yaml:"command"`
	// The number of cpu units reserved for the container.
	Cpu *float64 `json:"cpu" yaml:"cpu"`
	// Variables to set in the container's environment.
	Environment *[]*TaskEnvironmentVariable `json:"environment" yaml:"environment"`
	// Hard memory limit on the container.
	MemoryLimit *float64 `json:"memoryLimit" yaml:"memoryLimit"`
	// Soft memory limit on the container.
	MemoryReservation *float64 `json:"memoryReservation" yaml:"memoryReservation"`
}

Example: 

import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"
containerOverride := &containerOverride{
	containerName: jsii.String("containerName"),

	// the properties below are optional
	command: []*string{
		jsii.String("command"),
	},
	cpu: jsii.Number(123),
	environment: []taskEnvironmentVariable{
		&taskEnvironmentVariable{
			name: jsii.String("name"),
			value: jsii.String("value"),
		},
	},
	memoryLimit: jsii.Number(123),
	memoryReservation: jsii.Number(123),
}

type EcsTask 

type EcsTask interface {
	awsevents.IRuleTarget
	// The security groups associated with the task.
	//
	// Only applicable with awsvpc network mode.
	SecurityGroups() *[]awsec2.ISecurityGroup
	// Allows using tasks as target of EventBridge events.
	Bind(_rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Start a task on an ECS cluster.

Example: 

import awscdk "github.com/aws/aws-cdk-go/awscdk"type Rule awscdk.Rule
type Schedule awscdk.Scheduleimport awscdk "github.com/aws/aws-cdk-go/awscdk"type EcsTask awscdk.EcsTaskimport awscdk "github.com/aws/aws-cdk-go/awscdk"type Cluster awscdk.Cluster
type TaskDefinition awscdk.TaskDefinitionimport awscdk "github.com/aws/aws-cdk-go/awscdk"type Role awscdk.Role

var cluster cluster
var taskDefinition taskDefinition
var role role

ecsTaskTarget := NewEcsTask(&ecsTaskProps{
	cluster: cluster,
	taskDefinition: taskDefinition,
	role: role,
})

NewRule(this, jsii.String("ScheduleRule"), &ruleProps{
	schedule: schedule.cron(&cronOptions{
		minute: jsii.String("0"),
		hour: jsii.String("4"),
	}),
	targets: []iRuleTarget{
		ecsTaskTarget,
	},
})

func NewEcsTask 

func NewEcsTask(props *EcsTaskProps) EcsTask

type EcsTaskProps 

type EcsTaskProps struct {
	// Cluster where service will be deployed.
	Cluster awsecs.ICluster `json:"cluster" yaml:"cluster"`
	// Task Definition of the task that should be started.
	TaskDefinition awsecs.ITaskDefinition `json:"taskDefinition" yaml:"taskDefinition"`
	// Container setting overrides.
	//
	// Key is the name of the container to override, value is the
	// values you want to override.
	ContainerOverrides *[]*ContainerOverride `json:"containerOverrides" yaml:"containerOverrides"`
	// The platform version on which to run your task.
	//
	// Unless you have specific compatibility requirements, you don't need to specify this.
	// See: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html
	//
	PlatformVersion awsecs.FargatePlatformVersion `json:"platformVersion" yaml:"platformVersion"`
	// Existing IAM role to run the ECS task.
	Role awsiam.IRole `json:"role" yaml:"role"`
	// Existing security groups to use for the task's ENIs.
	//
	// (Only applicable in case the TaskDefinition is configured for AwsVpc networking).
	SecurityGroups *[]awsec2.ISecurityGroup `json:"securityGroups" yaml:"securityGroups"`
	// In what subnets to place the task's ENIs.
	//
	// (Only applicable in case the TaskDefinition is configured for AwsVpc networking).
	SubnetSelection *awsec2.SubnetSelection `json:"subnetSelection" yaml:"subnetSelection"`
	// How many tasks should be started when this event is triggered.
	TaskCount *float64 `json:"taskCount" yaml:"taskCount"`
}

Properties to define an ECS Event Task.

Example: 

import awscdk "github.com/aws/aws-cdk-go/awscdk"type Rule awscdk.Rule
type Schedule awscdk.Scheduleimport awscdk "github.com/aws/aws-cdk-go/awscdk"type EcsTask awscdk.EcsTaskimport awscdk "github.com/aws/aws-cdk-go/awscdk"type Cluster awscdk.Cluster
type TaskDefinition awscdk.TaskDefinitionimport awscdk "github.com/aws/aws-cdk-go/awscdk"type Role awscdk.Role

var cluster cluster
var taskDefinition taskDefinition
var role role

ecsTaskTarget := NewEcsTask(&ecsTaskProps{
	cluster: cluster,
	taskDefinition: taskDefinition,
	role: role,
})

NewRule(this, jsii.String("ScheduleRule"), &ruleProps{
	schedule: schedule.cron(&cronOptions{
		minute: jsii.String("0"),
		hour: jsii.String("4"),
	}),
	targets: []iRuleTarget{
		ecsTaskTarget,
	},
})

type EventBus 

type EventBus interface {
	awsevents.IRuleTarget
	// Returns the rule target specification.
	//
	// NOTE: Do not use the various `inputXxx` options. They can be set in a call to `addTarget`.
	Bind(rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Notify an existing Event Bus of an event.

Example: 

rule := events.NewRule(this, jsii.String("Rule"), &ruleProps{
	schedule: events.schedule.expression(jsii.String("rate(1 minute)")),
})

rule.addTarget(targets.NewEventBus(events.eventBus.fromEventBusArn(this, jsii.String("External"), jsii.String("arn:aws:events:eu-west-1:999999999999:event-bus/test-bus"))))

func NewEventBus 

func NewEventBus(eventBus awsevents.IEventBus, props *EventBusProps) EventBus

type EventBusProps 

type EventBusProps struct {
	// The SQS queue to be used as deadLetterQueue. Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
	//
	// The events not successfully delivered are automatically retried for a specified period of time,
	// depending on the retry policy of the target.
	// If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
	DeadLetterQueue awssqs.IQueue `json:"deadLetterQueue" yaml:"deadLetterQueue"`
	// Role to be used to publish the event.
	Role awsiam.IRole `json:"role" yaml:"role"`
}

Configuration properties of an Event Bus event.

Cannot extend TargetBaseProps. Retry policy is not supported for Event bus targets.

Example: 

import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"import awscdk "github.com/aws/aws-cdk-go/awscdk"import iam "github.com/aws/aws-cdk-go/awscdk/aws_iam"import awscdk "github.com/aws/aws-cdk-go/awscdk"import sqs "github.com/aws/aws-cdk-go/awscdk/aws_sqs"

var queue queue
var role role
eventBusProps := &eventBusProps{
	deadLetterQueue: queue,
	role: role,
}

type KinesisFirehoseStream 

type KinesisFirehoseStream interface {
	awsevents.IRuleTarget
	// Returns a RuleTarget that can be used to trigger this Firehose Stream as a result from a Event Bridge event.
	Bind(_rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Customize the Firehose Stream Event Target.

Example: 

import awscdk "github.com/aws/aws-cdk-go/awscdk"import events "github.com/aws/aws-cdk-go/awscdk/aws_events"import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"import awscdk "github.com/aws/aws-cdk-go/awscdk"import kinesisfirehose "github.com/aws/aws-cdk-go/awscdk/aws_kinesisfirehose"

var cfnDeliveryStream cfnDeliveryStream
var ruleTargetInput ruleTargetInput
kinesisFirehoseStream := events_targets.NewKinesisFirehoseStream(cfnDeliveryStream, &kinesisFirehoseStreamProps{
	message: ruleTargetInput,
})

func NewKinesisFirehoseStream 

func NewKinesisFirehoseStream(stream awskinesisfirehose.CfnDeliveryStream, props *KinesisFirehoseStreamProps) KinesisFirehoseStream

type KinesisFirehoseStreamProps 

type KinesisFirehoseStreamProps struct {
	// The message to send to the stream.
	//
	// Must be a valid JSON text passed to the target stream.
	Message awsevents.RuleTargetInput `json:"message" yaml:"message"`
}

Customize the Firehose Stream Event Target.

Example: 

import awscdk "github.com/aws/aws-cdk-go/awscdk"import events "github.com/aws/aws-cdk-go/awscdk/aws_events"import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"

var ruleTargetInput ruleTargetInput
kinesisFirehoseStreamProps := &kinesisFirehoseStreamProps{
	message: ruleTargetInput,
}

type KinesisStream 

type KinesisStream interface {
	awsevents.IRuleTarget
	// Returns a RuleTarget that can be used to trigger this Kinesis Stream as a result from a CloudWatch event.
	Bind(_rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Use a Kinesis Stream as a target for AWS CloudWatch event rules.

Example: 

// put to a Kinesis stream every time code is committed
// to a CodeCommit repository
repository.onCommit(jsii.String("onCommit"), &onCommitOptions{
	target: targets.NewKinesisStream(stream),
})

func NewKinesisStream 

func NewKinesisStream(stream awskinesis.IStream, props *KinesisStreamProps) KinesisStream

type KinesisStreamProps 

type KinesisStreamProps struct {
	// The message to send to the stream.
	//
	// Must be a valid JSON text passed to the target stream.
	Message awsevents.RuleTargetInput `json:"message" yaml:"message"`
	// Partition Key Path for records sent to this stream.
	PartitionKeyPath *string `json:"partitionKeyPath" yaml:"partitionKeyPath"`
}

Customize the Kinesis Stream Event Target.

Example: 

import awscdk "github.com/aws/aws-cdk-go/awscdk"import events "github.com/aws/aws-cdk-go/awscdk/aws_events"import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"

var ruleTargetInput ruleTargetInput
kinesisStreamProps := &kinesisStreamProps{
	message: ruleTargetInput,
	partitionKeyPath: jsii.String("partitionKeyPath"),
}

type LambdaFunction 

type LambdaFunction interface {
	awsevents.IRuleTarget
	// Returns a RuleTarget that can be used to trigger this Lambda as a result from an EventBridge event.
	Bind(rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Use an AWS Lambda function as an event rule target.

Example: 

import lambda "github.com/aws/aws-cdk-go/awscdk"

fn := lambda.NewFunction(this, jsii.String("MyFunc"), &functionProps{
	runtime: lambda.runtime_NODEJS_12_X(),
	handler: jsii.String("index.handler"),
	code: lambda.code.fromInline(jsii.String("exports.handler = handler.toString()")),
})

rule := events.NewRule(this, jsii.String("rule"), &ruleProps{
	eventPattern: &eventPattern{
		source: []*string{
			jsii.String("aws.ec2"),
		},
	},
})

queue := sqs.NewQueue(this, jsii.String("Queue"))

rule.addTarget(targets.NewLambdaFunction(fn, &lambdaFunctionProps{
	deadLetterQueue: queue,
	 // Optional: add a dead letter queue
	maxEventAge: cdk.duration.hours(jsii.Number(2)),
	 // Optional: set the maxEventAge retry policy
	retryAttempts: jsii.Number(2),
}))

func NewLambdaFunction 

func NewLambdaFunction(handler awslambda.IFunction, props *LambdaFunctionProps) LambdaFunction

type LambdaFunctionProps 

type LambdaFunctionProps struct {
	// The SQS queue to be used as deadLetterQueue. Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
	//
	// The events not successfully delivered are automatically retried for a specified period of time,
	// depending on the retry policy of the target.
	// If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
	DeadLetterQueue awssqs.IQueue `json:"deadLetterQueue" yaml:"deadLetterQueue"`
	// The maximum age of a request that Lambda sends to a function for processing.
	//
	// Minimum value of 60.
	// Maximum value of 86400.
	MaxEventAge awscdk.Duration `json:"maxEventAge" yaml:"maxEventAge"`
	// The maximum number of times to retry when the function returns an error.
	//
	// Minimum value of 0.
	// Maximum value of 185.
	RetryAttempts *float64 `json:"retryAttempts" yaml:"retryAttempts"`
	// The event to send to the Lambda.
	//
	// This will be the payload sent to the Lambda Function.
	Event awsevents.RuleTargetInput `json:"event" yaml:"event"`
}

Customize the Lambda Event Target.

Example: 

import lambda "github.com/aws/aws-cdk-go/awscdk"

fn := lambda.NewFunction(this, jsii.String("MyFunc"), &functionProps{
	runtime: lambda.runtime_NODEJS_12_X(),
	handler: jsii.String("index.handler"),
	code: lambda.code.fromInline(jsii.String("exports.handler = handler.toString()")),
})

rule := events.NewRule(this, jsii.String("rule"), &ruleProps{
	eventPattern: &eventPattern{
		source: []*string{
			jsii.String("aws.ec2"),
		},
	},
})

queue := sqs.NewQueue(this, jsii.String("Queue"))

rule.addTarget(targets.NewLambdaFunction(fn, &lambdaFunctionProps{
	deadLetterQueue: queue,
	 // Optional: add a dead letter queue
	maxEventAge: cdk.duration.hours(jsii.Number(2)),
	 // Optional: set the maxEventAge retry policy
	retryAttempts: jsii.Number(2),
}))

type LogGroupProps 

type LogGroupProps struct {
	// The SQS queue to be used as deadLetterQueue. Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
	//
	// The events not successfully delivered are automatically retried for a specified period of time,
	// depending on the retry policy of the target.
	// If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
	DeadLetterQueue awssqs.IQueue `json:"deadLetterQueue" yaml:"deadLetterQueue"`
	// The maximum age of a request that Lambda sends to a function for processing.
	//
	// Minimum value of 60.
	// Maximum value of 86400.
	MaxEventAge awscdk.Duration `json:"maxEventAge" yaml:"maxEventAge"`
	// The maximum number of times to retry when the function returns an error.
	//
	// Minimum value of 0.
	// Maximum value of 185.
	RetryAttempts *float64 `json:"retryAttempts" yaml:"retryAttempts"`
	// The event to send to the CloudWatch LogGroup.
	//
	// This will be the event logged into the CloudWatch LogGroup.
	Event awsevents.RuleTargetInput `json:"event" yaml:"event"`
}

Customize the CloudWatch LogGroup Event Target.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"import awscdk "github.com/aws/aws-cdk-go/awscdk"import events "github.com/aws/aws-cdk-go/awscdk/aws_events"import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"import awscdk "github.com/aws/aws-cdk-go/awscdk"import sqs "github.com/aws/aws-cdk-go/awscdk/aws_sqs"

var queue queue
var ruleTargetInput ruleTargetInput
logGroupProps := &logGroupProps{
	deadLetterQueue: queue,
	event: ruleTargetInput,
	maxEventAge: cdk.duration.minutes(jsii.Number(30)),
	retryAttempts: jsii.Number(123),
}

type SfnStateMachine 

type SfnStateMachine interface {
	awsevents.IRuleTarget
	Machine() awsstepfunctions.IStateMachine
	// Returns a properties that are used in an Rule to trigger this State Machine.
	// See: https://docs.aws.amazon.com/eventbridge/latest/userguide/resource-based-policies-eventbridge.html#sns-permissions
	//
	Bind(_rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Use a StepFunctions state machine as a target for Amazon EventBridge rules.

Example: 

import iam "github.com/aws/aws-cdk-go/awscdk"import sfn "github.com/aws/aws-cdk-go/awscdk"

rule := events.NewRule(this, jsii.String("Rule"), &ruleProps{
	schedule: events.schedule.rate(cdk.duration.minutes(jsii.Number(1))),
})

dlq := sqs.NewQueue(this, jsii.String("DeadLetterQueue"))

role := iam.NewRole(this, jsii.String("Role"), &roleProps{
	assumedBy: iam.NewServicePrincipal(jsii.String("events.amazonaws.com")),
})
stateMachine := sfn.NewStateMachine(this, jsii.String("SM"), &stateMachineProps{
	definition: sfn.NewWait(this, jsii.String("Hello"), &waitProps{
		time: sfn.waitTime.duration(cdk.*duration.seconds(jsii.Number(10))),
	}),
})

rule.addTarget(targets.NewSfnStateMachine(stateMachine, &sfnStateMachineProps{
	input: events.ruleTargetInput.fromObject(map[string]*string{
		"SomeParam": jsii.String("SomeValue"),
	}),
	deadLetterQueue: dlq,
	role: role,
}))

func NewSfnStateMachine 

func NewSfnStateMachine(machine awsstepfunctions.IStateMachine, props *SfnStateMachineProps) SfnStateMachine

type SfnStateMachineProps 

type SfnStateMachineProps struct {
	// The SQS queue to be used as deadLetterQueue. Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
	//
	// The events not successfully delivered are automatically retried for a specified period of time,
	// depending on the retry policy of the target.
	// If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
	DeadLetterQueue awssqs.IQueue `json:"deadLetterQueue" yaml:"deadLetterQueue"`
	// The maximum age of a request that Lambda sends to a function for processing.
	//
	// Minimum value of 60.
	// Maximum value of 86400.
	MaxEventAge awscdk.Duration `json:"maxEventAge" yaml:"maxEventAge"`
	// The maximum number of times to retry when the function returns an error.
	//
	// Minimum value of 0.
	// Maximum value of 185.
	RetryAttempts *float64 `json:"retryAttempts" yaml:"retryAttempts"`
	// The input to the state machine execution.
	Input awsevents.RuleTargetInput `json:"input" yaml:"input"`
	// The IAM role to be assumed to execute the State Machine.
	Role awsiam.IRole `json:"role" yaml:"role"`
}

Customize the Step Functions State Machine target.

Example: 

import iam "github.com/aws/aws-cdk-go/awscdk"import sfn "github.com/aws/aws-cdk-go/awscdk"

rule := events.NewRule(this, jsii.String("Rule"), &ruleProps{
	schedule: events.schedule.rate(cdk.duration.minutes(jsii.Number(1))),
})

dlq := sqs.NewQueue(this, jsii.String("DeadLetterQueue"))

role := iam.NewRole(this, jsii.String("Role"), &roleProps{
	assumedBy: iam.NewServicePrincipal(jsii.String("events.amazonaws.com")),
})
stateMachine := sfn.NewStateMachine(this, jsii.String("SM"), &stateMachineProps{
	definition: sfn.NewWait(this, jsii.String("Hello"), &waitProps{
		time: sfn.waitTime.duration(cdk.*duration.seconds(jsii.Number(10))),
	}),
})

rule.addTarget(targets.NewSfnStateMachine(stateMachine, &sfnStateMachineProps{
	input: events.ruleTargetInput.fromObject(map[string]*string{
		"SomeParam": jsii.String("SomeValue"),
	}),
	deadLetterQueue: dlq,
	role: role,
}))

type SnsTopic 

type SnsTopic interface {
	awsevents.IRuleTarget
	Topic() awssns.ITopic
	// Returns a RuleTarget that can be used to trigger this SNS topic as a result from an EventBridge event.
	// See: https://docs.aws.amazon.com/eventbridge/latest/userguide/resource-based-policies-eventbridge.html#sns-permissions
	//
	Bind(_rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Use an SNS topic as a target for Amazon EventBridge rules.

Example: 

// publish to an SNS topic every time code is committed
// to a CodeCommit repository
repository.onCommit(jsii.String("onCommit"), &onCommitOptions{
	target: targets.NewSnsTopic(topic),
})

func NewSnsTopic 

func NewSnsTopic(topic awssns.ITopic, props *SnsTopicProps) SnsTopic

type SnsTopicProps 

type SnsTopicProps struct {
	// The message to send to the topic.
	Message awsevents.RuleTargetInput `json:"message" yaml:"message"`
}

Customize the SNS Topic Event Target.

Example: 

var onCommitRule rule
var topic topic

onCommitRule.addTarget(targets.NewSnsTopic(topic, &snsTopicProps{
	message: events.ruleTargetInput.fromText(
	fmt.Sprintf("A commit was pushed to the repository %v on branch %v", codecommit.referenceEvent.repositoryName, codecommit.*referenceEvent.referenceName)),
}))

type SqsQueue 

type SqsQueue interface {
	awsevents.IRuleTarget
	Queue() awssqs.IQueue
	// Returns a RuleTarget that can be used to trigger this SQS queue as a result from an EventBridge event.
	// See: https://docs.aws.amazon.com/eventbridge/latest/userguide/resource-based-policies-eventbridge.html#sqs-permissions
	//
	Bind(rule awsevents.IRule, _id *string) *awsevents.RuleTargetConfig
}

Use an SQS Queue as a target for Amazon EventBridge rules.

Example: 

// publish to an SQS queue every time code is committed
// to a CodeCommit repository
repository.onCommit(jsii.String("onCommit"), &onCommitOptions{
	target: targets.NewSqsQueue(queue),
})

func NewSqsQueue 

func NewSqsQueue(queue awssqs.IQueue, props *SqsQueueProps) SqsQueue

type SqsQueueProps 

type SqsQueueProps struct {
	// The SQS queue to be used as deadLetterQueue. Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
	//
	// The events not successfully delivered are automatically retried for a specified period of time,
	// depending on the retry policy of the target.
	// If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
	DeadLetterQueue awssqs.IQueue `json:"deadLetterQueue" yaml:"deadLetterQueue"`
	// The maximum age of a request that Lambda sends to a function for processing.
	//
	// Minimum value of 60.
	// Maximum value of 86400.
	MaxEventAge awscdk.Duration `json:"maxEventAge" yaml:"maxEventAge"`
	// The maximum number of times to retry when the function returns an error.
	//
	// Minimum value of 0.
	// Maximum value of 185.
	RetryAttempts *float64 `json:"retryAttempts" yaml:"retryAttempts"`
	// The message to send to the queue.
	//
	// Must be a valid JSON text passed to the target queue.
	Message awsevents.RuleTargetInput `json:"message" yaml:"message"`
	// Message Group ID for messages sent to this queue.
	//
	// Required for FIFO queues, leave empty for regular queues.
	MessageGroupId *string `json:"messageGroupId" yaml:"messageGroupId"`
}

Customize the SQS Queue Event Target.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"import awscdk "github.com/aws/aws-cdk-go/awscdk"import events "github.com/aws/aws-cdk-go/awscdk/aws_events"import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"import awscdk "github.com/aws/aws-cdk-go/awscdk"import sqs "github.com/aws/aws-cdk-go/awscdk/aws_sqs"

var queue queue
var ruleTargetInput ruleTargetInput
sqsQueueProps := &sqsQueueProps{
	deadLetterQueue: queue,
	maxEventAge: cdk.duration.minutes(jsii.Number(30)),
	message: ruleTargetInput,
	messageGroupId: jsii.String("messageGroupId"),
	retryAttempts: jsii.Number(123),
}

type TargetBaseProps 

type TargetBaseProps struct {
	// The SQS queue to be used as deadLetterQueue. Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
	//
	// The events not successfully delivered are automatically retried for a specified period of time,
	// depending on the retry policy of the target.
	// If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
	DeadLetterQueue awssqs.IQueue `json:"deadLetterQueue" yaml:"deadLetterQueue"`
	// The maximum age of a request that Lambda sends to a function for processing.
	//
	// Minimum value of 60.
	// Maximum value of 86400.
	MaxEventAge awscdk.Duration `json:"maxEventAge" yaml:"maxEventAge"`
	// The maximum number of times to retry when the function returns an error.
	//
	// Minimum value of 0.
	// Maximum value of 185.
	RetryAttempts *float64 `json:"retryAttempts" yaml:"retryAttempts"`
}

The generic properties for an RuleTarget.

Example: 

import cdk "github.com/aws/aws-cdk-go/awscdk"import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"import awscdk "github.com/aws/aws-cdk-go/awscdk"import sqs "github.com/aws/aws-cdk-go/awscdk/aws_sqs"

var queue queue
targetBaseProps := &targetBaseProps{
	deadLetterQueue: queue,
	maxEventAge: cdk.duration.minutes(jsii.Number(30)),
	retryAttempts: jsii.Number(123),
}

type TaskEnvironmentVariable 

type TaskEnvironmentVariable struct {
	// Name for the environment variable.
	//
	// Exactly one of `name` and `namePath` must be specified.
	Name *string `json:"name" yaml:"name"`
	// Value of the environment variable.
	//
	// Exactly one of `value` and `valuePath` must be specified.
	Value *string `json:"value" yaml:"value"`
}

An environment variable to be set in the container run as a task.

Example: 

import awscdk "github.com/aws/aws-cdk-go/awscdk"import events_targets "github.com/aws/aws-cdk-go/awscdk/aws_events_targets"
taskEnvironmentVariable := &taskEnvironmentVariable{
	name: jsii.String("name"),
	value: jsii.String("value"),
}

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.