Blokkblob feltöltése Pythonnal

• .NET
• Java
• JavaScript
• TypeScript
• Python
• Ugrás

Ez a cikk bemutatja, hogyan tölthet fel blobokat a Pythonhoz készült Azure Storage ügyfélkódtár használatával. Adatokat feltölthet egy blokkblobba egy fájl elérési útjáról, egy streamből, egy bináris objektumból vagy egy szöveges sztringből. Indexcímkéket tartalmazó blobokat is feltölthet.

A blobok aszinkron API-k használatával történő feltöltéséről további információt a blobok aszinkron feltöltése című témakörben talál.

Előfeltételek

• Azure-előfizetés – hozzon létre egyet ingyenesen
• Azure Storage-fiók – tárfiók létrehozása
• Python 3.8+

Saját környezet beállítása

Ha nem rendelkezik meglévő projekttel, ez a szakasz bemutatja, hogyan állíthat be egy projektet a PythonHoz készült Azure Blob Storage ügyfélkódtár használatához. További részletekért tekintse meg az Azure Blob Storage és a Python használatának első lépéseit.

A jelen cikkben szereplő példakódok használatához kövesse az alábbi lépéseket a projekt beállításához.

Csomagok telepítése

Telepítse a következő csomagokat a következő használatával pip install:

pip install azure-storage-blob azure-identity

Importálási utasítások hozzáadása

Adja hozzá a következő import-utasításokat:

import io
import os
import uuid
from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient, ContainerClient, BlobBlock, BlobClient, StandardBlobTier

Engedélyezés

Az engedélyezési mechanizmusnak rendelkeznie kell a blob feltöltéséhez szükséges engedélyekkel. A Microsoft Entra-azonosítóval való engedélyezéshez (ajánlott) az Azure RBAC beépített szerepkörű Storage Blob Data Közreműködő vagy újabb szerepkörre van szüksége. További információkért tekintse meg a Put Blob (REST API) és a Put Block (REST API) engedélyezési útmutatóját.

Ügyfélobjektum létrehozása

Ha egy alkalmazást a Blob Storage-hoz szeretne csatlakoztatni, hozzon létre egy BlobServiceClient-példányt. Az alábbi példa bemutatja, hogyan hozhat létre ügyfélobjektumot DefaultAzureCredential engedélyezés céljából:

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

Ügyfélobjektumokat is létrehozhat adott tárolókhoz vagy blobokhoz közvetlenül vagy az BlobServiceClient objektumból. Az ügyfélobjektumok létrehozásáról és kezeléséről további információt az adaterőforrásokat kezelő ügyfélobjektumok létrehozása és kezelése című témakörben talál.

Adatok feltöltése blokkblobba

Blob stream vagy bináris objektum használatával való feltöltéséhez használja a következő módszert:

• upload_blob

Ez a módszer egy új blobot hoz létre egy automatikus adattömbökkel rendelkező adatforrásból, ami azt jelenti, hogy az adatforrás kisebb adattömbökre osztható és feltölthető. A feltöltés végrehajtásához az ügyfélkódtár használhatja a Put Blob vagy a Put Block hívások sorozatát, majd a Blokklista elhelyezése parancsot. Ez a viselkedés az objektum teljes méretétől és az adatátviteli beállítások beállításától függ.

Blokkblob feltöltése helyi fájl elérési útjáról

Az alábbi példa egy fájlt tölt fel egy blokkblobba egy BlobClient objektum használatával:

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)

Blokkblob feltöltése streamből

Az alábbi példa véletlenszerű bájtnyi adatot hoz létre, és objektumot BytesIO tölt fel egy blokkblobba egy BlobClient objektum használatával:

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

Bináris adatok feltöltése blokkblobba

Az alábbi példa bináris adatokat tölt fel egy blokkblobba egy BlobClient objektum használatával:

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

Blokkblob feltöltése indexcímkékkel

Az alábbi példa egy indexcímkéket tartalmazó blokkblobot tölt fel:

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)

Blokkblob feltöltése konfigurációs beállításokkal

Blob feltöltésekor megadhatja az ügyfélkódtár konfigurációs beállításait. Ezek a lehetőségek a teljesítmény javítása, a megbízhatóság növelése és a költségek optimalizálása érdekében hangolhatók. Az alábbi példakód bemutatja, hogyan definiálhat konfigurációs beállításokat egy feltöltéshez mind a metódus szintjén, mind az ügyfél szintjén a BlobClient példányosítása során. Ezek a beállítások containerClient-példányokhoz vagy BlobServiceClient-példányokhoz is konfigurálhatók.

A feltöltés adatátviteli beállításainak megadása

Az ügyfél példányosításakor konfigurálási beállításokat állíthat be az adatátviteli műveletek teljesítményének optimalizálása érdekében. Ügyfélobjektum Pythonban történő létrehozásakor a következő kulcsszóargumentumokat adhatja át:

• max_block_size – A blokkblobok adattömbökben való feltöltésének maximális adattömbmérete. Alapértelmezés szerint 4 MiB.
• max_single_put_size - Ha a blob mérete kisebb vagy egyenlő max_single_put_size, a blob egyetlen Put Blob kéréssel lesz feltöltve. Ha a blob mérete nagyobb max_single_put_size vagy ismeretlen, a blob adattömbökbe lesz feltöltve a használatával Put Block , és a használatával Put Block Listvéglegesítve lesz. Alapértelmezés szerint 64 miB.

A Blob Storage átviteli méretkorlátjairól további információt a Blob Storage céljainak méretezése című témakörben talál.

A feltöltési műveletekhez az argumentumot is átadhatja upload_blob max_concurrency hívásakor. Ez az argumentum határozza meg a párhuzamos kapcsolatok maximális számát, ha a blob mérete meghaladja a 64 MiB-t.

Az alábbi példakód bemutatja, hogyan adhatja meg az adatátviteli beállításokat egy BlobClient objektum létrehozásakor, és hogyan tölthet fel adatokat az ügyfélobjektum használatával. Az ebben a mintában megadott értékek nem javaslatok. Ezeknek az értékeknek a megfelelő finomhangolásához figyelembe kell vennie az alkalmazás adott igényeit.

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)

Az adatátviteli beállítások finomhangolásáról további információt a Feltöltések és letöltések teljesítményhangolása a Pythonnal című témakörben talál.

Blob hozzáférési szintjének beállítása feltöltésre

A blobok hozzáférési szintjét úgy állíthatja be feltöltéskor, hogy átadja a standard_blob_tier kulcsszó argumentumát upload_blob. Az Azure Storage különböző hozzáférési szinteket kínál, így a blobadatokat a legköltséghatékonyabb módon tárolhatja a használatuktól függően.

Az alábbi példakód bemutatja, hogyan állíthatja be a hozzáférési szintet egy blob feltöltésekor:

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)

A hozzáférési szint beállítása csak blokkblobok esetén engedélyezett. A blokkblobok Hothozzáférési szintjét a következőre állíthatja be: , Coolvagy ArchiveCold. A hozzáférési szint Coldbeállításához a 12.15.0-s minimális ügyfélkódtár-verziót kell használnia.

A hozzáférési szintekről további információt az Access-szintek áttekintésében talál.

Blokkblob feltöltése blokkok előkészítésével és véglegesítésével

Az egyes adatblokkok manuális előkészítésével nagyobb mértékben szabályozhatja a feltöltések blokkokra való felosztását. Amikor a blobokat alkotó összes blokkot előkészítette, véglegesítheti őket a Blob Storage-ban.

A következő módszerrel hozzon létre egy új blokkot, amelyet egy blob részeként szeretne véglegesíteni:

• stage_block

Blob írásához használja az alábbi módszert a blobokat alkotó blokkazonosítók listájának megadásával:

• commit_block_list

Az alábbi példa egy fájlból olvassa be az adatokat, és a blob részeként véglegesíteni kívánt fázisblokkokat:

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)

Blobok aszinkron feltöltése

A Pythonhoz készült Azure Blob Storage ügyfélkódtár támogatja a blobok aszinkron feltöltését. A projektbeállítási követelményekről további információt az Aszinkron programozás című témakörben talál.

Kövesse az alábbi lépéseket egy blob aszinkron API-k használatával való feltöltéséhez:

1. Adja hozzá a következő importálási utasításokat:

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

2. Kód hozzáadása a program futtatásához a következő használatával asyncio.run: . Ez a függvény a példánkban futtatja az átadott koroutint, main() és kezeli az asyncio eseményhurokot. A koroutinok az aszinkron/várakozási szintaxissal vannak deklarálva. Ebben a példában a main() koroutin először a legfelső szintet BlobServiceClient async withhozza létre, majd meghívja a blobot feltöltő metódust. Vegye figyelembe, hogy csak a legfelső szintű ügyfélnek kell használnia async with, mivel az abból létrehozott többi ügyfél ugyanazt a kapcsolatkészletet használja.

   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. Adjon hozzá kódot a blob feltöltéséhez. Az alábbi példa egy blobot tölt fel egy helyi fájl elérési útjáról egy ContainerClient objektum használatával. A kód megegyezik a szinkron példával, azzal a kivétellel, hogy a metódus a kulcsszóval async van deklarálva, és a await kulcsszót a metódus meghívásakor használja a upload_blob rendszer.

   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)
   

Ezzel az alapszintű beállítással a cikkben más példákat is implementálhat coroutinesként az aszinkron/várakozási szintaxis használatával.

Források

Ha többet szeretne megtudni a blobok Pythonhoz készült Azure Blob Storage-ügyfélkódtár használatával történő feltöltéséről, tekintse meg az alábbi erőforrásokat.

Kódminták

• Szinkron vagy aszinkron kódminták megtekintése ebből a cikkből (GitHub)

REST API-műveletek

Az Azure SDK for Python olyan kódtárakat tartalmaz, amelyek az Azure REST API-ra épülnek, lehetővé téve a REST API-műveletek használatát jól ismert Python-paradigmákon keresztül. A blobok feltöltéséhez használt ügyfélkódtár-metódusok a következő REST API-műveleteket használják:

• Blob elhelyezése (REST API)
• Blokk elhelyezése (REST API)

Ügyfélkódtár erőforrásai

• Ügyfélkódtár referenciadokumentációja
• Ügyfélkódtár forráskódja
• Csomag (PyPi)

Lásd még

• Azure Blob-adatok kezelése és keresése blobindexcímkék használatával
• Blobindex-címkék használata az Azure Blob Storage-adatok kezeléséhez és kereséséhez

Kapcsolódó tartalom

• Ez a cikk a Python Blob Storage fejlesztői útmutatójának része. További információkért tekintse meg a Python-alkalmazás buildeléséhez kapcsolódó fejlesztői útmutatók teljes listáját.