Cloud computing with Amazon Web Services, Part 2: Storage in the cloud with Amazon Simple Storage Service (S3)

Amazon Simple Storage Service

Part 1 of this series introduces the building blocks of Amazon Web Services and explains how you can use this virtual infrastructure to build Web-scale systems.

In this article, learn more about Amazon Simple Storage Service (S3). S3 is a highly scalable and fast Internet data-storage system that makes it simple to store and retrieve any amount of data, at any time, from anywhere in the world. You pay for the storage and bandwidth based on your actual usage of the service. There is no setup cost, minimum cost, or recurring overhead cost.

Amazon provides the administration and maintenance of the storage infrastructure, leaving you free to focus on the core functions of your systems and applications. S3 is an industrial-strength platform that is readily available for your data storage needs. It's great for:

• Storing the data for your applications.
• Personal or enterprise backups.
• Quickly and cheaply distributing media and other bandwidth-guzzling content to your customers.

Features of S3 include:

Reliability

It is designed to tolerate failures and repair the system very quickly with minimal or no downtime. Amazon provides a service-level agreement (SLA) to maintain 99.99 percent availability.

Simplicity

S3 is built on simple concepts and provides great flexibility for developing your applications. You can build more complex storage schemes, if needed, by layering additional functions on top of S3 components.

Scalability

The design provides a high level of scalability and allows an easy ramp-up in service when a spike in demand hits your Web-scale applications.

Inexpensive

S3 rates are very competitive with other enterprise and personal data-storage solutions on the market.

The three basic concepts underpinning the S3 framework are buckets, objects, and keys.

Buckets

Buckets are the fundamental building blocks. Each object stored in Amazon S3 is contained within a bucket. Think of a bucket as analogous to a folder, or a directory, on the file system. One of the key distinctions between a file folder and a bucket is that each bucket and its contents are addressable using a URL. For example, if you have a bucket named "prabhakar," it can be addressed using the URL http://prabhakar.s3.amazonaws.com.

Each S3 account can contain a maximum of 100 buckets. Buckets cannot be nested within each other, so you can't create a bucket within a bucket. You can affect the geographical location of your buckets by specifying a location constraint when you create them. This will automatically ensure that any objects that you store within that bucket will be stored in that geographical location. At this time, you can locate your buckets in either the United States or the European Union. If you do not specify a location when creating the bucket, the bucket and its contents will be stored in the location closest to the billing address for your account.

Bucket names need to conform to the following S3 requirements:

• The name must start with a number or a letter.
• The name must be between 3 and 255 characters.
• A valid name can contain only lowercase letters, numbers, periods, underscores, and dashes.
• Though names can have numbers and periods, they cannot be in the IP address format. You cannot name a bucket 192.168.1.254.
• The bucket namespace is shared among all buckets from all of the accounts in S3. Your bucket name must be unique across the entire S3.

Buckets that will contain objects to be served with addressable URLs must conform to the following additional S3 requirements:

• The name of the bucket must not contain any underscores.
• The name must be between 3 and 63 characters.
• The name cannot end with a dash. For example, myfavorite-.bucket.com is invalid.
• There cannot be dashes next to periods in the name. So my-.bucket.com would be invalid.

You can use a domain naming convention for your buckets, such as media.yourdomain.com, and thus map your existing Web domains or subdomains to Amazon S3. The actual mapping will be done when you add DNS CNAME entries to point back to S3. The big advantage with this scheme is that you can use your own domain name in your URLs to download files. The CNAME mapping will be responsible for translating between the S3 address for your bucket. For example, http://media.yourdomain.com.s3.amazonaws.com becomes the more-friendly http://media.yourdomain.com.

Objects

Objects contain the data stored within the buckets in S3. Think of an object as the file you want to store. Each object stored is composed of two entities: data and metadata. The data is the actual thing being stored, such as a PDF file, Word document, a video file, etc. The stored data also has associated metadata for describing the object. Some examples of metadata are the content type of the object being stored, the date the object was last modified, and any other metadata specific to you or your application. The metadata for an object is specified by the developer as key-value pairs when the object is sent to S3 for storage.

Unlike the limitation on the number of buckets, there are no restrictions on the number of objects. You can store an unlimited number of objects in your buckets, and each object can contain up to 5 GB of data.

The data in your publicly accessible S3 objects can be retrieved by HTTP, HTTPS, or BitTorrent. Distribution of large media files from your S3 account becomes very simple when using BitTorrent; Amazon will not only create the torrent for your object, it will also seed it.

Keys

Each object stored within an S3 bucket is identified using a unique key. This is similar in concept to the name of a file in a folder on your file system. The file name within a folder on your hard drive must be unique. Each object inside a bucket has exactly one key. The name of the bucket and the key are together used to provide the unique identification for each object stored in S3.

Every object within S3 is addressable using a URL that combines the S3 service URL, bucket name, and unique key. If you store an object with the key my_favorite_video.mov inside the bucket named prabhakar, that object can be addressed using the URL http://prabhakar.s3.amazonaws.com/ my_favorite_video.mov.

Though the concepts are simple, as shown in Figure 1, buckets, objects, and keys together provide a lot of flexibility for building your data storage solutions. You can leverage these building blocks to simply store data on S3, or use their flexibility to layer and build more complex storage and applications on top of S3 to provide additional functions.

Back to top

Access logging

Each S3 bucket can have access log records that contain details on each request for a contained object. The log records are turned off by default; you have to explicitly enable the logging for each Amazon S3 bucket you want to track. An access log record contains a lot of detail about the request, including the request type, the resource requested, and the time and date the request was processed.

The logs are provided in the S3 server access log format, but can be easily converted into an Apache combined log format. They can then be easily parsed by any of the open source or commercial log analysis tools, such as Webalizer, to give you a human-readable report and pretty graphs upon request. The reports can be useful to gain insight into your customer base that's accessing the files. See Resources for tools you can use for easier visualization of the S3 log records.

Back to top

Security

Each bucket and object created in S3 is private to the user account creating them. You have to explicitly grant permissions to other users and customers for them to be able to see the list of objects in your S3 buckets or to download the data contained within them. Amazon S3 provides the following security features to protect your buckets and the objects in them.

Authentication

Ensures that the request is being made by the user that owns the bucket or object. Each S3 request must include the Amazon Web Services access key that uniquely identifies the user.

Authorization

Ensures that the user trying to access the resource has the permissions or rights to the resource. Each S3 object has an access-control list (ACL) associated with it that explicitly identifies the grants and permissions for that resource. You can grant access to all Amazon Web Services users or to a specific user identified by e-mail address, or you can grant anonymous access to any user.

Integrity

Each S3 request must be digitally signed by the requesting user with an Amazon Web Services secret key. On receipt of the request, S3 will check the signature to ensure that the request has not been tampered with in transit.

Encryption

You can access S3 through the HTTPS protocol to ensure that the data is transmitted through an encrypted connection.

Nonrepudiation

Each S3 request is time-stamped and serves as proof of the transaction.

Each and every REST request made to S3 must go through the following standard steps essential to ensuring security:

• The request and all needed parameters must be assembled into a string.
• Your Amazon Web Services secret access key must be used to create a keyed-Hash Message Authentication Code (HMAC) signature hash of the request string.
• This calculated signature is itself added as a parameter on the request.
• The request is then forwarded to Amazon S3.
• Amazon S3 will check to see if the provided signature is a valid keyed-HMAC hash of the request.
• If the signature is valid, then (and only then) Amazon S3 will process the request.

Back to top

Pricing

The charges for S3 are calculated based on three criteria, which are different based on the geographic location of your buckets:

• The total amount of storage space used, which includes the actual size of your data content and the associated metadata. The units used by S3 for determining the storage consumed are GB/month. The number of bytes of storage used by your account is computed every hour, and at the end of the month, it's converted into the storage used for the month. The table below shows pricing for storage.
  
  

  Location	Cost
  United States	$0.15 per GB/month of storage used
  Europe	$0.18 per GB/month of storage used

  
  
  
• The amount of data or bandwidth transferred to and from S3. This includes all data uploaded and downloaded from S3. There is no charge for data transferred between EC2 and S3 buckets located in the United States. Data transferred between EC2 and European S3 buckets is charged at the standard data-transfer rate, as shown below.
  
  

  Location	Cost
  United States	$0.100 per GB — all data transfer in $0.170 per GB — first 10 TB/month data transfer out $0.130 per GB — next 40 TB/month data transfer out $0.110 per GB — next 100 TB/month data transfer out $0.100 per GB — data transfer out/month over 150 TB
  Europe	$0.100 per GB — all data transfer in $0.170 per GB — first 10 TB/month data transfer out $0.130 per GB — next 40 TB / month data transfer out $0.110 per GB — next 100 TB/month data transfer out $0.100 per GB — data transfer out/month over 150 TB

  
  
  
• The number of API requests performed. S3 charges fees per each request made using the interface — for creating objects, listing buckets, listing objects, etc. There is no fee for deleting objects and buckets. The fees are once again slightly different based on the geographic location of the bucket. The following table shows pricing for API requests.
  
  

  Location	Cost
  United States	$0.01 per 1,00 0 PUT, POST, or LIST requests $0.01 per 10,000 GET and all other requests No charge for delete requests
  Europe	$0.012 per 1,000 PUT, POST, or LIST requests $0.012 per 10,000 GET and all other requests No charge for delete requests

  
  
  

Check Amazon S3 for the latest pricing. You can also use the AWS Simple Monthly Calculator for calculating your monthly usage costs for S3 and the other Amazon Web Services.

Back to top

Getting started with Amazon Web Services and S3

To start exploring S3, you need to sign up for an Amazon Web Services account. You will be assigned an Amazon Web Services account number and will get the security access keys along with the x.509 security certificate that will be required when you start using the various libraries and tools for communicating with S3.

All communication with any of the Amazon Web Services is through either the SOAP interface or the query/REST interface. The request messages that are sent through either of these interfaces must be digitally signed by the sending user to ensure that the messages have not been tampered with in transit, and that they are really originating from the sending user. This is the most basic part of using the Amazon Web Services APIs. Each request must be digitally signed and the signature attached to the request.

Each Amazon Web Services user account is associated with the following security credentials:

• An access key ID that identifies you as the person making requests through the query/REST interface.
• A secret access key used to calculate the digital signature when you make requests through the query interface.
• Public and private x.509 certificates for signing requests and authentication when using the SOAP interface.

You can manage your keys and certificate, regenerate them, view account activity and usage reports, and modify your profile information from Web Services Account information.

After you successfully sign up for the Amazon Web Services account, you need to enable Amazon S3 service for your account using the following steps:

1. Log in to your Amazon Web Services account.
2. Navigate to the S3 home page.
3. Click on Sign Up For This Web Service on the right side of the page.
4. Provide the requested information and complete the sign-up process.

Examples in this article use the query/REST interface to communicate with S3. You are going to need to obtain your access keys. You can access them from your Web Services Account information page by selecting View Access Key Identifiers. You are now set up to use Amazon Web Services and have enabled S3 service for your account.

Back to top

Interacting with S3

To learn about interacting with S3, you can use existing libraries available from Amazon or from third parties and independent developers. This article does not delve into the details of communication with S3, such as how to sign requests, how to build up the XML documents used for encapsulating the data, or the parameters sent to and received from S3. We'll let the libraries handle all of that for us, and use the higher-level interface they provide. You can review the S3 developer guide for more details.

You'll use an open-source Javaâ„¢ library named JetS3t to explore S3, and learn about its API by viewing small snippets of code. By the end of the article you'll collect and organize these snippets into something useful: a simple and handy S3 Shell that you can use at any time to experiment and interact with S3.

JetS3t

JetS3t is an open source Java toolkit for interacting with S3. It is more than just a library. The distribution includes several very useful S3-related tools that can be used by typical S3 users as well as service providers who build applications on top of S3. JetS3t includes:

Cockpit

A GUI for managing the contents of an Amazon S3 account.

Synchronize

A command-line application for synchronizing directories on your computer with an Amazon S3 account.

Gatekeeper

A servlet you can use to mediate access to Amazon S3 accounts.

CockpitLite

A lighter version of Cockpit that routes all its operations through a mediating gatekeeper service.

Uploader

A GUI that routes all its operations through a mediating gatekeeper service and can be used by service providers to provide access to their S3 accounts for customers.

You can, of course, use one of these GUI applications for interacting with S3, but that won't be very helpful if you need to develop applications to interface with S3. You can download the complete source code for this article as a zipped archive, including a ready-to-go Netbeans project that you can import into your workspace.

Connecting to S3

JetS3t provides an abstract class named org.jets3t.service.S3Service that must be extended by classes that implement a specific interface, such as REST or SOAP. JetS3t provides two implementations you can use for connecting and interacting with S3:

• org.jets3t.service.impl.rest.httpclient.RestS3Service communicates with S3 through the REST interface.
• org.jets3t.service.impl.soap.axis.SoapS3Service communicates with S3 through the SOAP interface using Apache Axis 1.4.

JetS3t uses a file named jets3t.properties to configure various parameters used while communicating with S3. The example in this article uses the default jets3t.properties that is shipped with the distribution. The JetS3t configuration guide has a detailed explanation of the parameters.

In this article, you'll use the RestS3Service to connect to S3. A new RestS3Service object can be created by providing your Amazon Web Services access keys in the form of an AWSCredentials object. Keep in mind that the code snippets in this article are for demonstrating the API. To run each snippet, you have to ensure that all the required class imports are present. Refer to the source in the download package for the right imports. Or, even simpler, you can import the provided Netbeans project into your workspace for easy access to all the source code.

String awsAccessKey = ”Your AWS access key”;
String awsSecretKey = “Your AWS Secret key”;

// use your AWS keys to create a credentials object
AWSCredentials awsCredentials = new AWSCredentials(awsAccessKey, awsSecretKey);

// create the service object with our AWS credentials
S3Service s3Service = new RestS3Service(awsCredentials);

Managing your buckets

The concept of a bucket is encapsulated by the org.jets3t.service.model.S3Bucket, which extends the org.jets3t.service.model.BaseS3Object class. This class is the parent class for both buckets and objects in the JetS3t model. Each S3Bucket object provides a toString(), in addition to various accessor methods, that can be used to print the salient information for a bucket (name and geographical location of the bucket, date the bucket was created, owner’s name, and any metadata associated with the bucket).

// list all buckets in the AWS account and print info for each bucket.
S3Bucket[] buckets = s3Service.listAllBuckets();
for (S3Bucket b : buckets) {
   System.out.println(b);
}

You can create a new bucket by providing a unique name for it. The namespace for buckets is shared by all the user accounts, so sometimes finding a unique name can be challenging. You can also specify where you want the bucket and the objects that it will contain to be physically located.

// create a US bucket and print its info
S3Bucket bucket = s3Service.createBucket(bucketName);
System.out.println("Created bucket - " + bucketName + " - " + bucket);


// create a EU bucket and print its info
S3Bucket bucket = s3Service.createBucket(bucketName, S3Bucket.LOCATION_EUROPE);
System.out.println("Created bucket - " + bucketName + " - " + bucket);

You have to delete all the objects contained in the bucket prior to deleting the bucket or an exception will be raised. The RestS3Service class you have been using is fine for dealing with single objects. When you start dealing with multiple objects, it makes more sense to use a multithreaded approach to speed things up. JetS3t provides the org.jets3t.service.multithread.S3ServiceSimpleMulti class just for this purpose. You can wrap the existing s3Service object using this class and take full advantage of those multiprocessors. It comes in handy when you need to clear a bucket by deleting all the objects it contains.

// get the bucket
S3Bucket bucket = getBucketFromName(s3Service, “my bucket”);

// delete a bucket – it must be empty first
s3Service.deleteBucket(bucket);


// create a multi threaded version of the RestService
S3ServiceSimpleMulti s3ServiceMulti = new S3ServiceSimpleMulti(s3Service);


// get all the objects from bucket
S3Object[] objects = s3Service.listObjects(bucket);

// clear the bucket by deleting all its objects
s3ServiceMulti.deleteObjects(bucket, objects);

Each bucket is associated with an ACL that determines the permissions or grants for the bucket and the level of access provided to other users. You can retrieve the ACL and print the grants provided by it.

// get the bucket
S3Bucket bucket = getBucketFromName(s3Service, “my bucket”);

// get the ACL and print it
AccessControlList acl = s3Service.getBucketAcl(bucket);
System.out.println(acl);

The default permissions on newly created buckets and objects make them private to the owner. You can modify this by changing the ACL for a bucket and granting a group of users permission to read, write, or have full control over the bucket.

// get the bucket
S3Bucket bucket = getBucketFromName(s3Service, “my bucket”);

// get the ACL
AccessControlList acl = s3Service.getBucketAcl(bucket);

// give everyone read access
acl.grantPermission(GroupGrantee.ALL_USERS, Permission.PERMISSION_READ);

// save changes back to S3
bucket.setAcl(acl);
s3Service.putBucketAcl(bucket);

You can easily enable logging for a bucket and retrieve the current logging status. After logging is enabled, detailed access logs for each file in that bucket are stored in S3. Your S3 account will be charged for the storage space consumed by the logs.

// get the bucket
S3Bucket bucket = getBucketFromName(s3Service, “my bucket”);

// is logging enabled?
S3BucketLoggingStatus loggingStatus = s3Service.getBucketLoggingStatus(bucketName);
System.out.println(loggingStatus);

// enable logging
S3BucketLoggingStatus newLoggingStatus = new S3BucketLoggingStatus();

// set a prefix for your log files
newLoggingStatus.setLogfilePrefix(logFilePrefix);

// set the target bucket name
newLoggingStatus.setTargetBucketName(bucketName);

// give the log_delivery group permissions to read and write from the bucket
AccessControlList acl = s3Service.getBucketAcl(bucket);
acl.grantPermission(GroupGrantee.LOG_DELIVERY, Permission.PERMISSION_WRITE);
acl.grantPermission(GroupGrantee.LOG_DELIVERY, Permission.PERMISSION_READ_ACP);
bucket.setAcl(acl);

// save the changed ACL for the bucket to S3
s3Service.putBucketAcl(bucket);

// save the changes to the bucket logging
s3Service.setBucketLoggingStatus(bucketName, newLoggingStatus, true);
System.out.println("The bucket logging status is now enabled.");

Managing your objects

Each object contained in a bucket is represented by the org.jets3t.service.model.S3Object. Each S3Bucket object provides a toString() that can be used to print the important details for an object:

• Name of the key
• Name of the containing bucket
• Date the object was last modified
• Any metadata associated with the object

It also provides methods for accessing the various properties of an object, along with its metadata.

// list objects in a bucket.
S3Object[] objects = s3Service.listObjects(bucket);

// print out the object details
if (objects.length == 0) {
   System.out.println("No objects found");
} else {
   for (S3Object o : objects) {
      System.out.println(o);
   }
}

You can filter the list of objects retrieved by providing a prefix to match.

// list objects matching a prefix.
S3Object[] filteredObjects = s3Service.listObjects(bucket, “myprefix”, null);

// print out the object details
if (filteredObjects.length == 0) {
   System.out.println("No objects found");
} else {
   for (S3Object o : filteredObjects) {
      System.out.println(o);
   }
}

Each object can have associated metadata, such as the content type, date modified, etc. You can also associate your application-specific custom metadata with an object.

// get the bucket
S3Bucket bucket = getBucketFromName(s3Service, bucketName);

// getobjects matching a prefix
S3Object[] filteredObjects = s3Service.listObjects(bucket, “myprefix”, null);

if (filteredObjects.length == 0) {
   System.out.println("No matching objects found");
}else {
   
   // get the metadata for multiple objects.
   S3Object[] objectsWithHeadDetails = s3ServiceMulti.getObjectsHeads(bucket, 
      filteredObjects);

   // print out the metadata
   for (S3Object o : objectsWithHeadDetails) {
      System.out.println(o);
   }
}

Each newly created object is private by default. You can use JetS3t to generate a signed URL that anyone can use for downloading the object data. This URL can be created to be valid only for a certain duration, at the end of which it automatically expires. The object is still private, but you can give the URL to anyone to let them download it for a brief time.

// get the bucket
S3Bucket bucket = getBucketFromName(s3Service, bucketName);

// how long should this URL be valid?
int duration = Integer.parseInt(tokens.nextToken());
Calendar cal = Calendar.getInstance();
cal.add(Calendar.MINUTE, duration);
Date expiryDate = cal.getTime();

// create the signed url
String url = S3Service.createSignedGetUrl(bucketName, objectKey,
        awsCredentials, expiryDate);
System.out.println("You can use this public URL to access this file for the next " 
   + duration + " min - " + url);

S3 allows a maximum of 5 GB per object in a bucket. If you have objects larger than this, you'll need to split them up into multiple files, each 5 GB in size, then upload all the parts to S3.

// get the bucket
S3Bucket bucket = getBucketFromName(s3Service, bucketName);

// create an object with the file data
File fileData = new File(“/my_file_to_upload”);
S3Object fileObject = new S3Object(bucket, fileData);

// put the data on S3
s3Service.putObject(bucket, fileObject);
System.out.println("Successfully uploaded object - " + fileObject);

JetS3t provides a DownloadPackage class that makes it simple to associate the data from an S3 object to a local file and automatically save the data to it. You can use this feature to easily download objects from S3.

// get the bucket
S3Bucket bucket = getBucketFromName(s3Service, bucketName);

// get the object
S3Object fileObject = s3Service.getObject(bucket, fileName);

// associate a file with the object data
DownloadPackage[] downloadPackages = new DownloadPackage[1];
downloadPackages[0] = new DownloadPackage(fileObject,
                            new File(fileObject.getKey()));

// download objects to the associated files
s3ServiceMulti.downloadObjects(bucket, downloadPackages);
System.out.println("Successfully retrieved object to current directory");

This section covered some of the basic functions provided by the JetS3t toolkit, and how to use them to interact with S3. See Resources for more about S3 service and an in-depth discussion of the JetS3t toolkit.

S3 Shell

The interaction thus far with S3, through small code snippets, can be put into a more useful and longer-lasting form by creating a simple S3 Shell program you can run from the command line. You'll create a simple Java program that accepts the Amazon Web Services access key and secret key as parameters, and returns a console prompt. You can then type a letter or a few letters, such as b for listing buckets or om for listing objects that match a certain prefix. Use this program for experimentation.

The shell program contains a main() filled out with an implementation using the snippets of code you're using in this article. In the interest of space, the code listing for S3 Shell is not included here. The complete S3 Shell source code, along with its dependencies, is in the download. You can run the shell by simply executing the devworks-s3.jar file.

java -jar devworks-s3.jar my_aws_access_key my_aws_secret_key

You can type h at any time in the S3 Shell to get a list of supported commands.

Some of the more useful methods have been added to the S3 Shell. You can extend it to add any other functions you want to make the shell even more useful to your specific case.

Back to top

Summary

In this article, you learned some of the basic concepts behind Amazon's S3 service. The JetS3t toolkit is an open source library you can use to interact with S3. You also learned how to create a simple S3 Shell using sample snippets of code, so you can continue to experiment easily and simply with S3 using the command line.

Part 3 of this "Cloud computing with Amazon Web Services" series explains how to use Amazon Elastic Compute Cloud (EC2) to run virtual servers in the cloud.

Back to top

Download

Information about download methods

Resources

Learn

• Check out the other parts in this series:
  • Part 1, "Introduction"
  • Part 3, "Servers on demand with EC2"
  • Part 4, "Reliable messaging with SQS"
  • Part 5, "Dataset processing in the cloud with SimpleDB"
  
  
• Learn about specific Amazon Web Services:
  • Amazon Simple Storage Service (S3)
  • Amazon Elastic Compute Cloud (EC2)
  • Amazon Simple Queue Service (SQS)
  • Amazon SimpleDB (SDB)
  • The Service Health Dashboard is updated by the Amazon team regarding any issues with the services.
  
  
• Sign up for an Amazon Web Services account.
  
  
• The Amazon Web Services Developer Connection is the gateway to all the developer resources.
  
  
• Read the blog to find out the latest happenings in the world of Amazon Web Services.
  
  
• From the Web Services Account information page you can manage your keys and certificate, regenerate them, view account activity and usage reports, and modify your profile information.
  
  
• S3 Technical Resources has Amazon Web Services technical documentation, user guides, and other articles of interest.
  
  
• Amazon S3 has the latest pricing information. Use the AWS Simple Monthly Calculator tool for calculating your monthly usage costs for S3 and the other Amazon Web Services.
  
  
• Review the S3 Developer Guide for more details.
  
  
• Amazon Check out the Service Level Agreement (SLA) for S3.
  
  
• The S3stats resource page has several links on processing and viewing S3 log records. Logs are in the S3 Server Access Log Format, but can be easily converted into Apache Combined Log Format, then easily parsed by any of the open source or commercial log analysis tools such as Webalizer.
  
  
• Learn about JetS3t, an open source Java toolkit for Amazon S3, developed by James Murty. See the toolkit documentation, and get detailed explanations of parameters in the configuration guide.
  
  
• Get the RSS feed for this series.
  
  
• In the Architecture area on developerWorks, get the resources you need to advance your skills in the architecture arena.
  
  
• Browse the technology bookstore for books on these and other technical topics.
  
  

Get products and technologies

• Download JetS3t and other tools.
  
  
• Download IBM product evaluation versions and get your hands on application development tools and middleware products from IBM® DB2®, Lotus®, Rational®, Tivoli®, and WebSphere®.
  
  

Discuss

• Check out developerWorks blogs and get involved in the developerWorks community.
  
  

About the author

Prabhakar Chaganti is the CTO of Ylastic, a start-up that is building a single unified interface to architect, manage, and monitor a user's entire AWS Cloud computing environment: EC2, S3, SQS and SimpleDB. He is the author of two recent books, Xen Virtualization and GWT Java AJAX Programming. He is also the winner of the community choice award for the most innovative virtual appliance in the VMware Global Virtual Appliance Challenge.

Comments

Back to top

Trademarks

Table of contents

• Amazon Simple Storage Service
• Access logging
• Security
• Pricing
• Getting started
• Interacting with S3
• Summary
• Download
• Resources
• About the author
• Comments

Next steps from IBM

Access IBM software products in the Amazon Elastic Compute Cloud (EC2) virtual environment.

---

• Try: Reduce expenses by using IBM software running in a cloud environment.
• Article: Learn how you can use Infrastructure as a Service to get a full computer infrastructure using Amazon's Elastic Compute Cloud (EC2).
• Demo: Deploy multi-tenant SaaS applications on IBM middleware in the Amazon Elastic Compute Cloud
• Buy: Time (pay-as-you-go) using IBM products on Amazon EC2

My developerWorks community

Dig deeper into IT architecture on developerWorks

We want to know you!

Update your My developerWorks profile and start connecting with others

Special offers