Autor cu Steef-Jan Wiggers la Microsoft Azure

Cu Funcțiile durabile, puteți programa un flux de lucru și puteți crea sarcini în ordine secvențială sau paralelă, sau puteți construi un ceas sau susține un flux de interacțiune umană (flux de lucru de aprobare). Puteți conecta funcții pentru a vă controla fluxul. Puteți utiliza scenarii fan-in și fan-out, evenimente corelate, automatizări flexibile și procese de lungă durată și modele de interacțiune umană greu de pus în aplicare cu funcții sau cu aplicații logice.

Funcții de înlănțuire

Cea mai naturală și simplă utilizare a funcțiilor durabile este înlănțuirea funcțiilor. Aveți o funcție de orchestrator care apelează multe funcții în ordinea dorită. Puteți face acest lucru doar cu funcții și folosind cozile de autobuz de servicii, totuși veți întâmpina câteva provocări:

  • fără vizualizare pentru a arăta relația dintre funcții și cozi
  • cozile de mijloc sunt un detaliu de implementare, cu o cheltuială conceptuală
  • gestionarea erorilor adaugă mult mai multă complexitate

Folosind funcții durabile, nu veți întâmpina aceste provocări. Cu un orchestrator tu:

  • poate avea un loc central pentru a seta ordinea apelurilor de funcție (relații)
  • nu trebuie să gestionați cozile – sub capotă, funcțiile durabile utilizează și gestionează cozile de stocare
  • au gestionarea centralizată a erorilor – atunci când apare o eroare într-una din funcțiile de activitate, eroarea se propagă înapoi către orchestrator
//calls functions in sequence
public static async Task<object> Run (DurableOrchestrationContext ctx)
{ 
 try
 {
 var x = await ctx.CallFunctionAsync (“F1”);
 var y = await ctx.callFunctionAsync (“F2”, x);
 var z = await ctx.callFunctionAsync (“F3”, y);
 return = await ctx.CallFunctionAsync (“F4”, z);
 }
 
catch (Exception )
 {
 //global error handling /compensation goes here
 }
}

Fan-out / Fan-in

Fan-out / fan-in poate fi utilizat atunci când trebuie să executați una sau mai multe funcții în paralel și, pe baza rezultatelor, executați alte sarcini. Cu funcțiile, nu puteți pune în aplicare o astfel de abordare. Mai mult, vă veți confrunta și cu provocările menționate în secțiunea anterioară. Dar, cu funcții durabile, puteți realiza ventilare / intrare ventilator:

public static async Task Run (Durableorchestrationcontext ctx)
{
var parallelTasks = new List<Task<int>>();
//get a list of N work items to process in parallel
object []workBatch = await ctx.CallFunctionAsync<object[]> (“F1”);
for (int i = 0; i < workBatch.Length; i++)
{
Task<int> task = ctx.CallFunctionAsync <int> (“F2”, workBatch [i]); 
parallelTasks.Add (task);
}
await Task.WhenAll(parallelTasks);
//aggregate all N outputs and send result to F3
int sum = parallelTasks.Sum(t=> t.Result); 
await ctx.CallFunctionAsync (“F3”, sum);
}

Răspuns asincron HTTP

Cu funcțiile, este posibil ca atunci când apelați un alt API să nu știți cât timp ar dura înainte ca un răspuns să fie returnat. De exemplu, latența și volumul pot determina necunoașterea timpului pe care API l-ar face să proceseze cererea și să returneze un răspuns.

O funcție poate expira când se utilizează un plan de consum. Statul trebuie menținut, ceea ce este nedorit pentru funcții, deoarece acestea trebuie să fie apatrizi. Funcțiile durabile oferă API-uri încorporate care simplifică codul pe care îl scrieți pentru interacțiunea cu execuțiile de funcții de lungă durată. Mai mult, starea este gestionată de funcțiile Durable run-time.

//HTTP-triggered function to start a new orchestrator function instance.
public static async Task<HttpResponseMessage> Run (
HttpReq uestMessage req, DurableOrchestrationClient starter,
string functionName,
Ilogger log)
{
//Function name comes from the request URL.
//Function input comes from the request content .
dynamic eventData await req.Content .ReadAsAsync<object>();
string instanceid = await starter.StartNewAsync (functionName , eventData);
log .Loginformation ($”Started orchestration with ID = ‘{instanceid} ‘.”);
return starter.CreateCheckStatusResponse (req, instanceid);
}

Actori

O altă utilizare este monitorul – un proces recurent într-un flux de lucru, cum ar fi un proces de curățare. Puteți pune acest lucru cu o funcție. Dar, din nou, veți avea câteva provocări:

  • funcțiile sunt apatrizi și de scurtă durată
  • accesul de citire / scriere la o stare externă trebuie sincronizat

Cu funcțiile durabile, puteți avea intervale de recurență flexibile, gestionarea duratei de activitate și capacitatea de a crea multe procese de vizionare dintr-o singură orchestrație.

public static async Task Run(DurableOrchestrationContext ctx)
{
int counterState = ctx.Getinput<int>();
string operation = await ctx.WaitForExternalEvent<string>(“operation”);
if (operation == “incr”)
{
counterState++;
}
else if (operation == “decr”)
{
counterstate --;
}
ctx.ContinueAsNew(counterState);
}

Interacțiune umană

În cadrul organizațiilor, vă veți confrunta cu procese care necesită unele interacțiuni umane, cum ar fi aprobările. Interacțiunile precum aprobările necesită disponibilitatea aprobatorului. Astfel, procesul trebuie să fie activ de ceva timp și are nevoie de un mecanism de încredere atunci când procesul expiră. De exemplu, atunci când o aprobare nu are loc în termen de 72 de ore, trebuie să înceapă un proces de escaladare. Cu funcțiile durabile, puteți susține un astfel de scenariu.

public static async Task Run(DurableOrchestrationContext ctx)
{
await ctx.CallFunctionAsync<object []>(“RequestApproval”);
using (var timeoutCts = new CancellationTokenSource())
{
DateTime dueTime = ctx.CurrentUtcDateTime.AddHours(72);
Task durableTimeout = ctx.CreateTimer(dueTime, 0, cts.Token);
Task<bool > approvalEvent = ctx.WaitForExternalEvent< bool>(“ApprovalEvent”);
if (approvalEvent == await Task .WhenAny(approvalEvent, durableTimeout ))
{
timeoutCts.Cancel();
await ctx .CallFunctionAsync(“HandleApproval”, approvalEvent.Result);
}
else
{
await ctx.CallFunctionAsy nc(“Escalate” );
}
}
}

Implementarea eșantionului: înlănțuirea utilizând funcții durabile

O introducere in functiile Azure Durable modele si cele mai

Clientul Orchestrator este o funcție care poate fi declanșată atunci când este trimis un mesaj. Acest client, o funcție, va apela la Orchestrator și va transmite mesajul comenzii.

public static async Task<HttpResponseMessage> Run (
HttpReq uestMessage req, DurableOrchestrationClient starter, string functionName,
Ilogger log)
{
//Function name comes from the request URL.
//Function input comes from the request content .
dynamic eventData await req.Content .ReadAsAsync<object>();
string instanceid = await starter.StartNewAsync ( functionName , eventData);
log .Loginformation ($”Started orchestration with ID = ‘{instanceid} ‘.”);
return starter.CreateCheckStatusResponse (req, instanceid);
}

Orchestratorul va primi comanda și va apela funcțiile de activitate.

public static async Task Run(DurableOrchestrationContext context, object order, ILogger log)
{
log.LogInformation($”Data = ‘{order}’.”);
var orderDetail = (OrderDetail) order;
try
{
bool x = await context.CallActivityAsync<bool>(“WriteToDatabase”, orderDetail);
log.LogInformation($”Data storage = ‘{x}’.”);
if (x == true)
{
await context.CallActivityAsync<OrderDetail>(“WriteToArchive”, orderDetail);
await context.CallActivityAsync<OrderDetail>(“SendNotification”, orderDetail);
}
}
catch (Exception)
{
//ErrorHandling
}
}

Fiecare dintre funcțiile de activitate va efectua o sarcină – în acest caz, stocați comanda într-o colecție de documente într-o instanță CosmosDB, arhivați mesajul stocat și trimiteți un mesaj la coadă pentru a trimite o notificare printr-o aplicație logică.

Cele mai bune practici

Cu funcțiile durabile există câteva bune practici de urmat:

  • utilizați aplicația Azure App Insights pentru a monitoriza instanțele și starea de rulare, inclusiv funcțiile Azure
  • aplicația Durable Functions expune și API-ul HTTP pentru gestionare. Cu metodele API, puteți influența cursul acțiunilor pentru funcțiile dvs. durabile.
  • utilizați controlul versiunii cu funcția dvs. durabilă
  • puteți utiliza implementarea side-by-side, actualizând numele centrului dvs. de activități la implementare. Vedea Funcții durabile Strategii de implementare Blue Green pentru mai multe informatii.

Învelire

În această postare pe blog, sperăm să înțelegeți mai bine utilizarea funcțiilor durabile și ce valoare oferă. Funcțiile durabile vă oferă controlul final asupra unui flux de lucru, care nu poate fi realizat cu tehnologii alternative, cum ar fi aplicații logice sau funcții. Împreună cu unele dintre cele mai bune practici pe care le-am consolidat, ar trebui să puteți construi acum soluții durabile cu funcții durabile.

Acest articol a fost publicat inițial la Serverless360.