Appeler des opérations de l’API REST avec l’autorisation de clé partagée

Article
11/20/2023

Cet article explique comment appeler une opération d’API REST de Stockage Azure en créant une requête REST autorisée à l’aide de C#. Après avoir appris à appeler une opération d’API REST pour le stockage Blob, vous pouvez utiliser des étapes similaires pour toute autre opération REST de Stockage Azure.

Prérequis

L'exemple d'application dresse la liste des conteneurs d'objets blob d'un compte de stockage. Pour tester le code de cet article, vous avez besoin des éléments suivants :

Installez Visual Studio et intégrez la charge de travail de Développement Azure. Cet exemple a été créé à l’aide de Visual Studio 2019. Si vous utilisez une autre version, les conseils peuvent varier légèrement.
Un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.
Un compte de stockage à usage général. Si vous ne possédez pas encore de compte de stockage, consultez Création d’un compte de stockage.
L’exemple dans cet article illustre comment répertorier les conteneurs dans un compte de stockage. Pour voir la sortie, ajoutez des conteneurs d’objets Blob au compte de stockage avant de commencer.

Téléchargement de l'exemple d'application

L’exemple d’application est une application console écrite en C#.

Utilisez git pour télécharger une copie de l’application dans votre environnement de développement.

git clone https://github.com/Azure-Samples/storage-dotnet-rest-api-with-auth.git

Cette commande clone le dépôt dans votre dossier git local. Pour ouvrir la solution Visual Studio, accédez au dossier storage-dotnet-rest-api-with-auth et ouvrez StorageRestApiAuth.sln.

À propos de REST

Representational State Transfer (REST) est une architecture qui vous permet d'interagir avec un service via un protocole Internet, tel que HTTP/HTTPS. REST est indépendant du logiciel exécuté sur le serveur ou sur le client. L'API REST peut être appelée à partir de n'importe quelle plateforme prenant en charge le protocole HTTP/HTTPS. Vous pouvez écrire une application sur Mac, Windows, Linux, un téléphone ou une tablette Android, iPhone, iPod, ou un site web, et vous pouvez utiliser la même API REST pour toutes ces plateformes.

Un appel à l’API REST se compose d’une requête formulée par le client et d'une réponse renvoyée par le service. Dans la requête, vous envoyez une URL contenant des informations sur l'opération à appeler, la ressource à utiliser, les paramètres de requête et les en-têtes et, selon l'opération qui a été appelée, une charge utile de données. La réponse du service comprend un code d'état, un ensemble d'en-têtes de réponse et, selon l'opération qui a été appelée, une charge utile de données.

À propos de l’exemple d’application

L’exemple d’application liste les conteneurs dans un compte de stockage. Une fois que vous comprenez la corrélation entre les informations dans la documentation sur l’API REST et votre code réel, les autres appels REST sont simples à comprendre.

Si vous regardez l’API REST du service Blob, vous voyez toutes les opérations que vous pouvez effectuer sur le Stockage Blob. Les bibliothèques clientes de stockage sont des wrappers autour des API REST. Elles vous permettent d’accéder facilement aux ressources de stockage sans utiliser les API REST directement. Cependant, vous voulez parfois utiliser l’API REST au lieu d’une bibliothèque cliente de stockage.

Opération List Containers (Répertorier les conteneurs)

Cet article se concentre sur l’opération List Containers. Les informations suivantes vous aident à comprendre certains des champs de la requête et de la réponse.

Méthode de requête : GET. Ce verbe est la méthode HTTP que vous spécifiez en tant que propriété de l’objet de requête. Les autres valeurs pour ce verbe incluent HEAD, PUT et DELETE en fonction de l’API que vous appelez.

URI de requête : https://myaccount.blob.core.windows.net/?comp=list. La requête est créée à partir du point de terminaison du compte de stockage d'objets blob https://myaccount.blob.core.windows.net et de la chaîne de ressources /?comp=list.

Paramètres d’URI : il s’agit de paramètres de requête supplémentaires que vous pouvez utiliser lors de l’appel de ListContainers. Certains de ces paramètres sont timeout pour l’appel (en secondes) et prefix, utilisé pour le filtrage.

Un autre paramètre utile est maxresults: s’il existe plus de conteneurs disponibles que cette valeur, le corps de la réponse contiendra un élément NextMarker indiquant le conteneur suivant à retourner pour la requête suivante. Pour utiliser cette fonctionnalité, vous fournissez la valeur NextMarker sous la forme du paramètre marker dans l’URI lors de la requête suivante. L’utilisation de cette fonctionnalité est similaire à la pagination des résultats.

Pour utiliser d’autres paramètres, ajoutez-les à la chaîne de ressource avec la valeur, comme par exemple :

/?comp=list&timeout=60&maxresults=100

En-têtes de requête : cette section répertorie les en-têtes de requête obligatoires et facultatifs. Trois des en-têtes sont obligatoires : un en-tête Authorization, x-ms-date (contient l’heure UTC de la requête) et x-ms-version (spécifie la version de l’API REST à utiliser). L’inclusion de x-ms-client-request-id dans les en-têtes est facultative. Vous pouvez définir la valeur de ce champ sur n’importe quoi, et elle est écrite dans les journaux d’activité d’analyse de stockage lorsque la journalisation est activée.

Corps de la requête : il n’existe pas de corps de la demande pour ListContainers. Le corps de la demande est utilisé sur toutes les opérations PUT lors du chargement d’objets blob, notamment SetContainerAccessPolicy. Le corps de la demande vous permet d’envoyer une liste XML de stratégies d’accès stockées à appliquer. Les stratégies d’accès stockées sont traitées dans l’article Utilisation des signatures d’accès partagé (SAP).

Code d’état de la réponse : indique tous les codes d’état que vous devez connaître. Dans cet exemple, un code d’état HTTP de 200 est acceptable. Pour obtenir la liste complète des codes d’état HTTP, consultez Définitions des codes d’état. Pour consulter les codes d’erreur spécifiques aux API REST de Stockage, consultez Codes d’erreur API REST courants

En-tête de réponse: ils incluent Type de contenu ; x-ms-request-id, à savoir l’ID de requête que vous avez transmis ; x-ms-version, qui indique la version du service BLOB utilisé, et Date, au format UTC, qui indique l’heure à laquelle la requête a été faite.

Corps de la réponse : ce champ est une structure XML qui fournit les données demandées. Dans cet exemple, la réponse est une liste de conteneurs et leurs propriétés.

Création de la requête REST

À des fins de sécurité lors de l'exécution en production, utilisez toujours HTTPS plutôt que HTTP. Pour cet exercice, nous utilisons HTTP pour pouvoir afficher la requête et les données de la réponse. Pour afficher la requête et les informations de la réponse dans les appels REST réels, vous pouvez télécharger Fiddler ou une application similaire. Dans la solution Visual Studio, le nom et la clé du compte de stockage sont codés en dur dans la classe. La méthode ListContainersAsyncREST transmet le nom du compte de stockage et la clé du compte de stockage aux méthodes utilisées pour créer les divers composants de la requête REST. Dans une application réelle, le nom et la clé du compte de stockage résident dans un fichier de configuration, des variables d’environnement ou sont récupérés à partir d’Azure Key Vault.

Dans notre exemple de projet, le code pour créer l’en-tête d’autorisation se trouve dans une autre classe. L’idée est que vous pourriez prendre l’ensemble de la classe, l’ajouter à votre propre solution et l’utiliser « tel quel ». Le code d’en-tête Autorisation fonctionne pour la plupart des appels d’API REST au Stockage Azure.

Pour générer la requête, qui est un objet HttpRequestMessage, accédez à ListContainersAsyncREST dans Program.cs. Les étapes de génération de la requête sont les suivantes :

Créez l’URI à utiliser pour appeler le service.
Créez l’objet HttpRequestMessage et définissez la charge utile. La charge utile a la valeur null pour ListContainersAsyncREST car nous ne transmettons rien.
Ajoutez les en-têtes de la requête pour x-ms-date et x-ms-version.
Obtenez l’en-tête d’autorisation et ajoutez-le.

Informations de base dont vous avez besoin :

Pour ListContainers, la méthode est GET. Cette valeur est définie lorsque la requête est instanciée.
La ressource est la partie de requête de l’URI qui indique quelle API est appelée, donc la valeur est /?comp=list. Comme indiqué précédemment, la ressource se trouve sur la page de documentation de référence qui affiche les informations sur l’API ListContainers.
L’URI est construit en créant le point de terminaison du service Blob pour ce compte de stockage et en concaténant la ressource. La valeur de l’URI de requête devient http://contosorest.blob.core.windows.net/?comp=list.
Pour ListContainers, requestBody a la valeur null et il n’y a aucun en-tête supplémentaire.

D’autres API peuvent avoir d’autres paramètres à transmettre, comme ifMatch. L’appel de PutBlob est un exemple d’utilisation de ifMatch. Dans ce cas, vous définissez ifMatch sur une eTag, et l’objet Blob n’est mis à jour que si l’eTag que vous fournissez correspond à l’eTag actuelle de l’objet Blob. Si un autre utilisateur a mis à jour l’objet Blob depuis la récupération de l’eTag, sa modification n’est pas écrasée.

Premièrement, définissez uri et requestPayload.

// Construct the URI. It will look like this:
//   https://myaccount.blob.core.windows.net/resource
String uri = string.Format("http://{0}.blob.core.windows.net?comp=list", storageAccountName);

// Provide the appropriate payload, in this case null.
//   we're not passing anything in.
Byte[] requestPayload = null;

Ensuite, instanciez la requête, en définissant la méthode sur GET et en fournissant l’URI.

// Instantiate the request message with a null payload.
using (var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, uri)
{ Content = (requestPayload == null) ? null : new ByteArrayContent(requestPayload) })
{

Ajoutez les en-têtes de requête pour x-ms-date et x-ms-version. C’est à cet emplacement dans le code que vous ajoutez les en-têtes de requête supplémentaires requis pour l’appel. Cet exemple ne contient pas d’en-tête supplémentaire. L'opération Set Container ACL est un exemple d'API transmettant des en-têtes supplémentaires. Cet appel d'API ajoute un en-tête appelé « x-ms-blob-public-access » et la valeur du niveau d'accès.

// Add the request headers for x-ms-date and x-ms-version.
DateTime now = DateTime.UtcNow;
httpRequestMessage.Headers.Add("x-ms-date", now.ToString("R", CultureInfo.InvariantCulture));
httpRequestMessage.Headers.Add("x-ms-version", "2017-07-29");
// If you need any additional headers, add them here before creating
//   the authorization header.

Appelez la méthode qui crée l’en-tête d’autorisation et ajoutez-le aux en-têtes de la requête. L’en-tête d’autorisation est créé plus loin dans l’article. Le nom de la méthode est GetAuthorizationHeader, que vous pouvez voir dans cet extrait de code :

// Get the authorization header and add it.
httpRequestMessage.Headers.Authorization = AzureStorageAuthenticationHelper.GetAuthorizationHeader(
    storageAccountName, storageAccountKey, now, httpRequestMessage);

httpRequestMessage contient la requête REST complète avec les en-têtes d’autorisation.

Envoyer la demande

Maintenant que vous avez construit la demande, vous pouvez appeler la méthode SendAsync pour l’envoyer au stockage Azure. Vérifiez que la valeur du code d’état de la réponse est 200, ce qui signifie que l’opération a réussi. Analysez ensuite la réponse. Dans ce cas, vous obtenez une liste XML de conteneurs. Observons le code utilisé pour appeler la méthode GetRESTRequest pour créer la requête, exécuter la requête, puis examiner dans la réponse la liste de conteneurs.

    // Send the request.
    using (HttpResponseMessage httpResponseMessage =
      await new HttpClient().SendAsync(httpRequestMessage, cancellationToken))
    {
        // If successful (status code = 200),
        //   parse the XML response for the container names.
        if (httpResponseMessage.StatusCode == HttpStatusCode.OK)
        {
            String xmlString = await httpResponseMessage.Content.ReadAsStringAsync();
            XElement x = XElement.Parse(xmlString);
            foreach (XElement container in x.Element("Containers").Elements("Container"))
            {
                Console.WriteLine("Container name = {0}", container.Element("Name").Value);
            }
        }
    }
}

Si vous exécutez un sniffer réseau comme Fiddler lors de l’appel à SendAsync, vous pouvez voir la requête et les informations de la réponse. Jetons un œil sur cette configuration. Le nom du compte de stockage est contosorest.

Requête :

GET /?comp=list HTTP/1.1

En-têtes de requête :

x-ms-date: Thu, 16 Nov 2017 23:34:04 GMT
x-ms-version: 2014-02-14
Authorization: SharedKey contosorest:1dVlYJWWJAOSHTCPGiwdX1rOS8B4fenYP/VrU0LfzQk=
Host: contosorest.blob.core.windows.net
Connection: Keep-Alive

Code d’état et en-têtes de réponse retournés après l’exécution :

HTTP/1.1 200 OK
Content-Type: application/xml
Server: Windows-Azure-Blob/1.0 Microsoft-HTTPAPI/2.0
x-ms-request-id: 3e889876-001e-0039-6a3a-5f4396000000
x-ms-version: 2017-07-29
Date: Fri, 17 Nov 2017 00:23:42 GMT
Content-Length: 1511

Corps de la réponse (XML) : pour l'opération List Containers (Répertorier les conteneurs), ce paramètre affiche la liste des conteneurs et leurs propriétés.

<?xml version="1.0" encoding="utf-8"?>
<EnumerationResults
  ServiceEndpoint="http://contosorest.blob.core.windows.net/">
  <Containers>
    <Container>
      <Name>container-1</Name>
      <Properties>
        <Last-Modified>Thu, 16 Mar 2017 22:39:48 GMT</Last-Modified>
        <Etag>"0x8D46CBD5A7C301D"</Etag>
        <LeaseStatus>unlocked</LeaseStatus>
        <LeaseState>available</LeaseState>
      </Properties>
    </Container>
    <Container>
      <Name>container-2</Name>
      <Properties>
        <Last-Modified>Thu, 16 Mar 2017 22:40:50 GMT</Last-Modified>
        <Etag>"0x8D46CBD7F49E9BD"</Etag>
        <LeaseStatus>unlocked</LeaseStatus>
        <LeaseState>available</LeaseState>
      </Properties>
    </Container>
    <Container>
      <Name>container-3</Name>
      <Properties>
        <Last-Modified>Thu, 16 Mar 2017 22:41:10 GMT</Last-Modified>
        <Etag>"0x8D46CBD8B243D68"</Etag>
        <LeaseStatus>unlocked</LeaseStatus>
        <LeaseState>available</LeaseState>
      </Properties>
    </Container>
    <Container>
      <Name>container-4</Name>
      <Properties>
        <Last-Modified>Thu, 16 Mar 2017 22:41:25 GMT</Last-Modified>
        <Etag>"0x8D46CBD93FED46F"</Etag>
        <LeaseStatus>unlocked</LeaseStatus>
        <LeaseState>available</LeaseState>
        </Properties>
      </Container>
      <Container>
        <Name>container-5</Name>
        <Properties>
          <Last-Modified>Thu, 16 Mar 2017 22:41:39 GMT</Last-Modified>
          <Etag>"0x8D46CBD9C762815"</Etag>
          <LeaseStatus>unlocked</LeaseStatus>
          <LeaseState>available</LeaseState>
        </Properties>
      </Container>
  </Containers>
  <NextMarker />
</EnumerationResults>

Maintenant que vous comprenez comment créer la requête, appeler le service et analyser les résultats, intéressons-nous à la création de l’en-tête d’autorisation.

Création de l’en-tête d’autorisation

Conseil

Stockage Azure prend en charge l’intégration de Microsoft Entra pour les objets blob et les files d’attente. Microsoft Entra ID offre une expérience beaucoup plus simple pour autoriser une requête destinée au stockage Azure. Pour plus d’informations sur l’utilisation de Microsoft Entra ID pour autoriser les opérations REST, consultez Autoriser avec Microsoft Entra ID. Pour obtenir une vue d’ensemble de l’intégration de Microsoft Entra à Stockage Azure, consultez Authentifier l’accès au stockage Azure avec Microsoft Entra ID.

Pour en savoir plus sur les concepts d’autorisation, consultez Autoriser les requêtes vers Stockage Azure.

Examinons cet article de plus près pour montrer le code.

Tout d’abord, utilisez une autorisation de clé partagée. Le format de l’en-tête d’autorisation ressemble à ce qui suit :

Authorization="SharedKey <storage account name>:<signature>"

Le champ de la signature est un code d’authentification de message basé sur le hachage (HMAC) créé à partir de la requête et calculé à l’aide de l’algorithme SHA256, puis encodé à l’aide de l’encodage Base64.

Cet extrait de code affiche le format de la chaîne de signature par clé partagée :

StringToSign = VERB + "\n" +  
               Content-Encoding + "\n" +  
               Content-Language + "\n" +  
               Content-Length + "\n" +  
               Content-MD5 + "\n" +  
               Content-Type + "\n" +  
               Date + "\n" +  
               If-Modified-Since + "\n" +  
               If-Match + "\n" +  
               If-None-Match + "\n" +  
               If-Unmodified-Since + "\n" +  
               Range + "\n" +  
               CanonicalizedHeaders +  
               CanonicalizedResource;

Pour le stockage Blob, vous spécifiez VERB, md5, content length (longueur du contenu), Canonicalized Headers (en-têtes rendus canoniques) et Canonicalized Resource (ressource rendue canonique). Vous pouvez laisser les autres vides pour cet exemple, mais entrez \n pour spécifier qu’ils sont vides.

La canonicalisation est un processus de normalisation des données qui ont plusieurs représentations possibles. Dans ce cas, vous standardisez les en-têtes et la ressource. Les en-têtes canoniques sont les en-têtes qui commencent par « x-ms- ». La ressource canonique est l’URI de la ressource, y compris le nom du compte de stockage et tous les paramètres de requête (comme ?comp=list). La ressource canonique inclut également tous les paramètres de requête supplémentaires que vous avez ajoutés, tels que timeout=60, par exemple.

Commençons par ces deux champs rendus canoniques, car ils sont obligatoires pour créer l’en-tête d’autorisation.

En-têtes rendus canoniques

Pour créer cette valeur, récupérez les en-têtes qui commencent par « x-ms- » et triez-les, puis mettez-les en forme de chaîne d’instances [key:value\n], concaténées en une seule chaîne. Pour cet exemple, les en-têtes rendus canoniques ressemblent à ce qui suit :

x-ms-date:Fri, 17 Nov 2017 00:44:48 GMT\nx-ms-version:2017-07-29\n

Voici le code utilisé pour créer cette sortie :

private static string GetCanonicalizedHeaders(HttpRequestMessage httpRequestMessage)
{
    var headers = from kvp in httpRequestMessage.Headers
        where kvp.Key.StartsWith("x-ms-", StringComparison.OrdinalIgnoreCase)
        orderby kvp.Key
        select new { Key = kvp.Key.ToLowerInvariant(), kvp.Value };

    StringBuilder headersBuilder = new StringBuilder();

    foreach (var kvp in headers)
    {
        headersBuilder.Append(kvp.Key);
        char separator = ':';

        // Get the value for each header, strip out \r\n if found, then append it with the key.
        foreach (string headerValue in kvp.Value)
        {
            string trimmedValue = headerValue.TrimStart().Replace("\r\n", string.Empty);
            headersBuilder.Append(separator).Append(trimmedValue);

            // Set this to a comma; this will only be used
            // if there are multiple values for one of the headers.
            separator = ',';
        }

        headersBuilder.Append("\n");
    }

    return headersBuilder.ToString();
}

Ressource rendue canonique

Cette partie de la chaîne de signature représente le compte de stockage ciblé par la requête. N’oubliez pas que l’URI de requête est http://contosorest.blob.core.windows.net/?comp=list, avec le nom de compte réel (contosorest dans ce cas). Dans cet exemple, voici ce qui est retourné :

/contosorest/\ncomp:list

Si vous avez des paramètres de requête, cet exemple les inclut également. Voici le code, qui traite aussi les paramètres de requête supplémentaires et les paramètres de requête avec plusieurs valeurs. N’oubliez pas que vous générez ce code pour qu’il fonctionne avec toutes les API REST. Vous souhaitez inclure toutes les possibilités, même si la méthode ListContainers n’a pas besoin de toutes.

private static string GetCanonicalizedResource(Uri address, string storageAccountName)
{
    // The absolute path will be "/" because for we're getting a list of containers.
    StringBuilder sb = new StringBuilder("/").Append(storageAccountName).Append(address.AbsolutePath);

    // Address.Query is the resource, such as "?comp=list".
    // This ends up with a NameValueCollection with 1 entry having key=comp, value=list.
    // It will have more entries if you have more query parameters.
    NameValueCollection values = HttpUtility.ParseQueryString(address.Query);

    foreach (var item in values.AllKeys.OrderBy(k => k))
    {
        sb.Append('\n').Append(item.ToLower()).Append(':').Append(values[item]);
    }

    return sb.ToString();
}

Maintenant que les chaînes rendues canoniques sont définies, jetons un œil à la création de l’en-tête d’autorisation même. Vous commencez par créer une chaîne de la signature du message au format StringToSign précédemment illustré dans cet article. Ce concept est plus facile à expliquer à l’aide de commentaires dans le code, donc voici la méthode finale qui retourne l’en-tête d’autorisation :

internal static AuthenticationHeaderValue GetAuthorizationHeader(
    string storageAccountName, string storageAccountKey, DateTime now,
    HttpRequestMessage httpRequestMessage, string ifMatch = "", string md5 = "")
{
    // This is the raw representation of the message signature.
    HttpMethod method = httpRequestMessage.Method;
    String MessageSignature = String.Format("{0}\n\n\n{1}\n{5}\n\n\n\n{2}\n\n\n\n{3}{4}",
                method.ToString(),
                (method == HttpMethod.Get || method == HttpMethod.Head) ? String.Empty
                  : httpRequestMessage.Content.Headers.ContentLength.ToString(),
                ifMatch,
                GetCanonicalizedHeaders(httpRequestMessage),
                GetCanonicalizedResource(httpRequestMessage.RequestUri, storageAccountName),
                md5);

    // Now turn it into a byte array.
    byte[] SignatureBytes = Encoding.UTF8.GetBytes(MessageSignature);

    // Create the HMACSHA256 version of the storage key.
    HMACSHA256 SHA256 = new HMACSHA256(Convert.FromBase64String(storageAccountKey));

    // Compute the hash of the SignatureBytes and convert it to a base64 string.
    string signature = Convert.ToBase64String(SHA256.ComputeHash(SignatureBytes));

    // This is the actual header that will be added to the list of request headers.
    AuthenticationHeaderValue authHV = new AuthenticationHeaderValue("SharedKey",
        storageAccountName + ":" + signature);
    return authHV;
}

Lorsque vous exécutez ce code, le paramètre MessageSignature qui en résulte ressemble à cet exemple :

GET\n\n\n\n\n\n\n\n\n\n\n\nx-ms-date:Fri, 17 Nov 2017 01:07:37 GMT\nx-ms-version:2017-07-29\n/contosorest/\ncomp:list

Voici la valeur finale pour AuthorizationHeader :

SharedKey contosorest:Ms5sfwkA8nqTRw7Uury4MPHqM6Rj2nfgbYNvUKOa67w=

AuthorizationHeader est le dernier en-tête placé dans les en-têtes de la requête avant de publier la réponse.

Ceci conclut tout ce que vous devez savoir pour créer une classe grâce à laquelle vous pouvez créer une requête pour appeler les API REST des services Stockage.

Exemple : List blobs (Répertorier les objets BLOB)

Voyons comment modifier le code afin d'appeler l'opération List Blobs pour le conteneur container-1. Ce code est presque identique au code utilisé pour lister les conteneurs, les seules différences étant l’URI et la façon d’analyser la réponse.

Si vous consultez la documentation de référence pour ListBlobs, vous constaterez que la méthode est GET et l’URI de la requête est :

https://myaccount.blob.core.windows.net/container-1?restype=container&comp=list

Dans ListContainersAsyncREST, changez le code qui définit l’URI sur l’API pour ListBlobs. Le nom du conteneur est container-1.

String uri =
    string.Format("http://{0}.blob.core.windows.net/container-1?restype=container&comp=list",
      storageAccountName);

Puis, là où vous traitez la réponse, changez le code pour rechercher des objets Blob au lieu de conteneurs.

foreach (XElement container in x.Element("Blobs").Elements("Blob"))
{
    Console.WriteLine("Blob name = {0}", container.Element("Name").Value);
}

Lorsque vous exécutez cet exemple, vous obtenez des résultats comme ceux ci-dessous :

En-têtes rendus canoniques :

x-ms-date:Fri, 17 Nov 2017 05:16:48 GMT\nx-ms-version:2017-07-29\n

Ressource rendue canonique :

/contosorest/container-1\ncomp:list\nrestype:container

Signature du message :

GET\n\n\n\n\n\n\n\n\n\n\n\nx-ms-date:Fri, 17 Nov 2017 05:16:48 GMT
  \nx-ms-version:2017-07-29\n/contosorest/container-1\ncomp:list\nrestype:container

En-tête d'autorisation :

SharedKey contosorest:uzvWZN1WUIv2LYC6e3En10/7EIQJ5X9KtFQqrZkxi6s=

Les valeurs suivantes proviennent de Fiddler :