The aws:lambda/functionEventInvokeConfig:FunctionEventInvokeConfig resource, part of the Pulumi AWS provider, configures error handling and destination routing for asynchronous Lambda function invocations. This guide focuses on three capabilities: retry limits and event expiration, destination routing to SQS, SNS, EventBridge, and S3, and alias-specific configuration.
Event invoke configs reference Lambda functions and destination resources that must exist separately. The Lambda execution role needs permissions to write to configured destinations (sqs:SendMessage, sns:Publish, events:PutEvents, s3:PutObject). The examples are intentionally small. Combine them with your own Lambda functions and destination infrastructure.
Configure retry behavior without destinations
Many functions need custom retry logic without routing events elsewhere. Setting retry limits and event age controls how Lambda handles transient failures.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.lambda.FunctionEventInvokeConfig("example", {
functionName: exampleAwsLambdaFunction.functionName,
maximumEventAgeInSeconds: 60,
maximumRetryAttempts: 0,
});
import pulumi
import pulumi_aws as aws
example = aws.lambda_.FunctionEventInvokeConfig("example",
function_name=example_aws_lambda_function["functionName"],
maximum_event_age_in_seconds=60,
maximum_retry_attempts=0)
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lambda"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := lambda.NewFunctionEventInvokeConfig(ctx, "example", &lambda.FunctionEventInvokeConfigArgs{
FunctionName: pulumi.Any(exampleAwsLambdaFunction.FunctionName),
MaximumEventAgeInSeconds: pulumi.Int(60),
MaximumRetryAttempts: pulumi.Int(0),
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Lambda.FunctionEventInvokeConfig("example", new()
{
FunctionName = exampleAwsLambdaFunction.FunctionName,
MaximumEventAgeInSeconds = 60,
MaximumRetryAttempts = 0,
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.FunctionEventInvokeConfig;
import com.pulumi.aws.lambda.FunctionEventInvokeConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new FunctionEventInvokeConfig("example", FunctionEventInvokeConfigArgs.builder()
.functionName(exampleAwsLambdaFunction.functionName())
.maximumEventAgeInSeconds(60)
.maximumRetryAttempts(0)
.build());
}
}
resources:
example:
type: aws:lambda:FunctionEventInvokeConfig
properties:
functionName: ${exampleAwsLambdaFunction.functionName}
maximumEventAgeInSeconds: 60 # 1 minute - fail fast
maximumRetryAttempts: 0 # No retries
When an asynchronous invocation fails, Lambda retries based on maximumRetryAttempts (0 to 2, defaults to 2). The maximumEventAgeInSeconds property (60 to 21600 seconds) sets how long Lambda keeps retrying before discarding the event. Here, events expire after 60 seconds with no retries.
Route failed and successful events to destinations
Production workflows often need visibility into both failures and successes. Routing failed invocations to a dead letter queue and successful ones to SNS enables monitoring and downstream processing.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
// SQS queue for failed invocations
const dlq = new aws.sqs.Queue("dlq", {
name: "lambda-dlq",
tags: {
Environment: "production",
Purpose: "lambda-error-handling",
},
});
// SNS topic for successful invocations
const success = new aws.sns.Topic("success", {
name: "lambda-success-notifications",
tags: {
Environment: "production",
Purpose: "lambda-success-notifications",
},
});
// Complete event invoke configuration
const example = new aws.lambda.FunctionEventInvokeConfig("example", {
functionName: exampleAwsLambdaFunction.functionName,
maximumEventAgeInSeconds: 300,
maximumRetryAttempts: 1,
destinationConfig: {
onFailure: {
destination: dlq.arn,
},
onSuccess: {
destination: success.arn,
},
},
});
import pulumi
import pulumi_aws as aws
# SQS queue for failed invocations
dlq = aws.sqs.Queue("dlq",
name="lambda-dlq",
tags={
"Environment": "production",
"Purpose": "lambda-error-handling",
})
# SNS topic for successful invocations
success = aws.sns.Topic("success",
name="lambda-success-notifications",
tags={
"Environment": "production",
"Purpose": "lambda-success-notifications",
})
# Complete event invoke configuration
example = aws.lambda_.FunctionEventInvokeConfig("example",
function_name=example_aws_lambda_function["functionName"],
maximum_event_age_in_seconds=300,
maximum_retry_attempts=1,
destination_config={
"on_failure": {
"destination": dlq.arn,
},
"on_success": {
"destination": success.arn,
},
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lambda"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sns"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sqs"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
// SQS queue for failed invocations
dlq, err := sqs.NewQueue(ctx, "dlq", &sqs.QueueArgs{
Name: pulumi.String("lambda-dlq"),
Tags: pulumi.StringMap{
"Environment": pulumi.String("production"),
"Purpose": pulumi.String("lambda-error-handling"),
},
})
if err != nil {
return err
}
// SNS topic for successful invocations
success, err := sns.NewTopic(ctx, "success", &sns.TopicArgs{
Name: pulumi.String("lambda-success-notifications"),
Tags: pulumi.StringMap{
"Environment": pulumi.String("production"),
"Purpose": pulumi.String("lambda-success-notifications"),
},
})
if err != nil {
return err
}
// Complete event invoke configuration
_, err = lambda.NewFunctionEventInvokeConfig(ctx, "example", &lambda.FunctionEventInvokeConfigArgs{
FunctionName: pulumi.Any(exampleAwsLambdaFunction.FunctionName),
MaximumEventAgeInSeconds: pulumi.Int(300),
MaximumRetryAttempts: pulumi.Int(1),
DestinationConfig: &lambda.FunctionEventInvokeConfigDestinationConfigArgs{
OnFailure: &lambda.FunctionEventInvokeConfigDestinationConfigOnFailureArgs{
Destination: dlq.Arn,
},
OnSuccess: &lambda.FunctionEventInvokeConfigDestinationConfigOnSuccessArgs{
Destination: success.Arn,
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
// SQS queue for failed invocations
var dlq = new Aws.Sqs.Queue("dlq", new()
{
Name = "lambda-dlq",
Tags =
{
{ "Environment", "production" },
{ "Purpose", "lambda-error-handling" },
},
});
// SNS topic for successful invocations
var success = new Aws.Sns.Topic("success", new()
{
Name = "lambda-success-notifications",
Tags =
{
{ "Environment", "production" },
{ "Purpose", "lambda-success-notifications" },
},
});
// Complete event invoke configuration
var example = new Aws.Lambda.FunctionEventInvokeConfig("example", new()
{
FunctionName = exampleAwsLambdaFunction.FunctionName,
MaximumEventAgeInSeconds = 300,
MaximumRetryAttempts = 1,
DestinationConfig = new Aws.Lambda.Inputs.FunctionEventInvokeConfigDestinationConfigArgs
{
OnFailure = new Aws.Lambda.Inputs.FunctionEventInvokeConfigDestinationConfigOnFailureArgs
{
Destination = dlq.Arn,
},
OnSuccess = new Aws.Lambda.Inputs.FunctionEventInvokeConfigDestinationConfigOnSuccessArgs
{
Destination = success.Arn,
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.sqs.Queue;
import com.pulumi.aws.sqs.QueueArgs;
import com.pulumi.aws.sns.Topic;
import com.pulumi.aws.sns.TopicArgs;
import com.pulumi.aws.lambda.FunctionEventInvokeConfig;
import com.pulumi.aws.lambda.FunctionEventInvokeConfigArgs;
import com.pulumi.aws.lambda.inputs.FunctionEventInvokeConfigDestinationConfigArgs;
import com.pulumi.aws.lambda.inputs.FunctionEventInvokeConfigDestinationConfigOnFailureArgs;
import com.pulumi.aws.lambda.inputs.FunctionEventInvokeConfigDestinationConfigOnSuccessArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
// SQS queue for failed invocations
var dlq = new Queue("dlq", QueueArgs.builder()
.name("lambda-dlq")
.tags(Map.ofEntries(
Map.entry("Environment", "production"),
Map.entry("Purpose", "lambda-error-handling")
))
.build());
// SNS topic for successful invocations
var success = new Topic("success", TopicArgs.builder()
.name("lambda-success-notifications")
.tags(Map.ofEntries(
Map.entry("Environment", "production"),
Map.entry("Purpose", "lambda-success-notifications")
))
.build());
// Complete event invoke configuration
var example = new FunctionEventInvokeConfig("example", FunctionEventInvokeConfigArgs.builder()
.functionName(exampleAwsLambdaFunction.functionName())
.maximumEventAgeInSeconds(300)
.maximumRetryAttempts(1)
.destinationConfig(FunctionEventInvokeConfigDestinationConfigArgs.builder()
.onFailure(FunctionEventInvokeConfigDestinationConfigOnFailureArgs.builder()
.destination(dlq.arn())
.build())
.onSuccess(FunctionEventInvokeConfigDestinationConfigOnSuccessArgs.builder()
.destination(success.arn())
.build())
.build())
.build());
}
}
resources:
# SQS queue for failed invocations
dlq:
type: aws:sqs:Queue
properties:
name: lambda-dlq
tags:
Environment: production
Purpose: lambda-error-handling
# SNS topic for successful invocations
success:
type: aws:sns:Topic
properties:
name: lambda-success-notifications
tags:
Environment: production
Purpose: lambda-success-notifications
# Complete event invoke configuration
example:
type: aws:lambda:FunctionEventInvokeConfig
properties:
functionName: ${exampleAwsLambdaFunction.functionName}
maximumEventAgeInSeconds: 300 # 5 minutes
maximumRetryAttempts: 1 # Retry once on failure
destinationConfig:
onFailure:
destination: ${dlq.arn}
onSuccess:
destination: ${success.arn}
The destinationConfig block defines where Lambda sends events after all retries. The onFailure destination receives events that exhausted retries or exceeded the maximum age. The onSuccess destination receives events that completed successfully. Lambda writes to these destinations automatically; your execution role needs the appropriate permissions (sqs:SendMessage for SQS, sns:Publish for SNS).
Send events to EventBridge and S3
Some architectures route failures to EventBridge for complex event processing while archiving successful payloads to S3 for audit or analytics.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
// S3 bucket for archiving successful events
const lambdaSuccessArchive = new aws.s3.Bucket("lambda_success_archive", {bucket: `lambda-success-archive-${bucketSuffix.hex}`});
// EventBridge custom bus for failed events
const lambdaFailures = new aws.cloudwatch.EventBus("lambda_failures", {name: "lambda-failure-events"});
const example = new aws.lambda.FunctionEventInvokeConfig("example", {
functionName: exampleAwsLambdaFunction.functionName,
destinationConfig: {
onFailure: {
destination: lambdaFailures.arn,
},
onSuccess: {
destination: lambdaSuccessArchive.arn,
},
},
});
import pulumi
import pulumi_aws as aws
# S3 bucket for archiving successful events
lambda_success_archive = aws.s3.Bucket("lambda_success_archive", bucket=f"lambda-success-archive-{bucket_suffix['hex']}")
# EventBridge custom bus for failed events
lambda_failures = aws.cloudwatch.EventBus("lambda_failures", name="lambda-failure-events")
example = aws.lambda_.FunctionEventInvokeConfig("example",
function_name=example_aws_lambda_function["functionName"],
destination_config={
"on_failure": {
"destination": lambda_failures.arn,
},
"on_success": {
"destination": lambda_success_archive.arn,
},
})
package main
import (
"fmt"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lambda"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
// S3 bucket for archiving successful events
lambdaSuccessArchive, err := s3.NewBucket(ctx, "lambda_success_archive", &s3.BucketArgs{
Bucket: pulumi.Sprintf("lambda-success-archive-%v", bucketSuffix.Hex),
})
if err != nil {
return err
}
// EventBridge custom bus for failed events
lambdaFailures, err := cloudwatch.NewEventBus(ctx, "lambda_failures", &cloudwatch.EventBusArgs{
Name: pulumi.String("lambda-failure-events"),
})
if err != nil {
return err
}
_, err = lambda.NewFunctionEventInvokeConfig(ctx, "example", &lambda.FunctionEventInvokeConfigArgs{
FunctionName: pulumi.Any(exampleAwsLambdaFunction.FunctionName),
DestinationConfig: &lambda.FunctionEventInvokeConfigDestinationConfigArgs{
OnFailure: &lambda.FunctionEventInvokeConfigDestinationConfigOnFailureArgs{
Destination: lambdaFailures.Arn,
},
OnSuccess: &lambda.FunctionEventInvokeConfigDestinationConfigOnSuccessArgs{
Destination: lambdaSuccessArchive.Arn,
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
// S3 bucket for archiving successful events
var lambdaSuccessArchive = new Aws.S3.Bucket("lambda_success_archive", new()
{
BucketName = $"lambda-success-archive-{bucketSuffix.Hex}",
});
// EventBridge custom bus for failed events
var lambdaFailures = new Aws.CloudWatch.EventBus("lambda_failures", new()
{
Name = "lambda-failure-events",
});
var example = new Aws.Lambda.FunctionEventInvokeConfig("example", new()
{
FunctionName = exampleAwsLambdaFunction.FunctionName,
DestinationConfig = new Aws.Lambda.Inputs.FunctionEventInvokeConfigDestinationConfigArgs
{
OnFailure = new Aws.Lambda.Inputs.FunctionEventInvokeConfigDestinationConfigOnFailureArgs
{
Destination = lambdaFailures.Arn,
},
OnSuccess = new Aws.Lambda.Inputs.FunctionEventInvokeConfigDestinationConfigOnSuccessArgs
{
Destination = lambdaSuccessArchive.Arn,
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.Bucket;
import com.pulumi.aws.s3.BucketArgs;
import com.pulumi.aws.cloudwatch.EventBus;
import com.pulumi.aws.cloudwatch.EventBusArgs;
import com.pulumi.aws.lambda.FunctionEventInvokeConfig;
import com.pulumi.aws.lambda.FunctionEventInvokeConfigArgs;
import com.pulumi.aws.lambda.inputs.FunctionEventInvokeConfigDestinationConfigArgs;
import com.pulumi.aws.lambda.inputs.FunctionEventInvokeConfigDestinationConfigOnFailureArgs;
import com.pulumi.aws.lambda.inputs.FunctionEventInvokeConfigDestinationConfigOnSuccessArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
// S3 bucket for archiving successful events
var lambdaSuccessArchive = new Bucket("lambdaSuccessArchive", BucketArgs.builder()
.bucket(String.format("lambda-success-archive-%s", bucketSuffix.hex()))
.build());
// EventBridge custom bus for failed events
var lambdaFailures = new EventBus("lambdaFailures", EventBusArgs.builder()
.name("lambda-failure-events")
.build());
var example = new FunctionEventInvokeConfig("example", FunctionEventInvokeConfigArgs.builder()
.functionName(exampleAwsLambdaFunction.functionName())
.destinationConfig(FunctionEventInvokeConfigDestinationConfigArgs.builder()
.onFailure(FunctionEventInvokeConfigDestinationConfigOnFailureArgs.builder()
.destination(lambdaFailures.arn())
.build())
.onSuccess(FunctionEventInvokeConfigDestinationConfigOnSuccessArgs.builder()
.destination(lambdaSuccessArchive.arn())
.build())
.build())
.build());
}
}
resources:
# S3 bucket for archiving successful events
lambdaSuccessArchive:
type: aws:s3:Bucket
name: lambda_success_archive
properties:
bucket: lambda-success-archive-${bucketSuffix.hex}
# EventBridge custom bus for failed events
lambdaFailures:
type: aws:cloudwatch:EventBus
name: lambda_failures
properties:
name: lambda-failure-events
example:
type: aws:lambda:FunctionEventInvokeConfig
properties:
functionName: ${exampleAwsLambdaFunction.functionName}
destinationConfig:
onFailure:
destination: ${lambdaFailures.arn}
onSuccess:
destination: ${lambdaSuccessArchive.arn}
Destinations support SQS queues, SNS topics, EventBridge buses, and S3 buckets. EventBridge destinations enable routing to multiple targets via rules. S3 destinations archive the full event payload as an object. The Lambda execution role needs events:PutEvents for EventBridge and s3:PutObject for S3.
Configure retry behavior for a Lambda alias
Teams using aliases to manage traffic between versions can apply different retry and destination settings per alias.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.lambda.Alias("example", {
name: "production",
description: "Production alias",
functionName: exampleAwsLambdaFunction.functionName,
functionVersion: exampleAwsLambdaFunction.version,
});
const exampleFunctionEventInvokeConfig = new aws.lambda.FunctionEventInvokeConfig("example", {
functionName: exampleAwsLambdaFunction.functionName,
qualifier: example.name,
maximumEventAgeInSeconds: 1800,
maximumRetryAttempts: 2,
destinationConfig: {
onFailure: {
destination: productionDlq.arn,
},
},
});
import pulumi
import pulumi_aws as aws
example = aws.lambda_.Alias("example",
name="production",
description="Production alias",
function_name=example_aws_lambda_function["functionName"],
function_version=example_aws_lambda_function["version"])
example_function_event_invoke_config = aws.lambda_.FunctionEventInvokeConfig("example",
function_name=example_aws_lambda_function["functionName"],
qualifier=example.name,
maximum_event_age_in_seconds=1800,
maximum_retry_attempts=2,
destination_config={
"on_failure": {
"destination": production_dlq["arn"],
},
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lambda"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
example, err := lambda.NewAlias(ctx, "example", &lambda.AliasArgs{
Name: pulumi.String("production"),
Description: pulumi.String("Production alias"),
FunctionName: pulumi.Any(exampleAwsLambdaFunction.FunctionName),
FunctionVersion: pulumi.Any(exampleAwsLambdaFunction.Version),
})
if err != nil {
return err
}
_, err = lambda.NewFunctionEventInvokeConfig(ctx, "example", &lambda.FunctionEventInvokeConfigArgs{
FunctionName: pulumi.Any(exampleAwsLambdaFunction.FunctionName),
Qualifier: example.Name,
MaximumEventAgeInSeconds: pulumi.Int(1800),
MaximumRetryAttempts: pulumi.Int(2),
DestinationConfig: &lambda.FunctionEventInvokeConfigDestinationConfigArgs{
OnFailure: &lambda.FunctionEventInvokeConfigDestinationConfigOnFailureArgs{
Destination: pulumi.Any(productionDlq.Arn),
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Lambda.Alias("example", new()
{
Name = "production",
Description = "Production alias",
FunctionName = exampleAwsLambdaFunction.FunctionName,
FunctionVersion = exampleAwsLambdaFunction.Version,
});
var exampleFunctionEventInvokeConfig = new Aws.Lambda.FunctionEventInvokeConfig("example", new()
{
FunctionName = exampleAwsLambdaFunction.FunctionName,
Qualifier = example.Name,
MaximumEventAgeInSeconds = 1800,
MaximumRetryAttempts = 2,
DestinationConfig = new Aws.Lambda.Inputs.FunctionEventInvokeConfigDestinationConfigArgs
{
OnFailure = new Aws.Lambda.Inputs.FunctionEventInvokeConfigDestinationConfigOnFailureArgs
{
Destination = productionDlq.Arn,
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.Alias;
import com.pulumi.aws.lambda.AliasArgs;
import com.pulumi.aws.lambda.FunctionEventInvokeConfig;
import com.pulumi.aws.lambda.FunctionEventInvokeConfigArgs;
import com.pulumi.aws.lambda.inputs.FunctionEventInvokeConfigDestinationConfigArgs;
import com.pulumi.aws.lambda.inputs.FunctionEventInvokeConfigDestinationConfigOnFailureArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Alias("example", AliasArgs.builder()
.name("production")
.description("Production alias")
.functionName(exampleAwsLambdaFunction.functionName())
.functionVersion(exampleAwsLambdaFunction.version())
.build());
var exampleFunctionEventInvokeConfig = new FunctionEventInvokeConfig("exampleFunctionEventInvokeConfig", FunctionEventInvokeConfigArgs.builder()
.functionName(exampleAwsLambdaFunction.functionName())
.qualifier(example.name())
.maximumEventAgeInSeconds(1800)
.maximumRetryAttempts(2)
.destinationConfig(FunctionEventInvokeConfigDestinationConfigArgs.builder()
.onFailure(FunctionEventInvokeConfigDestinationConfigOnFailureArgs.builder()
.destination(productionDlq.arn())
.build())
.build())
.build());
}
}
resources:
example:
type: aws:lambda:Alias
properties:
name: production
description: Production alias
functionName: ${exampleAwsLambdaFunction.functionName}
functionVersion: ${exampleAwsLambdaFunction.version}
exampleFunctionEventInvokeConfig:
type: aws:lambda:FunctionEventInvokeConfig
name: example
properties:
functionName: ${exampleAwsLambdaFunction.functionName}
qualifier: ${example.name}
maximumEventAgeInSeconds: 1800 # 30 minutes for production
maximumRetryAttempts: 2 # Default retry behavior
destinationConfig:
onFailure:
destination: ${productionDlq.arn}
The qualifier property targets a specific alias or version. Without a qualifier, the configuration applies to all invocations. With an alias qualifier, you can set production-specific retry limits and destinations while using different settings for staging or development aliases.
Beyond these examples
These snippets focus on specific event invoke config features: retry limits and event age controls, destination routing (SQS, SNS, EventBridge, S3), and alias and version-specific configuration. They’re intentionally minimal rather than full error handling solutions.
The examples reference pre-existing infrastructure such as Lambda functions with execution roles, SQS queues, SNS topics, EventBridge buses, S3 buckets for destinations, and IAM permissions for destination access (sqs:SendMessage, sns:Publish, events:PutEvents, s3:PutObject). They focus on configuring the invoke behavior rather than provisioning the Lambda function or destinations.
To keep things focused, common invoke config patterns are omitted, including:
- Version-specific configuration (qualifier with version number)
- $LATEST qualifier for development environments
- Combining multiple destination types in complex workflows
These omissions are intentional: the goal is to illustrate how each invoke config feature is wired, not provide drop-in error handling modules. See the Lambda FunctionEventInvokeConfig resource reference for all available configuration options.
Let's configure AWS Lambda Function Event Invoke Settings
Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.
Try Pulumi Cloud for FREEFrequently Asked Questions
Common Issues
Why am I getting InvalidParameterValueException when setting a destination?
This generic error occurs when your Lambda function’s IAM role lacks necessary permissions for the destination service. Ensure the role includes permissions like
sqs:SendMessage for SQS queues or sns:Publish for SNS topics.Destinations & Error Handling
What destination types can I use for Lambda invocation results?
You can use SQS queues, SNS topics, S3 buckets, and EventBridge event buses as destinations for both successful and failed invocations.
Can I configure retry behavior without setting up destinations?
Yes, you can configure
maximumEventAgeInSeconds and maximumRetryAttempts without including a destinationConfig block.Can I send successful and failed invocations to different destinations?
Yes, configure
destinationConfig.onSuccess and destinationConfig.onFailure with different destination ARNs to route results separately.Retry & Timeout Configuration
What are the limits for retry attempts and event age?
maximumRetryAttempts accepts values between 0 and 2 (defaults to 2). maximumEventAgeInSeconds accepts values between 60 and 21600 seconds (1 minute to 6 hours).Versioning & Configuration Scope
How do I configure different settings for specific versions or aliases?
Use the
qualifier property to specify a published version number, alias name, or $LATEST to apply configuration to that specific version or alias.What properties can't I change after creating the configuration?
Both
functionName and qualifier are immutable and cannot be changed after the resource is created.Using a different cloud?
Explore serverless guides for other cloud providers: