Comparing AWS SimpleDB and Windows Azure Table Storage – Part I

We have a multitude of options for storing data in the cloud.  If you are looking for a storage mechanism for fast access to non-relational data, then both the Amazon Web Service (AWS) SimpleDB product and the Microsoft Windows Azure Table storage are viable choices.  In this post, I’m going to do a quick comparison of these two products, including how to leverage the .NET API provided by both.

First, let’s do a comparison of these two.

Amazon SimpleDB Windows Azure Table
Feature
Storage Metaphor Domains are like worksheets, items are rows, attributes are column headers, items are each cell Tables, properties are columns, entities are rows
Schema None enforced None enforced
“Table” size Domain up to 10GB, 256 attributes per item, 1 billion attributes per domain 255 properties per entity, 1MB per entity, 100TB per table
Cost (excluding transfer) Free up to 1GB, 25 machine hours (time used for interactions); $0.15 GB/month up to 10TB, $0.14 per machine hour 0.15 GB/month
Transactions Conditional put/delete for attributes on single item Batch transactions in same table and partition group
Interface mechanism REST, SOAP REST
Development tooling AWS SDK for .NET Visual Studio.NET, Development Fabric

These platforms are relatively similar in features and functions, with each platform also leveraging aspects of their sister products (e.g. AWS EC2 for SimpleDB), so that could sway your choice as well.

Both products provide a toolkit for .NET developers and here is a brief demonstration of each.

Amazon Simple DB using AWS SDK for .NET

You can download the AWS SDK for .NET from the AWS website.  You get some assemblies in the GAC, and also some Visual Studio.NET project templates.

2010.09.29storage01

In my case, I just built a simple Windows Forms application that creates a domain, adds attributes and items and then adds new attributes and new items.

After adding a reference to the AWSSDK.dll in my .NET project, I added the following “using” statements in my code:

using Amazon;
using Amazon.SimpleDB;
using Amazon.SimpleDB.Model;

Then I defined a few variables which will hold my SimpleDB domain name, AWS credentials and SimpleDB web service container object.

NameValueCollection appConfig;
AmazonSimpleDB simpleDb = null;
string domainName = "ConferenceDomain";

I next read my AWS credentials from a configuration file and pass them into the AmazonSimpleDB object.

appConfig = ConfigurationManager.AppSettings;
simpleDb = AWSClientFactory.CreateAmazonSimpleDBClient(appConfig["AWSAccessKey"],
                appConfig["AWSSecretKey"]);

Now I can create a SimpleDB domain (table) with a simple command.

CreateDomainRequest domainreq = (new CreateDomainRequest()).WithDomainName(domainName);
simpleDb.CreateDomain(domainreq);

Deleting domains looks like this:

DeleteDomainRequest deletereq = new DeleteDomainRequest().WithDomainName(domainName);
simpleDb.DeleteDomain(deletereq);

And listing all the domains under an account can be done like this:

string results = string.Empty;
ListDomainsResponse sdbListDomainsResponse = simpleDb.ListDomains(new ListDomainsRequest());
if (sdbListDomainsResponse.IsSetListDomainsResult())
{
   ListDomainsResult listDomainsResult = sdbListDomainsResponse.ListDomainsResult;
   
   foreach (string domain in listDomainsResult.DomainName)
   {
        results += domain + "\n";
    }
 }

To create attributes and items, we use a PutAttributeRequest object.  Here, I’m creating two items, adding attributes to them, and setting the value of the attributes.  Notice that we use a very loosely typed process and don’t work with typed objects representing the underlying items.

//first item
string itemName1 = "Conference_PDC2010";
PutAttributesRequest putreq1 = 
     new PutAttributesRequest().WithDomainName(domainName).WithItemName(itemName1);
List<ReplaceableAttribute> item1Attributes = putreq1.Attribute;
item1Attributes.Add(new ReplaceableAttribute().WithName("ConferenceName").WithValue("PDC 2010"));
item1Attributes.Add(new ReplaceableAttribute().WithName("ConferenceType").WithValue("Technology"));
item1Attributes.Add(new ReplaceableAttribute().WithName("ConferenceDates").WithValue("09/25/2010"));
simpleDb.PutAttributes(putreq1);

//second item
string itemName2 = "Conference_PandP";
PutAttributesRequest putreq2 = 
    new PutAttributesRequest().WithDomainName(domainName).WithItemName(itemName2);
List<ReplaceableAttribute> item2Attributes = putreq2.Attribute;
item2Attributes.Add(new ReplaceableAttribute().WithName("ConferenceName").
     WithValue("Patterns and Practices Conference"));
item2Attributes.Add(new ReplaceableAttribute().WithName("ConferenceType").WithValue("Technology"));
item2Attributes.Add(new ReplaceableAttribute().WithName("ConferenceDates").WithValue("11/10/2010"));
simpleDb.PutAttributes(putreq2);

If we want to update an item in the domain, we can do another PutAttributeRequest and specify which item we wish to update, and with which new attribute/value.

//replace conference date in item 2
ReplaceableAttribute repAttr = 
    new ReplaceableAttribute().WithName("ConferenceDates").WithValue("11/11/2010").WithReplace(true);
PutAttributesRequest putReq = 
    new PutAttributesRequest().WithDomainName(domainName).WithItemName("Conference_PandP").
    WithAttribute(repAttr);
simpleDb.PutAttributes(putReq);

Querying the domain is done with familiar T-SQL syntax.  In this case, I’m asking for all items in the domain where the ConferenceType attribute equals ‘Technology.”

string query = "SELECT * FROM ConferenceDomain WHERE ConferenceType='Technology'";
SelectRequest selreq = new SelectRequest().WithSelectExpression(query);
SelectResponse selresp = simpleDb.Select(selreq);

Summary of Part I

Easy stuff, eh?  Because of the non-existent domain schema, I can add a new attribute to an existing item (or new one) with no impact on the rest of the data in the domain.  If you’re looking for fast, highly flexible data storage with high redundancy and no need for the rigor of a relational database, then AWS SimpleDB is a nice choice.  In part two of this post, we’ll do a similar investigation of the Windows Azure Table storage option.



Categories: Cloud, Windows Azure

7 replies

  1. so Azure table has no computation cost associated with it, it’s purely the storage cost? I’ve used simpleDB and the computational cost has been far more expensive than the storage cost.

    It’s also worth noting that in simpleDB an attribute is limited to 1024 bytes, and all attributes are strings.

  2. Really good comparison. SDB Explorer is a tool for Amazon NOSQL SimpleDB that helps you manage large amount of distributed data in simple and easy way.

Trackbacks

  1. Comparing AWS SimpleDB and Windows Azure Table Storage – Part II « Richard Seroter's Architecture Musings
  2. Scott Banwart's Blog » Blog Archive » Distributed Weekly 71
  3. A Lap Around the New Amazon Web Services Toolkit for Visual Studio « Richard Seroter's Architecture Musings

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: