Input Parameters in AWS Lambda

In this guide, we will explore how to pass input parameters to AWS Lambda functions and use them effectively. AWS Lambda is a powerful serverless compute service that enables you to run code in response to events. One of its key features is the ability to handle inputs dynamically, making it ideal for scenarios where user-specific data is required.

A Quick Recap

Previously, we created a simple Lambda function that returned a static message, such as "Hello Viewers." In this post, we will enhance our Lambda function by introducing input parameters that allow dynamic outputs based on user-provided values.

Step 1: Setting Up the Function Logic

We started by modifying our existing Lambda function to handle basic arithmetic operations. Here is the updated code:

# Function to perform basic arithmetic operations
def lambda_handler(event, context):
    # Extracting input parameters from the event object
    number_one = int(event.get('number_one', 0))
    number_two = int(event.get('number_two', 0))

    # Performing operations
    sum_result = number_one + number_two
    product_result = number_one * number_two
    difference_result = number_two - number_one
    division_result = number_two / number_one if number_one != 0 else None

    # Returning results
    return {
        'sum': sum_result,
        'product': product_result,
        'difference': difference_result,
        'division': division_result
    }

Explanation of the Code:

Input Parameters:
- number_one and number_two are retrieved from the event object.
- We use the .get() method to safely extract these values and provide default values if they are missing.
Arithmetic Operations:
- The function calculates the sum, product, difference, and division of the two numbers.
- Division handles cases where number_one is zero to prevent errors.
Return Statement:
- The results are returned as a dictionary, making them easy to consume by other services or applications.

Step 2: Testing the Lambda Function

AWS Lambda provides a built-in testing feature that allows you to simulate input events. Here’s how you can test the updated function:

Sample Test Event:

{
    "number_one": 5,
    "number_two": 10
}

Steps to Test:

Go to the Lambda function console.
Click on Test and create a new test event with the above JSON payload.
Execute the test and observe the output.

Output:

{
    "sum": 15,
    "product": 50,
    "difference": 5,
    "division": 2.0
}

Step 3: Handling Input Errors

To make the function robust, ensure input validation:

Use .get() with default values to prevent errors when keys are missing.
Convert values to integers where necessary.
Handle edge cases like division by zero.

Conclusion

In this tutorial, we demonstrated how to:

Pass input parameters to an AWS Lambda function.
Process the inputs to perform calculations dynamically.
Handle potential input errors effectively.

By adding input parameters, you can make your Lambda functions more dynamic and adaptable to a variety of use cases. In the next post, we will explore integrating Lambda with other AWS services for more complex workflows.

For more tutorials and insights, visit Learning Ocean.

Previous Next