@aws-cdk/aws-pipes-targets-alpha

Amazon EventBridge Pipes Targets Construct Library

Version 2.274.0-alpha.0

Separate package

@aws-cdk/aws-pipes-targets-alpha is not part of aws-cdk-lib — install it separately:

npm install @aws-cdk/aws-pipes-targets-alpha
pip install aws-cdk.aws-pipes-targets-alpha

This module is experimental (alpha): its API may change in any release, without a major version bump.

---

The APIs of higher level constructs in this module are experimental and under active development. They are subject to non-backward compatible changes or removal in any future version. These are not subject to the Semantic Versioning model and breaking changes will be announced in the release notes. This means that while you may use them, you may need to update your source code when upgrading to a newer version of this package.

---

EventBridge Pipes Targets let you create a target for an EventBridge Pipe.

For more details see the service documentation.

Targets

Pipe targets are the end point of an EventBridge Pipe. The following targets are supported:

• targets.ApiDestinationTarget: Send event source to an EventBridge API destination
• targets.ApiGatewayTarget: Send event source to an API Gateway REST API
• targets.CloudWatchLogsTarget: Send event source to a CloudWatch Logs log group
• targets.EventBridgeTarget: Send event source to an EventBridge event bus
• targets.FirehoseTarget: Send event source to an Amazon Data Firehose delivery stream
• targets.KinesisTarget: Send event source to a Kinesis data stream
• targets.LambdaFunction: Send event source to a Lambda function
• targets.SageMakerTarget: Send event source to a SageMaker pipeline
• targets.SfnStateMachine: Invoke a Step Functions state machine from an event source
• targets.SnsTarget: Send event source to an SNS topic
• targets.SqsTarget: Send event source to an SQS queue

Amazon EventBridge API Destination

An EventBridge API destination can be used as a target for a pipe. The API destination will receive the (enriched/filtered) source payload.

declare const sourceQueue: sqs.Queue;
declare const dest: events.ApiDestination;

const apiTarget = new targets.ApiDestinationTarget(dest);

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: apiTarget,
});

# source_queue: sqs.Queue
# dest: events.ApiDestination


api_target = targets.ApiDestinationTarget(dest)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=api_target
)

Queue sourceQueue;
ApiDestination dest;


ApiDestinationTarget apiTarget = new ApiDestinationTarget(dest);

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(apiTarget)
        .build();

Queue sourceQueue;
ApiDestination dest;


var apiTarget = new ApiDestinationTarget(dest);

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = apiTarget
});

var sourceQueue Queue
var dest ApiDestination


apiTarget := targets.NewApiDestinationTarget(dest)

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: apiTarget,
})

The input to the target API destination can be transformed:

declare const sourceQueue: sqs.Queue;
declare const dest: events.ApiDestination;

const apiTarget = new targets.ApiDestinationTarget(dest, {
  inputTransformation: pipes.InputTransformation.fromObject({ body: "👀" }),
});

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: apiTarget,
});

# source_queue: sqs.Queue
# dest: events.ApiDestination


api_target = targets.ApiDestinationTarget(dest,
    input_transformation=pipes.InputTransformation.from_object({"body": "👀"})
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=api_target
)

Queue sourceQueue;
ApiDestination dest;


ApiDestinationTarget apiTarget = ApiDestinationTarget.Builder.create(dest)
        .inputTransformation(InputTransformation.fromObject(Map.of("body", "👀")))
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(apiTarget)
        .build();

Queue sourceQueue;
ApiDestination dest;


var apiTarget = new ApiDestinationTarget(dest, new ApiDestinationTargetParameters {
    InputTransformation = InputTransformation.FromObject(new Dictionary<string, object> { { "body", "👀" } })
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = apiTarget
});

var sourceQueue Queue
var dest ApiDestination


apiTarget := targets.NewApiDestinationTarget(dest, &ApiDestinationTargetParameters{
	InputTransformation: pipes.InputTransformation_FromObject(map[string]interface{}{
		"body": jsii.String("👀"),
	}),
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: apiTarget,
})

Amazon API Gateway Rest API

A REST API can be used as a target for a pipe. The REST API will receive the (enriched/filtered) source payload.

declare const sourceQueue: sqs.Queue;

const fn = new lambda.Function( this, 'MyFunc', {
  handler: 'index.handler',
  runtime: lambda.Runtime.NODEJS_LATEST,
  code: lambda.Code.fromInline( 'exports.handler = e => {}' ),
});

const restApi = new api.LambdaRestApi( this, 'MyRestAPI', { handler: fn } );
const apiTarget = new targets.ApiGatewayTarget(restApi);

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: apiTarget,
});

# source_queue: sqs.Queue


fn = lambda_.Function(self, "MyFunc",
    handler="index.handler",
    runtime=lambda_.Runtime.NODEJS_LATEST,
    code=lambda_.Code.from_inline("exports.handler = e => {}")
)

rest_api = api.LambdaRestApi(self, "MyRestAPI", handler=fn)
api_target = targets.ApiGatewayTarget(rest_api)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=api_target
)

Queue sourceQueue;


Function fn = Function.Builder.create(this, "MyFunc")
        .handler("index.handler")
        .runtime(Runtime.NODEJS_LATEST)
        .code(Code.fromInline("exports.handler = e => {}"))
        .build();

LambdaRestApi restApi = LambdaRestApi.Builder.create(this, "MyRestAPI").handler(fn).build();
ApiGatewayTarget apiTarget = new ApiGatewayTarget(restApi);

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(apiTarget)
        .build();

Queue sourceQueue;


var fn = new Function(this, "MyFunc", new FunctionProps {
    Handler = "index.handler",
    Runtime = Runtime.NODEJS_LATEST,
    Code = Code.FromInline("exports.handler = e => {}")
});

var restApi = new LambdaRestApi(this, "MyRestAPI", new LambdaRestApiProps { Handler = fn });
var apiTarget = new ApiGatewayTarget(restApi);

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = apiTarget
});

var sourceQueue Queue


fn := lambda.NewFunction(this, jsii.String("MyFunc"), &FunctionProps{
	Handler: jsii.String("index.handler"),
	Runtime: lambda.Runtime_NODEJS_LATEST(),
	Code: lambda.Code_FromInline(jsii.String("exports.handler = e => {}")),
})

restApi := api.NewLambdaRestApi(this, jsii.String("MyRestAPI"), &LambdaRestApiProps{
	Handler: fn,
})
apiTarget := targets.NewApiGatewayTarget(restApi)

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: apiTarget,
})

The input to the target REST API can be transformed:

declare const sourceQueue: sqs.Queue;

const fn = new lambda.Function( this, 'MyFunc', {
  handler: 'index.handler',
  runtime: lambda.Runtime.NODEJS_LATEST,
  code: lambda.Code.fromInline( 'exports.handler = e => {}' ),
});

const restApi = new api.LambdaRestApi( this, 'MyRestAPI', { handler: fn } );
const apiTarget = new targets.ApiGatewayTarget(restApi, {
  inputTransformation: pipes.InputTransformation.fromObject({ body: "👀" }),
});

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: apiTarget,
});

# source_queue: sqs.Queue


fn = lambda_.Function(self, "MyFunc",
    handler="index.handler",
    runtime=lambda_.Runtime.NODEJS_LATEST,
    code=lambda_.Code.from_inline("exports.handler = e => {}")
)

rest_api = api.LambdaRestApi(self, "MyRestAPI", handler=fn)
api_target = targets.ApiGatewayTarget(rest_api,
    input_transformation=pipes.InputTransformation.from_object({"body": "👀"})
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=api_target
)

Queue sourceQueue;


Function fn = Function.Builder.create(this, "MyFunc")
        .handler("index.handler")
        .runtime(Runtime.NODEJS_LATEST)
        .code(Code.fromInline("exports.handler = e => {}"))
        .build();

LambdaRestApi restApi = LambdaRestApi.Builder.create(this, "MyRestAPI").handler(fn).build();
ApiGatewayTarget apiTarget = ApiGatewayTarget.Builder.create(restApi)
        .inputTransformation(InputTransformation.fromObject(Map.of("body", "👀")))
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(apiTarget)
        .build();

Queue sourceQueue;


var fn = new Function(this, "MyFunc", new FunctionProps {
    Handler = "index.handler",
    Runtime = Runtime.NODEJS_LATEST,
    Code = Code.FromInline("exports.handler = e => {}")
});

var restApi = new LambdaRestApi(this, "MyRestAPI", new LambdaRestApiProps { Handler = fn });
var apiTarget = new ApiGatewayTarget(restApi, new ApiGatewayTargetParameters {
    InputTransformation = InputTransformation.FromObject(new Dictionary<string, object> { { "body", "👀" } })
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = apiTarget
});

var sourceQueue Queue


fn := lambda.NewFunction(this, jsii.String("MyFunc"), &FunctionProps{
	Handler: jsii.String("index.handler"),
	Runtime: lambda.Runtime_NODEJS_LATEST(),
	Code: lambda.Code_FromInline(jsii.String("exports.handler = e => {}")),
})

restApi := api.NewLambdaRestApi(this, jsii.String("MyRestAPI"), &LambdaRestApiProps{
	Handler: fn,
})
apiTarget := targets.NewApiGatewayTarget(restApi, &ApiGatewayTargetParameters{
	InputTransformation: pipes.InputTransformation_FromObject(map[string]interface{}{
		"body": jsii.String("👀"),
	}),
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: apiTarget,
})

Amazon CloudWatch Logs Log Group

A CloudWatch Logs log group can be used as a target for a pipe. The log group will receive the (enriched/filtered) source payload.

declare const sourceQueue: sqs.Queue;
declare const targetLogGroup: logs.LogGroup;

const logGroupTarget = new targets.CloudWatchLogsTarget(targetLogGroup);

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: logGroupTarget,
});

# source_queue: sqs.Queue
# target_log_group: logs.LogGroup


log_group_target = targets.CloudWatchLogsTarget(target_log_group)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=log_group_target
)

Queue sourceQueue;
LogGroup targetLogGroup;


CloudWatchLogsTarget logGroupTarget = new CloudWatchLogsTarget(targetLogGroup);

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(logGroupTarget)
        .build();

Queue sourceQueue;
LogGroup targetLogGroup;


var logGroupTarget = new CloudWatchLogsTarget(targetLogGroup);

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = logGroupTarget
});

var sourceQueue Queue
var targetLogGroup LogGroup


logGroupTarget := targets.NewCloudWatchLogsTarget(targetLogGroup)

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: logGroupTarget,
})

The input to the target log group can be transformed:

declare const sourceQueue: sqs.Queue;
declare const targetLogGroup: logs.LogGroup;

const logGroupTarget = new targets.CloudWatchLogsTarget(targetLogGroup, {
  inputTransformation: pipes.InputTransformation.fromObject({ body: "👀" }),
});

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: logGroupTarget,
});

# source_queue: sqs.Queue
# target_log_group: logs.LogGroup


log_group_target = targets.CloudWatchLogsTarget(target_log_group,
    input_transformation=pipes.InputTransformation.from_object({"body": "👀"})
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=log_group_target
)

Queue sourceQueue;
LogGroup targetLogGroup;


CloudWatchLogsTarget logGroupTarget = CloudWatchLogsTarget.Builder.create(targetLogGroup)
        .inputTransformation(InputTransformation.fromObject(Map.of("body", "👀")))
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(logGroupTarget)
        .build();

Queue sourceQueue;
LogGroup targetLogGroup;


var logGroupTarget = new CloudWatchLogsTarget(targetLogGroup, new CloudWatchLogsTargetParameters {
    InputTransformation = InputTransformation.FromObject(new Dictionary<string, object> { { "body", "👀" } })
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = logGroupTarget
});

var sourceQueue Queue
var targetLogGroup LogGroup


logGroupTarget := targets.NewCloudWatchLogsTarget(targetLogGroup, &CloudWatchLogsTargetParameters{
	InputTransformation: pipes.InputTransformation_FromObject(map[string]interface{}{
		"body": jsii.String("👀"),
	}),
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: logGroupTarget,
})

Amazon EventBridge Event Bus

An EventBridge event bus can be used as a target for a pipe. The event bus will receive the (enriched/filtered) source payload.

declare const sourceQueue: sqs.Queue;
declare const targetEventBus: events.EventBus;

const eventBusTarget = new targets.EventBridgeTarget(targetEventBus);

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: eventBusTarget,
});

# source_queue: sqs.Queue
# target_event_bus: events.EventBus


event_bus_target = targets.EventBridgeTarget(target_event_bus)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=event_bus_target
)

Queue sourceQueue;
EventBus targetEventBus;


EventBridgeTarget eventBusTarget = new EventBridgeTarget(targetEventBus);

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(eventBusTarget)
        .build();

Queue sourceQueue;
EventBus targetEventBus;


var eventBusTarget = new EventBridgeTarget(targetEventBus);

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = eventBusTarget
});

var sourceQueue Queue
var targetEventBus EventBus


eventBusTarget := targets.NewEventBridgeTarget(targetEventBus)

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: eventBusTarget,
})

The input to the target event bus can be transformed:

declare const sourceQueue: sqs.Queue;
declare const targetEventBus: events.EventBus;

const eventBusTarget = new targets.EventBridgeTarget(targetEventBus, {
  inputTransformation: pipes.InputTransformation.fromObject({ body: "👀" }),
});

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: eventBusTarget,
});

# source_queue: sqs.Queue
# target_event_bus: events.EventBus


event_bus_target = targets.EventBridgeTarget(target_event_bus,
    input_transformation=pipes.InputTransformation.from_object({"body": "👀"})
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=event_bus_target
)

Queue sourceQueue;
EventBus targetEventBus;


EventBridgeTarget eventBusTarget = EventBridgeTarget.Builder.create(targetEventBus)
        .inputTransformation(InputTransformation.fromObject(Map.of("body", "👀")))
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(eventBusTarget)
        .build();

Queue sourceQueue;
EventBus targetEventBus;


var eventBusTarget = new EventBridgeTarget(targetEventBus, new EventBridgeTargetParameters {
    InputTransformation = InputTransformation.FromObject(new Dictionary<string, object> { { "body", "👀" } })
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = eventBusTarget
});

var sourceQueue Queue
var targetEventBus EventBus


eventBusTarget := targets.NewEventBridgeTarget(targetEventBus, &EventBridgeTargetParameters{
	InputTransformation: pipes.InputTransformation_FromObject(map[string]interface{}{
		"body": jsii.String("👀"),
	}),
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: eventBusTarget,
})

Amazon Data Firehose Delivery Stream

An Amazon Data Firehose delivery stream can be used as a target for a pipe. The delivery stream will receive the (enriched/filtered) source payload.

declare const sourceQueue: sqs.Queue;
declare const targetDeliveryStream: firehose.DeliveryStream;

const deliveryStreamTarget = new targets.FirehoseTarget(targetDeliveryStream);

const pipe = new pipes.Pipe(this, 'Pipe', {
  source: new SqsSource(sourceQueue),
  target: deliveryStreamTarget,
});

# source_queue: sqs.Queue
# target_delivery_stream: firehose.DeliveryStream


delivery_stream_target = targets.FirehoseTarget(target_delivery_stream)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=delivery_stream_target
)

Queue sourceQueue;
DeliveryStream targetDeliveryStream;


FirehoseTarget deliveryStreamTarget = new FirehoseTarget(targetDeliveryStream);

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(deliveryStreamTarget)
        .build();

Queue sourceQueue;
DeliveryStream targetDeliveryStream;


var deliveryStreamTarget = new FirehoseTarget(targetDeliveryStream);

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = deliveryStreamTarget
});

var sourceQueue Queue
var targetDeliveryStream DeliveryStream


deliveryStreamTarget := targets.NewFirehoseTarget(targetDeliveryStream)

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: deliveryStreamTarget,
})

The input to the target delivery stream can be transformed:

declare const sourceQueue: sqs.Queue;
declare const targetDeliveryStream: firehose.DeliveryStream;

const deliveryStreamTarget = new targets.FirehoseTarget(targetDeliveryStream, {
  inputTransformation: pipes.InputTransformation.fromObject({ body: "👀" }),
});

const pipe = new pipes.Pipe(this, 'Pipe', {
  source: new SqsSource(sourceQueue),
  target: deliveryStreamTarget,
});

# source_queue: sqs.Queue
# target_delivery_stream: firehose.DeliveryStream


delivery_stream_target = targets.FirehoseTarget(target_delivery_stream,
    input_transformation=pipes.InputTransformation.from_object({"body": "👀"})
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=delivery_stream_target
)

Queue sourceQueue;
DeliveryStream targetDeliveryStream;


FirehoseTarget deliveryStreamTarget = FirehoseTarget.Builder.create(targetDeliveryStream)
        .inputTransformation(InputTransformation.fromObject(Map.of("body", "👀")))
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(deliveryStreamTarget)
        .build();

Queue sourceQueue;
DeliveryStream targetDeliveryStream;


var deliveryStreamTarget = new FirehoseTarget(targetDeliveryStream, new FirehoseTargetParameters {
    InputTransformation = InputTransformation.FromObject(new Dictionary<string, object> { { "body", "👀" } })
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = deliveryStreamTarget
});

var sourceQueue Queue
var targetDeliveryStream DeliveryStream


deliveryStreamTarget := targets.NewFirehoseTarget(targetDeliveryStream, &FirehoseTargetParameters{
	InputTransformation: pipes.InputTransformation_FromObject(map[string]interface{}{
		"body": jsii.String("👀"),
	}),
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: deliveryStreamTarget,
})

Amazon Kinesis Data Stream

A Kinesis data stream can be used as a target for a pipe. The data stream will receive the (enriched/filtered) source payload.

declare const sourceQueue: sqs.Queue;
declare const targetStream: kinesis.Stream;

const streamTarget = new targets.KinesisTarget(targetStream, {
    partitionKey: 'pk',
});

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: streamTarget,
});

# source_queue: sqs.Queue
# target_stream: kinesis.Stream


stream_target = targets.KinesisTarget(target_stream,
    partition_key="pk"
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=stream_target
)

Queue sourceQueue;
Stream targetStream;


KinesisTarget streamTarget = KinesisTarget.Builder.create(targetStream)
        .partitionKey("pk")
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(streamTarget)
        .build();

Queue sourceQueue;
Stream targetStream;


var streamTarget = new KinesisTarget(targetStream, new KinesisTargetParameters {
    PartitionKey = "pk"
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = streamTarget
});

var sourceQueue Queue
var targetStream Stream


streamTarget := targets.NewKinesisTarget(targetStream, &KinesisTargetParameters{
	PartitionKey: jsii.String("pk"),
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: streamTarget,
})

The input to the target data stream can be transformed:

declare const sourceQueue: sqs.Queue;
declare const targetStream: kinesis.Stream;

const streamTarget = new targets.KinesisTarget(targetStream, {
    partitionKey: 'pk',
    inputTransformation: pipes.InputTransformation.fromObject({ body: "👀" }),
});

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: streamTarget,
});

# source_queue: sqs.Queue
# target_stream: kinesis.Stream


stream_target = targets.KinesisTarget(target_stream,
    partition_key="pk",
    input_transformation=pipes.InputTransformation.from_object({"body": "👀"})
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=stream_target
)

Queue sourceQueue;
Stream targetStream;


KinesisTarget streamTarget = KinesisTarget.Builder.create(targetStream)
        .partitionKey("pk")
        .inputTransformation(InputTransformation.fromObject(Map.of("body", "👀")))
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(streamTarget)
        .build();

Queue sourceQueue;
Stream targetStream;


var streamTarget = new KinesisTarget(targetStream, new KinesisTargetParameters {
    PartitionKey = "pk",
    InputTransformation = InputTransformation.FromObject(new Dictionary<string, object> { { "body", "👀" } })
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = streamTarget
});

var sourceQueue Queue
var targetStream Stream


streamTarget := targets.NewKinesisTarget(targetStream, &KinesisTargetParameters{
	PartitionKey: jsii.String("pk"),
	InputTransformation: pipes.InputTransformation_FromObject(map[string]interface{}{
		"body": jsii.String("👀"),
	}),
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: streamTarget,
})

AWS Lambda Function

A Lambda function can be used as a target for a pipe. The Lambda function will be invoked with the (enriched/filtered) source payload.

declare const sourceQueue: sqs.Queue;
declare const targetFunction: lambda.IFunction;

const pipeTarget = new targets.LambdaFunction(targetFunction,{});

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: pipeTarget
});

# source_queue: sqs.Queue
# target_function: lambda.IFunction


pipe_target = targets.LambdaFunction(target_function)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=pipe_target
)

Queue sourceQueue;
IFunction targetFunction;


LambdaFunction pipeTarget = LambdaFunction.Builder.create(targetFunction).build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(pipeTarget)
        .build();

Queue sourceQueue;
IFunction targetFunction;


var pipeTarget = new LambdaFunction(targetFunction, new LambdaFunctionParameters { });

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = pipeTarget
});

var sourceQueue Queue
var targetFunction IFunction


pipeTarget := targets.NewLambdaFunction(targetFunction, &LambdaFunctionParameters{
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: pipeTarget,
})

The target Lambda function is invoked synchronously by default. You can also choose to invoke the Lambda Function asynchronously by setting invocationType property to FIRE_AND_FORGET.

declare const sourceQueue: sqs.Queue;
declare const targetFunction: lambda.IFunction;

const pipeTarget = new targets.LambdaFunction(targetFunction, {
  invocationType: targets.LambdaFunctionInvocationType.FIRE_AND_FORGET,
});

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: pipeTarget
});

# source_queue: sqs.Queue
# target_function: lambda.IFunction


pipe_target = targets.LambdaFunction(target_function,
    invocation_type=targets.LambdaFunctionInvocationType.FIRE_AND_FORGET
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=pipe_target
)

Queue sourceQueue;
IFunction targetFunction;


LambdaFunction pipeTarget = LambdaFunction.Builder.create(targetFunction)
        .invocationType(LambdaFunctionInvocationType.FIRE_AND_FORGET)
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(pipeTarget)
        .build();

Queue sourceQueue;
IFunction targetFunction;


var pipeTarget = new LambdaFunction(targetFunction, new LambdaFunctionParameters {
    InvocationType = LambdaFunctionInvocationType.FIRE_AND_FORGET
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = pipeTarget
});

var sourceQueue Queue
var targetFunction IFunction


pipeTarget := targets.NewLambdaFunction(targetFunction, &LambdaFunctionParameters{
	InvocationType: targets.LambdaFunctionInvocationType_FIRE_AND_FORGET,
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: pipeTarget,
})

The input to the target Lambda Function can be transformed:

declare const sourceQueue: sqs.Queue;
declare const targetFunction: lambda.IFunction;

const pipeTarget = new targets.LambdaFunction(targetFunction, {
  inputTransformation: pipes.InputTransformation.fromObject({ body: "👀" }),
});

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: pipeTarget
});

# source_queue: sqs.Queue
# target_function: lambda.IFunction


pipe_target = targets.LambdaFunction(target_function,
    input_transformation=pipes.InputTransformation.from_object({"body": "👀"})
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=pipe_target
)

Queue sourceQueue;
IFunction targetFunction;


LambdaFunction pipeTarget = LambdaFunction.Builder.create(targetFunction)
        .inputTransformation(InputTransformation.fromObject(Map.of("body", "👀")))
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(pipeTarget)
        .build();

Queue sourceQueue;
IFunction targetFunction;


var pipeTarget = new LambdaFunction(targetFunction, new LambdaFunctionParameters {
    InputTransformation = InputTransformation.FromObject(new Dictionary<string, object> { { "body", "👀" } })
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = pipeTarget
});

var sourceQueue Queue
var targetFunction IFunction


pipeTarget := targets.NewLambdaFunction(targetFunction, &LambdaFunctionParameters{
	InputTransformation: pipes.InputTransformation_FromObject(map[string]interface{}{
		"body": jsii.String("👀"),
	}),
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: pipeTarget,
})

Amazon SageMaker Pipeline

A SageMaker pipeline can be used as a target for a pipe. The pipeline will receive the (enriched/filtered) source payload.

declare const sourceQueue: sqs.Queue;
declare const targetPipeline: sagemaker.IPipeline;

const pipelineTarget = new targets.SageMakerTarget(targetPipeline);

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: pipelineTarget,
});

# source_queue: sqs.Queue
# target_pipeline: sagemaker.IPipeline


pipeline_target = targets.SageMakerTarget(target_pipeline)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=pipeline_target
)

Queue sourceQueue;
IPipeline targetPipeline;


SageMakerTarget pipelineTarget = new SageMakerTarget(targetPipeline);

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(pipelineTarget)
        .build();

Queue sourceQueue;
IPipeline targetPipeline;


var pipelineTarget = new SageMakerTarget(targetPipeline);

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = pipelineTarget
});

var sourceQueue Queue
var targetPipeline IPipeline


pipelineTarget := targets.NewSageMakerTarget(targetPipeline)

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: pipelineTarget,
})

The input to the target pipeline can be transformed:

declare const sourceQueue: sqs.Queue;
declare const targetPipeline: sagemaker.IPipeline;

const pipelineTarget = new targets.SageMakerTarget(targetPipeline, {
  inputTransformation: pipes.InputTransformation.fromObject({ body: "👀" }),
});

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: pipelineTarget,
});

# source_queue: sqs.Queue
# target_pipeline: sagemaker.IPipeline


pipeline_target = targets.SageMakerTarget(target_pipeline,
    input_transformation=pipes.InputTransformation.from_object({"body": "👀"})
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=pipeline_target
)

Queue sourceQueue;
IPipeline targetPipeline;


SageMakerTarget pipelineTarget = SageMakerTarget.Builder.create(targetPipeline)
        .inputTransformation(InputTransformation.fromObject(Map.of("body", "👀")))
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(pipelineTarget)
        .build();

Queue sourceQueue;
IPipeline targetPipeline;


var pipelineTarget = new SageMakerTarget(targetPipeline, new SageMakerTargetParameters {
    InputTransformation = InputTransformation.FromObject(new Dictionary<string, object> { { "body", "👀" } })
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = pipelineTarget
});

var sourceQueue Queue
var targetPipeline IPipeline


pipelineTarget := targets.NewSageMakerTarget(targetPipeline, &SageMakerTargetParameters{
	InputTransformation: pipes.InputTransformation_FromObject(map[string]interface{}{
		"body": jsii.String("👀"),
	}),
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: pipelineTarget,
})

AWS Step Functions State Machine

A Step Functions state machine can be used as a target for a pipe. The state machine will be invoked with the (enriched/filtered) source payload.

declare const sourceQueue: sqs.Queue;
declare const targetStateMachine: sfn.IStateMachine;

const pipeTarget = new targets.SfnStateMachine(targetStateMachine,{});

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: pipeTarget
});

# source_queue: sqs.Queue
# target_state_machine: sfn.IStateMachine


pipe_target = targets.SfnStateMachine(target_state_machine)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=pipe_target
)

Queue sourceQueue;
IStateMachine targetStateMachine;


SfnStateMachine pipeTarget = SfnStateMachine.Builder.create(targetStateMachine).build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(pipeTarget)
        .build();

Queue sourceQueue;
IStateMachine targetStateMachine;


var pipeTarget = new SfnStateMachine(targetStateMachine, new SfnStateMachineParameters { });

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = pipeTarget
});

var sourceQueue Queue
var targetStateMachine IStateMachine


pipeTarget := targets.NewSfnStateMachine(targetStateMachine, &SfnStateMachineParameters{
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: pipeTarget,
})

You can specify the invocation type when the target state machine is invoked:

declare const sourceQueue: sqs.Queue;
declare const targetStateMachine: sfn.IStateMachine;

const pipeTarget = new targets.SfnStateMachine(targetStateMachine, {
    invocationType: targets.StateMachineInvocationType.FIRE_AND_FORGET,
});

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: pipeTarget
});

# source_queue: sqs.Queue
# target_state_machine: sfn.IStateMachine


pipe_target = targets.SfnStateMachine(target_state_machine,
    invocation_type=targets.StateMachineInvocationType.FIRE_AND_FORGET
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=pipe_target
)

Queue sourceQueue;
IStateMachine targetStateMachine;


SfnStateMachine pipeTarget = SfnStateMachine.Builder.create(targetStateMachine)
        .invocationType(StateMachineInvocationType.FIRE_AND_FORGET)
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(pipeTarget)
        .build();

Queue sourceQueue;
IStateMachine targetStateMachine;


var pipeTarget = new SfnStateMachine(targetStateMachine, new SfnStateMachineParameters {
    InvocationType = StateMachineInvocationType.FIRE_AND_FORGET
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = pipeTarget
});

var sourceQueue Queue
var targetStateMachine IStateMachine


pipeTarget := targets.NewSfnStateMachine(targetStateMachine, &SfnStateMachineParameters{
	InvocationType: targets.StateMachineInvocationType_FIRE_AND_FORGET,
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: pipeTarget,
})

The input to the target state machine can be transformed:

declare const sourceQueue: sqs.Queue;
declare const targetStateMachine: sfn.IStateMachine;

const pipeTarget = new targets.SfnStateMachine(targetStateMachine,
    {
      inputTransformation: pipes.InputTransformation.fromObject({ body: '<$.body>' }),
      invocationType: targets.StateMachineInvocationType.FIRE_AND_FORGET,
    }
);

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: pipeTarget
});

# source_queue: sqs.Queue
# target_state_machine: sfn.IStateMachine


pipe_target = targets.SfnStateMachine(target_state_machine,
    input_transformation=pipes.InputTransformation.from_object({"body": "<$.body>"}),
    invocation_type=targets.StateMachineInvocationType.FIRE_AND_FORGET
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=pipe_target
)

Queue sourceQueue;
IStateMachine targetStateMachine;


SfnStateMachine pipeTarget = SfnStateMachine.Builder.create(targetStateMachine)
        .inputTransformation(InputTransformation.fromObject(Map.of("body", "<$.body>")))
        .invocationType(StateMachineInvocationType.FIRE_AND_FORGET)
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(pipeTarget)
        .build();

Queue sourceQueue;
IStateMachine targetStateMachine;


var pipeTarget = new SfnStateMachine(targetStateMachine, new SfnStateMachineParameters {
    InputTransformation = InputTransformation.FromObject(new Dictionary<string, object> { { "body", "<$.body>" } }),
    InvocationType = StateMachineInvocationType.FIRE_AND_FORGET
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = pipeTarget
});

var sourceQueue Queue
var targetStateMachine IStateMachine


pipeTarget := targets.NewSfnStateMachine(targetStateMachine, &SfnStateMachineParameters{
	InputTransformation: pipes.InputTransformation_FromObject(map[string]interface{}{
		"body": jsii.String("<$.body>"),
	}),
	InvocationType: targets.StateMachineInvocationType_FIRE_AND_FORGET,
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: pipeTarget,
})

Amazon SNS Topic

An SNS topic can be used as a target for a pipe. The topic will receive the (enriched/filtered) source payload.

declare const sourceQueue: sqs.Queue;
declare const targetTopic: sns.Topic;

const pipeTarget = new targets.SnsTarget(targetTopic);

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: pipeTarget
});

# source_queue: sqs.Queue
# target_topic: sns.Topic


pipe_target = targets.SnsTarget(target_topic)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=pipe_target
)

Queue sourceQueue;
Topic targetTopic;


SnsTarget pipeTarget = new SnsTarget(targetTopic);

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(pipeTarget)
        .build();

Queue sourceQueue;
Topic targetTopic;


var pipeTarget = new SnsTarget(targetTopic);

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = pipeTarget
});

var sourceQueue Queue
var targetTopic Topic


pipeTarget := targets.NewSnsTarget(targetTopic)

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: pipeTarget,
})

The target input can be transformed:

declare const sourceQueue: sqs.Queue;
declare const targetTopic: sns.Topic;

const pipeTarget = new targets.SnsTarget(targetTopic,
    {
      inputTransformation: pipes.InputTransformation.fromObject(
        {
            "SomeKey": pipes.DynamicInput.fromEventPath('$.body')
        })
    }
);

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: pipeTarget
});

# source_queue: sqs.Queue
# target_topic: sns.Topic


pipe_target = targets.SnsTarget(target_topic,
    input_transformation=pipes.InputTransformation.from_object({
        "SomeKey": pipes.DynamicInput.from_event_path("$.body")
    })
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=pipe_target
)

Queue sourceQueue;
Topic targetTopic;


SnsTarget pipeTarget = SnsTarget.Builder.create(targetTopic)
        .inputTransformation(InputTransformation.fromObject(Map.of(
                "SomeKey", DynamicInput.fromEventPath("$.body"))))
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(pipeTarget)
        .build();

Queue sourceQueue;
Topic targetTopic;


var pipeTarget = new SnsTarget(targetTopic, new SnsTargetParameters {
    InputTransformation = InputTransformation.FromObject(new Dictionary<string, object> {
        { "SomeKey", DynamicInput.FromEventPath("$.body") }
    })
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = pipeTarget
});

var sourceQueue Queue
var targetTopic Topic


pipeTarget := targets.NewSnsTarget(targetTopic, &SnsTargetParameters{
	InputTransformation: pipes.InputTransformation_FromObject(map[string]interface{}{
		"SomeKey": pipes.DynamicInput_fromEventPath(jsii.String("$.body")),
	}),
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: pipeTarget,
})

Amazon SQS Queue

An SQS queue can be used as a target for a pipe. The queue will receive the (enriched/filtered) source payload.

declare const sourceQueue: sqs.Queue;
declare const targetQueue: sqs.Queue;

const pipeTarget = new targets.SqsTarget(targetQueue);

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: pipeTarget
});

# source_queue: sqs.Queue
# target_queue: sqs.Queue


pipe_target = targets.SqsTarget(target_queue)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=pipe_target
)

Queue sourceQueue;
Queue targetQueue;


SqsTarget pipeTarget = new SqsTarget(targetQueue);

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(pipeTarget)
        .build();

Queue sourceQueue;
Queue targetQueue;


var pipeTarget = new SqsTarget(targetQueue);

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = pipeTarget
});

var sourceQueue Queue
var targetQueue Queue


pipeTarget := targets.NewSqsTarget(targetQueue)

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: pipeTarget,
})

The target input can be transformed:

declare const sourceQueue: sqs.Queue;
declare const targetQueue: sqs.Queue;

const pipeTarget = new targets.SqsTarget(targetQueue,
    {
      inputTransformation: pipes.InputTransformation.fromObject(
        {
            "SomeKey": pipes.DynamicInput.fromEventPath('$.body')
        })
    }
);

const pipe = new pipes.Pipe(this, 'Pipe', {
    source: new SqsSource(sourceQueue),
    target: pipeTarget
});

# source_queue: sqs.Queue
# target_queue: sqs.Queue


pipe_target = targets.SqsTarget(target_queue,
    input_transformation=pipes.InputTransformation.from_object({
        "SomeKey": pipes.DynamicInput.from_event_path("$.body")
    })
)

pipe = pipes.Pipe(self, "Pipe",
    source=SqsSource(source_queue),
    target=pipe_target
)

Queue sourceQueue;
Queue targetQueue;


SqsTarget pipeTarget = SqsTarget.Builder.create(targetQueue)
        .inputTransformation(InputTransformation.fromObject(Map.of(
                "SomeKey", DynamicInput.fromEventPath("$.body"))))
        .build();

Pipe pipe = Pipe.Builder.create(this, "Pipe")
        .source(new SqsSource(sourceQueue))
        .target(pipeTarget)
        .build();

Queue sourceQueue;
Queue targetQueue;


var pipeTarget = new SqsTarget(targetQueue, new SqsTargetParameters {
    InputTransformation = InputTransformation.FromObject(new Dictionary<string, object> {
        { "SomeKey", DynamicInput.FromEventPath("$.body") }
    })
});

var pipe = new Pipe(this, "Pipe", new PipeProps {
    Source = new SqsSource(sourceQueue),
    Target = pipeTarget
});

var sourceQueue Queue
var targetQueue Queue


pipeTarget := targets.NewSqsTarget(targetQueue, &SqsTargetParameters{
	InputTransformation: pipes.InputTransformation_FromObject(map[string]interface{}{
		"SomeKey": pipes.DynamicInput_fromEventPath(jsii.String("$.body")),
	}),
})

pipe := pipes.NewPipe(this, jsii.String("Pipe"), &PipeProps{
	Source: awscdkpipessourcesalpha.NewSqsSource(sourceQueue),
	Target: pipeTarget,
})

Types

Name	Kind	Summary
ApiDestinationTarget	Class	An EventBridge Pipes target that sends messages to an EventBridge API destination.
ApiDestinationTargetParameters	Struct	EventBridge API destination target properties.
ApiGatewayTarget	Class	An EventBridge Pipes target that sends messages to an EventBridge API destination.
ApiGatewayTargetParameters	Struct	API Gateway REST API target properties.
CloudWatchLogsTarget	Class	An EventBridge Pipes target that sends messages to a CloudWatch Logs log group.
CloudWatchLogsTargetParameters	Struct	CloudWatch Logs target properties.
EventBridgeTarget	Class	An EventBridge Pipes target that sends messages to an EventBridge event bus.
EventBridgeTargetParameters	Struct	EventBridge target properties.
FirehoseTarget	Class	An EventBridge Pipes target that sends messages to an Amazon Data Firehose delivery stream.
FirehoseTargetParameters	Struct	Amazon Data Firehose target properties.
KinesisTarget	Class	An EventBridge Pipes target that sends messages to a Kinesis stream.
KinesisTargetParameters	Struct	Kinesis target properties.
LambdaFunction	Class	An EventBridge Pipes target that sends messages to an AWS Lambda Function.
LambdaFunctionInvocationType	Enum	InvocationType for invoking the Lambda Function.
LambdaFunctionParameters	Struct	Parameters for the LambdaFunction target.
SageMakerTarget	Class	An EventBridge Pipes target that sends messages to a SageMaker pipeline.
SageMakerTargetParameters	Struct	SageMaker target properties.
SfnStateMachine	Class	An EventBridge Pipes target that sends messages to an AWS Step Functions State Machine.
SfnStateMachineParameters	Struct	Parameters for the SfnStateMachine target.
SnsTarget	Class	A EventBridge Pipes target that sends messages to an SNS topic.
SnsTargetParameters	Struct	SNS target properties.
SqsTarget	Class	A EventBridge Pipes target that sends messages to an SQS queue.
SqsTargetParameters	Struct	SQS target properties.
StateMachineInvocationType	Enum	InvocationType for invoking the State Machine.