Tempo di ritardo tra l'aumento dell'attività quando si usa il modello di concatenamento delle funzioni di Azure

La soluzione per il tempo di ritardo tra l'aumento dell'attività quando si usa il modello di concatenamento delle funzioni di Azure
è indicata di seguito:

Ho 3000 attività in esecuzione in una riga come il codice qui sotto

Il problema è che per le prime cento attività va veloce.

Per le successive cento attività, inizia a ritardare prima di iniziare una nuova attività (ritardo di 1 secondo tra due attività)

Per le ultime cento attività, il tempo di ritardo è di quasi 15 secondi.

Sembra che la funzione durevole di Azure non supporti il ​​concatenamento che ha una grande quantità di attività. Invece, dovremmo passare a utilizzare uno schema a ventaglio. Ma non soddisfa le mie esigenze.

        [FunctionName("Trigger")]
        public static async Task<HttpResponseMessage> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req,
            [DurableClient] IDurableOrchestrationClient starter,
            ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");
            string instanceId = await starter.StartNewAsync("Orchestrator", null);
            log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
            return starter.CreateCheckStatusResponse(req, instanceId);
        }

        [FunctionName("Orchestrator")]
        public static async Task<List<string>> RunOrchestrator(
            [OrchestrationTrigger] IDurableOrchestrationContext context,
            ILogger log)
        {
            log.LogInformation($"XXX start Orc");
            var outputs = new List<string>();
            //var tasks = new List<Task<string>>();

            // Run activity in a line
            for (int i = 0; i < 3000; i++)
                outputs.Add(await context.CallActivityAsync<string>("Activity", $"Sinh{i + 1}"));

            //outputs.AddRange(await Task.WhenAll(tasks));
            log.LogInformation($"XXX stop Orc");
            return outputs;
        }

        [FunctionName("Activity")]
        public static string SayHello([ActivityTrigger] string name, ILogger log)
        {
            log.LogInformation($"XXX Saying hello to {name}.");
            return $"Hello {name}!";
        }

Tutti i suggerimenti sono molto apprezzati

Mi aspetto che tu possa drammaticamente aumenta la velocità della tua orchestrazione impostando extendedSessionsEnabled a true in host.json. Alcuni documenti qui:https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-perf-and-scale#extended-sessions

Un po' più di background:le orchestrazioni vengono scaricate dalla memoria ogni volta che await per la prima volta un compito particolare. Ciò significa che la tua orchestrazione viene scaricata e ricaricata 3000 volte. Ogni volta che viene ricaricato in memoria, è necessario rileggere la cronologia di esecuzione da Archiviazione di Azure e quindi riprodurre il codice dell'agente di orchestrazione per tornare alla posizione precedente. Ogni ripetizione sarà più costosa perché deve scorrere più codice e caricare più righe della cronologia in memoria.

Le sessioni estese eliminano tutto il comportamento di riproduzione precedente impedendo all'orchestrazione di scaricare il proprio stato. Ciò significa che non deve mai essere riprodotto né ricaricare l'intera cronologia dell'orchestrazione a ogni nuovo await . Lo consiglio vivamente sia per grandi fan-in/fan-out che per grandi sequenze come nel tuo esempio.

Utilizza più processi di lavoro:

Per impostazione predefinita, qualsiasi istanza host per Funzioni utilizza un singolo processo di lavoro. Per migliorare le prestazioni, usa il FUNCTIONS_WORKER_PROCESS_COUNT per aumentare il numero di processi di lavoro per host (fino a 10).

Fare riferimento più qui

Ritardo di orchestrazione :

Le istanze delle orchestrazioni vengono avviate inserendo un ExecutionStarted messaggio in una delle code di controllo dell'hub attività. In determinate condizioni, è possibile osservare ritardi di più secondi tra il momento in cui è pianificata l'esecuzione di un'orchestrazione e l'avvio dell'esecuzione. Durante l'intervallo, l'istanza di orchestrazione rimane nel Pending stato. Ci sono due potenziali cause di questo ritardo:

Code di controllo arretrate:
La coda di controllo dell'istanza contiene un numero elevato di messaggi, potrebbe volerci del tempo prima che il ExecutionStarted il messaggio viene ricevuto ed elaborato dal runtime. I backlog di messaggi possono verificarsi quando le orchestrazioni elaborano molti eventi contemporaneamente. Gli eventi che entrano nella coda di controllo includono eventi di inizio dell'orchestrazione, completamenti di attività, timer durevoli, terminazione ed eventi esterni. Se questo ritardo si verifica in circostanze normali, prendere in considerazione la creazione di un nuovo hub attività con un numero maggiore di partizioni. La configurazione di più partizioni farà sì che il runtime crei più code di controllo per la distribuzione del carico. Ogni partizione corrisponde a 1:1 con una coda di controllo, con un massimo di 16 partizioni.

Per impostazione predefinita, il numero di partizioni è quattro . Se sono necessarie più partizioni, è necessario aggiornare la configurazione dell'hub attività in host.json con un nuovo conteggio delle partizioni. L'host rileverà questa modifica dopo il riavvio.

Ritiro dei ritardi nei sondaggi:
Un'altra causa comune di ritardi nell'orchestrazione è descritta qui, comportamento del polling di back-off per le code di controllo. Tuttavia, questo ritardo è previsto solo quando un'app viene ridimensionata a due o più istanze. Se è presente una sola istanza dell'app o se l'istanza dell'app che avvia l'orchestrazione è anche la stessa istanza che esegue il polling della coda di controllo di destinazione, non si verificherà alcun ritardo nel polling della coda. È possibile ridurre i ritardi del polling aggiornando host.json impostazioni, come descritto in precedenza.

Fai riferimento ai ritardi di orchestrazione