Integrating Bedrock With AWS Lambda

In this lesson you’ll learn how to connect Amazon Bedrock with AWS Lambda to automatically run generative AI tasks when new data arrives. The pattern is event-driven: Lambda reacts to incoming data (for example, files uploaded to Amazon S3), calls Bedrock to perform AI processing (summaries, Q&A, sentiment, etc.), and persists the results. This lesson follows this sequence:

Present the real-world problem of handling continuous data.
Introduce the Lambda + Bedrock solution.
Walk through the implementation workflow (with diagrams).
Share expected results and operational benefits.
Provide a hands-on implementation example.

Let’s begin with the real-world problem.

Real-world problem

Data arrives continuously from many sources: IoT devices, batch jobs, customer API uploads, reviews, surveys, and arbitrary file uploads. Manually reacting to each notification (for example, reading an email and triggering an AI workflow by hand) is slow, error-prone, and does not scale. An event-driven architecture removes human latency: the system responds automatically whenever relevant data appears. That enables near-real-time insights, consistent processing, and easier scaling.

Solution: Lambda + Bedrock

Use AWS Lambda as an event-driven compute layer to call Amazon Bedrock whenever new data needs generative AI processing. Lambda is a managed service that runs code in response to events, scales automatically, and uses execution roles for secure access to AWS services. Typical flow:

An S3 ObjectCreated event triggers a Lambda function.
The Lambda handler reads the object, builds a prompt, invokes Bedrock, and writes the result to a destination (S3, DynamoDB, etc.).

A diagram titled "Solution: Use Lambda With Bedrock" showing an event triggering an AWS Lambda function that executes code, reads a file, and sends a prompt. The Lambda then calls Bedrock to generate a response, with security handled by IAM roles.

Lambda permissions and IAM roles

Lambda functions assume an execution role that grants permissions for the function to read S3 objects and call Bedrock. Because the role is attached to the Lambda function, the application code does not need to manage credentials—the AWS SDK in the Lambda environment uses the function’s execution role.

Ensure your Lambda execution role follows least-privilege principles: grant only the permissions required to read the S3 bucket(s), write output, and call the Bedrock runtime API.

Workflow overview

A common S3-triggered Bedrock processing flow:

A file is uploaded to S3 (ObjectCreated event).
S3 event notification invokes the configured Lambda function.
Lambda reads the S3 object, constructs the prompt, and calls Amazon Bedrock.
Lambda stores the Bedrock-generated result back to S3 (or another destination).

A diagram titled "Workflow: Use Bedrock With Lambda" showing a four-step flow. It illustrates: file uploaded to Amazon S3 → AWS Lambda reads Python code → AI model processing by Amazon Bedrock → save generated response back to S3.

S3 event notifications

S3 supports event notifications on a per-bucket basis. You can subscribe to object creation events (Put, Post, Copy, CompleteMultipartUpload) and filter by prefix or suffix to restrict which objects trigger the event (for example, only .txt files or a specific folder). Destinations include Lambda functions, SNS topics, or SQS queues. When configuring the S3 bucket event, choose:

Event types to monitor (e.g., s3:ObjectCreated:*)
Optional key filters (prefix / suffix)
The destination Lambda function as the event target

A screenshot of an AWS console page titled "Workflow: S3 Events and Lambda" showing the Destination settings where a Lambda function (selected as "bedrock-summarize") is chosen as the event target. Below the screenshot is a caption instructing to link the S3 bucket event directly to the target Lambda function.

Lambda function and handler (Python example)

A Lambda function bundles your code and configuration (memory, timeout, execution role). For Python Lambdas, the handler signature is def lambda_handler(event, context):. The event parameter contains the S3 JSON payload; typical access to the object information is:

bucket = event['Records'][0]['s3']['bucket']['name']
key = event['Records'][0]['s3']['object']['key']

Below is an example Python Lambda handler that demonstrates:

Parsing the S3 event
Reading the object from S3
Invoking Bedrock to run a model
Writing the generated summary back to S3

import json
import os
import logging
import boto3
from botocore.exceptions import ClientError

logger = logging.getLogger()
logger.setLevel(logging.INFO)

s3 = boto3.client('s3')
bedrock = boto3.client('bedrock-runtime')

# You can configure MODEL_ID and OUTPUT_SUFFIX via environment variables
MODEL_ID = os.environ.get('MODEL_ID', 'anthropic.claude-v1')
OUTPUT_SUFFIX = os.environ.get('OUTPUT_SUFFIX', '_summary.txt')

def lambda_handler(event, context):
    try:
        # Parse S3 event (supporting one record)
        record = event['Records'][0]
        bucket = record['s3']['bucket']['name']
        key = record['s3']['object']['key']
        logger.info("Processing s3://%s/%s", bucket, key)

        # Read file from S3
        obj = s3.get_object(Bucket=bucket, Key=key)
        text = obj['Body'].read().decode('utf-8')

        # Build Bedrock request body (adjust according to the model's expected schema)
        request_body = {'input': text}

        response = bedrock.invoke_model(
            modelId=MODEL_ID,
            contentType='application/json',
            accept='application/json',
            body=json.dumps(request_body)
        )

        # Read and parse the model response
        body_bytes = response['body'].read()
        body_text = body_bytes.decode('utf-8')
        result = json.loads(body_text)

        # Extract model output (schema varies by provider/model)
        # Example: result.get('output') or result.get('results')[0].get('output')
        summary = result.get('output') or (result.get('results') and result['results'][0].get('output')) or ''

        # Save summary back to S3
        out_key = key.rsplit('.', 1)[0] + OUTPUT_SUFFIX
        s3.put_object(Bucket=bucket, Key=out_key, Body=summary.encode('utf-8'))
        logger.info("Saved summary at s3://%s/%s", bucket, out_key)

        return {
            'statusCode': 200,
            'body': json.dumps({'summary_key': out_key})
        }

    except ClientError as e:
        logger.exception("AWS client error")
        return {'statusCode': 500, 'body': json.dumps({'error': str(e)})}
    except Exception as e:
        logger.exception("Unexpected error")
        return {'statusCode': 500, 'body': json.dumps({'error': str(e)})}

Notes:

Model response schemas vary across providers and models. Adjust MODEL_ID and how you extract the generated content from the response accordingly.
Use environment variables to configure model IDs, output suffixes, and other behavior.
Keep Lambda timeouts and memory settings appropriate for the expected model latency. The Lambda maximum execution time is 15 minutes.

S3 event types and common IAM permissions

Feature	Typical values / examples
S3 event types	`s3:ObjectCreated:Put`, `s3:ObjectCreated:Post`, `s3:ObjectCreated:CompleteMultipartUpload`
S3 key filters	Prefix: `uploads/incoming/`, Suffix: `.txt`
IAM permissions (minimum examples)	`s3:GetObject` on the source bucket, `s3:PutObject` on the destination prefix, `bedrock:InvokeModel` or relevant Bedrock runtime API permission
Lambda config tips	Set `MODEL_ID` and `OUTPUT_SUFFIX` as environment variables; configure memory/timeout per model latency

Example IAM policy statements (attach to Lambda execution role):

s3:GetObject for arn:aws:s3:::example-bucket/uploads/*
s3:PutObject for arn:aws:s3:::example-bucket/processed/*
Bedrock runtime permission (policy name and action may vary by account/region; follow AWS docs)

Expected results and benefits

Adopting this event-driven Lambda + Bedrock pattern delivers several advantages:

Near-real-time processing: Files uploaded to S3 are handled immediately without scheduled batches.
Automatic scaling: Lambda scales to process bursts of uploads concurrently.
Reduced operational overhead: No servers or containers to manage; you pay only while code runs.
Reusable pattern: The same approach works for other AWS event sources (API Gateway, SQS, SNS, DynamoDB streams, EventBridge).

Key takeaway

Lambda enables Bedrock workflows to run automatically in response to events. In this lesson we used S3 object creation as the trigger example, but any AWS event source can invoke the same serverless, event-driven architecture—eliminating manual steps and simplifying scale.

Be mindful of model invocation costs, latency, and data privacy. Tune Lambda timeouts and memory, and validate model response schemas before productionizing. Ensure sensitive data is handled according to your compliance requirements.

Next steps

Implement the pattern in your AWS account:

Create or reuse an S3 bucket and configure event notifications with a key filter.
Create a Lambda function with the execution role granting minimal S3 and Bedrock permissions.
Deploy the Python handler (or a language of your choice), set MODEL_ID as an environment variable, and test with sample files.
Monitor Lambda logs (CloudWatch) and track Bedrock usage and cost.

References and further reading:

Good luck—build and iterate on the handler to suit your data schema and the Bedrock model you choose.

Introduction to Gen AI and LLMs

Introduction to Amazon Bedrock

Getting Started With Amazon Bedrock

Foundation Models in Amazon Bedrock

Basic Concepts of Prompt Engineering

Introduction to Text Generation With Amazon Bedrock

How Foundation Models Process Input

Extract Insights Using Prompt Engineering

Working With Different Task Types

Integrating Amazon Bedrock With Other AWS Services

Build a Marketing Email Generation Application

Introduction to Retrieval Augmentation With Bedrock Knowledge Bases

Best Practices and Optimization

Governance, Safety in Responsible AI

Security

Monitoring and Logging

Taking action with Bedrock Agents

Advanced Topics (Optional)

Final Project

Wrap Up

Integrating Bedrock With AWS Lambda

Real-world problem

Solution: Lambda + Bedrock

Lambda permissions and IAM roles

Workflow overview

S3 event notifications

Lambda function and handler (Python example)

S3 event types and common IAM permissions

Expected results and benefits

Key takeaway

Next steps

Watch Video

Practice Lab

​Real-world problem

​Solution: Lambda + Bedrock

​Lambda permissions and IAM roles

​Workflow overview

​S3 event notifications

​Lambda function and handler (Python example)

​S3 event types and common IAM permissions

​Expected results and benefits

​Key takeaway

​Next steps

Watch Video

Practice Lab

Real-world problem

Solution: Lambda + Bedrock

Lambda permissions and IAM roles

Workflow overview

S3 event notifications

Lambda function and handler (Python example)

S3 event types and common IAM permissions

Expected results and benefits

Key takeaway

Next steps