Paco de la Cruz gave a presentation on Durable Functions 2.0 and stateful serverless functions. The presentation covered an overview of serverless computing on Azure, a recap of Azure Functions and an introduction to Durable Functions. It discussed new features in Durable Functions 2.0 including Durable Entities, additional function types and patterns. The presentation also provided demonstrations of common Durable Functions patterns and a stateful serverless request bin application. It concluded with a Q&A section.
This document provides an overview of Durable Functions, which allow for implementing stateful workflows in Azure Functions. Durable Functions enable writing stateful workflows as code by using orchestrator functions to coordinate asynchronous activity functions. Key components include orchestrator functions that call and coordinate stateless activity functions, and an orchestration client to start and manage orchestrations. Patterns demonstrated include function chaining, fan-out/fan-in, and using an orchestration client to start and monitor orchestrations.
This document summarizes Paco de la Cruz's presentation on Azure Durable Functions. The presentation covered the evolution of application platforms from on-premises to serverless. It then discussed Azure Functions and some challenges it faces with stateful orchestrations. Durable Functions were introduced as an extension of Azure Functions that uses a Durable Task Framework to implement stateful workflows in a serverless manner. Key patterns demonstrated include function chaining, fan-out/fan-in, and using an orchestration client to start and monitor orchestrations. Code samples and demos were provided to illustrate approval workflows using Durable Functions.
There are several techniques for distributing information and responding to changes in mobile apps:
1. Delegation creates a formal protocol for type-to-type communication, avoiding tight coupling.
2. Closures provide decoupled communication through callbacks but require care regarding code locality and retain cycles.
3. Notifications broadcast information to any subscriber but lack a defined interface and can cause crashes if not cleaned up.
4. Property observers and bindings like Bond propagate changes implicitly within objects and between objects, respectively, but their communication is less explicit than other patterns.
This document provides examples and documentation on Azure Durable Functions patterns and concepts. It includes examples of orchestrator and activity functions, orchestration triggers, and common patterns like function chaining, fan-out/fan-in, and asynchronous HTTP responses. It also covers durable function concepts such as the control queue, work item queue, and history table.
Serverless APIs, the Good, the Bad and the Ugly (2019-09-19)Paco de la Cruz
This document outlines Paco de la Cruz's presentation on serverless APIs. The presentation covers an introduction to serverless computing and functions as a service (FaaS), major serverless platforms like AWS Lambda, Azure Functions, and Google Cloud Functions, use cases for serverless, benefits and downsides, strategies for mitigating cold starts, and demos of building serverless applications on Azure Functions.
Angular 4 and Firebase provide an easy way to build full-stack web applications. Firebase handles data modeling, hosting, authentication, notifications and other services. AngularFire2 allows binding Angular applications to Firebase's realtime database and services. The document outlines how to set up an Angular application with Firebase, including initializing AngularFire2, retrieving and saving data to Firebase, user authentication, and push notifications. Firebase's no-server architecture removes the need to manage backend infrastructure.
Parse is a suite of cloud based APIs, services and libraries that focus on letting developers build out rich applications and less time dealing with the overhead of setting up and managing databases, push notifications, social sign on, analytics, and even hosting and servers.
In this series I'll overview the options around developing an application that leverages Parse, including using Cloud Code to deploy your Node.js app to Parse's own hosting service.
Paco de la Cruz gave a presentation on Durable Functions 2.0 and stateful serverless functions. The presentation covered an overview of serverless computing on Azure, a recap of Azure Functions and an introduction to Durable Functions. It discussed new features in Durable Functions 2.0 including Durable Entities, additional function types and patterns. The presentation also provided demonstrations of common Durable Functions patterns and a stateful serverless request bin application. It concluded with a Q&A section.
This document provides an overview of Durable Functions, which allow for implementing stateful workflows in Azure Functions. Durable Functions enable writing stateful workflows as code by using orchestrator functions to coordinate asynchronous activity functions. Key components include orchestrator functions that call and coordinate stateless activity functions, and an orchestration client to start and manage orchestrations. Patterns demonstrated include function chaining, fan-out/fan-in, and using an orchestration client to start and monitor orchestrations.
This document summarizes Paco de la Cruz's presentation on Azure Durable Functions. The presentation covered the evolution of application platforms from on-premises to serverless. It then discussed Azure Functions and some challenges it faces with stateful orchestrations. Durable Functions were introduced as an extension of Azure Functions that uses a Durable Task Framework to implement stateful workflows in a serverless manner. Key patterns demonstrated include function chaining, fan-out/fan-in, and using an orchestration client to start and monitor orchestrations. Code samples and demos were provided to illustrate approval workflows using Durable Functions.
There are several techniques for distributing information and responding to changes in mobile apps:
1. Delegation creates a formal protocol for type-to-type communication, avoiding tight coupling.
2. Closures provide decoupled communication through callbacks but require care regarding code locality and retain cycles.
3. Notifications broadcast information to any subscriber but lack a defined interface and can cause crashes if not cleaned up.
4. Property observers and bindings like Bond propagate changes implicitly within objects and between objects, respectively, but their communication is less explicit than other patterns.
This document provides examples and documentation on Azure Durable Functions patterns and concepts. It includes examples of orchestrator and activity functions, orchestration triggers, and common patterns like function chaining, fan-out/fan-in, and asynchronous HTTP responses. It also covers durable function concepts such as the control queue, work item queue, and history table.
Serverless APIs, the Good, the Bad and the Ugly (2019-09-19)Paco de la Cruz
This document outlines Paco de la Cruz's presentation on serverless APIs. The presentation covers an introduction to serverless computing and functions as a service (FaaS), major serverless platforms like AWS Lambda, Azure Functions, and Google Cloud Functions, use cases for serverless, benefits and downsides, strategies for mitigating cold starts, and demos of building serverless applications on Azure Functions.
Angular 4 and Firebase provide an easy way to build full-stack web applications. Firebase handles data modeling, hosting, authentication, notifications and other services. AngularFire2 allows binding Angular applications to Firebase's realtime database and services. The document outlines how to set up an Angular application with Firebase, including initializing AngularFire2, retrieving and saving data to Firebase, user authentication, and push notifications. Firebase's no-server architecture removes the need to manage backend infrastructure.
Parse is a suite of cloud based APIs, services and libraries that focus on letting developers build out rich applications and less time dealing with the overhead of setting up and managing databases, push notifications, social sign on, analytics, and even hosting and servers.
In this series I'll overview the options around developing an application that leverages Parse, including using Cloud Code to deploy your Node.js app to Parse's own hosting service.
The document provides examples for managing context information using the Orion Context Broker, including creating entities and attributes, updating attribute values, and querying for context data. Key operations demonstrated include updateContext to create and update entities, and queryContext to retrieve entity attributes. Examples show creating Car and Room entities with speed/temperature attributes and updating their values.
Parse London Meetup - Cloud Code Tips & TricksHector Ramos
The document provides an overview of Cloud Code in Parse and discusses several tips and tricks for using Cloud Code. Some key points include:
- Cloud Code allows running JavaScript code on Parse's servers to perform actions like validating data, running background jobs, and sending push notifications.
- Functions like beforeSave and afterSave hooks allow running code anytime an object is saved to validate data, clean values, and perform other actions.
- Background jobs can run long-running processes on a scheduled basis, like cleaning up business name values over time.
- Push notifications can be sent from afterSave to keep client apps updated in real-time, such as notifying users of new comments.
Firebase and ng2
This document discusses Firebase and AngularFire/AngularFire2. It summarizes that Firebase is a backend as a service that provides realtime database functionality. AngularFire/AngularFire2 are wrappers that make the Firebase API accessible to Angular applications. Key features covered include authentication, authorization, data validation, and working with data through observable references and promises. Best practices like shallow data structures and avoiding deep nesting are also highlighted.
«От экспериментов с инфраструктурой до внедрения в продакшен»FDConf
The document discusses testing and development environments and tools. It covers topics like unit testing frameworks, test runners, dependency management with package managers, bundling code with webpack, and using tasks runners like Gulp. It provides examples of using these tools like writing unit tests with Jasmine/Mocha, configuring webpack, and defining Gulp tasks.
The document provides an overview of controllers (handlers) in the Model-View-Controller (MVC) design pattern as used in Coldbox applications. It discusses how handlers control application flow and call business logic. It describes handler anatomy, including public action methods, composed properties, and feature properties. It also explains how to get/set request values, set views and layouts, relocate to other events, render data, integrate models, and perform validation in handlers.
Reactive programming with Rx-Java allows building responsive systems that can handle varying workloads and failures. It promotes asynchronous and non-blocking code using observable sequences and operators. Rx-Java was created at Netflix to address issues like network chattiness and callback hell in their API. It transforms callback-based code into declarative pipelines. Key concepts are Observables that emit notifications, Operators that transform Observables, and Subscribers that receive emitted items. Rx-Java gained popularity due to its support for concurrency, error handling, and composability.
This document discusses diagnosing issues in cloud applications hosted on Microsoft Azure. It covers the types of diagnostic data that can be monitored on Azure, including performance counters, logs, and event logs. It provides guidance on using the Azure Diagnostics agent to configure which diagnostic data is collected and transferred to storage. Both imperative and declarative configuration methods are demonstrated. Real-world troubleshooting steps and examples are also presented.
Unit Testing Express and Koa Middleware in ES2015Morris Singer
Even for JavaScript software developers well-versed in Agile practices, using test-driven development in the development of Node.js-based webservers can be challenging. In this presentation, I identify solutions to some of the most significant challenges to using TDD to build middleware stacks, with a focus on Express and Koa.
Template forms allow creating forms directly in the template using directives like ngModel. Reactive forms use FormBuilder to build forms programmatically and attach validators and value changes. Both approaches allow collecting and validating user input, and associating forms with models. Forms are a key part of many applications for user input and data collection.
OpenStack Horizon: Controlling the Cloud using DjangoDavid Lapsley
OpenStack is an open source cloud computing project that is implemented predominantly in Python. OpenStack’s goal is to provide the "ubiquitous open source cloud computing platform for public and private clouds”. The OpenStack project was launched by Rackspace and NASA in July 2010. Since then the project has gained considerable momentum with over 200 companies joining the project, and the launch of commercial services and products that use OpenStack.
The OpenStack Horizon project provides a web-based User Interface to OpenStack services. It is constructed in two parts: (1) a core set of libraries for implementing a Dashboard; (2) a reference dashboard implementation that uses the core set of libraries. Customization is a core part of the Horizon Framework. The framework enables developers to construct their own dashboards, panel groups and panels, and enables them to assemble them together via a common navigation/presentation framework.
In this presentation, we will provide a brief introduction to OpenStack and Horizon. Then we will dive into the details of Horizon. We will review Horizon’s overall architecture and how it integrates with other OpenStack services. We will look at some of Horizon’s interesting features and describe how to get started developing with Horizon. Finally, we will discuss some of the current challenges facing Horizon and some future directions.
This document discusses new features in NGRX version 7, including breaking changes to ofType and selectors, new testing utilities like ProvideMockStore, and the introduction of meta reducers. Meta reducers allow preprocessing actions before normal reducers and act as middleware between actions and reducers. The document demonstrates building a meta reducer that syncs the store state with localStorage so the store rehydrates on app restart with the latest data from localStorage.
Alexey Buzdin "Maslow's Pyramid of Android Testing"IT Event
You all know what tests are. You all know you need to write them. But also you know it’s hard to start writing tests for mobile app thus you usually neglect it. Let’s look into Android automation testing, what technologies and approaches we can use to have a complete Maslow's Pyramid for testing. Unit Testing, Integration Testing, UI Automation, Mocking etc.
Typescript fundamentals document summarized in 3 sentences:
The document discusses Typescript fundamentals including types, classes, interfaces, modules and how to use the Typescript compiler. It explains how Typescript adds type safety and compile time checking to JavaScript by using types for variables, parameters, returns and more. Examples are provided for many Typescript features and how they compile down to equivalent JavaScript.
Backbone.js gives structure to web applications by providing models with key-value binding and custom events, collections with a rich API of functions, views with declarative event handling, and connects it all to your existing API over a RESTful JSON interface.
Kogito: cloud native business automationMario Fusco
The document discusses business automation in the cloud using Kogito. It begins with an introduction to business automation concepts like processes, rules, and workflows. It then provides an overview of Kogito, describing it as a cloud-native development, deployment and execution platform for business automation that uses technologies like Drools, jBPM, and Quarkus under the hood. The document also demonstrates a sample serverless workflow built with Kogito.
This document provides an introduction to Retrofit and RxJava. It discusses:
1. How Retrofit turns REST APIs into Java interfaces and handles JSON conversion.
2. What RxJava is and how it allows for composing asynchronous and event-based programs using observable sequences.
3. Examples of making HTTP requests with Retrofit, including defining services, making synchronous and asynchronous requests, and using callbacks and RxJava.
4. Key RxJava concepts like Observables, operators like map, flatMap, and zip, and threading.
1. The document discusses asynchrony and the Monix library for Scala. It introduces the concept of asynchronous computations using the type Async and describes how Monix implements asynchronous tasks using the Task type. It shows examples of composing Task values to run asynchronous operations sequentially or in parallel.
Amazon has been using and building workflow services for years now. They use Simple Workflow (SWF) internally to lay down OS and all required software onto a new Amazon server before it joins Amazon fleet. Every Amazon server being put in service is provisioned in a workflow using SWF.
During this brown-bag session you will be taken through the example of real application which uses SWF.
This document provides an overview of the Spray toolkit for building REST/HTTP services in Scala. It discusses what Spray is, why we use it, Spray application architecture including the Spray-can HTTP server and Spray routing. It also covers topics like directives, parameters, marshalling, unmarshalling and testing Spray applications using the Spray test kit.
El camino a las Cloud Native Apps - IntroductionPlain Concepts
The document discusses serverless computing and Azure Functions. It provides examples of how to model common patterns like function chaining, fan-out/fan-in, and human interaction with timeouts using Durable Functions. Durable Functions allow writing long-running orchestrations as single functions and handling state management automatically. This simplifies complex workflows that would otherwise require managing state across many functions.
Get to know the two stateful programming models of Azure Serverless compute: workflows and actors and how these models can simplify development and how they enable stateful and long-running application patterns within Azure’s compute environments.
The document provides examples for managing context information using the Orion Context Broker, including creating entities and attributes, updating attribute values, and querying for context data. Key operations demonstrated include updateContext to create and update entities, and queryContext to retrieve entity attributes. Examples show creating Car and Room entities with speed/temperature attributes and updating their values.
Parse London Meetup - Cloud Code Tips & TricksHector Ramos
The document provides an overview of Cloud Code in Parse and discusses several tips and tricks for using Cloud Code. Some key points include:
- Cloud Code allows running JavaScript code on Parse's servers to perform actions like validating data, running background jobs, and sending push notifications.
- Functions like beforeSave and afterSave hooks allow running code anytime an object is saved to validate data, clean values, and perform other actions.
- Background jobs can run long-running processes on a scheduled basis, like cleaning up business name values over time.
- Push notifications can be sent from afterSave to keep client apps updated in real-time, such as notifying users of new comments.
Firebase and ng2
This document discusses Firebase and AngularFire/AngularFire2. It summarizes that Firebase is a backend as a service that provides realtime database functionality. AngularFire/AngularFire2 are wrappers that make the Firebase API accessible to Angular applications. Key features covered include authentication, authorization, data validation, and working with data through observable references and promises. Best practices like shallow data structures and avoiding deep nesting are also highlighted.
«От экспериментов с инфраструктурой до внедрения в продакшен»FDConf
The document discusses testing and development environments and tools. It covers topics like unit testing frameworks, test runners, dependency management with package managers, bundling code with webpack, and using tasks runners like Gulp. It provides examples of using these tools like writing unit tests with Jasmine/Mocha, configuring webpack, and defining Gulp tasks.
The document provides an overview of controllers (handlers) in the Model-View-Controller (MVC) design pattern as used in Coldbox applications. It discusses how handlers control application flow and call business logic. It describes handler anatomy, including public action methods, composed properties, and feature properties. It also explains how to get/set request values, set views and layouts, relocate to other events, render data, integrate models, and perform validation in handlers.
Reactive programming with Rx-Java allows building responsive systems that can handle varying workloads and failures. It promotes asynchronous and non-blocking code using observable sequences and operators. Rx-Java was created at Netflix to address issues like network chattiness and callback hell in their API. It transforms callback-based code into declarative pipelines. Key concepts are Observables that emit notifications, Operators that transform Observables, and Subscribers that receive emitted items. Rx-Java gained popularity due to its support for concurrency, error handling, and composability.
This document discusses diagnosing issues in cloud applications hosted on Microsoft Azure. It covers the types of diagnostic data that can be monitored on Azure, including performance counters, logs, and event logs. It provides guidance on using the Azure Diagnostics agent to configure which diagnostic data is collected and transferred to storage. Both imperative and declarative configuration methods are demonstrated. Real-world troubleshooting steps and examples are also presented.
Unit Testing Express and Koa Middleware in ES2015Morris Singer
Even for JavaScript software developers well-versed in Agile practices, using test-driven development in the development of Node.js-based webservers can be challenging. In this presentation, I identify solutions to some of the most significant challenges to using TDD to build middleware stacks, with a focus on Express and Koa.
Template forms allow creating forms directly in the template using directives like ngModel. Reactive forms use FormBuilder to build forms programmatically and attach validators and value changes. Both approaches allow collecting and validating user input, and associating forms with models. Forms are a key part of many applications for user input and data collection.
OpenStack Horizon: Controlling the Cloud using DjangoDavid Lapsley
OpenStack is an open source cloud computing project that is implemented predominantly in Python. OpenStack’s goal is to provide the "ubiquitous open source cloud computing platform for public and private clouds”. The OpenStack project was launched by Rackspace and NASA in July 2010. Since then the project has gained considerable momentum with over 200 companies joining the project, and the launch of commercial services and products that use OpenStack.
The OpenStack Horizon project provides a web-based User Interface to OpenStack services. It is constructed in two parts: (1) a core set of libraries for implementing a Dashboard; (2) a reference dashboard implementation that uses the core set of libraries. Customization is a core part of the Horizon Framework. The framework enables developers to construct their own dashboards, panel groups and panels, and enables them to assemble them together via a common navigation/presentation framework.
In this presentation, we will provide a brief introduction to OpenStack and Horizon. Then we will dive into the details of Horizon. We will review Horizon’s overall architecture and how it integrates with other OpenStack services. We will look at some of Horizon’s interesting features and describe how to get started developing with Horizon. Finally, we will discuss some of the current challenges facing Horizon and some future directions.
This document discusses new features in NGRX version 7, including breaking changes to ofType and selectors, new testing utilities like ProvideMockStore, and the introduction of meta reducers. Meta reducers allow preprocessing actions before normal reducers and act as middleware between actions and reducers. The document demonstrates building a meta reducer that syncs the store state with localStorage so the store rehydrates on app restart with the latest data from localStorage.
Alexey Buzdin "Maslow's Pyramid of Android Testing"IT Event
You all know what tests are. You all know you need to write them. But also you know it’s hard to start writing tests for mobile app thus you usually neglect it. Let’s look into Android automation testing, what technologies and approaches we can use to have a complete Maslow's Pyramid for testing. Unit Testing, Integration Testing, UI Automation, Mocking etc.
Typescript fundamentals document summarized in 3 sentences:
The document discusses Typescript fundamentals including types, classes, interfaces, modules and how to use the Typescript compiler. It explains how Typescript adds type safety and compile time checking to JavaScript by using types for variables, parameters, returns and more. Examples are provided for many Typescript features and how they compile down to equivalent JavaScript.
Backbone.js gives structure to web applications by providing models with key-value binding and custom events, collections with a rich API of functions, views with declarative event handling, and connects it all to your existing API over a RESTful JSON interface.
Kogito: cloud native business automationMario Fusco
The document discusses business automation in the cloud using Kogito. It begins with an introduction to business automation concepts like processes, rules, and workflows. It then provides an overview of Kogito, describing it as a cloud-native development, deployment and execution platform for business automation that uses technologies like Drools, jBPM, and Quarkus under the hood. The document also demonstrates a sample serverless workflow built with Kogito.
This document provides an introduction to Retrofit and RxJava. It discusses:
1. How Retrofit turns REST APIs into Java interfaces and handles JSON conversion.
2. What RxJava is and how it allows for composing asynchronous and event-based programs using observable sequences.
3. Examples of making HTTP requests with Retrofit, including defining services, making synchronous and asynchronous requests, and using callbacks and RxJava.
4. Key RxJava concepts like Observables, operators like map, flatMap, and zip, and threading.
1. The document discusses asynchrony and the Monix library for Scala. It introduces the concept of asynchronous computations using the type Async and describes how Monix implements asynchronous tasks using the Task type. It shows examples of composing Task values to run asynchronous operations sequentially or in parallel.
Amazon has been using and building workflow services for years now. They use Simple Workflow (SWF) internally to lay down OS and all required software onto a new Amazon server before it joins Amazon fleet. Every Amazon server being put in service is provisioned in a workflow using SWF.
During this brown-bag session you will be taken through the example of real application which uses SWF.
This document provides an overview of the Spray toolkit for building REST/HTTP services in Scala. It discusses what Spray is, why we use it, Spray application architecture including the Spray-can HTTP server and Spray routing. It also covers topics like directives, parameters, marshalling, unmarshalling and testing Spray applications using the Spray test kit.
El camino a las Cloud Native Apps - IntroductionPlain Concepts
The document discusses serverless computing and Azure Functions. It provides examples of how to model common patterns like function chaining, fan-out/fan-in, and human interaction with timeouts using Durable Functions. Durable Functions allow writing long-running orchestrations as single functions and handling state management automatically. This simplifies complex workflows that would otherwise require managing state across many functions.
Get to know the two stateful programming models of Azure Serverless compute: workflows and actors and how these models can simplify development and how they enable stateful and long-running application patterns within Azure’s compute environments.
Azure Functions are great for a wide range of scenarios, including working with data on a transactional or event-driven basis. In this session, we'll look at how you can interact with Azure SQL, Cosmos DB, Event Hubs, and more so you can see how you can take a lightweight but code-first approach to building APIs, integrations, ETL, and maintenance routines.
Building workflow solution with Microsoft Azure and Cloud | Integration MondayBizTalk360
This document provides an overview of workflow solutions using Microsoft Azure and cloud technologies. It discusses Power Automate, Logic Apps, and Durable Functions for automating business processes and workflows. It covers what each technology can do, pricing models, use cases, and monitoring/governance options. Key takeaways are that the technologies are not competing and to choose based on use case, and that they are mature leading options with moderate learning curves.
CQRS and Event Sourcing are popular architectural patterns that allow you to build effective event-driven micro-services.
The basic idea of these patterns is to record each event that changes the state of the domain model into the event-storage.
This approach allows you to reduce service latency for any data scale, as well as be able to restore the system without losing any data.
MongoDB is the trusted document store we turn to when we have tough data store problems to solve. For this talk we are going to go a little bit off the path and explore what other roles we can fit MongoDB into. Others have discussed how to turn MongoDB’s capped collections into a publish/subscribe server. We stretch that a little further and turn MongoDB into a full fledged broker with both publish/subscribe and queue semantics, and a the ability to mix them. We will provide code and a running demo of the queue producers and consumers. Next we will turn to coordination services: We will explore the fundamental features and show how to implement them using MongoDB as the storage engine. Again we will show the code and demo the coordination of multiple applications.
Celery is an asynchronous task queue/job queue based on distributed message passing. It allows tasks to be executed asynchronously by worker servers using a message passing protocol like AMQP. Celery can be used to process tasks in the background outside of the HTTP request/response cycle, run periodic tasks, interact with APIs, and more. It uses brokers like RabbitMQ to push tasks to workers to execute tasks in parallel. Task results are stored for retrieval. Celery provides features like task retries, task sets, periodic tasks, and Django views for interacting with tasks.
Threads, Queues, and More: Async Programming in iOSTechWell
To keep your iOS app running butter-smooth at 60 frames per second, Apple recommends doing as many tasks as possible asynchronously or “off the main thread.” Joe Keeley introduces you to some basic concepts of asynchronous programming in iOS. He discusses what threads and queues are, how they are related, and the special significance of the main queue to iOS. Look at what options are available in the iOS SDK to work asynchronously, including NSOperationQueues and Grand Central Dispatch. Take an in depth look at how to implement some common use cases for those options in Swift. Joe pays special attention to networking, one of the most common asynchronous use cases. Spend some time discussing common asynchronous programming pitfalls—and how to avoid them. Leave this session ready to try out asynchronous programming in your iOS app.
Securing your Pulsar Cluster with Vault_Chris KelloggStreamNative
Learn how to secure a Pulsar cluster with Hashicorp Vault and deploy it on Kubernetes. Vault provides a secure way to generate tokens and store sensitive data and Pulsar has a pluggable architecture for authentication, authorization and secret management. This talk will walk through how to create custom plugins for Vault, integrate them with Pulsar and then deploy a Pulsar cluster on Kubernetes.
Develop in ludicrous mode with azure serverlessLalit Kale
Today, every one of us wants to get things done fast. The fact of the matter is Serverless is a fantastic platform for doing things fast. Because, with Serverless, you really don’t have time to waste in terms of delivering your business value. Turns out you can with the right cloud services. In this talk we’ll create a microservice using Azure Functions and also get introduced to bigger picture of serverless computing.
I presented this session in Global Azure Bootcamp 2019 in Dublin. #GlobalAzure #AzureFunctions #Serverless
Security DevOps - Free pentesters' time to focus on high-hanging fruits // Ha...Christian Schneider
The document discusses integrating security testing into continuous integration pipelines, referred to as "Security DevOps". It proposes a "Security DevOps Maturity Model" with four axes: Static Depth, Dynamic Depth, Intensity, and Consolidation. For the Dynamic Depth axis, it describes different levels of integrating dynamic application security testing tools like ZAP, Arachni, BDD-Security, and Gauntlt to test public, authenticated, and backend application layers within a CI pipeline. Examples are given for configuring the tools to perform targeted scans during commits or nightly builds.
The document introduces Test Driven Development (TDD), Continuous Integration (CI), Inversion of Control (IoC), and Aspect Oriented Programming (AOP). It discusses TDD principles and tools for writing tests first before code. CI aims to integrate code changes frequently to prevent integration problems. IoC and dependency injection improve software design by reducing coupling between components. AOP allows cross-cutting concerns like logging to be coded separately from the main program logic.
This is a sharing on a seminar held together by Cathay Bank and the AWS User Group in Taiwan. In this sharing, overview of Amazon EMR and AWS Glue is offered and CDK management on those services via practical scenarios is also presented
Containerisation Hack of a Legacy Software Solution - Alex Carter - CodeMill ...CodeMill digital skills
Details
Alexandra Carter - Callcredit, Numero and Microsoft: Containerisation Hack of a Legacy Software Solution
This is the story of how we took a legacy solution and pushed it into containers on windows in just three days. This was also a great chance to work with Microsoft at the cutting edge of their work on containerisation, VSTS and Azure. Moving on from our Hackathon, we have continued adding new components, experimenting with orchestration and showcasing our work. I’ll talk you through the prep work, the 3 day hack and the subsequent work; what it means for the product roadmap, the experimentation we have done and how stakeholders are responding. Finally, we’ll look ahead to next steps.
Case study: https://microsoft.github.io/techcasestudies/devops/2017/06/16/Callcredit_DevOps.html
Alex Carter
"I have worked in IT, Marketing, Software Support and Software Delivery before moving into my current System Build (DevOps) role within Callcredit. I live and breathe DevOps and am currently focussing on anything around containerisation in Windows. A day without Metal and motor racing is a dull one."
@smileandeliver (https://twitter.com/smileandeliver)
From CodeMill digital skills meetup https://www.meetup.com/CodeMill-Digital-Skills/events/243110732/
GDG Jakarta Meetup - Streaming Analytics With Apache BeamImre Nagi
Google slide version of this slide can be accessed from: https://docs.google.com/presentation/d/1Ws73JxlVH39HiKiYuF3vW903j8wFzxPQihXz4CQ_HZM/edit?usp=sharing
Struts 2 is an open source MVC framework based on Java EE standards. It uses a request-response pipeline where interceptors pre-process and post-process requests. The core components are interceptors, actions, and results. Interceptors provide functionality like validation while actions contain application logic and results define the response. Values are stored and accessed from a value stack using OGNL.
Similar to [NDC 2019] Enterprise-Grade Serverless (20)
What to do when you have a perfect model for your software but you are constrained by an imperfect business model?
This talk explores the challenges of bringing modelling rigour to the business and strategy levels, and talking to your non-technical counterparts in the process.
Baha Majid WCA4Z IBM Z Customer Council Boston June 2024.pdfBaha Majid
IBM watsonx Code Assistant for Z, our latest Generative AI-assisted mainframe application modernization solution. Mainframe (IBM Z) application modernization is a topic that every mainframe client is addressing to various degrees today, driven largely from digital transformation. With generative AI comes the opportunity to reimagine the mainframe application modernization experience. Infusing generative AI will enable speed and trust, help de-risk, and lower total costs associated with heavy-lifting application modernization initiatives. This document provides an overview of the IBM watsonx Code Assistant for Z which uses the power of generative AI to make it easier for developers to selectively modernize COBOL business services while maintaining mainframe qualities of service.
Most important New features of Oracle 23c for DBAs and Developers. You can get more idea from my youtube channel video from https://youtu.be/XvL5WtaC20A
The Key to Digital Success_ A Comprehensive Guide to Continuous Testing Integ...kalichargn70th171
In today's business landscape, digital integration is ubiquitous, demanding swift innovation as a necessity rather than a luxury. In a fiercely competitive market with heightened customer expectations, the timely launch of flawless digital products is crucial for both acquisition and retention—any delay risks ceding market share to competitors.
Why Apache Kafka Clusters Are Like Galaxies (And Other Cosmic Kafka Quandarie...Paul Brebner
Closing talk for the Performance Engineering track at Community Over Code EU (Bratislava, Slovakia, June 5 2024) https://eu.communityovercode.org/sessions/2024/why-apache-kafka-clusters-are-like-galaxies-and-other-cosmic-kafka-quandaries-explored/ Instaclustr (now part of NetApp) manages 100s of Apache Kafka clusters of many different sizes, for a variety of use cases and customers. For the last 7 years I’ve been focused outwardly on exploring Kafka application development challenges, but recently I decided to look inward and see what I could discover about the performance, scalability and resource characteristics of the Kafka clusters themselves. Using a suite of Performance Engineering techniques, I will reveal some surprising discoveries about cosmic Kafka mysteries in our data centres, related to: cluster sizes and distribution (using Zipf’s Law), horizontal vs. vertical scalability, and predicting Kafka performance using metrics, modelling and regression techniques. These insights are relevant to Kafka developers and operators.
DECODING JAVA THREAD DUMPS: MASTER THE ART OF ANALYSISTier1 app
Are you ready to unlock the secrets hidden within Java thread dumps? Join us for a hands-on session where we'll delve into effective troubleshooting patterns to swiftly identify the root causes of production problems. Discover the right tools, techniques, and best practices while exploring *real-world case studies of major outages* in Fortune 500 enterprises. Engage in interactive lab exercises where you'll have the opportunity to troubleshoot thread dumps and uncover performance issues firsthand. Join us and become a master of Java thread dump analysis!
WWDC 2024 Keynote Review: For CocoaCoders AustinPatrick Weigel
Overview of WWDC 2024 Keynote Address.
Covers: Apple Intelligence, iOS18, macOS Sequoia, iPadOS, watchOS, visionOS, and Apple TV+.
Understandable dialogue on Apple TV+
On-device app controlling AI.
Access to ChatGPT with a guest appearance by Chief Data Thief Sam Altman!
App Locking! iPhone Mirroring! And a Calculator!!
Unveiling the Advantages of Agile Software Development.pdfbrainerhub1
Learn about Agile Software Development's advantages. Simplify your workflow to spur quicker innovation. Jump right in! We have also discussed the advantages.
Consistent toolbox talks are critical for maintaining workplace safety, as they provide regular opportunities to address specific hazards and reinforce safe practices.
These brief, focused sessions ensure that safety is a continual conversation rather than a one-time event, which helps keep safety protocols fresh in employees' minds. Studies have shown that shorter, more frequent training sessions are more effective for retention and behavior change compared to longer, infrequent sessions.
Engaging workers regularly, toolbox talks promote a culture of safety, empower employees to voice concerns, and ultimately reduce the likelihood of accidents and injuries on site.
The traditional method of conducting safety talks with paper documents and lengthy meetings is not only time-consuming but also less effective. Manual tracking of attendance and compliance is prone to errors and inconsistencies, leading to gaps in safety communication and potential non-compliance with OSHA regulations. Switching to a digital solution like Safelyio offers significant advantages.
Safelyio automates the delivery and documentation of safety talks, ensuring consistency and accessibility. The microlearning approach breaks down complex safety protocols into manageable, bite-sized pieces, making it easier for employees to absorb and retain information.
This method minimizes disruptions to work schedules, eliminates the hassle of paperwork, and ensures that all safety communications are tracked and recorded accurately. Ultimately, using a digital platform like Safelyio enhances engagement, compliance, and overall safety performance on site. https://safelyio.com/
Top Benefits of Using Salesforce Healthcare CRM for Patient Management.pdfVALiNTRY360
Salesforce Healthcare CRM, implemented by VALiNTRY360, revolutionizes patient management by enhancing patient engagement, streamlining administrative processes, and improving care coordination. Its advanced analytics, robust security, and seamless integration with telehealth services ensure that healthcare providers can deliver personalized, efficient, and secure patient care. By automating routine tasks and providing actionable insights, Salesforce Healthcare CRM enables healthcare providers to focus on delivering high-quality care, leading to better patient outcomes and higher satisfaction. VALiNTRY360's expertise ensures a tailored solution that meets the unique needs of any healthcare practice, from small clinics to large hospital systems.
For more info visit us https://valintry360.com/solutions/health-life-sciences
Mobile App Development Company In Noida | Drona InfotechDrona Infotech
Drona Infotech is a premier mobile app development company in Noida, providing cutting-edge solutions for businesses.
Visit Us For : https://www.dronainfotech.com/mobile-application-development/
The Rising Future of CPaaS in the Middle East 2024Yara Milbes
Explore "The Rising Future of CPaaS in the Middle East in 2024" with this comprehensive PPT presentation. Discover how Communication Platforms as a Service (CPaaS) is transforming communication across various sectors in the Middle East.
8 Best Automated Android App Testing Tool and Framework in 2024.pdfkalichargn70th171
Regarding mobile operating systems, two major players dominate our thoughts: Android and iPhone. With Android leading the market, software development companies are focused on delivering apps compatible with this OS. Ensuring an app's functionality across various Android devices, OS versions, and hardware specifications is critical, making Android app testing essential.
Everything You Need to Know About X-Sign: The eSign Functionality of XfilesPr...XfilesPro
Wondering how X-Sign gained popularity in a quick time span? This eSign functionality of XfilesPro DocuPrime has many advancements to offer for Salesforce users. Explore them now!
INTRODUCTION TO AI CLASSICAL THEORY TARGETED EXAMPLESanfaltahir1010
Image: Include an image that represents the concept of precision, such as a AI helix or a futuristic healthcare
setting.
Objective: Provide a foundational understanding of precision medicine and its departure from traditional
approaches
Role of theory: Discuss how genomics, the study of an organism's complete set of AI ,
plays a crucial role in precision medicine.
Customizing treatment plans: Highlight how genetic information is used to customize
treatment plans based on an individual's genetic makeup.
Examples: Provide real-world examples of successful application of AI such as genetic
therapies or targeted treatments.
Importance of molecular diagnostics: Explain the role of molecular diagnostics in identifying
molecular and genetic markers associated with diseases.
Biomarker testing: Showcase how biomarker testing aids in creating personalized treatment plans.
Content:
• Ethical issues: Examine ethical concerns related to precision medicine, such as privacy, consent, and
potential misuse of genetic information.
• Regulations and guidelines: Present examples of ethical guidelines and regulations in place to safeguard
patient rights.
• Visuals: Include images or icons representing ethical considerations.
Content:
• Ethical issues: Examine ethical concerns related to precision medicine, such as privacy, consent, and
potential misuse of genetic information.
• Regulations and guidelines: Present examples of ethical guidelines and regulations in place to safeguard
patient rights.
• Visuals: Include images or icons representing ethical considerations.
Content:
• Ethical issues: Examine ethical concerns related to precision medicine, such as privacy, consent, and
potential misuse of genetic information.
• Regulations and guidelines: Present examples of ethical guidelines and regulations in place to safeguard
patient rights.
• Visuals: Include images or icons representing ethical considerations.
Real-world case study: Present a detailed case study showcasing the success of precision
medicine in a specific medical scenario.
Patient's journey: Discuss the patient's journey, treatment plan, and outcomes.
Impact: Emphasize the transformative effect of precision medicine on the individual's
health.
Objective: Ground the presentation in a real-world example, highlighting the practical
application and success of precision medicine.
Data challenges: Address the challenges associated with managing large sets of patient data in precision
medicine.
Technological solutions: Discuss technological innovations and solutions for handling and analyzing vast
datasets.
Visuals: Include graphics representing data management challenges and technological solutions.
Objective: Acknowledge the data-related challenges in precision medicine and highlight innovative solutions.
Data challenges: Address the challenges associated with managing large sets of patient data in precision
medicine.
Technological solutions: Discuss technological innovations and solutions
A neural network is a machine learning program, or model, that makes decisions in a manner similar to the human brain, by using processes that mimic the way biological neurons work together to identify phenomena, weigh options and arrive at conclusions.
8. Function Trigger
public static class SimpleExampleWithOutput
{
[FunctionName("CopyQueueMessage")]
public static void Run(
[QueueTrigger("myqueue-items-source")] string myQueueItem,
[Queue("myqueue-items-destination")] out string myQueueItemCopy,
ILogger log)
{
// Business logic goes here.
}
}
Output Binding
{
"generatedBy": "Microsoft.NET.Sdk.Functions-1.0.0.0",
"configurationSource": "attributes",
"bindings": [
{
"type": "queueTrigger",
"queueName": "%input-queue-name%",
"name": "myQueueItem"
}
],
"disabled": false,
"scriptFile": "..binFunctionApp1.dll",
"entryPoint": "FunctionApp1.QueueTrigger.Run"
}
function.json
9. Sounds great, but I need..
automated testing
to run on-premises
custom dependencies
custom hardware
automated deploymentreal-time monitoring
sub-second latency
network isolation complex workflows
long-running processes
identity management
secure credentials storage
versioning strategy
state managementto run in a VNET
10. Agenda
• Hosting Options
• Premium
• KEDA
• Monitoring and Diagnostics
• Application Insights
• Security
• MSI and KeyVault Integration
• Deployment
• Azure DevOps
• Workflows and State
• Durable Functions and Entities
12. • Serverless scale with bigger,
configurable instances
• Up to 4 cores 12Gb of memory
• Cold start controls
• Min plan size
• Pre-Warmed instances
• VNET connectivity
• Longer run duration
• ~25 minutes
• Predictable billing
• Max plan size
19. • Secure inbound HTTP access to your App
to one subnet in a VNET
• Allow secure outbound calls to resources
in a VNET
• Dependencies that you add can be
insecure
Internet
Functions
Runtime
HTTP Front-ends
Virtual Network
(VNET)
20. Virtual Network
(VNET)
• Leaving the multi-tenant world
• Your entire app is contained within a VNET
• Organizational controls over ingress / egress
• Limited scaling speed
Internet
Functions
Runtime
HTTP Front-ends
21. Orchestrates containerized workloads and
services.
Provides a clean interface for managing
distributed systems across many nodes,
including replication, scaling, and state
management.
App App
24. When to
consider KEDA
Run functions on-premises / Intelligent edge
Run functions alongside existing Kubernetes
investments or requirements
Run functions on a different platform or
cloud
Run functions with full control and
management of scale and compute
27. Spot the vulnerability!
module.exports = function (context, payload) {
if (payload.action != "opened") {
context.done();
return;
}
var comment = { "body": "Thank you for your contribution! We will get to it shortly." };
if (payload.pull_request) {
var pr = payload.pull_request;
context.log(pr.user.login, " submitted PR#", pr.number, ": ", pr.title);
SendGitHubRequest(pr.comments_url, comment, context); // posting a comment
}
context.done();
};
function SendGitHubRequest(url, requestBody, context) {
var request = require('request');
var githubCred = 'Basic ' + 'mattchenderson:8e254ed4';
request({
url: url,
method: 'POST',
headers: {
'User-Agent': 'mattchenderson',
'Authorization': githubCred
},
json: requestBody
}, function (error, response, body) {
if (error) {
context.log(error);
} else {
context.log(response.statusCode, body);
}
});
}
28. Secrets management
const msRestAzure = require('ms-rest-azure');
const KeyVault = require('azure-keyvault');
const vaultUri = process.env['GITHUB_SECRET_URI'];
// Value looks like: 'https://foo.vault.azure.net/secrets/gh'
//... Getting the event
let kvToken = msRestAzure.loginWithAppServiceMSI({
resource: 'https://vault.azure.net'
});
let keyVaultClient = new KeyVault.KeyVaultClient(kvToken);
keyVaultClient.getSecret(vaultUri).then(function (secret){
var githubHeader = 'Basic ' + secret;
//... Call GitHub
});
29. Managed identities for Azure Functions
Keep credentials out of code
Auto-managed identity in Azure AD
for Azure resource
Use local token endpoint to get
access tokens from Azure AD
Direct authentication with services,
or retrieve creds from Azure Key
Vault
Azure Functions
Azure Service
(e.g., ARM, Key Vault)
Your code
Local token
service
Credentials
1
2
3
Azure (inject and roll credentials)
30. Gets secrets out of App Settings
and into secrets management
Leverages the managed identity
of your function app
Versions required for initial
preview (goal of auto-rotation)
@Microsoft.KeyVault(SecretUri=https://myvault.vault.azure.net/secrets/mysecret/mysecretversion)
Foo: mysecret
Foo: mysecret
Foo: mysecret
Foo: reference
Foo: mysecret
33. • GA of Functions Build task
• Easily add Functions to a CI/CD pipeline
• New streamlined CLI command
• az functionapp devops-pipeline
create
• Automatically configures DevOps to build
with new commits to your version
control
• Configures Github or Azure Repos
automatically
aka.ms/functions-azure-devops
37. // 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);
return await ctx.CallFunctionAsync("F3", y);
}
catch (Exception)
{
// global error handling/compensation goes here
}
}
Orchestrator Function
Activity Functions
38. public static async Task<object> Run(DurableOrchestrationContext context)
{
try
{
var x = await context.CallActivityAsync<object>("F1");
var y = await context.CallActivityAsync<object>("F2", x);
var z = await context.CallActivityAsync<object>("F3", y);
return await context.CallActivityAsync<object>("F4", z);
}
catch (Exception)
{
// Error handling or compensation goes here.
}
}
39. // An HTTP-triggered function starts a new orchestrator function instance.
public static async Task<HttpResponseMessage> Run(
HttpRequestMessage req,
DurableOrchestrationClient starter,
string functionName,
ILogger log)
{
// The function name comes from the request URL.
// The 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);
}
40. public static async Task Run(DurableOrchestrationContext context)
{
int jobId = context.GetInput<int>();
int pollingInterval = GetPollingInterval();
DateTime expiryTime = GetExpiryTime();
while (context.CurrentUtcDateTime < expiryTime)
{
var jobStatus = await context.CallActivityAsync<string>("GetJobStatus", jobId);
if (jobStatus == "Completed")
{
// Perform an action when a condition is met.
await context.CallActivityAsync("SendAlert", machineId);
break;
}
// Orchestration sleeps until this time.
var nextCheck = context.CurrentUtcDateTime.AddSeconds(pollingInterval);
await context.CreateTimer(nextCheck, CancellationToken.None);
}
// Perform more work here, or let the orchestration end.
}
42. “Hello MDC!”[“Hello MDC!”]
Orchestrator
Function
Activity
Function
Execution
History
var outputs = new List<string>();
outputs.Add(await context.CallActivityAsync<string>(“Hello”, “MDC”));
return outputs;
Orchestrator
Function
?
Activity
Function
“Hello MDC!”
Orchestrator Started
Execution Started
Task Scheduled, Hello, “MDC”
Orchestrator Completed
Task Completed, “Hello MDC!”
Orchestrator Started
Execution Completed, ["Hello MDC!"]
Orchestrator Completed
History Table
43. public static async Task Counter([EntityTrigger(EntityClassName = "Counter")] IDurableEntityContext ctx)
{
int currentValue = ctx.GetState<int>();
int operand = ctx.GetInput<int>();
switch (ctx.OperationName)
{
case "add":
currentValue += operand;
break;
case "subtract":
currentValue -= operand;
break;
case "reset":
await SendResetNotificationAsync();
currentValue = 0;
break;
}
ctx.SetState(currentValue);
}
44. • Entities process one operation at a time
• An entity will be automatically created if it
does not yet exist
• Operations can be non-deterministic
• Entity functions can perform external calls
(preferably with async APIs)
• Entities can invoke other entities, but only
one-way communication
Developing
entity
functions
45.
46.
47. Event-driven programming model with Kubernetes - KEDA
Dependency injection support for .NET
Extension bundles
Durable Functions stateful patterns
Streamlined Azure DevOps experience
New Serverless Library experience
Premium Functions hosting option
Support for PowerShell Core 6
https://aka.ms/FunctionsBuild2019
48. Title Speakers Code Time
Serverless web apps with Blazor, Azure Functions, and
Azure Storage
Jeff Hollan THR2003 Monday, May 6
4:30 PM - 4:50 PM
Closing the key gaps of serverless with Azure Functions Alex Karcher
Jeff Hollan
BRK3042 Tuesday, May 7
10:00 AM - 11:00 AM
6 things you need to know about serverless Colby Tresness THR3009 Tuesday, May 7
2:00 PM - 2:20 PM
Bring serverless apps to life with Azure SignalR Service Anthony Chu THR3008 Tuesday, May 7
4:00 PM - 4:20 PM
Where should I host my code? Choosing between
Kubernetes, Containers, and Serverless
Jeff Hollan THR2005 Wednesday, May 8
10:00 AM - 10:20 AM
Event-driven design patterns to enhance existing
applications using Azure Functions
Daria Grigoriu
Eduardo Laureano
BRK3041 Wednesday, May 8
2:00 PM - 3:00 PM
The good, the bad and the ugly of Serverless Burke Holland
Cecil Phillip
CFS2025 Wednesday, May 8
3:30 PM - 4:30 PM
Mixing Stateful and Serverless – workflow, orchestration,
and actors
Matthew Henderson THR3011 Wednesday, May 8
4:00 PM - 4:20 PM
Abstraction of servers, infrastructure, OS config
“Functions as a Service”
OS/framework patching
No need to manage infrastructure
Event-driven scale
Triggered by events within Azure or third-party services
React in near real time to events and triggers
Scales within seconds quickly, limitlessly*
No scale configuration required
Sub-second billing
Pay only for the time your code is running
The time it takes to ready an instance when no instance yet exists
Varies greatly on a number of factors like language and # of files
Today for C# in v1 is generally around 3-4 seconds today, 1-2 seconds in on-deck release
Few angles of attack
Pre-warmed “workers”
Zipped artifacts without extract (Zip Deploy)
Keep alive (keep warm longer)
Users can help mitigate by:
Using Zip Deploy if possible (paired with something like funcpack for Node)
Use C# Class Libraries over .csx for large functions
If push comes to shove, a “pinger” can keep warm
Function with blob full of files I want to encrypt
haven’t called it in last twenty minutes
Call premium and consumption
-- K8 is reactive: container CPU/memory
-- Fx is event-driven: ex. queue depth, Kafka stream length
-- partnered w/Red Hat
-- scale from 0-1000s of instances
-- containers consume events directly from source; no decoupling w/HTTP
-- routing through HTTP == data and context loss
-- extensible
-- Azure Functions are containerizable
-- deploy in-cloud or on-prem
-- Fx run integrated w/OpenShift [[WHAT IS THIS]]
-- adds event sources to K8s
-- we see most of our executions come from non-HTTP sources (HTTP only 30%)
-- Kafka, Azure Queues, Azure Service Bus, RabbitMQ, HTTP, and Azure Event Grid / Cloud Events. More triggers will continue to be added in the future including Azure Event Hubs, Storage, Cosmos DB, and Durable Functions.
-- runs alongside Virtual Kubelet and AKS Virtual Nodes [[ WHAT ARE THESE ]]
-- open source
-- webinar! May 28: aka.ms/keda-webinar
-- when to consider KEDA
Imagine a scenario where I have to take the output of a Function and use it as the input to call another Function. I’ll have to coordinate the chaining manually.
If I have to have a function that takes some sort of event and then parallelizes it into multiple Functions, I can still do that but how will I know when all Functions have finished executing so I can aggregate the results and move on.
What if I had to listen on multiple events and aggregate their outcome to determine which specific job or function to run in my application.
What if I wanted to do some kind of extended monitoring on an endpoint? For example, if I were to monitor the temperature of a remote machine and take action x if the temperature were lower than a certain threshold, else do y or run job y.
What if I have an API or endpoint that was running for a long time? I know Functions are short-lived but sometimes you guys put some serious load on them. Could there be a mechanism to provide status of the execution back to the client so they’re not left hanging?
And lastly, what if I wanted to get some sort of human interaction in there? For example, if I am to do some sort of 2FA in the middle of my function execution but also don’t want to wait forever because sometimes people take forever to reply especially when the texts are automated.
Today, I’m going to be talking about some of these problems – how you can approach them in regular FaaS? And how they can be simplified with the technology of Durable Functions.
In the function chaining pattern, a sequence of functions executes in a specific order. In this pattern, the output of one function is applied to the input of another function.
The async HTTP APIs pattern addresses the problem of coordinating the state of long-running operations with external clients. A common way to implement this pattern is by having an HTTP call trigger the long-running action. Then, redirect the client to a status endpoint that the client polls to learn when the operation is finished.
The monitor pattern refers to a flexible, recurring process in a workflow. An example is polling until specific conditions are met. You can use a regular timer trigger to address a basic scenario, such as a periodic cleanup job, but its interval is static and managing instance lifetimes becomes complex. You can use Durable Functions to create flexible recurrence intervals, manage task lifetimes, and create multiple monitor processes from a single orchestration.
Many automated processes involve some kind of human interaction. Involving humans in an automated process is tricky because people aren't as highly available and as responsive as cloud services. An automated process might allow for this by using timeouts and compensation logic.
Grasping how orchestrators use execution history to replay and rebuild their local state is key to understanding how Durable Functions works, so let’s walk through the execution of a simple orchestrator function.
The light blue box at the top of the slide is the orchestrator’s code.
“SayHello” our activity function, which returns “Hello” and whatever input you give it.
Our execution history is currently empty. As we start to record events, they’ll show up here. (Indicate area.)
1. A request is made to the orchestrator function.
2. The orchestrator starts and begins executing until it’s asked to await some async work. In this case, we want to call an activity function.
3. The orchestrator checks the execution history for a record of the activity function.
4. There’s no record of the activity function being called or completed, so the orchestrator schedules that work.
5. While the orchestrator waits on work to complete, it shuts down.
5. The scheduled activity function runs.
6. A record of this is added to the execution history. In this case we produced output, so that’s stored.
7. Now the orchestrator has more work to do. It restarts and executes its code **from the beginning** to build up its local state.
8. As before, the orchestrator executes until it reaches an await.
9. The orchestrator checks the execution history. This time there’s a record of the async work being done.
10. The activity function’s stored output is passed back to the orchestrator. In this case, the value is added to a list of strings.
11. The orchestrator continues executing. In a more complex orchestrator with multiple await calls, the checkpoint, schedule and replay steps would repeat for each one. This orchestrator runs to completion and returns its output.
12. And we’re done!
- How does the framework know to wake up
The sixth pattern is about aggregating event data over a period of time into a single, addressable entity. In this pattern, the data being aggregated may come from multiple sources, may be delivered in batches, or may be scattered over long-periods of time. The aggregator might need to take action on event data as it arrives, and external clients may need to query the aggregated data.