Ladda ned en blob med Python

  • Artikel

Den här artikeln visar hur du laddar ned en blob med hjälp av Azure Storage-klientbiblioteket för Python. Du kan ladda ned blobdata till olika mål, inklusive en lokal filsökväg, dataström eller textsträng. Du kan också öppna en blobström och läsa från den.

Mer information om hur du laddar ned blobar med asynkrona API:er finns i Ladda ned blobar asynkront.

Förutsättningar

  • Den här artikeln förutsätter att du redan har ett projekt konfigurerat för att fungera med Azure Blob Storage-klientbiblioteket för Python. Mer information om hur du konfigurerar projektet, inklusive paketinstallation, tillägg import av instruktioner och skapande av ett auktoriserat klientobjekt finns i Komma igång med Azure Blob Storage och Python.
  • Information om hur du använder asynkrona API:er i koden finns i kraven i avsnittet Asynkron programmering .
  • Auktoriseringsmekanismen måste ha behörighet att utföra en nedladdningsåtgärd. Mer information finns i auktoriseringsvägledningen för följande REST API-åtgärd:

Ladda ned en blob

Du kan använda följande metod för att ladda ned en blob:

Metoden download_blob returnerar ett StorageStreamDownloader-objekt . Under en nedladdning delar klientbiblioteken upp nedladdningsbegäran i segment, där varje segment laddas ned med en separat Begäran om hämta blobintervall . Det här beteendet beror på blobens totala storlek och hur dataöverföringsalternativen anges.

Ladda ned till en filsökväg

I följande exempel laddas en blob ned till en filsökväg:

def download_blob_to_file(self, blob_service_client: BlobServiceClient, container_name):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")
    with open(file=os.path.join(r'filepath', 'filename'), mode="wb") as sample_blob:
        download_stream = blob_client.download_blob()
        sample_blob.write(download_stream.readall())

Ladda ned till en dataström

I följande exempel laddas en blob ned till en dataström. I det här exemplet laddar StorageStreamDownloader.read_into ned blobinnehållet till en dataström och returnerar antalet lästa byte:

def download_blob_to_stream(self, blob_service_client: BlobServiceClient, container_name):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")

    # readinto() downloads the blob contents to a stream and returns the number of bytes read
    stream = io.BytesIO()
    num_bytes = blob_client.download_blob().readinto(stream)
    print(f"Number of bytes: {num_bytes}")

Ladda ned en blob i segment

I följande exempel laddas en blob ned och itererar över segment i nedladdningsströmmen. I det här exemplet returnerar StorageStreamDownloader.chunks en iterator som gör att du kan läsa blobinnehållet i segment:

def download_blob_chunks(self, blob_service_client: BlobServiceClient, container_name):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")

    # This returns a StorageStreamDownloader
    stream = blob_client.download_blob()
    chunk_list = []

    # Read data in chunks to avoid loading all into memory at once
    for chunk in stream.chunks():
        # Process your data (anything can be done here - 'chunk' is a byte array)
        chunk_list.append(chunk)

Ladda ned till en sträng

I följande exempel laddas blobinnehållet ned som text. I det här exemplet är parametern encoding nödvändig för readall() att returnera en sträng, annars returneras byte:

def download_blob_to_string(self, blob_service_client: BlobServiceClient, container_name):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")

    # encoding param is necessary for readall() to return str, otherwise it returns bytes
    downloader = blob_client.download_blob(max_concurrency=1, encoding='UTF-8')
    blob_text = downloader.readall()
    print(f"Blob contents: {blob_text}")

Ladda ned en blockblob med konfigurationsalternativ

Du kan definiera konfigurationsalternativ för klientbibliotek när du laddar ned en blob. Dessa alternativ kan justeras för att förbättra prestanda och förbättra tillförlitligheten. Följande kodexempel visar hur du definierar konfigurationsalternativ för en nedladdning både på metodnivå och på klientnivå vid instansiering av BlobClient. Dessa alternativ kan också konfigureras för en ContainerClient-instans eller en BlobServiceClient-instans .

Ange alternativ för dataöverföring vid nedladdning

Du kan ange konfigurationsalternativ när du instansierar en klient för att optimera prestanda för dataöverföringsåtgärder. Du kan skicka följande nyckelordsargument när du skapar ett klientobjekt i Python:

  • max_chunk_get_size – Den maximala segmentstorleken som används för att ladda ned en blob. Standardvärdet är 4 MiB.
  • max_single_get_size – Den maximala storleken för en blob som ska laddas ned i ett enda anrop. Om den totala blobstorleken överskrider laddas max_single_get_sizeresten av blobdata ned i segment. Standardvärdet är 32 MiB.

För nedladdningsåtgärder kan du också skicka max_concurrency argumentet när du anropar download_blob. Det här argumentet definierar det maximala antalet parallella anslutningar för nedladdningsåtgärden.

Följande kodexempel visar hur du anger alternativ för dataöverföring när du skapar ett BlobClient objekt och hur du laddar ned data med det klientobjektet. De värden som anges i det här exemplet är inte avsedda att vara en rekommendation. Om du vill justera dessa värden korrekt måste du ta hänsyn till appens specifika behov.

def download_blob_transfer_options(self, account_url: str, container_name: str, blob_name: str):
    # Create a BlobClient object with data transfer options for download
    blob_client = BlobClient(
        account_url=account_url, 
        container_name=container_name, 
        blob_name=blob_name,
        credential=DefaultAzureCredential(),
        max_single_get_size=1024*1024*32, # 32 MiB
        max_chunk_get_size=1024*1024*4 # 4 MiB
    )

    with open(file=os.path.join(r'file_path', 'file_name'), mode="wb") as sample_blob:
        download_stream = blob_client.download_blob(max_concurrency=2)
        sample_blob.write(download_stream.readall())

Ladda ned blobar asynkront

Azure Blob Storage-klientbiblioteket för Python stöder nedladdning av blobar asynkront. Mer information om krav för projektkonfiguration finns i Asynkron programmering.

Följ dessa steg för att ladda ned en blob med asynkrona API:er:

  1. Lägg till följande importinstruktioner:

    import asyncio

from azure.identity.aio import DefaultAzureCredential
from azure.storage.blob.aio import BlobServiceClient, BlobClient

  2. Lägg till kod för att köra programmet med .asyncio.run Den här funktionen kör den skickade coroutinen main() i vårt exempel och hanterar händelseloopen asyncio . Coroutines deklareras med syntaxen async/await. I det här exemplet main() skapar coroutinen först den översta nivån BlobServiceClient med och async withanropar sedan metoden som laddar ned bloben. Observera att endast klienten på den översta nivån behöver använda async with, eftersom andra klienter som skapats från den delar samma anslutningspool.

    async def main():
    sample = BlobSamples()

    # TODO: Replace <storage-account-name> with your actual storage account name
    account_url = "https://<storage-account-name>.blob.core.windows.net"
    credential = DefaultAzureCredential()

    async with BlobServiceClient(account_url, credential=credential) as blob_service_client:
        await sample.download_blob_to_file(blob_service_client, "sample-container")

if __name__ == '__main__':
    asyncio.run(main())

  3. Lägg till kod för att ladda ned bloben. I följande exempel laddas en blob ned till en lokal filsökväg med hjälp av ett BlobClient objekt. Koden är samma som det synkrona exemplet, förutom att metoden deklareras med nyckelordet async och nyckelordet await används när metoden anropas download_blob .

    async def download_blob_to_file(self, blob_service_client: BlobServiceClient, container_name):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")
    with open(file=os.path.join(r'filepath', 'filename'), mode="wb") as sample_blob:
        download_stream = await blob_client.download_blob()
        data = await download_stream.readall()
        sample_blob.write(data)

Med den här grundläggande konfigurationen på plats kan du implementera andra exempel i den här artikeln som coroutines med hjälp av async/await-syntax.

Resurser

Mer information om hur du laddar ned blobar med hjälp av Azure Blob Storage-klientbiblioteket för Python finns i följande resurser.

REST API-åtgärder

Azure SDK för Python innehåller bibliotek som bygger på Azure REST API så att du kan interagera med REST API-åtgärder via välbekanta Python-paradigm. Klientbiblioteksmetoderna för att ladda ned blobar använder följande REST API-åtgärd:

Kodexempel

Klientbiblioteksresurser