Serverless Workflows with Durable Functions

Azure Functions are simple, short-lived, stateless, single-purpose actions that respond to events in the cloud.

But what if you need to implement a multi-step, long-running, stateful workflow? Aren't you able to reap the benefits of serverless? Or do you have to manage the orchestration of multiple isolated functions?

In this talk, Mikhail will demonstrate how Durable Functions combine Azure Functions and Durable Task to enable you to manage workflows. The toolbox includes "fan-out fan-in" pattern, waiting for external events and human interaction, error handling, retries and timeouts.

Transcript

1. Serverless Workflows with Durable Functions Mikhail Shilkov Milan | November 29 - 30, 2018
2. Microservices Event-Driven Cloud Serverless Function-as- a-Service Problems of Cloud Apps Activities & Orchestrators Activity Chaining Error Handling Parallelization External Events and Timers Conclusions
3. Microservices
4. Monolith Module A Module B Module C
5. Vertical Slices with Data Stores Service A Service B Service C
6. Distributed Systems Service A Service B Unreliable Network
7. The fallacy of synchronous HTTP-based communication Service A Service B Service C http(s) http(s)
8. The fallacy of synchronous HTTP-based communication Service A Service B Service C http(s) http(s)
9. Cascading Failures Service A Service B Service C http(s) http(s)
10. Event-Driven
11. Events: Decrease Coupling Service A Service B Service C Event Event
12. Martin Fowler “What do you mean by Event-Driven?”
13. Cloud
14. The Ultimate Distributed System
16. Serverless
17. Paul Johnston “A simple definition of Serverless”
18. Examples
19. Function-as-a- Service
20. Low Friction, Great Business Value $
21. Opiniated Development Model
22. Cloud Glue
23. Serverless Serviceful
24. Problems
25. Event-Driven Conference Planning App Book Conf. Book Flight Book Hotel Event Event
26. Flexible Sequencing Book Conf. Book Flight Book Hotel
27. Error Handling Book Conf. Book Flight Event
28. Stateful Retries Book Conf. Book Flight Event
29. Fallback on Error Book Conf. Book Flight Book Train Event
30. Parallel Calls (Fan-in) Book Conf. Book Flight Report Expenses Book Hotel Event Event Event
31. Missing Orchestration Plan Trip to Codemotion Book Conf. Book Flight Book Hotel
32. Introducing Azure Durable Functions
33. Built On
34. Activities Book Conf. Book Flight Book Hotel
35. Activity in C# [FunctionName("BookConference")] public static string BookConference( [ActivityTrigger] string name) { var ticket = BookingService.Book(name); return $"Ticket is {ticket}"; }
36. Activity in C# [FunctionName("BookConference")] public static string BookConference( [ActivityTrigger] string name) { var ticket = BookingService.Book(name); return $"Ticket is {ticket}"; }
37. Activity in C# [FunctionName("BookConference")] public static string BookConference( [ActivityTrigger] string name) { var ticket = BookingService.Book(name); return $"Ticket is {ticket}"; }
38. Orchestrator Plan Trip to Codemotion Book Conf. Book Flight Book Hotel
39. Orchestrator in C# [FunctionName("TrivialOrchestrator")] public static async Task Trivial( [OrchestrationTrigger] DurableOrchestrationContext context) { await context.CallActivityAsync<string> ("BookConference", "Codemotion Milan"); }
40. Orchestrator in C# [FunctionName("TrivialOrchestrator")] public static async Task Trivial( [OrchestrationTrigger] DurableOrchestrationContext context) { await context.CallActivityAsync<string> ("BookConference", "Codemotion Milan"); }
41. Orchestrator in C# [FunctionName("TrivialOrchestrator")] public static async Task Trivial( [OrchestrationTrigger] DurableOrchestrationContext context) { await context.CallActivityAsync<string> ("BookConference", "Codemotion Milan"); }
42. Activity Chaining
43. Multi-step Workflow Plan Trip to Codemotion Book Conf. Book Flight Book Hotel
44. Multi-step Workflow public static async Task Sequential(DurableOrchestrationContext context) { var conf = await context.CallActivityAsync<ConfTicket> ("BookConference", "Codemotion Milan"); var flight = await context.CallActivityAsync<FlightTickets> ("BookFlight", conf.Dates); await context.CallActivityAsync("BookHotel", flight.Dates); }
45. Behind the scenes: Queues Orchestrator Activity Event Event
46. Behind the scenes: Storage 1. Orchestrator Started 2. ExecutionStarted: PlanTrip 3. TaskScheduled: BookConference 4. OrchestratorCompleted 5. TaskCompleted: "Ticket is 000123" 6. OrchestratorStarted 7. TaskScheduled: BookFlight 8. OrchestratorCompleted 9. TaskCompleted: “Reservation UY9H2J"
47. Stop-Resume Behaviour public static async Task Sequential(DurableOrchestrationContext context) { var conf = await context.CallActivityAsync<ConfTicket> ("BookConference", "Codemotion Milan"); var flight = await context.CallActivityAsync<FlightTickets> ("BookFlight", conf.Dates); await context.CallActivityAsync("BookHotel", flight.Dates); }
48. Stop-Resume Behaviour public static async Task Sequential(DurableOrchestrationContext context) { var conf = await context.CallActivityAsync<ConfTicket> ("BookConference", "Codemotion Milan"); var flight = await context.CallActivityAsync<FlightTickets> ("BookFlight", conf.Dates); await context.CallActivityAsync("BookHotel", flight.Dates); }
49. Stop-Resume Behaviour public static async Task Sequential(DurableOrchestrationContext context) { var conf = await context.CallActivityAsync<ConfTicket> ("BookConference", "Codemotion Milan"); var flight = await context.CallActivityAsync<FlightTickets> ("BookFlight", conf.Dates); await context.CallActivityAsync("BookHotel", flight.Dates); }
50. Sub- Orchestrators Parent Orchest- rator Sub- Orchestrator Sub- Orchestrator
51. Sub-orchestrators public static async Task SuperOrchestrator( DurableOrchestrationContext context) { await context.CallSubOrchestratorAsync ("BookTrip", codeMotionMilan); await context.CallSubOrchestratorAsync ("BookTrip", codeMotionMadrid); }
52. Error Handling & Retries
53. Error Handling Plan Trip to Codemotion Book Conf. Book Flight Book Hotel
54. Error Handling public static async Task ErrorHandling(DurableOrchestrationContext context) { await context.CallActivityAsync("BookConference", "Codemotion Milan"); try { var itinerary = MakeItinerary(...); await context.CallActivityAsync("BookFlight", itinerary); } catch (FunctionFailedException) { var alternativeItinerary = MakeAnotherItinerary(...); await context.CallActivityAsync("BookFlight", alternativeItinerary); } await context.CallActivityAsync("BookHotel", stay); }
55. Error Handling public static async Task ErrorHandling(DurableOrchestrationContext context) { await context.CallActivityAsync("BookConference", "Codemotion Milan"); try { var itinerary = MakeItinerary(...); await context.CallActivityAsync("BookFlight", itinerary); } catch (FunctionFailedException) { var alternativeItinerary = MakeAnotherItinerary(...); await context.CallActivityAsync("BookFlight", alternativeItinerary); } await context.CallActivityAsync("BookHotel", stay); }
56. Stateful Retries Plan Trip to Codemotion Book Conf. Book Flight Book Hotel
57. Retries public static async Task Retries(DurableOrchestrationContext context) { await context.CallActivityAsync("BookConference", "Codemotion Milan"); var options = new RetryOptions( firstRetryInterval: TimeSpan.FromMinutes(1), maxNumberOfAttempts: 3); options.BackoffCoefficient = 2.0; await context.CallActivityWithRetryAsync("BookFlight", options, itinerary); await context.CallActivityAsync<string>("BookHotel", stay); }
58. Working in Parallel
59. Parallel Calls (Fan-in) Plan Conf. Tour Plan Milan Report Expenses Plan Madrid
60. Fan-out and Fan-in (1) public static async Task Parallel(DurableOrchestrationContext cxt) { var milan = cxt.CallSubOrchestratorAsync ("BookTrip", codeMotionMilan); var madrid = cxt.CallSubOrchestratorAsync ("BookTrip", codeMotionMadrid); var expenses = await Task.WhenAll(milan, madrid); await cxt.CallActivityAsync("ReportExpenses", expenses); }
61. Fan-out and Fan-in (1) public static async Task Parallel(DurableOrchestrationContext cxt) { var milan = cxt.CallSubOrchestratorAsync ("BookTrip", codeMotionMilan); var madrid = cxt.CallSubOrchestratorAsync ("BookTrip", codeMotionMadrid); var expenses = await Task.WhenAll(milan, madrid); await cxt.CallActivityAsync("ReportExpenses", expenses); }
62. Fan-out and Fan-in (1) public static async Task Parallel(DurableOrchestrationContext cxt) { var milan = cxt.CallSubOrchestratorAsync ("BookTrip", codeMotionMilan); var madrid = cxt.CallSubOrchestratorAsync ("BookTrip", codeMotionMadrid); var expenses = await Task.WhenAll(milan, madrid); await cxt.CallActivityAsync("ReportExpenses", expenses); }
63. Fan-out and Fan-in (2) public static async Task Parallel(DurableOrchestrationContext cxt) { var emailSendingTasks = recepients .Select(to => context.CallActivityAsync<bool>("SendEmail", to)) .ToArray(); var results = await Task.WhenAll(emailSendingTasks); if (results.All(r => r)) { /*...*/ } }
64. Schedules, Timeouts, External Events
65. Timers & Waiting for External Event Report Expenses At Schedule E-mail Result or Timeout Human Approves Timeout
66. Timers & Waiting for External Event // Schedule an e-mail with link to approve/reject var sendAt = context.CurrentUtcDateTime.Add(OneDay); await context.CreateTimer(sendAt); await context.CallActivityAsync("SendEmail", approvalEmail); // Wait for result with timeout var activityTask = context.WaitForExternalEvent<bool>("Approval"); var timeoutTask = context.CreateTimer(deadline); var winner = await Task.WhenAny(activityTask, timeoutTask); // Determine the outcome return winner == activityTask && activityTask.Result;
67. Timers & Waiting for External Event // Schedule an e-mail with link to approve/reject var sendAt = context.CurrentUtcDateTime.Add(OneDay); await context.CreateTimer(sendAt); await context.CallActivityAsync("SendEmail", approvalEmail); // Wait for result with timeout var activityTask = context.WaitForExternalEvent<bool>("Approval"); var timeoutTask = context.CreateTimer(deadline); var winner = await Task.WhenAny(activityTask, timeoutTask); // Determine the outcome return winner == activityTask && activityTask.Result;
68. Timers & Waiting for External Event // Schedule an e-mail with link to approve/reject var sendAt = context.CurrentUtcDateTime.Add(OneDay); await context.CreateTimer(sendAt); await context.CallActivityAsync("SendEmail", approvalEmail); // Wait for result with timeout var activityTask = context.WaitForExternalEvent<bool>("Approval"); var timeoutTask = context.CreateTimer(deadline); var winner = await Task.WhenAny(activityTask, timeoutTask); // Determine the outcome return winner == activityTask && activityTask.Result;
69. Conclusions
70. SERVICEFUL SERVERLESS Less Code Pay-as-you-Go
71. SERVERLESS IS EARLY DAYS Higher-level Architecture Patterns Will Emerge
72. AZURE DURABLE FUNCTIONS Bring the Clarity of RPC Style to Event-Driven Apps
73. AZURE DURABLE FUNCTIONS Try It, Learn It, Help Improve It
74. @MikhailShilkov https://mikhail.io