getLayerVersion function

Future<GetLayerVersionResult> getLayerVersion(
  1. GetLayerVersionArgs args, {
  2. InvokeOptions? options,
})

Provides details about an AWS Lambda Layer Version. Use this data source to retrieve information about a specific layer version or find the latest version compatible with your runtime and architecture requirements.

Example Usage

Get Latest Layer Version

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = aws.lambda.getLayerVersion({
    layerName: "my-shared-utilities",
});
// Use the layer in a Lambda function
const exampleFunction = new aws.lambda.Function("example", {
    code: new pulumi.asset.FileArchive("function.zip"),
    name: "example_function",
    role: lambdaRole.arn,
    handler: "index.handler",
    runtime: aws.lambda.Runtime.NodeJS24dX,
    layers: [example.then(example => example.arn)],
});

import pulumi
import pulumi_aws as aws

example = aws.lambda_.get_layer_version(layer_name="my-shared-utilities")
# Use the layer in a Lambda function
example_function = aws.lambda_.Function("example",
    code=pulumi.FileArchive("function.zip"),
    name="example_function",
    role=lambda_role["arn"],
    handler="index.handler",
    runtime=aws.lambda_.Runtime.NODE_JS24D_X,
    layers=[example.arn])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = Aws.Lambda.GetLayerVersion.Invoke(new()
    {
        LayerName = "my-shared-utilities",
    });

    // Use the layer in a Lambda function
    var exampleFunction = new Aws.Lambda.Function("example", new()
    {
        Code = new FileArchive("function.zip"),
        Name = "example_function",
        Role = lambdaRole.Arn,
        Handler = "index.handler",
        Runtime = Aws.Lambda.Runtime.NodeJS24dX,
        Layers = new[]
        {
            example.Apply(getLayerVersionResult => getLayerVersionResult.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.LookupLayerVersion(ctx, &lambda.LookupLayerVersionArgs{
			LayerName: pulumi.StringRef("my-shared-utilities"),
		}, nil)
		if err != nil {
			return err
		}
		// Use the layer in a Lambda function
		_, err = lambda.NewFunction(ctx, "example", &lambda.FunctionArgs{
			Code:    pulumi.NewFileArchive("function.zip"),
			Name:    pulumi.String("example_function"),
			Role:    pulumi.Any(lambdaRole.Arn),
			Handler: pulumi.String("index.handler"),
			Runtime: pulumi.String(lambda.RuntimeNodeJS24dX),
			Layers: pulumi.StringArray{
				pulumi.String(example.Arn),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lambda_getlayerversion" "example" {
  layer_name = "my-shared-utilities"
}

# Use the layer in a Lambda function
resource "aws_lambda_function" "example" {
  code    = fileArchive("function.zip")
  name    = "example_function"
  role    = lambdaRole.arn
  handler = "index.handler"
  runtime = "nodejs24.x"
  layers  = [data.aws_lambda_getlayerversion.example.arn]
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.LambdaFunctions;
import com.pulumi.aws.lambda.inputs.GetLayerVersionArgs;
import com.pulumi.aws.lambda.Function;
import com.pulumi.aws.lambda.FunctionArgs;
import com.pulumi.asset.FileArchive;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        final var example = LambdaFunctions.getLayerVersion(GetLayerVersionArgs.builder()
            .layerName("my-shared-utilities")
            .build());

        // Use the layer in a Lambda function
        var exampleFunction = new Function("exampleFunction", FunctionArgs.builder()
            .code(new FileArchive("function.zip"))
            .name("example_function")
            .role(lambdaRole.arn())
            .handler("index.handler")
            .runtime("nodejs24.x")
            .layers(example.arn())
            .build());

    }
}

resources:
  # Use the layer in a Lambda function
  exampleFunction:
    type: aws:lambda:Function
    name: example
    properties:
      code:
        fn::fileArchive: function.zip
      name: example_function
      role: ${lambdaRole.arn}
      handler: index.handler
      runtime: nodejs24.x
      layers:
        - ${example.arn}
variables:
  example:
    fn::invoke:
      function: aws:lambda:getLayerVersion
      arguments:
        layerName: my-shared-utilities

Get Specific Layer Version

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = aws.lambda.getLayerVersion({
    layerName: "production-utilities",
    version: 5,
});
export const layerInfo = {
    arn: example.then(example => example.arn),
    version: example.then(example => example.version),
    description: example.then(example => example.description),
};

import pulumi
import pulumi_aws as aws

example = aws.lambda_.get_layer_version(layer_name="production-utilities",
    version=5)
pulumi.export("layerInfo", {
    "arn": example.arn,
    "version": example.version,
    "description": example.description,
})

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = Aws.Lambda.GetLayerVersion.Invoke(new()
    {
        LayerName = "production-utilities",
        Version = 5,
    });

    return new Dictionary<string, object?>
    {
        ["layerInfo"] =
        {
            { "arn", example.Apply(getLayerVersionResult => getLayerVersionResult.Arn) },
            { "version", example.Apply(getLayerVersionResult => getLayerVersionResult.Version) },
            { "description", example.Apply(getLayerVersionResult => getLayerVersionResult.Description) },
        },
    };
});

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.LookupLayerVersion(ctx, &lambda.LookupLayerVersionArgs{
			LayerName: pulumi.StringRef("production-utilities"),
			Version:   pulumi.IntRef(5),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("layerInfo", pulumi.Map{
			"arn":         example.Arn,
			"version":     example.Version,
			"description": example.Description,
		})
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lambda_getlayerversion" "example" {
  layer_name = "production-utilities"
  version    = 5
}

output "layerInfo" {
  value = {
    "arn"         = data.aws_lambda_getlayerversion.example.arn
    "version"     = data.aws_lambda_getlayerversion.example.version
    "description" = data.aws_lambda_getlayerversion.example.description
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.LambdaFunctions;
import com.pulumi.aws.lambda.inputs.GetLayerVersionArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        final var example = LambdaFunctions.getLayerVersion(GetLayerVersionArgs.builder()
            .layerName("production-utilities")
            .version(5)
            .build());

        ctx.export("layerInfo", Map.ofEntries(
            Map.entry("arn", example.arn()),
            Map.entry("version", example.version()),
            Map.entry("description", example.description())
        ));
    }
}

variables:
  example:
    fn::invoke:
      function: aws:lambda:getLayerVersion
      arguments:
        layerName: production-utilities
        version: 5
outputs:
  layerInfo:
    arn: ${example.arn}
    version: ${example.version}
    description: ${example.description}

Get Latest Compatible Layer Version

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

// Find latest layer version compatible with Python 3.12
const pythonLayer = aws.lambda.getLayerVersion({
    layerName: "python-dependencies",
    compatibleRuntime: "python3.12",
});
// Find latest layer version compatible with ARM64 architecture
const armLayer = aws.lambda.getLayerVersion({
    layerName: "optimized-libraries",
    compatibleArchitecture: "arm64",
});
// Use both layers in a function
const example = new aws.lambda.Function("example", {
    code: new pulumi.asset.FileArchive("function.zip"),
    name: "multi_layer_function",
    role: lambdaRole.arn,
    handler: "app.handler",
    runtime: aws.lambda.Runtime.Python3d12,
    architectures: ["arm64"],
    layers: [
        pythonLayer.then(pythonLayer => pythonLayer.arn),
        armLayer.then(armLayer => armLayer.arn),
    ],
});

import pulumi
import pulumi_aws as aws

# Find latest layer version compatible with Python 3.12
python_layer = aws.lambda_.get_layer_version(layer_name="python-dependencies",
    compatible_runtime="python3.12")
# Find latest layer version compatible with ARM64 architecture
arm_layer = aws.lambda_.get_layer_version(layer_name="optimized-libraries",
    compatible_architecture="arm64")
# Use both layers in a function
example = aws.lambda_.Function("example",
    code=pulumi.FileArchive("function.zip"),
    name="multi_layer_function",
    role=lambda_role["arn"],
    handler="app.handler",
    runtime=aws.lambda_.Runtime.PYTHON3D12,
    architectures=["arm64"],
    layers=[
        python_layer.arn,
        arm_layer.arn,
    ])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    // Find latest layer version compatible with Python 3.12
    var pythonLayer = Aws.Lambda.GetLayerVersion.Invoke(new()
    {
        LayerName = "python-dependencies",
        CompatibleRuntime = "python3.12",
    });

    // Find latest layer version compatible with ARM64 architecture
    var armLayer = Aws.Lambda.GetLayerVersion.Invoke(new()
    {
        LayerName = "optimized-libraries",
        CompatibleArchitecture = "arm64",
    });

    // Use both layers in a function
    var example = new Aws.Lambda.Function("example", new()
    {
        Code = new FileArchive("function.zip"),
        Name = "multi_layer_function",
        Role = lambdaRole.Arn,
        Handler = "app.handler",
        Runtime = Aws.Lambda.Runtime.Python3d12,
        Architectures = new[]
        {
            "arm64",
        },
        Layers = new[]
        {
            pythonLayer.Apply(getLayerVersionResult => getLayerVersionResult.Arn),
            armLayer.Apply(getLayerVersionResult => getLayerVersionResult.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 {
		// Find latest layer version compatible with Python 3.12
		pythonLayer, err := lambda.LookupLayerVersion(ctx, &lambda.LookupLayerVersionArgs{
			LayerName:         pulumi.StringRef("python-dependencies"),
			CompatibleRuntime: pulumi.StringRef("python3.12"),
		}, nil)
		if err != nil {
			return err
		}
		// Find latest layer version compatible with ARM64 architecture
		armLayer, err := lambda.LookupLayerVersion(ctx, &lambda.LookupLayerVersionArgs{
			LayerName:              pulumi.StringRef("optimized-libraries"),
			CompatibleArchitecture: pulumi.StringRef("arm64"),
		}, nil)
		if err != nil {
			return err
		}
		// Use both layers in a function
		_, err = lambda.NewFunction(ctx, "example", &lambda.FunctionArgs{
			Code:    pulumi.NewFileArchive("function.zip"),
			Name:    pulumi.String("multi_layer_function"),
			Role:    pulumi.Any(lambdaRole.Arn),
			Handler: pulumi.String("app.handler"),
			Runtime: pulumi.String(lambda.RuntimePython3d12),
			Architectures: pulumi.StringArray{
				pulumi.String("arm64"),
			},
			Layers: pulumi.StringArray{
				pulumi.String(pythonLayer.Arn),
				pulumi.String(armLayer.Arn),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lambda_getlayerversion" "pythonLayer" {
  layer_name         = "python-dependencies"
  compatible_runtime = "python3.12"
}
data "aws_lambda_getlayerversion" "armLayer" {
  layer_name              = "optimized-libraries"
  compatible_architecture = "arm64"
}

# Use both layers in a function
resource "aws_lambda_function" "example" {
  code          = fileArchive("function.zip")
  name          = "multi_layer_function"
  role          = lambdaRole.arn
  handler       = "app.handler"
  runtime       = "python3.12"
  architectures = ["arm64"]
  layers        = [data.aws_lambda_getlayerversion.pythonLayer.arn, data.aws_lambda_getlayerversion.armLayer.arn]
}
# Find latest layer version compatible with Python 3.12
# Find latest layer version compatible with ARM64 architecture

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.LambdaFunctions;
import com.pulumi.aws.lambda.inputs.GetLayerVersionArgs;
import com.pulumi.aws.lambda.Function;
import com.pulumi.aws.lambda.FunctionArgs;
import com.pulumi.asset.FileArchive;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Find latest layer version compatible with Python 3.12
        final var pythonLayer = LambdaFunctions.getLayerVersion(GetLayerVersionArgs.builder()
            .layerName("python-dependencies")
            .compatibleRuntime("python3.12")
            .build());

        // Find latest layer version compatible with ARM64 architecture
        final var armLayer = LambdaFunctions.getLayerVersion(GetLayerVersionArgs.builder()
            .layerName("optimized-libraries")
            .compatibleArchitecture("arm64")
            .build());

        // Use both layers in a function
        var example = new Function("example", FunctionArgs.builder()
            .code(new FileArchive("function.zip"))
            .name("multi_layer_function")
            .role(lambdaRole.arn())
            .handler("app.handler")
            .runtime("python3.12")
            .architectures("arm64")
            .layers(
                pythonLayer.arn(),
                armLayer.arn())
            .build());

    }
}

resources:
  # Use both layers in a function
  example:
    type: aws:lambda:Function
    properties:
      code:
        fn::fileArchive: function.zip
      name: multi_layer_function
      role: ${lambdaRole.arn}
      handler: app.handler
      runtime: python3.12
      architectures:
        - arm64
      layers:
        - ${pythonLayer.arn}
        - ${armLayer.arn}
variables:
  # Find latest layer version compatible with Python 3.12
  pythonLayer:
    fn::invoke:
      function: aws:lambda:getLayerVersion
      arguments:
        layerName: python-dependencies
        compatibleRuntime: python3.12
  # Find latest layer version compatible with ARM64 architecture
  armLayer:
    fn::invoke:
      function: aws:lambda:getLayerVersion
      arguments:
        layerName: optimized-libraries
        compatibleArchitecture: arm64

Compare Layer Versions

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

// Get latest version
const latest = aws.lambda.getLayerVersion({
    layerName: "shared-layer",
});
// Get specific version for comparison
const stable = aws.lambda.getLayerVersion({
    layerName: "shared-layer",
    version: 3,
});
const useLatestLayer = latest.then(latest => latest.version > 5);
const selectedLayer = useLatestLayer ? latest.then(latest => latest.arn) : stable.then(stable => stable.arn);
export const selectedLayerVersion = useLatestLayer ? latest.then(latest => latest.version) : stable.then(stable => stable.version);

import pulumi
import pulumi_aws as aws

# Get latest version
latest = aws.lambda_.get_layer_version(layer_name="shared-layer")
# Get specific version for comparison
stable = aws.lambda_.get_layer_version(layer_name="shared-layer",
    version=3)
use_latest_layer = output(latest.version).apply(lambda x: float(x)) > float(5)
selected_layer = latest.arn if use_latest_layer else stable.arn
pulumi.export("selectedLayerVersion", latest.version if use_latest_layer else stable.version)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    // Get latest version
    var latest = Aws.Lambda.GetLayerVersion.Invoke(new()
    {
        LayerName = "shared-layer",
    });

    // Get specific version for comparison
    var stable = Aws.Lambda.GetLayerVersion.Invoke(new()
    {
        LayerName = "shared-layer",
        Version = 3,
    });

    var useLatestLayer = latest.Apply(getLayerVersionResult => getLayerVersionResult.Version) > 5;

    var selectedLayer = useLatestLayer ? latest.Apply(getLayerVersionResult => getLayerVersionResult.Arn) : stable.Apply(getLayerVersionResult => getLayerVersionResult.Arn);

    return new Dictionary<string, object?>
    {
        ["selectedLayerVersion"] = useLatestLayer ? latest.Apply(getLayerVersionResult => getLayerVersionResult.Version) : stable.Apply(getLayerVersionResult => getLayerVersionResult.Version),
    };
});

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 {
		// Get latest version
		latest, err := lambda.LookupLayerVersion(ctx, &lambda.LookupLayerVersionArgs{
			LayerName: pulumi.StringRef("shared-layer"),
		}, nil)
		if err != nil {
			return err
		}
		// Get specific version for comparison
		stable, err := lambda.LookupLayerVersion(ctx, &lambda.LookupLayerVersionArgs{
			LayerName: pulumi.StringRef("shared-layer"),
			Version:   pulumi.IntRef(3),
		}, nil)
		if err != nil {
			return err
		}
		useLatestLayer := pulumi.Float64(latest.Version) > 5
		var tmp0 *string
		if useLatestLayer {
			tmp0 = latest.Arn
		} else {
			tmp0 = stable.Arn
		}
		_ := tmp0
		var tmp1 *int
		if useLatestLayer {
			tmp1 = latest.Version
		} else {
			tmp1 = stable.Version
		}
		ctx.Export("selectedLayerVersion", tmp1)
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lambda_getlayerversion" "latest" {
  layer_name = "shared-layer"
}
data "aws_lambda_getlayerversion" "stable" {
  layer_name = "shared-layer"
  version    = 3
}

# Get latest version
# Get specific version for comparison
locals {
  useLatestLayer = data.aws_lambda_getlayerversion.latest.version > 5
}
locals {
  selectedLayer = local.useLatestLayer ? data.aws_lambda_getlayerversion.latest.arn : data.aws_lambda_getlayerversion.stable.arn
}
output "selectedLayerVersion" {
  value = local.useLatestLayer ? data.aws_lambda_getlayerversion.latest.version : data.aws_lambda_getlayerversion.stable.version
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.LambdaFunctions;
import com.pulumi.aws.lambda.inputs.GetLayerVersionArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Get latest version
        final var latest = LambdaFunctions.getLayerVersion(GetLayerVersionArgs.builder()
            .layerName("shared-layer")
            .build());

        // Get specific version for comparison
        final var stable = LambdaFunctions.getLayerVersion(GetLayerVersionArgs.builder()
            .layerName("shared-layer")
            .version(3)
            .build());

        final var useLatestLayer = latest.version() > 5;

        final var selectedLayer = useLatestLayer ? latest.arn() : stable.arn();

        ctx.export("selectedLayerVersion", useLatestLayer ? latest.version() : stable.version());
    }
}

Cross-Account Layer Access

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

// Reference a layer from another AWS account using full ARN with version
const sharedLayer = aws.lambda.getLayerVersion({
    layerVersionArn: "arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities:5",
});
// Use in your Lambda function
const example = new aws.lambda.Function("example", {
    code: new pulumi.asset.FileArchive("function.zip"),
    name: "cross_account_example",
    role: lambdaRole.arn,
    handler: "index.handler",
    runtime: aws.lambda.Runtime.NodeJS24dX,
    layers: [sharedLayer.then(sharedLayer => sharedLayer.arn)],
});

import pulumi
import pulumi_aws as aws

# Reference a layer from another AWS account using full ARN with version
shared_layer = aws.lambda_.get_layer_version(layer_version_arn="arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities:5")
# Use in your Lambda function
example = aws.lambda_.Function("example",
    code=pulumi.FileArchive("function.zip"),
    name="cross_account_example",
    role=lambda_role["arn"],
    handler="index.handler",
    runtime=aws.lambda_.Runtime.NODE_JS24D_X,
    layers=[shared_layer.arn])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    // Reference a layer from another AWS account using full ARN with version
    var sharedLayer = Aws.Lambda.GetLayerVersion.Invoke(new()
    {
        LayerVersionArn = "arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities:5",
    });

    // Use in your Lambda function
    var example = new Aws.Lambda.Function("example", new()
    {
        Code = new FileArchive("function.zip"),
        Name = "cross_account_example",
        Role = lambdaRole.Arn,
        Handler = "index.handler",
        Runtime = Aws.Lambda.Runtime.NodeJS24dX,
        Layers = new[]
        {
            sharedLayer.Apply(getLayerVersionResult => getLayerVersionResult.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 {
		// Reference a layer from another AWS account using full ARN with version
		sharedLayer, err := lambda.LookupLayerVersion(ctx, &lambda.LookupLayerVersionArgs{
			LayerVersionArn: pulumi.StringRef("arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities:5"),
		}, nil)
		if err != nil {
			return err
		}
		// Use in your Lambda function
		_, err = lambda.NewFunction(ctx, "example", &lambda.FunctionArgs{
			Code:    pulumi.NewFileArchive("function.zip"),
			Name:    pulumi.String("cross_account_example"),
			Role:    pulumi.Any(lambdaRole.Arn),
			Handler: pulumi.String("index.handler"),
			Runtime: pulumi.String(lambda.RuntimeNodeJS24dX),
			Layers: pulumi.StringArray{
				pulumi.String(sharedLayer.Arn),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lambda_getlayerversion" "sharedLayer" {
  layer_version_arn = "arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities:5"
}

# Use in your Lambda function
resource "aws_lambda_function" "example" {
  code    = fileArchive("function.zip")
  name    = "cross_account_example"
  role    = lambdaRole.arn
  handler = "index.handler"
  runtime = "nodejs24.x"
  layers  = [data.aws_lambda_getlayerversion.sharedLayer.arn]
}
# Reference a layer from another AWS account using full ARN with version

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.LambdaFunctions;
import com.pulumi.aws.lambda.inputs.GetLayerVersionArgs;
import com.pulumi.aws.lambda.Function;
import com.pulumi.aws.lambda.FunctionArgs;
import com.pulumi.asset.FileArchive;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Reference a layer from another AWS account using full ARN with version
        final var sharedLayer = LambdaFunctions.getLayerVersion(GetLayerVersionArgs.builder()
            .layerVersionArn("arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities:5")
            .build());

        // Use in your Lambda function
        var example = new Function("example", FunctionArgs.builder()
            .code(new FileArchive("function.zip"))
            .name("cross_account_example")
            .role(lambdaRole.arn())
            .handler("index.handler")
            .runtime("nodejs24.x")
            .layers(sharedLayer.arn())
            .build());

    }
}

resources:
  # Use in your Lambda function
  example:
    type: aws:lambda:Function
    properties:
      code:
        fn::fileArchive: function.zip
      name: cross_account_example
      role: ${lambdaRole.arn}
      handler: index.handler
      runtime: nodejs24.x
      layers:
        - ${sharedLayer.arn}
variables:
  # Reference a layer from another AWS account using full ARN with version
  sharedLayer:
    fn::invoke:
      function: aws:lambda:getLayerVersion
      arguments:
        layerVersionArn: arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities:5

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

// Reference a layer ARN without version (requires ListLayerVersions permission)
const latestShared = aws.lambda.getLayerVersion({
    layerVersionArn: "arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities",
});

import pulumi
import pulumi_aws as aws

# Reference a layer ARN without version (requires ListLayerVersions permission)
latest_shared = aws.lambda_.get_layer_version(layer_version_arn="arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    // Reference a layer ARN without version (requires ListLayerVersions permission)
    var latestShared = Aws.Lambda.GetLayerVersion.Invoke(new()
    {
        LayerVersionArn = "arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities",
    });

});

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 {
		// Reference a layer ARN without version (requires ListLayerVersions permission)
		_, err := lambda.LookupLayerVersion(ctx, &lambda.LookupLayerVersionArgs{
			LayerVersionArn: pulumi.StringRef("arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lambda_getlayerversion" "latestShared" {
  layer_version_arn = "arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities"
}

# Reference a layer ARN without version (requires ListLayerVersions permission)

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.LambdaFunctions;
import com.pulumi.aws.lambda.inputs.GetLayerVersionArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Reference a layer ARN without version (requires ListLayerVersions permission)
        final var latestShared = LambdaFunctions.getLayerVersion(GetLayerVersionArgs.builder()
            .layerVersionArn("arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities")
            .build());

    }
}

variables:
  # Reference a layer ARN without version (requires ListLayerVersions permission)
  latestShared:
    fn::invoke:
      function: aws:lambda:getLayerVersion
      arguments:
        layerVersionArn: arn:aws:lambda:us-east-1:123456789012:layer:shared-utilities

args Arguments passed to this invoke. Arguments for getLayerVersion. options Invoke options controlling this call.

Implementation

Future<GetLayerVersionResult> getLayerVersion(
  GetLayerVersionArgs args, {
  pulumi.InvokeOptions? options,
}) async {
  final deployment = pulumi.Deployment.instance;
  final result = await deployment.invoke<Map<String, dynamic>>(
    'aws:lambda/getLayerVersion:getLayerVersion',
    args.toMap(),
    options: pulumi.toDeploymentInvokeOptions(options),
  );
  return GetLayerVersionResult.fromMap(result);
}