Lista blobar med Go

Den här artikeln visar hur man listar blobs genom att använda Azure Storage-klientmodulen för Go.

Prerequisites

• Azure-prenumeration – skapa en kostnadsfritt
• Azure Storage-konto – skapa ett lagringskonto
• Go 1.18+

Konfigurera din miljö

Om du inte har ett befintligt projekt visar det här avsnittet hur du konfigurerar ett projekt så att det fungerar med Azure Blob Storage-klientmodulen för Go. Stegen omfattar modulinstallation, tillägg av import sökvägar och skapande av ett auktoriserat klientobjekt. Mer information finns i Kom igång med Azure Blob Storage och Go.

Installera moduler

Installera azblob-modulen med följande kommando:

go get github.com/Azure/azure-sdk-for-go/sdk/storage/azblob

Om du vill autentisera med Microsoft Entra-ID (rekommenderas) installerar du modulen azidentity med följande kommando:

go get github.com/Azure/azure-sdk-for-go/sdk/azidentity

Lägga till importsökvägar

Lägg till följande importsökvägar i kodfilen:

import (
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)

Dessa importvägar representerar det minsta som krävs för att komma igång. Vissa kodexempel i den här artikeln kan kräva ytterligare importsökvägar. Specifik information och exempelanvändning finns i Kodexempel.

Skapa ett klientobjekt

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

func getServiceClientTokenCredential(accountURL string) *azblob.Client {
    // Create a new service client with token credential
    credential, err := azidentity.NewDefaultAzureCredential(nil)
    handleError(err)

    client, err := azblob.NewClient(accountURL, credential, nil)
    handleError(err)

    return client
}

Auktorisering

Auktoriseringsmekanismen måste ha de behörigheter som krävs för att ladda upp en blob. För auktorisation med Microsoft Entra ID (rekommenderas) behöver du Azure RBAC:s inbyggda roll Storage Blob Data Reader eller högre. Mer information finns i auktoriseringsvägledningen för REST-API (List Blobs).

Om alternativ för bloblistning

När du listar blobar från koden kan du ange många alternativ för att hantera hur resultaten returneras från Azure Storage. Du kan ange hur många resultat som ska returneras i varje resultatuppsättning och sedan hämta efterföljande uppsättningar. Du kan ange ett prefix för att returnera blobar vars namn börjar med det tecknet eller strängen. Du kan lista blobs i en platt liststruktur eller hierarkiskt. En hierarkisk lista returnerar blobar som om de vore ordnade i mappar.

För att lista blobbarna i en behållare med hjälp av en platt listning anropar du följande metod:

• NewListBlobsFlatPager

För att lista blobsen i en container med hjälp av en hierarkisk listning, anropa följande metod från ett containerklientobjekt:

• NewListBlobsHierarchyPager

Hantera hur många resultat som returneras

Som standard returnerar en listningsåtgärd upp till 5 000 resultat åt gången. Om du vill returnera en mindre uppsättning resultat anger du ett icke-nollvärde för MaxResults fältet i ListBlobsFlatOptions eller ListBlobsHierarchyOptions.

Filtrera resultat med ett prefix

Om du vill filtrera listan över blobar som returneras anger du en sträng eller ett tecken för Prefix fältet i ListBlobsFlatOptions eller ListBlobsHierarchyOptions. Prefixsträngen kan innehålla ett eller flera tecken. Azure Storage returnerar sedan endast de blobar vars namn börjar med prefixet.

Inkludera blobmetadata eller annan information

Om du vill inkludera blobmetadata med resultatet anger du fältet Metadata till true som en del av ListBlobsInclude. Azure Storage innehåller metadata för varje blob som returneras, så du behöver inte hämta blobmetadata separat.

Se ListBlobsInclude för ytterligare alternativ för att inkludera ögonblicksbilder, versioner, blobindextaggar och annan information med resultatet.

Flat listning jämfört med hierarkisk lista

Blobar i Azure Storage är ordnade i ett platt paradigm snarare än ett hierarkiskt paradigm (som ett klassiskt filsystem). Du kan dock ordna blobar i virtuella kataloger för att efterlikna en mappstruktur. En virtuell katalog utgör en del av blobens namn och indikeras av avgränsartecknet.

Om du vill organisera blobar i virtuella kataloger använder du ett avgränsartecken i blobnamnet. Standardtecken för avgränsare är ett snedstreck (/), men du kan ange valfritt tecken som avgränsare.

Om du namnger dina blobar med en avgränsare kan du välja att lista blobar hierarkiskt. För en hierarkisk listningsåtgärd returnerar Azure Storage alla virtuella kataloger och blobbar under det överordnade objektet. Du kan anropa listningsåtgärden rekursivt för att korsa hierarkin, ungefär som du skulle gå igenom ett klassiskt filsystem programmatiskt.

Använd en platt lista

Som standard returnerar en liståtgärd blobar i en platt lista. I en platt lista är blobbar inte organiserade i en virtuell katalog.

I följande exempel visas blobarna i den angivna containern med en platt lista. Det här exemplet inkluderar blob-snapshots och blob-versioner, om de finns:

func listBlobsFlat(client *azblob.Client, containerName string) {
    // List the blobs in the container
    pager := client.NewListBlobsFlatPager(containerName, &azblob.ListBlobsFlatOptions{
        Include: azblob.ListBlobsInclude{Snapshots: true, Versions: true},
    })

    fmt.Println("List blobs flat:")
    for pager.More() {
        resp, err := pager.NextPage(context.TODO())
        handleError(err)

        for _, blob := range resp.Segment.BlobItems {
            fmt.Println(*blob.Name)
        }
    }
}

Exempelutdata liknar:

List blobs flat:
file4.txt
folderA/file1.txt
folderA/file2.txt
folderA/folderB/file3.txt

I följande exempel visas blobar i en container som börjar med ett specifikt prefix:

func listBlobsFlatOptions(client *azblob.Client, containerName string, prefix string) {
    // List the blobs in the container with a prefix
    pager := client.NewListBlobsFlatPager(containerName, &azblob.ListBlobsFlatOptions{
        Prefix: to.Ptr(prefix),
    })

    fmt.Println("List blobs with prefix:")
    for pager.More() {
        resp, err := pager.NextPage(context.TODO())
        handleError(err)

        for _, blob := range resp.Segment.BlobItems {
            fmt.Println(*blob.Name)
        }
    }
}

När du skickar en prefixsträng i "sample" är utgången liknande:

List blobs with prefix:
sample-blob1.txt
sample-blob2.txt
sample-blob3.txt

Använda en hierarkisk lista

När du anropar en liståtgärd hierarkiskt returnerar Azure Storage de virtuella katalogerna och blobarna på den första nivån i hierarkin.

Om du vill lista blobar hierarkiskt använder du följande metod:

• NewListBlobsHierarchyPager

I följande exempel visas blobarna i den angivna containern med hjälp av en hierarkisk lista. I det här exemplet är prefixparametern ursprungligen inställd på en tom sträng för att visa en lista över alla blobar i containern. Exemplet anropar sedan listningsåtgärden rekursivt för att passera den virtuella kataloghierarkin och listblobbarna.

func listBlobsHierarchy(client *azblob.Client, containerName string, prefix string) {
    // Reference the container as a client object
    containerClient := client.ServiceClient().NewContainerClient(containerName)

    pager := containerClient.NewListBlobsHierarchyPager("/", &container.ListBlobsHierarchyOptions{
        Prefix:     to.Ptr(prefix),
        MaxResults: to.Ptr(int32(1)), // MaxResults set to 1 for demonstration purposes
    })

    for pager.More() {
        resp, err := pager.NextPage(context.TODO())
        handleError(err)

        if resp.Segment.BlobPrefixes != nil {
            for _, prefix := range resp.Segment.BlobPrefixes {
                fmt.Println("Virtual directory prefix:", *prefix.Name)

                // Recursively list blobs in the prefix
                listBlobsHierarchy(client, containerName, *prefix.Name)
            }
        }

        for _, blob := range resp.Segment.BlobItems {
            fmt.Println("Blob:", *blob.Name)
        }
    }
}

Exempelutdata liknar:

Virtual directory prefix: folderA/
Blob: folderA/file1.txt
Blob: folderA/file2.txt
Blob: folderA/file3.txt
Virtual directory prefix: folderA/folderB/
Blob: folderA/folderB/file1.txt
Blob: folderA/folderB/file2.txt
Blob: folderA/folderB/file3.txt

Listablobbar i Apache Arrow-format (förhandsvisning)

Denna funktion bygger på det befintliga List Blobs API:et. Istället för att använda standard-XML använder den det kompakta, kolumnarformade Apache Arrow-formatet som svarsformat på tråden. Du aktiverar det genom att ställa in ett enda alternativ i containerlisting-anropet. Go SDK avkodar Apache Arrow bakom kulisserna och returnerar fortfarande samma BlobItem värden. Denna metod förbättrar listningskapaciteten och minskar klientsidans CPU vid uppräkning av stora containrar. Det bevarar det responsavtal som applikationer är beroende av.

För att begära Apache Arrow-formaterade resultat, ställ ResponseFormat fältet ListBlobsFlatOptions till StorageResponseFormatArrow och skicka sedan alternativen till NewListBlobsFlatPager. När du använder utdata i Apache Arrow-format kan du också ställa in StartFrom- och EndBefore-fälten för att styra intervallet för sökvägar som returneras.

Följande exempel listar blobsen i en container och begär resultaten i Apache Arrow-format:

import (
    "context"

    "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
    "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
    "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/container"
)

pager := client.NewListBlobsFlatPager("sample-container", &azblob.ListBlobsFlatOptions{
    Prefix:         to.Ptr("folderA/"),
    ResponseFormat: container.StorageResponseFormatArrow,
})

for pager.More() {
    resp, err := pager.NextPage(context.TODO())
    handleError(err)

    for _, blob := range resp.Segment.BlobItems {
        fmt.Println(*blob.Name)
    }
}

Resurser

Mer information om hur du listar blobar med hjälp av Azure Blob Storage-klientmodulen för Go finns i följande resurser.

Kodexempel

• Visa kodexempel från den här artikeln (GitHub)

REST API-åtgärder

Azure SDKs för Go innehåller bibliotek som bygger ovanpå Azure REST API. Genom att använda dessa bibliotek kan du interagera med REST API-operationer via välbekanta Go-paradigm. Klientbiblioteksmetoderna för att visa blobar använder följande REST API-åtgärd:

• Lista blobs (REST API)

Klientmodulresurser

• Referensdokumentation för klientmoduler
• Källkod för klientmodul
• Paket (pkg.go.dev)

Se även

• Räkna upp blobresurser
• Versionshantering för Blob

Relaterat innehåll

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