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

Blob feltöltése .NET-tel

Ez a cikk bemutatja, hogyan tölthet fel blobot a .NET-hez 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. Megnyithat egy blobstreamet, és írhat hozzá, vagy nagy blobokat tölthet fel blokkokban.

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 projektet a .NET-hez készült Azure Blob Storage ügyfélkódtár használatához. A lépések közé tartozik a csomagtelepítés, az irányelvek hozzáadása using és egy engedélyezett ügyfélobjektum létrehozása. További részletekért tekintse meg az Azure Blob Storage és a .NET használatának első lépéseit.

Csomagok telepítése

A projektkönyvtárból telepítse az Azure Blob Storage- és Az Azure Identity-ügyfélkódtárak csomagjait a dotnet add package paranccsal. Az Azure.Identity-csomagra az Azure-szolgáltatásokhoz való jelszó nélküli kapcsolatokhoz van szükség.

dotnet add package Azure.Storage.Blobs
dotnet add package Azure.Identity

Utasítások hozzáadása using

Adja hozzá ezeket az using irányelveket a kódfájl elejéhez:

using Azure.Identity;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using Azure.Storage.Blobs.Specialized;

A cikkben szereplő néhány példakód további using irányelveket igényelhet.

Ü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:

public BlobServiceClient GetBlobServiceClient(string accountName)
{
    BlobServiceClient client = new(
        new Uri($"https://{accountName}.blob.core.windows.net"),
        new DefaultAzureCredential());

    return client;
}

Regisztrálhat egy klienst függőség-injektáláshoz egy .NET-alkalmazásban.

Ügyfélobjektumokat is létrehozhat adott tárolókhoz vagy blobokhoz. 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.

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.

Adatok feltöltése blokkblobba

Az alábbi módszerek egyikével tölthet fel adatokat blokkblobba:

Amikor ezeket a feltöltési módszereket használja, az ügyfélkönyvtár meghívhatja a Put Blob vagy egy Put Block hívássorozatot, amelyet egy Put Block List követ. 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.

Ha megnyit egy streamet a Blob Storage-ban, és a streambe szeretne írni, használja az alábbi módszerek egyikét:

Feljegyzé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 blokkblobot tölt fel egy helyi fájl elérési útjáról:

public static async Task UploadFromFileAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    await blobClient.UploadAsync(localFilePath, true);
}

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

Az alábbi példa feltölt egy blokkblobot egy Stream-objektum létrehozásával és a stream feltöltésével.

public static async Task UploadFromStreamAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    FileStream fileStream = File.OpenRead(localFilePath);
    await blobClient.UploadAsync(fileStream, true);
    fileStream.Close();
}

Blokkblob feltöltése BinaryData-objektumból

Az alábbi példa feltölt egy blokkblobot egy BinaryData-objektumból .

public static async Task UploadFromBinaryDataAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    FileStream fileStream = File.OpenRead(localFilePath);
    BinaryReader reader = new BinaryReader(fileStream);

    byte[] buffer = new byte[fileStream.Length];
    reader.Read(buffer, 0, buffer.Length);
    BinaryData binaryData = new BinaryData(buffer);

    await blobClient.UploadAsync(binaryData, true);

    fileStream.Close();
}

Blokkblob feltöltése sztringből

Az alábbi példa egy blokkblobot tölt fel egy sztringből:

public static async Task UploadFromStringAsync(
    BlobContainerClient containerClient,
    string blobName)
{
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    string blobContents = "Sample blob data";

    await blobClient.UploadAsync(BinaryData.FromString(blobContents), overwrite: true);
}

Feltöltés streambe a Blob Storage-ban

Megnyithat egy streamet a Blob Storage-ban, és írhat hozzá. Az alábbi példa létrehoz egy zip-fájlt a Blob Storage-ban, és fájlokat ír rá. Ahelyett, hogy zip-fájlt hoz létre a helyi memóriában, egyszerre csak egy fájl van a memóriában.

Figyelmeztetés

Ez a módszer nagyon költséges lehet, ha az objektumreplikációs szabályzat engedélyezve van, mert a streambe való írások létrehoznak egy új zip-fájlt, és minden verziót átmásol a célfiókba. Ugyanez igaz, ha az Azure Blob-tárolós biztonsági mentés engedélyezve van, mert a tárolóalapú biztonsági mentés objektumreplikálást használ.

public static async Task UploadToStreamAsync(
    BlobContainerClient containerClient,
    string localDirectoryPath)
{
    string zipFileName = Path.GetFileName(
        Path.GetDirectoryName(localDirectoryPath)) + ".zip";

    BlockBlobClient blockBlobClient = containerClient.GetBlockBlobClient(zipFileName);

    using (Stream stream = await blockBlobClient.OpenWriteAsync(true))
    {
        using (ZipArchive zip = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: false))
        {
            foreach (var fileName in Directory.EnumerateFiles(localDirectoryPath))
            {
                using (var fileStream = File.OpenRead(fileName))
                {
                    var entry = zip.CreateEntry(
                        Path.GetFileName(fileName), CompressionLevel.Optimal);
                    using (var innerFile = entry.Open())
                    {
                        await fileStream.CopyToAsync(innerFile);
                    }
                }
            }
        }
    }
}

Blokk típusú blob feltöltése konfigurációs lehetőségekkel

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 a BlobUploadOptions használatával egy feltöltési módszer meghívásakor.

Adatátviteli beállítások megadása feltöltéskor

A StorageTransferOptions értékeit konfigurálhatja az adatátviteli műveletek teljesítményének javítása érdekében. Az alábbi példakód bemutatja, hogyan állíthat be értékeket a StorageTransferOptions számára, és hogyan foglalhatja bele a beállításokat egy BlobUploadOptions példány részeként. 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.

public static async Task UploadWithTransferOptionsAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    var transferOptions = new StorageTransferOptions
    {
        // Set the maximum number of parallel transfer workers
        MaximumConcurrency = 2,

        // Set the initial transfer length to 8 MiB
        InitialTransferSize = 8 * 1024 * 1024,

        // Set the maximum length of a transfer to 4 MiB
        MaximumTransferSize = 4 * 1024 * 1024
    };

    var uploadOptions = new BlobUploadOptions()
    {
        TransferOptions = transferOptions
    };

    FileStream fileStream = File.OpenRead(localFilePath);
    await blobClient.UploadAsync(fileStream, uploadOptions);
    fileStream.Close();
}

Az adatátviteli lehetőségek finomhangolásával kapcsolatos további információkért lásd a feltöltések és letöltések teljesítményhangolását a .NET-tel.

Átadás-ellenőrzési beállítások megadása feltöltéskor

Az átviteli érvényesítési lehetőségek megadásával biztosíthatja, hogy az adatok feltöltése megfelelően történjen, és ne legyenek megrongálódtak az átvitel során. Az átviteli érvényesítési beállítások ügyfélszinten definiálhatók a BlobClientOptions használatával, amely érvényesítési beállításokat alkalmaz a BlobClient-példánybólhívott összes metódusra.

A BlobUploadOptions használatával felülbírálhatja az átvitelérvényesítési beállításokat a metódus szintjén is. Az alábbi példakód bemutatja, hogyan hozhat létre objektumot BlobUploadOptions , és hogyan adhat meg algoritmust egy ellenőrzőösszeg létrehozásához. Ezt követően a szolgáltatás az ellenőrzőösszeget használja a feltöltött tartalom adatintegritásának ellenőrzésére.

public static async Task UploadWithChecksumAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlobClient blobClient = containerClient.GetBlobClient(fileName);

    var validationOptions = new UploadTransferValidationOptions
    {
        ChecksumAlgorithm = StorageChecksumAlgorithm.Auto
    };

    var uploadOptions = new BlobUploadOptions()
    {
        TransferValidation = validationOptions
    };

    FileStream fileStream = File.OpenRead(localFilePath);
    await blobClient.UploadAsync(fileStream, uploadOptions);
    fileStream.Close();
}

Az alábbi táblázat a StorageChecksumAlgorithm által meghatározott ellenőrzőösszeg-algoritmus elérhető beállításait mutatja be:

Név Érték Leírás
Autó 0 Ajánlott. Lehetővé teszi, hogy a kódtár algoritmust válasszon. A kódtár különböző verziói különböző algoritmusokat választhatnak.
Egyik sem 1 Nincs kijelölt algoritmus. Ne számítson ki vagy kérjen ellenőrző összegeket.
MD5 2 Standard MD5 kivonatoló algoritmus.
StorageCrc64 3 Egyedi 64 bites CRC az Azure Storage-ban.

Feljegyzés

Ha a kérelemben megadott ellenőrzőösszeg nem felel meg a szolgáltatás által kiszámított ellenőrzőösszegnek, a feltöltési művelet meghiúsul. A művelet nem lesz újrapróbálkozott alapértelmezett újrapróbálkozási szabályzat használatakor. A .NET-ben a rendszer a RequestFailedException 400-ás állapotkóddal és hibakóddal Md5Mismatch vagy Crc64Mismatch– attól függően, hogy melyik algoritmust használja – dobja ki.

Feltöltés indexcímkékkel

A blobindexcímkék kulcs-érték címkeattribútumok használatával kategorizálják a tárfiók adatait. Ezek a címkék automatikusan indexelhetők, és kereshető többdimenziós indexként jelennek meg az adatok egyszerű keresése érdekében. Címkéket adhat hozzá egy BlobUploadOptions-példányhoz , és átadhatja a példányt a UploadAsync metódusnak.

Az alábbi példa egy indexcímkéket tartalmazó blokkblobot tölt fel:

public static async Task UploadBlobWithTagsAsync(
    BlobContainerClient containerClient,
    string blobName)
{
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    string blobContents = "Sample blob data";

    BlobUploadOptions options = new BlobUploadOptions();
    options.Tags = new Dictionary<string, string>
    {
        { "Sealed", "false" },
        { "Content", "image" },
        { "Date", "2020-04-20" }
    };

    await blobClient.UploadAsync(BinaryData.FromString(blobContents), options);
}

A blob hozzáférési szintjének beállítása feltöltés közben

A blobok hozzáférési szintjét a BlobUploadOptions osztály használatával állíthatja be feltöltéskor. Az alábbi példakód bemutatja, hogyan állíthatja be a hozzáférési szintet egy blob feltöltésekor:

public static async Task UploadWithAccessTierAsync(
    BlobContainerClient containerClient,
    string localFilePath)
{
    string fileName = Path.GetFileName(localFilePath);
    BlockBlobClient blockBlobClient = containerClient.GetBlockBlobClient(fileName);

    var uploadOptions = new BlobUploadOptions()
    {
        AccessTier = AccessTier.Cool
    };

    FileStream fileStream = File.OpenRead(localFilePath);
    await blockBlobClient.UploadAsync(fileStream, uploadOptions);
    fileStream.Close();
}

A hozzáférési szint beállítása csak blokkblobok esetén engedélyezett. Beállíthatja a blokkblob hozzáférési szintjét Hot, Cool, Cold vagy Archive állapotba. 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. Ezzel a megközelítéssel növelheti a teljesítményt blokkok párhuzamos feltöltésével.

public static async Task UploadBlocksAsync(
    BlobContainerClient blobContainerClient,
    string localFilePath,
    int blockSize)
{
    string fileName = Path.GetFileName(localFilePath);
    BlockBlobClient blobClient = blobContainerClient.GetBlockBlobClient(fileName);

    FileStream fileStream = File.OpenRead(localFilePath);
    ArrayList blockIDArrayList = new ArrayList();
    byte[] buffer;

    var bytesLeft = (fileStream.Length - fileStream.Position);

    while (bytesLeft > 0)
    {
        if (bytesLeft >= blockSize)
        {
            buffer = new byte[blockSize];
            await fileStream.ReadAsync(buffer, 0, blockSize);
        }
        else
        {
            buffer = new byte[bytesLeft];
            await fileStream.ReadAsync(buffer, 0, Convert.ToInt32(bytesLeft));
            bytesLeft = (fileStream.Length - fileStream.Position);
        }

        using (var stream = new MemoryStream(buffer))
        {
            string blockID = Convert.ToBase64String(
                Encoding.UTF8.GetBytes(Guid.NewGuid().ToString()));

            blockIDArrayList.Add(blockID);
            await blobClient.StageBlockAsync(blockID, stream);
        }
        bytesLeft = (fileStream.Length - fileStream.Position);
    }

    string[] blockIDArray = (string[])blockIDArrayList.ToArray(typeof(string));

    await blobClient.CommitBlockListAsync(blockIDArray);
}

Források

Ha többet szeretne megtudni a blobok .NET-hez 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ódminták

REST API-műveletek

A .NET-hez készült Azure SDK 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 ismerős .NET-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:

Lásd még

Kapcsolódó tartalom

  • Last updated on