Ladda upp en blockblob med Python

Artikel
11/16/2023

Den här artikeln visar hur du laddar upp en blob med hjälp av Azure Storage-klientbiblioteket för Python. Du kan ladda upp data till en blockblob från en filsökväg, en ström, ett binärt objekt eller en textsträng. Du kan också ladda upp blobar med indextaggar.

Mer information om hur du laddar upp blobar med asynkrona API:er finns i Ladda upp 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 uppladdningsåtgärd. Mer information finns i auktoriseringsvägledningen för följande REST API-åtgärder:
- Placera blob
- Placera block

Ladda upp data till en blockblob

Om du vill ladda upp en blob med hjälp av en dataström eller ett binärt objekt använder du följande metod:

upload_blob

Den här metoden skapar en ny blob från en datakälla med automatisk segmentering, vilket innebär att datakällan kan delas upp i mindre segment och laddas upp. För att utföra uppladdningen kan klientbiblioteket använda antingen Put Blob eller en serie Put Block-anrop följt av Placera blockeringslista. Det här beteendet beror på objektets övergripande storlek och hur dataöverföringsalternativen anges.

Ladda upp en blockblob från en lokal filsökväg

I följande exempel laddas en fil upp till en blockblob med hjälp av ett BlobClient objekt:

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)

Ladda upp en blockblob från en dataström

I följande exempel skapas slumpmässiga byte med data och ett BytesIO objekt laddas upp till en blockblob med hjälp av ett BlobClient objekt:

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

Ladda upp binära data till en blockblob

I följande exempel laddas binära data upp till en blockblob med hjälp av ett BlobClient objekt:

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

Ladda upp en blockblob med indextaggar

I följande exempel laddas en blockblob upp med indextaggar:

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)

Ladda upp en blockblob med konfigurationsalternativ

Du kan definiera konfigurationsalternativ för klientbibliotek när du laddar upp en blob. Dessa alternativ kan justeras för att förbättra prestanda, förbättra tillförlitligheten och optimera kostnaderna. Följande kodexempel visar hur du definierar konfigurationsalternativ för en uppladdning 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 för uppladdning

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_block_size – Den maximala segmentstorleken för att ladda upp en blockblob i segment. Standardvärdet är 4 MiB.
max_single_put_size – Om blobstorleken är mindre än eller lika max_single_put_sizemed laddas blobben upp med en enda Put Blob begäran. Om blobstorleken är större än max_single_put_size eller okänd laddas bloben upp i segment med hjälp av Put Block och bekräftas med hjälp av Put Block List. Standardvärdet är 64 MiB.

Mer information om överföringsstorleksgränser för Blob Storage finns i Skala mål för Blob Storage.

För uppladdningsåtgärder kan du också skicka max_concurrency argumentet när du anropar upload_blob. Det här argumentet definierar det maximala antalet parallella anslutningar som ska användas när blobstorleken överskrider 64 MiB.

Följande kodexempel visar hur du anger alternativ för dataöverföring när du skapar ett BlobClient objekt och hur du laddar upp 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 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)

Mer information om hur du justerar dataöverföringsalternativ finns i Prestandajustering för uppladdningar och nedladdningar med Python.

Ange åtkomstnivån för en blob vid uppladdning

Du kan ange åtkomstnivån för en blob vid uppladdning genom att skicka nyckelordsargumentet standard_blob_tier till upload_blob. Azure Storage erbjuder olika åtkomstnivåer så att du kan lagra dina blobdata på det mest kostnadseffektiva sättet baserat på hur de används.

Följande kodexempel visar hur du anger åtkomstnivån när du laddar upp en blob:

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)

Det går bara att ange åtkomstnivån för blockblobar. Du kan ange åtkomstnivån för en blockblob till Hot, Cool, Coldeller Archive. Om du vill ange åtkomstnivån till Coldmåste du använda en lägsta klientbiblioteksversion på 12.15.0.

Mer information om åtkomstnivåer finns i Översikt över åtkomstnivåer.

Ladda upp en blockblob genom mellanlagringsblock och incheckning

Du kan ha större kontroll över hur du delar uppladdningar i block genom att mellanlagring av enskilda datablock manuellt. När alla block som utgör en blob mellanlagras kan du checka in dem till Blob Storage.

Använd följande metod för att skapa ett nytt block som ska checkas in som en del av en blob:

stage_block

Använd följande metod för att skriva en blob genom att ange listan över block-ID:t som utgör bloben:

commit_block_list

I följande exempel läss data från en fil och fasblock som ska checkas in som en del av en blob:

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)

Ladda upp blobar asynkront

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

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

Lägg till följande importinstruktioner:

import asyncio

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

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

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

Lägg till kod för att ladda upp bloben. I följande exempel laddas en blob upp från en lokal filsökväg med hjälp av ett ContainerClient 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 upload_blob .

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)

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 upp 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 upp blobar använder följande REST API-åtgärder: