Damir Dobric Posts : Architecture and Modeling, AppFabric, cloud

Power of Windows Azure PaaS: State Share and Persistence in the cloud

Damir Dobric — Mon, 22 Apr 2013 13:00:00 GMT

If you are experienced enterprise developer who targets the Microsoft platform, you have probably at least once in your have a requirement to share some state across different instance of an application.
But, if you are hobby developer or any other professional developer, who possible do not focus distributed systems, you will might find the term “State” in context of persistence a pure theory thing.
So who ever you are, let’s start with a simple theory thing.
Imaging you have in theory a trivial application (today I call such applications simply “apps”). Assume this is an app running on smart phone or any other mobile device. This app has a variable ‘A’ and value assigned to this variable ‘1’. This value is not the default value. It is rather the value which user has assigned at some point of time.

Now, imagine the application crashes and you start it again. The value of variable A is obviously lost. If you want to keep this value somewhere, so it can be loaded even if application crashes. We call that usually persistence. Depending on application and your skill, there are several ways to persists the value of an variable. For example you can use any kind of local cache, like a file system.

But what if your application has to survive the hardware damage? Or what if your application is consisted multiple clients which have to share the same value? In this case you will have to use some kind of database.
As long you are in control of your infrastructure (means application is deployed in your enterprise) you can use some database to persist the value. The good example of this is Workflow Foundation. Long running processes require by default the state persistence.
Unfortunately we have more often scenarios where applications are distributed across the web. In such cases the only sharing artifact between such applications is the cloud. Following picture shows how two apps (or applications) share their state through the cloud.

This is a nice theoretical case which is practically a horror to implement. I strongly believe that today we are implicitly preparing for dominance of devices in the web. In this hypothetical scenario both devices (see picture above) should act as services to be able to share their state. If you are distributed application or integration developer you know that connectivity us such scenarios is a big, big issue. Or simply, it is the fact, devices in the web have a private IP address and because of that they are not reachable by anybody. So if the microscope on the left cannot reach the smart-phone on the right, the state from left to right cannot be propagated and vice versa.

If this to theoretical to you, imagine just a service which is running distributed across cloud. This might be WCF service, Windows Service (running in SCM) or even Web Api based service. Whatever technology you peek, it does not matter. The only important thing is that you want run multiple instances of the service, but on two machines which are not in the same environment (if they are in the same environment even better). So that means, independent on a case, devices or services or both, we have the same requirement:

1. Sharing of the state between applications distributed in the web
2. Persisting of the state without database.

You believe or not, this problem can be solved by using Windows Azure Service Bus, which in this case plays a role of cloud artifact. To illustrate how this can work, take a look on following example.
This is a console application in C#. The state which should be shared and persisted across many applications is stared in variable State.

class Program{

public static WebState<string> State { get; set; }

static void Main(string[] args)
{

State = new WebState<string>(ConfigurationManager.AppSettings["SbConnStr"], "BusinessDomain", ConfigurationManager.AppSettings["Node"]);

           State.StateChanged += State_StateChanged;

            Console.WriteLine("I'm node with name: " + ConfigurationManager.AppSettings["Node"]);

Console.WriteLine("Running with state: {0}", State.Value);

           while (true)
            {
                State.Value = Console.ReadLine();
            }
        }

        static void State_StateChanged(object sender, WebStateEventArg<string> e)
        {
            Console.WriteLine("State changed by {0} at value: {1}", e.InstanceName, e.NewValue);
        }

}

As you see this variable is of type WebState, which is implemented by me. When you start this application, enter some text on the console. The text will be immediately persisted in the cloud after following line of code is executed:

State.Value = …

Now stop the application gracefully and start it again. You will notice that application write out the value which was as last one persisted. In fact event with one participant in the system you have achieved the persistence.
The magic behind this is implemented on top of Windows Azure Service Bus queues. Each time the value is changed, the WebState implementation receives the existing message from the queue and put back the new message in the queue which basically holds the serialized value of variable State, and so on. Because access to the queue is session based, Service Bus guaranties that no any other applications which shares this value, will access the queue in the same time. I don’t want to call this distributed transaction, but it behaves in persistence this scenario like it would be one. In fact the WebState class uses the Queue as a unit of storage. By reading and immediate writing back of the new value, it is guarantied that the queue holds one and only one message all the time.
Following picture illustrate this. Each time the value i changed the old value is stored in the queue as a message. The old value is received from queue and the new message with new value is sent to the queue. At the end the old one is completed, because PeekAndLock receive is used.When the new instance of the State is created (for example when application is started) the same cycle with receive/send is done. This is how multiple applications obtain there actual state.

Additionally the implementation of the WebState takes a care about state sharing. For this purpose there is a topic used to share state changes. All participants in this distributed system have to create a subscription on that topic.
In this case (see picture below) the new value is published as a message to the topic. After that all subscribers can receive the message with the new value. The publishing process additionally updates the new value in the persistence queue from previous example.

Because topic-subscriptions are used, the application which was not running for a while, will automatically receive all state changes which have happened in the mean time.

This examples shows how complex patterns can be implemented by using connectivity service in Windows Azure. I know that majority of people out there still think a..bout cloud as an old thing. There is also a group of people who thinks that cloud is unsafe think to keep the data. If you are one them them please rethink your thinking. The scenario and solution shown above is a new way of thinking and using cloud services. And the nice think here is that practically no real data is stored in the cloud.
As you see, the cloud is more than solely putting of some application online. :)

The code for this will be published soon.

How to sign up for preview features?

Damir Dobric — Sat, 09 Jun 2012 10:08:20 GMT

Windows Azure “spring release” 2012 provides few new features: like media service, virtual machine (with real persistence), and Web Sites.

Media Services

Windows Azure Media Services enable solution providers and content owners to build end-to-end workflows for the creation, management, and distribution of media. Combining core components of the Microsoft Media Platform, Media Services include Encoding, Format Conversion, Content Protection, On-Demand Streaming, and Live Streaming. Solutions built on Media Services offer the flexibility, scalability, and reliability to deliver high quality media experiences to a global audience.

Virtual Machines & Virtual Networks

Easily deploy and run Windows Server and Linux virtual machines in Windows Azure. Windows Azure Virtual Machines allow you to migrate applications and infrastructure without having to change existing code. You can also create your own virtual private networks (VPNs) in Windows Azure and securely connect them to on-premises IT infrastructure with Windows Azure Virtual Network. You can extend your on-premises networks into the cloud with control over network topology, including configuration of IP addresses and DNS.

Web Sites (also called Web Site as a Service)

Quickly and easily deploy sites to a highly scalable cloud environment with the frameworks and open source apps of your choice using Windows Azure Web Sites. Get started for free and scale as you go on a cloud platform that enables automatic scale-out options across shared and reserved instances for greater isolation and performance.

If you like to take a look on the preview: https://account.windowsazure.com/PreviewFeatures

WinDays 2012 KeyNote Demo Step Through

Damir Dobric — Sat, 12 May 2012 11:54:46 GMT

Few days ago I showed the Demo at WinDays 2012 keynote under the name “SharePoint Ralay”. The idea of the keynote was to show some important features which never have been shown or documented in the way as of very one common industry scenario. To keep things simple we didn’t go to deep into details of SharePoint and ServiceBus. We wanted to to build a demo which will show how to build few complex and enterprise relevant scenarios, but to be in the same time interesting for most developers in audience and even for journalists who have been attending the key note.
So I decided to target three common industrial issues which daenet has been asked to solve multiple times during 2011:

1. How to get (or put) SharePoint data out of enterprise without changing of infrastructure?
2. How to build dynamic WCF contract?
3. How to build Failover cluster in 48 Seconds?

1. How to get/put data out of SPS without changing of infrastructure?

Most SharePoint Developers live in their collaborative context which mostly does not require such scenarios. But when building SharePoint solutions you will figure out that SharePoint isn’t application platform in term how one solution or enterprise architect expect to be. Today, complex systems are systems which consist of usually distributed and hybrid hybrid applications.Distributed means they at least do not run in one process and hybrid means they can be build on top of different technologies.
So, imagine now one application which is build in .NET 4.5 which should run in SharePoint. To make it more simpler image a JAVA application which runs at different machine on different geographic location. Now put it in SharePoint and let talk to each other. Application Platform is the platform which enables to do such things. Any other application platform like SharePoint, CRM, BizTalk or anything else is a platform of their own definition with huge limitations. Because of that be careful, when you say platform. “One can be a boss in his village, but just some little peace in the global world”. The part of Microsoft which build such platforms is called Business Platform Division.

So, let’s get now some data out of SharePoint in context of distributed application scenario. First of all in the world of distributed thinking, you should never allow external parties get in touch with your platform directly. To illustrate this constraint, think on giving the public access to your database. You will probably never allow somebody to send you DB-commands which will be executed against your DB (SQL Injections etc..). If you do it it is wrong and please think change it.. By following the same rule you shouldn’t let anybody to dig in your SharePoint platform for the same reason. You even should not share the secret, that you platform is SPS.

The easiest way is to provide some kind of intermediary component which will abstract the business scenario over secret platform which is running in the background. The technology which does exactly this job is WCF. We will put WCF service between SPS and external party. At some point of time when you have lot of such services, you can start to talk about Middle-Ware. This is a fine solution, but there is a still one practical problem.

The service contract could look in our case as shown below:

[ServiceContract(Name = "EchoContract", Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
public interface ISpsRelayService
{
[OperationContract]
List<MyEntity> Query(QueryEntity query);
}

You should define the QueryEntity which somehow describes what you want. SPS developer would like to to see here probably SPS- “ClientObjects”. Unfortinatelly they have never been designed for such scenarios. They can only be used by explicit helper libraries. Such libraries do not work out of SharePoint and their dependent entities are not serializable.
But never mind, define your entities like your business needs them (see service contract above).

The service implementation (see code below) will read the QueryEntity instance and build appropriate SPS-query (not shown in the demo below).
After all we will call SPS WebService hosted internally in our enterprise at http://yourhost:44445 and finally build response as collection of MyEntity instances.
This service decouples the SPS from external parties and provides very simple and business related contract as usual in the SOA world.
Following code snippet shows how to implement the service which gets documents from some SharePOint library and returns them as collection to the external party. In fact this is nothing very complicated (not yet)..

public List<MyEntitity> Query(QueryEntity query)
{
ClientContext clientContext = new ClientContext("http://yourhost:44445");

            Web oWebsite = clientContext.Web;
            var files = oWebsite.GetFolderByServerRelativeUrl("/Shared%20Documents").Files;
            clientContext.Load(files);
            clientContext.ExecuteQuery();

List<MyEntitity> items = new List<MyEntitity>();

            foreach (var doc in files)
            {
                dynamic o = new MyEntitity();
                o.Name = doc.Name;
                o.Something = DateTime.Now.Ticks;
                o.Version = doc.UIVersionLabel;

items.Add(o);
}

return items;
}

To make it available in the internet this service needs to have a public endpoint accessible by the external party. And exactly this is the change demand in infrastructure which is very, very often an organizational issue or even “No go”. First somebody hast to give you an public IP address, then you need to configure NAT and DNS for it, then Security, port mapping from probably 80 to 4445 etc., etc..
I want to build some kind of VPN between my WCF (talking to SPS) and external caller, but without changing any piece of infrastructure. The next picture shows this scenario. Windows Azure provides a platform service called “Service Bus”. This one provides a feature called relying. Relaying can connect two participants directly thorough firewall. Two participants are connected through Service Bus intermediary by using bidirectional TCP connection, which remains open after once is established.

Following code shows how to start-up the service which will listen on Service-Bus packets and relay SharePoint to external caller.

static void Main(string[] args)
{
ServicePointManager.ServerCertificateValidationCallback = validateServerCert;

           // create the service URI based on the service namespace which you will obtain when creating the
           // service bus namespace.
          Uri address = ServiceBusEnvironment.CreateServiceUri("https", serviceNamespaceDomain, "SpsRelayService/DocumentLibrary");

          // create the credential object for the endpoint
          TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
          sharedSecretServiceBusCredential.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);

// create the service host reading the configuration
ServiceHost host = new ServiceHost(typeof(SpsRelayService), address);

          // create the ServiceRegistrySettings behavior for the endpoint
          IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings()
{ DisplayName = "Sharepoint Relay Document Library Service", DiscoveryMode = DiscoveryType.Public };

          foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
          {

               // add the Service Bus credentials to all endpoints specified in configuration
             endpoint.Behaviors.Add(sharedSecretServiceBusCredential);

             // Optionally you can add the URI in the registry.
             endpoint.Behaviors.Add(serviceRegistrySettings);
          }

// Open the service
host.Open();

Console.ForegroundColor = ConsoleColor.Cyan;

          Console.WriteLine("Service address: " + address);
          Console.WriteLine("Press [Enter] to exit");
          Console.ReadLine();

          // close the service
          host.Close();
      }

Similarly, external party will also establish the connection as shown in the next snippet:

static void Main(string[] args)
{
ServicePointManager.ServerCertificateValidationCallback = validateServerCert;

// create the service URI based on the service namespace
Uri address = ServiceBusEnvironment.CreateServiceUri("https", serviceNamespaceDomain, "SpsRelayService/DocumentLibrary");

           // create the credential object for the endpoint
           TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
           sharedSecretServiceBusCredential.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);

// create the channel factory loading the configuration
ChannelFactory<ISpsRelayService> channelFactory = new ChannelFactory<ISpsRelayService>("RelayEndpoint", new EndpointAddress(address));

// apply the Service Bus credentials
channelFactory.Endpoint.Behaviors.Add(/*swtBehavior*/sharedSecretServiceBusCredential);

           // create and open the client channel
           ISpsRelayService channel = channelFactory.CreateChannel();

           ((ICommunicationObject)channel).Open();

           Console.WriteLine("Enter text to echo (or [Enter] to exit):");

           string input = Console.ReadLine();

           List<MyEntity> res = channel.Query(new QueryEntity(){…});

            ((ICommunicationObject)channel).Close();

           channelFactory.Close();
       }

If you ever worked with WCF there is not much more to say. The code shown above contains a bit sugar around standard WCF.Everything else is a matter of channel which is hidden behind RelayBinding. For more information about ports in use take a look here.
Following binding must be configured in both service and client.

After you start service and then client,the client will send the request to service through firewall. The service will get data out of SPS and relay it back to the client.

2. How to build dynamic WCF contract?

In the world of SOA you always should build a clear contract between two boundaries. That means contracts like following one are not well designed:

Message Operation(Message msg);

I have also seen in some projects following variant of the similar contract, which is semantically the same one as previous one:

string Operation(string msg);

By using such contract the client has no way to know how to serialize the message. Even after the service version is changed, there is no way to communicate this to anybody instead of verbal human communication which is time intensive and error prone. Compare it with “add service reference” to create the proxy. The client and service must in such cases implement code which serializes/deserializes respectively the message (string).
In other words, using service contracted this way is called “Anti-Pattern”, which should not be used in the SOA world.

Many developers think they can build SOA solution if they are just able to build WCF based service. This is a mistake. When you use WCF it doesn’t mean at all that you are by default SOAP capable. In our scenario I will use out this fact as my advantage. Connecting external party to our relay service is not SOA focused scenario. It is more about classical EAI and not SOA. Such kind of connecting system is known as interface with point-to-point connection. This is also not the best pattern in the world of SOA (I mean point2point interface). and it should b e avoided when building middle-wares. But this is another story.

In other words, If you are connecting two systems as point2poin it might be valid to apply SOA anti-pattern.This is in context of SOA an anti-pattern, but not an anti-pattern in universe of possible solutions. If you have two parties talking to each other then you can often change the contract between them without of too much organizational difficulties.If you are changing often the contract (in our case MyEntity and MyQuery) it is easier to make it dynamic. In this case you can build it once without need to change it in the future, because it is dynamic one. Following example shows how to use ExpandoObject to build dynamic WCF contract. If you don’t know what this is take a look on Alexandra’s and Rick’s posts.

ServiceContract(Name = "SpsRelayContract", Namespace = "http://daenet.deServiceModel/Relay/")]
public interface ISpsRelayService
{
[OperationContract]
List<ExpandoObject> Query(ExpandoObject expression);
}

The good thing on Expando-contract is that you can do something like this:

dynamic o = new ExpandoObject();
               o.Name = “bla bla”;
               o.Something = DateTime.Now.Ticks;
               o.Method= new SomeDelegate(someMethod);

You can set on this object whatever property you want (more or less). But note in a case of WCF the method instance as property wouldn’t make a sense, because that instance will not exist on some other process and some other machine. However all other properties can be set as you like. And WCF will serialize them automatically for you. In other words, if you have a new property you don’t have to change contract. You just set it like:

o.NewPropery = 17;

The consumer of this value just hast to know that is there (because,. remember, there is not clear contract, Add-Reference or SVCUTIL).

As a recap, note that ExpandoObject provides a dynamic contract. Build your Service on top of this entity and you will not have to change the contract when new properties are added in the business scenario, which service implements. Remember that this is not a SOA capable solution, but it is valid to build Point-To-Point scenarios when one party is connecting to another one.

3. How to build Failover cluster in 48 Seconds?

Last but not least I there is an issue which has been mostly forgotten in almost all our discussion when building relaying scenarios. I every project you will reach a point when the solution has to be deployed in the production. Then you will ask yourself how to build redundancy based on relying? This means, you want to provide a fail-over instance of you WCF relaying service which will be used when the first one is not reachable. The picture shown bellow illustrates this requirement.

To make this working you really do not have to change any peace of infrastructure. Just start the another instance of the service on another machine. That’s all. This will work by using both protocols TCP and HTTP. There are currently few undocumented differences in routing when using different protocols, nut in general both will provide you the stable and reliable fail-over mechanism.

Remark: If you are demoing this scenario with both WCF-instances on one machine, the basicHttpRelayBinding will not work with out-of-the-box configuration, because both instances will try to start listening for contract sharing at the same address. In a case of netTcpRelayBindig this will not happen. So, the latter one can be started multiple timas at one box.

Thanks to Tomislav Tipuric director of WinDays technical track who has visionary recognized the industry need for this scenario.

Agenda for WinDays 2012 Session: Solution Architectures for Cloud, None-Cloud and Hybrid Applications Part II

Damir Dobric — Sun, 22 Apr 2012 16:34:04 GMT

WHEN: 25.04.2012. 17:15 - 18:00h
WHERE: Rovinj - HALL 4

In this session you will learn about new possibilities around number of Windows Azure Services which provide new possibilities for applications running On-Premise, in the cloud or both. This demo-powered session will focus on powerful solution architecture patterns around Relaying, Tunneling, brokering with Message Queue, Topics and more.
Note that this is not Windows Azure session only. It shows platform services and new possibilities which can be achieved.The session is designed for Windows and Windows Azure developers and architects, which need to build new kind of applications with new building blocks. Even more, we will also focus on development of applications which do not run in the cloud, but make usage of Windows Azure services.

Focus of session are advanced solution architectures of hybrid and/or distributed applications which run on-premise in the cloud or both.
The coding related content is level 300 and architecture related topics might be higher like 400.

On WinDays Portal:: http://www.windays.hr/hr/raspored/technology/

Follow: http://twitter.com/#!/ddobric

Agenda for WinDays 2012 Session: Solution Architectures for Cloud, None-Cloud and Hybrid Applications Part I

Damir Dobric — Sat, 21 Apr 2012 17:57:50 GMT

WHEN: 25.04.2012. | 16:10 - 16:55h
WHERE: Rovinj - HALL 4

In this session you will start to talk about need for new platform service and cloud at all. The we will take a look on a number of new possibilities around Windows Azure Platform Services which provide new possibilities for applications running On-Premise, in the cloud or both.

This demo-powered session will focus on new solution architectures based on componets like Caching, Storage and Access Control. We will see how these services work and how they can be used as components of modern applications.

Focus of session are advanced solution architectures of hybrid distributed applications which run on-premise in the clod or both.

Follow or recommend content on my blog:
http://developers.de/blogs/damir_dobric/archive/2012/04/21/agenda-for-windays-2012-session-solution-architectures-for-cloud-none-cloud-and-hybrid-applications.aspx

On WinDays Portal:: http://www.windays.hr/hr/raspored/technology/

Follow: http://twitter.com/#!/ddobric

Microsoft Network 2: Get Ready for Windows Azure

Damir Dobric — Tue, 13 Mar 2012 22:11:17 GMT

Announcing the session about Solution Architectures for Cloud, None-Cloud and hybrid applications. n this session you will learn about new possibilities around number of Windows Azure Services which provide new possibilities for applications running On-Premise, in the cloud or both. This demo-powered session will focus on powerful solution architecture patterns around Caching, Remoting, Tunneling, Relaying, brokering with Message Queue, Topics and more. The focus of session is not only development of Cloud applications. Even more, we will also focus on development of applications which do not run necessarily in the cloud, but make usage of Windows Azure services and related patterns.

The session content targets every Windows and also none- Windows developers and architects who want to get ready for cloud.
Key messages:

- Learn how to design On Premise, Cloud and Hybrid applications
- See how new communication styles can be applied to set right solution architecture for cloud, none-cloud and hybrid applications
- Prepare to build On Premise applications today, which can run in Cloud tomorrow

When: 05.04.2012 09.00 – 10.00h
Add to your calendar.