Teilen über

Hochladen eines Blockblobs mit Python

  • Artikel

In diesem Artikel wird beschrieben, wie ein Blob mithilfe der Azure Storage-Clientbibliothek für Python hochgeladen wird. Sie können Daten aus einem Dateipfad, einem Stream, einem binären Objekt oder einer Textzeichenfolge in ein Blockblob hochladen. Sie können auch Blobs mit Indextags hochladen.

Informationen zum Hochladen von Blobs mithilfe asynchroner APIs finden Sie unter Asynchrones Hochladen von Blobs.

Voraussetzungen

  • In diesem Artikel wird davon ausgegangen, dass Sie bereits ein Projekt für die Arbeit mit der Azure Blob Storage-Clientbibliothek für Python eingerichtet haben. Informationen zum Einrichten Ihres Projekts – einschließlich Paketinstallation, Hinzufügen von import-Anweisungen und Erstellen eines autorisierten Clientobjekts – finden Sie unter Erste Schritte mit Azure Blob Storage und Python.
  • Informationen zur Verwendung asynchroner APIs in Ihrem Code finden Sie in den Anforderungen im Abschnitt Asynchrone Programmierung.
  • Der Autorisierungsmechanismus muss über Berechtigungen zum Ausführen eines Uploadvorgangs verfügen. Weitere Informationen finden Sie im Autorisierungsleitfaden für die folgenden REST-API-Vorgänge:

Hochladen von Daten in ein Blockblob

Um ein Blob mit einem Stream oder einem Binärobjekt hochzuladen, verwenden Sie die folgende Methode:

Diese Methode erstellt ein neues Blob aus einer Datenquelle mit automatischem Blocking, was bedeutet, dass die Datenquelle in kleinere Blöcke aufgeteilt und hochgeladen werden kann. Um den Upload durchzuführen, kann die Clientbibliothek entweder Put Blob oder eine Reihe von Put Block-Aufrufen gefolgt von Put Block List verwenden. Dieses Verhalten hängt von der Gesamtgröße des Objekts ab und davon, wie die Datenübertragungsoptionen festgelegt sind.

Hochladen eines Blockblobs aus einem lokalen Dateipfad

Im folgenden Beispiel wird eine Datei mithilfe eines BlobClient-Objekts in ein Blockblob hochgeladen:

def upload_blob_file(self, blob_service_client: BlobServiceClient, container_name: str):
    container_client = blob_service_client.get_container_client(container=container_name)
    with open(file=os.path.join('filepath', 'filename'), mode="rb") as data:
        blob_client = container_client.upload_blob(name="sample-blob.txt", data=data, overwrite=True)

Hochladen eines Blockblobs aus einem Stream

Im folgenden Beispiel werden zufällige Bytes von Daten erstellt und ein BytesIO-Objekt mithilfe eines BlobClient-Objekts in ein Blockblob hochgeladen:

def upload_blob_stream(self, blob_service_client: BlobServiceClient, container_name: str):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")
    input_stream = io.BytesIO(os.urandom(15))
    blob_client.upload_blob(input_stream, blob_type="BlockBlob")

Hochladen von Binärdaten in ein Blockblob

Im folgenden Beispiel werden Binärdaten mithilfe eines BlobClient-Objekts in ein Blockblob hochgeladen:

def upload_blob_data(self, blob_service_client: BlobServiceClient, container_name: str):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")
    data = b"Sample data for blob"

    # Upload the blob data - default blob type is BlockBlob
    blob_client.upload_blob(data, blob_type="BlockBlob")

Hochladen eines Blockblobs mit Indextags

Im folgenden Beispiel wird ein Blockblob mit Indextags hochgeladen:

def upload_blob_tags(self, blob_service_client: BlobServiceClient, container_name: str):
    container_client = blob_service_client.get_container_client(container=container_name)
    sample_tags = {"Content": "image", "Date": "2022-01-01"}
    with open(file=os.path.join('filepath', 'filename'), mode="rb") as data:
        blob_client = container_client.upload_blob(name="sample-blob.txt", data=data, tags=sample_tags)

Upload eines Blockblobs mit Konfigurationsoptionen

Beim Upload eines Blobs können Sie Clientbibliotheks-Konfigurationsoptionen definieren. Diese Optionen können feiner abgestimmt werden, um die Leistung und die Zuverlässigkeit zu verbessern und die Kosten zu optimieren. Die folgenden Codebeispiele zeigen, wie Sie Konfigurationsoptionen für einen Upload sowohl auf Methodenebene als auch auf Clientebene beim Instanziieren von BlobClient definieren. Diese Optionen können auch für eine ContainerClient-Instanz oder eine BlobServiceClient-Instanz konfiguriert werden.

Angeben von Datenübertragungsoptionen für den Upload

Sie können beim Instanziieren eines Clients Konfigurationsoptionen festlegen, um die Leistung für Datenübertragungsvorgänge zu optimieren. Sie können die folgenden Schlüsselwortargumente übergeben, wenn Sie ein Clientobjekt in Python erstellen:

  • max_block_size – Die maximale Blockgröße zum Hochladen eines Blockblobs in Blöcken. Der Standardwert ist 4 MiB.
  • max_single_put_size – Wenn die Blobgröße kleiner oder gleich max_single_put_size ist, wird das Blob mit einer einzelnen Put Blob-Anforderung hochgeladen. Wenn die Blobgröße größer als max_single_put_size oder unbekannt ist, wird das Blob mithilfe von Put Block in Blöcken hochgeladen und mit Put Block Listcommittet. Der Standardwert ist 64 MiB.

Weitere Informationen zu Grenzwerten im Zusammenhang mit der Übertragungsgröße für Blob Storage finden Sie unter Skalierbarkeitsziele für Blob Storage.

Bei Uploadvorgängen können Sie das max_concurrency-Argument auch übergeben, wenn Sie upload_blob aufrufen. Dieses Argument definiert die maximale Anzahl paralleler Verbindungen, die verwendet werden sollen, wenn die Blobgröße 64 MiB überschreitet.

Das folgende Codebeispiel zeigt, wie beim Erstellen eines BlobClient-Objekts Datenübertragungsoptionen angegeben und Daten mithilfe dieses Clientobjekts hochgeladen werden. Die in diesem Beispiel angegebenen Werte sind nicht als Empfehlungen zu verstehen. Zur ordnungsgemäßen Optimierung dieser Werte müssen die spezifischen Anforderungen Ihrer App berücksichtigt werden.

def upload_blob_transfer_options(self, account_url: str, container_name: str, blob_name: str):
    # Create a BlobClient object with data transfer options for upload
    blob_client = BlobClient(
        account_url=account_url, 
        container_name=container_name, 
        blob_name=blob_name,
        credential=DefaultAzureCredential(),
        max_block_size=1024*1024*4, # 4 MiB
        max_single_put_size=1024*1024*8 # 8 MiB
    )
    
    with open(file=os.path.join(r'file_path', blob_name), mode="rb") as data:
        blob_client = blob_client.upload_blob(data=data, overwrite=True, max_concurrency=2)

Weitere Informationen zur Feinabstimmung von Datenübertragungsoptionen finden Sie unter Leistungsoptimierung für Uploads und Downloads mit Python.

Festlegen der Zugriffsebene eines Blobs während des Uploads

Sie können die Zugriffsebene eines Blobs für den Upload festlegen, indem Sie das standard_blob_tier-Schlüsselwortargument an upload_blob übergeben. Azure Storage weist verschiedene Zugriffsebenen auf, sodass Sie Blobdaten basierend auf ihrer Verwendung auf die kostengünstigste Weise speichern können.

Im folgenden Codebeispiel wird gezeigt, wie die Zugriffsebene beim Upload eines Blobs festgelegt wird:

def upload_blob_access_tier(self, blob_service_client: BlobServiceClient, container_name: str, blob_name: str):
    blob_client = blob_service_client.get_blob_client(container=container_name, blob=blob_name)
    
    #Upload blob to the cool tier
    with open(file=os.path.join(r'file_path', blob_name), mode="rb") as data:
        blob_client = blob_client.upload_blob(data=data, overwrite=True, standard_blob_tier=StandardBlobTier.COOL)

Das Festlegen der Zugriffsebene ist nur für Blockblobs zulässig. Sie können die Zugriffsebene für ein Blockblob auf Hot, Cool, Cold oder Archive festlegen. Um die Zugriffsebene auf Cold festzulegen, müssen Sie mindestens die Version 12.15.0 der Clientbibliothek verwenden.

Weitere Informationen zu Zugriffsebenen finden Sie unter Übersicht über Zugriffsebenen.

Hochladen eines Blockblobs durch Stagingblöcke und Commit

Sie können die Aufteilung der Uploads in Blöcke besser kontrollieren, indem Sie einzelne Datenblöcke manuell bereitstellen. Wenn alle Blöcke, aus denen ein Blob besteht, bereitgestellt wurden, können Sie sie in Blob Storage committen.

Verwenden Sie die folgende Methode, um einen neuen Block zu erstellen, der als Teil eines Blobs committet werden soll:

Verwenden Sie die folgende Methode, um ein Blob zu schreiben, indem Sie die Liste der Block-IDs angeben, aus denen das Blob besteht:

Im folgenden Beispiel werden Daten aus einer Datei gelesen und Blöcke bereitgestellt, die als Teil eines Blobs übertragen werden:

def upload_blocks(self, blob_container_client: ContainerClient, local_file_path: str, block_size: int):
    file_name = os.path.basename(local_file_path)
    blob_client = blob_container_client.get_blob_client(file_name)

    with open(file=local_file_path, mode="rb") as file_stream:
        block_id_list = []

        while True:
            buffer = file_stream.read(block_size)
            if not buffer:
                break

            block_id = uuid.uuid4().hex
            block_id_list.append(BlobBlock(block_id=block_id))

            blob_client.stage_block(block_id=block_id, data=buffer, length=len(buffer))

        blob_client.commit_block_list(block_id_list)

Asynchrones Hochladen von Blobs

Die Azure Blob Storage-Clientbibliothek für Python unterstützt das asynchrone Hochladen von Blobs. Weitere Informationen zu den Projekteinrichtungsanforderungen finden Sie unter Asynchrone Programmierung.

Führen Sie die folgenden Schritte aus, um ein Blob mithilfe asynchroner APIs hochzuladen:

  1. Fügen Sie die folgenden import-Anweisungen hinzu:

    import asyncio

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

  2. Fügen Sie Code hinzu, um das Programm mithilfe von asyncio.run auszuführen. Diese Funktion führt die übergebene Coroutine aus, main() in unserem Beispiel, und verwaltet die Ereignisschleife von asyncio. Coroutinen werden mit der async/await-Syntax deklariert. In diesem Beispiel erstellt die Coroutine main() zunächst die oberste Ebene von BlobServiceClient mit async withund ruft dann die Methode auf, die das Blob hochlädt. Beachten Sie, dass nur der Client auf oberster Ebene async withverwenden muss, da andere von ihm erstellte Clients denselben Verbindungspool aufweisen.

    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.upload_blob_file(blob_service_client, "sample-container")

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

  3. Fügen Sie Code zum Hochladen des Blob hinzu. Im folgenden Beispiel wird ein Blob aus einem lokalen Dateipfad mithilfe eines ContainerClient-Objekts hochgeladen: Der Code ist identisch mit dem synchronen Beispiel, mit der Ausnahme, dass die Methode mit dem Schlüsselwort „async“ deklariert wird und das Schlüsselwort „await‘‘ beim Aufrufen der Methode „upload_blob“ verwendet wird.

    async def upload_blob_file(self, blob_service_client: BlobServiceClient, container_name: str):
    container_client = blob_service_client.get_container_client(container=container_name)
    with open(file=os.path.join('filepath', 'filename'), mode="rb") as data:
        blob_client = await container_client.upload_blob(name="sample-blob.txt", data=data, overwrite=True)

Mit dieser grundlegenden Einrichtung können Sie weitere Beispiele in diesem Artikel als Coroutinen mit async/await-Syntax implementieren.

Ressourcen

Weitere Informationen zum Hochladen von Blobs mithilfe der Azure Blob Storage-Clientbibliothek für Python finden Sie in den folgenden Ressourcen.

REST-API-Vorgänge

Das Azure SDK für Python enthält Bibliotheken, die auf der Azure-REST-API basieren, und ermöglicht Ihnen so die Interaktion mit REST-API-Vorgängen über vertraute Python-Paradigmen. Die Clientbibliotheksmethoden zum Hochladen von Blobs verwenden die folgenden REST-API-Vorgänge:

Codebeispiele

Ressourcen zur Clientbibliothek

Weitere Informationen