Dela via

Skapa en tjänst-SAS för en container eller blob med .NET

  • Artikel

Med en signatur för delad åtkomst (SAS) kan du bevilja begränsad åtkomst till containrar och blobar i ditt lagringskonto. När du skapar en SAS anger du dess begränsningar, inklusive vilka Azure Storage-resurser en klient har åtkomst till, vilka behörigheter de har för dessa resurser och hur länge SAS är giltigt.

Varje SAS signeras med en nyckel. Du kan signera en SAS på något av två sätt:

  • Med en nyckel som skapats med Microsoft Entra-autentiseringsuppgifter. En SAS som är signerad med Microsoft Entra-autentiseringsuppgifter är en SAS för användardelegering . En klient som skapar en SAS för användardelegering måste tilldelas en Azure RBAC-roll som innehåller åtgärden Microsoft.Storage/storageAccounts/blobServices/generateUserDelegationKey . Mer information finns i Skapa en SAS för användardelegering.
  • Med lagringskontonyckeln. Både en tjänst-SAS och ett sas-konto signeras med lagringskontonyckeln. Klienten som skapar en tjänst-SAS måste antingen ha direkt åtkomst till kontonyckeln eller tilldelas behörigheten Microsoft.Storage/storageAccounts/listkeys/action . Mer information finns i Skapa en tjänst-SAS eller Skapa ett konto-SAS.

Kommentar

En SAS för användardelegering ger överlägsen säkerhet till en SAS som är signerad med lagringskontonyckeln. Microsoft rekommenderar att du använder en SAS för användardelegering när det är möjligt. Mer information finns i Bevilja begränsad åtkomst till data med signaturer för delad åtkomst (SAS).

Den här artikeln visar hur du använder lagringskontonyckeln för att skapa en tjänst-SAS för en container eller blob med Azure Blob Storage-klientbiblioteket för .NET.

Om tjänsten SAS

En tjänst-SAS signeras med kontoåtkomstnyckeln. Du kan använda klassen StorageSharedKeyCredential för att skapa autentiseringsuppgifterna som används för att signera tjänstens SAS.

Du kan också använda en lagrad åtkomstprincip för att definiera behörigheter och varaktighet för SAS. Om namnet på en befintlig lagrad åtkomstprincip anges associeras den principen med SAS. Mer information om lagrade åtkomstprinciper finns i Definiera en lagrad åtkomstprincip. Om ingen lagrad åtkomstprincip anges visar kodexemplen i den här artikeln hur du definierar behörigheter och varaktighet för SAS.

Skapa en tjänst-SAS

Du kan skapa en tjänst-SAS för en container eller blob baserat på appens behov.

I följande kodexempel visas hur du skapar en tjänst-SAS för en containerresurs. Först verifierar koden att BlobContainerClient-objektet är auktoriserat med en delad nyckelautentiseringsuppgifter genom att kontrollera egenskapen CanGenerateSasUri . Sedan genererar tjänsten SAS via klassen BlobSasBuilder och anropar GenerateSasUri för att skapa en tjänst-SAS-URI baserat på klient- och byggobjekten.

public static async Task<Uri> CreateServiceSASContainer(
    BlobContainerClient containerClient,
    string storedPolicyName = null)
{
    // Check if BlobContainerClient object has been authorized with Shared Key
    if (containerClient.CanGenerateSasUri)
    {
        // Create a SAS token that's valid for one day
        BlobSasBuilder sasBuilder = new BlobSasBuilder()
        {
            BlobContainerName = containerClient.Name,
            Resource = "c"
        };

        if (storedPolicyName == null)
        {
            sasBuilder.ExpiresOn = DateTimeOffset.UtcNow.AddDays(1);
            sasBuilder.SetPermissions(BlobContainerSasPermissions.Read);
        }
        else
        {
            sasBuilder.Identifier = storedPolicyName;
        }

        Uri sasURI = containerClient.GenerateSasUri(sasBuilder);

        return sasURI;
    }
    else
    {
        // Client object is not authorized via Shared Key
        return null;
    }
}

Använda en tjänst-SAS för att auktorisera ett klientobjekt

Du kan använda en tjänst-SAS för att auktorisera ett klientobjekt för att utföra åtgärder på en container eller blob baserat på de behörigheter som beviljas av SAS.

Följande kodexempel visar hur du använder tjänsten SAS för att auktorisera ett BlobContainerClient-objekt . Det här klientobjektet kan användas för att utföra åtgärder på containerresursen baserat på de behörigheter som beviljas av SAS.

Skapa först ett BlobServiceClient-objekt signerat med kontoåtkomstnyckeln:

string accountName = "<storage-account-name>";
string accountKey = "<storage-account-key";
StorageSharedKeyCredential storageSharedKeyCredential =
    new(accountName, accountKey);
BlobServiceClient blobServiceClient = new BlobServiceClient(
    new Uri($"https://{accountName}.blob.core.windows.net"),
    storageSharedKeyCredential);

Generera sedan tjänsten SAS enligt föregående exempel och använd SAS för att auktorisera ett BlobContainerClient-objekt :

// Create a Uri object with a service SAS appended
BlobContainerClient containerClient = blobServiceClient
    .GetBlobContainerClient("sample-container");
Uri containerSASURI = await CreateServiceSASContainer(containerClient);

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

Definiera en lagrad åtkomstprincip

En lagrad åtkomstprincip ger ytterligare kontroll över en signatur för delad åtkomst på tjänstnivå (SAS) på serversidan. Genom att upprätta en lagrad åtkomstprincip kan du gruppera signaturer för delad åtkomst och ange ytterligare begränsningar för signaturer som är bundna av principen.

Du kan använda en lagrad åtkomstprincip för att ändra starttid, förfallotid eller behörigheter för en signatur. Du kan också använda en lagrad åtkomstprincip för att återkalla en signatur när den har utfärdats. Det här avsnittet fokuserar på blobcontainrar, men lagrade åtkomstprinciper stöds också för filresurser, köer och tabeller.

Om du vill hantera lagrade åtkomstprinciper på en containerresurs anropar du någon av följande metoder från ett BlobContainerClient-objekt :

Skapa eller ändra en lagrad åtkomstprincip

Du kan ange högst fem åtkomstprinciper för en resurs i taget. Varje SignedIdentifier fält, med sitt unika Id fält, motsvarar en åtkomstprincip. Om du försöker ange fler än fem åtkomstprinciper samtidigt returnerar tjänsten statuskoden 400 (Bad Request).

I följande kodexempel visas hur du skapar två lagrade åtkomstprinciper på en containerresurs:

public static async Task CreateStoredAccessPolicyAsync(BlobContainerClient containerClient)
{
    // Create a stored access policy with read and write permissions, valid for one day
    List<BlobSignedIdentifier> signedIdentifiers = new List<BlobSignedIdentifier>
    {
        new BlobSignedIdentifier
        {
            Id = "sample-read-write-policy",
            AccessPolicy = new BlobAccessPolicy
            {
                StartsOn = DateTimeOffset.UtcNow,
                ExpiresOn = DateTimeOffset.UtcNow.AddDays(1),
                Permissions = "rw"
            }
        },
        new BlobSignedIdentifier
        {
            Id = "sample-read-policy",
            AccessPolicy = new BlobAccessPolicy
            {
                StartsOn = DateTimeOffset.UtcNow,
                ExpiresOn = DateTimeOffset.UtcNow.AddDays(1),
                Permissions = "r"
            }
        }
    };

    // Set the container's access policy
    await containerClient.SetAccessPolicyAsync(permissions: signedIdentifiers);
}

Du kan också ändra en befintlig princip. I följande kodexempel visas hur du ändrar en enda lagrad åtkomstprincip för att uppdatera principens förfallodatum:

public static async Task ModifyStoredAccessPolicyAsync(BlobContainerClient containerClient)
{
    BlobContainerAccessPolicy accessPolicy = await containerClient.GetAccessPolicyAsync();
    List<BlobSignedIdentifier> signedIdentifiers = accessPolicy.SignedIdentifiers.ToList();

    // Modify the expiration date a single policy
    var samplePolicy = signedIdentifiers.FirstOrDefault(item => item.Id == "sample-read-policy");
    samplePolicy.AccessPolicy.PolicyExpiresOn = DateTimeOffset.UtcNow.AddDays(7);

    // Update the container's access policy
    await containerClient.SetAccessPolicyAsync(permissions: signedIdentifiers);
}

Återkalla eller ta bort en lagrad åtkomstprincip

För att återkalla en lagrad åtkomstprincip rekommenderar Microsoft att du tar bort den signerade identifieraren och skapar en ny. Om du ändrar den signerade identifieraren bryts associationerna mellan befintliga signaturer och den lagrade åtkomstprincipen. Om du tar bort eller ändrar den lagrade åtkomstprincipen påverkas omedelbart alla signaturer för delad åtkomst som är associerade med den.

I följande kodexempel visas hur du återkallar en princip genom att ändra Id egenskapen för den signerade identifieraren. Den här metoden tar effektivt bort den signerade identifieraren och skapar en ny:

public static async Task RevokeStoredAccessPolicyAsync(BlobContainerClient containerClient)
{
    BlobContainerAccessPolicy accessPolicy = await containerClient.GetAccessPolicyAsync();
    List<BlobSignedIdentifier> signedIdentifiers = accessPolicy.SignedIdentifiers.ToList();

    // Revoke a single policy by changing its name
    var samplePolicy = signedIdentifiers.FirstOrDefault(item => item.Id == "sample-read-policy");
    samplePolicy.Id = "sample-read-policy-revoke";

    // Update the container's access policy
    await containerClient.SetAccessPolicyAsync(permissions: signedIdentifiers);
}

Du kan också ta bort alla åtkomstprinciper från en containerresurs genom att anropa SetAccessPolicyAsync med en tom permissions parameter. I följande exempel visas hur du tar bort alla lagrade åtkomstprinciper från en angiven container:

public static async Task DeleteStoredAccessPolicyAsync(BlobContainerClient containerClient)
{
    // Remove all stored access policies for the container resource
    await containerClient.SetAccessPolicyAsync();
}

Resurser

Mer information om hur du skapar en tjänst-SAS med hjälp av Azure Blob Storage-klientbiblioteket för .NET finns i följande resurser.

Kodexempel

Klientbiblioteksresurser

Se även