In a previous post, we reviewed how to access a non-public resource in a VPC from a Lambda function. Today we do the same but with a different Amazon resource, Redis:
Amazon Elasticache for Redis is a distributed in-memory data store that is built on open-source Redis. It works with Redis APIs, and standard Redis client libraries, and uses open Redis data formats. Amazon ElastiCache for Redis can be used as a cache environment for your cloud applications in AWS.
Prerequisites
An Amazon ElastiCache Cluster (Redis).
Install AWS CLI.
Install the Amazon Lambda Templates (dotnet new -i Amazon.Lambda.Templates).
Install the Amazon Lambda Tools (dotnet tool install -g Amazon.Lambda.Tools).
Install AWS SAM CLI.
Code
We will build an API to calculate a GUID value after a very expensive process. Redis will be used to store the value for 60 seconds using as a key a part of the request path. Run the following command to create the .NET projects and solution:
dotnet new lambda.EmptyFunction -n verySlowCalculationApi -o .
dotnet new sln -n aws-elasticache-sandbox
dotnet sln add --in-root src/verySlowCalculationApi
dotnet add src/verySlowCalculationApi package Amazon.Lambda.APIGatewayEvents
dotnet add src/verySlowCalculationApi package StackExchange.Redis
Open the solution and modify the Function.cs file with the following content:
public class Function
{
private IDatabase _database;
public Function()
{
var connectionString = Environment.GetEnvironmentVariable("REDIS_CONFIGURATION");
var connection = ConnectionMultiplexer.Connect(connectionString);
_database = connection.GetDatabase();
}
public async Task<APIGatewayProxyResponse> FunctionHandler(APIGatewayProxyRequest input, ILambdaContext context)
{
var id = input.PathParameters["id"];
var value = string.Empty;
var cacheValue = await _database.StringGetAsync(id);
if(cacheValue.HasValue)
{
value = cacheValue;
}
else
{
value = await VeryExpensiveCalculation();
await _database.StringSetAsync(id, value, TimeSpan.FromSeconds(60), When.Always, CommandFlags.PreferMaster);
}
return new APIGatewayProxyResponse
{
Body = "{\"Value\":\""+ value + "\"}",
StatusCode = 200,
Headers = new Dictionary<string, string> { { "Content-Type", "application/json" } }
};
}
public async Task<string> VeryExpensiveCalculation()
{
await Task.Delay(5000);
return Guid.NewGuid().ToString();
}
}
Create a template.yml file at the solution level:
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: >
Slow API
Parameters:
Redis:
Type: String
Default: <REDIS_CONFIGURATION>
Description: Redis configuration
Vpc:
Type: String
Default: <REDIS_VPC>
Description: Redis Vpc
Subnet:
Type: String
Default: <REDIS_SUBNET>
Description: Redis Subnet
Globals:
Function:
Timeout: 60
MemorySize: 512
Runtime: dotnet6
Architectures:
- x86_64
Environment:
Variables:
REDIS_CONFIGURATION: !Ref Redis
Resources:
LambdaSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: lambda security group
VpcId: !Ref Vpc
VerySlowFunction:
Type: AWS::Serverless::Function
Properties:
Handler: verySlowCalculationApi::verySlowCalculationApi.Function::FunctionHandler
CodeUri: ./src/verySlowCalculationApi/
VpcConfig:
SecurityGroupIds:
- !Ref LambdaSecurityGroup
SubnetIds:
- !Ref Subnet
Policies:
- AWSLambda_FullAccess
- AWSLambdaVPCAccessExecutionRole
Events:
ListPosts:
Type: Api
Properties:
Path: /{id}
Method: get
Outputs:
Api:
Description: "API Gateway endpoint URL"
Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/{id}"
To connect the Lambda function to the VPC, we need to do the following:
Assign the AWSLambdaVPCAccessExecutionRole and AWSLambda_FullAccess policies.
Create the LambdaSecurityGroup security group(inside our VPC) and use it in our Lambda function(SecurityGroupIds property).
Assign a subnet(the same subnet where our Redis cache lives) to the Lambda function(SubnetIds property)
Run sam build to build the application, and then sam deploy --guided, the command will guide you through the deployment. One thing to notice is that, by default, the Redis is not designed to be public. You can follow this article to achieve it, but we recommend using a local instance to test your lambda function before deploying it. All the code is available here. Thanks, and happy coding.
