Windows Azure:

• Compute @ $0.12 / instance hour
• Storage @ $0.15 / GB / month stored
• Storage Transactions @ $0.01 / 10K

SQL Azure:

• Web Edition – Up to 1 GB relational database @ $9.99
• Business Edition – Up to 10 GB relational database @ $99.99

.NET Services:

• Messages @ $0.15/100K message operations , including Service Bus messages and Access Control tokens

Bandwidth across all three services will be charged at $0.10 in / $0.15 out / GB

You can get the full information from here.

This class of service allows IT to reduce both the capex and resource challenges associated with the fluctuating infrastructure requirements of development teams. Developers are able to use the vCloud Express service at their convenience to address various infrastructure and programming needs such as experimentation, prototyping and testing. The vCloud Express service retains the robustness, interoperability and reliability that VMware is known for.

vCloud Partner Ecosystem, which includes the ISV and open source community has taken note of our investment in vCloud and is integrating key solutions with the VMware vCloud API as part of innovative services from VMware vCloud Express providers. For example, we now have available both Java and Python software development kits (SDKs) for the vCloud API, making it easier for developers and ISVs to jumpstart their projects by flexibly leveraging private and public cloud services via the vCloud API.

When you deploy an application to Microsoft SQL Azure Database, you may need to migrate a database from an on-premises instance of SQL Server to SQL Azure. This topic shows how to migrate a simple database to SQL Azure by using Transact-SQL scripts.

SQL Azure supports a subset of the Transact-SQL language. You must modify the generated script to only include supported Transact-SQL statements before you deploy the database to SQL Azure.

Create the Transact-SQL Script

1. In Object Explorer, right-click the School database, point to Tasks, and select Generate Scripts.
2. In the Script Wizard dialog box, click Next to get to the Select Database step. Select School, select Script all objects in the selected database, and then click Next.
3. In Choose Script Options, set the following options:
   • Convert UDDTs to Base Types = True
   • Script Extended Properties = False
   • Script Logins = False
   • Script USE DATABASE = False
   • Script Data = True

SQL Azure does not support user-defined data types, extended properties, Windows authentication, or the USE statement.

1. Click Next, click Next, and then click Finish. The Script Wizard generates the script. Click Close when the script is completed.
2. In the generated script, delete all instances of “SET ANSI_NULLS ON”.
3. Each CREATE TABLE statement includes a “WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]” clause. Delete all instances of that clause.
4. Each CREATE TABLE statement includes the “ON [PRIMARY]” clause. Delete all instances of that clause.

There is also no manager application currently available from the Azure Team to help you migrate databases or even create databases at the moment. You can’t use SQL Server Management Studio fully via the Object Explorer at this time either.

One of the solutions available that is pretty good IMHO is the free SQL Azure Migration Wizard on CodePlex that will attempt to migrate a SQL Server 2005 or SQL Server 2008 database to SQL Azure. You pick the items you want to migrate and the wizard will show any warnings and/or move the database ( schema not data ) to SQL Azure.

I had a really simple database I wanted to copy last night and it did an excellent job. However, this was indeed a simple database just for testing SQL Azure via ASP.NET MVC, etc.

That being said, however, if you are just getting started with SQL Azure, the SQL Azure Migration Wizard is a good and simple place to start for making that first test database.

You can download the SQL Azure Migration Wizard from CodePlex here.

At the consumer end, small startup companies found Cloud computing can significantly reduce their initial setup cost. Large enterprises also found Cloud computing allows them to improve resource utilization and cost effectiveness, although they also have security and control concerns.

Traditional software companies who distributes software on CD also look into the SaaS model as a new way of doing business. However, a SaaS model typically requires the companies to build some kind of web site. But these companies may not have the expertise to build large scale web sites and operate it. Cloud computing also allows them to outsource the SaaS infrastructure.

Here we look at the leader in the cloud computing provider space. AWS from Amazon.

Amazon Web Service

Amazon is the current leading provider in the Cloud computing space. At the heart of its technology stack (which is known as the Amazon Web Services), it includes an IaaS stack, a PaaS stack and a SaaS stack.

1. Their IaaS stack includes infrastructure resource such as virtual machine, virtual mount disks, virtual network, load balancer, VPN, Databases.
2. Their PaaS stack provides a set of distributed computing services including queuing, data storage, metadata, parallel batch processing,
3. Their SaaS stack provides a set of high level services such as content delivery network, payment processing services, ecommerce fulfillment services.

Since we are focusing in the Cloud Computing aspects, we will describe their IaaS and PaaS stack below but will skip their SaaS stack.

EC2 – Elastic Computing

Amazon has procured a large number of commoditized Intel boxes running virtualization software Xen. On top of Xen, Linux or Windows can be run as the guest OS . The guest operating system can have many variations with different set of software packages installed.

Each configuration is bundled as a custom machine image (called AMI). Amazon host a catalog of AMI for the users to choose from. Some AMI is free while other requires a usage charge. User can also customize their own setup by starting from a standard AMI, make their special configuration changes and then create a specific AMI that is customized for their specific needs. The AMIs are stored in Amazon’s storage subsystem S3.

Amazon also classifies their machines in terms of their processor power (no of cores, memory and disk size) and charged their usage at a different rate. These machines can be run in different network topology specified by the users. There is an “availability zone” concept which is basically a logical data center. “Availability zone” has no interdependency and is therefore very unlikely to fail at the same time. To achieve high availability, users should consider putting their EC2 instances in different availability zones.

“Security Group” is the virtual firewall of Amazon EC2 environment. EC2 instances can be grouped under “security group” which specifies which port is open to which incoming range of IP addresses. So EC2 instances that running applications at various level of security requirements can be put into appropriated security groups and managed using ACL (access control list). Somewhat very similar to what network administrator configure their firewalls.

User can start the virtual machine (called an EC2 instance) by specifying the AMI, the machine size, the security group, and its authentication key via command line or an HTTP/XML message. So it is very easy to startup the virtual machine and start running the user’s application. When the application completes, the user can also shutdown the EC2 instance via command line or HTTP/XML message. The user is only charged for the actual time when the EC2 instance is running.

One of the issue of extremely dynamic machine configuration (such as EC2) is that a lot of configuration setting is transient and does not survive across reboot. For example, the node name and IP address may have been changed, all the data stored in local files is lost. Latency and network bandwidth between machines may also have changed. Fortunately, Amazon provides a number of ways to mitigate these issues.

• By paying some charge, user can reserve a stable IP address, called “elastic IP”, which can be attached to EC2 instance after they bootup. External facing machine is typically done this way.
• To deal with data persistence, Amazon also provides a logical network disk, called “elastic block storage” to store the data. By paying some charges, EBS is reserved for the user and it survives across EC2 reboots. User can attach the EBS to EC2 instances after the reboot.

EBS – Elastic Block Storage

Based on RAID disks, EBS provides a persistent block storage device for data persistence where user can attach it to a running EC2 instance within the same availability zone. EBS is typically used as a file system that is mounted to EC2 instance, or as raw devices for database.

Although EBS is a network devices to the EC2 instance, benchmark from Amazon shows that it has higher performance than local disk access. Unlike S3 which is based on eventual consistent model, EBS provides strict consistency where latest updates are immediately available.

CloudWatch — Monitoring Services

CloudWatch provides an API to extract system level metrics for each VM (e.g. CPU, network I/O and disk I/O) as well as for each load balancer services (e.g. response time, request rate). The collected metrics is modeled as a multi-dimensional data cube and therefore can be queried and aggregated (e.g. min/max/avg/sum/count) in different dimensions, such as by time, or by machine groups (by ami, by machine class, by particular machine instance id, by auto-scaling group).

This metrics is also used to drive the auto-scaling services (described below). Note that the metrics are predefined by Amazon and custom metrics (application level metrics) is not supported at this moment.

Load Balancing Services

Load balancer provides a way to group identical VMs into a pool. Amazon provides a way to create a software load balancer in a region and then attach EC2 instances (of the same region) to the it. The EC2 instances under a particular load balancer can be in different availability zone but they have to be in the same region.

Auto-Scaling Services

Auto-scaling allows the user to group a number of EC2 instances (typically behind the same load balancer) and specify a set of triggers to grow and shrink the group. Trigger defines the condition which is matching the collected metrics from the CloudWatch and match that against some threshold values. When match, the associated action can be to grow or shrink the group.

Auto-scaling allows resource capacity (number of EC2 instances) automatically adjusted to the actual workload. This way user can automatically spawn more VMs as the workload increases and shutdown the VM as the load decreases.

Relational DB Services

RDS is basically running MySQL in the EC2.

S3 – Simple Storage Service

Amazon S3 provides a HTTP/XML services to save and retrieve content. It provides a file system-like metaphor where “objects” are group under “buckets”. Based on a REST design, each object and bucket has its own URL.

With HTTP verbs (PUT, GET, DELETE, POST), user can create a bucket, list all the objects within the bucket, create object within a bucket, retrieve an object, remove an object, remove a bucket … etc.

Under S3, each object has a unique URI which serves as its key. There is no query mechanism in S3 and User has to lookup the object by its key. Each object is stored as an opaque byte array with maximum 5GB size. S3 also provides an interesting partial object retrieval mechanism by specifying the ranges of bytes in the URL.

However, partial put is not current support but it can be simulated by breaking the large object into multiple small objects and then do the assembly at the app level. Breaking down the object also help to speed up the upload and download by doing the data transfer in parallel.

Within Amazon S3, each S3 objects are replicated across 2 (or more) data center and also cache at the edge for fast retrieval.

Amazon S3 is based on an “eventual consistent” model which means it is possible that an application won’t see the change it just made. Therefore, some degree of tolerance of inconsistent view is required by the application. Application should avoid the situation of having two concurrent modifications to the same object. And application should wait for some time between updates, and also should expect all the data it reads is potentially stale for few seconds.

There is also no versioning concept in S3, but it is not hard to build one on top of S3.

SimpleDB – queriable data storage

Unlike S3 where data has to be looked up by key, SimpleDB provides a semi-structured data store with querying capability. Each object can be stored as a number of attributes where the user can search the object by the attribute name.

Similar to the concepts of “buckets “ and “objects” in S3, SimpleDB is organized as a set of “items” grouped by “domains”. However, each item can have a number of “attributes” (up to 256). Each attribute can store one or multiple values and the value must be a string (or a string array in case of multi-valued attribute). Each attribute can store up to 1K bytes, so it is not appropriate to store binary content.

SimpleDB is typically used as a metadata store in conjuction with S3 where the actual data is being stored. SimpleDB is also schema-less. Each item can define its own set of attributes and is free to add more or remove some attributes at runtime.

SimpleDB provides a query capability which is quite different from SQL. The “where” clause can only match an attribute value with a constant but not with other attributes. On the other hand, the query result only return the name of the matched items but not the attributes, which means subsequent lookup by item name is needed. Also, there is no equivalent of “order by” and the returned query result is unsorted.

Since all attribute are store as strings (even number, dates … etc). All comparison operation is done based on lexical order. Therefore, special encoding is needed for data type such as date, number to string to make sure comparison operation is done correctly.

SimpleDB is also based on an eventual consistency model like S3.

SQS – Simple Queue Service

Amazon provides a queue services for application to communicate in an asynchronous way with each other. Message (up to 256KB size) can be sent to queues. Each queue is replicated across multiple data centers.

Enterprises use HTTP protocol to send messages to a queue. “At least once” semantics is provided, which means, when the sender get back a 200 OK response, SQS guarantees that the message will be received by at least one receiver.

Receiving messages from a queue is done by polling rather than event driven calling interface. Since messages are replicated across queues asynchronously, it is possible that receivers only get some (but not all) messages sent to the queue. But the receiver keep polling the queue, he will eventually get all messages sent to the queue. On the other hand, message can be delivered out of order or delivered more than once. So the message processing logic needs to be idempotent as well as independent of message arrival order.

Once message is taken by a receiver, the message is invisible to other receivers for a period of time but it is not gone yet. The original receiver is supposed to process the message and make an explicit call to remove the message permanently from the queue. If such “removal” request is not made within the timeout period, the message will be visible in the queue again and will be picked up by subsequent receivers.

Elastic Map/Reduce

Amazon provides an easy way to run Hadoop Map/Reduce in the EC2 environment. They provide a web UI interface to start/stop a Hadoop Cluster and submit jobs to it.

Under elastic MR, both input and output data are stored into S3 rather than HDFS. This means data need to be loaded to S3 before the Hadoop processing can be started. Elastic also provides a job flow definition so user can concatenate multiple Map/Reduce job together. Elastic MR supports the program to be written in Java (jar) or any programming language (Hadoop streaming) as well as PIG and Hive.

Virtual Private Cloud

VPC is a VPN solution such that the user can extend its data center to include EC2 instances running in the Amazon cloud. Notice that this is an “elastic data center” because its size can grow and shrink when the user starts / stops EC2 instances.

User can create a VPC object which represents an isolated virtual network in the Amazon cloud environment and user can create multiple virtual subnets under a VPC. When starting the EC2 instance, the subnet id need to be specified so that the EC2 instance will be put into the subnet under the corresponding VPC.

EC2 instances under the VPC is completely isolated from the rest of Amazon’s infrastructure at the network packet routing level (of course it is software-implemented isolation). Then a pair of gateway objects (VPN Gateway on the Amazon side and Customer gateway on the data center side) need to be created. Finally a connection object is created that binds these 2 gateway objects together and then attached to the VPC object.

After these steps, the two gateway will do the appropriate routing between your data center and the Amazon VPC with VPN technologies used underneath to protect the network traffic.

Things to watch out

I personally think Amazon provides a very complete set of services that is sufficient for a wide spectrum of deployment scenarios. Nevertheless, there are a number of limitations that needs to pay attention to …

1. There are no Cloud standards today. Whatever choice made for a provider will imply some degree of lock-in to a vendor specific architecture. Amazon is no exception. One way to minimize such lock-in is to introduce an insulation layer to localize all the provider-specific API.
2. Cloud providers typically run their infrastructure on low-cost commodity hardware inside some data center with network connected between them. Amazon is not making their hosting environment very transparently and so it is not very clear how much reliability one can expect from their environment. On the other hand, the SLA guarantee that Amazon is willing to provide is relatively low.
3. Multicast communication is not supported between EC2 instances. This means application has to communicate using TCP point-to-point protocol. Some cluster replication framework based on IP multicast simply doesn’t work in EC2 environment.
4. EBS currently cannot be attached to a multiple EC2 instance at the same time. This means some application (e.g. Oracle cluster) which based on having multiple machines accessing a shared disk simply won’t work in EC2 environment.

(direct link here). This release supports Visual Studio 2008 SP1 and the upcoming Visual Studio 2010 RC.

What’s New

• Windows Azure Drive: Enables a Windows Azure application to use existing NTFS APIs to access a durable drive. This allows the Windows Azure application to mount a page blob as a drive letter, such as X:, and enables easily migration of existing NTFS applications to the cloud.
• OS Version Support: Allows a Windows Azure application to choose the appropriate Guest OS to run on in the cloud.
• Bug Fixes:

1. StorageClient: Expose account key from storage credentials, expose continuation tokens for pagination, reduce maximum buffer size for parallel uploads.
2. Windows Azure Diagnostics: Fix path corruption for crash dumps, OnDemandTransfer now respects LogLevelFilter.
3. VS 2010: Improved packaging performance.
4. VS 2010: Support for linked files in Web projects.
5. VS 2010: Support for ASP.NET web project web.config transformations.
6. Certificate selection lists certificates from LocalMachine\My instead of CurrentUser\My.
7. Right click on Role under Roles folder to select whether to launch the browser against HTTP, HTTPS or not at all.

Updated and additional samples are available at: http://code.msdn.microsoft.com/windowsazuresamples

Scalable: Scaling the application means maximizing concurrency and using application resources more efficiently—for example, optimizing locking duration, sharing pooled resources such as threads and network connections, caching reference data, and partitioning large databases.

Multi-tenant-efficient: When a user at one company accesses customer information by using a CRM application service, the application instance that the user connects to may be accommodating users from dozens, or even hundreds, of other companies—all completely unknown to any of the users. This requires an architecture that maximizes the sharing of resources across tenants, but that is still able to differentiate data belonging to different customers.

Configurable: If a single application instance on a single server has to accommodate users from several different companies at once, you can’t simply write custom code to customize the end-user experience—anything you do to customize the application for one customer will change the application for other customers as well. Instead of customizing the application in the traditional sense, then, each customer uses metadata to configure the way the application appears and behaves for its users. The challenge for the SaaS architect is to ensure that the task of configuring applications is simple and easy for the customers, without incurring extra development or operation costs for each configuration.

Software as a Service Maturity Model:

SaaS architecture has four maturity levels, whose key attributes are configurability, multi-tenant-efficiency, and scalability.  Followings are the four maturity levels:

Level 1 – Ad-Hoc/Custom: At the first level of maturity, each customer has its own customized version of the hosted application and runs its own instance of the application on the host’s server. Migrating a traditional non-networked or client-server application to this level of SaaS typically requires the least development effort and reduces operating cost by consolidating server hardware and administration.

Level 2- Configurable: The second maturity level provides greater flexibility through configurable metadata, so that many customers can use separate instance of the same application code. This allows the vendor to meet the different needs of each customer through detailed configuration options, while simplifying maintenance and updating of a common code base.

Level 3- Configurable, Multi-Tenant-Efficiency: The third maturity level adds multi-tenancy to the second level, so that a single program instance serves all customers. This approach enables more efficient use of server resources without any apparent difference to the end user. But ultimately comes up against limits in scalability.

Level 4- Scalable, Configurable, Multi-Tenant-Efficiency: The fourth and final SaaS maturity level adds scalability through a multitier architecture supporting a load-balanced farm of identical application instances, running on a variable number of servers. The provider can increase or decrease the system’s capacity to match demand by adding or removing servers, without the need for any further alteration of application software architecture.

So now it is right time to compare all the option available in market for cloud computing. Here is a good blog to compare Microsoft Azure vs. Google Apps vs. Amazon.

Related blogs:

Important tips on SQL Server programming model

Key benefits of SQL Azure

Tools and utilities support by SQL Azure

Introduction to SaaS architecture

How to migrate SQL Server database to SQL Azure database by using the generate script wizard

This walkthrough covers what I found to be the simplest way to get a sample up and running on Windows Azure that uses the Table Storage Service. It is not trying to be comprehensive or trying to dive deep in the technology, it just serves as an introduction to how the Table Storage Service works.

Please take the Quick Lap Around the Tools before doing this walkthrough.

Note: The code for this walkthrough is attached, you will still have to add and reference the Common and StorageClient projects from the Windows Azure SDK.

After you have completed this walkthrough, you will have a Web Role that is a simple ASP.Net Web Application that shows a list of Contacts and allows you to add to and delete from that list. Each contact will have simplified information: just a name and an address (both strings).

Table Storage Concepts

The Windows Azure Table Storage Services provides queryable structured storage. Each account can have 0..n tables.

Design of the Sample

When a request comes in to the UI, it makes its way to the Table Storage Service as follows (click for larger size):

The UI class (the aspx page and it’s code behind) is data bound through an ObjectDataSource to the SimpleTableSample_WebRole.ContactDataSource which creates the connection to the Table Storage service gets the list of Contacts and Inserts to, and Deletes from, the Table Storage.

The SimpleTableSample_WebRole.ContactDataModel class acts as the data model object and the SimpleTableSample_WebRole.ContactDataServiceContext derives from TableStorageDataServiceContext which handles the authentication process and allows you to write LINQ queries, insert, delete and save changes to the Table Storage service.

Creating the Cloud Service Project

1. Start Visual Studio as an administrator

2. Create a new project: File à New à Project

3. Select “Web Cloud Service”. This will create the Cloud Service Project and an ASP.Net Web Role. Call it “SimpleTableSample”

4. Find the installation location of the Windows Azure SDK. By default this will be: C:\Program Files\Windows Azure SDK\v1.0

a. Find the file named “samples.zip”

b. Unzip this to a writeable location

5. From the samples you just unzipped, add the StorageClient\Lib\StorageClient.csproj and HelloFabric\Common\Common.csproj to your solution by right-clicking on the solution in Solution Explorer and selecting Add à Existing Project.

a. Common and StorageClient and libraries that are currently distributed as samples that provide functionality to help you build Cloud Applications. Common adds Access to settings and logging while StorageClient provides helpers for using the storage services.

6. From your Web Role, add references to the Common and StorageClient projects you just added along with a reference to System.Data.Services.Client

7. Add a ContactDataModel class to your Web Role that derives from TableStorageEntity. For simplicity, we’ll just assign a new Guid as the PartitionKey to ensure uniqueness. This default of assigning the PartitionKey and setting the RowKey to a hard coded value (String.Empty) gives the storage system the freedom to distribute the data.

using Microsoft.Samples.ServiceHosting.StorageClient;

public class ContactDataModel : TableStorageEntity

{

    public ContactDataModel(string partitionKey, string rowKey)

        : base(partitionKey, rowKey)

    {

    }

    public ContactDataModel()

        : base()

    {

        PartitionKey = Guid.NewGuid().ToString();

        RowKey = String.Empty;

    }

    public string Name

    {

        get;

        set;

    }

    public string Address

    {

        get;

        set;

    }

}

8. Now add the ContactDataServiceContext to the Web Role that derives from TableStorageDataServiceContext.

a. We’ll use this later to write queries, insert, remove and save changes to the table storage.

using Microsoft.Samples.ServiceHosting.StorageClient;

internal class ContactDataServiceContext : TableStorageDataServiceContext

{

    internal ContactDataServiceContext(StorageAccountInfo accountInfo)

        : base(accountInfo)

    {

    }

    internal const string ContactTableName = “ContactTable”;

    public IQueryable<ContactDataModel> ContactTable

    {

        get

        {

            return this.CreateQuery<ContactDataModel>(ContactTableName);

        }

    }

}

9. Next add a ContactDataSource class. We’ll fill this class out over the course of the next few steps.  This is the class the does all the hookup between the UI and the table storage service. Starting with the first part of the constructor, a StorageAccountInfo class is instantiated in order to get the settings required to make a connection to the Table Storage Service. (note that this is just the first part of the constructor code, the rest is in step 12)

using Microsoft.Samples.ServiceHosting.StorageClient;

using System.Data.Services.Client;

public class ContactDataSource

{

    private ContactDataServiceContext _ServiceContext = null;

    public ContactDataSource()

    {

        // Get the settings from the Service Configuration file

        StorageAccountInfo account =
        StorageAccountInfo.GetDefaultTableStorageAccountFromConfiguration();

10. In order for the StorageAccountInfo class to find the configuration settings, open up ServiceDefinition.csdef and add the following to <WebRole/>. These define the settings.

    <ConfigurationSettings>

      <Setting name=”AccountName”/>

      <Setting name=”AccountSharedKey”/>

      <Setting name=”TableStorageEndpoint”/>

    </ConfigurationSettings> 

11. Likewise, add the actual local development values to the ServiceConfiguration.cscfg file. Note that the settings between both files have to match exactly otherwise your Cloud Service will not run.

• When you run in the Cloud, the AccountName and AccountSharedKey will be set to the values you will get back from the Portal for your account. The TableStorageEndpoint will be set the URL for the Table Storage Service: http://table.core.windows.net
• Because these are set in the ServiceConfiguration.cscfg file, these values can be updated even after deploying to the cloud by uploading a new Service Configuration.
• For the local development case, the local host and port 10002 (by default) will be used as the Table Storage Endpoint. The AccountName and AccountSharedKey are hard coded to a value that the Development Storage service is looking for (it’s the same for all 3, Table, Blob and Queue services).

    <ConfigurationSettings>

      <Setting name=”AccountName” value=”devstoreaccount1″/>

      <Setting name=”AccountSharedKey”
        value=”Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==”/>

      <Setting name=”TableStorageEndpoint”
        value=”http://127.0.0.1:10002/“/>
    </ConfigurationSettings>

12. Next, continue to fill out the constructor (just after the call to GetDefaultTableStorageAccountFromConfiguration ()) by instantiating the ContactDataServiceContext. Set the RetryPolicy that applies only to the methods on the DataServiceContext (i.e. SaveChanges() and not the query. )

    // Create the service context we’ll query against

    _ServiceContext = new ContactDataServiceContext(account);

    _ServiceContext.RetryPolicy = RetryPolicies.RetryN(3, TimeSpan.FromSeconds(1));

}

13. We need some code to ensure that the tables we rely on get created.  We’ll do this on first request to the web site — which can be done by adding code to one of the handlers in the global application class.  Add a global application class by right clicking on the web role and selecting Add -> New Item -> Global Application Class. (see this post for more information)

14. Add the following code to global.asax.cs to create the tables on first request:

using Microsoft.Samples.ServiceHosting.StorageClient;

protected void Application_BeginRequest(object sender, EventArgs e)

{

    HttpApplication app = (HttpApplication)sender;

    HttpContext context = app.Context;

    // Attempt to peform first request initialization

    FirstRequestInitialization.Initialize(context);

}

And the implementation of the FirstRequestInitialization class:

internal class FirstRequestInitialization

{

    private static bool s_InitializedAlready = false;

    private static Object s_lock = new Object();

    // Initialize only on the first request

    public static void Initialize(HttpContext context)

    {

        if (s_InitializedAlready)

        {

            return;

        }

        lock (s_lock)

        {

            if (s_InitializedAlready)

            {

                return;

            }

            ApplicationStartUponFirstRequest(context);

            s_InitializedAlready = true;

        }

    }

    private static void ApplicationStartUponFirstRequest(HttpContext context)

    {

        // This is where you put initialization logic for the site.

        // RoleManager is properly initialized at this point.

        // Create the tables on first request initialization as there is a performance impact

        // if you call CreateTablesFromModel() when the tables already exist. This limits the exposure of

        // creating tables multiple times.

        // Get the settings from the Service Configuration file

        StorageAccountInfo account = StorageAccountInfo.GetDefaultTableStorageAccountFromConfiguration();

        // Create the tables

        // In this case, just a single table. 

        // This will create tables for all public properties that are IQueryable (collections)

        TableStorage.CreateTablesFromModel(typeof(ContactDataServiceContext), account);

    }

}

15. When running in the real cloud, this code is all that is needed to create the tables for your Cloud Service. The TableStorage class reflects over the ContactDataServiceContext classs and creates a table for each IQueryable<T> property where the columns of that table are based on the properties of the type T of the IQueryable<T>.

a. There is a bit more to do in order to get this to work in the local Development Storage case, more on that later.

16. At this point, it’s just a matter of filling out the ContactDataSource class with methods to query for the data, insert and delete rows. This is done through LINQ and using the ContactDataServiceContext.

a. Note: in the Select() method, the TableStorageDataServiceQuery<T> class enables you to have finer grained control over how you get the data.

i. Execute() or ExecuteWithRetries() will access the data store and return up to the first 1000 elements.

ii. ExecuteAll() or ExecuteAllWithRetries() will return all of the elements with continuation as you enumerate over the data.

iii. ExecuteWithRetries() and ExecuteAllWithRetries() uses the retry policy set on the ContactDataServiceContext for the queries.

b. Note: the use of AttachTo() in the Delete() method to connect to and remove the row.

public IEnumerable<ContactDataModel> Select()

{

    var results = from c in _ServiceContext.ContactTable

                  select c;

    TableStorageDataServiceQuery<ContactDataModel> query =
        new TableStorageDataServiceQuery<ContactDataModel>(results as DataServiceQuery<ContactDataModel>);

    IEnumerable<ContactDataModel> queryResults = query.ExecuteAllWithRetries();

    return queryResults;

}

public void Delete(ContactDataModel itemToDelete)

{

    _ServiceContext.AttachTo(ContactDataServiceContext.ContactTableName, itemToDelete, “*”);

    _ServiceContext.DeleteObject(itemToDelete);

    _ServiceContext.SaveChanges();

}

public void Insert(ContactDataModel newItem)

{

    _ServiceContext.AddObject(ContactDataServiceContext.ContactTableName, newItem);

    _ServiceContext.SaveChanges();

}

17. The UI is defined in the aspx page and consists of 3 parts. The GridView which will display all of the rows of data, the FormView which allows the user to add rows and the ObjectDataSource which databinds the UI to the ContactDataSource.

18. The GridView is placed after the first <div>. Note that in this sample, we’ll just auto-generate the columns and show the delete button. The DataSourceId is set the ObjectDataSource which will be covered below.

    <asp:GridView

        id=”contactsView”

        DataSourceId=”contactData”

        DataKeyNames=”PartitionKey”

        AllowPaging=”False”

        AutoGenerateColumns=”True”

        GridLines=”Vertical”

        Runat=”server”

        BackColor=”White” ForeColor=”Black”

        BorderColor=”#DEDFDE” BorderStyle=”None” BorderWidth=”1px” CellPadding=”4″>

        <Columns>

            <asp:CommandField ShowDeleteButton=”true”  />

        </Columns>

        <RowStyle BackColor=”#F7F7DE” />

        <FooterStyle BackColor=”#CCCC99″ />

        <PagerStyle BackColor=”#F7F7DE” ForeColor=”Black” HorizontalAlign=”Right” />

        <SelectedRowStyle BackColor=”#CE5D5A” Font-Bold=”True” ForeColor=”White” />

        <HeaderStyle BackColor=”#6B696B” Font-Bold=”True” ForeColor=”White” />

        <AlternatingRowStyle BackColor=”White” />

    </asp:GridView>   

19. The Form view to add rows is really simple, just labels and text boxes with a button at the end to raise the “Insert” command. Note that the DataSourceID is again set to the ObjectDataProvider and there are bindings to the Name and Address.

    <br />       

    <asp:FormView

        id=”frmAdd”

        DataSourceId=”contactData”

        DefaultMode=”Insert”

        Runat=”server”>

        <InsertItemTemplate>

            <asp:Label

                    id=”nameLabel”

                    Text=”Name:”

                    AssociatedControlID=”nameBox”

                    Runat=”server” />

            <asp:TextBox

                    id=”nameBox”

                    Text=’<%# Bind(“Name”) %>’

                    Runat=”server” />

            <br />

            <asp:Label

                    id=”addressLabel”

                    Text=”Address:”

                    AssociatedControlID=”addressBox”

                    Runat=”server” />

            <asp:TextBox

                    id=”addressBox”

                    Text=’<%# Bind(“Address”) %>’

                    Runat=”server” />

            <br />

            <asp:Button

                    id=”insertButton”

                    Text=”Add”

                    CommandName=”Insert”

                    Runat=”server”/>

        </InsertItemTemplate>

    </asp:FormView>

20. The final part of the aspx is the definition of the ObjectDataSource. See how it ties the ContactDataSource and the ContactDataModel together with the GridView and FormView.

    <%– Data Sources –%>

    <asp:ObjectDataSource runat=”server” ID=”contactData”
        TypeName=”SimpleTableSample_WebRole.ContactDataSource”

        DataObjectTypeName=”SimpleTableSample_WebRole.ContactDataModel”

        SelectMethod=”Select” DeleteMethod=”Delete” InsertMethod=”Insert”>   

    </asp:ObjectDataSource>

21. Build. You should not have any compilation errors, all 4 projects in the solution should build successfully.

22. Create Test Storage Tables. As mentioned in step 15, creating tables in the Cloud is all done programmatically, however there is an additional step that is needed in the local Development Storage case.

a. In the local development case, tables need to be created in the SQL Express database that the local Development Storage uses for its storage. These need to correspond exactly to the runtime code. This is due to a current limitation in the local Development Storage.

b. Right click on the Cloud Service node in Solution Explorer named “Create Test Storage Tables” that runs a tool that uses reflection to create the tables you need in a SQL Express database whose name corresponds to your Solution name.

i. ContactDataServiceContext is the type that the tool will look for and use to create those tables on your behalf.

ii. Each IQueryable<T> property on ContactDataServiceContext will have a table created for it where the columns in that table will correspond to the public properties of the type T of the IQueryable<T>.

23. F5 to debug. You will see the app running in the Development Fabric using the Table Development Storage

Due to some reasons, i reinstalled all the azure setup beginning from the SQL server. But when i try to debug(F5) a very basic HelloWorld application after building the solution, Getting a dialog box saying:
————————————
Microsoft Visual Studio
————————————

Windows Azure Tools for Microsoft Visual Studio CTP

Failed to initialize the Development Storage service.

Even i can’t see the Development Fabric Icon in the Task Bar items at this time
Answer :-

 This scenario happens when your SQL’s default instance name is not SQLEXPRESS. Because Azure SDK searches for this instance by defualt.

 So when this instance name is not found development Fabric doesn’t initializes.

Solution :-

1. Open Azure Sdk command prompt

2.     type DSInit /sqlinstance:<your sql instance name> press enter.
3. This utility opens up a small window and show the progress. this will automatically create three Ports for blob, queue and Tables. and create the Development  storage DB.