Skip to main content

Shared Access Signature on Windows Azure - Overview

Until now we saw how we can work with Shared Access Signature on blobs, tables and queues on Windows Azure. In this post we will try to see how this mechanism works in more details.
The Shared Access Signature can be used from any language. Until now I have example only from C#, where we used the current API to make calls to generate and set the access policy. This is not the only way to generate and configure them. All this features are exposed on Windows Azure as a RES API that can be used very easily.
There are different ways to make the REST API calls; we can send the configuration items in the query string or in the body of the request. The most important think that we need to know is that each access policy that is created need to have a unique id (string) and a list of permissions. Each type of resources supports different permissions types:
  • Read – r
  • Add – a
  • Update – u
  • Delete - d
  • Process – p
  • List - l
For each resource that is used we need to define the permissions in a specific order. For example if we want to define for a table the add and the read permissions, we cannot defined the add permissions first and after that the read permissions. In the following I will order the permissions for each resource:
  • Table – raud
  • Container (blob container) – rwdl
  • Blob - rwd
  • Queue – raup
When we want to create a Shared Access Policy using the REST API we need to specify the following data (parameters):
  • REST URL
  • REST URL parameters
  • signedversion (sv)– represent the version of the Shared Access Policy. This need to use in the case you is using a Shared Access Policy version before 12/02/2012.
  • signedresource (sr, only for blobs) – define what resources from a blob are accessible. The supported values are “b” and “c”. When we specify “b” we grand access to the blob content and metadata. “c” need to be specify when we work with container, by using it we grand access to list of blobs and all blobs from that container.
  • tablename (tb, only for tables) – the name of the table that we want to share.
  • access policy – the access policy right on the given resource. We will talk about this resource later on.
  • signedidentifier (si) –unique identifier for each access policy that is defined. Using this id we can delete and update any access policy.
  • signature (sig) – the signature that is used to authenticate the request.
The access policy parameter is not form from only one parameter. This is a collection of parameters that need to be set. Using these parameters we defined the access policy rights. The following parameters need (can) be set for access policy:
  • signedstart (st) – the start time from when the access policy is valid
  • signedexpiry (se) – the end time of the access policy
  • signedpermissions (sp) – the permissions associated with the given resource
  • startpk (spk), startrk (srk), endpk (epk), endrk (erk) – only for tables, the start and end row key and partition key
If you are working with, the simple solution is to use the API directly from code. This will generate automatically the REST API calls. But we don’t need to create the calls by hand.
An interesting think about Shared Access Policy is the number of access policies that we can define. Each queue, table, blob or container can have maximum 5 access policies. For each access policies we can define how many access token we want.
A very common scenario when Shared Access Signature is used is when a consumer what to access a specific resources and we don’t want to manually creating the access policy for him. For this case we can define a service on a web role or on a worker role that create the access policy automatically.  Using this flow, it is very easy to control automatically the users that have access to a given resource. If the user needs to renew his token, the only think that need to do is to send a new request to the web role that generate the access token and renew the old one.
When we are using Shared Access Policy we should try to respect the following recommendations:
  • Don’t generate lifetime access token – Try not to have access token that expired in 10 year. The lifetime of an access token should be limited. If the token expired, than the user should request a new token (or you can have an automatically mechanism that renew the access policy).
  • Send the access token by HTTPS – Any user that has the access token can access your resources. Because of this try to use a secure connection when you send the access token to the consumer. A simple and safe way is HTTPS.
  • Clock skew – On different machines we can have different time. The maxim difference that is accepted between machines on Windows Azure is 300 seconds. If you set the start time of an access policy, try to have in mind this time period.
  • Group access policy – For each resource we can define maximum 5 access policies. Because of this we should group our access policies based on some logic. When we revoke an access policies, all access token for that access policy are invalidated.
In this post we saw we discuss about some particularities that Shared Access Policy have and how can be access using the REST API. This is a powerful feature and need to be used carefully, because we don’t want any person to have access our private data from blobs, tables or queues.

Tutorials about Shared Access Signature:
  1. Overview
  2. How to use Shared Access Signature with tables from Windows Azure
  3. How to use Shared Access Signature with blobs from Windows Azure
  4. How to use Shared Access Signature with queues from Windows Azure
  5. How to remove or edit a Shared Access Signature from Windows Azure 
  6. Some scenarios when we can use Shared Access Signature from Windows Azure

Comments

  1. What I would be interesting to know what are some real-life scenarios where shared-access signature is useful (in custom applications hosted on cloud that use tables, blobs or queues).

    ReplyDelete

Post a Comment

Popular posts from this blog

Windows Docker Containers can make WIN32 API calls, use COM and ASP.NET WebForms

After the last post , I received two interesting questions related to Docker and Windows. People were interested if we do Win32 API calls from a Docker container and if there is support for COM. WIN32 Support To test calls to WIN32 API, let’s try to populate SYSTEM_INFO class. [StructLayout(LayoutKind.Sequential)] public struct SYSTEM_INFO { public uint dwOemId; public uint dwPageSize; public uint lpMinimumApplicationAddress; public uint lpMaximumApplicationAddress; public uint dwActiveProcessorMask; public uint dwNumberOfProcessors; public uint dwProcessorType; public uint dwAllocationGranularity; public uint dwProcessorLevel; public uint dwProcessorRevision; } ... [DllImport("kernel32")] static extern void GetSystemInfo(ref SYSTEM_INFO pSI); ... SYSTEM_INFO pSI = new SYSTEM_INFO(

Azure AD and AWS Cognito side-by-side

In the last few weeks, I was involved in multiple opportunities on Microsoft Azure and Amazon, where we had to analyse AWS Cognito, Azure AD and other solutions that are available on the market. I decided to consolidate in one post all features and differences that I identified for both of them that we should need to take into account. Take into account that Azure AD is an identity and access management services well integrated with Microsoft stack. In comparison, AWS Cognito is just a user sign-up, sign-in and access control and nothing more. The focus is not on the main features, is more on small things that can make a difference when you want to decide where we want to store and manage our users.  This information might be useful in the future when we need to decide where we want to keep and manage our users.  Feature Azure AD (B2C, B2C) AWS Cognito Access token lifetime Default 1h – the value is configurable 1h – cannot be modified

What to do when you hit the throughput limits of Azure Storage (Blobs)

In this post we will talk about how we can detect when we hit a throughput limit of Azure Storage and what we can do in that moment. Context If we take a look on Scalability Targets of Azure Storage ( https://azure.microsoft.com/en-us/documentation/articles/storage-scalability-targets/ ) we will observe that the limits are prety high. But, based on our business logic we can end up at this limits. If you create a system that is hitted by a high number of device, you can hit easily the total number of requests rate that can be done on a Storage Account. This limits on Azure is 20.000 IOPS (entities or messages per second) where (and this is very important) the size of the request is 1KB. Normally, if you make a load tests where 20.000 clients will hit different blobs storages from the same Azure Storage Account, this limits can be reached. How we can detect this problem? From client, we can detect that this limits was reached based on the HTTP error code that is returned by HTTP