Megosztás a következőn keresztül:

Blokkblob feltöltése Pythonnal

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

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(z) pip install használatával:

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 történő engedélyezéshez (ajánlott) szüksége van az Azure RBAC beépített szerepköreinek egyikére, például a Storage Blob Data közreműködő vagy annál magasabb szintű szerepkörre. 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 feltöltéséhez stream vagy bináris objektum használatával, alkalmazza a következő módszert:

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önyvtár használhatja a Put Blob-ot vagy a Put Block hívások sorozatát, majd a Put Block List-et. 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.

Megjegyzés

Az Azure Storage-ügyfélkódtárak nem támogatják ugyanahhoz a blobhoz való egyidejű írást. Ha az alkalmazáshoz több folyamat írása szükséges ugyanahhoz a blobhoz, akkor az egyidejűség-vezérlés stratégiáját kell implementálnia, hogy kiszámítható élményt nyújtson. Az egyidejűségi stratégiákról további információt a Egyidejűség kezelése a Blob Storage-bancímű témakörben talál.

Feltöltés blokkblobként egy helyi fájl elérési útvonalá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)

Egy blokk blob feltöltése egy streamből

Az alábbi példa véletlenszerű adatbájtokat hoz létre, és egy BytesIO objektumot tölt fel egy blokkblobba a 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ék hozzáadásával

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)

Blokk típusú blob 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, 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, akkor a blobot adattömbökre bontva töltjük fel Put Block használatával, és Put Block List használatával véglegesítjük. 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.

Feltöltési műveletek esetén az max_concurrency argumentumot is megadhatja az upload_blob 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és közben

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 hozzáférési szintjét beállíthatja Hot, Cool, Cold, vagy Archive értékekre. 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 összeállításával é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:

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

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. Adj hozzá kódot 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 korutinokat az async/await szintaxissal deklarálják. Ebben a példában a main() koroutin először a legfelső szintet a BlobServiceClient segítségével async with hozza 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ódrészletek

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:

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

Lásd még

Kapcsolódó tartalom

  • Last updated on