Dela via

Skapa och hantera bloblån med Python

  • Artikel

Den här artikeln visar hur du skapar och hanterar bloblån med hjälp av Azure Storage-klientbiblioteket för Python. Du kan använda klientbiblioteket för att hämta, förnya, frigöra och bryta bloblån.

Mer information om hur du hyr en blob med asynkrona API:er finns i Avsnittet om att asynkront låna blobar.

Förutsättningar

Konfigurera din miljö

Om du inte har ett befintligt projekt visar det här avsnittet hur du konfigurerar ett projekt för att arbeta med Azure Blob Storage-klientbiblioteket för Python. Mer information finns i Kom igång med Azure Blob Storage och Python.

Följ de här stegen för att konfigurera projektet om du vill arbeta med kodexemplen i den här artikeln.

Installera paket

Installera följande paket med :pip install

pip install azure-storage-blob azure-identity

Lägga till importinstruktioner

Lägg till följande import-uttryck:

from azure.identity import DefaultAzureCredential
from azure.storage.blob import BlobServiceClient, BlobLeaseClient

Auktorisering

Auktoriseringsmekanismen måste ha de behörigheter som krävs för att fungera med ett bloblån. För auktorisering med Microsoft Entra-ID (rekommenderas) behöver du den inbyggda rollen Storage Blob Data Contributor eller senare. Mer information finns i auktoriseringsvägledningen för låneblob (REST API).

Skapa ett klientobjekt

Om du vill ansluta en app till Blob Storage skapar du en instans av BlobServiceClient. I följande exempel visas hur du skapar ett klientobjekt med hjälp av DefaultAzureCredential för auktorisering:

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

Du kan också skapa klientobjekt för specifika containrar eller blobar, antingen direkt eller från objektet BlobServiceClient . Mer information om hur du skapar och hanterar klientobjekt finns i Skapa och hantera klientobjekt som interagerar med dataresurser.

Om bloblån

Ett lån skapar och hanterar ett lås på en blob för skriv- och borttagningsåtgärder. Låsvaraktigheten kan vara mellan 15 och 60 sekunder, eller så kan den vara oändlig. Ett lån på en blob ger exklusiv skriv- och borttagningsåtkomst till bloben. Om du vill skriva till en blob med ett aktivt lån måste en klient inkludera det aktiva låne-ID:t med skrivbegäran.

Mer information om lånetillstånd och när du kan utföra en viss åtgärd på ett lån finns i Lånetillstånd och åtgärder.

Alla containeråtgärder är tillåtna för en container som innehåller blobar med ett aktivt lån, inklusive Ta bort container. Därför kan en container tas bort även om blobar i den har aktiva lån. Använd åtgärden Lånecontainer för att kontrollera behörigheter för att ta bort en container.

Låneåtgärder hanteras av klassen BlobLeaseClient , som tillhandahåller en klient som innehåller alla låneåtgärder för blobar och containrar. Mer information om containerlån med hjälp av klientbiblioteket finns i Skapa och hantera containerlån med Python.

Skaffa ett lån

När du skaffar ett bloblån får du ett låne-ID som koden kan använda för att fungera på bloben. Om blobben redan har ett aktivt lån kan du bara begära ett nytt lån med hjälp av det aktiva låne-ID:t. Du kan dock ange en ny lånetid.

Om du vill skaffa ett lån skapar du en instans av klassen BlobLeaseClient och använder sedan följande metod:

Du kan också skaffa ett lån på en blob genom att skapa en instans av BlobClient och med hjälp av följande metod:

I följande exempel hämtas ett lån på 30 sekunder för en blob:

def acquire_blob_lease(self, blob_service_client: BlobServiceClient, container_name):
    # Instantiate a BlobClient
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")

    # Acquire a 30-second lease on the blob
    lease_client = blob_client.acquire_lease(30)

    return lease_client

Förnya ett lån

Du kan förnya ett bloblån om låne-ID:t som anges i begäran matchar det låne-ID som är associerat med bloben. Lånet kan förnyas även om det har upphört att gälla, så länge blobben inte har ändrats eller hyrts igen sedan lånet upphör att gälla. När du förnyar ett lån återställs lånets varaktighet.

Använd följande metod för att förnya ett lån:

I följande exempel förnyas ett lån för en blob:

def renew_blob_lease(self, lease_client: BlobLeaseClient):
    # Renew a lease on a blob
    lease_client.renew()

Frigöra ett lån

Du kan frigöra ett bloblån om låne-ID:t som anges i begäran matchar låne-ID:t som är associerat med bloben. Om du släpper ett lån kan en annan klient skaffa ett lån för bloben omedelbart efter att versionen har slutförts.

Du kan frigöra ett lån med hjälp av följande metod:

I följande exempel släpps lånet på en blob:

def release_blob_lease(self, lease_client: BlobLeaseClient):
    # Release a lease on a blob
    lease_client.release()

Bryta ett lån

Du kan bryta ett bloblån om blobben har ett aktivt lån. Alla auktoriserade begäranden kan bryta lånet. begäran krävs inte för att ange ett matchande låne-ID. Ett lån kan inte förnyas efter att det har brutits, och om du bryter ett lån förhindras ett nytt lån från att förvärvas under en tidsperiod tills det ursprungliga lånet upphör att gälla eller frisläpps.

Du kan bryta ett lån med hjälp av följande metod:

I följande exempel bryts lånet för en blob:

def break_blob_lease(self, lease_client: BlobLeaseClient):
    # Break a lease on a blob
    lease_client.break_lease()

Asynkront låna blobar

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

Följ dessa steg för att låna en blob med asynkrona API:er:

  1. Lägg till följande importinstruktioner:

    import asyncio

from azure.identity.aio import DefaultAzureCredential
from azure.storage.blob.aio import BlobServiceClient, BlobLeaseClient

  2. 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 hämtar bloblånet. 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:
        lease_client = await sample.acquire_blob_lease(blob_service_client, "sample-container")

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

  3. Lägg till kod för att hämta ett bloblån. Koden är samma som det synkrona exemplet, förutom att metoden deklareras med nyckelordet async och nyckelordet await används när metoden anropas acquire_lease .

    async def acquire_blob_lease(self, blob_service_client: BlobServiceClient, container_name):
    # Instantiate a BlobClient
    blob_client = blob_service_client.get_blob_client(container=container_name, blob="sample-blob.txt")

    # Acquire a 30-second lease on the blob
    lease_client = await blob_client.acquire_lease(30)

    return lease_client

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.

Lånetillstånd och åtgärder

Följande diagram visar de fem tillstånden för ett lån och de kommandon eller händelser som orsakar ändringar i lånetillståndet.

Ett diagram som visar bloblånetillstånd och utlösare för tillståndsändring.

I följande tabell visas de fem lånetillstånden, en kort beskrivning av var och en och en av de låneåtgärder som tillåts i ett visst tillstånd. Dessa låneåtgärder orsakar tillståndsövergångar, som visas i diagrammet.

Lånetillstånd beskrivning Låneåtgärder tillåts
Tillgängligt Lånet är olåst och kan förvärvas. acquire
Leasade Lånet är låst. acquire (endast samma låne-ID), renew, change, releaseoch break
Upphört Lånetiden har upphört att gälla. acquire, renew, releaseoch break
Brott Lånet har brutits, men lånet fortsätter att vara låst tills brytperioden har upphört att gälla. release och break
Bruten Lånet har brutits och brytperioden har upphört att gälla. acquire, release och break

När ett lån upphör att gälla underhålls låne-ID:t av Blob-tjänsten tills blobben ändras eller leasas igen. En klient kan försöka förnya eller frigöra lånet med det utgångna låne-ID:t. Om den här åtgärden lyckas vet klienten att bloben inte har ändrats sedan låne-ID:t senast var giltigt. Om begäran misslyckas vet klienten att bloben har ändrats eller att blobben hyrdes igen eftersom lånet senast var aktivt. Klienten måste sedan skaffa ett nytt lån för bloben.

Om ett lån upphör att gälla i stället för att uttryckligen frisläppas kan en klient behöva vänta upp till en minut innan ett nytt lån kan hämtas för bloben. Klienten kan dock förnya lånet med sitt låne-ID omedelbart om bloben inte har ändrats.

Det går inte att bevilja ett lån för en blobögonblicksbild eftersom ögonblicksbilder är skrivskyddade. Att begära ett lån mot en ögonblicksbild resulterar i statuskoden 400 (Bad Request).

Resurser

Mer information om hur du hanterar bloblån med hjälp av Azure Blob Storage-klientbiblioteket för Python finns i följande resurser.

Kodexempel

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 hantera bloblån använder följande REST API-åtgärd:

Klientbiblioteksresurser

Se även

Relaterat innehåll

  • Den här artikeln är en del av utvecklarguiden för Blob Storage för Python. Mer information finns i den fullständiga listan över utvecklarguideartiklar i Skapa din Python-app.