Partager via

Créer et utiliser des jetons SAS de compte avec le Stockage Blob Azure et JavaScript

  • Article

Cet article explique comment créer et utiliser des jetons SAS de compte pour utiliser la bibliothèque de client du Stockage Blob Azure v12 pour JavaScript. Une fois la connexion établie, votre code peut opérer sur les conteneurs, les blobs et les fonctionnalités du service Stockage Blob Azure.

Des exemples d’extraits de code sont disponibles dans GitHub en tant que fichiers Node.js exécutables.

Package (npm) | Exemples | Référence API | Code source de la bibliothèque | Envoyer des commentaires

Jetons SAS de compte

Un jeton SAS de compte est un type de jeton SAS pour la délégation d’accès qui est fourni par le Stockage Azure. Un jeton SAS de compte fournit l’accès au Stockage Azure. Le niveau de restriction du jeton est défini lors de sa création. Étant donné que toute personne disposant du jeton peut l’utiliser pour accéder à votre compte de stockage, vous devez configurer le jeton avec les autorisations les plus restrictives qui permettent néanmoins au jeton d’effectuer les tâches nécessaires.

Les bonnes pratiques de création de jetons incluent la limitation des autorisations :

  • Services : blob, fichier, file d’attente, table
  • Types de ressources : service, conteneur ou objet
  • Autorisations comme : Créer, Lire, Écrire, Mettre à jour et Supprimer

Ajouter les dépendances nécessaires à votre application

Incluez les dépendances nécessaires pour créer un jeton SAS de compte.

const { 
    BlobServiceClient, 
    generateAccountSASQueryParameters, 
    AccountSASPermissions, 
    AccountSASServices,
    AccountSASResourceTypes,
    StorageSharedKeyCredential,
    SASProtocol 
} = require('@azure/storage-blob');
require('dotenv').config()

Obtenir des variables d’environnement pour créer des informations d’identification de clé partagée

Utilisez le nom et la clé du compte de stockage Blob pour créer un StorageSharedKeyCredential. Cette clé est nécessaire pour créer et utiliser le jeton SAS.

Créez une classe StorageSharedKeyCredential à l’aide du nom du compte de stockage et de la clé du compte. Utilisez ensuite StorageSharedKeyCredential pour initialiser un BlobServiceClient.

const constants = {
    accountName: process.env.AZURE_STORAGE_ACCOUNT_NAME,
    accountKey: process.env.AZURE_STORAGE_ACCOUNT_KEY
};
const sharedKeyCredential = new StorageSharedKeyCredential(
    constants.accountName,
    constants.accountKey
);

Code réutilisable d’opération asynchrone

Les exemples d’extraits de code restants supposent le code réutilisable asynchrone suivant pour Node.js.

async function main() {

    const sasToken = await createAccountSas();

    await useSasToken(sasToken);
}

main()
    .then(() => {
        console.log(`done`);
    }).catch((ex) => {
        console.log(`Error: ${ex.message}`)
    });

Créer un jeton SAS

Étant donné que ce jeton peut être utilisé avec des objets blob, des files d’attente, des tables et des fichiers, certains paramètres sont plus étendus que les options d’objet blob.

  1. Créez l’objet options.

    L’étendue des capacités d’un jeton SAS est définie par accountSASSignatureValues.

    Utilisez les fonctions d’assistance suivantes fournies par le SDK pour créer les types de valeurs corrects :

  2. Passez l’objet à la fonction generateAccountSASQueryParameters, ainsi que SharedKeyCredential, pour créer le jeton SAS.

    Avant de retourner le jeton SAS, ajoutez le délimiteur de chaîne de requête ?.

    async function createAccountSas() {

    const sasOptions = {

        services: AccountSASServices.parse("btqf").toString(),          // blobs, tables, queues, files
        resourceTypes: AccountSASResourceTypes.parse("sco").toString(), // service, container, object
        permissions: AccountSASPermissions.parse("rwdlacupi"),          // permissions
        protocol: SASProtocol.Https,
        startsOn: new Date(),
        expiresOn: new Date(new Date().valueOf() + (10 * 60 * 1000)),   // 10 minutes
    };

    const sasToken = generateAccountSASQueryParameters(
        sasOptions,
        sharedKeyCredential 
    ).toString();

    console.log(`sasToken = '${sasToken}'\n`);

    // prepend sasToken with `?`
    return (sasToken[0] === '?') ? sasToken : `?${sasToken}`;
}

  3. Sécurisez le jeton SAS jusqu’à son utilisation.

Utiliser le service Blob avec le jeton SAS de compte

Pour utiliser le jeton SAS de compte, vous devez le combiner avec le nom du compte pour créer l’URI. Passez l’URI pour créer blobServiceClient. Une fois que vous avez blobServiceClient, vous pouvez utiliser ce client pour accéder à votre service Blob.

// connect-with-sas-token.js
const { BlobServiceClient } = require('@azure/storage-blob');
require('dotenv').config()

const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME;
const sasToken = process.env.AZURE_STORAGE_SAS_TOKEN;
if (!accountName) throw Error('Azure Storage accountName not found');
if (!sasToken) throw Error('Azure Storage accountKey not found');

const blobServiceUri = `https://${accountName}.blob.core.windows.net`;

// https://YOUR-RESOURCE-NAME.blob.core.windows.net?YOUR-SAS-TOKEN
const blobServiceClient = new BlobServiceClient(
  `${blobServiceUri}?${sasToken}`,
  null
);

async function main(){
  
  const containerName = 'REPLACE-WITH-EXISTING-CONTAINER-NAME';
  const blobName = 'REPLACE-WITH-EXISTING-BLOB-NAME';

  const timestamp = Date.now();
  const fileName = `my-new-file-${timestamp}.txt`;

  // create container client
  const containerClient = await blobServiceClient.getContainerClient(containerName);

  // create blob client
  const blobClient = await containerClient.getBlockBlobClient(blobName);

  // download file
  await blobClient.downloadToFile(fileName);

  console.log(`${fileName} downloaded`);
  
}

main()
  .then(() => console.log(`done`))
  .catch((ex) => console.log(`error: ${ex.message}`));

Le package dotenv est utilisé pour lire le nom de votre compte de stockage à partir d’un fichier .env. Ce fichier ne doit pas être archivé dans le contrôle de code source.

Voir aussi