Comparing Windows Azure Blob Storage and Google Cloud Storage

Original author: Gaurav Mantri (Cerebrata)
  • Transfer
Greetings to lovers of cloud computing.
I suggest looking at a comparison of Windows Azure Blob Storage and Google Cloud Storage services (while the author does not forget to mention Amazon AS3).

I thought it would be nice to write an article comparing Google App Engine storage and Windows Azure storage. In this article, we compare Windows Azure Blob Storage and Google Cloud Storage .

The first part of the cycle - Comparison of Windows Azure Table Storage and Amazon DynamoDB
The second part of the cycle - Comparison of Windows Azure Blob Storage and Amazon Simple Storage Service (S3) - Part I
The third part of the cycle - Comparison of Windows Azure Blob Storage and Amazon Simple Storage Service (S3) –Part II, Summary of
Abbreviations:Windows Azure Blob Storage - WABS and Google Cloud Storage - GCS, Amazon S3 - AS3 .

Conceptually, WABS and GCS provide similar functionality - simply put, both systems are cloud file systems that allow you to store large amounts of unstructured data (usually in the form of files).

Both systems provide a REST API for working with files and folders and other libraries of high-level languages, which are usually wrappers of the REST API. Each release of the API has its own version, in WABS it has a date value, in GCS - numbers. At the time of writing, the version of WABS was 2011-08-18 , GCS was version 2.0 .

Similar functionality in two systems:

  • Both systems are cloud-based file systems with a two-level hierarchy.
  • Both systems allow you to store large amounts of data for a long time and cheaply.
  • Both systems protect content from unauthorized access.
  • Both systems provide their access control mechanisms to protect data. In GCS, these are ACLs and Query String Authentication in WABS - ACLs and Shared Access Signatures .
  • Both systems allow you to store an arbitrarily large number of versions of the source object, but the versioning mechanism in the two systems is different.


Of the concept



Before we talk more about these two services, I consider it important to clarify some concepts. If you are familiar with the basic concepts of WABS and GCS, you can skip this section.

Blob containers and baskets : If these services are file systems in the cloud, consider the WABS blob container and GCS bucket as a folder or directory. In the WABS storage account or GCS account, you can have zero or more blob containers and baskets that can contain blobs or objects, respectively.

Comments:

  • There is no such thing as nested blob containers or baskets. Both services provide a two-level hierarchy without nesting. However, both systems allow you to create the illusion of a folder hierarchy using prefixes.
  • There are no restrictions on the number of containers and baskets.
  • Both systems provide the ability to log resource requests - this function is called “logging” in GCS, and “Storage Analytics” in WABS. The difference is that in GCS, logging works at the basket level, while in WABS, logging works at the storage account level. In GCS, logging data is placed in a separate user-defined basket, in WABS, in predefined tables and containers that are created automatically when logging is enabled.


Blobs and objects : WABS blobs and GCS objects are files in your cloud file system located in blob containers and baskets.

Comments:

  • There is no limit on the number of blobs and objects stored, while in GCS this number is simply unknown, in WABS this number is limited by the size of the storage account (100 Tb).
  • The maximum size of an object in WABS is 1 TB, in GCS it is not defined.
  • There are two types of blobs in WABS: block, convenient for streaming (for example, pictures, videos, documents) and having a maximum size of 200 GB, and page, convenient for random access / recording operations and having a maximum size of 1 TB. A common case of using a page blob is to mount VHD as a disk in the role of Windows Azure. GCS has no such separation.
  • Both systems provide rich blob and object management functionality. You can copy, download, download and perform other operations.
  • Both systems provide the ability to protect content from unauthorized access, and the mechanism of access control lists is configured in more detail in GCS, where you can create your own ACL for each file in the basket. In WABS, everything happens at the blob container level.


The two most important functions are downloading and downloading, let's discuss them first, then compare the other functions.

Loading blobs and objects



Let's talk about loading blobs and objects in containers and baskets. There are two loading mechanisms - you can download a blob or an object completely within the framework of a single request or divide them into pieces (blocks or WABS pages, in GCS they do not have any special name).

Download in one request


If the downloaded data is small and you have a good connection speed, you can fully download this data in one request. WABS uses Put Blob for this . In the GCS- PUT Object or POST Object .

Loading pieces


You can share big data that is inefficient to load in a single request completely. Both systems allow you to break data into pieces (blocks or pages in WABS, in GCS they do not have any special name) and load gradually. In WABS, for block blobs, you must use Put Block and Put Block List , for page blobs - Put Page . GCS uses the POST Object and Put Object functions for this .

There are many reasons why you can decide whether to load data in chunks:

  • Very large data needs to be loaded. Please note that in WABS one block blob is limited to 200 GB, the page blob is 1 TB, in GCS you can have one object up to 5 TB. Such volumes are impractical to load in one request.
  • Low connection speed.
  • Both systems are cloud services designed to process requests of hundreds and thousands of users at the same time, and both systems will limit your requests if they run longer than the set limit - in WABS it takes 10 minutes to download 1 MB of data.
  • Dividing big data into pieces allows parallel loading (respectively, loading data faster).
  • In case of a broken loading of a piece, you can repeat its loading, but if the loading of large data loading in a single request fails, you have to download everything again, which is inefficient.
  • System limitations - WABS does not allow downloading data in a single request if its size exceeds 64 MB.


Let's see how to load data in pieces in each of the systems. For example, you want to upload a 100 MB file in chunks.

Wabs


Suppose each piece has a size of 1 MB (despite the fact that there is no need to have pieces of the same size) - you need to download 100 pieces. We take a block blob, each of the blocks (pieces) of which has a unique identifier (BlockId). To load it, use the Put Block function . BlockId is a Base64-encoded string with a maximum size of 64 bytes. All BlockId (100 in our case) should be the same length. It doesn’t matter in which order you load the blocks - you can load them in parallel. After loading a block, WABS puts it somewhere in the repository, and stores it for 7 days. After loading all the blocks, we call Put Block List ,confirming these blocks. You cannot contact the blob until this function is called, and if you have not confirmed the blocks within 7 days, they will be deleted by the system. After calling the function, based on the order of the BlockId list, WABS will recreate the blob and mark it as available. It doesn’t matter what values ​​BlockId will have (they can all be GUIDs), but it’s important in which order you send the BlockId when using Put Block List.

Limitations:

  • Blob can be divided into a maximum of 50,000 blocks.
  • A blob can have a maximum of 100,000 unconfirmed blocks at any given time.
  • A set of unconfirmed blocks cannot have a size larger than 400 GB.
  • All BlockId blocks of one blob must be of the same length, i.e. an unacceptable situation is when they are equal to block8, block9, block11.
  • The maximum length of BlockId is 64 bytes.


Gcs


In the case of GCS, uploading a large file in chunks is called “ Resumable Uploads ”. First you need to tell GCS that you started the boot process by calling the POST Object . Usually this function is used to upload a file using HTML forms, but in this case you do not define the file. You can define request headers that tell GCS that you have started the download process. After the download is complete, GCS will return a response containing the Upload Id that uniquely identifies the download process. This Id needs to be saved, as it will be needed when loading pieces. Next, you need to try to upload the file using the Put Object function.and passing it the Upload Id and the contents of the object. If everything works out, GCS will respond with an HTTP code of 200 Ok, but if the operation fails, you will have to ask GCS for the number of bytes downloaded. GCS will return the 308 Resume Incomplete HTTP code. Further it will be possible to continue loading data using Put Object.

Thoughts:

  • I think we can get rid of the first call to return the object of the function in which we are trying to load the entire file in the hope of getting the 200 OK code. If I try to download a 100 MB file, I am pretty sure that it will not load in one go. Instead of trying to download the whole file, I can skip the first two steps and just download a piece of this file, get its status and then reload it or download the next piece.
  • I'm not sure how it is possible to load chunks in GCS in parallel, when GCS returns the Range header when asking for the number of bytes loaded. WABS has a BlockId, in AS3 there is a part number, which facilitates the parallel loading task.


Download blobs and objects



Let's see how you can download blobs and objects. There are two mechanisms for this - either download the whole blob or object in one request, or in pieces.

Each system has only one download function - Get Blob in WABS and GET Object in GCS.

Download in one request


If the data is small and you have a good connection speed, you can download the object completely using Get Blob in WABS and GET Object in GCS.


Downloading in pieces


If the object is large and you are not sure whether you can download it at a time, you can download it in pieces using the same function with the addition of the Range header and determining the range of bytes needed for downloading.

Download process:

  1. Determine the size of the object. For example, it "weighs" 100 MB.
  2. Determine the size of the pieces. For example, it’s convenient for you to download 1 MB pieces.
  3. Call Get Blob or Get Object and pass them the corresponding values ​​in the Range header. If you download sequentially, your first request will have the value of this header “0 - ​​1048575” (0 - 1 Mb), the second request - “1048576 - 2097151” (1 - 2 Mb) and so on.
  4. After downloading, put the piece somewhere.
  5. After downloading all the pieces, create an empty 100 MB file and fill this file with the downloaded pieces.


Common points between WABS, AS3 and GCS



All three systems have common points, for example:

  • All three systems are cloud file systems with a two-level hierarchy.
  • All three systems allow you to store large amounts of data for a long time and cheaply.
  • All three systems provide a two-level hierarchy (baskets / objects in AS3 / GCS and blob containers / blobs in WABS).
  • All three systems provide a RESTful interface for interacting with their own services and a library of high-level languages, which are usually REST wrappers.


Common with AS3



When I first read about GCS, I found that GCS and AS3 have a lot in common, for example:

  • One terminology: both systems use similar terminology such as baskets and objects (in WABS they are called blob containers and blobs).
  • Same operation names: both systems use the same operation names. For example, a function from the API that returns a list of baskets is called GET Service on both systems.
  • Same pricing structure: both systems have a similar pricing structure. In WABS, all transactions are the same, AS3 and GCS have transaction costs, which vary depending on the operation being performed.
  • One hosting style: both systems support virtual-hosted-style (e.g. http://mybucket.s3.amazon.com/myobject ) and path-style (e.g. http: //s3-eu-west-1.amazonaws. com / mybucket / myobject ), while WABS only supports path-style (e.g. http://myaccount.blob.core.windows.net/myblobcontainer/myblob ).
  • A similar consistency model: Both systems provide a similar consistency model. For example, both systems provide a strong read-after-write robustness model for all PUT requests and ultimately robust stability for all List (GET) operations.


Unique moments at GCS



When we started discussing the basic functionality of GCS, it might seem that GCS provides less functionality than WABS and AS3, however, GCS has functions that are not found on any other platform. For instance:

  • OAuth 2.0 Authentication : This is a unique and modern feature that eliminates the need for credentials to be provided by users and applications when they need to access data. Learn more at https://developers.google.com/storage/docs/authentication#oauth .
  • Cookie-based authentication : GCS allows you to make authenticated browser requests (for those who do not have a GCS account). To do this, configure the ACL and give users the URL of the object. Learn more at https://developers.google.com/storage/docs/authentication#cookieauth .
  • Cross - Origin Resource Sharing (CORS) : Another unique and modern feature available only in GCS. The CORS specification developed by W3C is a policy applied in client-side applications to prevent interactions between resources from different origin ( same-origin policy implementation ). However, this function prevents not only dangerous behavior, but also quite useful and legitimate interactions between famous origins. GCS supports this specification by allowing you to configure baskets to return CORS-compliant responses. More details: https://developers.google.com/storage/docs/cross-origin. Please note that the function is at the “Experimental” stage (in other words, in beta :)). I'm not 100% sure, but it seems that the same thing can be achieved using the $ root blobs container in WABS.


Pricing



When using both systems, there are no "capital" costs. The pricing model is relatively simple and based on consumption. In both systems, the invoice is billed based on usage and it can consist of three components:

  1. Number of transactions : Payment is made according to the number of transactions made - roughly speaking, one transaction is one function call in the system. There is a significant difference between the two systems - in WABS, the transaction cost is fixed ($ 0.01 per 10,000 transactions), in GCS it varies depending on the type of transaction. If you perform PUT, COPY, POST, LIST operations, you pay a higher price per transaction ($ 0.01 per 1000 transactions), for GET and others you pay a lower price ($ 0.01 per 10,000 transactions). Removal requests are not written, but I assume that they are free in GCS.
  2. Storage : You pay for the amount of data stored on each system.


  1. Traffic : You pay for the amount of data transferred to and from the system. At the time of writing, both systems provide free incoming traffic. It is not mentioned whether the cost of data transfer is paid within the same data center in GCS.


A special pricing model is also available and both systems provide different payment packages. More about pricing - https://www.windowsazure.com/en-us/pricing/details/ for WABS and https://developers.google.com/storage/docs/pricingandterms for GCS.

Functions



The table summarizes the functions provided by WABS and GCS. It contains only functions supported by both systems.
 Wabs
Gcs
Create Container / Put Bucket
Yes
Yes
List Containers / GET Service
Yes
Yes
Delete Container / DELETE Bucket
Yes
Yes
List Blobs / GET Bucket (List Objects)
Yes
Yes
Set Container ACL / PUT Bucket (ACL or CORS)
Yes
Yes
Get Container ACL / Get Bucket (ACL or CORS)
Yes
Yes
Put Blob / PUT Object
Yes
Yes
POST Object
Not
Yes
Get Blob / GET Object
Yes
Yes
Delete Blob / DELETE Object
Yes
Yes
Copy Blob / PUT Object
Yes
Yes
Get Blob Properties / HEAD Object
Yes
Yes
Get Blob Metadata / HEAD Object
Yes
Yes

The following table lists the features supported only in WABS.
 Wabs
Gcs
Set blob service properties
Yes
Not
Get Blob Service Properties
Yes
Not
Set container metadata
Yes
Not
Get Container Metadata
Yes
Not
Set blob properties
Yes
Not
Set blob metadata
Yes
Not
Snapshot blob
Yes
Not
Lease blob
Yes
Not
Put block
Yes
Not
Put block list
Yes
Not
Get Block List / List Parts
Yes
Not
Put Page
Yes
Not
Get Page Ranges
Yes
Not

Let's consider these functions in more detail.
 Wabs
Gcs
Create Container / Put Bucket
Yes
Yes

This function creates a new blob container or basket.

An important point to keep in mind is that blob containers are limited to the storage account, while GCS baskets are limited to the GCS project. When you create a WABS storage account, you determine its location (data center), and your blob containers are located in a specific data center in a specific geographical location. When you create a basket in GCS, you determine the region in which this basket will be created, so you can distribute baskets to all data centers in GCS, if necessary. In order to do the same in WABS, you need to create a storage account for each data center in which you want to place containers.

There are several naming rules for blob containers and baskets, they are summarized in the table below.
 Wabs
Gcs
Min / Max length title
3/63
3/63
Case sensitivity
lower case
lower case
Allowed Characters
Alphanumeric and hyphen (-)
Alphanumeric, hyphen (-) and period (.)

More naming conventions:
  • The names of blob containers should start with a letter or number, but not with a hyphen, while after a hyphen a letter or number should go again, several consecutive hyphens are not allowed.
  • GCS basket names must consist of labels separated by a dot, where each label must begin and end with a lowercase letter or number, and the basket name should not look like an IP address (for example, 127.0.0.1).
  • Despite the fact that the names of the baskets can contain from 3 to 63 characters, if the name contains dots, then the name of the basket can be up to 222 characters, given the number of points.
  • Basket names cannot begin with the goog prefix.


Notes:

  • When creating a container or basket, you can specify an ACL (optional), if it is not specified, then the container or basket becomes private, that is, available only to the owner. In GCS, you cannot define ACLs during creation — the System Default ACLs are used during creation. Learn more at https://developers.google.com/storage/docs/accesscontrol#default . You can change the ACL or apply CORS to the basket after you create it.
  • WABS allows you to define your own metadata for a container, which are collections of key-value values ​​and have a maximum size of 8 KB. In GCS, this is not available.

 Wabs
Gcs
List Containers / GET Service
Yes
Yes


The function returns a list of all blob containers or baskets that belong to the authenticated owner in GCS.

Comments:

  • One call to this function in WABS will return a maximum of 5000 containers; if there are more of them in the storage account, a continuation token will also be returned. By default, WABS returns up to 5000 containers, but you can specify a smaller quantity. GCS does not mention this amount.
  • In WABS, you can perform filtering on the server side using the prefix from which the names of the containers that fall into the selection should begin.
  • In WABS, you can specify whether to return metadata for the blob container along with the list.

 Wabs
Gcs
Delete Container / DELETE Bucket
Yes
Yes

The function deletes the blob container or basket.

Comments:

  • Может так выглядеть, что эта операция выглядит как синхронная, в реальности же она не такая. Когда вы отправляете запрос на удаление контейнера блобов, он помечается для удаления и становится недоступным, после чего удаляется в процессе сборки мусора, поэтому реальное время удаления контейнера может варьироваться в зависимости от размера данных в этом контейнере. По моему опыту удаление очень большого контейнера может занять часы, и в это время попытка создания контейнера с таким же именем приведет к ошибке (Conflict Error – HTTP 409). В связи с этим необходимо планировать, что делать в это время.
  • В GCS корзина должна быть пустой перед удалением. Сначала необходимо удалить все объекты из корзины, после чего удалить ее. Иначе будет возвращена ошибка 409 Conflict.

 WABS
GCS
List Blobs / GET Bucket (List Objects)
Yes
Yes

The function is used to get a list of blobs and objects in a container or basket. The functions in the systems do the same thing, given:

  • Both functions allow you to limit the resulting selection to the desired number of objects.
  • Both functions have the maximum number of objects that they can return in one function call - in WABS this is 5000, in GCS it is 1000.
  • Обе функции поддерживают разделители, которые представляют из себя символ, группирующий блобы или объекты. Наиболее используемый разделитель — /. Как указывалось выше, обе системы поддерживают двухуровневую иерархию, и использование разделителя может создать иллюзию иерархию типа папки. Например, у вас есть следующие объекты: images/a.png, images/b.png, images/c.png, logs/1.txt, logs/2.txt, files.txt. Когда вы хотите вызвать функцию и передаете ей разделитель /, обе системы возвратят следующие значения: images, logs, files.txt.
  • Both functions support server-side filtering using prefixes. When your request contains a prefix, both systems will return objects that have a name that begins with this prefix. Using the example above, if we pass the prefix “images” without separators, both systems will return the following values: images / a.png, images / b.png, images / c.png.
  • Both functions can use a marker, which is, in fact, a continuation token, and is used to indicate to both systems that they should begin to receive a list of objects starting with this marker.
  • Both systems return objects in alphabetical order.


Differences:

  • One function call in WABS will return a maximum of 5000 blobs, GCS - 1000 objects.
  • Upon receipt of the list, you can indicate to WABS that it is also necessary to return snapshots of blobs. GCS cannot do this.
  • При получении списка можно указать WABS, что необходимо возвращать метаданные для блобов. В GCS метаданные для объектов не возвращаются – для этого необходимо использовать HEAD Object.
  • При получении списка можно указать WABS, что необходимо возвращать список блобов, которые ещё не подтверждены (commited), т.е. частично загружены, GCS же может возвращать только те объекты, которые уже полностью загружены.
  • Можно использовать эту функцию для получения конфигурации ACL или CORS для корзины.

 WABS
GCS
Set Container ACL/PUT Bucket (ACL or CORS)
Да
Да

The function is used to specify ACLs for containers or baskets, and one or more access policies can also be specified in WABS. CORS can also be configured in GCS (but CORS and ACL cannot be configured in the same request).

For a blob container, ACLs can be:



For baskets, ACLs can be:

  • READ : Allowed to get a list of objects in the basket.
  • WRITE : Allowed to create, overwrite and delete objects in the recycle bin.
  • FULL _ CONTROL : READ, WRITE permissions are granted with this value.


Convenient in GCS is that you can give users different permission sets, for example, user1 can have a READ ACL, user2 can have a WRITE ACL, WABS does not have such flexibility, permissions are set only on the blob container.

Convenient in WABS is that, in addition to ACLs, you can set up to 5 access policies for a container that define a temporary set of permissions for this container. For example, you can create an access policy with write permission on the blob container, which will be valid only for a day. Using policies allows you to generate a special URL with a signature and give it to users (flexible Shared Access Signatures functionality). Signatures allow you to issue access rights to containers and blobs at a more detailed level for a certain time.
 Wabs
Gcs
Get Container ACL / GET Bucket (ACL or CORS)
Yes
Yes

The function is used to obtain ACLs for the blob container or basket, and in WABS this function also returns the access policies defined for the container.

To get the ACL of the basket, you need to call GET Bucket with the string parameter “ acl ”, to get CORS, with the string parameter “ cors”. If neither one is specified, the list of objects in the basket is returned.

 Wabs
Gcs
Put Blob / PUT Object
Yes
Yes

The function adds the blob to the blob container and the object to the basket. This function can be used to indicate an ACL to an existing object in the GCS or to copy an object from one basket to another.

Comments:

  • On both systems, the function will overwrite the existing object with the specified name.
  • Обе системы позволяют определить свойства для объектов (cache control, тип содержимого и т.д.)
  • Обе системы позволяют послать хэш MD5 содержимого для проверки консистентности данных.
  • В GCS можно при создании объекта задать на него ACL, чего нельзя сделать в WABS.
  • Обе системы позволяют указывать метаданные для блобов и объектов в форме коллекции пар ключ-значение. В WABS максимальный размер этих метаданных – 8 Кб, в GCS – неизвестно.
  • При создании страничного блоба с использованием этой функции вы только инициируете страничный блоб, но не кладете в него данные. Для вставки данных необходимо использовать функцию Put Page.
  • При создании блочного блоба или объекта в GCS данные отправляются в запросе.
  • Максимальный размер блочного блоба, созданного с использованием этой функции, равен 64 Мб. Если размер больше, блоб должен быть разделен на блоки и загружен с помощью Put Block и Put Block List.
  • WABS позволяет определить предусловия, которые должны быть удовлетворены для успешного завершения этой функции (If-Modified-Since, If-Unmodified-Since, If-Match, If-None-Match).


 WABS
GCS
POST Object
Нет
Да

The function adds an object to the specified basket using an HTML form. POST is an alternative to PUT and allows the browser to load an object. Parameters passed to PUT using HTTP headers are passed from POST as the body of the encrypted multipart / form-data message.
 Wabs
Gcs
Get Blob / GET Object
Yes
Yes

The function allows you to download blob from a container or basket.

Comments:

  • You can download pieces by specifying the number of bytes in the Range header.
  • In WABS, the function also returns metadata for the downloaded blob.
  • In GCS, you can use this function to retrieve the contents of an object or its ACL.
  • Both systems allow you to determine the preconditions that must be satisfied for the successful completion of this function ( If - Modified - Since , If - Unmodified - Since , If - Match , If - None - Match ).
  • You can use this function to get blob versions - to get blob version you need to specify the date / time of blob snapshot.

 Wabs
Gcs
Delete Blob / DELETE Object
Yes
Yes

The function deletes the blob or object from the repository.

Comments:

  • In WABS, you can use this function to remove only snapshots without deleting the source. If the source is deleted, all of its snapshots are also deleted.
  • Эту функцию можно использовать для удаления конкретных версий блоба– для этого нужно указать дату/время снапшота блоба в WABS.


· WABS позволяет определить предусловия, которые должны быть удовлетворены для успешного завершения этой функции (If-Modified-Since, If-Unmodified-Since, If-Match, If-None-Match).
 WABS
GCS
Copy Blob/Put Object – Copy
Да
Да

The function copies the blob or object to somewhere from its original location.

Comments:

· Both systems allow you to determine the preconditions that must be satisfied for the successful completion of this function ( If- Modified- Since , If- Unmodified- Since , If- Match , If- None- Match ). These conditions can be defined both on the source and on the final copy in WABS and on the source in GCS.

· WABS allows you to copy objects from container to container only within one storage account. GCS has no such limitation. If the baskets between which the exchange takes place belong to the same project, the object will be copied. However, if you created an object using the API to load chunks, you will not be able to copy the object from region to region.

· Both systems allow you to copy existing metadata or specify metadata for the final copy.

  • In GCS, when copying, a specific ACL is deleted and the default ACL is set on the object. A custom ACL can be determined during the copy process using the appropriate request header.


Advice:

  • Both systems do not support renaming an object. Renaming an object can be done by first copying the object, and then deleting it.
  • You can also “upgrade” the blob or object version to the “current” version. To do this, specify the versioned blob (pointing to its snapshot) or object (pointing to its Version Id) and the final copy as an unversioned blob or object as the source for copying.

 Wabs
Gcs
Get Blob Properties / HEAD Object
Yes
Yes

The function is used to get blob properties and object metadata, but does not return the blob or object contents.

Comments:

  • Get Blob Properties in WABS and HEAD Object in GCS returns a set of user-defined metadata, standard HTTP properties, and system properties for a blob or object.
  • WABS позволяет определить предусловия, которые должны быть удовлетворены для успешного завершения этой функции (If-Modified-Since, If-Unmodified-Since, If-Match, If-None-Match).
  • Эту функцию можно использовать для получения свойств конкретной версии блоба. Для получения этой информации необходимо указать дату/время снапшота блоба. Если эти параметры опущены, возвращается информация о текущей версии.
  • Если необходимо возвратить только определенные пользователем метаданные для блоба в WABS, нужно использовать Get Blob Metadata.

 WABS
GCS
Get Blob Metadata/HEAD Object
Да
Да

The function returns user-defined metadata for the blob or object. This function can be used to get the properties of a specific version of blob or object. To obtain this information, you must specify the date / time of the snapshot blob in WABS.

Summary



As we saw from the article, both systems provide a similar set of functions, however, some functions are present in one system but absent in another. Despite this, one cannot talk about a big difference in functionality.

Note from the translator
Reading this review, the feeling that Google reasonably decided not to build lapsedas, but to go along the beaten and successful Amazon road, is evidenced by the almost complete identity of some parameters. Given that Amazon launched their service in 2006, and Google in 2010, it may well be that it was. However, Google has some really nice features that are lacking in other services - the same CORS, for example. In general, you can even try to say that the pace of development of Google and Microsoft services in a temporary context is higher than the pace of Amazon.
Thank you for your attention, as soon as the next materials are developed, I will translate them and provide them to your attention.

Also popular now: