AWS CDK Events Targets

import * as targets from "@aws-cdk/aws-events-targets";

import { 
  LambdaFunction, 
  SqsQueue, 
  SnsTopic, 
  EcsTask 
} from "@aws-cdk/aws-events-targets";

import * as events from "@aws-cdk/aws-events";
import * as lambda from "@aws-cdk/aws-lambda";
import * as targets from "@aws-cdk/aws-events-targets";

// Create a Lambda function
const fn = new lambda.Function(this, "MyFunc", {
  runtime: lambda.Runtime.NODEJS_14_X,
  handler: "index.handler",
  code: lambda.Code.fromInline("exports.handler = () => {}"),
});

// Create an EventBridge rule
const rule = new events.Rule(this, "MyRule", {
  eventPattern: {
    source: ["aws.ec2"],
  },
});

// Add Lambda function as target
rule.addTarget(new targets.LambdaFunction(fn, {
  retryAttempts: 2,
  maxEventAge: Duration.hours(2),
}));

class LambdaFunction implements events.IRuleTarget {
  constructor(handler: lambda.IFunction, props?: LambdaFunctionProps);
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

interface LambdaFunctionProps extends TargetBaseProps {
  /** The event to send to the Lambda function as payload (default: entire EventBridge event) */
  readonly event?: events.RuleTargetInput;
}

class EcsTask implements events.IRuleTarget {
  constructor(props: EcsTaskProps);
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

class BatchJob implements events.IRuleTarget {
  constructor(
    jobQueueArn: string,
    jobQueueScope: IConstruct,
    jobDefinitionArn: string,
    jobDefinitionScope: IConstruct,
    props?: BatchJobProps
  );
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

interface BatchJobProps extends TargetBaseProps {
  /** The event to send to the batch job (default: entire EventBridge event) */
  readonly event?: events.RuleTargetInput;
  /** The size of the array, if this is an array batch job (valid values: 2-10,000) */
  readonly size?: number;
  /** The number of times to attempt to retry, if the job fails (valid values: 1-10) */
  readonly attempts?: number;
  /** The name of the submitted job (default: automatically generated) */
  readonly jobName?: string;
}

class SqsQueue implements events.IRuleTarget {
  constructor(queue: sqs.IQueue, props?: SqsQueueProps);
  readonly queue: sqs.IQueue;
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

interface SqsQueueProps extends TargetBaseProps {
  /** Message Group ID for messages sent to FIFO queues */
  readonly messageGroupId?: string;
  /** The message to send to the queue (default: entire EventBridge event) */
  readonly message?: events.RuleTargetInput;
}

class SnsTopic implements events.IRuleTarget {
  constructor(topic: sns.ITopic, props?: SnsTopicProps);
  readonly topic: sns.ITopic;
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

interface SnsTopicProps {
  /** The message to send to the topic (default: entire EventBridge event) */
  readonly message?: events.RuleTargetInput;
}

class ApiGateway implements events.IRuleTarget {
  constructor(restApi: api.RestApi, props?: ApiGatewayProps);
  readonly restApi: api.RestApi;
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

interface ApiGatewayProps extends TargetBaseProps {
  /** The method for API resource invoked by the rule (default: '*' treated as ANY) */
  readonly method?: string;
  /** The API resource invoked by the rule (default: '/') */
  readonly path?: string;
  /** The deploy stage of API gateway invoked by the rule */
  readonly stage?: string;
  /** The headers to be set when requesting API */
  readonly headerParameters?: { [key: string]: string };
  /** The path parameter values to populate wildcards in API path */
  readonly pathParameterValues?: string[];
  /** The query parameters to be set when requesting API */
  readonly queryStringParameters?: { [key: string]: string };
  /** The post request body sent to the API (default: entire EventBridge event) */
  readonly postBody?: events.RuleTargetInput;
  /** The role to assume before invoking the target (default: new role created) */
  readonly eventRole?: iam.IRole;
}

class ApiDestination implements events.IRuleTarget {
  constructor(apiDestination: events.IApiDestination, props?: ApiDestinationProps);
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

interface ApiDestinationProps extends TargetBaseProps {
  /** The event to send (default: entire EventBridge event) */
  readonly event?: events.RuleTargetInput;
  /** The role to assume before invoking the target (default: new role created) */
  readonly eventRole?: iam.IRole;
  /** Additional headers sent to the API Destination */
  readonly headerParameters?: Record<string, string>;
  /** Path parameters to insert in place of path wildcards */
  readonly pathParameterValues?: string[];
  /** Additional query string parameters sent to the API Destination */
  readonly queryStringParameters?: Record<string, string>;
}

class CodeBuildProject implements events.IRuleTarget {
  constructor(project: codebuild.IProject, props?: CodeBuildProjectProps);
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

interface CodeBuildProjectProps extends TargetBaseProps {
  /** The role to assume before invoking the target (default: new role created) */
  readonly eventRole?: iam.IRole;
  /** The event to send to CodeBuild as StartBuild API payload (default: entire EventBridge event) */
  readonly event?: events.RuleTargetInput;
}

class CodePipeline implements events.IRuleTarget {
  constructor(pipeline: codepipeline.IPipeline, options?: CodePipelineTargetOptions);
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

interface CodePipelineTargetOptions extends TargetBaseProps {
  /** The role to assume before invoking the pipeline (default: new role created) */
  readonly eventRole?: iam.IRole;
}

class KinesisStream implements events.IRuleTarget {
  constructor(stream: kinesis.IStream, props?: KinesisStreamProps);
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

class CloudWatchLogGroup implements events.IRuleTarget {
  constructor(logGroup: logs.ILogGroup, props?: LogGroupProps);
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

class KinesisFirehoseStream implements events.IRuleTarget {
  constructor(stream: firehose.CfnDeliveryStream, props?: KinesisFirehoseStreamProps);
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

class SfnStateMachine implements events.IRuleTarget {
  constructor(machine: sfn.IStateMachine, props?: SfnStateMachineProps);
  readonly machine: sfn.IStateMachine;
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

class EventBus implements events.IRuleTarget {
  constructor(eventBus: events.IEventBus, props?: EventBusProps);
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

class AwsApi implements events.IRuleTarget {
  constructor(props: AwsApiProps);
  bind(rule: events.IRule, id?: string): events.RuleTargetConfig;
}

interface TargetBaseProps {
  /** SQS queue for failed event deliveries */
  readonly deadLetterQueue?: sqs.IQueue;
  /** Maximum age of requests sent to target */
  readonly maxEventAge?: Duration;
  /** Maximum number of retry attempts */
  readonly retryAttempts?: number;
}

interface ContainerOverride {
  /** Name of the container inside task definition */
  readonly containerName: string;
  /** Command to run inside container */
  readonly command?: string[];
  /** Environment variables to set */
  readonly environment?: TaskEnvironmentVariable[];
  /** CPU units reserved for container */
  readonly cpu?: number;
  /** Hard memory limit on container */
  readonly memoryLimit?: number;
  /** Soft memory limit on container */
  readonly memoryReservation?: number;
}

interface TaskEnvironmentVariable {
  /** Name for the environment variable (exactly one of name and namePath must be specified) */
  readonly name: string;
  /** Value of the environment variable (exactly one of value and valuePath must be specified) */
  readonly value: string;
}

function addLambdaPermission(rule: events.IRule, handler: lambda.IFunction): void;
function addToDeadLetterQueueResourcePolicy(rule: events.IRule, queue: sqs.IQueue): void;
function singletonEventRole(scope: IConstruct): iam.IRole;
function bindBaseTargetConfig(props: TargetBaseProps): object;