Lambda with DynamoDB Streams in AWS - Commands & Configuration

Introduction

Sometimes you want your app to react automatically when data changes in a database. AWS Lambda with DynamoDB Streams lets you run code right after data updates happen in DynamoDB tables, without needing a server always running.

When you want to send a notification every time a new item is added to your DynamoDB table.

When you need to update a search index automatically after data changes in your database.

When you want to keep data in sync between DynamoDB and another system without manual steps.

When you want to process or filter data changes in real-time for analytics or monitoring.

When you want to trigger workflows or other AWS services based on database updates.

Config File - lambda-dynamodb-streams.yaml

lambda-dynamodb-streams.yaml

Resources:
  MyDynamoDBTable:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: example-table
      AttributeDefinitions:
        - AttributeName: id
          AttributeType: S
      KeySchema:
        - AttributeName: id
          KeyType: HASH
      BillingMode: PAY_PER_REQUEST
      StreamSpecification:
        StreamViewType: NEW_IMAGE

  MyLambdaFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: example-lambda
      Runtime: python3.9
      Handler: index.handler
      Role: arn:aws:iam::123456789012:role/lambda-execution-role
      Code:
        ZipFile: |
          def handler(event, context):
              for record in event['Records']:
                  print('DynamoDB Record:', record['dynamodb'])
              return 'Processed'

  MyEventSourceMapping:
    Type: AWS::Lambda::EventSourceMapping
    Properties:
      EventSourceArn: !GetAtt MyDynamoDBTable.StreamArn
      FunctionName: !Ref MyLambdaFunction
      StartingPosition: TRIM_HORIZON

MyDynamoDBTable: Defines a DynamoDB table with a stream enabled to capture new item images.

MyLambdaFunction: A simple Lambda function in Python that processes DynamoDB stream events.

MyEventSourceMapping: Connects the DynamoDB stream to the Lambda function so it triggers on data changes.

Commands

This command creates the DynamoDB table, Lambda function, and the event source mapping connecting them. It uses CloudFormation to deploy all resources together.

Terminal

aws cloudformation deploy --template-file lambda-dynamodb-streams.yaml --stack-name example-stack --capabilities CAPABILITY_NAMED_IAM

Expected Output

Waiting for stack create/update to complete...

Successfully created/updated stack - example-stack

→

--capabilities CAPABILITY_NAMED_IAM - Allows creation of IAM roles needed by Lambda

Adds a new item to the DynamoDB table to trigger the Lambda function via the stream.

Terminal

aws dynamodb put-item --table-name example-table --item '{"id": {"S": "123"}, "name": {"S": "Test Item"}}'

Expected Output

{}

Checks the Lambda function logs to see the output from processing the DynamoDB stream event.

Terminal

aws logs filter-log-events --log-group-name /aws/lambda/example-lambda --limit 5

Expected Output

{"events":[{"message":"DynamoDB Record: {\"Keys\": {\"id\": {\"S\": \"123\"}}, \"NewImage\": {\"id\": {\"S\": \"123\"}, \"name\": {\"S\": \"Test Item\"}}, \"SequenceNumber\": \"000000000000000000001\", \"SizeBytes\": 50, \"StreamViewType\": \"NEW_IMAGE\"}","timestamp":1680000000000}]}

→

--limit 5 - Limits output to the 5 most recent log events

Key Concept

If you remember nothing else from this pattern, remember: DynamoDB Streams capture data changes and Lambda runs your code automatically when those changes happen.

Common Mistakes

Not enabling the DynamoDB stream on the table.

Without the stream enabled, Lambda will never receive events to trigger on.

Always set StreamSpecification with StreamViewType when creating the DynamoDB table.

Using the wrong ARN or function name in the event source mapping.

If the event source mapping points to the wrong resource, Lambda won't trigger on the stream events.

Use the DynamoDB table's StreamArn and the exact Lambda function name or ARN.

Not giving Lambda permission to read from the DynamoDB stream.

Lambda needs an IAM role with permissions to access the stream; otherwise, it will fail to run.

Attach an IAM role to Lambda with the AWS managed policy AWSLambdaDynamoDBExecutionRole or equivalent.

Summary

Create a DynamoDB table with streams enabled to capture data changes.

Create a Lambda function that processes events from the DynamoDB stream.

Set up an event source mapping to connect the DynamoDB stream to the Lambda function.

Add data to the table to trigger the Lambda and verify processing via logs.

Practice

1. What is the main purpose of connecting AWS Lambda to DynamoDB Streams?

easy

A. To manually trigger Lambda functions from the AWS console

B. To automatically run code when data in the DynamoDB table changes

C. To backup DynamoDB data to S3 automatically

D. To increase the read capacity of the DynamoDB table

Solution

1. Step 1: Understand DynamoDB Streams role

   DynamoDB Streams capture data changes in the table as events.

2. Step 2: Understand Lambda integration

   Lambda can be triggered automatically by these stream events to run code.

3. Final Answer:

   To automatically run code when data in the DynamoDB table changes -> Option B

4. Quick Check:

   Lambda triggers on stream events = A [OK]

Hint: Streams trigger Lambda on data changes automatically [OK]

Common Mistakes:

• Thinking Lambda triggers manually from console
• Confusing streams with backups
• Assuming streams increase table capacity

2. Which of the following is the correct way to enable DynamoDB Streams on a table?

easy

A. Create a Lambda function and attach it to the table

B. Enable versioning on the DynamoDB table

C. Set the stream specification to NEW_AND_OLD_IMAGES in the table settings

D. Increase the write capacity units of the table

Solution

1. Step 1: Identify how to enable streams

   DynamoDB Streams are enabled by setting the stream specification on the table.

2. Step 2: Choose correct stream view type

   NEW_AND_OLD_IMAGES captures both before and after images of changes.

3. Final Answer:

   Set the stream specification to NEW_AND_OLD_IMAGES in the table settings -> Option C

4. Quick Check:

   Stream enabled via table settings = B [OK]

Hint: Enable streams in table settings, not in Lambda [OK]

Common Mistakes:

• Trying to enable streams by creating Lambda
• Confusing versioning with streams
• Changing capacity units instead of streams

3. Given this Lambda event handler code snippet triggered by DynamoDB Streams:

def lambda_handler(event, context):
    for record in event['Records']:
        if record['eventName'] == 'INSERT':
            print(record['dynamodb']['NewImage']['id']['S'])

What will this code print when a new item with id '123' is added to the DynamoDB table?

medium

A. '123' printed once for the new item

B. 'id' key printed instead of its value

C. An error because 'NewImage' does not exist

D. Nothing, because eventName is not 'INSERT'

Solution

1. Step 1: Understand event structure for INSERT

   For an INSERT event, 'NewImage' contains the new item data including 'id'.

2. Step 2: Analyze code behavior

   The code prints the string value of 'id' from 'NewImage' when eventName is 'INSERT'.

3. Final Answer:

   '123' printed once for the new item -> Option A

4. Quick Check:

   INSERT event prints new id value = D [OK]

Hint: INSERT events have NewImage with new item data [OK]

Common Mistakes:

• Assuming eventName is different
• Expecting OldImage on INSERT
• Confusing key name with value

4. You deployed a Lambda function triggered by DynamoDB Streams but it never runs. Which of the following is the most likely cause?

medium

A. The DynamoDB table does not have streams enabled

B. The Lambda function code has a syntax error

C. The DynamoDB table has no read capacity units

D. The Lambda function has no execution role

Solution

1. Step 1: Check stream enablement

   Lambda triggers on DynamoDB Streams events, so streams must be enabled on the table.

2. Step 2: Consider other causes

   While code errors or roles cause failures, the function would still be invoked if streams exist.

3. Final Answer:

   The DynamoDB table does not have streams enabled -> Option A

4. Quick Check:

   Streams must be enabled for Lambda trigger = C [OK]

Hint: Check if streams are enabled on the table first [OK]

Common Mistakes:

• Assuming code errors prevent invocation
• Ignoring missing streams
• Confusing read capacity with triggers

5. You want your Lambda function to process only updated attributes from DynamoDB Streams and ignore inserts and deletes. Which stream view type and event filter should you use?

hard

A. Enable NEW_AND_OLD_IMAGES stream view and filter events where eventName is 'INSERT'

B. Enable KEYS_ONLY stream view and filter events where eventName is 'INSERT'

C. Enable OLD_IMAGE stream view and filter events where eventName is 'REMOVE'

D. Enable NEW_IMAGE stream view and filter events where eventName is 'MODIFY'

Solution

1. Step 1: Choose stream view for updated data

   NEW_IMAGE provides the new state after update, suitable for processing changes.

2. Step 2: Filter events for updates only

   Filtering on eventName 'MODIFY' ensures only update events trigger Lambda.

3. Final Answer:

   Enable NEW_IMAGE stream view and filter events where eventName is 'MODIFY' -> Option D

4. Quick Check:

   Updates = NEW_IMAGE + 'MODIFY' filter [OK]

Hint: Use NEW_IMAGE and 'MODIFY' event filter for updates only [OK]

Common Mistakes:

• Using KEYS_ONLY which lacks attribute data
• Filtering on INSERT or REMOVE instead of MODIFY
• Choosing OLD_IMAGE which shows old data only