How to use Dependency Injection in AWS Lambda C# implementation

Question

I have created Lambda functions using AWS.Net SDK, .net core version 1.0. I want to implement dependency injection. Since lambda functions triggered and run independently in AWS environment, there is no such class like Startup present. How and Where can I configure my containers to achieve this implementation?

Answer 1

I know I am way late to the game but I am adding this because I believe there are some bad/lacking examples out on the internet. @Erndob is right about the accepted answer. You'll just be creating more instances.

Depending on what registrations you are making in your DI container you need to keep in mind:

1. What registrations are you making that implement IDisposable
2. How long does AWS keep the instance of your object around. I have not been able to find any documentation on this.

Ended up going with something like this:

public class Function
{
    private ServiceCollection _serviceCollection;

    public Function()
    {
        ConfigureServices();
    }

    public string FunctionHandler(string input, ILambdaContext context)
    {
        using (ServiceProvider serviceProvider = _serviceCollection.BuildServiceProvider())
        {
            // entry to run app.
            return serviceProvider.GetService<App>().Run(input);
        }
    }

    private void ConfigureServices()
    {
        // add dependencies here
        _serviceCollection = new ServiceCollection();
        _serviceCollection.AddTransient<App>();
    }
}

With this pattern each lambda invocation will get a new ServiceProvider and dispose of it when finished.

Answer 2

While the FunctionHandler is indeed your entry point to your application, I would actually wire up your DI in a parameterless constructor. The constructor only ever gets called once, so this purely "setup" code should really only need to be called once. We just want to take advantage of using it in every subsequent invocation that gets routed to the same container.

public class Function
{
    private static ServiceProvider ServiceProvider { get; set; }

    /// <summary>
    /// The parameterless constructor is what Lambda uses to construct your instance the first time.
    /// It will only ever be called once for the lifetime of the container that it's running on.
    /// We want to build our ServiceProvider once, and then use the same provider in all subsequent 
    /// Lambda invocations. This makes things like using local MemoryCache techniques viable (Just 
    /// remember that you can never count on a locally cached item to be there!)
    /// </summary>
    public Function()
    {
        var services = new ServiceCollection();
        ConfigureServices(services);
        ServiceProvider = services.BuildServiceProvider();
    }

    public async Task FunctionHandler(SQSEvent evnt, ILambdaContext context)
    {
        await ServiceProvider.GetService<App>().Run(evnt);
    }

    /// <summary>
    /// Configure whatever dependency injection you like here
    /// </summary>
    /// <param name="services"></param>
    private static void ConfigureServices(IServiceCollection services)
    {
        // add dependencies here ex: Logging, IMemoryCache, Interface mapping to concrete class, etc...

        // add a hook to your class that will actually do the application logic
        services.AddTransient<App>();
    }

    /// <summary>
    /// Since we don't want to dispose of the ServiceProvider in the FunctionHandler, we will
    /// at least try to clean up after ourselves in the destructor for the class.
    /// </summary>
    ~Function()
    {
        ServiceProvider.Dispose();
    }
}

public class App
{
    public async Task Run(SQSEvent evnt)
    {
        // actual business logic goes here
        await Task.CompletedTask;
    }
}

Answer 3

You can do this. Your FunctionHandler is your entry point to your application.. so you have to wire up the service collection from there.

public class Function
{
    public string FunctionHandler(string input, ILambdaContext context)
    {
        var serviceCollection = new ServiceCollection();
        ConfigureServices(serviceCollection);

        // create service provider
        var serviceProvider = serviceCollection.BuildServiceProvider();

        // entry to run app.
        return serviceProvider.GetService<App>().Run(input);
    }

    private static void ConfigureServices(IServiceCollection serviceCollection)
    {
        // add dependencies here

        // here is where you're adding the actual application logic to the collection
        serviceCollection.AddTransient<App>();
    }
}

public class App
{
    // if you put a constructor here with arguments that are wired up in your services collection, they will be injected.

    public string Run(string input)
    {
        return "This is a test";
    }
}

If you want to wire up logging, have a look here: https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.Logging.AspNetCore

Answer 4

With the regular Lambda projects template, it seems that Scoped lifetime app didn't exist, you had to create workarounds as the answers above.

With new ".NET Annotations Lambda Framework", AWS is trying to solve that issue.

Here the explanation: https://aws.amazon.com/blogs/developer/introducing-net-annotations-lambda-framework-preview/

Answer 5

Here is another way to handle it. This is a simplified version of some code from here https://aws.amazon.com/blogs/compute/migrating-a-monolithic-net-rest-api-to-aws-lambda/. One notable difference is that BuildServiceProvider() is only called once when the Lambda is created.

public class Function
{
    private static IServiceProvider services;
    private readonly IBookingRepository bookingRepository;
    private readonly ILogger<Function> logger;

    public Function()
    {
        ConfigureServices();
        
        this.bookingRepository = services.GetRequiredService<IBookingRepository>();
        this.logger = services.GetRequiredService<ILogger<Function>>();
    }

    public async Task<APIGatewayProxyResponse> FunctionHandler(APIGatewayProxyRequest apigProxyEvent, ILambdaContext context)
    {
        if (!apigProxyEvent.PathParameters.ContainsKey("customerId"))
        {
            return new APIGatewayProxyResponse
            {
                StatusCode = 400,
                Headers = new Dictionary<string, string> { { "Content-Type", "application/json" } }
            };
        }

        var customerId = apigProxyEvent.PathParameters["customerId"];

        this.logger.LogInformation($"Received request to list bookings for: {customerId}");

        var customerBookings = await this.bookingRepository.ListForCustomer(customerId);

        return new APIGatewayProxyResponse
        {
            Body = JsonSerializer.Serialize(customerBookings),
            StatusCode = 200,
            Headers = new Dictionary<string, string> { { "Content-Type", "application/json" } }
        };
    }

    private void ConfigureServices()
    {
        // Add dependencies here.
        var serviceCollection = new ServiceCollection();
        serviceCollection.AddDbContext<BookingContext>(options =>
            options.UseMySQL("ConnectionString..."));
        serviceCollection.AddTransient<IBookingRepository, BookingRepository>();
        serviceCollection.AddLogging(logging =>
        {
            logging.AddLambdaLogger();
            logging.SetMinimumLevel(LogLevel.Debug);
        });
        services = serviceCollection.BuildServiceProvider();
    }
}

Answer 6

Based on the comments of the answers above, shouldn't the following be the correct answer?

public class Function
{
    private readonly ServiceProvider serviceProvider;

    public Function()
    {
        var serviceCollection = new ServiceCollection();
        serviceCollection.AddTransient<FunctionHandler>(); //your 'app' or actual handler
        //add your services...
        //serviceCollection.AddSingleton(...);
        //serviceCollection.AddScoped(...);

        serviceProvider = serviceCollection.BuildServiceProvider();
    }

    public Task<APIGatewayProxyResponse> Handler(APIGatewayProxyRequest request, ILambdaContext context)
    {
        //create a scope for each function execution, respecting the DI singletons and scoped configurations
        using var scope = serviceProvider.CreateScope();
        return scope.ServiceProvider.GetService<FunctionHandler>()!.Run(request, context);
    }

    ~Function()
    {
        serviceProvider.Dispose();
    }
}