Hochladen eines Blockblobs mit Python
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
- Azure-Abonnement – Erstellen eines kostenlosen Kontos
- Azure Storage-Konto – Erstellen eines Speicherkontos
- Ab Python 3.8
Erstellen Ihrer Umgebung
Wenn Sie kein vorhandenes Projekt haben, wird in diesem Abschnitt gezeigt, wie Sie ein Projekt für die Arbeit mit der Azure Blob Storage-Clientbibliothek für Python einrichten. Weitere Details finden Sie unter Erste Schritte mit Azure Blob Storage und Python.
Um die Codebeispiele in diesem Artikel zu verwenden, führen Sie die folgenden Schritte zum Einrichten Ihres Projekts aus.
Installieren von Paketen
Installieren Sie die folgenden Pakete mittels pip install:
pip install azure-storage-blob azure-identity
Hinzufügen von Importanweisungen
Fügen Sie die folgenden import -Anweisungen ein:
import io
import os
import uuid
from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient, ContainerClient, BlobBlock, BlobClient, StandardBlobTier
Autorisierung
Der Autorisierungsmechanismus muss über die erforderlichen Berechtigungen zum Hochladen eines Blobs verfügen. Für die Autorisierung mit Microsoft Entra ID (empfohlen) benötigen Sie mindestens die integrierte Azure RBAC-Rolle Mitwirkender an Storage-Blobdaten. Weitere Informationen finden Sie im Autorisierungsleitfaden für Put Blob (REST API) und Put Block (REST API).
Erstellen eines Clientobjekts
Um eine App mit Blob Storage zu verbinden, erstellen Sie eine Instanz von BlobServiceClient. Das folgende Beispiel zeigt, wie Sie ein Clientobjekt mithilfe von DefaultAzureCredential für die Autorisierung erstellen:
# TODO: Replace <storage-account-name> with your actual storage account name
account_url = "https://<storage-account-name>.blob.core.windows.net"
credential = DefaultAzureCredential()
# Create the BlobServiceClient object
blob_service_client = BlobServiceClient(account_url, credential=credential)
Sie können auch Clientobjekte für bestimmte Container oder Blobs erstellen, entweder direkt oder aus dem BlobServiceClient-Objekt. Weitere Informationen zum Erstellen und Verwalten von Clientobjekten finden Sie unter Erstellen und Verwalten von Clientobjekten, die mit Datenressourcen interagieren.
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 gleichmax_single_put_sizeist, wird das Blob mit einer einzelnenPut Blob-Anforderung hochgeladen. Wenn die Blobgröße größer alsmax_single_put_sizeoder unbekannt ist, wird das Blob mithilfe vonPut Blockin Blöcken hochgeladen und mitPut 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:
Fügen Sie die folgenden import-Anweisungen hinzu:
import asyncio from azure.identity.aio import DefaultAzureCredential from azure.storage.blob.aio import BlobServiceClient, BlobClient, ContainerClientFügen Sie Code hinzu, um das Programm mithilfe von
asyncio.runauszuführen. Diese Funktion führt die übergebene Coroutine aus,main()in unserem Beispiel, und verwaltet die Ereignisschleife vonasyncio. Coroutinen werden mit der async/await-Syntax deklariert. In diesem Beispiel erstellt die Coroutinemain()zunächst die oberste Ebene vonBlobServiceClientmitasync withund ruft dann die Methode auf, die das Blob hochlädt. Beachten Sie, dass nur der Client auf oberster Ebeneasync 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())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.
Codebeispiele
- Anzeigen synchroner oder asynchroner Codebeispiele aus diesem Artikel (GitHub)
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:
Ressourcen zur Clientbibliothek
Weitere Informationen
- Verwalten und Finden von Azure-Blobdaten mit Blobindextags
- Verwenden von Blobindextags zum Verwalten und Suchen von Daten in Azure Blob Storage
Zugehöriger Inhalt
- Dieser Artikel ist Teil des Blob Storage-Entwicklerleitfadens für Python. Weitere Informationen finden Sie in der vollständigen Liste der Entwicklerleitfadenartikel unter Erstellen Ihrer Python-App.