New AWS Lambda scaling controls for Kinesis and DynamoDB event sources

AWS Lambda is introducing a new scaling parameter for Amazon Kinesis Data Streams and Amazon DynamoDB Streams event sources. Parallelization Factor can be set to increase concurrent Lambda invocations for each shard, which by default is 1. This allows for faster stream processing without the need to over-scale the number of shards, while still guaranteeing order of records processed.

There are two common optimization scenarios: high traffic and low traffic. For example, an online business might experience seasonal spikes in traffic. The following features help ensure that your business can scale appropriately to withstand the upcoming holiday season.

Handling high traffic with Parallelization Factor

Each shard has uniquely identified sequences of data records. Each record contains a partition key to guarantee order and are organized separately into shards based on that key. The records from each shard must be polled to guarantee that records with the same partition key are processed in order.

When there is a high volume of data traffic, you want to process records as fast as possible. Before this release, customers were solving this by updating the number of shards on a Kinesis data stream . Increasing the number of shards increases the number of functions processing data from those shards. One Lambda function invocation processes one shard at a time.

You can now use the new Parallelization Factor to specify the number of concurrent batches that Lambda polls from a single shard. This feature introduces more flexibility in scaling options for Lambda and Kinesis. The default factor of one exhibits normal behavior. A factor of two allows up to 200 concurrent invocations on 100 Kinesis data shards. The Parallelization Factor can be scaled up to 10.

Each parallelized shard contains messages with the same partition key. This means record processing order will still be maintained and each parallelized shard must complete before processing the next.

Using Parallelization Factor

Since Parallelization Factor is quickly set on an event source mapping, it can be increased or decreased on demand. Fully automated scaling of stream processing is now possible.

For example, Amazon CloudWatch can be used to monitor changes in traffic. High traffic can cause the IteratorAge metric to increase, and an alarm can be created if this occurs for some specified period of time. The alarm can trigger a Lambda function that uses the UpdateEventSourceMapping API to increase the Parallelization Factor. In the same way, an alarm can be set to reduce the factor if traffic decreases.

You can enable Parallelization Factor in the AWS Lambda console by creating or updating a Kinesis or DynamoDB event source. Choose Additional settings and set the Concurrent batches per shard to the desired factor, between 1 and 10.

Configuring the Parallelization Factor from the AWS Lambda console.

You can also enable this feature from the AWS CLI using the –-parallelization-factor parameter when creating or updating an event source mapping.

$ aws lambda create-event-source-mapping –function-name my-function \

–parallelization-factor 2 –batch-size 100 –starting-position AT_TIMESTAMP –starting-position-timestamp 1541139109 \

–event-source-arn arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream

{

“UUID”: “2b733gdc-8ac3-cdf5-af3a-1827b3b11284”,

“ParallelizationFactor”: 2,

“BatchSize”: 100,

“MaximumBatchingWindowInSeconds”: 0,

“EventSourceArn”: “arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream”,

“FunctionArn”: “arn:aws:lambda:us-east-2:123456789012:function:my-function”,

“LastModified”: 1541139209.351,

“LastProcessingResult”: “No records processed”,

“State”: “Creating”,

“StateTransitionReason”: “User action”

}

Handling low traffic with Batch Window

Previously, you could use Batch Size to handle low volumes, or handle tasks that were not time sensitive. Batch Size configures the number of records to read from a shard, up to 10,000. The payload limit of a single invocation is 6 MB.

In September, we launched Batch Window , which allows you to fine tune when Lambda invocations occur. Lambda normally reads records from a Kinesis data stream at a particular interval. This feature is ideal in situations where data is sparse and batches of data take time to build up.

Using Batch Window, you can set your function to wait up to 300 seconds for a batch to build before processing it. This means you can also set your function to process on certain conditions, such as reaching the payload size, or Batch Size reaching its maximum value. With Batch Window, you can manage the average number of records processed by the function with each invocation. This allows you to increase the efficiency of each invocation and reduce the total number.

Batch Window is set when adding a new event trigger in the AWS Lambda console .

Adding an event source trigger in the AWS Lambda console

It can also be set using AWS CLI with the –maximum-batching-window-in-seconds parameter.

$ aws lambda create-event-source-mapping –function-name my-function \

–maximum-batching-window-in-seconds 300 –batch-size 100 –starting-position AT_TIMESTAMP –starting-position-timestamp 1541139109 \

–event-source-arn arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream

{

“UUID”: “2b733gdc-8ac3-cdf5-af3a-1827b3b11284”,

“BatchSize”: 100,

“MaximumBatchingWindowInSeconds”: 300,

“EventSourceArn”: “arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream”,

“FunctionArn”: “arn:aws:lambda:us-east-2:123456789012:function:my-function”,

“LastModified”: 1541139209.351,

“LastProcessingResult”: “No records processed”,

“State”: “Creating”,

“StateTransitionReason”: “User action”

}

Conclusion

You now have new options for managing scale in Amazon Kinesis and Amazon DynamoDB stream processing.  The Batch Window parameter allows you to tune how long to wait before processing a batch, ideal for low traffic or tasks that aren’t time sensitive. The Parallelization Factor parameter enables faster stream processing of ordered records at high volume, using concurrent Lambda invocations per shard. Both of these features can lead to more efficient stream processing.