Blokkblob feltöltése Pythonnal

• .NET
• Java
• JavaScript
• TypeScript
• Python

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

• Ez a cikk feltételezi, hogy már van egy projektje, amely a PythonHoz készült Azure Blob Storage ügyfélkódtárral működik együtt. Ha többet szeretne megtudni a projekt beállításáról, beleértve a csomagtelepítést, az utasítások hozzáadását import és egy engedélyezett ügyfélobjektum létrehozását, olvassa el az Azure Blob Storage és a Python használatának első lépéseit.
• Ha aszinkron API-kat szeretne használni a kódban, tekintse meg az Aszinkron programozási szakasz követelményeit.
• Az engedélyezési mechanizmusnak rendelkeznie kell a feltöltési művelet végrehajtásához szükséges engedélyekkel. További információkért tekintse meg az alábbi REST API-műveletek engedélyezési útmutatóját:
  • Blob elhelyezése
  • Blokk elhelyezése

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 BlobServiceClientasync 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.

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)

Code samples

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

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

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

Kapcsolódó információk

• 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