pulumi-aws-kotlin/com.pulumi.aws.lambda.kotlin/FunctionEventInvokeConfig

FunctionEventInvokeConfig

class FunctionEventInvokeConfig : KotlinCustomResource

Manages an asynchronous invocation configuration for a Lambda Function or Alias. More information about asynchronous invocations and the configurable values can be found in the Lambda Developer Guide.

Example Usage

Destination Configuration

NOTE: Ensure the Lambda Function IAM Role has necessary permissions for the destination, such as sqs:SendMessage or sns:Publish, otherwise the API will return a generic InvalidParameterValueException: The destination ARN arn:PARTITION:SERVICE:REGION:ACCOUNT:RESOURCE is invalid. error.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.lambda.FunctionEventInvokeConfig("example", {
    functionName: exampleAwsLambdaAlias.functionName,
    destinationConfig: {
        onFailure: {
            destination: exampleAwsSqsQueue.arn,
        },
        onSuccess: {
            destination: exampleAwsSnsTopic.arn,
        },
    },
});

import pulumi
import pulumi_aws as aws
example = aws.lambda_.FunctionEventInvokeConfig("example",
    function_name=example_aws_lambda_alias["functionName"],
    destination_config={
        "on_failure": {
            "destination": example_aws_sqs_queue["arn"],
        },
        "on_success": {
            "destination": example_aws_sns_topic["arn"],
        },
    })

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 = exampleAwsLambdaAlias.FunctionName,
        DestinationConfig = new Aws.Lambda.Inputs.FunctionEventInvokeConfigDestinationConfigArgs
        {
            OnFailure = new Aws.Lambda.Inputs.FunctionEventInvokeConfigDestinationConfigOnFailureArgs
            {
                Destination = exampleAwsSqsQueue.Arn,
            },
            OnSuccess = new Aws.Lambda.Inputs.FunctionEventInvokeConfigDestinationConfigOnSuccessArgs
            {
                Destination = exampleAwsSnsTopic.Arn,
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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(exampleAwsLambdaAlias.FunctionName),
			DestinationConfig: &lambda.FunctionEventInvokeConfigDestinationConfigArgs{
				OnFailure: &lambda.FunctionEventInvokeConfigDestinationConfigOnFailureArgs{
					Destination: pulumi.Any(exampleAwsSqsQueue.Arn),
				},
				OnSuccess: &lambda.FunctionEventInvokeConfigDestinationConfigOnSuccessArgs{
					Destination: pulumi.Any(exampleAwsSnsTopic.Arn),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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 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) {
        var example = new FunctionEventInvokeConfig("example", FunctionEventInvokeConfigArgs.builder()
            .functionName(exampleAwsLambdaAlias.functionName())
            .destinationConfig(FunctionEventInvokeConfigDestinationConfigArgs.builder()
                .onFailure(FunctionEventInvokeConfigDestinationConfigOnFailureArgs.builder()
                    .destination(exampleAwsSqsQueue.arn())
                    .build())
                .onSuccess(FunctionEventInvokeConfigDestinationConfigOnSuccessArgs.builder()
                    .destination(exampleAwsSnsTopic.arn())
                    .build())
                .build())
            .build());
    }
}

resources:
  example:
    type: aws:lambda:FunctionEventInvokeConfig
    properties:
      functionName: ${exampleAwsLambdaAlias.functionName}
      destinationConfig:
        onFailure:
          destination: ${exampleAwsSqsQueue.arn}
        onSuccess:
          destination: ${exampleAwsSnsTopic.arn}

Error Handling Configuration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.lambda.FunctionEventInvokeConfig("example", {
    functionName: exampleAwsLambdaAlias.functionName,
    maximumEventAgeInSeconds: 60,
    maximumRetryAttempts: 0,
});

import pulumi
import pulumi_aws as aws
example = aws.lambda_.FunctionEventInvokeConfig("example",
    function_name=example_aws_lambda_alias["functionName"],
    maximum_event_age_in_seconds=60,
    maximum_retry_attempts=0)

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 = exampleAwsLambdaAlias.FunctionName,
        MaximumEventAgeInSeconds = 60,
        MaximumRetryAttempts = 0,
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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(exampleAwsLambdaAlias.FunctionName),
			MaximumEventAgeInSeconds: pulumi.Int(60),
			MaximumRetryAttempts:     pulumi.Int(0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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(exampleAwsLambdaAlias.functionName())
            .maximumEventAgeInSeconds(60)
            .maximumRetryAttempts(0)
            .build());
    }
}

resources:
  example:
    type: aws:lambda:FunctionEventInvokeConfig
    properties:
      functionName: ${exampleAwsLambdaAlias.functionName}
      maximumEventAgeInSeconds: 60
      maximumRetryAttempts: 0

Configuration for Alias Name

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.lambda.FunctionEventInvokeConfig("example", {
    functionName: exampleAwsLambdaAlias.functionName,
    qualifier: exampleAwsLambdaAlias.name,
});

import pulumi
import pulumi_aws as aws
example = aws.lambda_.FunctionEventInvokeConfig("example",
    function_name=example_aws_lambda_alias["functionName"],
    qualifier=example_aws_lambda_alias["name"])

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 = exampleAwsLambdaAlias.FunctionName,
        Qualifier = exampleAwsLambdaAlias.Name,
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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(exampleAwsLambdaAlias.FunctionName),
			Qualifier:    pulumi.Any(exampleAwsLambdaAlias.Name),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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(exampleAwsLambdaAlias.functionName())
            .qualifier(exampleAwsLambdaAlias.name())
            .build());
    }
}

resources:
  example:
    type: aws:lambda:FunctionEventInvokeConfig
    properties:
      functionName: ${exampleAwsLambdaAlias.functionName}
      qualifier: ${exampleAwsLambdaAlias.name}

Configuration for Function Latest Unpublished Version

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.lambda.FunctionEventInvokeConfig("example", {
    functionName: exampleAwsLambdaFunction.functionName,
    qualifier: "$LATEST",
});

import pulumi
import pulumi_aws as aws
example = aws.lambda_.FunctionEventInvokeConfig("example",
    function_name=example_aws_lambda_function["functionName"],
    qualifier="$LATEST")

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,
        Qualifier = "$LATEST",
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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),
			Qualifier:    pulumi.String("$LATEST"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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())
            .qualifier("$LATEST")
            .build());
    }
}

resources:
  example:
    type: aws:lambda:FunctionEventInvokeConfig
    properties:
      functionName: ${exampleAwsLambdaFunction.functionName}
      qualifier: $LATEST

Configuration for Function Published Version

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.lambda.FunctionEventInvokeConfig("example", {
    functionName: exampleAwsLambdaFunction.functionName,
    qualifier: exampleAwsLambdaFunction.version,
});

import pulumi
import pulumi_aws as aws
example = aws.lambda_.FunctionEventInvokeConfig("example",
    function_name=example_aws_lambda_function["functionName"],
    qualifier=example_aws_lambda_function["version"])

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,
        Qualifier = exampleAwsLambdaFunction.Version,
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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),
			Qualifier:    pulumi.Any(exampleAwsLambdaFunction.Version),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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())
            .qualifier(exampleAwsLambdaFunction.version())
            .build());
    }
}

resources:
  example:
    type: aws:lambda:FunctionEventInvokeConfig
    properties:
      functionName: ${exampleAwsLambdaFunction.functionName}
      qualifier: ${exampleAwsLambdaFunction.version}

Import

ARN with qualifier: Name without qualifier (all versions and aliases): Name with qualifier: Using pulumi import to import Lambda Function Event Invoke Configs using the fully qualified Function name or Amazon Resource Name (ARN). For example: ARN without qualifier (all versions and aliases):

$ pulumi import aws:lambda/functionEventInvokeConfig:FunctionEventInvokeConfig example arn:aws:us-east-1:123456789012:function:my_function

ARN with qualifier:

$ pulumi import aws:lambda/functionEventInvokeConfig:FunctionEventInvokeConfig example arn:aws:us-east-1:123456789012:function:my_function:production

Name without qualifier (all versions and aliases):

$ pulumi import aws:lambda/functionEventInvokeConfig:FunctionEventInvokeConfig example my_function

Name with qualifier:

$ pulumi import aws:lambda/functionEventInvokeConfig:FunctionEventInvokeConfig example my_function:production

Properties

destinationConfig

val destinationConfig: Output<FunctionEventInvokeConfigDestinationConfig>?

Configuration block with destination configuration. See below for details.

functionName

val functionName: Output<String>

Name or Amazon Resource Name (ARN) of the Lambda Function, omitting any version or alias qualifier. The following arguments are optional:

val id: Output<String>

maximumEventAgeInSeconds

val maximumEventAgeInSeconds: Output<Int>?

Maximum age of a request that Lambda sends to a function for processing in seconds. Valid values between 60 and 21600.

maximumRetryAttempts

val maximumRetryAttempts: Output<Int>?

Maximum number of times to retry when the function returns an error. Valid values between 0 and 2. Defaults to 2.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

qualifier

val qualifier: Output<String>?

Lambda Function published version, $LATEST, or Lambda Alias name.

urn

val urn: Output<String>