Struct FunctionBuilder 

pub struct FunctionBuilder<T>
where
    T: FunctionBuilderState,
{ /* private fields */ }

Builder for creating AWS Lambda functions.

This builder provides a fluent API for configuring Lambda functions with their associated IAM roles, environment variables, permissions, and event sources.

Example

use rusty_cdk_core::stack::StackBuilder;
use rusty_cdk_core::lambda::{FunctionBuilder, Architecture, Runtime, Zip};
use rusty_cdk_core::wrappers::*;
use rusty_cdk_macros::{memory, timeout, env_var_key, zip_file};

let mut stack_builder = StackBuilder::new();

let zip = unimplemented!("create a zip");

let (function, role, log_group) = FunctionBuilder::new(
        "my-function",
        Architecture::ARM64,
        memory!(512),
        timeout!(30)
    )
    .code(zip)
    .handler("index.handler")
    .runtime(Runtime::NodeJs22)
    .env_var_string(env_var_key!("TABLE_NAME"), "my-table")
    .build(&mut stack_builder);

See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html

Implementations

impl<T> FunctionBuilder<T>

where T: FunctionBuilderState,

pub fn function_name( self, name: StringWithOnlyAlphaNumericsUnderscoresAndHyphens, ) -> FunctionBuilder<T>

Sets a custom name for the function.

If not specified, a name will be generated automatically.

Arguments

• name - The name for the function.

pub fn add_permission(self, permission: Permission<'_>) -> FunctionBuilder<T>

Adds an IAM permission to the functions execution role.

Arguments

• permission - The IAM permission to add.

pub fn check_permissions_against_dependencies( self, cargo_toml: TomlFile, ) -> FunctionBuilder<T>

Checks that the function has permissions for AWS services listed in Cargo.toml dependencies.

Parses the Cargo.toml to find AWS SDK dependencies and verifies that IAM permissions have been granted for those services.

pub fn env_var(self, key: EnvVarKey, value: Value) -> FunctionBuilder<T>

Adds an environment variable to the function. If you just want to set a string as the environment variable value, use env_var_string

Arguments

• key - The name of the environment variable.
• value - The value of the environment variable, as a serde_json::Value.

pub fn env_var_string<V>(self, key: EnvVarKey, value: V) -> FunctionBuilder<T>

where V: Into<String>,

Adds a string environment variable to the function.

Arguments

• key - The name of the environment variable.
• value - The string value of the environment variable.

pub fn reserved_concurrent_executions( self, executions: u32, ) -> FunctionBuilder<T>

Sets the number of reserved concurrent executions for the function.

Arguments

• executions - The number of reserved concurrent executions.

pub fn log_group(self, log_group: &LogGroupRef) -> FunctionBuilder<T>

Use a custom log group for this function. If no log group is set, once is created automatically

impl FunctionBuilder<StartState>

pub fn new( id: &str, architecture: Architecture, memory: Memory, timeout: Timeout, ) -> FunctionBuilder<StartState>

Creates a new Lambda function builder. You will have to specify a handler and runtime before you are able to build a function.

Arguments

• id - Unique identifier for the function
• architecture - CPU architecture (x86_64 or ARM64)
• memory - Memory allocation in MB
• timeout - Maximum execution time

pub fn code(self, code: Code) -> FunctionBuilder<CodeState>

Sets the source code for the function.

This can either be a zip file from S3 or inline code.

Arguments

• code - The functions source code.

impl FunctionBuilder<CodeState>

pub fn handler<T>(self, handler: T) -> FunctionBuilder<ZipStateWithHandler>

where T: Into<String>,

Sets the functions handler.

This is the entry point for the function, e.g., “index.handler”, “bootstrap” (for ‘provided’ runtimes), etc.

Arguments

• handler - The function handler.

impl FunctionBuilder<ZipStateWithHandler>

pub fn runtime( self, runtime: Runtime, ) -> FunctionBuilder<ZipStateWithHandlerAndRuntime>

Sets the functions runtime.

Arguments

• runtime - The runtime environment for the function.

impl FunctionBuilder<ZipStateWithHandlerAndRuntime>

pub fn sqs_event_source_mapping( self, sqs_queue: &QueueRef, max_concurrency: Option<SqsEventSourceMaxConcurrency>, ) -> FunctionBuilder<EventSourceMappingState>

Configures the function to be triggered by an SQS queue.

Automatically adds the necessary IAM permissions for reading from the queue.

pub fn build( self, stack_builder: &mut StackBuilder, ) -> (FunctionRef, RoleRef, LogGroupRef)

Builds the Lambda function and adds it to the stack.

Creates the function along with its IAM execution role and CloudWatch log group. Returns references to all three resources.

impl FunctionBuilder<EventSourceMappingState>

pub fn build( self, stack_builder: &mut StackBuilder, ) -> (FunctionRef, RoleRef, LogGroupRef)

Builds the Lambda function and adds it to the stack.

Creates the function along with its IAM execution role, CloudWatch log group, and event source mapping. Returns references to the function, role, and log group.