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

Cet article explique comment appeler une opération d’API REST 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 stockage Azure.

Prerequisites

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

• Installez Visual Studio et incluez 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 n’avez pas encore de compte de stockage, consultez Créer un compte de stockage.

• L’exemple de cet article montre 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écharger 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 référentiel 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

Rest (Representational State Transfer) 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 en cours d’exécution sur le serveur ou le client. L’API REST peut être appelée à partir de n’importe quelle plateforme prenant en charge HTTP/HTTPS. Vous pouvez écrire une application qui s’exécute sur un Mac, Windows, Linux, un téléphone ou une tablette Android, un iPhone, un iPod ou un site web, et utiliser la même API REST pour toutes ces plateformes.

Un appel à l’API REST se compose d’une requête effectuée par le client et d’une réponse retournée par le service. Dans la demande, vous envoyez une URL avec des informations sur l’opération à appeler, la ressource à agir, les paramètres de requête et les en-têtes, et en fonction de l’opération 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 appelée, une charge utile de données.

À propos de l’exemple d’application

L’exemple d’application répertorie les conteneurs dans un compte de stockage. Une fois que vous avez compris comment les informations de la documentation de l’API REST sont corrélées à votre code réel, d’autres appels REST sont plus faciles à comprendre.

Si vous examinez l’API REST du service Blob, vous voyez toutes les opérations que vous pouvez effectuer sur le stockage d’objets blob. Les bibliothèques clientes de stockage sont des wrappers autour des API REST, ce qui facilite l’accès aux ressources de stockage sans utiliser directement les API REST. Toutefois, vous souhaiterez peut-être utiliser l’API REST au lieu d’une bibliothèque de client de stockage.

Opération de liste des conteneurs

Cet article se concentre sur l’opération List Containers . Les informations suivantes vous aident à comprendre certains des champs de la demande 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. D’autres valeurs pour ce verbe incluent HEAD, PUT et DELETE, selon 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 : vous pouvez utiliser des paramètres de requête supplémentaires lors de l’appel de ListContainers. Quelques-uns de ces paramètres sont le délai d’expiration de l’appel (en secondes) et le préfixe, qui est utilisé pour le filtrage.

Un autre paramètre utile est maxresults : si plus de conteneurs sont disponibles que cette valeur, le corps de la réponse contient un élément NextMarker qui indique le conteneur suivant à retourner sur la requête suivante. Pour utiliser cette fonctionnalité, vous fournissez la valeur NextMarker comme paramètre de marqueur dans l’URI lorsque vous effectuez la requête suivante. Lorsque vous utilisez cette fonctionnalité, c'est comme feuilleter les résultats.

Pour utiliser des paramètres supplémentaires, ajoutez-les à la chaîne de ressource avec la valeur, comme cet 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 requis : un en-tête d’autorisation , 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 demande: il n’existe aucun corps de requête 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 décrites dans l’article Utilisation des signatures d’accès partagé (SAP).

Code d’état de la réponse: indique les codes d’état dont vous avez besoin. Dans cet exemple, un code d’état HTTP de 200 est ok. Pour obtenir la liste complète des codes d’état HTTP, consultez les définitions de code d’état. Pour afficher les codes d’erreur spécifiques aux API REST de stockage, consultez les codes d’erreur d’API REST courants

En-têtes de réponse: il s’agit du type de contenu ; x-ms-request-id, qui est l’ID de requête que vous avez passé ; x-ms-version, qui indique la version du service Blob utilisé ; et la date, qui est au format UTC et indique l’heure à laquelle la demande a été effectuée.

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

Création de la requête REST

Pour la sécurité lors de l’exécution en production, utilisez toujours HTTPS plutôt que HTTP. Dans le cadre de cet exercice, nous utilisons HTTP pour afficher les données de requête et de réponse. Pour afficher les informations de demande et de 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é de compte de stockage aux méthodes utilisées pour créer les différents 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’un coffre de clés Azure.

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

Pour générer la requête, qui est un objet HttpRequestMessage, accédez à ListContainersAsyncREST dans Program.cs. Les étapes de création 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 est null pour ListContainersAsyncREST, car nous ne transmettons rien.
• Ajoutez les en-têtes de requête pour x-ms-date et x-ms-version.
• Obtenez l’en-tête d’autorisation et ajoutez-le.

Voici quelques informations de base dont vous avez besoin :

• Pour ListContainers, la méthode est GET. Cette valeur est définie lors de l’instanciation de la requête.
• La ressource est la partie de requête de l’URI qui indique l’API appelée, de sorte que 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 finit par être http://contosorest.blob.core.windows.net/?comp=list.
• Pour ListContainers, requestBody est null et il n’existe aucun en-tête supplémentaire.

Différentes API peuvent avoir d’autres paramètres à transmettre, tels que ifMatch. Par exemple, vous pouvez utiliser ifMatch lors de l’appel de PutBlob. Dans ce cas, vous définissez ifMatch sur un eTag, et il met uniquement à jour l’objet blob si l’eTag que vous fournissez correspond à l’eTag actuel sur 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.

Tout d’abord, définissez le uri et le 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, définissez la méthode sur GET et fournissez 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. Cet emplacement dans le code est également l’endroit où vous ajoutez tous les en-têtes de requête supplémentaires requis pour l’appel. Dans cet exemple, il n’existe aucun en-tête supplémentaire. Un exemple d'API qui utilise des en-têtes supplémentaires est l’opération « Set Container ACL ». 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-la aux en-têtes de 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);

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

Envoyer la demande

Maintenant que vous avez construit la requête, 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. Ensuite, analysez la réponse. Dans ce cas, vous obtenez une liste XML de conteneurs. Examinons le code permettant d’appeler la méthode GetRESTRequest pour créer la requête, exécuter la requête, puis examiner la réponse pour la liste des 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 analyseur de réseau tel que Fiddler lorsque vous utilisez SendAsync, vous pouvez voir les informations de requête et de réponse. Regardons. Le nom du compte de stockage est contosorest.

Requête :

GET /?comp=list HTTP/1.1

En-têtes de demande :

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, cela 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 demande, appeler le service et analyser les résultats, voyons comment créer l’en-tête d’autorisation.

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

Pour en savoir plus sur les concepts d’autorisation, consultez Autoriser les demandes vers stockage Azure.

Nous allons distiller cet article pour ne garder que ce qui est nécessaire et afficher le code.

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

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

Le champ de signature est un code HMAC (Hash-based Message Authentication Code) 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 montre le format de la chaîne de signature de 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 d’objets blob, vous spécifiez VERB, md5, longueur du contenu, En-têtes canoniques et ressource canonique. Vous pouvez laisser les autres vides pour cet exemple, mais mettre dans \n pour spécifier qu’ils sont vides.

La canonisation est un processus de normalisation des données qui a 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 (par exemple ?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 les deux champs canoniques, car ils sont nécessaires pour créer l’en-tête Authorization.

En-têtes 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 en une chaîne d’instances [key:value\n] , concaténées en une seule chaîne. Pour cet exemple, les en-têtes canoniques ressemblent à ceci :

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 du compte réel (contosorest dans ce cas). Dans cet exemple, ce résultat est renvoyé :

/contosorest/\ncomp:list

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

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 canoniques sont définies, examinons comment créer l’en-tête d’autorisation lui-même. Vous commencez par créer une chaîne de la signature de message au format StringToSign précédemment affiché dans cet article. Ce concept est plus facile à expliquer à l’aide de commentaires dans le code. Voici donc 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 MessageSignature résultant 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 requête avant de publier la réponse.

Cela couvre tout ce que vous devez savoir pour mettre en place une classe avec laquelle vous pouvez créer une demande pour appeler les API REST des services de stockage.

Exemple : Répertorier les objets blob

Examinons comment modifier le code pour appeler l’opération List Blobs pour conteneur container-1. Ce code est presque identique au code pour répertorier les conteneurs, les seules différences étant l’URI et la façon dont vous analysez la réponse.

Si vous examinez la documentation de référence pour ListBlobs, vous constatez que la méthode est GET et requestURI :

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

Dans ListContainersAsyncREST, modifiez le code qui configure l’URI de 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);

Ensuite, où vous gérez la réponse, modifiez 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 suit :

En-têtes canoniques :

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

Ressource canonique :

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

Signature de 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 :

Requête :

GET http://contosorest.blob.core.windows.net/container-1?restype=container&comp=list HTTP/1.1

En-têtes de demande :

x-ms-date: Fri, 17 Nov 2017 05:16:48 GMT
x-ms-version: 2017-07-29
Authorization: SharedKey contosorest:uzvWZN1WUIv2LYC6e3En10/7EIQJ5X9KtFQqrZkxi6s=
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: 7e9316da-001e-0037-4063-5faf9d000000
x-ms-version: 2017-07-29
Date: Fri, 17 Nov 2017 05:20:21 GMT
Content-Length: 1135

Corps de la réponse (XML) : Cette réponse XML affiche la liste des objets blob et leurs propriétés.

<?xml version="1.0" encoding="utf-8"?>
<EnumerationResults
    ServiceEndpoint="http://contosorest.blob.core.windows.net/" ContainerName="container-1">
    <Blobs>
        <Blob>
            <Name>DogInCatTree.png</Name>
            <Properties><Last-Modified>Fri, 17 Nov 2017 01:41:14 GMT</Last-Modified>
            <Etag>0x8D52D5C4A4C96B0</Etag>
            <Content-Length>419416</Content-Length>
            <Content-Type>image/png</Content-Type>
            <Content-Encoding />
            <Content-Language />
            <Content-MD5 />
            <Cache-Control />
            <Content-Disposition />
            <BlobType>BlockBlob</BlobType>
            <LeaseStatus>unlocked</LeaseStatus>
            <LeaseState>available</LeaseState>
            <ServerEncrypted>true</ServerEncrypted>
            </Properties>
        </Blob>
        <Blob>
            <Name>GuyEyeingOreos.png</Name>
            <Properties>
                <Last-Modified>Fri, 17 Nov 2017 01:41:14 GMT</Last-Modified>
                <Etag>0x8D52D5C4A25A6F6</Etag>
                <Content-Length>167464</Content-Length>
                <Content-Type>image/png</Content-Type>
                <Content-Encoding />
                <Content-Language />
                <Content-MD5 />
                <Cache-Control />
                <Content-Disposition />
                <BlobType>BlockBlob</BlobType>
                <LeaseStatus>unlocked</LeaseStatus>
                <LeaseState>available</LeaseState>
                <ServerEncrypted>true</ServerEncrypted>
            </Properties>
            </Blob>
        </Blobs>
    <NextMarker />
</EnumerationResults>

Résumé

Dans cet article, vous avez appris à effectuer une demande à l’API REST de blob storage. Cette requête vous permet de récupérer une liste de conteneurs ou une liste d’objets blob dans un conteneur. Vous avez appris à créer la signature d’autorisation pour l’appel d’API REST et à l’utiliser dans la requête REST. Enfin, vous avez appris à examiner la réponse.

Étapes suivantes

• Blob Service REST API
• API REST du service de fichiers
• API REST du service de file d’attente
• Table Service REST API