Developing serverless REST APIs with API Gateway and AWS Lambda is now common for tasks like form submissions or backend workflows. With Amazon extending the API Gateway timeout beyond 29 seconds), it can now handle complex workflows like long-running machine learning predictions and Generative AI tasks.

In this article, we’ll explore how to leverage the AWS Lambda Power Tuning tool to optimize serverless REST APIs for both performance and cost efficiency.

What Is AWS Lambda Power Tuning?

• AWS Lambda Power Tuning is a state machine built with AWS Step Functions that tests Lambda function performance with different memory allocation and recommends ways to reduce costs or improve performance.
• It works with any Lambda runtime, offering broad compatibility.

Getting Started

Choose your deployment option from the guide and deploy the AWS Lambda Power Tuning tool. Once deployed, the following state machine will appear in AWS Step Functions:

Executing the Tool

Key Input Parameters

The key parameters for executing the state machine are given below

For a detailed description of these parameters, refer to the official documentation.

Inputs

Let’s explore how to configure inputs for executing the AWS Lambda Power Tuning tool in a scenario where API Gateway is configured with proxy integration to expose AWS Lambda as a REST API.

with the following input

{
  "lambdaARN": "<arn of the function being executed>",
  "powerValues": [ 128, 256, 512, 1024, 1536, 2048, 2560, 3072],
  "num": 10,
  "strategy": "speed",
  "payload": {...},
  "parallelInvocation": true,
  "includeOutputResults": true,
  "onlyColdStarts": true
}

Here's a breakdown of the input parameters and their effects:

• lambdaARN: Specifies the ARN (Amazon Resource Name) of the Lambda function being tested.
• powerValues: The function will be executed with the following memory allocations: 128 MB, 256 MB, 512 MB, 1024 MB, 1536 MB, 2048 MB, 2560 MB, and 3072 MB.
• num: 10 parallel executions will be performed for each memory allocation.
• strategy: In this case, the speed strategy is selected, meaning the tool will focus on finding the allocation that minimizes execution time.
• payload: The data that will be passed as input to the Lambda function during each invocation. Refer Input format of a Lambda function for proxy integration for a full description of input for lambda. The input changes based on the HTTP Method - GET, PUT , POST, DELETE, ETC
• parallelInvocation: The tool will invoke the Lambda function in parallel for each memory allocation, allowing for faster testing across configurations.
• includeOutputResults: The average cost and average duration for every memory allocation will be included in the state machine output.
• onlyColdStarts: Ensures that all invocations are cold starts.

Sample Inputs

The table contains GitHub links to sample input for testing various requests.

Weighted Payloads

The tool also offers the option to define multiple payloads for HTTP methods, making it suitable for scenarios where payload structures vary significantly and can impact performance or speed. Refer Weighted Payloads in official documentation to understand how weighted payloads work

Pre/post-processing functions

The tool also provides the ability to run custom logic before and after the execution of the lambda function. This logic should be implemented as lambda functions. Refer Pre/Post-processing functions in official documentation to understand how weighted payloads work

Output

A sample output is shown below

{
  "output": {
    "power": 2048,
    "cost": 0.0000018816000000000001,
    "duration": 54.95933333333334,
    "stateMachine": {
      "executionCost": 0.00075,
      "lambdaCost": 0.0013002423000000002,
      "visualization": "https://lambda-power-tuning.show/#encodeddata"
    },
    "stats": [
      {
        "value": 128,
        "averagePrice": 9.345000000000001e-7,
        "averageDuration": 443.89949999999993
      },
      {
        "value": 256,
        "averagePrice": 8.358000000000001e-7,
        "averageDuration": 198.4030000000001
      },
      {
        "value": 512,
        "averagePrice": 7.56e-7,
        "averageDuration": 88.51350000000001
      },
      {
        "value": 1024,
        "averagePrice": 0.0000011256,
        "averageDuration": 66.2415
      },
      {
        "value": 1536,
        "averagePrice": 0.000001512,
        "averageDuration": 58.86233333333332
      },
      {
        "value": 2048,
        "averagePrice": 0.0000018816000000000001,
        "averageDuration": 54.95933333333334
      },
      {
        "value": 2560,
        "averagePrice": 0.0000023940000000000003,
        "averageDuration": 56.222
      },
      {
        "value": 3072,
        "averagePrice": 0.0000028728000000000007,
        "averageDuration": 56.312333333333335
      }
    ]
  }
}

A brief description of the output is given below

Visualizing the output

The element - output.stateMachine.visualization provides a visualization URL - https://lambda-power-tuning.show/#encodeddata that can be used to visualize the result

The source code of the UI is also open source - https://github.com/matteo-ronchetti/aws-lambda-power-tuning-ui

References

• Amazon API Gateway integration timeout limit increase beyond 29 seconds
• AWS Lambda Power Tuning
• AWS Lambda Power Tuning - Deployment Guide
• AWS Lambda Power Tuning - Execution Parameters
• Input format for API Gateway Proxy Integrations