Object storage

Object storage is entirely different from NAS (file storage) and SAN (block storage). Although data is still accessed through the network, the way that data is retrieved is uniquely different. You will not access files through a filesystem, but through RESTful APIs using HTTP methods.

Objects are stored in a flat namespace, which can store millions or billions of them; this is the key to its high scalability, as it is not restrained by the number of nodes as it is in regular filesystems, such as XFS and EXT4. It is important to know that the namespaces can have partitions (often called buckets), but they cannot be nested as regular folders in a filesystem because the namespace is flat:

When comparing object storage with traditional storage, the self-parking versus valet-parking analogy is often used. Why is this similar? Well, because, in traditional filesystems, when you store your file you store it in a folder or directory, and it is your responsibility to know where that file was stored, just like parking a car in a parking spot—you need to remember the number and floor of where you left your car. With object storage, on the other hand, when you upload your data or put a file in a bucket, you are granted a unique identifier that you can later use to retrieve it; you don't need to remember where it was stored. Just like a valet, who will go and get the car for you, you simply need to give them the ticket you received when you left your car.

Continuing with the valet-parking reference, you usually give your valet information about the car they need to get to you, not because they need it, but because they can identify your car better in this way—for instance, the color, plate number, or model of the car will help them a lot. With object storage, the process is the same. Each object has its own metadata, its unique ID, and the file itself, which are all part of the stored object.

The following diagram shows what comprises an object in object storage: 

As we have mentioned several times, object storage is accessed through RESTful APIs. So, in theory, any device that supports HTTP protocols can access your object storage buckets via HTTP methods such as PUT or GET. This sounds insecure, but, in fact, most software-defined object storage has some type of authentication method, and you require an authentication token in order to retrieve or upload files. A simple request using the Linux curl tool may look like this:

curl -X PUT -T "${path_to_file}" \
  -H "Host: ${bucket_name}.s3.amazonaws.com" \
  -H "Date: ${date}" \
  -H "Content-Type: ${contentType}" \
  -H "Authorization: AWS ${s3Key}:${signature}" \
  https://${bucket}.s3.amazonaws.com/${file}

Here, we can see how multiple distinct devices can connect to object storage buckets in the cloud through the HTTP protocol: