{"id":6123,"date":"2016-01-30T16:02:36","date_gmt":"2016-01-30T16:02:36","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/webdev\/2016\/01\/30\/sending-asp-net-webhooks-from-azure-webjobs\/"},"modified":"2023-09-21T11:44:37","modified_gmt":"2023-09-21T18:44:37","slug":"sending-asp-net-webhooks-from-azure-webjobs","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/sending-asp-net-webhooks-from-azure-webjobs\/","title":{"rendered":"Sending ASP.NET WebHooks from Azure WebJobs"},"content":{"rendered":"

Azure WebJobs<\/a> is a great way for running any kind of script or executable as a background process in connection with an Azure App Service Web Site or App<\/a>. You can upload an executable or script as a WebJob and run it either on a schedule or continuously. The WebJob can perform any function you can stick into a command line script or program and using the Azure WebJobs SDK, you can trigger actions to happen as a result of inputs from a number of sources<\/a>, for example:<\/p>\n

    \n
  1. A message arriving on an Azure Storage queue<\/a>; <\/li>\n
  2. An Azure Storage blob being created or updated<\/a>; <\/li>\n
  3. A message arriving on an Azure Service Bus queue<\/a>. <\/li>\n<\/ol>\n

    WebHooks provide a simple mechanism for sending event notification across web applications and external services. For example, you can receive a WebHook when someone sends money to your PayPal account, or when a message is posted to Slack, or a picture is posted to Instagram. The opportunities for integrating services using WebHooks are endless. ASP.NET WebHooks provide support for both sending and receiving WebHooks allowing your ASP.NET applications to easily integrate with other services. <\/p>\n

    If you are new to ASP.NET WebHooks, then check out the blog Introducing Microsoft ASP.NET WebHooks Preview<\/a>. For an introduction for how to use ASP.NET WebHooks for sending WebHooks, please see Sending WebHooks with ASP.NET WebHooks Preview<\/a>. For scaling up and out when sending WebHooks, please see the blog New Year Updates to ASP.NET WebHooks Preview<\/a>.<\/p>\n

    In this blog we will describe how to send ASP.NET WebHooks from inside an Azure WebJob as a result of a message arriving on an Azure Storage Queue. However, there are many more possibilities for using these two technologies together.<\/p>\n

    The functionality described in this blog is available in the Microsoft ASP.NET WebHooks Nuget packages version 1.2.0-beta6a<\/a> \u2013 remember to set the preview flag when looking for them in Visual Studio.<\/p>\n

    Sending WebHooks from Web Server<\/h3>\n

    As described in the blog Sending WebHooks with ASP.NET WebHooks Preview<\/a>, the basic model for sending WebHooks works as illustrated in this diagram:<\/p>\n

    \"WebHooksSender\"<\/a><\/p>\n

    Here we have a regular Web site (for example deployed in Azure) with support for registering WebHooks. WebHooks are triggered as a result of incoming HTTP requests, typically through an MVC controller or a WebAPI controller. The orange blocks are the core abstractions provided by ASP.NET WebHooks:<\/p>\n

      \n
    1. IWebHookStore<\/a>: An abstraction for storing WebHook registrations persistently. Out of the box we provide support for Azure Table Storage<\/a> and SQL<\/a> but the list is open-ended. <\/li>\n
    2. IWebHookManager<\/a>: An abstraction for determining which WebHooks should be sent as a result of an event notification being generated. The manager can match event notifications with registered WebHooks as well as applying filters. <\/li>\n
    3. IWebHookSender<\/a>: An abstraction for sending WebHooks determining the retry policy and error handling as well as the actual shape of the WebHook HTTP requests. Out of the box we provide support for immediate transmission of WebHooks as well as a queuing model which can be used for scaling up and out, see the blog New Year Updates to ASP.NET WebHooks Preview<\/a> for details. <\/li>\n<\/ol>\n

      The registration process can happen through any number of mechanisms as well. Out of the box we support registering WebHooks through a REST API but you can also build registration support as an MVC controller or anything else you like.<\/p>\n

      Sending WebHooks From WebJobs<\/h3>\n

      The WebHook abstractions for the WebJob are the same as for the Web site allowing you to manage and send WebHooks in an identical manner. The difference is that you can now send WebHooks not just as a result of incoming HTTP requests but also as a result of messages being sent on a queue, a blob being created, or anything else that can trigger a WebJob:<\/p>\n

      \"WebHooksWebJobsSender\"<\/a><\/p>\n

      Creating an Azure WebJob<\/h3>\n

      In the blog New Developer and Debugging Features for Azure WebJobs in Visual Studio<\/a>, you will find a great overview of how to create an Azure WebJob using Visual Studio. This can be used to set up a Command Line project including the Microsoft.Azure.WebJobs Nuget package<\/a>. Alternatively you can see this sample project<\/a> which contains the code below:<\/p>\n

      The project contains three pieces:<\/p>\n

        \n
      1. An App.config file where we configure the WebJob; <\/li>\n
      2. The usual Program static class with a Main entry method to the application; <\/li>\n
      3. A Function class where we will add a method to be invoked when a message arrives on a given Azure Storage Queue. <\/li>\n<\/ol>\n

        To configure the WebJob, we set three connection strings in the App.config file:<\/p>\n

        \n
        <<\/span>connectionStrings<\/span>><\/span>
          <<\/span>add<\/span> name<\/span>="AzureWebJobsDashboard"<\/span> connectionString<\/span>="DefaultEndpointsProtocol=https;\u2026"<\/span> \/><\/span>
          <<\/span>add<\/span> name<\/span>="WebHookListener"<\/span> connectionString<\/span>="DefaultEndpointsProtocol=https;\u2026"<\/span> \/><\/span>
          <<\/span>add<\/span> name<\/span>="MS_AzureStoreConnectionString"<\/span> connectionString<\/span>="UseDevelopmentStorage=true;"<\/span> \/><\/span>
        <\/<\/span>connectionStrings<\/span>><\/span>
        <\/pre>\n
        <\/div>\n
        The first two must be pointing to an actual Azure Storage Account, not the local storage emulator. If you don\u2019t already have an Azure Storage Account, then create one through the Azure Portal<\/a>. Once created you can find the connection string under the Settings\/Keys<\/strong> menu for the Azure Storage Account in the portal:<\/div>\n
         <\/div>\n
        \"AzureStorageConnectionString\"<\/a><\/div>\n
         <\/div>\n
        The AzureWebJobsDashboard<\/strong> connection string is used by WebJobs to communicate with the WebJobs Dashboard where you can see what the WebJob is doing. You can find the link to the dashboard in the Azure Portal<\/a> once you have deployed the WebJob. <\/div>\n
         <\/div>\n
        The WebHookListener<\/strong> connection string is where the WebJob will listen for trigger messages. This also must be an actual Azure Storage Account but it can be the same as for the dashboard.<\/div>\n
         <\/div>\n
        The MS_AzureStoreConnectionString<\/strong> connection string is where WebHook registrations are stored \u2013 this can just be the local storage emulator as indicated above.<\/div>\n
         <\/div>\n
        The Main<\/strong> method is used to initialize the WebJob and the WebHookManager so that we can send WebHooks from the WebJob:<\/div>\n
         <\/div>\n
        \n
        internal<\/span> class<\/span> Program
        {
            \/\/\/ <summary><\/span>
            \/\/\/ Gets or sets the <see cref="IWebHookManager"\/> instance to use.<\/span>
            \/\/\/ <\/summary><\/span>
            public<\/span> static<\/span> IWebHookManager Manager { get; set; }
         
            public<\/span> static<\/span> void<\/span> Main(string<\/span>[] args)
            {
                \/\/ Set up default WebHook logger<\/span>
                ILogger logger = new<\/span> TraceLogger();
         
                \/\/ Set the WebHook Store we want to get WebHook subscriptions from. Azure store requires<\/span>
                \/\/ a valid Azure Storage connection string named MS_AzureStoreConnectionString.<\/span>
                IWebHookStore store = AzureWebHookStore.CreateStore(logger);
         
                \/\/ Set the sender we want to actually send out the WebHooks. We could also <\/span>
                \/\/ enqueue messages for scale out.<\/span>
                IWebHookSender sender = new<\/span> DataflowWebHookSender(logger);
         
                \/\/ Set up WebHook manager which we use for creating notifications.<\/span>
                Manager = new<\/span> WebHookManager(store, sender, logger);
         
                \/\/ Initialize WebJob<\/span>
                var listener = ConfigurationManager.ConnectionStrings["WebHookListener"<\/span>].ConnectionString;
                JobHostConfiguration config = new<\/span> JobHostConfiguration
                {
                    StorageConnectionString = listener
                };
                JobHost host = new<\/span> JobHost(config);
                host.RunAndBlock();
            }
        }
        <\/pre>\n
        <\/div>\n
        To facilitate running WebJobs in development mode, you can enable the JobHostConfiguration.UseDevelopmentSettings<\/strong> flag which sets polling frequency and other properties. For more information about running WebJobs in development mode, please see the documentation on Development Settings<\/a>.<\/div>\n
         <\/div>\n
        Last step is to define a method that is triggered when a message arrives on the listener<\/strong> queue on the WebHookListener<\/strong> connection string:<\/div>\n
         <\/div>\n
        \n
        public<\/span> class<\/span> Functions
        {
            \/\/\/ <summary><\/span>
            \/\/\/ This method is triggered when a message arrives on the 'listener' queue on the<\/span>
            \/\/\/ the 'WebHookListener' Azure Storage Account. <\/span>
            \/\/\/ <\/summary><\/span>
            public<\/span> static<\/span> async Task ProcessAsync([QueueTrigger("listener"<\/span>)] string<\/span> message, TextWriter logger)
            {
                await logger.WriteLineAsync(message);
         
                \/\/ Send message to all subscribers as WebHooks. Use a predicate to filter<\/span>
                \/\/ which receivers should get a WebHook request.<\/span>
                await Program.Manager.NotifyAllAsync("event1"<\/span>, new<\/span> { Message = message });
            }
        }<\/pre>\n
        <\/div>\n
        Trying It Out<\/h3>\n
        As there are several moving parts in getting this up and running, we will focus on the already existing sample code that you can find in the Microsoft ASP.NET WebHooks GitHub repository<\/a>:<\/p>\n