Guidance to use Parallel with DynamoDB

[nicolastarzia]

I created a simple code to test a specific scenario that I'm facing using Lambda Function to use DynamoDB and Systems.Thread.Tasks.Parallel.

If I run the following Parallel in 100 times, function is executed by no mistake.
If I run the following Parallel as the code is showing, function returned exception "Out of Memory" and during the parallel it's showing: "Too many files open".

Out of memory in this scenario means that I opened too many sockets!

I'd like to know if it's a best practice to use the Systems.Thread.Tasks.Parallel with AWS SDK.

using System;
using System.Text;
using System.Threading.Tasks;
using Amazon.Lambda.Core;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;

// Assembly attribute to enable Lambda function logging
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace ExampleLambda;

public class OrderHandler
{
    private readonly IAmazonDynamoDB _dynamoClient;

    public OrderHandler()
    {
        _dynamoClient = new AmazonDynamoDBClient();
    }

    public async Task<string> HandleRequest(OrderRequest request, ILambdaContext context)
    {
        var parallelOptions = new ParallelOptions  
        {  
            MaxDegreeOfParallelism = 8  
        };

        Parallel.For(0, 10000, parallelOptions, async i =>
        {
            try{
                var getRequest = new GetItemRequest
                {
                    TableName = "Orders",
                    Key = new Dictionary<string, AttributeValue>
                    {
                        { "OrderId", new AttributeValue { S = $"ORDER-{i}" } }
                    }
                };
            

                await _dynamoClient.GetItemAsync(getRequest);
                Console.WriteLine($"Querying item {i}");
            }catch(Exception e){
                Console.WriteLine(e);
            }
            
        });

        return "Queries completed";
    }
}

public class OrderRequest
{
    public string Order { get; set; }
}

[AlexDaines]

Parallel.For doesn't await async lambdas, they become fire-and-forget, so you're opening all 10k connections at once.

Either throttle with a semaphore + Task.WhenAll, or use BatchGetItemAsync to fetch up to 100 items per request.

[normj]

As @AlexDaines said the Parallel.For doesn't await the Action passed in so the 10000 iterations fire off immediately because as far Parallel.For is concerned the Action is over once you hit your first await call and then starts another one.

I think all you have to do is change the Parallel.For to Parallel.ForEachAsync. Don't forget to await the Parallel.ForEachAsync call.

        await Parallel.ForEachAsync(
            Enumerable.Range(0, 10_000),
            new ParallelOptions
            {
                MaxDegreeOfParallelism = 8
            },
            async (i, ct) =>
            {
                var getRequest = new GetItemRequest
                {
                    TableName = "Orders",
                    Key = new Dictionary<string, Amazon.DynamoDBv2.Model.AttributeValue>
                    {
                        { "OrderId", new Amazon.DynamoDBv2.Model.AttributeValue { S = $"ORDER-{i}" } }
                    }
                };

                await _dynamoClient.GetItemAsync(getRequest, ct);
            });