Fråga efter en Blob Storage-slutpunkt med hjälp av Azure Storage-hanteringsbiblioteket
Artikel
En Blob Storage-slutpunkt utgör basadressen för alla objekt i ett lagringskonto. När du skapar ett lagringskonto anger du vilken typ av slutpunkt du vill använda. Blob Storage stöder två typer av slutpunkter:
En standardslutpunkt innehåller det unika lagringskontonamnet tillsammans med ett fast domännamn. Formatet för en standardslutpunkt är https://<storage-account>.blob.core.windows.net.
En Azure DNS-zonslutpunkt (förhandsversion) väljer dynamiskt en Azure DNS-zon och tilldelar den till lagringskontot när den skapas. Formatet för en Azure DNS-zonslutpunkt är https://<storage-account>.z[00-99].blob.storage.azure.net.
När ditt program skapar ett tjänstklientobjekt som ansluter till Blob Storage-dataresurser skickar du en URI som refererar till slutpunkten till tjänstklientkonstruktorn. Du kan konstruera URI-strängen manuellt, eller så kan du fråga efter tjänstslutpunkten vid körning med hjälp av Azure Storage-hanteringsbiblioteket.
Viktigt!
När du refererar till en tjänstslutpunkt i ett klientprogram rekommenderar vi att du undviker att använda ett beroende av en cachelagrad IP-adress. IP-adressen för lagringskontot kan komma att ändras, och om du förlitar dig på en cachelagrad IP-adress kan det leda till oväntat beteende.
CNAMEs som är associerade med en lagringskontoslutpunkt kan ändras utan föregående meddelande. Programmet bör inte vara beroende av antalet CNAME-poster eller de underdomäner som är associerade med dessa CNAME-poster.
Dessutom rekommenderar vi att du respekterar TTL (time-to-live) för DNS-posten och undviker att åsidosätta den. Att åsidosätta DNS TTL kan leda till oväntat beteende.
Azure Storage-hanteringsbiblioteket ger programmatisk åtkomst till Azure Storage-resursprovidern. Resursprovidern är Azure Storage-implementeringen av Azure Resource Manager. Med hanteringsbiblioteket kan utvecklare hantera lagringskonton och kontokonfiguration samt konfigurera principer för livscykelhantering, principer för objektreplikering och oföränderlighetsprinciper.
I den här artikeln får du lära dig hur du kör frågor mot en Blob Storage-slutpunkt med hjälp av Azure Storage-hanteringsbiblioteket. Sedan använder du slutpunkten för att skapa ett BlobServiceClient objekt för att ansluta till Blob Storage-dataresurser.
Konfigurera projektet
Följ de här stegen för att konfigurera projektet om du vill arbeta med kodexemplen i den här artikeln.
Installera paket
Installera paket för att arbeta med de bibliotek som används i det här exemplet.
Lägg till azure-sdk-bom för att ta ett beroende av den senaste versionen av biblioteket. I följande kodfragment ersätter du {bom_version_to_target} platshållaren med versionsnumret. Med hjälp av azure-sdk-bom behöver du inte ange versionen av varje enskilt beroende. Mer information om bommen finns i AZURE SDK BOM README.
Lägg till nödvändiga using eller import direktiv i koden. Observera att kodexemplen kan dela upp funktioner mellan filer, men i det här avsnittet visas alla direktiv tillsammans.
using Azure.Core;
using Azure.Identity;
using Azure.Storage.Blobs;
using Azure.ResourceManager;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Storage;
Information om klientbiblioteket:
Azure.Identity: Tillhandahåller stöd för Microsoft Entra-tokenautentisering i Azure SDK och behövs för lösenordslösa anslutningar till Azure-tjänster.
Azure.ResourceManager.Storage: Stöder hantering av Azure Storage-resurser, inklusive resursgrupper och lagringskonton.
Azure.Storage.Blobs: Innehåller de primära klasser som du kan använda för att arbeta med Blob Storage-dataresurser.
com.azure.identity: Tillhandahåller stöd för Microsoft Entra-tokenautentisering i Azure SDK och behövs för lösenordslösa anslutningar till Azure-tjänster.
com.azure.storage.blob: Innehåller de primära klasser som du kan använda för att arbeta med Blob Storage-dataresurser.
@azure/arm-storage: Stöder hantering av Azure Storage-resurser, inklusive resursgrupper och lagringskonton.
Lägg till följande import-uttryck:
from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient
from azure.mgmt.resource import ResourceManagementClient
from azure.mgmt.storage import StorageManagementClient
Information om klientbiblioteket:
azure-identity: Tillhandahåller stöd för Microsoft Entra-tokenautentisering i Azure SDK och behövs för lösenordslösa anslutningar till Azure-tjänster.
azure-storage-blob: Innehåller de primära klasser som du kan använda för att arbeta med Blob Storage-dataresurser.
azure-mgmt-storage: Stöder hantering av Azure Storage-resurser, inklusive resursgrupper och lagringskonton.
Registrera lagringsresursprovidern med en prenumeration
En resursprovider måste registreras med din Azure-prenumeration innan du kan arbeta med den. Det här steget behöver bara utföras en gång per prenumeration och gäller endast om resursprovidern Microsoft.Storage för närvarande inte är registrerad med din prenumeration.
Du kan också använda Azure-hanteringsbiblioteken för att kontrollera registreringsstatusen och registrera lagringsresursprovidern, som du ser i följande exempel:
public static async Task RegisterSRPInSubscription(SubscriptionResource subscription)
{
ResourceProviderResource resourceProvider =
await subscription.GetResourceProviderAsync("Microsoft.Storage");
// Check the registration state of the resource provider and register, if needed
if (resourceProvider.Data.RegistrationState == "NotRegistered")
resourceProvider.Register();
}
public void RegisterSRPInSubscription(AzureResourceManager armClient) {
// Check the registration state of the resource provider and register, if needed
if (armClient.providers().getByName("Microsoft.Storage").registrationState() == "NotRegistered")
armClient.providers().register("Microsoft.Storage");
}
async function registerSRPInSubscription(resourceMgmtClient /*: ResourceManagementClient*/) {
// Check the registration state of the resource provider and register, if needed
if (resourceMgmtClient.providers.get("Microsoft.Storage").registrationState == "NotRegistered")
resourceMgmtClient.providers.register("Microsoft.Storage");
}
def register_srp_in_subscription(self, resource_mgmt_client: ResourceManagementClient):
if (resource_mgmt_client.providers.get("Microsoft.Storage").registration_state == "NotRegistered"):
resource_mgmt_client.providers.register("Microsoft.Storage")
Kommentar
För att utföra registeråtgärden behöver du behörigheter för följande Azure RBAC-åtgärd: Microsoft.Storage/register/action. Den här behörigheten ingår i rollerna Deltagare och Ägare .
Fråga efter Blob Storage-slutpunkten
För att hämta Blob Storage-slutpunkten för ett visst lagringskonto måste vi hämta egenskaperna för lagringskontot genom att anropa åtgärden Hämta egenskaper . Följande kodexempel använder både dataåtkomst- och hanteringsbiblioteken för att hämta en Blob Storage-slutpunkt för ett angivet lagringskonto:
public static async Task<Uri> GetBlobServiceEndpoint(
string storageAccountName,
TokenCredential credential)
{
// TODO: replace with your subscription ID and resource group name
// You can locate your subscription ID on the Subscriptions blade
// of the Azure portal (https://portal.azure.com)
const string subscriptionId = "<subscription-id>";
const string rgName = "<resource-group-name>";
ArmClient armClient = new(credential);
// Create a resource identifier, then get the subscription resource
ResourceIdentifier resourceIdentifier = new($"/subscriptions/{subscriptionId}");
SubscriptionResource subscription = armClient.GetSubscriptionResource(resourceIdentifier);
// Get a resource group
ResourceGroupResource resourceGroup = await subscription.GetResourceGroupAsync(rgName);
// Get a collection of storage account resources
StorageAccountCollection accountCollection = resourceGroup.GetStorageAccounts();
// Get the properties for the specified storage account
StorageAccountResource storageAccount = await accountCollection.GetAsync(storageAccountName);
// Return the primary endpoint for the blob service
return storageAccount.Data.PrimaryEndpoints.BlobUri;
}
Om du vill hämta egenskaperna för ett angivet lagringskonto använder du följande metod från ett AzureResourceManager-objekt :
async function getBlobServiceEndpoint(saName, credential) {
const subscriptionId = "<subscription-id>";
const rgName = "<resource-group-name>";
const storageMgmtClient = new StorageManagementClient(
credential,
subscriptionId
);
// Get the properties for the specified storage account
const storageAccount = await storageMgmtClient.storageAccounts.getProperties(
rgName,
saName
);
// Get the primary endpoint for the blob service
const endpoint = storageAccount.primaryEndpoints.blob;
return endpoint;
}
Om du vill hämta egenskaperna för ett angivet lagringskonto använder du följande metod från ett StorageManagementClient-objekt :
Den här metoden returnerar ett StorageAccount objekt som representerar lagringskontot.
def get_blob_service_endpoint(self, storage_account_name, credential: DefaultAzureCredential) -> str:
subscription_id = "<subscription-id>"
rg_name = "<resource-group-name>"
storage_mgmt_client = StorageManagementClient(
credential=credential,
subscription_id=subscription_id
)
# Get the properties for the specified storage account
storage_account = storage_mgmt_client.storage_accounts.get_properties(
resource_group_name=rg_name,
account_name=storage_account_name
)
# Get blob service endpoint
endpoint = storage_account.primary_endpoints.blob
return endpoint
Skapa ett klientobjekt med hjälp av slutpunkten
När du har Blob Storage-slutpunkten för ett lagringskonto kan du instansiera ett klientobjekt för att arbeta med dataresurser. Följande kodexempel skapar ett BlobServiceClient objekt med den slutpunkt som vi hämtade i det tidigare exemplet:
// Create an instance of DefaultAzureCredential for authorization
TokenCredential credential = new DefaultAzureCredential();
// TODO: replace with your storage account name
string storageAccountName = "<storage-account-name>";
// Call out to our function that retrieves the blob service endpoint for the given storage account
Uri blobURI = await AccountProperties.GetBlobServiceEndpoint(storageAccountName, credential);
Console.WriteLine($"URI: {blobURI}");
// Now that we know the endpoint, create the client object
BlobServiceClient blobServiceClient = new(blobURI, credential);
// Do something with the storage account or its resources ...
String saName = "<storage-account-name>";
DefaultAzureCredential credential = new DefaultAzureCredentialBuilder().build();
AccountProperties accountProps = new AccountProperties();
String blobEndpoint = accountProps.GetBlobServiceEndpoint(saName, credential);
System.out.printf("URI: %s", blobEndpoint);
BlobServiceClient blobServiceClient = new BlobServiceClientBuilder()
.endpoint(blobEndpoint)
.credential(credential)
.buildClient();
// Do something with the storage account or its resources ...
// For client-side applications running in the browser, use InteractiveBrowserCredential instead of DefaultAzureCredential.
// See https://aka.ms/azsdk/js/identity/examples for more details.
const saName = "<storage-account-name>";
const credential = new DefaultAzureCredential();
// Call out to our function that retrieves the blob service endpoint for a storage account
const endpoint = await getBlobServiceEndpoint(saName, credential)
console.log(endpoint);
// Now that we know the endpoint, create the client object
const blobServiceClient = new BlobServiceClient(
endpoint,
credential);
// Do something with the storage account or its resources ...
storage_account_name = "<storage-account-name>"
credential = DefaultAzureCredential()
sample = BlobEndpointSample()
# Call out to our function that retrieves the blob service endpoint for a storage account
endpoint = sample.get_blob_service_endpoint(storage_account_name, credential)
print(f"URL: {endpoint}")
# Now that we know the endpoint, create the client object
blob_service_client = BlobServiceClient(account_url=endpoint, credential=credential)
# Do something with the storage account or its resources ...