Een blob downloaden met Python

Artikel
11/21/2023

In dit artikel wordt beschreven hoe u een blob downloadt met behulp van de Azure Storage-clientbibliotheek voor Python. U kunt blobgegevens downloaden naar verschillende bestemmingen, waaronder een lokaal bestandspad, een stroom of een tekenreeks. U kunt ook een blobstream openen en ermee lezen.

Zie Blobs asynchroon downloaden voor meer informatie over het downloaden van blobs met behulp van asynchrone API's.

Vereisten

In dit artikel wordt ervan uitgegaan dat u al een project hebt ingesteld voor gebruik met de Azure Blob Storage-clientbibliotheek voor Python. Zie Aan de slag met Azure Blob Storage en Python voor meer informatie over het instellen van uw project, inclusief pakketinstallatie, het toevoegen import van instructies en het maken van een geautoriseerd clientobject.
Als u asynchrone API's in uw code wilt gebruiken, raadpleegt u de vereisten in de sectie Asynchroon programmeren .
Het autorisatiemechanisme moet machtigingen hebben om een downloadbewerking uit te voeren. Zie de autorisatierichtlijnen voor de volgende REST API-bewerking voor meer informatie:
- Blob ophalen

Blob downloaden

U kunt de volgende methode gebruiken om een blob te downloaden:

BlobClient.download_blob

De download_blob methode retourneert een StorageStreamDownloader-object . Tijdens een download splitsen de clientbibliotheken de downloadaanvraag op in segmenten, waarbij elke segment wordt gedownload met een afzonderlijke aanvraag voor het bereik Van de blob ophalen. Dit gedrag is afhankelijk van de totale grootte van de blob en hoe de opties voor gegevensoverdracht worden ingesteld.

Downloaden naar een bestandspad

In het volgende voorbeeld wordt een blob gedownload naar een bestandspad:

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())

Downloaden naar een stream

In het volgende voorbeeld wordt een blob gedownload naar een stream. In dit voorbeeld downloadt StorageStreamDownloader.read_into de blob-inhoud naar een stream en wordt het aantal gelezen bytes geretourneerd:

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}")

Een blob downloaden in segmenten

In het volgende voorbeeld wordt een blob gedownload en herhaald over segmenten in de downloadstroom. In dit voorbeeld retourneert StorageStreamDownloader.chunks een iterator, waarmee u de blob-inhoud in segmenten kunt lezen:

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)

Downloaden naar een tekenreeks

In het volgende voorbeeld wordt de blob-inhoud gedownload als tekst. In dit voorbeeld is de encoding parameter nodig om readall() een tekenreeks te retourneren, anders retourneert deze bytes:

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}")

Een blok-blob downloaden met configuratieopties

U kunt configuratieopties voor clientbibliotheek definiëren bij het downloaden van een blob. Deze opties kunnen worden afgestemd om de prestaties te verbeteren en de betrouwbaarheid te verbeteren. In de volgende codevoorbeelden ziet u hoe u configuratieopties definieert voor een download, zowel op methodeniveau als op clientniveau bij het instantiëren van BlobClient. Deze opties kunnen ook worden geconfigureerd voor een ContainerClient-exemplaar of een BlobServiceClient-exemplaar .

Opties voor gegevensoverdracht opgeven bij downloaden

U kunt configuratieopties instellen bij het instantiëren van een client om de prestaties voor gegevensoverdrachtbewerkingen te optimaliseren. U kunt de volgende trefwoordargumenten doorgeven bij het maken van een clientobject in Python:

max_chunk_get_size - De maximale segmentgrootte die wordt gebruikt voor het downloaden van een blob. De standaardwaarde is 4 MiB.
max_single_get_size - De maximale grootte voor een blob die in één aanroep moet worden gedownload. Als de totale blobgrootte groter is max_single_get_size, wordt de rest van de blobgegevens gedownload in segmenten. De standaardwaarde is 32 MiB.

Voor downloadbewerkingen kunt u ook het argument doorgeven bij het max_concurrency aanroepen van download_blob. Dit argument definieert het maximum aantal parallelle verbindingen voor de downloadbewerking.

In het volgende codevoorbeeld ziet u hoe u opties voor gegevensoverdracht opgeeft bij het maken van een BlobClient object en hoe u gegevens downloadt met dat clientobject. De waarden in dit voorbeeld zijn niet bedoeld als aanbeveling. Als u deze waarden goed wilt afstemmen, moet u rekening houden met de specifieke behoeften van uw app.

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())

Blobs asynchroon downloaden

De Azure Blob Storage-clientbibliotheek voor Python ondersteunt het asynchroon downloaden van blobs. Zie Asynchrone programmering voor meer informatie over de vereisten voor het instellen van projecten.

Volg deze stappen om een blob te downloaden met behulp van asynchrone API's:

Voeg de volgende importinstructies toe:

import asyncio

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

Voeg code toe om het programma uit te voeren met behulp van asyncio.run. Met deze functie wordt de doorgegeven coroutine uitgevoerd in main() ons voorbeeld en wordt de asyncio gebeurtenislus beheerd. Coroutines worden gedeclareerd met de syntaxis async/await. In dit voorbeeld maakt de main() coroutine eerst het hoogste niveau BlobServiceClient met behulp van async withen roept vervolgens de methode aan waarmee de blob wordt gedownload. Houd er rekening mee dat alleen de client op het hoogste niveau moet worden gebruikt async with, omdat andere clients die ermee zijn gemaakt, dezelfde verbindingsgroep delen.
```
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())
```

Voeg code toe om de blob te downloaden. In het volgende voorbeeld wordt een blob gedownload naar een lokaal bestandspad met behulp van een BlobClient object. De code is hetzelfde als het synchrone voorbeeld, behalve dat de methode wordt gedeclareerd met het async trefwoord en het await trefwoord wordt gebruikt bij het aanroepen van de download_blob methode.

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)

Met deze basisinstallatie kunt u andere voorbeelden in dit artikel implementeren als coroutines met behulp van async/await syntaxis.

Resources

Zie de volgende resources voor meer informatie over het downloaden van blobs met behulp van de Azure Blob Storage-clientbibliotheek voor Python.

REST API-bewerkingen

De Azure SDK voor Python bevat bibliotheken die zijn gebaseerd op de Azure REST API, zodat u kunt communiceren met REST API-bewerkingen via bekende Python-paradigma's. De clientbibliotheekmethoden voor het downloaden van blobs gebruiken de volgende REST API-bewerking:

Blob ophalen (REST API)

Codevoorbeelden

Synchrone of asynchrone codevoorbeelden weergeven uit dit artikel (GitHub)

Share via