Azure 功能 - 并行任务似乎不会同时运行

Question

I have a question referencing the usage of concurrently running tasks in Azure Functions, on the consumption plan.

One part of our application allows users to connect their mail accounts, then downloads messages every 15 minutes. We have azure function to do so, one for all users. The thing is, as users count increases, the function need's more time to execute.

In order to mitigate a timeout case, I've changed our function logic. You can find some code below. Now it creates a separate task for each user and then waits for all of them to finish. There is also some exception handling implemented, but that's not the topic for today.

The problem is, that when I check some logs, I see executions as the functions weren't executed simultaneously, but rather one after one. Now I wonder if I made some mistake in my code, or is it a thing with azure functions that they cannot run in such a scenario (I haven't found anything suggesting it on the Microsoft sites, quite the opposite actually)

PS - I do know about durable functions, however, for some reason I'd like to resolve this issue without them.

My code:

List<Task<List<MailMessage>>> tasks = new List<Task<List<MailMessage>>>();
            foreach (var account in accounts)
            {
                using (var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromMinutes(6)))
                {
                    try
                    {
                        tasks.Add(GetMailsForUser(account, cancellationTokenSource.Token, log));
                    }
                    catch (TaskCanceledException)
                    {
                        log.LogInformation("Task was cancelled");
                   }
                }
            }
            
            try
            {
                await Task.WhenAll(tasks.ToArray());
            }
            catch(AggregateException aex)
            {
                aex.Handle(ex =>
                {
                    TaskCanceledException tcex = ex as TaskCanceledException;
                    if (tcex != null)
                    {
                        log.LogInformation("Handling cancellation of task {0}", tcex.Task.Id);
                        return true;
                    }
                    return false;
                });
            }

            log.LogInformation($"Zakończono pobieranie wiadomości.");

private async Task<List<MailMessage>> GetMailsForUser(MailAccount account, CancellationToken cancellationToken, ILogger log)
    {
        log.LogInformation($"[{account.UserID}] Rozpoczęto pobieranie danych dla konta {account.EmailAddress}");

        IEnumerable<MailMessage> mails;

        try
        {
            using (var client = _mailClientFactory.GetIncomingMailClient(account))
            {
                mails = client.GetNewest(false);
            }
            log.LogInformation($"[{account.UserID}] Pobrano {mails.Count()} wiadomości dla konta {account.EmailAddress}.");
            return mails.ToList();
        }
        catch (Exception ex)
        {
            log.LogWarning($"[{account.UserID}] Nie udało się pobrać wiadomości dla konta {account.EmailAddress}");
            log.LogError($"[{account.UserID}] {ex.Message} {ex.StackTrace}");
            return new List<MailMessage>();
        }
    }

Output:

Answer 1

Azure functions in a consumption plan scales out automatically. Problem is that the load needs to be high enough to trigger the scale out.

What is probably happening is that the scaling is not being triggered, therefore everything runs on the same instance, therefore the calls run sequentially.

There is a discussion on this with some code to test it here: https://docs.microsoft.com/en-us/answers/questions/51368/http-triggered-azure-function-not-scaling-to-extra.html

Answer 2

The compiler will give you a warning for GetMailsForUser :

CS1998: This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(…)' to do CPU-bound work on a background thread.

It's telling you it will run synchronously, which is the behaviour you're seeing. In the warning message there's a couple of recommendations:

1. Use await . This would be the most ideal solution, since it will reduce the resources your Azure Function uses. However, this means your _mailClientFactory will need to support asynchronous APIs, which may be too much work to take on right now (many SMTP libraries still do not support async ).
2. Use thread pool threads. Task.Run is one option, or you could use PLINQ or Parallel . This solution will consume one thread per account, and you'll eventually hit scaling issues there.

Answer 3

1. If you want to identify which Task is running in which Function instance etc. use invocation id ctx.InvocationId.ToString() . May be prefix all your logs with this id.

2. Your code isn't written such that it can be run in parallel by the runtime. See this: Executing tasks in parallel

3. You can also get more info about the trigger using trigger meta-data . Depends on trigger. This is just to get more insight into what function is handling what message etc.