Tutorial: Using Lambda with Amazon SQS

Consuming an SQS event with Lambda using .NET.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
using Amazon.Lambda.Core;
using Amazon.Lambda.SQSEvents;
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace SqsIntegrationSampleCode
{
 public async Task FunctionHandler(SQSEvent evnt, ILambdaContext context)
 {
 foreach (var message in evnt.Records)
 {
 await ProcessMessageAsync(message, context);
 }
 context.Logger.LogInformation("done");
 }
 private async Task ProcessMessageAsync(SQSEvent.SQSMessage message, ILambdaContext context)
 {
 try
 {
 context.Logger.LogInformation($"Processed message {message.Body}");
 // TODO: Do interesting work based on the new message
 await Task.CompletedTask;
 }
 catch (Exception e)
 {
 //You can use Dead Letter Queue to handle failures. By configuring a Lambda DLQ.
 context.Logger.LogError($"An error occurred");
 throw;
 }
 }
}

Consuming an SQS event with Lambda using Go.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package integration_sqs_to_lambda
import (
	"fmt"
	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
)
func handler(event events.SQSEvent) error {
	for _, record := range event.Records {
		err := processMessage(record)
		if err != nil {
			return err
		}
	}
	fmt.Println("done")
	return nil
}
func processMessage(record events.SQSMessage) error {
	fmt.Printf("Processed message %s\n", record.Body)
	// TODO: Do interesting work based on the new message
	return nil
}
func main() {
	lambda.Start(handler)
}

Consuming an SQS event with Lambda using Java.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.SQSEvent;
import com.amazonaws.services.lambda.runtime.events.SQSEvent.SQSMessage;
public class Function implements RequestHandler<SQSEvent, Void> {
 @Override
 public Void handleRequest(SQSEvent sqsEvent, Context context) {
 for (SQSMessage msg : sqsEvent.getRecords()) {
 processMessage(msg, context);
 }
 context.getLogger().log("done");
 return null;
 }
 private void processMessage(SQSMessage msg, Context context) {
 try {
 context.getLogger().log("Processed message " + msg.getBody());
 // TODO: Do interesting work based on the new message
 } catch (Exception e) {
 context.getLogger().log("An error occurred");
 throw e;
 }
 }
}

Consuming an SQS event with Lambda using JavaScript.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
exports.handler = async (event, context) => {
 for (const message of event.Records) {
 await processMessageAsync(message);
 }
 console.info("done");
};
async function processMessageAsync(message) {
 try {
 console.log(`Processed message ${message.body}`);
 // TODO: Do interesting work based on the new message
 await Promise.resolve(1); //Placeholder for actual async work
 } catch (err) {
 console.error("An error occurred");
 throw err;
 }
}

Consuming an SQS event with Lambda using TypeScript.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { SQSEvent, Context, SQSHandler, SQSRecord } from "aws-lambda";
export const functionHandler: SQSHandler = async (
 event: SQSEvent,
 context: Context
): Promise<void> => {
 for (const message of event.Records) {
 await processMessageAsync(message);
 }
 console.info("done");
};
async function processMessageAsync(message: SQSRecord): Promise<any> {
 try {
 console.log(`Processed message ${message.body}`);
 // TODO: Do interesting work based on the new message
 await Promise.resolve(1); //Placeholder for actual async work
 } catch (err) {
 console.error("An error occurred");
 throw err;
 }
}

Consuming an SQS event with Lambda using PHP.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
<?php
# using bref/bref and bref/logger for simplicity
use Bref\Context\Context;
use Bref\Event\InvalidLambdaEvent;
use Bref\Event\Sqs\SqsEvent;
use Bref\Event\Sqs\SqsHandler;
use Bref\Logger\StderrLogger;
require __DIR__ . '/vendor/autoload.php';
class Handler extends SqsHandler
{
 private StderrLogger $logger;
 public function __construct(StderrLogger $logger)
 {
 $this->logger = $logger;
 }
 /**
 * @throws InvalidLambdaEvent
 */
 public function handleSqs(SqsEvent $event, Context $context): void
 {
 foreach ($event->getRecords() as $record) {
 $body = $record->getBody();
 // TODO: Do interesting work based on the new message
 }
 }
}
$logger = new StderrLogger();
return new Handler($logger);

Consuming an SQS event with Lambda using Python.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
def lambda_handler(event, context):
 for message in event['Records']:
 process_message(message)
 print("done")
def process_message(message):
 try:
 print(f"Processed message {message['body']}")
 # TODO: Do interesting work based on the new message
 except Exception as err:
 print("An error occurred")
 raise err

Consuming an SQS event with Lambda using Ruby.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
def lambda_handler(event:, context:)
 event['Records'].each do |message|
 process_message(message)
 end
 puts "done"
end
def process_message(message)
 begin
 puts "Processed message #{message['body']}"
 # TODO: Do interesting work based on the new message
 rescue StandardError => err
 puts "An error occurred"
 raise err
 end
end

Consuming an SQS event with Lambda using Rust.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
use aws_lambda_events::event::sqs::SqsEvent;
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
async fn function_handler(event: LambdaEvent<SqsEvent>) -> Result<(), Error> {
 event.payload.records.iter().for_each(|record| {
 // process the record
 tracing::info!("Message body: {}", record.body.as_deref().unwrap_or_default())
 });
 Ok(())
}
#[tokio::main]
async fn main() -> Result<(), Error> {
 tracing_subscriber::fmt()
 .with_max_level(tracing::Level::INFO)
 // disable printing the name of the module in every log line.
 .with_target(false)
 // disabling time is handy because CloudWatch will add the ingestion time.
 .without_time()
 .init();
 run(service_fn(function_handler)).await
}