Azure Event Grid with Custom Events

As of yesterday (16-8-2017) the public preview of Azure Event Grid is live. Azure Event Grid is a fully managed event routing service. Azure Event Grid greatly simplifies the development of event-based applications and simplifies serverless workflow creation. Using a single service, Azure Event Grid manages all routing of events from any source, to any destination, for any application.

Microsoft explains Azure Event Grid as follows:

“Azure Event Grid allows you to easily build applications with event-based architectures. You select the Azure resource you would like to subscribe to, and give the event handler or WebHook endpoint to send the event to. Event Grid has built-in support for events coming from Azure services, like storage blobs and resource groups. Event Grid also has custom support for application and third-party events, using custom topics and custom webhooks.

As explained above there is support for custom topics and webhooks. Setting up custom events needs the following within Azure.

 

Azure Event Grid

The Event Grid Topic is the Azure Service were the events are sent to, and the Subscriptions are the applications that need to receive the events. So let’s get this to work within Azure and Visual Studio.

Create the Event Grid Topic

First create the Event Grid Topic in Azure. With this topic we know were we need to send the events.

  1. Open the Azure Portal (https://portal.azure.com)
  2. Click on the “+” icon and search for “Event Grid Topic”.
  3. Click on “Create” to create the topic.
  4. Fill in the correct information and click on “Create”

Azure Event Grid Topic

You now have a Topic were events can be send too.

Sending Events to the Event Grid Topic

With the Topic in place the events can be send. In order to send events we need two things: the endpoint and the key from the topic. Both things are available on the Azure Event Grid Topic Blade.

  1. Open the Event Grid Topic Blade to find the Endpoint and Key of the Topic.

Event Grid Topic

The Endpoint is used to Post a request to and The key as an authentication to the topic and is placed in the header with the key: “aeg-sas-key”.

  1. The event itself needs should be in the form of a json message with specific properties. On the documentation site of Azure Event Grid you will find information on the schema: Event Grid event schema. Good to notice on the schema and the example provided is that the event is an array.
[
  {
    "topic": "/subscriptions/{subscription-id}/resourceGroups/Storage/providers/Microsoft.EventGrid/topics/myeventgridtopic",
    "subject": "/myapp/vehicles/motorcycles",    
    "id": "b68529f3-68cd-4744-baa4-3c0498ec19e2",
    "eventType": "recordInserted",
    "eventTime": "2017-06-26T18:41:00.9584103Z",
    "data":{
      "make": "Ducati",
      "model": "Monster"
    }
  }
]
subject string Path to the event subscription it is used for filtering and routing the requests
eventType string The event type
eventTime string The time the event is generated based on the provider’s UTC time. During testing I  needed to give a date time offset.
id string Unique identifier for the event. Can be a Guid provided as string value.
data object Your specific event data.
  1. Open Visual Studio and Create a new Console Application Project. In this project add the below code.
static void Main(string[] args) {
    var eventNew = MakeRequestEvent();
    eventNew.Wait();            
    Console.WriteLine(eventNew.Result.Content.ReadAsStringAsync().Result);

    Console.ReadKey();
}

private static async Task<HttpResponseMessage> MakeRequestEvent() {
    string topicEndpoint = "[endpoint]";
    var httpClient = new HttpClient();
    httpClient.DefaultRequestHeaders.Add("aeg-sas-key", "[key]");

    List<CustomEvent<Account>> events = new List<CustomEvent<Account>>();
    var customEvent = new CustomEvent<Account>();
    customEvent.EventType = "eventgridtest";
    customEvent.Subject = "/msft/test";
    customEvent.Data = new Account() { Name = "Maik", Gender = "Male" };
    events.Add(customEvent);

    string jsonContent = JsonConvert.SerializeObject(events);
    Console.WriteLine(jsonContent);

    var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");
    return await httpClient.PostAsync(topicEndpoint, content);            
}

The code above make an http post call to the topic endpoint with the key in the “aeg-sas-key” header.

The event (json) is placed in the body which is a serialized version of the CustomEvent object I created myself. This object has the default properties for an event. For the data every object could be used as it based on generics. The Accounts class used is a basic class with only a Name and Gender property.

public class CustomEvent<T> {

    public string Id { get; private set; }

    public string EventType { get; set; }

    public string Subject { get; set; }

    public string EventTime { get; private set; }

    public T Data { get; set; }

    public CustomEvent(){
        Id = Guid.NewGuid().ToString();

        DateTime localTime = DateTime.Now;
        DateTime utcTime = DateTime.UtcNow;
        DateTimeOffset localTimeAndOffset = new DateTimeOffset(localTime, TimeZoneInfo.Local.GetUtcOffset(localTime));
        EventTime = localTimeAndOffset.ToString("o");
     }
}

If the event is posted successfully the response will be empty.

Subscribing application

The subscribing application will be a simple web application with one API method. This method will add a custom event in Application Insights.

  1. Create a new project within Visual Studio make this a ASP.Net Web application.
  2. Use a API project as the template for the application.
  3. Add the Application Insights nuget package.
  4. Add a EventsController and add the below code.
public class EventsController : ApiController {
    // POST api/events
    public void Post([FromBody]List<CustomEvent<Account>> value) {
        foreach(var eventValue in value) {
            string data = JsonConvert.SerializeObject(eventValue);
            Dictionary<string, string> allData = new Dictionary<string, string>();
            allData.Add("event id", eventValue.Id);
            allData.Add("eventdata", data);

            TelemetryClient client = new TelemetryClient();
            client.TrackEvent("Event Received", allData);
        }
    }
}

This method reads the event from the body and places the data within Application Insights with the name Event Received.

  1. Publish the application to Azure and remember the endpoint of the API method [url]/api/events.

Configure the Event Grid Subscriber

With all applications in place the Event Grid Topic needs to know were to send the events to. For this an Event Grid Subscriber needs to be configured.

  1. Open the Event Grid Blade and click on Event Subscription.

Add Azure Event Grid Subscription

  1. Fill in the correct properties. The EventType property can be used to filter on the eventtype of the event. The prefix and suffix properties can be used to filter on the subject.

Create Event Grid Subscription

  1. Click on create to create the subscription.

Azure Event Grid with Subscription

The Test

With everything in place we can start using the Event Grid.

  1. Fire up the console application the application will give you the json message as output. If something goes wrong during the event you will see the error message within the console window.

Console Application

  1. Soon after triggering the event the entry will be visible within Application Insights.

image

Sample Project

The sample project used is added to GitHub:

https://github.com/MaikvanderGaag/MSFT-AzureEventGrid

Conclusion

Because almost every solution uses hammer polling within Azure the Azure Event Grid is a really good addition to the Azure Stack. Be aware that in enterprise messages scenario you still keep using the Azure Service Bus because that support dead lettering, transactions sessions and other great capabilities.

Hope to see a lot of steps forward the next weeks / months as this seems a great service.

Related Posts

Listing Azure Services within a CSV file In some situations you will look into a current Azure Environment and the setup/governance of it and need to migrate or move resources around. The ...
Removing the Classis Hybrid Connections from Azure (Azure BizTalk Service) As you know the classic hybrid connections that are build upon Azure BizTalk Services are deprecated. These connection will have to be replaced by the...
Restricting access to your Azure Web Application As you may know almost everything that is deployed to Azure is publicly available. As with Azure SQL Database you do not have a firewall available for...
Configure access to a private network for a Azure App Services On-Premise connections for Azure App Services can be created by using Hybrid Connections. Hybrid connections do not need any development or re-configu...
Extensions and Tips for deploying with Azure Resource Templates Working with Azure Services in different subscriptions means that the Azure Services need to run in different subscriptions. This often occurs when we...
Part 2 – Azure API Application to query the Azure SQL Database This post is the second in a series of three posts and will help you with the creation of identity pass-through authentication from a client applicati...

Leave a Reply

Your email address will not be published. Required fields are marked *