Package com.pulumi.aws.lambda

Class LambdaFunctions

  • public final class LambdaFunctions
extends java.lang.Object

    • Constructor Detail

      • LambdaFunctions

        public LambdaFunctions()

    • Method Detail

      • getAlias

        public static com.pulumi.core.Output<GetAliasResult> getAlias​(GetAliasArgs args)
        Provides details about an AWS Lambda Alias. Use this data source to retrieve information about an existing Lambda function alias for traffic management, deployment strategies, or API integrations. ## Example Usage ### Basic Usage 
         
 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.GetAliasArgs;
 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.getAlias(GetAliasArgs.builder()
             .functionName("my-lambda-function")
             .name("production")
             .build());
 
         ctx.export("aliasArn", example.arn());
     }
 }
        ### API Gateway Integration 
         
 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.GetAliasArgs;
 import com.pulumi.aws.apigateway.Integration;
 import com.pulumi.aws.apigateway.IntegrationArgs;
 import com.pulumi.aws.lambda.Permission;
 import com.pulumi.aws.lambda.PermissionArgs;
 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 apiHandler = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("api-handler")
             .name("live")
             .build());
 
         var example = new Integration("example", IntegrationArgs.builder()
             .restApi(exampleAwsApiGatewayRestApi.id())
             .resourceId(exampleAwsApiGatewayResource.id())
             .httpMethod(exampleAwsApiGatewayMethod.httpMethod())
             .integrationHttpMethod("POST")
             .type("AWS_PROXY")
             .uri(apiHandler.invokeArn())
             .build());
 
         // Grant API Gateway permission to invoke the alias
         var apiGateway = new Permission("apiGateway", PermissionArgs.builder()
             .statementId("AllowExecutionFromAPIGateway")
             .action("lambda:InvokeFunction")
             .function(apiHandler.functionName())
             .principal("apigateway.amazonaws.com")
             .qualifier(apiHandler.name())
             .sourceArn(String.format("%s/*/*", exampleAwsApiGatewayRestApi.executionArn()))
             .build());
 
     }
 }
        ### Deployment Version Tracking 
         
 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.GetAliasArgs;
 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 production alias details
         final var production = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("payment-processor")
             .name("production")
             .build());
 
         // Get staging alias details
         final var staging = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("payment-processor")
             .name("staging")
             .build());
 
         final var versionDrift = production.functionVersion() != staging.functionVersion();
 
         ctx.export("deploymentStatus", Map.ofEntries(
             Map.entry("productionVersion", production.functionVersion()),
             Map.entry("stagingVersion", staging.functionVersion()),
             Map.entry("versionDrift", versionDrift),
             Map.entry("readyForPromotion", !versionDrift)
         ));
     }
 }
        ### EventBridge Rule Target 
         
 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.GetAliasArgs;
 import com.pulumi.aws.cloudwatch.EventRule;
 import com.pulumi.aws.cloudwatch.EventRuleArgs;
 import com.pulumi.aws.cloudwatch.EventTarget;
 import com.pulumi.aws.cloudwatch.EventTargetArgs;
 import com.pulumi.aws.lambda.Permission;
 import com.pulumi.aws.lambda.PermissionArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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 eventProcessor = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("event-processor")
             .name("stable")
             .build());
 
         var example = new EventRule("example", EventRuleArgs.builder()
             .name("capture-events")
             .description("Capture events for processing")
             .eventPattern(serializeJson(
                 jsonObject(
                     jsonProperty("source", jsonArray("myapp.orders")),
                     jsonProperty("detail-type", jsonArray("Order Placed"))
                 )))
             .build());
 
         var lambda = new EventTarget("lambda", EventTargetArgs.builder()
             .rule(example.name())
             .targetId("SendToLambda")
             .arn(eventProcessor.arn())
             .build());
 
         var allowEventbridge = new Permission("allowEventbridge", PermissionArgs.builder()
             .statementId("AllowExecutionFromEventBridge")
             .action("lambda:InvokeFunction")
             .function(eventProcessor.functionName())
             .principal("events.amazonaws.com")
             .qualifier(eventProcessor.name())
             .sourceArn(example.arn())
             .build());
 
     }
 }

      • getAliasPlain

        public static java.util.concurrent.CompletableFuture<GetAliasResult> getAliasPlain​(GetAliasPlainArgs args)
        Provides details about an AWS Lambda Alias. Use this data source to retrieve information about an existing Lambda function alias for traffic management, deployment strategies, or API integrations. ## Example Usage ### Basic Usage 
         
 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.GetAliasArgs;
 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.getAlias(GetAliasArgs.builder()
             .functionName("my-lambda-function")
             .name("production")
             .build());
 
         ctx.export("aliasArn", example.arn());
     }
 }
        ### API Gateway Integration 
         
 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.GetAliasArgs;
 import com.pulumi.aws.apigateway.Integration;
 import com.pulumi.aws.apigateway.IntegrationArgs;
 import com.pulumi.aws.lambda.Permission;
 import com.pulumi.aws.lambda.PermissionArgs;
 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 apiHandler = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("api-handler")
             .name("live")
             .build());
 
         var example = new Integration("example", IntegrationArgs.builder()
             .restApi(exampleAwsApiGatewayRestApi.id())
             .resourceId(exampleAwsApiGatewayResource.id())
             .httpMethod(exampleAwsApiGatewayMethod.httpMethod())
             .integrationHttpMethod("POST")
             .type("AWS_PROXY")
             .uri(apiHandler.invokeArn())
             .build());
 
         // Grant API Gateway permission to invoke the alias
         var apiGateway = new Permission("apiGateway", PermissionArgs.builder()
             .statementId("AllowExecutionFromAPIGateway")
             .action("lambda:InvokeFunction")
             .function(apiHandler.functionName())
             .principal("apigateway.amazonaws.com")
             .qualifier(apiHandler.name())
             .sourceArn(String.format("%s/*/*", exampleAwsApiGatewayRestApi.executionArn()))
             .build());
 
     }
 }
        ### Deployment Version Tracking 
         
 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.GetAliasArgs;
 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 production alias details
         final var production = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("payment-processor")
             .name("production")
             .build());
 
         // Get staging alias details
         final var staging = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("payment-processor")
             .name("staging")
             .build());
 
         final var versionDrift = production.functionVersion() != staging.functionVersion();
 
         ctx.export("deploymentStatus", Map.ofEntries(
             Map.entry("productionVersion", production.functionVersion()),
             Map.entry("stagingVersion", staging.functionVersion()),
             Map.entry("versionDrift", versionDrift),
             Map.entry("readyForPromotion", !versionDrift)
         ));
     }
 }
        ### EventBridge Rule Target 
         
 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.GetAliasArgs;
 import com.pulumi.aws.cloudwatch.EventRule;
 import com.pulumi.aws.cloudwatch.EventRuleArgs;
 import com.pulumi.aws.cloudwatch.EventTarget;
 import com.pulumi.aws.cloudwatch.EventTargetArgs;
 import com.pulumi.aws.lambda.Permission;
 import com.pulumi.aws.lambda.PermissionArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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 eventProcessor = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("event-processor")
             .name("stable")
             .build());
 
         var example = new EventRule("example", EventRuleArgs.builder()
             .name("capture-events")
             .description("Capture events for processing")
             .eventPattern(serializeJson(
                 jsonObject(
                     jsonProperty("source", jsonArray("myapp.orders")),
                     jsonProperty("detail-type", jsonArray("Order Placed"))
                 )))
             .build());
 
         var lambda = new EventTarget("lambda", EventTargetArgs.builder()
             .rule(example.name())
             .targetId("SendToLambda")
             .arn(eventProcessor.arn())
             .build());
 
         var allowEventbridge = new Permission("allowEventbridge", PermissionArgs.builder()
             .statementId("AllowExecutionFromEventBridge")
             .action("lambda:InvokeFunction")
             .function(eventProcessor.functionName())
             .principal("events.amazonaws.com")
             .qualifier(eventProcessor.name())
             .sourceArn(example.arn())
             .build());
 
     }
 }

      • getAlias

        public static com.pulumi.core.Output<GetAliasResult> getAlias​(GetAliasArgs args,
                                                              com.pulumi.deployment.InvokeOptions options)
        Provides details about an AWS Lambda Alias. Use this data source to retrieve information about an existing Lambda function alias for traffic management, deployment strategies, or API integrations. ## Example Usage ### Basic Usage 
         
 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.GetAliasArgs;
 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.getAlias(GetAliasArgs.builder()
             .functionName("my-lambda-function")
             .name("production")
             .build());
 
         ctx.export("aliasArn", example.arn());
     }
 }
        ### API Gateway Integration 
         
 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.GetAliasArgs;
 import com.pulumi.aws.apigateway.Integration;
 import com.pulumi.aws.apigateway.IntegrationArgs;
 import com.pulumi.aws.lambda.Permission;
 import com.pulumi.aws.lambda.PermissionArgs;
 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 apiHandler = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("api-handler")
             .name("live")
             .build());
 
         var example = new Integration("example", IntegrationArgs.builder()
             .restApi(exampleAwsApiGatewayRestApi.id())
             .resourceId(exampleAwsApiGatewayResource.id())
             .httpMethod(exampleAwsApiGatewayMethod.httpMethod())
             .integrationHttpMethod("POST")
             .type("AWS_PROXY")
             .uri(apiHandler.invokeArn())
             .build());
 
         // Grant API Gateway permission to invoke the alias
         var apiGateway = new Permission("apiGateway", PermissionArgs.builder()
             .statementId("AllowExecutionFromAPIGateway")
             .action("lambda:InvokeFunction")
             .function(apiHandler.functionName())
             .principal("apigateway.amazonaws.com")
             .qualifier(apiHandler.name())
             .sourceArn(String.format("%s/*/*", exampleAwsApiGatewayRestApi.executionArn()))
             .build());
 
     }
 }
        ### Deployment Version Tracking 
         
 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.GetAliasArgs;
 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 production alias details
         final var production = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("payment-processor")
             .name("production")
             .build());
 
         // Get staging alias details
         final var staging = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("payment-processor")
             .name("staging")
             .build());
 
         final var versionDrift = production.functionVersion() != staging.functionVersion();
 
         ctx.export("deploymentStatus", Map.ofEntries(
             Map.entry("productionVersion", production.functionVersion()),
             Map.entry("stagingVersion", staging.functionVersion()),
             Map.entry("versionDrift", versionDrift),
             Map.entry("readyForPromotion", !versionDrift)
         ));
     }
 }
        ### EventBridge Rule Target 
         
 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.GetAliasArgs;
 import com.pulumi.aws.cloudwatch.EventRule;
 import com.pulumi.aws.cloudwatch.EventRuleArgs;
 import com.pulumi.aws.cloudwatch.EventTarget;
 import com.pulumi.aws.cloudwatch.EventTargetArgs;
 import com.pulumi.aws.lambda.Permission;
 import com.pulumi.aws.lambda.PermissionArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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 eventProcessor = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("event-processor")
             .name("stable")
             .build());
 
         var example = new EventRule("example", EventRuleArgs.builder()
             .name("capture-events")
             .description("Capture events for processing")
             .eventPattern(serializeJson(
                 jsonObject(
                     jsonProperty("source", jsonArray("myapp.orders")),
                     jsonProperty("detail-type", jsonArray("Order Placed"))
                 )))
             .build());
 
         var lambda = new EventTarget("lambda", EventTargetArgs.builder()
             .rule(example.name())
             .targetId("SendToLambda")
             .arn(eventProcessor.arn())
             .build());
 
         var allowEventbridge = new Permission("allowEventbridge", PermissionArgs.builder()
             .statementId("AllowExecutionFromEventBridge")
             .action("lambda:InvokeFunction")
             .function(eventProcessor.functionName())
             .principal("events.amazonaws.com")
             .qualifier(eventProcessor.name())
             .sourceArn(example.arn())
             .build());
 
     }
 }

      • getAlias

        public static com.pulumi.core.Output<GetAliasResult> getAlias​(GetAliasArgs args,
                                                              com.pulumi.deployment.InvokeOutputOptions options)
        Provides details about an AWS Lambda Alias. Use this data source to retrieve information about an existing Lambda function alias for traffic management, deployment strategies, or API integrations. ## Example Usage ### Basic Usage 
         
 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.GetAliasArgs;
 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.getAlias(GetAliasArgs.builder()
             .functionName("my-lambda-function")
             .name("production")
             .build());
 
         ctx.export("aliasArn", example.arn());
     }
 }
        ### API Gateway Integration 
         
 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.GetAliasArgs;
 import com.pulumi.aws.apigateway.Integration;
 import com.pulumi.aws.apigateway.IntegrationArgs;
 import com.pulumi.aws.lambda.Permission;
 import com.pulumi.aws.lambda.PermissionArgs;
 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 apiHandler = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("api-handler")
             .name("live")
             .build());
 
         var example = new Integration("example", IntegrationArgs.builder()
             .restApi(exampleAwsApiGatewayRestApi.id())
             .resourceId(exampleAwsApiGatewayResource.id())
             .httpMethod(exampleAwsApiGatewayMethod.httpMethod())
             .integrationHttpMethod("POST")
             .type("AWS_PROXY")
             .uri(apiHandler.invokeArn())
             .build());
 
         // Grant API Gateway permission to invoke the alias
         var apiGateway = new Permission("apiGateway", PermissionArgs.builder()
             .statementId("AllowExecutionFromAPIGateway")
             .action("lambda:InvokeFunction")
             .function(apiHandler.functionName())
             .principal("apigateway.amazonaws.com")
             .qualifier(apiHandler.name())
             .sourceArn(String.format("%s/*/*", exampleAwsApiGatewayRestApi.executionArn()))
             .build());
 
     }
 }
        ### Deployment Version Tracking 
         
 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.GetAliasArgs;
 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 production alias details
         final var production = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("payment-processor")
             .name("production")
             .build());
 
         // Get staging alias details
         final var staging = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("payment-processor")
             .name("staging")
             .build());
 
         final var versionDrift = production.functionVersion() != staging.functionVersion();
 
         ctx.export("deploymentStatus", Map.ofEntries(
             Map.entry("productionVersion", production.functionVersion()),
             Map.entry("stagingVersion", staging.functionVersion()),
             Map.entry("versionDrift", versionDrift),
             Map.entry("readyForPromotion", !versionDrift)
         ));
     }
 }
        ### EventBridge Rule Target 
         
 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.GetAliasArgs;
 import com.pulumi.aws.cloudwatch.EventRule;
 import com.pulumi.aws.cloudwatch.EventRuleArgs;
 import com.pulumi.aws.cloudwatch.EventTarget;
 import com.pulumi.aws.cloudwatch.EventTargetArgs;
 import com.pulumi.aws.lambda.Permission;
 import com.pulumi.aws.lambda.PermissionArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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 eventProcessor = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("event-processor")
             .name("stable")
             .build());
 
         var example = new EventRule("example", EventRuleArgs.builder()
             .name("capture-events")
             .description("Capture events for processing")
             .eventPattern(serializeJson(
                 jsonObject(
                     jsonProperty("source", jsonArray("myapp.orders")),
                     jsonProperty("detail-type", jsonArray("Order Placed"))
                 )))
             .build());
 
         var lambda = new EventTarget("lambda", EventTargetArgs.builder()
             .rule(example.name())
             .targetId("SendToLambda")
             .arn(eventProcessor.arn())
             .build());
 
         var allowEventbridge = new Permission("allowEventbridge", PermissionArgs.builder()
             .statementId("AllowExecutionFromEventBridge")
             .action("lambda:InvokeFunction")
             .function(eventProcessor.functionName())
             .principal("events.amazonaws.com")
             .qualifier(eventProcessor.name())
             .sourceArn(example.arn())
             .build());
 
     }
 }

      • getAliasPlain

        public static java.util.concurrent.CompletableFuture<GetAliasResult> getAliasPlain​(GetAliasPlainArgs args,
                                                                                   com.pulumi.deployment.InvokeOptions options)
        Provides details about an AWS Lambda Alias. Use this data source to retrieve information about an existing Lambda function alias for traffic management, deployment strategies, or API integrations. ## Example Usage ### Basic Usage 
         
 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.GetAliasArgs;
 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.getAlias(GetAliasArgs.builder()
             .functionName("my-lambda-function")
             .name("production")
             .build());
 
         ctx.export("aliasArn", example.arn());
     }
 }
        ### API Gateway Integration 
         
 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.GetAliasArgs;
 import com.pulumi.aws.apigateway.Integration;
 import com.pulumi.aws.apigateway.IntegrationArgs;
 import com.pulumi.aws.lambda.Permission;
 import com.pulumi.aws.lambda.PermissionArgs;
 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 apiHandler = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("api-handler")
             .name("live")
             .build());
 
         var example = new Integration("example", IntegrationArgs.builder()
             .restApi(exampleAwsApiGatewayRestApi.id())
             .resourceId(exampleAwsApiGatewayResource.id())
             .httpMethod(exampleAwsApiGatewayMethod.httpMethod())
             .integrationHttpMethod("POST")
             .type("AWS_PROXY")
             .uri(apiHandler.invokeArn())
             .build());
 
         // Grant API Gateway permission to invoke the alias
         var apiGateway = new Permission("apiGateway", PermissionArgs.builder()
             .statementId("AllowExecutionFromAPIGateway")
             .action("lambda:InvokeFunction")
             .function(apiHandler.functionName())
             .principal("apigateway.amazonaws.com")
             .qualifier(apiHandler.name())
             .sourceArn(String.format("%s/*/*", exampleAwsApiGatewayRestApi.executionArn()))
             .build());
 
     }
 }
        ### Deployment Version Tracking 
         
 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.GetAliasArgs;
 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 production alias details
         final var production = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("payment-processor")
             .name("production")
             .build());
 
         // Get staging alias details
         final var staging = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("payment-processor")
             .name("staging")
             .build());
 
         final var versionDrift = production.functionVersion() != staging.functionVersion();
 
         ctx.export("deploymentStatus", Map.ofEntries(
             Map.entry("productionVersion", production.functionVersion()),
             Map.entry("stagingVersion", staging.functionVersion()),
             Map.entry("versionDrift", versionDrift),
             Map.entry("readyForPromotion", !versionDrift)
         ));
     }
 }
        ### EventBridge Rule Target 
         
 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.GetAliasArgs;
 import com.pulumi.aws.cloudwatch.EventRule;
 import com.pulumi.aws.cloudwatch.EventRuleArgs;
 import com.pulumi.aws.cloudwatch.EventTarget;
 import com.pulumi.aws.cloudwatch.EventTargetArgs;
 import com.pulumi.aws.lambda.Permission;
 import com.pulumi.aws.lambda.PermissionArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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 eventProcessor = LambdaFunctions.getAlias(GetAliasArgs.builder()
             .functionName("event-processor")
             .name("stable")
             .build());
 
         var example = new EventRule("example", EventRuleArgs.builder()
             .name("capture-events")
             .description("Capture events for processing")
             .eventPattern(serializeJson(
                 jsonObject(
                     jsonProperty("source", jsonArray("myapp.orders")),
                     jsonProperty("detail-type", jsonArray("Order Placed"))
                 )))
             .build());
 
         var lambda = new EventTarget("lambda", EventTargetArgs.builder()
             .rule(example.name())
             .targetId("SendToLambda")
             .arn(eventProcessor.arn())
             .build());
 
         var allowEventbridge = new Permission("allowEventbridge", PermissionArgs.builder()
             .statementId("AllowExecutionFromEventBridge")
             .action("lambda:InvokeFunction")
             .function(eventProcessor.functionName())
             .principal("events.amazonaws.com")
             .qualifier(eventProcessor.name())
             .sourceArn(example.arn())
             .build());
 
     }
 }

      • getCodeSigningConfig

        public static com.pulumi.core.Output<GetCodeSigningConfigResult> getCodeSigningConfig​(GetCodeSigningConfigArgs args)
        Provides details about an AWS Lambda Code Signing Config. Use this data source to retrieve information about an existing code signing configuration for Lambda functions to ensure code integrity and authenticity. For information about Lambda code signing configurations and how to use them, see [configuring code signing for Lambda functions](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html). ## Example Usage ### Basic Usage 
         
 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.GetCodeSigningConfigArgs;
 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.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-0f6c334abcdea4d8b")
             .build());
 
         ctx.export("configDetails", Map.ofEntries(
             Map.entry("configId", example.configId()),
             Map.entry("description", example.description()),
             Map.entry("policy", example.policies()[0].untrustedArtifactOnDeployment())
         ));
     }
 }
        ### Use in Lambda Function 
         
 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.GetCodeSigningConfigArgs;
 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) {
         // Get existing code signing configuration
         final var securityConfig = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn(codeSigningConfigArn)
             .build());
 
         // Create Lambda function with code signing
         var example = new Function("example", FunctionArgs.builder()
             .code(new FileArchive("function.zip"))
             .name("secure-function")
             .role(lambdaRole.arn())
             .handler("index.handler")
             .runtime("nodejs24.x")
             .codeSigningConfigArn(securityConfig.arn())
             .tags(Map.ofEntries(
                 Map.entry("Environment", "production"),
                 Map.entry("Security", "code-signed")
             ))
             .build());
 
     }
 }
        ### Validate Signing Profiles 
         
 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.GetCodeSigningConfigArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.ContainsArgs;
 import com.pulumi.aws.lambda.Function;
 import com.pulumi.aws.lambda.FunctionArgs;
 import com.pulumi.asset.FileArchive;
 import com.pulumi.codegen.internal.KeyedValue;
 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.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn(codeSigningConfigArn)
             .build());
 
         final var allowedProfiles = example.allowedPublishers()[0].signingProfileVersionArns();
 
         final var requiredProfile = "arn:aws:signer:us-west-2:123456789012:/signing-profiles/MyProfile";
 
         final var profileAllowed = StdFunctions.contains(ContainsArgs.builder()
             .input(allowedProfiles)
             .element(requiredProfile)
             .build()).result();
 
         // Conditional resource creation based on signing profile validation
         for (var i = 0; i < profileAllowed ? 1 : 0; i++) {
             new Function("conditional-" + i, FunctionArgs.builder()
                 .code(new FileArchive("function.zip"))
                 .name("conditional-function")
                 .role(lambdaRole.arn())
                 .handler("index.handler")
                 .runtime("python3.12")
                 .codeSigningConfigArn(example.arn())
                 .build());
 
         
 }
         ctx.export("deploymentStatus", Map.ofEntries(
             Map.entry("profileAllowed", profileAllowed),
             Map.entry("functionCreated", profileAllowed),
             Map.entry("message", profileAllowed ? "Function deployed with valid signing profile" : "Deployment blocked - signing profile not allowed")
         ));
     }
 }
        ### Multi-Environment Configuration 
         
 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.GetCodeSigningConfigArgs;
 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) {
         // Production code signing config
         final var prod = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-prod-123")
             .build());
 
         // Development code signing config
         final var dev = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-dev-456")
             .build());
 
         final var prodPolicy = prod.policies()[0].untrustedArtifactOnDeployment();
 
         final var devPolicy = dev.policies()[0].untrustedArtifactOnDeployment();
 
         final var configComparison = Map.ofEntries(
             Map.entry("prodEnforcement", prodPolicy),
             Map.entry("devEnforcement", devPolicy),
             Map.entry("policiesMatch", prodPolicy == devPolicy)
         );
 
         ctx.export("environmentComparison", configComparison);
     }
 }

      • getCodeSigningConfigPlain

        public static java.util.concurrent.CompletableFuture<GetCodeSigningConfigResult> getCodeSigningConfigPlain​(GetCodeSigningConfigPlainArgs args)
        Provides details about an AWS Lambda Code Signing Config. Use this data source to retrieve information about an existing code signing configuration for Lambda functions to ensure code integrity and authenticity. For information about Lambda code signing configurations and how to use them, see [configuring code signing for Lambda functions](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html). ## Example Usage ### Basic Usage 
         
 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.GetCodeSigningConfigArgs;
 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.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-0f6c334abcdea4d8b")
             .build());
 
         ctx.export("configDetails", Map.ofEntries(
             Map.entry("configId", example.configId()),
             Map.entry("description", example.description()),
             Map.entry("policy", example.policies()[0].untrustedArtifactOnDeployment())
         ));
     }
 }
        ### Use in Lambda Function 
         
 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.GetCodeSigningConfigArgs;
 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) {
         // Get existing code signing configuration
         final var securityConfig = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn(codeSigningConfigArn)
             .build());
 
         // Create Lambda function with code signing
         var example = new Function("example", FunctionArgs.builder()
             .code(new FileArchive("function.zip"))
             .name("secure-function")
             .role(lambdaRole.arn())
             .handler("index.handler")
             .runtime("nodejs24.x")
             .codeSigningConfigArn(securityConfig.arn())
             .tags(Map.ofEntries(
                 Map.entry("Environment", "production"),
                 Map.entry("Security", "code-signed")
             ))
             .build());
 
     }
 }
        ### Validate Signing Profiles 
         
 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.GetCodeSigningConfigArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.ContainsArgs;
 import com.pulumi.aws.lambda.Function;
 import com.pulumi.aws.lambda.FunctionArgs;
 import com.pulumi.asset.FileArchive;
 import com.pulumi.codegen.internal.KeyedValue;
 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.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn(codeSigningConfigArn)
             .build());
 
         final var allowedProfiles = example.allowedPublishers()[0].signingProfileVersionArns();
 
         final var requiredProfile = "arn:aws:signer:us-west-2:123456789012:/signing-profiles/MyProfile";
 
         final var profileAllowed = StdFunctions.contains(ContainsArgs.builder()
             .input(allowedProfiles)
             .element(requiredProfile)
             .build()).result();
 
         // Conditional resource creation based on signing profile validation
         for (var i = 0; i < profileAllowed ? 1 : 0; i++) {
             new Function("conditional-" + i, FunctionArgs.builder()
                 .code(new FileArchive("function.zip"))
                 .name("conditional-function")
                 .role(lambdaRole.arn())
                 .handler("index.handler")
                 .runtime("python3.12")
                 .codeSigningConfigArn(example.arn())
                 .build());
 
         
 }
         ctx.export("deploymentStatus", Map.ofEntries(
             Map.entry("profileAllowed", profileAllowed),
             Map.entry("functionCreated", profileAllowed),
             Map.entry("message", profileAllowed ? "Function deployed with valid signing profile" : "Deployment blocked - signing profile not allowed")
         ));
     }
 }
        ### Multi-Environment Configuration 
         
 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.GetCodeSigningConfigArgs;
 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) {
         // Production code signing config
         final var prod = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-prod-123")
             .build());
 
         // Development code signing config
         final var dev = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-dev-456")
             .build());
 
         final var prodPolicy = prod.policies()[0].untrustedArtifactOnDeployment();
 
         final var devPolicy = dev.policies()[0].untrustedArtifactOnDeployment();
 
         final var configComparison = Map.ofEntries(
             Map.entry("prodEnforcement", prodPolicy),
             Map.entry("devEnforcement", devPolicy),
             Map.entry("policiesMatch", prodPolicy == devPolicy)
         );
 
         ctx.export("environmentComparison", configComparison);
     }
 }

      • getCodeSigningConfig

        public static com.pulumi.core.Output<GetCodeSigningConfigResult> getCodeSigningConfig​(GetCodeSigningConfigArgs args,
                                                                                      com.pulumi.deployment.InvokeOptions options)
        Provides details about an AWS Lambda Code Signing Config. Use this data source to retrieve information about an existing code signing configuration for Lambda functions to ensure code integrity and authenticity. For information about Lambda code signing configurations and how to use them, see [configuring code signing for Lambda functions](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html). ## Example Usage ### Basic Usage 
         
 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.GetCodeSigningConfigArgs;
 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.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-0f6c334abcdea4d8b")
             .build());
 
         ctx.export("configDetails", Map.ofEntries(
             Map.entry("configId", example.configId()),
             Map.entry("description", example.description()),
             Map.entry("policy", example.policies()[0].untrustedArtifactOnDeployment())
         ));
     }
 }
        ### Use in Lambda Function 
         
 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.GetCodeSigningConfigArgs;
 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) {
         // Get existing code signing configuration
         final var securityConfig = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn(codeSigningConfigArn)
             .build());
 
         // Create Lambda function with code signing
         var example = new Function("example", FunctionArgs.builder()
             .code(new FileArchive("function.zip"))
             .name("secure-function")
             .role(lambdaRole.arn())
             .handler("index.handler")
             .runtime("nodejs24.x")
             .codeSigningConfigArn(securityConfig.arn())
             .tags(Map.ofEntries(
                 Map.entry("Environment", "production"),
                 Map.entry("Security", "code-signed")
             ))
             .build());
 
     }
 }
        ### Validate Signing Profiles 
         
 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.GetCodeSigningConfigArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.ContainsArgs;
 import com.pulumi.aws.lambda.Function;
 import com.pulumi.aws.lambda.FunctionArgs;
 import com.pulumi.asset.FileArchive;
 import com.pulumi.codegen.internal.KeyedValue;
 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.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn(codeSigningConfigArn)
             .build());
 
         final var allowedProfiles = example.allowedPublishers()[0].signingProfileVersionArns();
 
         final var requiredProfile = "arn:aws:signer:us-west-2:123456789012:/signing-profiles/MyProfile";
 
         final var profileAllowed = StdFunctions.contains(ContainsArgs.builder()
             .input(allowedProfiles)
             .element(requiredProfile)
             .build()).result();
 
         // Conditional resource creation based on signing profile validation
         for (var i = 0; i < profileAllowed ? 1 : 0; i++) {
             new Function("conditional-" + i, FunctionArgs.builder()
                 .code(new FileArchive("function.zip"))
                 .name("conditional-function")
                 .role(lambdaRole.arn())
                 .handler("index.handler")
                 .runtime("python3.12")
                 .codeSigningConfigArn(example.arn())
                 .build());
 
         
 }
         ctx.export("deploymentStatus", Map.ofEntries(
             Map.entry("profileAllowed", profileAllowed),
             Map.entry("functionCreated", profileAllowed),
             Map.entry("message", profileAllowed ? "Function deployed with valid signing profile" : "Deployment blocked - signing profile not allowed")
         ));
     }
 }
        ### Multi-Environment Configuration 
         
 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.GetCodeSigningConfigArgs;
 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) {
         // Production code signing config
         final var prod = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-prod-123")
             .build());
 
         // Development code signing config
         final var dev = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-dev-456")
             .build());
 
         final var prodPolicy = prod.policies()[0].untrustedArtifactOnDeployment();
 
         final var devPolicy = dev.policies()[0].untrustedArtifactOnDeployment();
 
         final var configComparison = Map.ofEntries(
             Map.entry("prodEnforcement", prodPolicy),
             Map.entry("devEnforcement", devPolicy),
             Map.entry("policiesMatch", prodPolicy == devPolicy)
         );
 
         ctx.export("environmentComparison", configComparison);
     }
 }

      • getCodeSigningConfig

        public static com.pulumi.core.Output<GetCodeSigningConfigResult> getCodeSigningConfig​(GetCodeSigningConfigArgs args,
                                                                                      com.pulumi.deployment.InvokeOutputOptions options)
        Provides details about an AWS Lambda Code Signing Config. Use this data source to retrieve information about an existing code signing configuration for Lambda functions to ensure code integrity and authenticity. For information about Lambda code signing configurations and how to use them, see [configuring code signing for Lambda functions](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html). ## Example Usage ### Basic Usage 
         
 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.GetCodeSigningConfigArgs;
 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.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-0f6c334abcdea4d8b")
             .build());
 
         ctx.export("configDetails", Map.ofEntries(
             Map.entry("configId", example.configId()),
             Map.entry("description", example.description()),
             Map.entry("policy", example.policies()[0].untrustedArtifactOnDeployment())
         ));
     }
 }
        ### Use in Lambda Function 
         
 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.GetCodeSigningConfigArgs;
 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) {
         // Get existing code signing configuration
         final var securityConfig = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn(codeSigningConfigArn)
             .build());
 
         // Create Lambda function with code signing
         var example = new Function("example", FunctionArgs.builder()
             .code(new FileArchive("function.zip"))
             .name("secure-function")
             .role(lambdaRole.arn())
             .handler("index.handler")
             .runtime("nodejs24.x")
             .codeSigningConfigArn(securityConfig.arn())
             .tags(Map.ofEntries(
                 Map.entry("Environment", "production"),
                 Map.entry("Security", "code-signed")
             ))
             .build());
 
     }
 }
        ### Validate Signing Profiles 
         
 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.GetCodeSigningConfigArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.ContainsArgs;
 import com.pulumi.aws.lambda.Function;
 import com.pulumi.aws.lambda.FunctionArgs;
 import com.pulumi.asset.FileArchive;
 import com.pulumi.codegen.internal.KeyedValue;
 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.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn(codeSigningConfigArn)
             .build());
 
         final var allowedProfiles = example.allowedPublishers()[0].signingProfileVersionArns();
 
         final var requiredProfile = "arn:aws:signer:us-west-2:123456789012:/signing-profiles/MyProfile";
 
         final var profileAllowed = StdFunctions.contains(ContainsArgs.builder()
             .input(allowedProfiles)
             .element(requiredProfile)
             .build()).result();
 
         // Conditional resource creation based on signing profile validation
         for (var i = 0; i < profileAllowed ? 1 : 0; i++) {
             new Function("conditional-" + i, FunctionArgs.builder()
                 .code(new FileArchive("function.zip"))
                 .name("conditional-function")
                 .role(lambdaRole.arn())
                 .handler("index.handler")
                 .runtime("python3.12")
                 .codeSigningConfigArn(example.arn())
                 .build());
 
         
 }
         ctx.export("deploymentStatus", Map.ofEntries(
             Map.entry("profileAllowed", profileAllowed),
             Map.entry("functionCreated", profileAllowed),
             Map.entry("message", profileAllowed ? "Function deployed with valid signing profile" : "Deployment blocked - signing profile not allowed")
         ));
     }
 }
        ### Multi-Environment Configuration 
         
 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.GetCodeSigningConfigArgs;
 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) {
         // Production code signing config
         final var prod = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-prod-123")
             .build());
 
         // Development code signing config
         final var dev = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-dev-456")
             .build());
 
         final var prodPolicy = prod.policies()[0].untrustedArtifactOnDeployment();
 
         final var devPolicy = dev.policies()[0].untrustedArtifactOnDeployment();
 
         final var configComparison = Map.ofEntries(
             Map.entry("prodEnforcement", prodPolicy),
             Map.entry("devEnforcement", devPolicy),
             Map.entry("policiesMatch", prodPolicy == devPolicy)
         );
 
         ctx.export("environmentComparison", configComparison);
     }
 }

      • getCodeSigningConfigPlain

        public static java.util.concurrent.CompletableFuture<GetCodeSigningConfigResult> getCodeSigningConfigPlain​(GetCodeSigningConfigPlainArgs args,
                                                                                                           com.pulumi.deployment.InvokeOptions options)
        Provides details about an AWS Lambda Code Signing Config. Use this data source to retrieve information about an existing code signing configuration for Lambda functions to ensure code integrity and authenticity. For information about Lambda code signing configurations and how to use them, see [configuring code signing for Lambda functions](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html). ## Example Usage ### Basic Usage 
         
 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.GetCodeSigningConfigArgs;
 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.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-0f6c334abcdea4d8b")
             .build());
 
         ctx.export("configDetails", Map.ofEntries(
             Map.entry("configId", example.configId()),
             Map.entry("description", example.description()),
             Map.entry("policy", example.policies()[0].untrustedArtifactOnDeployment())
         ));
     }
 }
        ### Use in Lambda Function 
         
 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.GetCodeSigningConfigArgs;
 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) {
         // Get existing code signing configuration
         final var securityConfig = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn(codeSigningConfigArn)
             .build());
 
         // Create Lambda function with code signing
         var example = new Function("example", FunctionArgs.builder()
             .code(new FileArchive("function.zip"))
             .name("secure-function")
             .role(lambdaRole.arn())
             .handler("index.handler")
             .runtime("nodejs24.x")
             .codeSigningConfigArn(securityConfig.arn())
             .tags(Map.ofEntries(
                 Map.entry("Environment", "production"),
                 Map.entry("Security", "code-signed")
             ))
             .build());
 
     }
 }
        ### Validate Signing Profiles 
         
 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.GetCodeSigningConfigArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.ContainsArgs;
 import com.pulumi.aws.lambda.Function;
 import com.pulumi.aws.lambda.FunctionArgs;
 import com.pulumi.asset.FileArchive;
 import com.pulumi.codegen.internal.KeyedValue;
 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.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn(codeSigningConfigArn)
             .build());
 
         final var allowedProfiles = example.allowedPublishers()[0].signingProfileVersionArns();
 
         final var requiredProfile = "arn:aws:signer:us-west-2:123456789012:/signing-profiles/MyProfile";
 
         final var profileAllowed = StdFunctions.contains(ContainsArgs.builder()
             .input(allowedProfiles)
             .element(requiredProfile)
             .build()).result();
 
         // Conditional resource creation based on signing profile validation
         for (var i = 0; i < profileAllowed ? 1 : 0; i++) {
             new Function("conditional-" + i, FunctionArgs.builder()
                 .code(new FileArchive("function.zip"))
                 .name("conditional-function")
                 .role(lambdaRole.arn())
                 .handler("index.handler")
                 .runtime("python3.12")
                 .codeSigningConfigArn(example.arn())
                 .build());
 
         
 }
         ctx.export("deploymentStatus", Map.ofEntries(
             Map.entry("profileAllowed", profileAllowed),
             Map.entry("functionCreated", profileAllowed),
             Map.entry("message", profileAllowed ? "Function deployed with valid signing profile" : "Deployment blocked - signing profile not allowed")
         ));
     }
 }
        ### Multi-Environment Configuration 
         
 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.GetCodeSigningConfigArgs;
 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) {
         // Production code signing config
         final var prod = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-prod-123")
             .build());
 
         // Development code signing config
         final var dev = LambdaFunctions.getCodeSigningConfig(GetCodeSigningConfigArgs.builder()
             .arn("arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-dev-456")
             .build());
 
         final var prodPolicy = prod.policies()[0].untrustedArtifactOnDeployment();
 
         final var devPolicy = dev.policies()[0].untrustedArtifactOnDeployment();
 
         final var configComparison = Map.ofEntries(
             Map.entry("prodEnforcement", prodPolicy),
             Map.entry("devEnforcement", devPolicy),
             Map.entry("policiesMatch", prodPolicy == devPolicy)
         );
 
         ctx.export("environmentComparison", configComparison);
     }
 }

      • getFunction

        public static com.pulumi.core.Output<GetFunctionResult> getFunction​(GetFunctionArgs args)
        Provides details about an AWS Lambda Function. Use this data source to obtain information about an existing Lambda function for use in other resources or as a reference for function configurations. > **Note:** This data source returns information about the latest version or alias specified by the `qualifier`. If no `qualifier` is provided, it returns information about the most recent published version, or `$LATEST` if no published version exists. ## Example Usage ### Basic Usage 
         
 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.GetFunctionArgs;
 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.getFunction(GetFunctionArgs.builder()
             .functionName("my-lambda-function")
             .build());
 
         ctx.export("functionArn", example.arn());
     }
 }
        ### Using Function Alias 
         
 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.GetFunctionArgs;
 import com.pulumi.aws.apigateway.Integration;
 import com.pulumi.aws.apigateway.IntegrationArgs;
 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.getFunction(GetFunctionArgs.builder()
             .functionName("api-handler")
             .qualifier("production")
             .build());
 
         // Use in API Gateway integration
         var exampleIntegration = new Integration("exampleIntegration", IntegrationArgs.builder()
             .restApi(exampleAwsApiGatewayRestApi.id())
             .resourceId(exampleAwsApiGatewayResource.id())
             .httpMethod(exampleAwsApiGatewayMethod.httpMethod())
             .integrationHttpMethod("POST")
             .type("AWS_PROXY")
             .uri(example.invokeArn())
             .build());
 
     }
 }
        ### Function Configuration Reference ### Function Version Management 
         
 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.GetFunctionArgs;
 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 details about specific version
         final var version = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-function")
             .qualifier("3")
             .build());
 
         // Get details about latest version
         final var latest = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-function")
             .qualifier("$LATEST")
             .build());
 
         ctx.export("versionComparison", Map.ofEntries(
             Map.entry("specificVersion", version.version()),
             Map.entry("latestVersion", latest.version()),
             Map.entry("codeDifference", version.codeSha256() != latest.codeSha256())
         ));
     }
 }
        ### Accessing Durable Configuration 
         
 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.GetFunctionArgs;
 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 durableFunction = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-durable-function")
             .build());
 
         ctx.export("durableSettings", Map.ofEntries(
             Map.entry("hasDurableConfig", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0)),
             Map.entry("executionTimeout", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0 ? durableFunction.durableConfigs()[0].executionTimeout() : null)),
             Map.entry("retentionPeriod", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0 ? durableFunction.durableConfigs()[0].retentionPeriod() : null))
         ));
     }
 }

      • getFunctionPlain

        public static java.util.concurrent.CompletableFuture<GetFunctionResult> getFunctionPlain​(GetFunctionPlainArgs args)
        Provides details about an AWS Lambda Function. Use this data source to obtain information about an existing Lambda function for use in other resources or as a reference for function configurations. > **Note:** This data source returns information about the latest version or alias specified by the `qualifier`. If no `qualifier` is provided, it returns information about the most recent published version, or `$LATEST` if no published version exists. ## Example Usage ### Basic Usage 
         
 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.GetFunctionArgs;
 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.getFunction(GetFunctionArgs.builder()
             .functionName("my-lambda-function")
             .build());
 
         ctx.export("functionArn", example.arn());
     }
 }
        ### Using Function Alias 
         
 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.GetFunctionArgs;
 import com.pulumi.aws.apigateway.Integration;
 import com.pulumi.aws.apigateway.IntegrationArgs;
 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.getFunction(GetFunctionArgs.builder()
             .functionName("api-handler")
             .qualifier("production")
             .build());
 
         // Use in API Gateway integration
         var exampleIntegration = new Integration("exampleIntegration", IntegrationArgs.builder()
             .restApi(exampleAwsApiGatewayRestApi.id())
             .resourceId(exampleAwsApiGatewayResource.id())
             .httpMethod(exampleAwsApiGatewayMethod.httpMethod())
             .integrationHttpMethod("POST")
             .type("AWS_PROXY")
             .uri(example.invokeArn())
             .build());
 
     }
 }
        ### Function Configuration Reference ### Function Version Management 
         
 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.GetFunctionArgs;
 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 details about specific version
         final var version = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-function")
             .qualifier("3")
             .build());
 
         // Get details about latest version
         final var latest = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-function")
             .qualifier("$LATEST")
             .build());
 
         ctx.export("versionComparison", Map.ofEntries(
             Map.entry("specificVersion", version.version()),
             Map.entry("latestVersion", latest.version()),
             Map.entry("codeDifference", version.codeSha256() != latest.codeSha256())
         ));
     }
 }
        ### Accessing Durable Configuration 
         
 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.GetFunctionArgs;
 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 durableFunction = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-durable-function")
             .build());
 
         ctx.export("durableSettings", Map.ofEntries(
             Map.entry("hasDurableConfig", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0)),
             Map.entry("executionTimeout", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0 ? durableFunction.durableConfigs()[0].executionTimeout() : null)),
             Map.entry("retentionPeriod", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0 ? durableFunction.durableConfigs()[0].retentionPeriod() : null))
         ));
     }
 }

      • getFunction

        public static com.pulumi.core.Output<GetFunctionResult> getFunction​(GetFunctionArgs args,
                                                                    com.pulumi.deployment.InvokeOptions options)
        Provides details about an AWS Lambda Function. Use this data source to obtain information about an existing Lambda function for use in other resources or as a reference for function configurations. > **Note:** This data source returns information about the latest version or alias specified by the `qualifier`. If no `qualifier` is provided, it returns information about the most recent published version, or `$LATEST` if no published version exists. ## Example Usage ### Basic Usage 
         
 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.GetFunctionArgs;
 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.getFunction(GetFunctionArgs.builder()
             .functionName("my-lambda-function")
             .build());
 
         ctx.export("functionArn", example.arn());
     }
 }
        ### Using Function Alias 
         
 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.GetFunctionArgs;
 import com.pulumi.aws.apigateway.Integration;
 import com.pulumi.aws.apigateway.IntegrationArgs;
 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.getFunction(GetFunctionArgs.builder()
             .functionName("api-handler")
             .qualifier("production")
             .build());
 
         // Use in API Gateway integration
         var exampleIntegration = new Integration("exampleIntegration", IntegrationArgs.builder()
             .restApi(exampleAwsApiGatewayRestApi.id())
             .resourceId(exampleAwsApiGatewayResource.id())
             .httpMethod(exampleAwsApiGatewayMethod.httpMethod())
             .integrationHttpMethod("POST")
             .type("AWS_PROXY")
             .uri(example.invokeArn())
             .build());
 
     }
 }
        ### Function Configuration Reference ### Function Version Management 
         
 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.GetFunctionArgs;
 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 details about specific version
         final var version = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-function")
             .qualifier("3")
             .build());
 
         // Get details about latest version
         final var latest = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-function")
             .qualifier("$LATEST")
             .build());
 
         ctx.export("versionComparison", Map.ofEntries(
             Map.entry("specificVersion", version.version()),
             Map.entry("latestVersion", latest.version()),
             Map.entry("codeDifference", version.codeSha256() != latest.codeSha256())
         ));
     }
 }
        ### Accessing Durable Configuration 
         
 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.GetFunctionArgs;
 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 durableFunction = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-durable-function")
             .build());
 
         ctx.export("durableSettings", Map.ofEntries(
             Map.entry("hasDurableConfig", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0)),
             Map.entry("executionTimeout", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0 ? durableFunction.durableConfigs()[0].executionTimeout() : null)),
             Map.entry("retentionPeriod", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0 ? durableFunction.durableConfigs()[0].retentionPeriod() : null))
         ));
     }
 }

      • getFunction

        public static com.pulumi.core.Output<GetFunctionResult> getFunction​(GetFunctionArgs args,
                                                                    com.pulumi.deployment.InvokeOutputOptions options)
        Provides details about an AWS Lambda Function. Use this data source to obtain information about an existing Lambda function for use in other resources or as a reference for function configurations. > **Note:** This data source returns information about the latest version or alias specified by the `qualifier`. If no `qualifier` is provided, it returns information about the most recent published version, or `$LATEST` if no published version exists. ## Example Usage ### Basic Usage 
         
 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.GetFunctionArgs;
 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.getFunction(GetFunctionArgs.builder()
             .functionName("my-lambda-function")
             .build());
 
         ctx.export("functionArn", example.arn());
     }
 }
        ### Using Function Alias 
         
 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.GetFunctionArgs;
 import com.pulumi.aws.apigateway.Integration;
 import com.pulumi.aws.apigateway.IntegrationArgs;
 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.getFunction(GetFunctionArgs.builder()
             .functionName("api-handler")
             .qualifier("production")
             .build());
 
         // Use in API Gateway integration
         var exampleIntegration = new Integration("exampleIntegration", IntegrationArgs.builder()
             .restApi(exampleAwsApiGatewayRestApi.id())
             .resourceId(exampleAwsApiGatewayResource.id())
             .httpMethod(exampleAwsApiGatewayMethod.httpMethod())
             .integrationHttpMethod("POST")
             .type("AWS_PROXY")
             .uri(example.invokeArn())
             .build());
 
     }
 }
        ### Function Configuration Reference ### Function Version Management 
         
 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.GetFunctionArgs;
 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 details about specific version
         final var version = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-function")
             .qualifier("3")
             .build());
 
         // Get details about latest version
         final var latest = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-function")
             .qualifier("$LATEST")
             .build());
 
         ctx.export("versionComparison", Map.ofEntries(
             Map.entry("specificVersion", version.version()),
             Map.entry("latestVersion", latest.version()),
             Map.entry("codeDifference", version.codeSha256() != latest.codeSha256())
         ));
     }
 }
        ### Accessing Durable Configuration 
         
 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.GetFunctionArgs;
 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 durableFunction = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-durable-function")
             .build());
 
         ctx.export("durableSettings", Map.ofEntries(
             Map.entry("hasDurableConfig", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0)),
             Map.entry("executionTimeout", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0 ? durableFunction.durableConfigs()[0].executionTimeout() : null)),
             Map.entry("retentionPeriod", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0 ? durableFunction.durableConfigs()[0].retentionPeriod() : null))
         ));
     }
 }

      • getFunctionPlain

        public static java.util.concurrent.CompletableFuture<GetFunctionResult> getFunctionPlain​(GetFunctionPlainArgs args,
                                                                                         com.pulumi.deployment.InvokeOptions options)
        Provides details about an AWS Lambda Function. Use this data source to obtain information about an existing Lambda function for use in other resources or as a reference for function configurations. > **Note:** This data source returns information about the latest version or alias specified by the `qualifier`. If no `qualifier` is provided, it returns information about the most recent published version, or `$LATEST` if no published version exists. ## Example Usage ### Basic Usage 
         
 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.GetFunctionArgs;
 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.getFunction(GetFunctionArgs.builder()
             .functionName("my-lambda-function")
             .build());
 
         ctx.export("functionArn", example.arn());
     }
 }
        ### Using Function Alias 
         
 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.GetFunctionArgs;
 import com.pulumi.aws.apigateway.Integration;
 import com.pulumi.aws.apigateway.IntegrationArgs;
 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.getFunction(GetFunctionArgs.builder()
             .functionName("api-handler")
             .qualifier("production")
             .build());
 
         // Use in API Gateway integration
         var exampleIntegration = new Integration("exampleIntegration", IntegrationArgs.builder()
             .restApi(exampleAwsApiGatewayRestApi.id())
             .resourceId(exampleAwsApiGatewayResource.id())
             .httpMethod(exampleAwsApiGatewayMethod.httpMethod())
             .integrationHttpMethod("POST")
             .type("AWS_PROXY")
             .uri(example.invokeArn())
             .build());
 
     }
 }
        ### Function Configuration Reference ### Function Version Management 
         
 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.GetFunctionArgs;
 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 details about specific version
         final var version = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-function")
             .qualifier("3")
             .build());
 
         // Get details about latest version
         final var latest = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-function")
             .qualifier("$LATEST")
             .build());
 
         ctx.export("versionComparison", Map.ofEntries(
             Map.entry("specificVersion", version.version()),
             Map.entry("latestVersion", latest.version()),
             Map.entry("codeDifference", version.codeSha256() != latest.codeSha256())
         ));
     }
 }
        ### Accessing Durable Configuration 
         
 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.GetFunctionArgs;
 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 durableFunction = LambdaFunctions.getFunction(GetFunctionArgs.builder()
             .functionName("my-durable-function")
             .build());
 
         ctx.export("durableSettings", Map.ofEntries(
             Map.entry("hasDurableConfig", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0)),
             Map.entry("executionTimeout", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0 ? durableFunction.durableConfigs()[0].executionTimeout() : null)),
             Map.entry("retentionPeriod", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0 ? durableFunction.durableConfigs()[0].retentionPeriod() : null))
         ));
     }
 }

      • getFunctionUrl

        public static com.pulumi.core.Output<GetFunctionUrlResult> getFunctionUrl​(GetFunctionUrlArgs args)
        Provides details about an AWS Lambda Function URL. Use this data source to retrieve information about an existing function URL configuration. ## Example Usage ### Basic Usage 
         
 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.GetFunctionUrlArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName("my_lambda_function")
             .build());
 
         ctx.export("functionUrl", example.functionUrl());
     }
 }
        ### With Qualifier 
         
 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.GetFunctionUrlArgs;
 import com.pulumi.aws.route53.Record;
 import com.pulumi.aws.route53.RecordArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.ReplaceArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName(exampleAwsLambdaFunction.functionName())
             .qualifier("production")
             .build());
 
         // Use the URL in other resources
         var lambdaAlias = new Record("lambdaAlias", RecordArgs.builder()
             .zoneId(exampleAwsRoute53Zone.zoneId())
             .name("api.example.com")
             .type("CNAME")
             .ttl(300)
             .records(StdFunctions.replace(ReplaceArgs.builder()
                 .text(example.functionUrl())
                 .search("https://")
                 .replace("")
                 .build()).result())
             .build());
 
     }
 }
        ### Retrieve CORS Configuration 
         
 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.GetFunctionUrlArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName("api_function")
             .build());
 
         final var corsConfig = example.cors().size().applyValue(_length -> _length > 0 ? example.cors()[0] : null);
 
         final var allowedOrigins = corsConfig != null ? corsConfig.allowOrigins() : Arrays.asList();
 
         ctx.export("corsAllowedOrigins", allowedOrigins);
     }
 }

      • getFunctionUrlPlain

        public static java.util.concurrent.CompletableFuture<GetFunctionUrlResult> getFunctionUrlPlain​(GetFunctionUrlPlainArgs args)
        Provides details about an AWS Lambda Function URL. Use this data source to retrieve information about an existing function URL configuration. ## Example Usage ### Basic Usage 
         
 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.GetFunctionUrlArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName("my_lambda_function")
             .build());
 
         ctx.export("functionUrl", example.functionUrl());
     }
 }
        ### With Qualifier 
         
 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.GetFunctionUrlArgs;
 import com.pulumi.aws.route53.Record;
 import com.pulumi.aws.route53.RecordArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.ReplaceArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName(exampleAwsLambdaFunction.functionName())
             .qualifier("production")
             .build());
 
         // Use the URL in other resources
         var lambdaAlias = new Record("lambdaAlias", RecordArgs.builder()
             .zoneId(exampleAwsRoute53Zone.zoneId())
             .name("api.example.com")
             .type("CNAME")
             .ttl(300)
             .records(StdFunctions.replace(ReplaceArgs.builder()
                 .text(example.functionUrl())
                 .search("https://")
                 .replace("")
                 .build()).result())
             .build());
 
     }
 }
        ### Retrieve CORS Configuration 
         
 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.GetFunctionUrlArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName("api_function")
             .build());
 
         final var corsConfig = example.cors().size().applyValue(_length -> _length > 0 ? example.cors()[0] : null);
 
         final var allowedOrigins = corsConfig != null ? corsConfig.allowOrigins() : Arrays.asList();
 
         ctx.export("corsAllowedOrigins", allowedOrigins);
     }
 }

      • getFunctionUrl

        public static com.pulumi.core.Output<GetFunctionUrlResult> getFunctionUrl​(GetFunctionUrlArgs args,
                                                                          com.pulumi.deployment.InvokeOptions options)
        Provides details about an AWS Lambda Function URL. Use this data source to retrieve information about an existing function URL configuration. ## Example Usage ### Basic Usage 
         
 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.GetFunctionUrlArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName("my_lambda_function")
             .build());
 
         ctx.export("functionUrl", example.functionUrl());
     }
 }
        ### With Qualifier 
         
 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.GetFunctionUrlArgs;
 import com.pulumi.aws.route53.Record;
 import com.pulumi.aws.route53.RecordArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.ReplaceArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName(exampleAwsLambdaFunction.functionName())
             .qualifier("production")
             .build());
 
         // Use the URL in other resources
         var lambdaAlias = new Record("lambdaAlias", RecordArgs.builder()
             .zoneId(exampleAwsRoute53Zone.zoneId())
             .name("api.example.com")
             .type("CNAME")
             .ttl(300)
             .records(StdFunctions.replace(ReplaceArgs.builder()
                 .text(example.functionUrl())
                 .search("https://")
                 .replace("")
                 .build()).result())
             .build());
 
     }
 }
        ### Retrieve CORS Configuration 
         
 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.GetFunctionUrlArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName("api_function")
             .build());
 
         final var corsConfig = example.cors().size().applyValue(_length -> _length > 0 ? example.cors()[0] : null);
 
         final var allowedOrigins = corsConfig != null ? corsConfig.allowOrigins() : Arrays.asList();
 
         ctx.export("corsAllowedOrigins", allowedOrigins);
     }
 }

      • getFunctionUrl

        public static com.pulumi.core.Output<GetFunctionUrlResult> getFunctionUrl​(GetFunctionUrlArgs args,
                                                                          com.pulumi.deployment.InvokeOutputOptions options)
        Provides details about an AWS Lambda Function URL. Use this data source to retrieve information about an existing function URL configuration. ## Example Usage ### Basic Usage 
         
 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.GetFunctionUrlArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName("my_lambda_function")
             .build());
 
         ctx.export("functionUrl", example.functionUrl());
     }
 }
        ### With Qualifier 
         
 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.GetFunctionUrlArgs;
 import com.pulumi.aws.route53.Record;
 import com.pulumi.aws.route53.RecordArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.ReplaceArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName(exampleAwsLambdaFunction.functionName())
             .qualifier("production")
             .build());
 
         // Use the URL in other resources
         var lambdaAlias = new Record("lambdaAlias", RecordArgs.builder()
             .zoneId(exampleAwsRoute53Zone.zoneId())
             .name("api.example.com")
             .type("CNAME")
             .ttl(300)
             .records(StdFunctions.replace(ReplaceArgs.builder()
                 .text(example.functionUrl())
                 .search("https://")
                 .replace("")
                 .build()).result())
             .build());
 
     }
 }
        ### Retrieve CORS Configuration 
         
 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.GetFunctionUrlArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName("api_function")
             .build());
 
         final var corsConfig = example.cors().size().applyValue(_length -> _length > 0 ? example.cors()[0] : null);
 
         final var allowedOrigins = corsConfig != null ? corsConfig.allowOrigins() : Arrays.asList();
 
         ctx.export("corsAllowedOrigins", allowedOrigins);
     }
 }

      • getFunctionUrlPlain

        public static java.util.concurrent.CompletableFuture<GetFunctionUrlResult> getFunctionUrlPlain​(GetFunctionUrlPlainArgs args,
                                                                                               com.pulumi.deployment.InvokeOptions options)
        Provides details about an AWS Lambda Function URL. Use this data source to retrieve information about an existing function URL configuration. ## Example Usage ### Basic Usage 
         
 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.GetFunctionUrlArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName("my_lambda_function")
             .build());
 
         ctx.export("functionUrl", example.functionUrl());
     }
 }
        ### With Qualifier 
         
 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.GetFunctionUrlArgs;
 import com.pulumi.aws.route53.Record;
 import com.pulumi.aws.route53.RecordArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.ReplaceArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName(exampleAwsLambdaFunction.functionName())
             .qualifier("production")
             .build());
 
         // Use the URL in other resources
         var lambdaAlias = new Record("lambdaAlias", RecordArgs.builder()
             .zoneId(exampleAwsRoute53Zone.zoneId())
             .name("api.example.com")
             .type("CNAME")
             .ttl(300)
             .records(StdFunctions.replace(ReplaceArgs.builder()
                 .text(example.functionUrl())
                 .search("https://")
                 .replace("")
                 .build()).result())
             .build());
 
     }
 }
        ### Retrieve CORS Configuration 
         
 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.GetFunctionUrlArgs;
 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.getFunctionUrl(GetFunctionUrlArgs.builder()
             .functionName("api_function")
             .build());
 
         final var corsConfig = example.cors().size().applyValue(_length -> _length > 0 ? example.cors()[0] : null);
 
         final var allowedOrigins = corsConfig != null ? corsConfig.allowOrigins() : Arrays.asList();
 
         ctx.export("corsAllowedOrigins", allowedOrigins);
     }
 }

      • getFunctions

        public static com.pulumi.core.Output<GetFunctionsResult> getFunctions()
        Provides a list of AWS Lambda Functions in the current region. Use this data source to discover existing Lambda functions for inventory, monitoring, or bulk operations. ## Example Usage ### List All Functions 
         
 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.GetFunctionsArgs;
 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 all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         ctx.export("functionCount", all.functionNames().size());
         ctx.export("allFunctionNames", all.functionNames());
     }
 }
        ### Use Function List for Bulk Operations 
         
 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.GetFunctionsArgs;
 import com.pulumi.aws.cloudwatch.MetricAlarm;
 import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
 import com.pulumi.codegen.internal.KeyedValue;
 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 all Lambda functions
         final var all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         // Create CloudWatch alarms for all functions
         for (var i = 0; i < all.functionNames().size(); i++) {
             new MetricAlarm("lambdaErrors-" + i, MetricAlarmArgs.builder()
                 .name(String.format("%s-errors", all.functionNames()[range.value()]))
                 .comparisonOperator("GreaterThanThreshold")
                 .evaluationPeriods(2)
                 .metricName("Errors")
                 .namespace("AWS/Lambda")
                 .period(300)
                 .statistic("Sum")
                 .threshold(5.0)
                 .alarmDescription("This metric monitors lambda errors")
                 .dimensions(Map.of("FunctionName", all.functionNames()[range.value()]))
                 .tags(Map.ofEntries(
                     Map.entry("Environment", "monitoring"),
                     Map.entry("Purpose", "lambda-error-tracking")
                 ))
                 .build());
 
         
 }
     }
 }
        ### Filter Functions by Name Pattern ### Create Function Inventory

      • getFunctionsPlain

        public static java.util.concurrent.CompletableFuture<GetFunctionsResult> getFunctionsPlain()
        Provides a list of AWS Lambda Functions in the current region. Use this data source to discover existing Lambda functions for inventory, monitoring, or bulk operations. ## Example Usage ### List All Functions 
         
 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.GetFunctionsArgs;
 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 all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         ctx.export("functionCount", all.functionNames().size());
         ctx.export("allFunctionNames", all.functionNames());
     }
 }
        ### Use Function List for Bulk Operations 
         
 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.GetFunctionsArgs;
 import com.pulumi.aws.cloudwatch.MetricAlarm;
 import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
 import com.pulumi.codegen.internal.KeyedValue;
 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 all Lambda functions
         final var all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         // Create CloudWatch alarms for all functions
         for (var i = 0; i < all.functionNames().size(); i++) {
             new MetricAlarm("lambdaErrors-" + i, MetricAlarmArgs.builder()
                 .name(String.format("%s-errors", all.functionNames()[range.value()]))
                 .comparisonOperator("GreaterThanThreshold")
                 .evaluationPeriods(2)
                 .metricName("Errors")
                 .namespace("AWS/Lambda")
                 .period(300)
                 .statistic("Sum")
                 .threshold(5.0)
                 .alarmDescription("This metric monitors lambda errors")
                 .dimensions(Map.of("FunctionName", all.functionNames()[range.value()]))
                 .tags(Map.ofEntries(
                     Map.entry("Environment", "monitoring"),
                     Map.entry("Purpose", "lambda-error-tracking")
                 ))
                 .build());
 
         
 }
     }
 }
        ### Filter Functions by Name Pattern ### Create Function Inventory

      • getFunctions

        public static com.pulumi.core.Output<GetFunctionsResult> getFunctions​(GetFunctionsArgs args)
        Provides a list of AWS Lambda Functions in the current region. Use this data source to discover existing Lambda functions for inventory, monitoring, or bulk operations. ## Example Usage ### List All Functions 
         
 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.GetFunctionsArgs;
 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 all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         ctx.export("functionCount", all.functionNames().size());
         ctx.export("allFunctionNames", all.functionNames());
     }
 }
        ### Use Function List for Bulk Operations 
         
 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.GetFunctionsArgs;
 import com.pulumi.aws.cloudwatch.MetricAlarm;
 import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
 import com.pulumi.codegen.internal.KeyedValue;
 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 all Lambda functions
         final var all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         // Create CloudWatch alarms for all functions
         for (var i = 0; i < all.functionNames().size(); i++) {
             new MetricAlarm("lambdaErrors-" + i, MetricAlarmArgs.builder()
                 .name(String.format("%s-errors", all.functionNames()[range.value()]))
                 .comparisonOperator("GreaterThanThreshold")
                 .evaluationPeriods(2)
                 .metricName("Errors")
                 .namespace("AWS/Lambda")
                 .period(300)
                 .statistic("Sum")
                 .threshold(5.0)
                 .alarmDescription("This metric monitors lambda errors")
                 .dimensions(Map.of("FunctionName", all.functionNames()[range.value()]))
                 .tags(Map.ofEntries(
                     Map.entry("Environment", "monitoring"),
                     Map.entry("Purpose", "lambda-error-tracking")
                 ))
                 .build());
 
         
 }
     }
 }
        ### Filter Functions by Name Pattern ### Create Function Inventory

      • getFunctionsPlain

        public static java.util.concurrent.CompletableFuture<GetFunctionsResult> getFunctionsPlain​(GetFunctionsPlainArgs args)
        Provides a list of AWS Lambda Functions in the current region. Use this data source to discover existing Lambda functions for inventory, monitoring, or bulk operations. ## Example Usage ### List All Functions 
         
 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.GetFunctionsArgs;
 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 all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         ctx.export("functionCount", all.functionNames().size());
         ctx.export("allFunctionNames", all.functionNames());
     }
 }
        ### Use Function List for Bulk Operations 
         
 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.GetFunctionsArgs;
 import com.pulumi.aws.cloudwatch.MetricAlarm;
 import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
 import com.pulumi.codegen.internal.KeyedValue;
 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 all Lambda functions
         final var all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         // Create CloudWatch alarms for all functions
         for (var i = 0; i < all.functionNames().size(); i++) {
             new MetricAlarm("lambdaErrors-" + i, MetricAlarmArgs.builder()
                 .name(String.format("%s-errors", all.functionNames()[range.value()]))
                 .comparisonOperator("GreaterThanThreshold")
                 .evaluationPeriods(2)
                 .metricName("Errors")
                 .namespace("AWS/Lambda")
                 .period(300)
                 .statistic("Sum")
                 .threshold(5.0)
                 .alarmDescription("This metric monitors lambda errors")
                 .dimensions(Map.of("FunctionName", all.functionNames()[range.value()]))
                 .tags(Map.ofEntries(
                     Map.entry("Environment", "monitoring"),
                     Map.entry("Purpose", "lambda-error-tracking")
                 ))
                 .build());
 
         
 }
     }
 }
        ### Filter Functions by Name Pattern ### Create Function Inventory

      • getFunctions

        public static com.pulumi.core.Output<GetFunctionsResult> getFunctions​(GetFunctionsArgs args,
                                                                      com.pulumi.deployment.InvokeOptions options)
        Provides a list of AWS Lambda Functions in the current region. Use this data source to discover existing Lambda functions for inventory, monitoring, or bulk operations. ## Example Usage ### List All Functions 
         
 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.GetFunctionsArgs;
 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 all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         ctx.export("functionCount", all.functionNames().size());
         ctx.export("allFunctionNames", all.functionNames());
     }
 }
        ### Use Function List for Bulk Operations 
         
 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.GetFunctionsArgs;
 import com.pulumi.aws.cloudwatch.MetricAlarm;
 import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
 import com.pulumi.codegen.internal.KeyedValue;
 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 all Lambda functions
         final var all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         // Create CloudWatch alarms for all functions
         for (var i = 0; i < all.functionNames().size(); i++) {
             new MetricAlarm("lambdaErrors-" + i, MetricAlarmArgs.builder()
                 .name(String.format("%s-errors", all.functionNames()[range.value()]))
                 .comparisonOperator("GreaterThanThreshold")
                 .evaluationPeriods(2)
                 .metricName("Errors")
                 .namespace("AWS/Lambda")
                 .period(300)
                 .statistic("Sum")
                 .threshold(5.0)
                 .alarmDescription("This metric monitors lambda errors")
                 .dimensions(Map.of("FunctionName", all.functionNames()[range.value()]))
                 .tags(Map.ofEntries(
                     Map.entry("Environment", "monitoring"),
                     Map.entry("Purpose", "lambda-error-tracking")
                 ))
                 .build());
 
         
 }
     }
 }
        ### Filter Functions by Name Pattern ### Create Function Inventory

      • getFunctions

        public static com.pulumi.core.Output<GetFunctionsResult> getFunctions​(GetFunctionsArgs args,
                                                                      com.pulumi.deployment.InvokeOutputOptions options)
        Provides a list of AWS Lambda Functions in the current region. Use this data source to discover existing Lambda functions for inventory, monitoring, or bulk operations. ## Example Usage ### List All Functions 
         
 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.GetFunctionsArgs;
 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 all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         ctx.export("functionCount", all.functionNames().size());
         ctx.export("allFunctionNames", all.functionNames());
     }
 }
        ### Use Function List for Bulk Operations 
         
 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.GetFunctionsArgs;
 import com.pulumi.aws.cloudwatch.MetricAlarm;
 import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
 import com.pulumi.codegen.internal.KeyedValue;
 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 all Lambda functions
         final var all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         // Create CloudWatch alarms for all functions
         for (var i = 0; i < all.functionNames().size(); i++) {
             new MetricAlarm("lambdaErrors-" + i, MetricAlarmArgs.builder()
                 .name(String.format("%s-errors", all.functionNames()[range.value()]))
                 .comparisonOperator("GreaterThanThreshold")
                 .evaluationPeriods(2)
                 .metricName("Errors")
                 .namespace("AWS/Lambda")
                 .period(300)
                 .statistic("Sum")
                 .threshold(5.0)
                 .alarmDescription("This metric monitors lambda errors")
                 .dimensions(Map.of("FunctionName", all.functionNames()[range.value()]))
                 .tags(Map.ofEntries(
                     Map.entry("Environment", "monitoring"),
                     Map.entry("Purpose", "lambda-error-tracking")
                 ))
                 .build());
 
         
 }
     }
 }
        ### Filter Functions by Name Pattern ### Create Function Inventory

      • getFunctionsPlain

        public static java.util.concurrent.CompletableFuture<GetFunctionsResult> getFunctionsPlain​(GetFunctionsPlainArgs args,
                                                                                           com.pulumi.deployment.InvokeOptions options)
        Provides a list of AWS Lambda Functions in the current region. Use this data source to discover existing Lambda functions for inventory, monitoring, or bulk operations. ## Example Usage ### List All Functions 
         
 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.GetFunctionsArgs;
 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 all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         ctx.export("functionCount", all.functionNames().size());
         ctx.export("allFunctionNames", all.functionNames());
     }
 }
        ### Use Function List for Bulk Operations 
         
 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.GetFunctionsArgs;
 import com.pulumi.aws.cloudwatch.MetricAlarm;
 import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
 import com.pulumi.codegen.internal.KeyedValue;
 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 all Lambda functions
         final var all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
             .build());
 
         // Create CloudWatch alarms for all functions
         for (var i = 0; i < all.functionNames().size(); i++) {
             new MetricAlarm("lambdaErrors-" + i, MetricAlarmArgs.builder()
                 .name(String.format("%s-errors", all.functionNames()[range.value()]))
                 .comparisonOperator("GreaterThanThreshold")
                 .evaluationPeriods(2)
                 .metricName("Errors")
                 .namespace("AWS/Lambda")
                 .period(300)
                 .statistic("Sum")
                 .threshold(5.0)
                 .alarmDescription("This metric monitors lambda errors")
                 .dimensions(Map.of("FunctionName", all.functionNames()[range.value()]))
                 .tags(Map.ofEntries(
                     Map.entry("Environment", "monitoring"),
                     Map.entry("Purpose", "lambda-error-tracking")
                 ))
                 .build());
 
         
 }
     }
 }
        ### Filter Functions by Name Pattern ### Create Function Inventory

      • getInvocation

        public static com.pulumi.core.Output<GetInvocationResult> getInvocation​(GetInvocationArgs args)
        Invokes an AWS Lambda Function and returns its results. Use this data source to execute Lambda functions during Pulumi operations and use their results in other resources or outputs. The Lambda function is invoked with [RequestResponse](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html#API_Invoke_RequestSyntax) invocation type. > **Note:** The `aws.lambda.Invocation` data source invokes the function during the first `apply` and every subsequent `plan` when the function is known. > **Note:** If you get a `KMSAccessDeniedException: Lambda was unable to decrypt the environment variables because KMS access was denied` error when invoking a Lambda function with environment variables, the IAM role associated with the function may have been deleted and recreated after the function was created. You can fix the problem two ways: 1) updating the function's role to another role and then updating it back again to the recreated role. (When you create a function, Lambda grants permissions on the KMS key to the function's IAM role. If the IAM role is recreated, the grant is no longer valid. Changing the function's role or recreating the function causes Lambda to update the grant.) ## Example Usage ### Basic Invocation 
         
 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.GetInvocationArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.JsondecodeArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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.getInvocation(GetInvocationArgs.builder()
             .functionName(exampleAwsLambdaFunction.functionName())
             .input(serializeJson(
                 jsonObject(
                     jsonProperty("operation", "getStatus"),
                     jsonProperty("id", "123456")
                 )))
             .build());
 
         ctx.export("result", StdFunctions.jsondecode(JsondecodeArgs.builder()
             .input(example.result())
             .build()).result());
     }
 }
        ### Dynamic Resource Configuration 
         
 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.GetInvocationArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.JsondecodeArgs;
 import com.pulumi.aws.elasticache.Cluster;
 import com.pulumi.aws.elasticache.ClusterArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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 resource configuration from Lambda
         final var resourceConfig = LambdaFunctions.getInvocation(GetInvocationArgs.builder()
             .functionName("resource-config-generator")
             .qualifier("production")
             .input(serializeJson(
                 jsonObject(
                     jsonProperty("environment", environment),
                     jsonProperty("region", current.region()),
                     jsonProperty("service", "api")
                 )))
             .build());
 
         final var config = StdFunctions.jsondecode(JsondecodeArgs.builder()
             .input(resourceConfig.result())
             .build()).result();
 
         // Use dynamic configuration
         var example = new Cluster("example", ClusterArgs.builder()
             .clusterId(config.cache().clusterId())
             .engine(config.cache().engine())
             .nodeType(config.cache().nodeType())
             .numCacheNodes(config.cache().nodes())
             .parameterGroupName(config.cache().parameterGroup())
             .tags(config.tags())
             .build());
 
     }
 }

      • getInvocationPlain

        public static java.util.concurrent.CompletableFuture<GetInvocationResult> getInvocationPlain​(GetInvocationPlainArgs args)
        Invokes an AWS Lambda Function and returns its results. Use this data source to execute Lambda functions during Pulumi operations and use their results in other resources or outputs. The Lambda function is invoked with [RequestResponse](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html#API_Invoke_RequestSyntax) invocation type. > **Note:** The `aws.lambda.Invocation` data source invokes the function during the first `apply` and every subsequent `plan` when the function is known. > **Note:** If you get a `KMSAccessDeniedException: Lambda was unable to decrypt the environment variables because KMS access was denied` error when invoking a Lambda function with environment variables, the IAM role associated with the function may have been deleted and recreated after the function was created. You can fix the problem two ways: 1) updating the function's role to another role and then updating it back again to the recreated role. (When you create a function, Lambda grants permissions on the KMS key to the function's IAM role. If the IAM role is recreated, the grant is no longer valid. Changing the function's role or recreating the function causes Lambda to update the grant.) ## Example Usage ### Basic Invocation 
         
 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.GetInvocationArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.JsondecodeArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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.getInvocation(GetInvocationArgs.builder()
             .functionName(exampleAwsLambdaFunction.functionName())
             .input(serializeJson(
                 jsonObject(
                     jsonProperty("operation", "getStatus"),
                     jsonProperty("id", "123456")
                 )))
             .build());
 
         ctx.export("result", StdFunctions.jsondecode(JsondecodeArgs.builder()
             .input(example.result())
             .build()).result());
     }
 }
        ### Dynamic Resource Configuration 
         
 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.GetInvocationArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.JsondecodeArgs;
 import com.pulumi.aws.elasticache.Cluster;
 import com.pulumi.aws.elasticache.ClusterArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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 resource configuration from Lambda
         final var resourceConfig = LambdaFunctions.getInvocation(GetInvocationArgs.builder()
             .functionName("resource-config-generator")
             .qualifier("production")
             .input(serializeJson(
                 jsonObject(
                     jsonProperty("environment", environment),
                     jsonProperty("region", current.region()),
                     jsonProperty("service", "api")
                 )))
             .build());
 
         final var config = StdFunctions.jsondecode(JsondecodeArgs.builder()
             .input(resourceConfig.result())
             .build()).result();
 
         // Use dynamic configuration
         var example = new Cluster("example", ClusterArgs.builder()
             .clusterId(config.cache().clusterId())
             .engine(config.cache().engine())
             .nodeType(config.cache().nodeType())
             .numCacheNodes(config.cache().nodes())
             .parameterGroupName(config.cache().parameterGroup())
             .tags(config.tags())
             .build());
 
     }
 }

      • getInvocation

        public static com.pulumi.core.Output<GetInvocationResult> getInvocation​(GetInvocationArgs args,
                                                                        com.pulumi.deployment.InvokeOptions options)
        Invokes an AWS Lambda Function and returns its results. Use this data source to execute Lambda functions during Pulumi operations and use their results in other resources or outputs. The Lambda function is invoked with [RequestResponse](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html#API_Invoke_RequestSyntax) invocation type. > **Note:** The `aws.lambda.Invocation` data source invokes the function during the first `apply` and every subsequent `plan` when the function is known. > **Note:** If you get a `KMSAccessDeniedException: Lambda was unable to decrypt the environment variables because KMS access was denied` error when invoking a Lambda function with environment variables, the IAM role associated with the function may have been deleted and recreated after the function was created. You can fix the problem two ways: 1) updating the function's role to another role and then updating it back again to the recreated role. (When you create a function, Lambda grants permissions on the KMS key to the function's IAM role. If the IAM role is recreated, the grant is no longer valid. Changing the function's role or recreating the function causes Lambda to update the grant.) ## Example Usage ### Basic Invocation 
         
 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.GetInvocationArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.JsondecodeArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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.getInvocation(GetInvocationArgs.builder()
             .functionName(exampleAwsLambdaFunction.functionName())
             .input(serializeJson(
                 jsonObject(
                     jsonProperty("operation", "getStatus"),
                     jsonProperty("id", "123456")
                 )))
             .build());
 
         ctx.export("result", StdFunctions.jsondecode(JsondecodeArgs.builder()
             .input(example.result())
             .build()).result());
     }
 }
        ### Dynamic Resource Configuration 
         
 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.GetInvocationArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.JsondecodeArgs;
 import com.pulumi.aws.elasticache.Cluster;
 import com.pulumi.aws.elasticache.ClusterArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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 resource configuration from Lambda
         final var resourceConfig = LambdaFunctions.getInvocation(GetInvocationArgs.builder()
             .functionName("resource-config-generator")
             .qualifier("production")
             .input(serializeJson(
                 jsonObject(
                     jsonProperty("environment", environment),
                     jsonProperty("region", current.region()),
                     jsonProperty("service", "api")
                 )))
             .build());
 
         final var config = StdFunctions.jsondecode(JsondecodeArgs.builder()
             .input(resourceConfig.result())
             .build()).result();
 
         // Use dynamic configuration
         var example = new Cluster("example", ClusterArgs.builder()
             .clusterId(config.cache().clusterId())
             .engine(config.cache().engine())
             .nodeType(config.cache().nodeType())
             .numCacheNodes(config.cache().nodes())
             .parameterGroupName(config.cache().parameterGroup())
             .tags(config.tags())
             .build());
 
     }
 }

      • getInvocation

        public static com.pulumi.core.Output<GetInvocationResult> getInvocation​(GetInvocationArgs args,
                                                                        com.pulumi.deployment.InvokeOutputOptions options)
        Invokes an AWS Lambda Function and returns its results. Use this data source to execute Lambda functions during Pulumi operations and use their results in other resources or outputs. The Lambda function is invoked with [RequestResponse](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html#API_Invoke_RequestSyntax) invocation type. > **Note:** The `aws.lambda.Invocation` data source invokes the function during the first `apply` and every subsequent `plan` when the function is known. > **Note:** If you get a `KMSAccessDeniedException: Lambda was unable to decrypt the environment variables because KMS access was denied` error when invoking a Lambda function with environment variables, the IAM role associated with the function may have been deleted and recreated after the function was created. You can fix the problem two ways: 1) updating the function's role to another role and then updating it back again to the recreated role. (When you create a function, Lambda grants permissions on the KMS key to the function's IAM role. If the IAM role is recreated, the grant is no longer valid. Changing the function's role or recreating the function causes Lambda to update the grant.) ## Example Usage ### Basic Invocation 
         
 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.GetInvocationArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.JsondecodeArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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.getInvocation(GetInvocationArgs.builder()
             .functionName(exampleAwsLambdaFunction.functionName())
             .input(serializeJson(
                 jsonObject(
                     jsonProperty("operation", "getStatus"),
                     jsonProperty("id", "123456")
                 )))
             .build());
 
         ctx.export("result", StdFunctions.jsondecode(JsondecodeArgs.builder()
             .input(example.result())
             .build()).result());
     }
 }
        ### Dynamic Resource Configuration 
         
 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.GetInvocationArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.JsondecodeArgs;
 import com.pulumi.aws.elasticache.Cluster;
 import com.pulumi.aws.elasticache.ClusterArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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 resource configuration from Lambda
         final var resourceConfig = LambdaFunctions.getInvocation(GetInvocationArgs.builder()
             .functionName("resource-config-generator")
             .qualifier("production")
             .input(serializeJson(
                 jsonObject(
                     jsonProperty("environment", environment),
                     jsonProperty("region", current.region()),
                     jsonProperty("service", "api")
                 )))
             .build());
 
         final var config = StdFunctions.jsondecode(JsondecodeArgs.builder()
             .input(resourceConfig.result())
             .build()).result();
 
         // Use dynamic configuration
         var example = new Cluster("example", ClusterArgs.builder()
             .clusterId(config.cache().clusterId())
             .engine(config.cache().engine())
             .nodeType(config.cache().nodeType())
             .numCacheNodes(config.cache().nodes())
             .parameterGroupName(config.cache().parameterGroup())
             .tags(config.tags())
             .build());
 
     }
 }

      • getInvocationPlain

        public static java.util.concurrent.CompletableFuture<GetInvocationResult> getInvocationPlain​(GetInvocationPlainArgs args,
                                                                                             com.pulumi.deployment.InvokeOptions options)
        Invokes an AWS Lambda Function and returns its results. Use this data source to execute Lambda functions during Pulumi operations and use their results in other resources or outputs. The Lambda function is invoked with [RequestResponse](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html#API_Invoke_RequestSyntax) invocation type. > **Note:** The `aws.lambda.Invocation` data source invokes the function during the first `apply` and every subsequent `plan` when the function is known. > **Note:** If you get a `KMSAccessDeniedException: Lambda was unable to decrypt the environment variables because KMS access was denied` error when invoking a Lambda function with environment variables, the IAM role associated with the function may have been deleted and recreated after the function was created. You can fix the problem two ways: 1) updating the function's role to another role and then updating it back again to the recreated role. (When you create a function, Lambda grants permissions on the KMS key to the function's IAM role. If the IAM role is recreated, the grant is no longer valid. Changing the function's role or recreating the function causes Lambda to update the grant.) ## Example Usage ### Basic Invocation 
         
 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.GetInvocationArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.JsondecodeArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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.getInvocation(GetInvocationArgs.builder()
             .functionName(exampleAwsLambdaFunction.functionName())
             .input(serializeJson(
                 jsonObject(
                     jsonProperty("operation", "getStatus"),
                     jsonProperty("id", "123456")
                 )))
             .build());
 
         ctx.export("result", StdFunctions.jsondecode(JsondecodeArgs.builder()
             .input(example.result())
             .build()).result());
     }
 }
        ### Dynamic Resource Configuration 
         
 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.GetInvocationArgs;
 import com.pulumi.std.StdFunctions;
 import com.pulumi.std.inputs.JsondecodeArgs;
 import com.pulumi.aws.elasticache.Cluster;
 import com.pulumi.aws.elasticache.ClusterArgs;
 import static com.pulumi.codegen.internal.Serialization.*;
 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 resource configuration from Lambda
         final var resourceConfig = LambdaFunctions.getInvocation(GetInvocationArgs.builder()
             .functionName("resource-config-generator")
             .qualifier("production")
             .input(serializeJson(
                 jsonObject(
                     jsonProperty("environment", environment),
                     jsonProperty("region", current.region()),
                     jsonProperty("service", "api")
                 )))
             .build());
 
         final var config = StdFunctions.jsondecode(JsondecodeArgs.builder()
             .input(resourceConfig.result())
             .build()).result();
 
         // Use dynamic configuration
         var example = new Cluster("example", ClusterArgs.builder()
             .clusterId(config.cache().clusterId())
             .engine(config.cache().engine())
             .nodeType(config.cache().nodeType())
             .numCacheNodes(config.cache().nodes())
             .parameterGroupName(config.cache().parameterGroup())
             .tags(config.tags())
             .build());
 
     }
 }

      • getLayerVersion

        public static com.pulumi.core.Output<GetLayerVersionResult> getLayerVersion()
        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 
         
 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());
 
     }
 }
        ### Get Specific Layer 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) {
         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())
         ));
     }
 }
        ### Get Latest Compatible Layer 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) {
         // 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());
 
     }
 }
        ### Compare Layer Versions 
         
 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 
         
 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());
 
     }
 }
 
 
         
 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());
 
     }
 }

      • getLayerVersionPlain

        public static java.util.concurrent.CompletableFuture<GetLayerVersionResult> getLayerVersionPlain()
        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 
         
 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());
 
     }
 }
        ### Get Specific Layer 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) {
         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())
         ));
     }
 }
        ### Get Latest Compatible Layer 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) {
         // 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());
 
     }
 }
        ### Compare Layer Versions 
         
 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 
         
 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());
 
     }
 }
 
 
         
 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());
 
     }
 }

      • getLayerVersion

        public static com.pulumi.core.Output<GetLayerVersionResult> getLayerVersion​(GetLayerVersionArgs args)
        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 
         
 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());
 
     }
 }
        ### Get Specific Layer 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) {
         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())
         ));
     }
 }
        ### Get Latest Compatible Layer 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) {
         // 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());
 
     }
 }
        ### Compare Layer Versions 
         
 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 
         
 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());
 
     }
 }
 
 
         
 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());
 
     }
 }

      • getLayerVersionPlain

        public static java.util.concurrent.CompletableFuture<GetLayerVersionResult> getLayerVersionPlain​(GetLayerVersionPlainArgs args)
        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 
         
 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());
 
     }
 }
        ### Get Specific Layer 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) {
         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())
         ));
     }
 }
        ### Get Latest Compatible Layer 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) {
         // 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());
 
     }
 }
        ### Compare Layer Versions 
         
 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 
         
 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());
 
     }
 }
 
 
         
 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());
 
     }
 }

      • getLayerVersion

        public static com.pulumi.core.Output<GetLayerVersionResult> getLayerVersion​(GetLayerVersionArgs args,
                                                                            com.pulumi.deployment.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 
         
 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());
 
     }
 }
        ### Get Specific Layer 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) {
         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())
         ));
     }
 }
        ### Get Latest Compatible Layer 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) {
         // 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());
 
     }
 }
        ### Compare Layer Versions 
         
 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 
         
 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());
 
     }
 }
 
 
         
 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());
 
     }
 }

      • getLayerVersion

        public static com.pulumi.core.Output<GetLayerVersionResult> getLayerVersion​(GetLayerVersionArgs args,
                                                                            com.pulumi.deployment.InvokeOutputOptions 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 
         
 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());
 
     }
 }
        ### Get Specific Layer 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) {
         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())
         ));
     }
 }
        ### Get Latest Compatible Layer 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) {
         // 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());
 
     }
 }
        ### Compare Layer Versions 
         
 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 
         
 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());
 
     }
 }
 
 
         
 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());
 
     }
 }

      • getLayerVersionPlain

        public static java.util.concurrent.CompletableFuture<GetLayerVersionResult> getLayerVersionPlain​(GetLayerVersionPlainArgs args,
                                                                                                 com.pulumi.deployment.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 
         
 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());
 
     }
 }
        ### Get Specific Layer 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) {
         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())
         ));
     }
 }
        ### Get Latest Compatible Layer 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) {
         // 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());
 
     }
 }
        ### Compare Layer Versions 
         
 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 
         
 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());
 
     }
 }
 
 
         
 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());
 
     }
 }