This course will provide a deep and thorough understanding of the brokered messaging capabilities of the Azure Service Bus. Messaging scenarios will be covered, along with the Service Bus functionality. The sending and receiving of messages will be covered before going into more depth on the more advanced features such as message sessions, duplicate detection and dead-lettering. The course will round off by covering how to provide granular security on the Service Bus.
Alan Smith is a Windows Azure developer, trainer, mentor and evangelist at Active Solution in Stockholm. He has a strong hands-on philosophy and focusses on embracing the power and flexibility of cloud computing to deliver engaging and exciting demos.
Understanding the Azure Service Bus In this module, we'll cover the basics of the Azure Service Bus brokered messaging, and get an understanding of the Azure Service Bus. We'll first have a brief overview of the Microsoft Azure Service Bus. We'll then look at brokered messaging scenarios and look in more depth at Azure Service Bus brokered messaging with this course we'll focus on. We'll look at how we can use the Microsoft Azure Service Bus SDK, to program against the Azure Service Bus. We'll look at some real-world usage scenarios for the Azure Service Bus, and round off by looking at the Service Bus tier offering and pricing.
Managing Service Bus Namespaces & Artifacts This module is going to focus on Managing Service Bus Namespaces and Artifacts. We'll start off by getting an overview of Service Bus Namespaces, Queues, Topics, and Subscriptions. We'll then look at using tools to manage artifacts using the Azure portal and also Visual Studio. We'll then move on to look at managing artifacts with Code, which is often the preferable way to manage artifacts in the Service Bus.
Working with Messages In this module, we're going to be focusing on working with messages in the Azure Service Bus. We'll look in depth at what brokered messages are, and look at how they are comprised of a message header and a message body. We'll look at creating and sending messages, and how we can create messages from objects, streams, and also create event and control messages. We'll look at different ways of serializing messages, and how we can use JSON message serialization to have a more loosely coupled architecture that allows for cross-platform integration. We'll then look at receiving and processing messages and how we can do this efficiently using multi-threading and constrained concurrency. We'll round off the module by looking at Duplicate Message Detection and how we can handle duplicate messages on the Service Bus and provide an idempotent solution.
Publish-subscribe, Routing, & Correlation In this module, we're going to be looking at publish-subscribe messaging routing and message correlation. We'll start out by examining publish-subscribe messaging and seeing how it differs with point-to-point messaging. We'll then look at how we can use topics and subscriptions in the service bus to implement publish-subscribe messaging. We'll look at using rules and subscription filters to control how the subscriptions subscribe to messages. We'll then move on to look at message correlation and message sessions and see how we can use message sessions to implement request-response messaging.
Poison Messages, Dead Lettering, & Error Handling In this module, we're going to look at poison messages, dead-lettering and error handling in the Azure Service Bus. We'll start the module by looking at the kind of communication problems that we can have when working with distributed applications. We'll then take a look at transient fault handling and see how this can resolve some of the communication issues. We'll move on to look at dead-lettering, which is a feature of Azure Service Bus brokered messaging. We'll look at how we can identify poison messages and explicitly dead-letter those messages. We'll look at how we can specify an expiration time on messages and what happens to those messages when they expire. And we'll round off the module by looking at how we can monitor and manage dead-letter messages in a production service bus scenario.
Securing Service Bus Entities This section is going to look at securing service bus entities. Up until now, we've explored a lot of functionality in the service bus, but we haven't really been following any security best practices. So in this module, we're going to look at the security requirements that we have on working with distributed applications. We'll then look at working with shared access signatures in the Azure service bus.