Getting started with Amazon's DynamoDB in Python

Amazon provides many cloud services, both for Infrastructure as a Service (running Virtual Machines in EC2) and Platform as a Service (providing the actual services). One of the services is DynamoDB, a simple NoSQL database, hosted on Amazon's servers.DynamoDB, like many NoSQL Databases is a simple key-value storage, with some added capabilities.
Basically, you store objects (representable in JSON), matched to a key. Your key can be a string or an int (and actually, DynamoDB allows your key to be composed of two fields, a hash and a range, but here we will only do the hash). Your object is just a dictionary mapping fields to values.
The best python library for DynamoDB (and for most other aws services) is boto.  The easiest way to install boto is with pip; just do pip install boto or sudo pip install boto.
Amazon offers a free tier for DynamoDB, which should be enough for playing and small applications (the DB has to be less than 100M in size, and you get 5KB in reads and 1KB in writes per second), so head down to aws.amazon.com and create your account, if you don't have it; after making your account, go to security credentials and find out your access key id and your secret access key. You may want to store your credentials in a file called .boto in your home folder, as explained here. After that, you can connect to your dynamodb as follows:

	conn=boto.connect_dynamodb() # if set in ~/.boto
	# or
	conn = boto.connect_dynamodb(aws_access_key_id='...',aws_secret_access_key='...')

view raw 1_connect.py hosted with ❤ by GitHub

Now, let's try to create one table. Our table will be called users, and its key will be a string. We first need to create a schema (the schema only specifies the name and type of your key; your 'table' can contain any kind of objects, with any attributes), and then use that schema to create a table, as follows:

	myschema=conn.create_schema(hash_key_name='username',hash_key_proto_value='S');
	table=conn.create_table(name='users', schema=myschema, read_units=1, write_units=1);

view raw create_table.py hosted with ❤ by GitHub

Once we have created the table, we go onto adding items; we create a dictionary containing our data, then use the new_item method of our table to create the item, and finally the put method of that item to actually add it to the database, as follows:

	user_data={'name':'Orlando Karam', 'password':'abc123', 'email':'ok@ok.com'};
	user=table.new_item(hash_key='okaram', attrs=user_data);
	user.put();

view raw insert_user.py hosted with ❤ by GitHub

And, after creating several items we can obtain an element (knowing its key) with the get_item method of a table, as follows (notice it will throw an exception if the key doesn't exist):

	it=table.get_item("okaram")
	# or select only some fields
	it=table.get_item("okaram", attributes_to_get=['email'])

view raw get_item.py hosted with ❤ by GitHub

To modify the item in the DB, we would just modify it in memory (it looks like a dictionary) and then call its put method again.
Most of the times you will be searching for a given key (or at least will know a part of the key), but if not, you can use the scan method (notice this method goes through EVERY object on the table, and so may be slow and consume a lot of I/O). You can pass a list of conditions (as of now, the documentation is incorrect, stating you specify the conditions with strings; you need to use elements coming from boto.dynamodb.condition). A scan would look like:

	users=table.scan(scan_filter={'username':CONTAINS('o')})
	# and later we cab iterate like
	for user in users:
	print user;

view raw scan.py hosted with ❤ by GitHub

For more information, check:

• Amazon's DynamoDB page
• boto's github
• Boto's DynamoDB tutorial
• Boto's DynamoDB API reference

Or come back :) I should be blogging more about dynamodb (and other aws services) soon.