> You can definitely achieve multiple lambda functions from one code base using the Lambda Bootstrapper and the custom runtime feature.

[antsaia]

You can definitely achieve multiple lambda functions from one code base using the Lambda Bootstrapper and the custom runtime feature.

I have a suite of 16 lambdas that are deployed from one application, rather than a “monolith”.

This is achieved by using the _handler environment variable to pick the method to use at runtime, rather than the hard-coded one-to-one mapping shown in the blog post’s sample code.

I think of it as a console app which receives a switch that tells it what action to “become” when started up.

@martincostello

I'm having some trouble pulling this off based on your explanation. I have about 20 Lambda functions in my Functions.cs that are tied to corresponding definitions in my serverless.template. I understand you would be passing an environment variable with each definition to indicate which function to call. Most of these functions are of the signature:

public APIGatewayProxyResponse ThisLambdaFunction(APIGatewayProxyRequest request, ILambdaContext context)
{

How do add support for different lambda function signatures, if I have other functions that take different arguments (other than APIGatewayProxyRequest ) and different return types ?

Originally posted by @antsaia in #554 (comment)

[klaytaybai]

Thanks for opening the separate issue. I'm hoping @martincostello or @antsaia will respond to provide more discussion on this. If I have time, I'll play around with it too to give a better opinion and guidance. Which aspects of the codebase are you hoping to share and which are you hoping to abstract? Will 3.1 support solve your problem?

[martincostello]

So here's a very simplified way to try and illustrate how you could do this that I've adapted from a production application that can run as one of 18 different functions that process an SQS message from a queue. The messages perform very similar processing via a series of different triggers, which is why we package the application as one unit and change its "role" via configuration, rather than maintain 18 different functions with lots of shared code via assembly references.

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Amazon.Lambda.Core;
using Amazon.Lambda.RuntimeSupport;
using Amazon.Lambda.SQSEvents;
using Microsoft.Extensions.DependencyInjection;

namespace MyLambdaFunctions
{
    public static class FunctionEntrypoint
    {
        public static async Task RunAsync(
            string handlerName,
            HttpClient httpClient = null,
            CancellationToken cancellationToken = default)
        {
            using var function = new ApplicationFunction();

            using HandlerWrapper handlerWrapper = GetHandlerWrapperForFunction(function, handlerName);
            using var bootstrap = new LambdaBootstrap(httpClient ?? new HttpClient(), handlerWrapper, function.InitializeAsync);

            await bootstrap.RunAsync(cancellationToken);
        }

        internal static async Task Main()
        {
            await RunAsync(Environment.GetEnvironmentVariable("_HANDLER"));
        }

        private static HandlerWrapper GetHandlerWrapperForFunction(
            ApplicationFunction function,
            string handlerName)
        {
            Func<SQSEvent, ILambdaContext, Task> handler = handlerName.ToLowerInvariant() switch
            {
                "foo" => function.HandleFooAsync,
                "bar" => function.HandleBarAsync,
                _ => throw new NotSupportedException(),
            };

            var serializer = new Amazon.Lambda.Serialization.Json.JsonSerializer();

            return HandlerWrapper.GetHandlerWrapper(handler, serializer);
        }
    }

    public class ApplicationFunction : IDisposable
    {
        private bool _disposed;
        private ServiceProvider _serviceProvider;

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        public Task<bool> InitializeAsync()
        {
            if (_serviceProvider != null)
            {
                throw new InvalidOperationException();
            }

            _serviceProvider = CreateServiceProvider();

            return Task.FromResult(true);
        }

        public async Task HandleFooAsync(SQSEvent sqsEvent, ILambdaContext context)
        {
            await HandleAsync<Foo>(sqsEvent);
        }

        public async Task HandleBarAsync(SQSEvent sqsEvent, ILambdaContext context)
        {
            await HandleAsync<Bar>(sqsEvent);
        }

        protected virtual void ConfigureServices(IServiceCollection services)
        {
            services.AddSingleton<ISqsMessageParser, SqsMessageParser>();

            services.AddSingleton<IHandler<Foo>, FooHandler>();
            services.AddSingleton<IHandler<Bar>, BarHandler>();

            services.AddSingleton<IMessageProcessor<Foo>, IMessageProcessor<Foo>>();
            services.AddSingleton<IMessageProcessor<Bar>, IMessageProcessor<Bar>>();
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    _serviceProvider?.Dispose();
                }

                _disposed = true;
            }
        }

        private ServiceProvider CreateServiceProvider()
        {
            var services = new ServiceCollection();

            ConfigureServices(services);

            return services.BuildServiceProvider();
        }

        private async Task HandleAsync<T>(SQSEvent sqsEvent)
            where T : class
        {
            var processor = _serviceProvider.GetRequiredService<IMessageProcessor<T>>();

            await processor.ProcessAsync(sqsEvent);
        }
    }

    public class Foo
    {
        public string UserId { get; set; }

        public string Message { get; set; }
    }

    public class Bar
    {
        public string UserId { get; set; }

        public string Text { get; set; }
    }

    public interface IHandler<in T>
        where T : class
    {
        Task HandleAsync(T message);
    }

    public class FooHandler : IHandler<Foo>
    {
        public Task HandleAsync(Foo message)
        {
            // TODO Do something with Foo
            return Task.CompletedTask;
        }
    }

    public class BarHandler : IHandler<Bar>
    {
        public Task HandleAsync(Bar message)
        {
            // TODO Do something with Bar
            return Task.CompletedTask;
        }
    }

    public interface ISqsMessageParser
    {
        IEnumerable<T> Parse<T>(SQSEvent value);
    }

    public class SqsMessageParser : ISqsMessageParser
    {
        public IEnumerable<T> Parse<T>(SQSEvent value)
        {
            foreach (var record in value.Records)
            {
                yield return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(record.Body);
            }
        }
    }

    public interface IMessageProcessor<T>
        where T : class
    {
        Task ProcessAsync(SQSEvent sqsEvent);
    }

    public class MessageProcessor<T> : IMessageProcessor<T>
        where T : class
    {
        private readonly IHandler<T> _handler;
        private readonly ISqsMessageParser _parser;

        public MessageProcessor(IHandler<T> handler, ISqsMessageParser parser)
        {
            _handler = handler;
            _parser = parser;
        }

        public async Task ProcessAsync(SQSEvent sqsEvent)
        {
            foreach (var message in _parser.Parse<T>(sqsEvent))
            {
                await _handler.HandleAsync(message);
            }
        }
    }
}

[antsaia]

Ok it some time for me to wrap my head around the few examples I was able to find. @martincostello first of all THANK YOU for taking the time to provide that example. That came in handy in helping me come up with my own solution.

I still don't fully understand what you did there with MessageProcessor, SqsMessageParser, CreateService provider. It looks like you're building custom Async support for SQSEvent handling and that all of your Lambda handler functions are triggered by SQSEvents. Is that right?

Is this a requirement for Amazon.Lambda.RuntimeSupport or is it for your own requirements?

My use case was different in that I have about 50 separate Lambda functions in this one project, in the one shared Functions.cs, and that use several different Trigger types. Most of the functions are triggered by API Gateway and take a APIGatewayProxyRequest parameter, but others are triggered by SQSEvent or another. See my slimmed down version of Functions.cs below. I would love to get some feedback on how I'm doing this and if you think it can be simplified.

I'm pulling "AWS_LAMBDA_FUNCTION_NAME" and my "EnvironmentName" from EnvironmentVariables to determine which function to run.

`using System.Linq;
using System.Net;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.IdentityModel.Tokens;
using Amazon.Lambda.Core;
using Amazon.Lambda.APIGatewayEvents;
using Amazon.Lambda.RuntimeSupport;
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.Json.JsonSerializer))]
namespace My.Lambda
{
public partial class Functions
{
private static async Task Main(string[] args)
{
//Get Handler Function Name
//ex: testProcessIncoming gets concerted to ProcessIncoming, which is the handler function name
int index = Environment.GetEnvironmentVariable("AWS_LAMBDA_FUNCTION_NAME").IndexOf(Environment.GetEnvironmentVariable("EnvironmentName"));
var handlerName = (index < 0)
? Environment.GetEnvironmentVariable("AWS_LAMBDA_FUNCTION_NAME")
: Environment.GetEnvironmentVariable("AWS_LAMBDA_FUNCTION_NAME").Remove(index, Environment.GetEnvironmentVariable("EnvironmentName").Length);

        switch (handlerName)
        {
            case "ProcessIncoming":
                Action<SQSEvent, ILambdaContext> sqsFunctionHandler = ProcessIncoming;
                using (var handlerWrapper = HandlerWrapper.GetHandlerWrapper(sqsFunctionHandler, new Amazon.Lambda.Serialization.Json.JsonSerializer()))
                {
                    using (var bootstrap = new LambdaBootstrap(handlerWrapper))
                    {
                        await bootstrap.RunAsync();
                    }
                }
                break;


            case "SendMobilePushNotification":
                Action<string, ILambdaContext> spnFunctionHandler = SendMobilePushNotification;
                using (var handlerWrapper = HandlerWrapper.GetHandlerWrapper(spnFunctionHandler, new Amazon.Lambda.Serialization.Json.JsonSerializer()))
                {
                    using (var bootstrap = new LambdaBootstrap(handlerWrapper))
                    {
                        await bootstrap.RunAsync();
                    }
                }
                break;

            case "LogTelemetryData":
                Action<TelemetryEvent<object>> ltdFunctionHandler = LogTelemetryDataInternal;
                using (var handlerWrapper = HandlerWrapper.GetHandlerWrapper(ltdFunctionHandler, new Amazon.Lambda.Serialization.Json.JsonSerializer()))
                {
                    using (var bootstrap = new LambdaBootstrap(handlerWrapper))
                    {
                        await bootstrap.RunAsync();
                    }
                }
                break;


            default:
                {
                    Func<APIGatewayProxyRequest, ILambdaContext, APIGatewayProxyResponse> apiGatewayFunctionHandler = null;
                    switch (handlerName)
                    {
                        case "SetAgentAvailability": apiGatewayFunctionHandler = SetAgentUnavailable; break;
                        case "ReceiveSlackMessage":
                            apiGatewayFunctionHandler = ReceiveSlackMessage; break;

                            using (var handlerWrapper = HandlerWrapper.GetHandlerWrapper(apiGatewayFunctionHandler, new Amazon.Lambda.Serialization.Json.JsonSerializer()))
                            {
                                using (var bootstrap = new LambdaBootstrap(handlerWrapper))
                                {
                                    await bootstrap.RunAsync();
                                }
                            }
                            break;
                    }

                }
        }


        public static void ProcessIncoming(SQSEvent @event, ILambdaContext context)
        {
            var records = @event.Records;

            if (records != null && records.Any())
            {
                //Do some cool stuff
            }
        }

        public static void SendMobilePushNotification(string msg, ILambdaContext context)
        {
            //Do something amazing
        }

        public static void LogTelemetryData(TelemetryEvent<object> telemetryEvent)
        {
            //I don't know what I'm doing
        }

        public static APIGatewayProxyResponse SetAgentAvailability(APIGatewayProxyRequest request, ILambdaContext context)
        {
            APIGatewayProxyResponse result = new APIGatewayProxyResponse();

            if (request.Headers != null && request.Headers.Any())
            {
                // Let's go!
            }
            else
            {
                result.StatusCode = (int)HttpStatusCode.Unauthorized;
            }

            return result;
        }

        public static APIGatewayProxyResponse SetAgentAvailability(APIGatewayProxyRequest request, ILambdaContext context)
        {
            APIGatewayProxyResponse result = new APIGatewayProxyResponse();

            if (request.Headers != null && request.Headers.Any())
            {
                // Let's go!
            }
            else
            {
                result.StatusCode = (int)HttpStatusCode.Unauthorized;
            }

            return result;
        }


        public static APIGatewayProxyResponse ReceiveSlackMessage(APIGatewayProxyRequest request, ILambdaContext context)
        {
            APIGatewayProxyResponse result = new APIGatewayProxyResponse();

            if (request.Headers != null && request.Headers.Any())
            {
                // Let's go!
            }
            else
            {
                result.StatusCode = (int)HttpStatusCode.Unauthorized;
            }

            return result;
        }
    }
}

}`

[antsaia]

I can't get the code above to display correctly for some reason. Here's a link to it: https://pastebin.com/8JgibAce

[martincostello]

I'm glad you found it useful.

I still don't fully understand what you did there with MessageProcessor, SqsMessageParser, CreateService provider. It looks like you're building custom Async support for SQSEvent handling and that all of your Lambda handler functions are triggered by SQSEvents. Is that right?

Is this a requirement for Amazon.Lambda.RuntimeSupport or is it for your own requirements?

In a nutshell the processor is used to dispatch a batch of an arbitrary strongly-typed message within an SQS message to a handler function.

This isn't a requirement of runtime support, it's just how I've chosen to tackle the problem to simplify the amount of boilerplate code to go from a type of message in a batch to a handler function while still using dependency injection etc where there's 18 different messages with similar themes all being routed into the same code eventually.

The Lambdas we use in my team all process SQS events and no other types of triggers, so that's why that's all that's demonstrated in the sample.

[ashishdhingra]

Hi @antsaia,

Good afternoon.

I was going through the old issues and encountered this one. Please confirm if @martincostello provided guidance works for you and if this issue could be closed.

Thanks,
Ashish

[github-actions]

This issue has not recieved a response in 2 weeks. If you want to keep this issue open, please just leave a comment below and auto-close will be canceled.