Post summary: Code examples on how to create AWS Lambda function in .NET Core.
This post is part of AWS examples in C# – working with SQS, DynamoDB, Lambda, ECS series. The code used for this series of blog posts is located in aws.examples.csharp GitHub repository.
AWS Lambda
AWS Lambda allows easy ramp-up of service without all the hassle to manage servers and environments. The ready code is uploaded to Lambda and automatically run. More detailed information and design considerations about AWS Lambda can be found in AWS examples in C# – working with Lambda functions post.
Create Lambda
Amazon provides Amazon.Lambda.Templates NuGet package which contains a lot of templates for Lambda functions. The NuGet package can be installed with dotnet new -i Amazon.Lambda.Templates. Once templates are installed, a new empty function is created with:
dotnet new lambda.EmptyFunction --name MyFunctionTwo projects are created: src and test. The source project is with netcoreapp2.1 runtime and has reference to Amazon.Lambda.Core and Amazon.Lambda.Serialization.Json NuGet packages. It has only one simple function that takes a string input and converts it to uppercase. The test project has a unit test that tests this function.
Once the function is ready, it can be deployed to AWS Lambda and tested. In order to deploy, the Amazon lambda tools should be installed with: dotnet tool install -g Amazon.Lambda.Tools. Once the tool is installed, there should be an IAM role created with name MyRole for e.g. Before deploying the lambda, environment variable with AWS access information should be set:
export AwsAccessKey=KIA57FV4.....
export AwsSecretKey=mSgsxOWVh...
export AwsRegion=us-east-1
Then lambda is deployed with:
dotnet lambda deploy-function MyFunction \
--function-role MyRole \
--project-location src/MyFunction \
--region $AwsRegion \
--aws-access-key-id $AwsAccessKey \
--aws-secret-key $AwsSecretKey
The function can be tested with:
dotnet lambda invoke-function MyFunction \
--payload "Just Testing the Payload" \
--project-location src/MyFunction \
--region $AwsRegion \
--aws-access-key-id $AwsAccessKey \
--aws-secret-key $AwsSecretKey
The result is shown:
Amazon Lambda Tools for .NET Core applications (3.3.1)
Project Home: https://github.com/aws/aws-extensions-for-dotnet-cli, https://github.com/aws/aws-lambda-dotnet
Payload:
"JUST TESTING THE PAYLOAD"
Log Tail:
START RequestId: 3f1844e0-7437-4219-a391-621a55dec0e9 Version: $LATEST
END RequestId: 3f1844e0-7437-4219-a391-621a55dec0e9
REPORT RequestId: 3f1844e0-7437-4219-a391-621a55dec0e9 Duration: 925.38 ms Billed Duration: 1000 ms Memory Size: 256 MB Max Memory Used: 62 MB Init Duration: 196.85 ms
The duration in the example above is 925.38ms, billed duration is 1000ms. This is the first run, the cold start as described in the previous section, which took almost a second for a very simple function. Next run the duration was 0.28ms.
The lambda can also manually be deployed and tested, see how in Run a “Hello, World!” with AWS Lambda article.
Listen to DynamoDB events
In AWS examples in C# – create a service working with DynamoDB post, I have described more about DynamoDB and its streams are very well integrated with AWS Lambda. In the current examples, the lambda functions are designed to process DynamoDB stream events. DynamoDB stream ARN (Amazon Resource Name) is defined as an event source for the lambda. Then the lambda receives DynamoDBEvent object, which is defined in Amazon.Lambda.DynamoDBEvents NuGet package. There is not much business logic in the lambda function, once the event object is received, it is read, logged to AWS CloudWatch with ILambdaContext, and its data is written to another DynamoDB table and to an SQS queue. For this purpose, references to AWSSDK.DynamoDBv2 and AWSSDK.SQS NuGet packages are made. In the example code, I have created SQS and DynamoDB proxies, so functionalities are isolated and only what is needed is exposed, these are DynamoDbWriter and SqsWriter. In both proxies, the configuration is done with Region, which is read by AWS_REGION environment variable. This variable is always present in the AWS Lambda environment. In this case, there is no need for authentication with AWSCredentials class, as everything happens inside AWS. The lambda function has two constructors, one is receiving instances of both proxies, if none are passed it instantiates them. An automatic dependency injection is not used with lambda. This constructor is used by the unit tests to pass mocked objects. The parameterless constructor is needed by AWS Lambda to instantiate the function class.
MoviesFunction
public class MoviesFunction
{
private readonly ISqsWriter _sqsWriter;
private readonly IDynamoDbWriter _dynamoDbWriter;
public MoviesFunction() : this(null, null) { }
public MoviesFunction(ISqsWriter sqsWriter, IDynamoDbWriter dynamoDbWriter)
{
_sqsWriter = sqsWriter ?? new SqsWriter();
_dynamoDbWriter = dynamoDbWriter ?? new DynamoDbWriter();
}
public async Task FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context)
{
context.Logger.LogLine($"Beginning to process {dynamoEvent.Records.Count} records...");
foreach (var record in dynamoEvent.Records)
{
context.Logger.LogLine($"Event ID: {record.EventID}");
context.Logger.LogLine($"Event Name: {record.EventName}");
var streamRecordJson = _dynamoDbWriter.SerializeStreamRecord(record.Dynamodb);
context.Logger.LogLine($"DynamoDB Record:{streamRecordJson}");
context.Logger.LogLine(streamRecordJson);
var logEntry = new LogEntry
{
Message = $"Movie '{record.Dynamodb.NewImage["Title"].S}' processed by lambda",
DateTime = DateTime.Now
};
await _sqsWriter.WriteLogEntryAsync(logEntry);
await _dynamoDbWriter.PutLogEntryAsync(logEntry);
}
context.Logger.LogLine("Stream processing complete.");
}
}
DynamoDbWriter
public interface IDynamoDbWriter
{
Task PutLogEntryAsync(LogEntry logEntry);
string SerializeStreamRecord(StreamRecord streamRecord);
}
public class DynamoDbWriter : IDynamoDbWriter
{
private static readonly string Region = Environment.GetEnvironmentVariable("AWS_REGION") ?? "us-east-1";
private readonly IAmazonDynamoDB _dynamoDbClient;
private readonly JsonSerializer _jsonSerializer;
public DynamoDbWriter()
{
var dynamoDbConfig = new AmazonDynamoDBConfig
{
RegionEndpoint = RegionEndpoint.GetBySystemName(Region)
};
_dynamoDbClient = new AmazonDynamoDBClient(dynamoDbConfig);
_jsonSerializer = new JsonSerializer();
}
public async Task PutLogEntryAsync(LogEntry logEntry)
{
var request = new PutItemRequest
{
TableName = "LogEntries",
Item = new Dictionary<string, AttributeValue>
{
{"Message", new AttributeValue {S = logEntry.Message}},
{"DateTime", new AttributeValue {S = logEntry.ToString()}}
}
};
await _dynamoDbClient.PutItemAsync(request);
}
public string SerializeStreamRecord(StreamRecord streamRecord)
{
using (var writer = new StringWriter())
{
_jsonSerializer.Serialize(writer, streamRecord);
return writer.ToString();
}
}
}
SqsWriter
public interface ISqsWriter
{
Task WriteLogEntryAsync(LogEntry logEntry);
}
public class SqsWriter : ISqsWriter
{
private static readonly string QueueName = Environment.GetEnvironmentVariable("AWS_SQS_QUEUE_NAME");
private static readonly bool IsQueueFifo = bool.Parse(Environment.GetEnvironmentVariable("AWS_SQS_IS_FIFO") ?? "false");
private static readonly string Region = Environment.GetEnvironmentVariable("AWS_REGION") ?? "us-east-1";
private readonly IAmazonSQS _sqsClient;
public SqsWriter()
{
var sqsConfig = new AmazonSQSConfig
{
RegionEndpoint = RegionEndpoint.GetBySystemName(Region)
};
_sqsClient = new AmazonSQSClient(sqsConfig);
}
public async Task WriteLogEntryAsync(LogEntry logEntry)
{
var queueUrl = await _sqsClient.GetQueueUrlAsync(QueueName);
var sendMessageRequest = new SendMessageRequest
{
QueueUrl = queueUrl.QueueUrl,
MessageBody = JsonConvert.SerializeObject(logEntry),
MessageAttributes = SqsMessageTypeAttribute.CreateAttributes(typeof(LogEntry).Name)
};
if (IsQueueFifo)
{
sendMessageRequest.MessageGroupId = typeof(LogEntry).Name;
sendMessageRequest.MessageDeduplicationId = Guid.NewGuid().ToString();
}
await _sqsClient.SendMessageAsync(sendMessageRequest);
}
}
Conclusion
As shown in the current post, it is very easy to create lambda function, deploy and run it. The current post shows a lambda function that listens to DynamoDB events and processes those events by writing into another DynamoDB table and SQS queue.
