Setting up custom Claims for an API registered in Azure AD

One way to further reduce the surface area attack on an API when using the Client Credential OAuth flow is to pass claims in the token. This adds another layer of security and provides more granular control over your API. By adding custom claims within the token, the API can inspect these and restrict what operations the client may perform within the API service. This may be just to limit basic crud type operations or some other type of grant requirement. More information about optional claims can be found here: https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-optional-claims

Just to recall, Client Credentials flow is normally Client-to-Service requests and has no users involved in the flow. A Service Principal (SP) object is associated with the Client App when making calls to a backend service API. The value of this Id can be found under AAD Enterprise Applications and is the ObjectId of the application name. To ensure the SP used to call your API is the one you are expecting, use the oid or sub claims to validate the SP as another security check.

Also the Client Credentials flow is meant to be used with confidential clients. These are clients that are running on the server as opposed to those running on user devices (which are often referred to as ‘public clients’) as they are able to store the secret securely. Confidential clients provide their client ID and client secret in the requests for access tokens.

Scenario

A typical scenario is where a Client App needs to call a backend API Service. Here the Client App is a CRM Website which is calling a CRM Service which is the backend API Service to either get a users profile or update their details using the Client Credentials flow. Also to limit operational functionality, two roles will be sent with the bearer token to allow only reading or updating the CRM contact information.

In this article I will go through the process of adding a list of Application claims to an App registered as an API service (CRM Service) in Azure Active Directory (AAD). Another App registration is also required for the client (CRM Website) which has a set of restricted claims. These restricted claims will be inserted into the Access token where the API service (CRM Service) would interrogate the claims and perform the required operations if the claims are valid.

Configuration Walkthrough

Below are the steps required to create an AAD App Registration for the CRM Service API and to add the required application claims (roles). The claims are added by modifying the manifest file after the App has been registered as there is no UI available to manage this.

Registering the Service API

1. Register the CRM Service API – Under the Azure Active Directory page, click on App registrations and New registration

2. Add a name (CRM Service) for the application and then click the Register button at the bottom of the page.

3. Adding Claims – Once the App registration has been saved, click on the Manifest menu option to view and update the manifest appRoles via the portal.

Now we can add a of collection of custom roles under the “appRoles” attribute using the following JSON structure for the claims. This is where you define the complete list of custom roles that your API service will support. The claims I will be adding for the CRM service are basic crud type operations. Note the value for the id for each role is just a Guid to keep it unique within the tenant.

Remember to click the Save button to on the top to update the manifest.

4. Set Application ID URL – Under the Expose an API menu option, click the Set for Application ID URI. This value will be used as the Scope parameter when requesting an OAuth token for the Client App. You can also view this value from the app registration Overview page.

That is all required to register the API Service and to add custom application claims. Next is registering the client.

Registering the Client App

1. Create a new App registration as before, but for the client (CRM Website)

2. Add the required permissions – This section is where you define the roles required for the client app. To add the permissions, click on API Permissions and then Add a permission.

Then click on My API’s on the top menu to list all your registered apps. Select the CRM Service app which was added in the first section to which you want access to.

Select Application permissions and then expand the permissions. This will list all the available roles available that was added when registering the CRM Service API. For the CRM Website, I only require the read and update roles. Once checked, then click on the Add permissions button.

Once the permissions have been added, Click on Grant admin consent for the cloud and then press Yes on the dialogue box.

The status of the permissions should then be all green as highlighted below.

5. Add a client secret – Click on the Certificates & secrets menu option to add a new client secret. Remember to take note of this value as it is required when obtaining an OAuth token later.

Requesting an OAuth Token

Before the Client App (CRM Website) can call the API Service (CRM Service), a bearer token needs to be obtained from the OAuth 2.0 token endpoint of AAD. For this, I am going to use Postman to act as the Client App by sending the following parameters. You should be able to get all these values from the Overview of the Client App (CRM Website) and the Scope value from the API Service (CRM Service)

grant_type – Must be set to client_credentials
client_id – The application found in the Client App (CRM Website)
client_secret – The secret that was generated in the Client App (CRM Website) which must be URL encoded.
scope – This the application ID URL of the API Service (CRM Service) which must be URL encoded. Also you need to append /.default to the end of the URL eg (scope=api://189f0961-ba0f-4a5e-93c1-7f71a10b1a13/.default)

Here is an example of the PostMan request to obtain the token. Remember to replace {your-tenant-id} with your one.

When you send it and all the parameters are correct, you should receive a JWT token as per below.

Now if you take the value of the “access_token” and use a tool like https://jwt.ms/ to decode it, you should see the custom application claims.

In conclusion, use custom claims to provide granular control of operations in your backend API’s and any security breaches from hijacked client applications.

Keep a watch out for my next blog where I will show you how to access these claims from within an Azure Function.

Enjoy…

23 April 2020

Connecting an Azure WebApp to a SQL Server VM inside a VNet

This article is about connecting an Azure WebApp to a SQL Server VM which is hosted inside an Azure Virtual Network. Typically a SQL Server VM would be hosted inside an Azure Virtual Network (VNet) to isolate it from the internet by blocking all inbound and outbound internet traffic using a Network Security Group (NSG). In this scenario, connectivity to the SQL Database is achieved by using the new VNet Integration feature found on the App Service component. Using this feature removes the requirement of an App Service Environment (ASE) for the WebApp thus reducing overall hosting costs.

Using VNet integration provides private outbound access from your App Service to resources in your VNet using the RFC1918 internal IP address allocation range (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) by default.

Scenario

A web application is hosted in a WebApp which requires a connection to the SQL Database hosted inside a VNet.

The network topology of this scenario is shown below which uses the Regional VNet Integration option where both the WebApp and SQL VM are in the same region. Here we have a VNet called Backend which has two subnets, one for the VNet Integration used for delegating called IntegDeleg and the other to host the SQL Server VM called DataStore.

Configuration Walkthrough

The following are the sequence of steps used to setup VNet Integration between a Web App and SQL Server with the assumption the SQL Server VM is already hosted inside a VNet.

1. Adding a VNet subnet

2. Provisioning an AppSvc Plan

3. Provisioning a WebApp

4. Setting up the VNet Integration

5. Validating SQL Server Security Settings

6. Testing connectivity to the SQL Server

7. Updating the Web App SQL Connection String

1. Adding a VNet Subnet

A dedicated subnet used by the VNet Integration feature is required to be added to the existing VNet hosting the SQL Server VM. The IP range should match the maximum number of AppSvc plan instances when fully scaled out as each instance would require a IP address. For this scenario I will be using a /27 prefix giving a total range of 32 address, however 5 address are used internally by Azure leaving 27 usable addresses for each plan instance.

2. Provisioning App Svc Plan

To use VNet Integration, you will need to provision an App Service plan using newer V2 scale units. Note if you are currently using V1 App Services, you will need to provision a new plan using V2 and migrate you apps to this new plan.

To confirm if you have selected the newer V2 App Services, the Premium plans should be shown as P1V2, P2V2 and P3V2. Here I will be using a Standard Plan S1 for this scenario highlighted below.

3. Provisioning Web App

Create a new Web App and ensure it is in the same region as the VNet. Also ensure you have selected the App Service Plan you created above.

4. Enable VNet Integration

Under the Web App that was provisioned above, click on the Networking menu item to view the networking options and then click on “Click here to configure” under the VNet Integration heading.

Once the VNet Configuration form opens, click on the “Add VNet” to open the Network Feature Status blade. Select the VNet that hosts the SQL Server and then the Subnet that was created earlier for the VNet Integration. Then press OK to save the changes.

After you hit OK, the VNet Integration should be connected and ready for testing the connectivity. Remember the VNet Integration will route all outbound RFC1918 traffic from the WebApp into your VNet.

5. Validating SQL Server Security Settings

To reduce the surface area of attack, ensure the SQL Server can only accept connections within the VNet. This is done by setting the “SQL connectivity” option to Private (within Virtual Network) under the Security menu of the SQL Virtual Machine.

Also check the NSG attached to the SQL Server VM to ensure there is a rule to disable all outbound internet traffic. If there is a inbound rule called default-allow-sql as highlighted below, it is advisable to delete this rule if not required. This inbound rule default-allow-sql is normally created when the security on the SQL Server VM allows SQL connectivity via Public (Internet) connections.

6. Testing connectivity

To check connectivity between the Web App and the SQL server, we can use the tcpping command from a console window. Go to the Web App that was created previously and click on the Console menu item to open a console window similar to below.

In the console window type the command tcpping <sql vm private ip address>:1433. All going well you should get a reply similar to that below where 10.0.2.4 was the private IP address of my SQL Server VM using the default port 1433.

7. Updating the Web App SQL Connection String

Once the connectivity has been verified, the next step is to update the connection string on the Web App to use the private IP address of the SQL Server VM. Typically the connection string should look something like this:- Server=10.0.2.4;Database=coreDb;User Id=myusername;Password=mypassword;MultipleActiveResultSets=true

After the connection string has been updated to use the private IP address, you should be able to test your application. Here I am just adding some new tasks in the TodoList web application and confirming the records are written to the database.

Conclusion

VNet Integration provides an easy and cost effective solution to access databases hosted within a VNet without resorting to a dedicated ASE. Also using rules on the NSG applied to the SQL Server VM provides the capability to block all internet traffic and allow only RFC1918 internal addresses to have access.

More information about VNet Integration can be found on the MS docs site https://docs.microsoft.com/en-us/azure/app-service/web-sites-integrate-with-vnet.

Enjoy…

19 March 202019 March 2020

Ensuring Ordered Delivery of Messages using Azure Functions

Typically when using Azure Functions to consume messages from a Service Bus (SB), the ordering is not guaranteed although the SB is First-In-First-Out (FIFO). This is due to competing consumers, where multiple instances of the function are competing for messages of the service bus.

An example where out of ordering can happen is when a function instance takes longer to process a message than other instances therefore affecting the process ordering. This is represented in the sequence diagram below, where the function instance 1 took longer to update the same record in a database than instance 2.

One option to enforce ordered delivery is to configure the Azure Function to spin up only one instance. The only problem with this solution is it won’t scale very well. A more scalable option is to use sessions.This allows you to have multiple instances of a function executing giving you a higher message throughput.

To enforce message ordering several properties must be set. The property Requires Session must be enabled on the SB queues and topic subscriptions. Messages sent onto the SB must set the context property SessionId to unique value from other non related messages. Some examples of a session Id could be the account number, customer number, batch Id, etc. Azure Functions need to have the IsSessionsEnabled property set to enabled on the SB input binding.

This feature for Azure Functions to use SB sessions only came GA as of mid 2019. Enabling sessions on the Azure Function places a lock on all messages that have the same session Id causing the locked messages to be consumed by that one function instance that placed the lock.

Typical Scenario

A warehouse needs to track the progress of an order from when its first received to when it gets dispatched. Throughout each stage (Ordered, Picked, Packaged, Dispatched) of the ordering process, the status of the order must be updated. This involves placing a new message onto the service bus every time the order status needs to get updated. An Azure function will then pull the messages from the service bus and update the order status in a database where the customer can view the current state of their order.

To simulate the warehouse tracking system, a console app will be used to create messages for each status change (Ordered, Picked, Packaged, Dispatched), for several hundred orders. The session Id of each status message will be set to the order number. The app will then send the messages to a SB Topic where it will have two subscriptions, one with sessions enabled and the other disabled. This is so we can compare the ordering of messages being received with and without sessions enabled.

Order message generater

class Program
  {
      private static string connectionString = ConfigurationManager.AppSettings[“ServiceBusConnectionString”];
      private static string topicName = ConfigurationManager.AppSettings[“TopicName”];
      private static int orders = 100;
      private static int messagePerSession = 4;
      static async Task Main(string[] args)
      {
          Console.WriteLine(“Creating Service Bus sender….”);
          var taskList = new List<Task>();
          var sender = new MessageSender(connectionString, topicName);
          //create an order
          for (int order = 0; order < orders; order++)
          {
              var orderNumber = $”OrderId-{order.ToString()}“;
              var messageList = new List<Message>();
              //simulate a status update in the correct order
              for (int m = 0; m < messagePerSession; m++)
              {
                  var status = string.Empty;
                  switch (m)
                  {
                      case 0 :
                          status = “1 – Ordered”;
                          break;
                      case 1:
                          status = “2 – Picked”;
                          break;
                      case 2:
                          status = “3 – Packaged”;
                          break;
                      case 3:
                          status = “4 – Dispatched”;
                          break;
                  }
                  var message = new Message(Encoding.UTF8.GetBytes($”Status-{status}“))
                  {
                      //set the service bus SessionId property to the current order number
                      SessionId = orderNumber
                  };
                  messageList.Add(message);
              }
              //send the list of status update messages for the order to the service bus
              taskList.Add(sender.SendAsync(messageList));
          }
          Console.WriteLine(“Sending all messages…”);
          await Task.WhenAll(taskList);
          Console.WriteLine(“All messages sent.”);
      }
  }

Two Azure functions will be created, where one has sessions enabled and the other disabled. The functions will have a random delay created from 1 to 10 seconds to simulate some business logic which may be calling out to an external service before updating the order status. Instead of the function writing to a database, each status update message received will be written to an Azure Table storage to create an audit log of when a status update message was processed.

Below is the source code for the function which will process the messages on the service bus using sessions. Note the IsSessionEnabled property is set to true on the ServiceBusTrigger input binding. The randomiser is to simulate some business logic that could vary in time to process a message.

Azure Function using sessions

public static class MsgOrderingSessions
    {
        [FunctionName(“MsgOrderingSessions”)]
        [return: Table(“OrdersSession”, Connection = “StorageConnectionAppSetting”)]
        public static OrderEntity Run([ServiceBusTrigger(“orders”, “OrdersSession”, Connection = “SbConnStr”, IsSessionsEnabled = true)]
              Message sbMesssage, ILogger log)
        {
            log.LogInformation($”C# ServiceBus topic trigger function processed message: {Encoding.UTF8.GetString(sbMesssage.Body)}“);
            Random random = new Random();
            int randNumb = random.Next(1000, 10000);
            System.Threading.Thread.Sleep(randNumb);
            return new OrderEntity { PartitionKey = $”{sbMesssage.SessionId} – {DateTime.Now.Ticks}“ , RowKey = Guid.NewGuid().ToString(), Text = Encoding.UTF8.GetString(sbMesssage.Body) };
        }
    }

Below is the source code for the function which does not use sessions. Here the IsSessionEnabled is set to false.

Azure Function no sessions

public static class MsgOrderingNoSession
    {
        [FunctionName(“MsgOrderingNoSessions”)]
        [return: Table(“OrdersNoSession”, Connection = “StorageConnectionAppSetting”)]
        public static OrderEntity Run([ServiceBusTrigger(“orders”, “OrdersNoSession”, Connection = “SbConnStr”, IsSessionsEnabled = false)]
              Message sbMesssage, ILogger log)
        {
            log.LogInformation($”C# ServiceBus topic trigger function processed message: {Encoding.UTF8.GetString(sbMesssage.Body)}“);
            Random random = new Random();
            int randNumb = random.Next(1000, 10000);
            System.Threading.Thread.Sleep(randNumb);
            return new OrderEntity { PartitionKey = $”{sbMesssage.SessionId} – {DateTime.Now.Ticks}“, RowKey = Guid.NewGuid().ToString(), Text = Encoding.UTF8.GetString(sbMesssage.Body) };
        }       
    }

Below is the settings for the service bus topic which has 2 subscriptions and one of them has Requires Session checked.

Running the console app creates 400 messages on both subscriptions, 4 status update messages per 1 order.

Conclusion

The Azure function which had the ServiceBusTrigger, IsSessionsEnabled = false inserted the rows out of order due to multiple function instances competing for the next message on the service bus.

Now the Azure Function which had IsSessionsEnabled = true and read messages from a service bus subscription which also had the Requires Session flag enabled, the messages were processed in the correct sequence as they were placed onto the service bus.

When using sessions, there is a slight performance hit depending on the number of function instances executing. In this example both functions where running under the consumption plan which spun up 6 instances. As you can see the number of messages waiting on each of the subscriptions below, the subscription which had sessions disabled are processing the messages a lot faster.

When sessions are used, each function instance places a locked on all messages having the same session Id which are processed one after another. As there were only 6 instances available, only a maximum of six orders could be processed at one time.

Enjoy…

29 August 2019

Using an Azure APIM Scatter-Gather policy with a Mapping Function

This is a follow up from a previous blog “Azure APIM Scatter-Gather Pattern Policy” where I wrote about using the Wait policy to create a scatter-gather pattern. A few colleges were asking about being able to map the inbound request to the different schemas required by each of the Microservices.

A high level design is shown below using two “Wait” polices and an Azure Function for the mapping. The first policy ‘Translation’ sends the request to the mapping function and when completed the second policy ‘Scatter’ is executed to send the mapped request to each of the Microservices.

The internals of the Azure Function that maps the incoming request is shown below as an example. Here I am using a route on the supplier name and a simple If-Then statement to select which static translator method to call.

public static class MappingService
   {
       [FunctionName("DataMapping")]
       public static async Task<IActionResult> Run(
           [HttpTrigger(AuthorizationLevel.Function,  "post", Route = "Pricing/{suppliername}")]
           HttpRequest req,
           string suppliername,
           ILogger log)
       {
           log.LogInformation("C# HTTP trigger function processed a request.");

           string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
           dynamic response = null;
           if (suppliername.Equals("Supplier1", StringComparison.OrdinalIgnoreCase))
               response = Translator.TranslateSupplier1(requestBody);
           else if (suppliername.Equals("Supplier2", StringComparison.OrdinalIgnoreCase))
               response = Translator.TranslateSupplier2(requestBody);            

           return response != null
               ? (ActionResult)new OkObjectResult(response)
               : new BadRequestObjectResult("Invalid message.");
       }
   }

Below is the code for the Translation Policy which calls the two Azure function resources in parallel that accepts the inbound price request message. The function access code is stored as a named-value pair in APIM called “functionapkey”.

<!-- Call the mapping service -->
<wait for="all">
   <send-request mode="copy" response-variable-name="res_SupplierMap1" timeout="120" ignore-error="false">
       <set-url>https://mapsvc.azurewebsites.net/api/Pricing/supplier1?code={{funcmapkey}}</set-url>
       <set-method>POST</set-method>
       <set-body>@(context.Variables.GetValueOrDefault<string>("requestPayload"))</set-body>
   </send-request>
   <send-request mode="copy" response-variable-name="res_SupplierMap2" timeout="120" ignore-error="false">
       <set-url>https://mapsvc.azurewebsites.net/api/Pricing/supplier2?code={{funcmapkey}}</set-url>
       <set-method>POST</set-method>
       <set-body>@(context.Variables.GetValueOrDefault<string>("requestPayload"))</set-body>
   </send-request>
</wait>

The code for the Scatter Policy is shown below which is similar to the original blog post. However it uses the mapped outputs from the Translation policy that are stored in the res_SupplerMap1 and res_SupplerMap2 context variables instead.

<!-- Call the pricing services -->
<wait for="all">
   <send-request mode="copy" response-variable-name="response_1" timeout="120" ignore-error="false">
       <set-url>{{serviceendpoint_1}}</set-url>
       <set-method>POST</set-method>
       <set-body>@(((IResponse)context.Variables["res_SupplierMap1"]).Body.As<string>())</set-body>
   </send-request>
   <send-request mode="copy" response-variable-name="response_2" timeout="120" ignore-error="false">
       <set-url>{{serviceendpoint_2}}</set-url>
       <set-method>POST</set-method>
       <set-body>@(((IResponse)context.Variables["res_SupplierMap2"]).Body.As<string>())</set-body>
   </send-request>
</wait>

The last policy checks the status of each of the pricing services and returns the results as a composite message if there were no errors encountered. This is similar to the original blog post but instead of returning a JObject I am now returning a JArray collection.

<choose>
   <when condition="@((int)((IResponse)context.Variables["response_1"]).StatusCode != 200)">
       <return-response response-variable-name="response_1" />
   </when>
   <when condition="@((int)((IResponse)context.Variables["response_2"]).StatusCode != 200)">
       <return-response response-variable-name="response_2" />
   </when>
   <otherwise>
       <return-response>
           <set-status code="200" reason="OK" />
           <set-header name="Content-Type" exists-action="override">
               <value>application/json</value>
           </set-header>
           <set-body>@{
                       JArray suppliers = new JArray();
                       suppliers.Add(((IResponse)context.Variables["response_1"]).Body.As<JObject>());
                       suppliers.Add(((IResponse)context.Variables["response_2"]).Body.As<JObject>());                               
                       return suppliers.ToString();
           }</set-body>
       </return-response>
   </otherwise>
</choose>

The completed policy for the method looks like this below. Take note the request payload is stored in the variable named “requestPayload” initially to avoid locking body context in the <Wait> policies.

<policies>
    <inbound>
        <set-variable name="requestPayload" value="@(context.Request.Body.As&lt;string>(true))" />
        <!-- Call the mapping service -->
        <wait for="all">
            <send-request mode="copy" response-variable-name="res_SupplierMap1" timeout="120" ignore-error="false">
                <set-url>https://mapsvc.azurewebsites.net/api/Pricing/supplier1?code={{funcmapkey}}</set-url>
                <set-method>POST</set-method>
                <set-body>@(context.Variables.GetValueOrDefault<string>("requestPayload"))</set-body>
            </send-request>
            <send-request mode="copy" response-variable-name="res_SupplierMap2" timeout="120" ignore-error="false">
                <set-url>https://mapsvc.azurewebsites.net/api/Pricing/supplier2?code={{funcmapkey}}</set-url>
                <set-method>POST</set-method>
                <set-body>@(context.Variables.GetValueOrDefault<string>("requestPayload"))</set-body>
            </send-request>
        </wait>
        <!-- Call the pricing services -->
        <wait for="all">
            <send-request mode="copy" response-variable-name="response_1" timeout="120" ignore-error="false">
                <set-url>{{serviceendpoint_1}}</set-url>
                <set-method>POST</set-method>
                <set-body>@(((IResponse)context.Variables["res_SupplierMap1"]).Body.As<string>())</set-body>
            </send-request>
            <send-request mode="copy" response-variable-name="response_2" timeout="120" ignore-error="false">
                <set-url>{{serviceendpoint_2}}</set-url>
                <set-method>POST</set-method>
                <set-body>@(((IResponse)context.Variables["res_SupplierMap2"]).Body.As<string>())</set-body>
            </send-request>
        </wait>
        <choose>
            <when condition="@((int)((IResponse)context.Variables["response_1"]).StatusCode != 200)">
                <return-response response-variable-name="response_1" />
            </when>
            <when condition="@((int)((IResponse)context.Variables["response_2"]).StatusCode != 200)">
                <return-response response-variable-name="response_2" />
            </when>
            <otherwise>
                <return-response>
                    <set-status code="200" reason="OK" />
                    <set-header name="Content-Type" exists-action="override">
                        <value>application/json</value>
                    </set-header>
                    <set-body>@{
                                JArray suppliers = new JArray();
                                suppliers.Add(((IResponse)context.Variables["response_1"]).Body.As<JObject>());
                                suppliers.Add(((IResponse)context.Variables["response_2"]).Body.As<JObject>());                               
                                return suppliers.ToString();
                    }</set-body>
                </return-response>
            </otherwise>
        </choose>
    </inbound>
    <backend>
        <base />
    </backend>
    <outbound>
        <base />
    </outbound>
    <on-error>
        <base />
    </on-error>
</policies>

Using the tracing feature in APIM, you can see the initial price request message below. This will be sent to the mapping function Pricing method.

Below is the trace output from APIM showing the two different messages returned from mapping function and assigned to the res_Supplier variables.

Below is the composite message returned from APIM as an JSON array containing each supplier.

In conclusion, using the two <Wait> polices to send multiple requests in parallel yields a request/response latency of around 200ms on average in this scenario. Also instead of using an Azure Function to map the incoming request, you could replace it with a couple of “Transformation” policies.

Enjoy…

6 August 2019

Azure APIM Scatter-Gather Pattern Policy

Recently I have been reading about some of the advanced policies available in APIM and the one that caught my eye was the “Wait” policy found here https://docs.microsoft.com/en-us/azure/api-management/api-management-advanced-policies. This policy will execute child policies in parallel and will wait until either one or all of the child polices have completed before continuing.

I was pondering on a good use case for this policy and the first one came to mind was a scatter-gather pattern shown below. I could easily create this pattern without having to provision any other required Azure services.

The Scatter-Gather pattern is created by exposing a REST endpoint through APIM which will accept a JSON payload. When a request comes into APIM, a custom policy will forward this request onto the service endpoints defined in the policy and wait until they have all responded before continuing on with the rest of the statements in the parent policy. Once all the destination endpoints have responded, the return status code on each service is then checked for success or an error. If an error does occur, then the error is returned immediately otherwise the message from each service is combined into a composite JSON message which is returned back to the caller as the response message.

For the scenario, I will be sending a price request for a product to 3 suppliers simultaneously. In Azure APIM, I created a method which will accept a JSON price request message as shown below.

Then I added an Inbound processing policy to that method which is broken down into two parts. Below is the first part of the policy where it sends the inbound request to multiple endpoints in parallel using the <send-request> tag. Named values are used for the service endpoint address defined in the <set-url>{{serviceendpoint_xxx}}</set-url> tags. The response from each service call is inserted into the variable response-variable-name=”response_xxx” which is used in the second part of this policy.

<set-variable name="requestPayload" value="@(context.Request.Body.As&lt;string>(true))" />
        <wait for="all">
            <send-request mode="copy" response-variable-name="response_1" timeout="120" ignore-error="false">
                <set-url>{{serviceendpoint_1}}</set-url>
                <set-method>POST</set-method>
                <set-body>@(context.Variables.GetValueOrDefault<string>("requestPayload"))</set-body>
            </send-request>
            <send-request mode="copy" response-variable-name="response_2" timeout="120" ignore-error="false">
                <set-url>{{serviceendpoint_2}}</set-url>
                <set-method>POST</set-method>
                <set-body>@(context.Variables.GetValueOrDefault<string>("requestPayload"))</set-body>
            </send-request>
            <send-request mode="copy" response-variable-name="response_3" timeout="120" ignore-error="false">
                <set-url>{{serviceendpoint_3}}</set-url>
                <set-method>POST</set-method>
                <set-body>@(context.Variables.GetValueOrDefault<string>("requestPayload"))</set-body>
            </send-request>
        </wait>

After the closing </wait> tag, the response code from each of the services is checked inside a <choose> block. If its not equal to 200 then the response is immediately returned, otherwise each of the responses is wrap inside a JSON object and returned as the composite response message.

<choose>
           <when condition="@((int)((IResponse)context.Variables["response_1"]).StatusCode != 200)">
               <return-response response-variable-name="response_1" />
           </when>
           <when condition="@((int)((IResponse)context.Variables["response_2"]).StatusCode != 200)">
               <return-response response-variable-name="response_2" />
           </when>
           <when condition="@((int)((IResponse)context.Variables["response_3"]).StatusCode != 200)">
               <return-response response-variable-name="response_3" />
           </when>
           <otherwise>
               <return-response>
                   <set-status code="200" reason="OK" />
                   <set-header name="Content-Type" exists-action="override">
                       <value>application/json</value>
                   </set-header>
                   <set-body>@(new JObject(
                               new JProperty("service_1",((IResponse)context.Variables["response_1"]).Body.As<JObject>()),
                               new JProperty("service_2",((IResponse)context.Variables["response_2"]).Body.As<JObject>()),
                               new JProperty("service_3",((IResponse)context.Variables["response_3"]).Body.As<JObject>())                      
                           ).ToString())</set-body>
               </return-response>
           </otherwise>
</choose>

Below is the whole policy for the method. More service endpoints may be added or removed from this policy as desired.

<policies>
    <inbound>
        <set-variable name="requestPayload" value="@(context.Request.Body.As&lt;string>(true))" />
        <wait for="all">
            <send-request mode="copy" response-variable-name="response_1" timeout="120" ignore-error="false">
                <set-url>{{serviceendpoint_1}}</set-url>
                <set-method>POST</set-method>
                <set-body>@(context.Variables.GetValueOrDefault<string>("requestPayload"))</set-body>
            </send-request>
            <send-request mode="copy" response-variable-name="response_2" timeout="120" ignore-error="false">
                <set-url>{{serviceendpoint_2}}</set-url>
                <set-method>POST</set-method>
                <set-body>@(context.Variables.GetValueOrDefault<string>("requestPayload"))</set-body>
            </send-request>
            <send-request mode="copy" response-variable-name="response_3" timeout="120" ignore-error="false">
                <set-url>{{serviceendpoint_3}}</set-url>
                <set-method>POST</set-method>
                <set-body>@(context.Variables.GetValueOrDefault<string>("requestPayload"))</set-body>
            </send-request>
        </wait>
        <choose>
            <when condition="@((int)((IResponse)context.Variables["response_1"]).StatusCode != 200)">
                <return-response response-variable-name="response_1" />
            </when>
            <when condition="@((int)((IResponse)context.Variables["response_2"]).StatusCode != 200)">
                <return-response response-variable-name="response_2" />
            </when>
            <when condition="@((int)((IResponse)context.Variables["response_3"]).StatusCode != 200)">
                <return-response response-variable-name="response_3" />
            </when>
            <otherwise>
                <return-response>
                    <set-status code="200" reason="OK" />
                    <set-header name="Content-Type" exists-action="override">
                        <value>application/json</value>
                    </set-header>
                    <set-body>@(new JObject(
                                new JProperty("service_1",((IResponse)context.Variables["response_1"]).Body.As<JObject>()),
                                new JProperty("service_2",((IResponse)context.Variables["response_2"]).Body.As<JObject>()),
                                new JProperty("service_3",((IResponse)context.Variables["response_3"]).Body.As<JObject>())                      
                            ).ToString())</set-body>
                </return-response>
            </otherwise>
        </choose>
    </inbound>
    <backend>
        <base />
    </backend>
    <outbound>
        <base />
    </outbound>
    <on-error>
        <base />
    </on-error>
</policies>

For testing purposes, I just created 3 simple logic apps triggered by a HTTP request which returned some static data. Using Postman, I sent the following message.

The response message from APIM is shown below.

Enjoy…

26 May 201926 May 2019

ARM Template for Provisioning an Azure Function App with a Key Vault

Late in 2018, Microsoft announced you can now store sensitive application setting values in an App Service to an Azure Key Vault without any changes to the function code. The only requirement was to update the value settings with “@Microsoft.KeyVault(SecretUri=secret_uri_with_version)” to reference the Key Vault and enabling an identity account of the App Service to access the Key Vault.

This is a great leap forward having this feature baked into an App Service, however trying to create an ARM template to provision an App Service, Storage Account and a Key Vault by following these instructions https://docs.microsoft.com/en-us/azure/app-service/app-service-key-vault-references#azure-resource-manager-deployment proved to be rather challenging. After several hours of getting the versions correct and getting the dependencies in the correct order, I managed to create a working template to provision all 3 artefacts.

The template creates the App Service and uses the system-assigned managed identity account to access the Key Vault with Get only permissions. The primary key for the Storage Account and the Application Insights key are stored in Key Vault. These are then referenced by the AzureWebJobsStorage, WEBSITE_CONTENTAZUREFILECONNECTIONSTRING and APPINSIGHTS_INSTRUMENTATIONKEY names in the application settings of the Function App Service.

Updating the parameters file with the required artefact names and deploying the template, provisions the following services in Azure. Only thing left is to deploy your Function into the newly provisioned App Service.

If you try and view the Secrets in Key Vault, you will encounter an authorisation error shown below. If you wish, you may update the ARM template to add your ID to the access policies collection of the Key Vault.

To add your account using the Azure Portal, navigate to Access Policies and then click Add new. Notice the App Svc account has already been added by the ARM template.

Then click on Select principal and type in you login address into the Principle blade to find your name and then click the select button.

Once your login name has been added, you can then select the required permissions.

Now you can view the keys added by the ARM template.

Below are the Application settings under the App Service showing references to the Key Vault for the values.

The code for the ARM Template can be downloaded from here: https://github.com/connectedcircuits/azappsvc. I have added comments into the template so you should be able to modify it to suit your requirements.

Enjoy…

24 April 201925 April 2019

Always subscribe to Dead-lettered messages when using an Azure Service Bus

I typically come across solutions that incorporate a service bus where monitoring of the dead-letter queues are simply ignored. Upon questioning the reason, the normal excuse for not monitoring the DLQ (dead-letter queue) is quote “I don’t require it because I have added exception handling therefore no messages will end up on the DLQ”. From experience there will be scenarios where the exception logic did not capture an edge case scenario and the message will end up onto the DLQ without anyone knowing about.

A simple solution is to have a single process to monitor all the DQL messages and raise an alert when one occurs. Below is one of my building blocks which a typically incorporate when there is a service bus involved in a solution.

To use the DLQ building block to centrally capture any DLQ message, simply set the “ForwardDeadLetteredMessagesTo” property on each of the messaging queues to a common DLQ handler queue as shown below.

Now when a message gets dead lettered, it will end up in this common queue which is monitored by an Azure Function. Note the current NuGet version v3.0.4 of the ServiceBus DLL has the DeadLetterSource property and is not currently available in the Logic App Service Bus connector. The function writes the DLQ meta data, any custom properties and the message payload to a blobstore file. By using an Azure Storage Account V2 for the blobstore, a new blob creation event will be fired to any interested subscribers which in this case is a Logic App.

Azure Function Code

Below is the code for the Azure Function. Here I am using the IBinder interface to allow me to set the folder path and file name imperatively. The connection strings (ServiceBusConn, StorageAccountConn) are defined in the Application settings of the Azure App Service.

Code Snippet

using Microsoft.Azure.ServiceBus;
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
 
namespace ServiceBusDLQMonitoring
{
    public static class Function1
    {
        [FunctionName("Function1")]
 
        public static async Task RunAsync([ServiceBusTrigger("dlq-processor", Connection = "ServiceBusConn")] Message dlqQueue,
            Binder blobBinder,          
            ILogger log)
        {
            log.LogInformation($"C# ServiceBus queue trigger function processed message: {dlqQueue.MessageId}");
 
            //set the filename and blob path
            var blobFile = Guid.NewGuid().ToString() + ".json";
            var path = string.Concat("dlq/",DateTime.UtcNow.ToString("yyyy/MM/dd"),"/" ,dlqQueue.SystemProperties.DeadLetterSource,"/", blobFile);
 
            var dlqMsq = new DLQMessage
            {
                DeadletterSource = dlqQueue.SystemProperties.DeadLetterSource,
                MessageId = dlqQueue.MessageId,
                SequenceNumber = dlqQueue.SystemProperties.SequenceNumber,
                SessionId = dlqQueue.SessionId,
                UserProperties = dlqQueue.UserProperties,
                DeadLetterReason = dlqQueue.UserProperties["DeadLetterReason"].ToString(),
                EnqueuedDttmUTC = dlqQueue.SystemProperties.EnqueuedTimeUtc,
                ContentType = dlqQueue.ContentType,
                DeliveryCount = dlqQueue.SystemProperties.DeliveryCount,
                Label = dlqQueue.Label,
                MsgBase64Encoded = Convert.ToBase64String(dlqQueue.Body, Base64FormattingOptions.None)
            };
 
            var blobAttributes = new Attribute[]
            {
                new BlobAttribute(path),
                new StorageAccountAttribute("StorageAccountConn")                
            };
 
            using (var writer = await blobBinder.BindAsync<TextWriter>(blobAttributes))
            {              
              writer.Write(JsonConvert.SerializeObject(dlqMsq,Formatting.Indented));
            }
        }
    }
 
    public class DLQMessage
    {       
        public string DeadletterSource { get; set; }
        public long SequenceNumber { get; set; }
        public string MessageId { get; set; }
        public string SessionId { get; set; }
        public string Label { get; set; }
        public string DeadLetterReason { get; set; }
        public DateTime EnqueuedDttmUTC { get; set; }
        public int DeliveryCount { get; set; }        
        public string ContentType { get; set; }
        public IDictionary<string,object> UserProperties { get; set; }
        public string MsgBase64Encoded { get; set; }
    }
}

Logic App Implementation

A Logic App is used to the retrieve the message from the blob store when it is triggered by the EventGrid HTTP webhook. The basic workflow is shown below and can be expanded to suit your own requirements.

The expression for the ‘Get blob content using path’ action is @{replace(triggerBody()[0][‘data’][‘url’],’https://dqlmessages.blob.core.windows.net/’,”)}. Here I am just replacing the Domain name with an empty string as I only want the resource location.

The Parse JSON action has the following schema. This makes it easier to reference the properties downstream.

{
    "properties": {
        "ContentType": {
            "type": [
                "string",
                "null"
            ]
        },
        "DeadLetterReason": {
            "type": "string"
        },
        "DeadletterSource": {
            "type": "string"
        },
        "DeliveryCount": {
            "type": "integer"
        },
        "EnqueuedDttmUTC": {
            "type": "string"
        },
        "Label": {
            "type": [
                "string",
                "null"
            ]
        },
        "MessageId": {
            "type": "string"
        },
        "MsgBase64Encoded": {
            "type": [
                "string",
                "null"
            ]
        },
        "SequenceNumber": {
            "type": "integer"
        },
        "SessionId": {
            "type": [
                "string",
                "null"
            ]
        },
        "UserProperties": {
            "type": "any"
        }
    },
    "type": "object"
}

The last action ‘Set variable MsgBody’ has the value set to: “@{base64ToString(body(‘Parse_JSON’)?[‘MsgBase64Encoded’])}”

Blob creation event configuration

Next is to setup a subscription to the Blob creation event. Click on Events under the Storage account for the DLQ messages as shown below.

Then click on the +Event Subscription to add a new subscription.

Setup the subscription Basic details with a suitable subscription name and the blob storage account resource name. Uncheck the ‘Subscribe to all event types’ and select Blob Created event. Set the endpoint details to Web Hook and the URL of the Logic App Http trigger endpoint address.

Under Filters, enable subject filtering. Add the following prefix ‘/blobServices/default/containers/’ to the name of the DLQ container (in this example its called ‘dlq’) and add it to the ‘Subject Begins With’ textbox. Then in the ‘Subject Ends With’, set it to the filename extension ‘.json’. Now click the Create button at the bottom of the page to create the subscription.

Sample Logic App output

Once everything is wired up and if there are any messages that have been placed onto the DLQ, you should see some logic app runs. Below is an example of the outputs from the last two actions.

All you need to do now is extend the Logic App to deliver the DLQ alert to somewhere.

Enjoy…

2 December 2018

Providing DR By Using An Azure Service Bus In Two Regions

This is a Disaster Recovery option I used on one of my projects. A client required a DR solution which guaranteed not to lose any messages during the DR failover process. In essence, no messages were allowed to be lost in mid flight whilst the DR process was taking place.

Solution

The approach I took was to use an Azure Service Bus in a primary Azure region and another service bus in a secondary Azure DR region. The publisher would then send the same message to both service bus endpoints. For my solution I used Azure APIM to post the same message to both primary and secondary regions, thereby simplifying the code for the publisher.

The primary region would simply process the messages as per normal using a Logic App to poll for new messages on the service bus. However in the DR region, the equivalent Logic App would be set in a disabled state. The messages in the secondary region would remain on the bus until the Time-To-Live (TTL) threshold is reached before either being moved onto the Deadletter queue, or dropped from the queue altogether by setting the EnableDeadLetteringOnMessageExpiration property to false. Using this technique provides automatic pruning of the older messages that would have definitely been processed by the primary region before failing over.

The value chosen for the TTL property is determined by how long it would take to failover to the DR region and the time to detect an issue being realised in the primary region.

Failing over would simply involve enable the Logic App the DR region and failing back would involve disabling this Logic App again.

Pros

No messages are lost during the failover process.
Low monetary transaction cost by the DR environment as no Logic Apps are being triggered during the normal process flow through the primary region.
Simplistic DR design which involves just another another queue.
Simple failover process.

Cons

There is a delay before any new messages would be processed while the older messages on the service bus are reprocessed first.
The backend system processing the messages must be idempotent, meaning the same message maybe processed by the backend system multiple times and produce the same outcome.
Requires the publisher to send the same message to 2 different endpoints. This may be mitigated by using APIM to manage sending the messages to both service bus endpoints.

Enjoy…

25 November 2018

Using Azure Logic App and an Automation Runbook to execute a long running SQL Stored Procedure

When trying to execute a long running SQL query using the Logic App SQL Connector, you will most likely hit the 2 minute execution timeout limit on the connector.

Even if you move the SQL query to an Azure function and use ADO.Net to access the backend database, you will hit the 10 minute execution timeout limit of the function when using the consumption plan.

An Alternative Approach

The solution here is to use the Azure Automation service to execute a PowerShell script which calls a SQL query. There is now a new connector available in Logic Apps to execute an Automation Runbook which you have the option to wait until it completes before moving onto the next action shape in the workflow.

Implementation

First find and add an Automation Account to your Azure resource group. Set the Create Azure Run As account to No.

Once the Automation Account has been created, click on the Credentials on the left menu pane to store the SQL Server login credentials.

Then add the SQL username and password and click Create. We will be using this as the Credential parameter in our PowerShell script.

Now click on Runbooks to create a new runbook. This is where we add a PowerShell script to execute.

Add a name for the Runbook and ensure the Runbook type is set to PowerShell Workflow, then click the Create button at the bottom of the page.

After the Runbook has been created, click on the Edit icon to add the PowerShell script.

Inside the PowerShell editor, paste the following code. Basically we are using ADO.Net object to create a SQL connection and to execute the stored procedure. To ensure the command object does not timeout, set the CommandTimeout = 0.

workflow ExecuteSQLStoredProcedure
{
    param(
        [parameter(Mandatory=$True)]
        [string] $SqlServer,
        
        [parameter(Mandatory=$False)]
        [int] $SqlServerPort=1433,
        
        [parameter(Mandatory=$True)]
        [string] $Database,
        
        [parameter(Mandatory=$True)]
        [string] $Sproc,
        
        [parameter(Mandatory=$True)]
        [PSCredential] $SqlCredential
    )
 
    # Get the username and password from the SQL Credential
    $SqlUsername = $SqlCredential.UserName
    $SqlPass = $SqlCredential.GetNetworkCredential().Password
    
    inlinescript {
        # Define the connection to the SQL Database
        $SQLConn = New-Object System.Data.SqlClient.SqlConnection("Server=tcp:$using:SqlServer,$using:SqlServerPort;Database=$using:Database;User ID=$using:SqlUsername;Password=$using:SqlPass;Trusted_Connection=False;Encrypt=True;Connection Timeout=30;")
        
        # Open the SQL connection
        $SQLConn.Open()
 
        # Define the SQL command to run. 
        $Cmd =  New-Object System.Data.SQLClient.SqlCommand 
        $Cmd.Connection = $SQLConn 
        $Cmd.CommandTimeout=0
        $Cmd.CommandType = [System.Data.CommandType]::StoredProcedure
        $Cmd.CommandText = $using:Sproc
 
        $Cmd.ExecuteNonQuery()
 
        # Close the SQL connection
        $SQLConn.Close()
    }
}

After the code has been pasted into the editor, save and remember to publish it after it has been saved.

Now to add a Logic App to execute the Runbook. For this demo, I will simply use the scheduler connector to fire the Logic App. In the designer add a Recurrence trigger and for the next action, search for automation and select the Create Job Azure Automation.

The parameters defined in the PowerShell script will be shown in the properties page of the connector as shown below. I will be executing a stored procedure called “dbo.LongProcess” which has a WaitFor Delay ‘00:15’ T-SQL statement. This will simulate a long running query of 15 minutes.

To get the results of the SQL query add the Azure Automation Get job output shape after the Create job shape.

Testing

To confirm the Logic App and SQL query does not timeout, run the trigger manually. After a period of 15 minutes, which is the delay period defined in the stored procedure, the Logic App will complete as shown below.

The output of the stored procedure will be shown in the Get job output shape.

To return a recordset as JSON from the PowerShell script, replace the code $Cmd.ExecuteNonQuery() with the following:

$reader = $Cmd.ExecuteReader()

$table = new-object "System.Data.DataTable"

$table.Load($reader)

#--Exporting data to the screen --#

$table | select $table.Columns.ColumnName | ConvertTo-Json

Note if you return a very large recordset, you may exceed the allocated memory,. In this scenario, you will need to batch the results.

Enjoy…

25 September 201820 October 2018

Exposing Azure Service Bus through APIM, generating a SAS Token and setting the Session Id

On one of my recent projects, a client application was required to place a message onto an Azure Service Bus by using a HTTP endpoint rather than using the Service Bus SDK and with the following constraints.

The client is unable to generate the Service Bus SAS token.
Service Bus Session Id needs to be set to the customer number found in the message to ensure ordered delivery by the consumer.
All messages are to be sent to a Service Bus Topic and require to add a custom Service Bus property called ‘MgsType’.
Custom HTTP Request Headers may be used.

I decided upon a solution that uses Azure APIM to expose the Service Bus endpoint. A custom policy will be used to generate the Service Bus SAS token and to parse the message for the customer Id. The customer Id will then be used to set the SessionId on the Service Bus. The client then only has to register for a subscription key in the Azure Developer portal and then pass this key with each HTTP request in the header.

The first step of this solution is to create an Azure Service Bus with a Topic called ‘transactions’ and to create a Shared access policy called ‘Sender’ which has only Send claims.

Next add a subscription to the topic with ‘Require Session’ enabled and the following rule “MsgType = ‘Deposits’”

Before we start developing the custom policies, we need to setup 3 Name Values in the APIM blade as shown below. These values are used for generating the Service Bus SAS token and are obtained from the Service Bus properties.

Where,

SB_Key – primary key for the ‘Sender’ shared access policies
SB_KeyName – name of the Shared access policy
SB_Uri – is the topic URL which can be found by clicking on the topic name under the ‘Topics’ blade shown below.

Next is to create an API using the ‘Blank API’ template similar to what I have done below. Note the ‘Web service URL’ value is the base address of the Service Bus topic URL. (ie without the topic name resource location)

Then add an operation to the service as below. Note the URL should be the name of your topic with the resource ‘messages’ appended to the end.

Once the operation has been created, we can now add the custom policy to the ‘Inbound processing’ stage.

The APIM policy consists of several code blocks inside the inbound processing stage which are describe in detail below. To improve performance I will be caching the generated SAS token.

The first code block looks up cache for a value. If nothing is found then the variable “cachedSasToken” is assigned to null as there is no default value specified.

<cache-lookup-value key="crmsbsas" variable-name="cachedSasToken" />

Next a control flow is used to check the variable “cachedSasToken” for null and if true then a SAS token is generated using the values stored in APIM Name-Value pairs. Once the token is calculated then it is stored in cache and set to expire in 120 seconds. The cache is then read again to assign the variable “cachedSasToken” with the generated SAS token.

Both the signature and resource URL is required to be UrlEncoded. My first choice was to use the System.Web.UrlEncode function to encode the values. Unfortunately this function is not available in the APIM policy expressions as it only has a subset of the .Net Framework types. To work around this issue, I ended up using the System.Uri.EscapeDataString method instead.

<choose>
            <when condition="@(context.Variables.GetValueOrDefault&lt;string>("cachedSasToken") == null)">
                <cache-store-value key="crmsbsas" value="@{
                        string resourceUri = "{{SB_Uri}}";
                        string keyName = "{{SB_KeyName}}";
                        string key = "{{SB_Key}}";
                        TimeSpan sinceEpoch = DateTime.UtcNow - new DateTime(1970, 1, 1);
                        var expiry = Convert.ToString((int)sinceEpoch.TotalSeconds + 120);
                        string stringToSign = System.Uri.EscapeDataString(resourceUri) + "\n" + expiry;
                        HMACSHA256 hmac = new HMACSHA256(Encoding.UTF8.GetBytes(key));
                        var signature = Convert.ToBase64String(hmac.ComputeHash(Encoding.UTF8.GetBytes(stringToSign)));
                        var sasToken = String.Format("SharedAccessSignature sr={0}&amp;sig={1}&amp;se={2}&amp;skn={3}", 
                                        System.Uri.EscapeDataString(resourceUri),
                                        System.Uri.EscapeDataString(signature), expiry, keyName);
                        return sasToken;
                    }" duration="100" />
                <cache-lookup-value key="crmsbsas" variable-name="cachedSasToken" />
            </when>
        </choose>

The SAS token is then added to the header using the value from the variable ‘cachedSasToken’

<set-header name="Authorization" exists-action="override">
<value>@(context.Variables.GetValueOrDefault<string>("cachedSasToken"))</value>
</set-header>

I then set the message content type to application/json and remove the APIM subscription key header from being sent to the Service Bus endpoint.

<set-header name="Content-type" exists-action="override">
          <value>application/json</value>
      </set-header>
      <set-header name="Ocp-Apim-Subscription-Key" exists-action="delete" />

The last part is to extract the customer number from the message and assign it to the SessionId property of the Service Bus. The standard set of Service Bus properties are required to be added to a custom header called ‘BrokerProperties’

<set-header name="BrokerProperties" exists-action="override">
            <value>@{
               string reqData = context.Request.Body?.As<string>(true);
               dynamic data =  JsonConvert.DeserializeObject(reqData);
               string order =  data?.CustomerNumber;
               return string.Format("{{\"SessionId\":\"{0}\"}}", order);
            }</value>
        </set-header>

The full code for the custom policy is here:

<!--
    IMPORTANT:
    - Policy elements can appear only within the <inbound>, <outbound>, <backend> section elements.
    - Only the <forward-request> policy element can appear within the <backend> section element.
    - To apply a policy to the incoming request (before it is forwarded to the backend service), place a corresponding policy element within the <inbound> section element.
    - To apply a policy to the outgoing response (before it is sent back to the caller), place a corresponding policy element within the <outbound> section element.
    - To add a policy position the cursor at the desired insertion point and click on the round button associated with the policy.
    - To remove a policy, delete the corresponding policy statement from the policy document.
    - Position the <base> element within a section element to inherit all policies from the corresponding section element in the enclosing scope.
    - Remove the <base> element to prevent inheriting policies from the corresponding section element in the enclosing scope.
    - Policies are applied in the order of their appearance, from the top down.
-->
<policies>
    <inbound>
        <base />
        <cache-lookup-value key="crmsbsas" variable-name="cachedSasToken" />
        <choose>
            <when condition="@(context.Variables.GetValueOrDefault&lt;string>("cachedSasToken") == null)">
                <cache-store-value key="crmsbsas" value="@{
                        string resourceUri = "{{SB_Uri}}";
                        string keyName = "{{SB_KeyName}}";
                        string key = "{{SB_Key}}";
                        TimeSpan sinceEpoch = DateTime.UtcNow - new DateTime(1970, 1, 1);
                        var expiry = Convert.ToString((int)sinceEpoch.TotalSeconds + 120);
                        string stringToSign = System.Uri.EscapeDataString(resourceUri) + "\n" + expiry;
                        HMACSHA256 hmac = new HMACSHA256(Encoding.UTF8.GetBytes(key));
                        var signature = Convert.ToBase64String(hmac.ComputeHash(Encoding.UTF8.GetBytes(stringToSign)));
                        var sasToken = String.Format("SharedAccessSignature sr={0}&amp;sig={1}&amp;se={2}&amp;skn={3}", 
                                        System.Uri.EscapeDataString(resourceUri),
                                        System.Uri.EscapeDataString(signature), expiry, keyName);
                        return sasToken;
                    }" duration="10" />
                <cache-lookup-value key="crmsbsas" variable-name="cachedSasToken" />
            </when>
        </choose>
        <set-header name="Authorization" exists-action="override">
            <value>@(context.Variables.GetValueOrDefault<string>("cachedSasToken"))</value>
        </set-header>
        <set-header name="Content-type" exists-action="override">
            <value>application/json</value>
        </set-header>
        <set-header name="Ocp-Apim-Subscription-Key" exists-action="delete" />
        <set-header name="BrokerProperties" exists-action="override">
            <value>@{
               string reqData = context.Request.Body?.As<string>(true);
               dynamic data =  JsonConvert.DeserializeObject(reqData);
               string order =  data?.CustomerNumber;
               return string.Format("{{\"SessionId\":\"{0}\"}}", order);
            }</value>
        </set-header>
    </inbound>
    <backend>
        <base />
    </backend>
    <outbound>
        <base />
    </outbound>
    <on-error>
        <base />
    </on-error>
</policies>

Now lets use Postman to send a message to the URL endpoint exposed by APIM to test the policy. The headers contain the APIM subscription key and a custom header for the ‘MsgType’ which will be used for the Service Bus subscription filter.

The message body simply contains the Customer number and the amount to deposit.

After posting the message to the APIM endpoint URL, we can see the message was successfully forwarded to the Service Bus by using Service Bus Explorer to view the message properties and content.

Notice the message custom properties has the MsgType and the ‘SessionId’ is populated with the customer number.

Enjoy…

Scenario

Configuration Walkthrough

Registering the Service API

Registering the Client App

Requesting an OAuth Token

Share this:

Like this:

Scenario

Configuration Walkthrough

1. Adding a VNet Subnet

2. Provisioning App Svc Plan

3. Provisioning Web App

4. Enable VNet Integration

5. Validating SQL Server Security Settings

6. Testing connectivity

7. Updating the Web App SQL Connection String

Conclusion

Share this:

Like this:

Typical Scenario

Conclusion

Share this:

Like this:

Share this:

Like this:

Share this:

Like this:

Share this:

Like this:

Azure Function Code

Logic App Implementation

Blob creation event configuration

Sample Logic App output

Share this:

Like this:

Solution

Pros

Cons

Share this:

Like this:

An Alternative Approach

Implementation

Testing

Share this:

Like this:

Share this:

Like this: