Python ile blok blobu yükleme

Makale
11/16/2023

Bu makalede, Python için Azure Depolama istemci kitaplığını kullanarak bir blobu karşıya yükleme işlemi gösterilmektedir. Bir dosya yolundan, akıştan, ikili nesneden veya metin dizesinden blok bloba veri yükleyebilirsiniz. Blobları dizin etiketleriyle de karşıya yükleyebilirsiniz.

Zaman uyumsuz API'leri kullanarak blobları karşıya yükleme hakkında bilgi edinmek için bkz . Blobları zaman uyumsuz olarak karşıya yükleme.

Önkoşullar

Bu makalede, Python için Azure Blob Depolama istemci kitaplığıyla çalışmak üzere ayarlanmış bir projeniz olduğu varsayılır. Paket yükleme, deyim ekleme import ve yetkili istemci nesnesi oluşturma dahil olmak üzere projenizi ayarlama hakkında bilgi edinmek için bkz. Azure Blob Depolama ve Python'ı kullanmaya başlama.
Kodunuzda zaman uyumsuz API'leri kullanmak için Zaman uyumsuz programlama bölümündeki gereksinimlere bakın.
Yetkilendirme mekanizmasının karşıya yükleme işlemi gerçekleştirme izinleri olmalıdır. Daha fazla bilgi edinmek için aşağıdaki REST API işlemleri için yetkilendirme kılavuzuna bakın:
- Blobu Yerleştir
- Blok Koy

Blok bloba veri yükleme

Akış veya ikili nesne kullanarak bir blobu karşıya yüklemek için aşağıdaki yöntemi kullanın:

upload_blob

Bu yöntem, otomatik öbekleme ile bir veri kaynağından yeni bir blob oluşturur; bu da veri kaynağının daha küçük öbeklere bölünebileceği ve karşıya yüklenebileceği anlamına gelir. Karşıya yüklemeyi gerçekleştirmek için istemci kitaplığı Put Blob veya bir dizi Put Block çağrısı ve ardından Put Block List kullanabilir. Bu davranış, nesnenin genel boyutuna ve veri aktarımı seçeneklerinin nasıl ayarlandığına bağlıdır.

Yerel dosya yolundan blok blobu yükleme

Aşağıdaki örnek, nesne kullanarak BlobClient bir dosyayı blok bloba yükler:

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)

Akıştan blok blobu yükleme

Aşağıdaki örnek rastgele veri baytları oluşturur ve nesnesini kullanarak BlobClient bir BytesIO nesneyi blok bloba yükler:

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

İkili verileri blok bloba yükleme

Aşağıdaki örnek, nesne kullanarak BlobClient ikili verileri blok bloba yükler:

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

Dizin etiketleriyle blok blobu karşıya yükleme

Aşağıdaki örnek, dizin etiketlerine sahip bir blok blobunu karşıya yükler:

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)

Yapılandırma seçenekleriyle blok blobu karşıya yükleme

Blobu karşıya yüklerken istemci kitaplığı yapılandırma seçeneklerini tanımlayabilirsiniz. Bu seçenekler performansı geliştirmek, güvenilirliği artırmak ve maliyetleri iyileştirmek için ayarlanabilir. Aşağıdaki kod örneklerinde, blobclient örneği oluştururken hem yöntem düzeyinde hem de istemci düzeyinde karşıya yükleme için yapılandırma seçeneklerinin nasıl tanımlanacağı gösterilmektedir. Bu seçenekler bir ContainerClient örneği veya BlobServiceClient örneği için de yapılandırılabilir.

Karşıya yükleme için veri aktarımı seçeneklerini belirtme

Veri aktarımı işlemlerinin performansını iyileştirmek için istemci örneği oluştururken yapılandırma seçeneklerini ayarlayabilirsiniz. Python'da bir istemci nesnesi oluştururken aşağıdaki anahtar sözcük bağımsız değişkenlerini geçirebilirsiniz:

max_block_size - Blok blobunu öbeklere yüklemek için en büyük öbek boyutu. Varsayılan değer 4 MiB'dir.
max_single_put_size - Blob boyutu değerinden küçük veya buna eşitse max_single_put_sizeblob tek Put Blob bir istekle karşıya yüklenir. Blob boyutu değerinden max_single_put_size büyük veya bilinmiyorsa blob kullanılarak Put Block öbekler halinde karşıya yüklenir ve kullanılarak Put Block Listişlenir. Varsayılan değer 64 MiB'dir.

Blob Depolama aktarım boyutu sınırları hakkında daha fazla bilgi için bkz. Blob depolama için hedefleri ölçeklendirme.

Karşıya yükleme işlemleri için, upload_blob çağırırken bağımsız değişkeni de geçirebilirsinizmax_concurrency. Bu bağımsız değişken, blob boyutu 64 MiB'yi aştığında kullanılacak en fazla paralel bağlantı sayısını tanımlar.

Aşağıdaki kod örneği, nesne BlobClient oluştururken veri aktarımı seçeneklerini belirtmeyi ve bu istemci nesnesini kullanarak verileri karşıya yüklemeyi gösterir. Bu örnekte sağlanan değerler bir öneri olarak tasarlanmamıştır. Bu değerleri düzgün ayarlamak için uygulamanızın belirli gereksinimlerini dikkate almanız gerekir.

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)

Veri aktarımı seçeneklerini ayarlama hakkında daha fazla bilgi edinmek için bkz . Python ile karşıya yüklemeler ve indirmeler için performans ayarlama.

Karşıya yüklemede blob'un erişim katmanını ayarlama

Anahtar sözcük bağımsız değişkenini upload_blob geçirerek karşıya yüklemede blob'un standard_blob_tier erişim katmanını ayarlayabilirsiniz. Azure Depolama, blob verilerinizi nasıl kullanıldıklarına bağlı olarak en etkili şekilde depolayabilmeniz için farklı erişim katmanları sunar.

Aşağıdaki kod örneğinde blob karşıya yüklenirken erişim katmanının nasıl ayarlanacağı gösterilmektedir:

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)

Erişim katmanının ayarlanmasına yalnızca blok blobları için izin verilir. Blok blobu için erişim katmanını Hot, , CoolColdveya Archiveolarak ayarlayabilirsiniz. Erişim katmanını olarak ayarlamak için Colden az 12.15.0 istemci kitaplığı sürümünü kullanmanız gerekir.

Erişim katmanları hakkında daha fazla bilgi edinmek için bkz . Erişim katmanlarına genel bakış.

Blokları hazırlama ve işleme yoluyla blok blobu yükleme

Tek tek veri bloklarını el ile hazırlayarak karşıya yüklemeleri bloklara bölme konusunda daha fazla denetime sahip olabilirsiniz. Bir blobu oluşturan tüm bloklar hazırlandığında, bunları Blob Depolama'a işleyebilirsiniz.

Bir blobun parçası olarak işlenecek yeni bir blok oluşturmak için aşağıdaki yöntemi kullanın:

stage_block

Blobu oluşturan blok kimliklerinin listesini belirterek blob yazmak için aşağıdaki yöntemi kullanın:

commit_block_list

Aşağıdaki örnek bir dosyadaki verileri okur ve blobun parçası olarak işlenecek blokları aşamalar:

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)

Blobları zaman uyumsuz olarak karşıya yükleme

Python için Azure Blob Depolama istemci kitaplığı, blobların zaman uyumsuz olarak karşıya yüklenmesini destekler. Proje kurulum gereksinimleri hakkında daha fazla bilgi edinmek için bkz . Zaman uyumsuz programlama.

Zaman uyumsuz API'leri kullanarak bir blobu karşıya yüklemek için şu adımları izleyin:

Aşağıdaki içeri aktarma deyimlerini ekleyin:

import asyncio

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

kullanarak asyncio.runprogramı çalıştırmak için kod ekleyin. Bu işlev, main() örneğimizde geçirilen eş yordamları çalıştırır ve olay döngüsünü yönetir asyncio . Eş yordamlar zaman uyumsuz/await söz dizimi ile bildirilir. Bu örnekte, main() coroutine önce kullanarak async withen üst düzeyi BlobServiceClient oluşturur, ardından blobu karşıya yükleyen yöntemi çağırır. Yalnızca en üst düzey istemcinin kullanması async withgerektiğini unutmayın; bu istemciden oluşturulan diğer istemciler aynı bağlantı havuzunu paylaşır.
```
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())
```

Blobu karşıya yüklemek için kod ekleyin. Aşağıdaki örnek, bir nesne kullanarak yerel dosya yolundan bir ContainerClient blob yükler. Kod, zaman uyumlu örnekle aynıdır, ancak yöntemi anahtar sözcüğüyle async bildirilir ve await yöntemi çağrılırken upload_blob anahtar sözcüğü kullanılır.

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)

Bu temel kurulumla, bu makaledeki diğer örnekleri zaman uyumsuz/await söz dizimini kullanarak eş yordam olarak uygulayabilirsiniz.

Kaynaklar

Python için Azure Blob Depolama istemci kitaplığını kullanarak blobları karşıya yükleme hakkında daha fazla bilgi edinmek için aşağıdaki kaynaklara bakın.

REST API işlemleri

Python için Azure SDK, Azure REST API'sinin üzerinde derlenmiş kitaplıklar içerir ve tanıdık Python paradigmalarıyla REST API işlemleriyle etkileşim kurmanızı sağlar. Blobları karşıya yüklemek için istemci kitaplığı yöntemleri aşağıdaki REST API işlemlerini kullanır:

Blobu Yerleştirme (REST API)
Blok Koy (REST API)

Kod örnekleri

Bu makaledeki (GitHub) zaman uyumlu veya zaman uyumsuz kod örneklerini görüntüleyin