Creare una SAS delegata dall'utente per Azure Blob, File di Azure e Azure Queue con .NET

Una firma di accesso condiviso (SAS) permette all'utente di concedere l'accesso limitato a contenitori e BLOB nell'account di archiviazione. Quando si crea una firma di accesso condiviso, si specificano i relativi vincoli, incluse le risorse di Archiviazione di Azure alle quali un client è autorizzato ad accedere, le autorizzazioni di cui dispone per tali risorse e la durata della validità della firma di accesso condiviso.

Ogni SAS è firmata con una chiave. È possibile firmare un SAS in uno dei due modi:

Con una chiave creata utilizzando le credenziali di Microsoft Entra. Una SAS firmata con credenziali Microsoft Entra è una SAS delegata dall'utente. A un client che crea una SAS di delega utente deve essere assegnato un ruolo RBAC di Azure che include l'azione Microsoft.Storage/storageAccounts/blobServices/generateUserDelegationKey. Per saperne di più, vedere Creare una firma di accesso condiviso delegata dall'utente.
Con la chiave dell’account di archiviazione. Una chiave di accesso condiviso del servizio e una chiave di accesso condiviso dell'account sono entrambe firmate con la chiave dell'account condivisa. Il client che crea una SAS di servizio deve avere accesso diretto alla chiave dell'account oppure deve essergli assegnata l'autorizzazione Microsoft.Storage/storageAccounts/listkeys/action. Per altre informazioni, vedere Creare una firma di accesso condiviso del servizio oppure Creare una firma di accesso condiviso dell'account.

Nota

Una firma di accesso condiviso di delega utente offre una sicurezza superiore rispetto a una firma di accesso condiviso di delega utente firmata con la chiave dell'account di archiviazione. Quando possibile, Microsoft consiglia di usare una SAS di delega utente. Per altre informazioni, vedere Concedere accesso limitato ai dati con firme di accesso condiviso.

Questo articolo illustra come utilizzare le credenziali di Microsoft Entra per creare una firma di accesso condiviso delegata dall'utente per un contenitore o BLOB usando la libreria client dell'Archiviazione di Azure per .NET.

Informazioni sulla firma di accesso condiviso (SAS) delegata all'utente

Un token SAS per accedere a un contenitore o a un BLOB può essere protetto usando le credenziali di Microsoft Entra o la chiave dell'account. Una SAS protetta con le credenziali di Microsoft Entra è chiamata SAS di delega utente, perché il token OAuth 2.0 usato per firmare la SAS viene richiesto per conto dell'utente.

Microsoft raccomanda di usare le credenziali di Microsoft Entra, quando è possibile, come procedura consigliata per la sicurezza, invece di usare la chiave dell'account, che può essere compromessa più facilmente. Se la progettazione dell'applicazione richiede firme di accesso condiviso (SAS), usa le credenziali di Microsoft Entra per creare una SAS di delega utente per una sicurezza superiore. Per altre informazioni sulla SAS di delega utente, vedi Creare una SAS di delega utente.

Attenzione

Qualsiasi client che disponga di una firma di accesso condiviso (SAS) valida può accedere ai dati nel tuo account di archiviazione, come consentito da tale SAS. È importante proteggere una SAS da un uso malevolo o non intenzionale. Usare prudenza nella distribuzione di una firma di accesso condiviso (SAS) e disporre di un piano per revocare un SAS compromesso.

Per altre informazioni sulle firme di accesso condiviso, vedere Concedere accesso limitato alle risorse di archiviazione di Azure tramite firme di accesso condiviso.

Assegnare ruoli di Azure per l'accesso ai dati

Quando un'entità di sicurezza di Microsoft Entra tenta di accedere ai dati, tale entità deve avere le autorizzazioni per la risorsa. Se l'entità di sicurezza è un'identità gestita in Azure o un account utente Microsoft Entra che esegue codice nell'ambiente di sviluppo, all'entità di sicurezza deve essere assegnato un ruolo di Azure che concede l'accesso ai dati. Per informazioni sull'assegnazione delle autorizzazioni tramite Azure RBAC, vedere Assegnare un ruolo di Azure per l'accesso ai dati BLOB.

Impostare il progetto

Per usare gli esempi di codice in questo articolo, seguire questa procedura per configurare il progetto.

Installare i pacchetti

Installare i pacchetti seguenti:

.NET CLI
PowerShell

dotnet add package Azure.Identity
dotnet add package Azure.Storage.Blobs

Install-Package Azure.Identity
Install-Package Azure.Storage.Blobs

Configurare il codice dell'app

Aggiungere le direttive seguenti using per i BLOB:

using Azure;
using Azure.Identity;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using Azure.Storage.Blobs.Specialized;
using Azure.Storage.Sas;

Aggiungere le direttive seguenti using per File:

using Azure;
using Azure.Identity;
using Azure.Storage.Files;
using Azure.Storage.Files.Models;
using Azure.Storage.Files.Specialized;
using Azure.Storage.Sas;

Aggiungi le seguenti direttive using per le code:

using Azure;
using Azure.Identity;
using Azure.Storage.Queues;
using Azure.Storage.Queues.Models;
using Azure.Storage.Queues.Specialized;
using Azure.Storage.Sas;

Ottenere una credenziale del token autenticato

Per ottenere una credenziale token che il codice può usare per autorizzare le richieste all'Archiviazione BLOB, crea un'istanza della classe DefaultAzureCredential. Per altre informazioni sull'uso della classe DefaultAzureCredential per autorizzare un'identità gestita ad accedere all'archiviazione BLOB, vedere Libreria client di Identità di Azure per .NET.

Il frammento di codice seguente illustra come ottenere le credenziali del token autenticato e usarlo per creare un client del servizio per l'archiviazione BLOB:

// Construct the blob endpoint from the account name.
string endpoint = $"https://{accountName}.blob.core.windows.net";

// Create a blob service client object using DefaultAzureCredential
BlobServiceClient blobServiceClient = new BlobServiceClient(
    new Uri(endpoint),
    new DefaultAzureCredential());

Per altre informazioni sull'autorizzazione dell'accesso all'archiviazione BLOB dalle applicazioni con .NET SDK, vedere Come autenticare le applicazioni .NET con i servizi di Azure.

Il frammento di codice seguente illustra come ottenere le credenziali del token autenticato e usarlo per creare un client del servizio per l'archiviazione file:

// Construct the file endpoint from the account name.
string endpoint = $"https://{accountName}.file.core.windows.net”;

// Create a file service client object using DefaultAzureCredential
FilesServiceClient filesServiceClient = new filesServiceClient(
    new Uri(endpoint),
    new DefaultAzureCredential());

Il frammento di codice seguente mostra come ottenere la credenziale del token autenticato e usarla per creare un client di servizio per l'archiviazione code:

// Construct the queue endpoint from the account name.
string endpoint = $"https://{accountName}.queue.core.windows.net";

// Create a queue service client object using DefaultAzureCredential
QueueServiceClient queueServiceClient = new QueueServiceClient(
    new Uri(endpoint),
    new DefaultAzureCredential());

Ottenere la chiave di delega utente

Ogni SAS è firmata con una chiave. Per creare una SAS di delega utente, è innanzitutto necessario richiedere una chiave di delega utente, che viene quindi usata per firmare la SAS. La chiave di delega utente è analoga alla chiave dell'account usata per firmare una firma di accesso condiviso di servizio o dell'account, tranne per il fatto che si basa sulle credenziali di Microsoft Entra. Quando un client richiede una chiave di delega utente utilizzando un token OAuth 2.0, l'Archivio BLOB restituisce la chiave di delega utente per conto dell'utente.

Dopo aver ottenuto la chiave di delega utente, è possibile utilizzarla per creare un numero qualsiasi di firme di accesso condiviso di delega utente, per l'intera durata della chiave. La chiave di delega utente è indipendente dal token OAuth 2.0 utilizzato per acquisirla, quindi non è necessario rinnovare il token se la chiave è ancora valida. È possibile specificare l'intervallo di tempo di validità della chiave, fino a un massimo di sette giorni.

Utilizzare uno dei metodi seguenti per richiedere la chiave di delega utente:

L'esempio di codice seguente illustra come richiedere la delega utente per i BLOB:

public static async Task<UserDelegationKey> RequestUserDelegationKey(
    BlobServiceClient blobServiceClient)
{
    // Get a user delegation key for the Blob service that's valid for 1 day
    UserDelegationKey userDelegationKey =
        await blobServiceClient.GetUserDelegationKeyAsync(
            DateTimeOffset.UtcNow,
            DateTimeOffset.UtcNow.AddDays(1));

    return userDelegationKey;
}

L'esempio di codice seguente illustra come richiedere la delega utente per Files:

public static async Task<UserDelegationKey> RequestUserDelegationKey(
    FileServiceClient fileServiceClient)
{
    // Get a user delegation key for the Azure Files Service that's valid for 1 day
    UserDelegationKey userDelegationKey =
        await fileServiceClient.GetUserDelegationKeyAsync(
            DateTimeOffset.UtcNow,
            DateTimeOffset.UtcNow.AddDays(1));

    return userDelegationKey;
}

Nell'esempio di codice seguente viene illustrato come richiedere la delega utente per le code:

public static async Task<UserDelegationKey> RequestUserDelegationKey(
    QueueServiceClient queueServiceClient)
{
    // Get a user delegation key for the Queue service that's valid for 1 day
    UserDelegationKey userDelegationKey =
        await queueServiceClient.GetUserDelegationKeyAsync(
            DateTimeOffset.UtcNow,
            DateTimeOffset.UtcNow.AddDays(1));

    return userDelegationKey;
}

Crea una SAS con delega utente

È possibile creare una firma di accesso condiviso con delega utente per un contenitore BLOB, un BLOB, una condivisione di file, un file o una coda, in base alle esigenze dell'app.

Dopo aver ottenuto la chiave di delega utente, è possibile creare una firma di accesso condiviso di delega utente per concedere l'accesso limitato a un contenitore. L'esempio di codice seguente mostra come creare una firma di accesso condiviso con delega utente per un contenitore:

public static async Task<Uri> CreateUserDelegationSASContainer(
    BlobContainerClient containerClient,
    UserDelegationKey userDelegationKey)
{
    // Create a SAS token for the container resource that's also valid for 1 day
    BlobSasBuilder sasBuilder = new BlobSasBuilder()
    {
        BlobContainerName = containerClient.Name,
        Resource = "c",
        StartsOn = DateTimeOffset.UtcNow,
        ExpiresOn = DateTimeOffset.UtcNow.AddDays(1)
    };

    // Specify the necessary permissions
    sasBuilder.SetPermissions(BlobSasPermissions.Read | BlobSasPermissions.Write);

    // Add the SAS token to the blob URI
    BlobUriBuilder uriBuilder = new BlobUriBuilder(containerClient.Uri)
    {
        // Specify the user delegation key
        Sas = sasBuilder.ToSasQueryParameters(
            userDelegationKey,
            containerClient.GetParentBlobServiceClient().AccountName)
    };

    return uriBuilder.ToUri();
}

Dopo aver ottenuto la chiave di delega utente, è possibile creare una SAS di delega utente per delegare un accesso limitato a un blob. L'esempio di codice seguente mostra come creare una firma di accesso condiviso con delega utente per un BLOB:

public static async Task<Uri> CreateUserDelegationSASBlob(
    BlobClient blobClient,
    UserDelegationKey userDelegationKey)
{
    // Create a SAS token for the blob resource that's also valid for 1 day
    BlobSasBuilder sasBuilder = new BlobSasBuilder()
    {
        BlobContainerName = blobClient.BlobContainerName,
        BlobName = blobClient.Name,
        Resource = "b",
        StartsOn = DateTimeOffset.UtcNow,
        ExpiresOn = DateTimeOffset.UtcNow.AddDays(1)
    };

    // Specify the necessary permissions
    sasBuilder.SetPermissions(BlobSasPermissions.Read | BlobSasPermissions.Write);

    // Add the SAS token to the blob URI
    BlobUriBuilder uriBuilder = new BlobUriBuilder(blobClient.Uri)
    {
        // Specify the user delegation key
        Sas = sasBuilder.ToSasQueryParameters(
            userDelegationKey,
            blobClient
            .GetParentBlobContainerClient()
            .GetParentBlobServiceClient().AccountName)
    };

    return uriBuilder.ToUri();
}

Dopo aver ottenuto la chiave di delega utente, è possibile creare una SAS di delega utente per concedere un accesso limitato a un file. L'esempio di codice seguente mostra come creare una firma di accesso condiviso con delega utente per un file:

public static async Task<Uri> CreateUserDelegationSASFile(
    FileClient fileClient,
    UserDelegationKey userDelegationKey)
{
    // Create a SAS token for the container resource that's also valid for 1 day
    FileSasBuilder sasBuilder = new BlobSasBuilder()
    {
        FileContainerName = fileClient.FileContainerName,
        FileName = fileClient.Name,
        Resource = "f",
        StartsOn = DateTimeOffset.UtcNow,
        ExpiresOn = DateTimeOffset.UtcNow.AddDays(1)
    };

    // Specify the necessary permissions
    sasBuilder.SetPermissions(FileSasPermissions.Read | FileSasPermissions.Write);

     // Add the SAS token to the file URI
    ShareUriBuilder uriBuilder = new ShareUriBuilder(shareClient.Uri)
    {
        // Specify the user delegation key
        Sas = sasBuilder.ToSasQueryParameters(
            userDelegationKey,
            fileClient
            .GetParentFileContainerClient()
            .GetParentFileServiceClient().AccountName)
    };
    return uriBuilder.ToUri();

Dopo aver ottenuto la chiave di delega utente, è possibile creare una SAS di delega utente per delegare un accesso limitato a una coda. L'esempio di codice seguente mostra come creare una firma di accesso condiviso con delega utente per una coda:

public static async Task<Uri> CreateUserDelegationSASQueue(
    QueueClient queueClient,
    UserDelegationKey userDelegationKey)
{
    // Create a SAS token for the container resource that's also valid for 1 day
    QueueSasBuilder sasBuilder = new QueueSasBuilder()
    {
        QueueContainerName = queueClient.QueueContainerName,
        QueueName = queueClient.Name,
        Resource = "q",
        StartsOn = DateTimeOffset.UtcNow,
        ExpiresOn = DateTimeOffset.UtcNow.AddDays(1)
    };

    // Specify the necessary permissions
    sasBuilder.SetPermissions(QueueSasPermissions.Read | QueueSasPermissions.Write);

     // Add the SAS token to the queue URI
    BlobUriBuilder uriBuilder = new BlobUriBuilder(blobClient.Uri)
    {
        // Specify the user delegation key
        Sas = sasBuilder.ToSasQueryParameters(
            userDelegationKey,
            queueClient
            .GetParentFileContainerClient()
            .GetParentFileServiceClient().AccountName)
    };
    return uriBuilder.ToUri();
}

Usare una SAS di delega utente per autorizzare un oggetto client

È possibile usare una firma di accesso condiviso di delega utente per autorizzare un oggetto client a eseguire operazioni su un contenitore BLOB, un BLOB, una condivisione di file, un file o una coda in base alle autorizzazioni concesse dalla firma di accesso condiviso di delega utente.

L'esempio di codice seguente mostra come usare la SAS di delega utente per autorizzare un oggetto BlobContainerClient. Questo oggetto client può essere utilizzato per eseguire operazioni sulla risorsa del contenitore in base alle autorizzazioni concesse dal SAS.

// Create a Uri object with a user delegation SAS appended
BlobContainerClient containerClient = blobServiceClient
    .GetBlobContainerClient("sample-container");
Uri containerSASURI = await CreateUserDelegationSASContainer(containerClient, userDelegationKey);

// Create a container client object with SAS authorization
BlobContainerClient containerClientSAS = new BlobContainerClient(containerSASURI);

L'esempio di codice seguente mostra come usare la SAS di delega utente per autorizzare un oggetto BlobClient. Questo oggetto client può essere utilizzato per eseguire operazioni sulla risorsa blob in base alle autorizzazioni concesse dal SAS.

// Create a Uri object with a user delegation SAS appended
BlobClient blobClient = blobServiceClient
    .GetBlobContainerClient("sample-container")
    .GetBlobClient("sample-blob.txt");
Uri blobSASURI = await CreateUserDelegationSASBlob(blobClient, userDelegationKey);

// Create a blob client object with SAS authorization
BlobClient blobClientSAS = new BlobClient(blobSASURI);

L'esempio di codice seguente illustra come utilizzare la SAS di delega utente per autorizzare un oggetto FileClient. Questo oggetto client può essere utilizzato per eseguire operazioni su una condivisione file di Azure in base alle autorizzazioni concesse dal SAS.

// Create a Uri object with a user delegation SAS appended
FileClient fileClient = filesServiceClient
    .GetFileShareClient("sample-share")
    .GetRootDirectoryClient()
    .GetFileClient("sample-file.txt");
Uri fileSASURI = await CreateUserDelegationSASFile(fileClient, userDelegationKey);

// Create a file client object with SAS authorization
FileClient fileClientSAS = new FileClient(fileSASURI);

L'esempio di codice seguente mostra come usare la SAS di delega utente per autorizzare un oggetto QueueClient. Questo oggetto client può essere utilizzato per eseguire operazioni sulla risorsa coda in base alle autorizzazioni concesse dalla firma di accesso condiviso.

// Create a Uri object with a user delegation SAS appended
QueueClient queueClient = queueServiceClient
    .GetQueueClient("sample-queue");
Uri queueSASURI = await CreateUserDelegationSASQueue(queueClient, userDelegationKey);

// Create a queue client object with SAS authorization
QueueClient queueClientSAS = new QueueClient(queueSASURI);

Risorse

Per altre informazioni sulla creazione di una SAS di delega utente usando la libreria client di Archiviazione BLOB di Azure per .NET, vedere le risorse seguenti.

Esempi di codice

Vedere gli esempi di codice di questo articolo (GitHub)

Operazioni dell'API REST

Azure SDK per .NET contiene librerie basate sull'API REST di Azure che consentono di interagire con le operazioni dell'API REST tramite paradigmi .NET noti. Il metodo della libreria client per ottenere una chiave di delega utente utilizza le seguenti operazioni API REST:

Ottenere la chiave di delega utente (API REST)

Risorse della libreria client

Vedi anche

Questo articolo fa parte della Guida per sviluppatori di Archiviazione BLOB per .NET. Per altre informazioni, vedere l’elenco completo degli articoli della Guida per sviluppatori inCreare la propria app .NET.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-06-23