Adatok átvitele az adatátviteli kódtárral

Feljegyzés

Ez a cikk útmutatást tartalmaz az Azure Storage Adatáthelyezési kódtár 2.0.XX-s verziójának használatához. A 2.0.XX-es verzió jelenleg karbantartási módban van, és a kódtár csak az adatintegritással és biztonsági problémákkal kapcsolatos javításokat kapja. A tár nem ad hozzá új funkciókat vagy szolgáltatásokat, és a tár nem támogatja az új tárolási szolgáltatási verziókat.

A modern adatáthelyezési kódtár bétaverziói jelenleg fejlesztés alatt állnak. További információ: Azure Storage Data Movement Common client library for .NET on GitHub.

Az Azure Storage adatáthelyezési kódtár egy platformfüggetlen nyílt forráskód kódtár, amely a blobok és fájlok nagy teljesítményű feltöltésére, letöltésére és másolására szolgál. Az adatáthelyezési kódtár olyan kényelmes módszereket biztosít, amelyek nem érhetők el a .NET-hez készült Azure Storage-ügyfélkódtárban. Ezek a módszerek lehetővé teszik a párhuzamos műveletek számának beállítását, az átvitel előrehaladásának nyomon követését, a megszakított átvitel egyszerű folytatását és még sok mást.

Ez a kódtár a .NET Core-t is használja, ami azt jelenti, hogy a .NET-alkalmazások Windowshoz, Linuxhoz és macOS-hez való létrehozásakor is használható. A .NET Core-ról a .NET Core dokumentációjában olvashat bővebben. Ez a kódtár a windowsos hagyományos .NET-keretrendszer-alkalmazásokhoz is használható.

Ez a dokumentum bemutatja, hogyan hozhat létre windowsos, linuxos és macOS rendszerű .NET Core-konzolalkalmazásokat, és hogyan hajthatja végre a következő forgatókönyveket:

• Fájlok és könyvtárak feltöltése a Blob Storage-ba.
• Adja meg a párhuzamos műveletek számát az adatok átvitele során.
• Az adatátvitel előrehaladásának nyomon követése.
• Folytassa a megszakított adatátvitelt.
• Fájl másolása URL-címről Blob Storage-ba.
• Másolás a Blob Storage-ból a Blob Storage-ba.

Előfeltételek

• Visual Studio Code
• Egy Azure-tárfiók

Beállítás

1. A .NET Core SDK telepítéséhez tekintse meg a .NET Core telepítési útmutatóját. A környezet kiválasztásakor válassza a parancssori lehetőséget.
2. A parancssorból hozzon létre egy könyvtárat a projekthez. Lépjen ebbe a könyvtárba, majd írjon be dotnet new console -o <sample-project-name> egy C#-konzolprojektet.
3. Nyissa meg ezt a könyvtárat a Visual Studio Code-ban. Ez a lépés gyorsan elvégezhető a parancssoron keresztül a Windows beírásával code . .
4. Telepítse a C# bővítményt a Visual Studio Code Marketplace-ről. Indítsa újra a Visual Studio Code-ot.
5. Ezen a ponton két üzenetnek kell megjelennie. Az egyik a "létrehozáshoz és hibakereséshez szükséges eszközök" hozzáadása. Válassza az "igen" lehetőséget. Egy másik kérés a megoldatlan függőségek visszaállítása. Válassza a "visszaállítás" lehetőséget.
6. A módosítás launch.json alatt .vscode külső terminált használhat konzolként. Ennek a beállításnak a következőnek kell lennie: "console": "externalTerminal"
7. A Visual Studio Code lehetővé teszi a .NET Core-alkalmazások hibakeresését. Az alkalmazás futtatásához és annak ellenőrzéséhez, F5 hogy a beállítás működik-e. A konzolra nyomtatott "„Helló világ!” alkalmazás!" feliratnak kell megjelennie.

Az adatáthelyezési kódtár hozzáadása a projekthez

1. Adja hozzá az Adatáthelyezési kódtár legújabb verzióját a dependencies fájl szakaszához <project-name>.csproj . Az íráskor ez a verzió "Microsoft.Azure.Storage.DataMovement": "0.6.2"
2. Ekkor megjelenik egy üzenet a projekt visszaállításához. Válassza a "visszaállítás" gombot. A projektet a parancssorból is visszaállíthatja, ha beírja a parancsot dotnet restore a projektkönyvtár gyökerében.

Módosítás <project-name>.csproj:

<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>netcoreapp2.0</TargetFramework>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Microsoft.Azure.Storage.DataMovement" Version="0.6.2" />
        </ItemGroup>
    </Project>

Az alkalmazás-keretrendszer beállítása

Első lépésként be kell állítani az alkalmazás kódkeretét. Ez a kód egy tárfiók nevét és fiókkulcsát kéri, és a hitelesítő adatok használatával hoz létre egy objektumot CloudStorageAccount . Ez az objektum a tárfiókunkkal való interakcióra szolgál minden átviteli forgatókönyvben. A kód arra is kéri, hogy válasszuk ki a végrehajtani kívánt átviteli műveletet.

Módosítás Program.cs:

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Diagnostics;
using Microsoft.Azure.Storage;
using Microsoft.Azure.Storage.Blob;
using Microsoft.Azure.Storage.DataMovement;

namespace DMLibSample
{
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("Enter Storage account name:");
            string accountName = Console.ReadLine();

            Console.WriteLine("\nEnter Storage account key:");
            string accountKey = Console.ReadLine();

            string storageConnectionString = "DefaultEndpointsProtocol=https;AccountName=" + accountName + ";AccountKey=" + accountKey;
            CloudStorageAccount account = CloudStorageAccount.Parse(storageConnectionString);

            ExecuteChoice(account);
        }

        public static void ExecuteChoice(CloudStorageAccount account)
        {
            Console.WriteLine("\nWhat type of transfer would you like to execute?\n1. Local file --> Azure Blob\n2. Local directory --> Azure Blob directory\n3. URL (e.g. Amazon S3 file) --> Azure Blob\n4. Azure Blob --> Azure Blob");
            int choice = int.Parse(Console.ReadLine());

            if(choice == 1)
            {
                TransferLocalFileToAzureBlob(account).Wait();
            }
            else if(choice == 2)
            {
                TransferLocalDirectoryToAzureBlobDirectory(account).Wait();
            }
            else if(choice == 3)
            {
                TransferUrlToAzureBlob(account).Wait();
            }
            else if(choice == 4)
            {
                TransferAzureBlobToAzureBlob(account).Wait();
            }
        }

        public static async Task TransferLocalFileToAzureBlob(CloudStorageAccount account)
        {

        }

        public static async Task TransferLocalDirectoryToAzureBlobDirectory(CloudStorageAccount account)
        {

        }

        public static async Task TransferUrlToAzureBlob(CloudStorageAccount account)
        {

        }

        public static async Task TransferAzureBlobToAzureBlob(CloudStorageAccount account)
        {

        }
    }
}

Fontos

Ez a példakód egy kapcsolati sztring használ a tárfiókhoz való hozzáférés engedélyezéséhez. Ez a konfiguráció példaként szolgál. Az alkalmazáskódban körültekintően kell használni a kapcsolati sztringeket és a fiókelérési kulcsokat. Ha a fiók hozzáférési kulcsa elveszett vagy véletlenül nem biztonságos helyre került, a szolgáltatás sebezhetővé válhat. Bárki, aki rendelkezik a hozzáférési kulccsal, engedélyezheti a tárfiókra irányuló kérelmeket, és hatékonyan hozzáférhet az összes adathoz.

Helyi fájl feltöltése blobba

Adja hozzá a metódusokat GetSourcePath és GetBlob a következőhöz Program.cs:

public static string GetSourcePath()
{
    Console.WriteLine("\nProvide path for source:");
    string sourcePath = Console.ReadLine();

    return sourcePath;
}

public static CloudBlockBlob GetBlob(CloudStorageAccount account)
{
    CloudBlobClient blobClient = account.CreateCloudBlobClient();

    Console.WriteLine("\nProvide name of Blob container:");
    string containerName = Console.ReadLine();
    CloudBlobContainer container = blobClient.GetContainerReference(containerName);
    container.CreateIfNotExistsAsync().Wait();

    Console.WriteLine("\nProvide name of new Blob:");
    string blobName = Console.ReadLine();
    CloudBlockBlob blob = container.GetBlockBlobReference(blobName);

    return blob;
}

Módosítsa a metódust TransferLocalFileToAzureBlob :

public static async Task TransferLocalFileToAzureBlob(CloudStorageAccount account)
{
    string localFilePath = GetSourcePath();
    CloudBlockBlob blob = GetBlob(account);
    Console.WriteLine("\nTransfer started...");
    await TransferManager.UploadAsync(localFilePath, blob);
    Console.WriteLine("\nTransfer operation complete.");
    ExecuteChoice(account);
}

Ez a kód egy helyi fájl elérési útját, egy új vagy meglévő tároló nevét és egy új blob nevét kéri. A TransferManager.UploadAsync metódus ezzel az információval végzi el a feltöltést.

Nyomja le F5 az alkalmazás futtatásához. A feltöltés megtörténtének ellenőrzéséhez tekintse meg a Tárfiókot a Microsoft Azure Storage Explorerben.

Párhuzamos műveletek számának beállítása

Az adatátviteli kódtár lehetővé teszi a párhuzamos műveletek számának beállítását az adatátvitel átviteli sebességének növelése érdekében. Alapértelmezés szerint az Adatáthelyezési kódtár a párhuzamos műveletek számát 8 * értékre állítja a gépen lévő magok számával.

Ne feledje, hogy az alacsony sávszélességű környezetben számos párhuzamos művelet túlterhelheti a hálózati kapcsolatot, és ténylegesen megakadályozhatja a műveletek teljes befejezését. Kísérletezzen ezzel a beállítással annak meghatározásához, hogy mi működik a legjobban az elérhető hálózati sávszélesség alapján.

Ebben a példában olyan kódot adunk hozzá, amely lehetővé teszi a párhuzamos műveletek számának beállítását. Olyan kódot is hozzáadunk, amely az átvitel befejezésének időtartamához szükséges.

SetNumberOfParallelOperations Metódus hozzáadása a következőhözProgram.cs:

public static void SetNumberOfParallelOperations()
{
    Console.WriteLine("\nHow many parallel operations would you like to use?");
    string parallelOperations = Console.ReadLine();
    TransferManager.Configurations.ParallelOperations = int.Parse(parallelOperations);
}

Módosítsa a ExecuteChoice használni SetNumberOfParallelOperationskívánt metódust:

public static void ExecuteChoice(CloudStorageAccount account)
{
    Console.WriteLine("\nWhat type of transfer would you like to execute?\n1. Local file --> Azure Blob\n2. Local directory --> Azure Blob directory\n3. URL (e.g. Amazon S3 file) --> Azure Blob\n4. Azure Blob --> Azure Blob");
    int choice = int.Parse(Console.ReadLine());

    SetNumberOfParallelOperations();

    if(choice == 1)
    {
        TransferLocalFileToAzureBlob(account).Wait();
    }
    else if(choice == 2)
    {
        TransferLocalDirectoryToAzureBlobDirectory(account).Wait();
    }
    else if(choice == 3)
    {
        TransferUrlToAzureBlob(account).Wait();
    }
    else if(choice == 4)
    {
        TransferAzureBlobToAzureBlob(account).Wait();
    }
}

Módosítsa a metódust TransferLocalFileToAzureBlob időzítő használatára:

public static async Task TransferLocalFileToAzureBlob(CloudStorageAccount account)
{
    string localFilePath = GetSourcePath();
    CloudBlockBlob blob = GetBlob(account);
    Console.WriteLine("\nTransfer started...");
    Stopwatch stopWatch = Stopwatch.StartNew();
    await TransferManager.UploadAsync(localFilePath, blob);
    stopWatch.Stop();
    Console.WriteLine("\nTransfer operation completed in " + stopWatch.Elapsed.TotalSeconds + " seconds.");
    ExecuteChoice(account);
}

Az átvitel előrehaladásának nyomon követése

Egy objektum létrehozásával TransferContext nyomon követheti az átvitel előrehaladását az átviteli művelet során. Az TransferContext objektum két formában érhető el: SingleTransferContext egyetlen fájlátvitelhez és DirectoryTransferContext címtárátvitelhez.

Adja hozzá a metódusokat GetSingleTransferContext és GetDirectoryTransferContext a következőhöz Program.cs:

public static SingleTransferContext GetSingleTransferContext(TransferCheckpoint checkpoint)
{
    SingleTransferContext context = new SingleTransferContext(checkpoint);

    context.ProgressHandler = new Progress<TransferStatus>((progress) =>
    {
        Console.Write("\rBytes transferred: {0}", progress.BytesTransferred );
    });

    return context;
}

public static DirectoryTransferContext GetDirectoryTransferContext(TransferCheckpoint checkpoint)
{
    DirectoryTransferContext context = new DirectoryTransferContext(checkpoint);

    context.ProgressHandler = new Progress<TransferStatus>((progress) =>
    {
        Console.Write("\rBytes transferred: {0}", progress.BytesTransferred );
    });

    return context;
}

Módosítsa a TransferLocalFileToAzureBlob használni GetSingleTransferContextkívánt metódust:

public static async Task TransferLocalFileToAzureBlob(CloudStorageAccount account)
{
    string localFilePath = GetSourcePath();
    CloudBlockBlob blob = GetBlob(account);
    TransferCheckpoint checkpoint = null;
    SingleTransferContext context = GetSingleTransferContext(checkpoint);
    Console.WriteLine("\nTransfer started...\n");
    Stopwatch stopWatch = Stopwatch.StartNew();
    await TransferManager.UploadAsync(localFilePath, blob, null, context);
    stopWatch.Stop();
    Console.WriteLine("\nTransfer operation completed in " + stopWatch.Elapsed.TotalSeconds + " seconds.");
    ExecuteChoice(account);
}

Megszakított átvitel folytatása

Az adatáthelyezési kódtár egy másik funkciója a megszakított átvitel folytatása. Ezután hozzáadunk néhány kódot, amely lehetővé teszi, hogy ideiglenesen megszakítsuk az átvitelt gépeléssel c, majd 3 másodperccel később folytathatjuk az átvitelt.

Módosítsa a metódust TransferLocalFileToAzureBlob:

public static async Task TransferLocalFileToAzureBlob(CloudStorageAccount account)
{
    string localFilePath = GetSourcePath();
    CloudBlockBlob blob = GetBlob(account);
    TransferCheckpoint checkpoint = null;
    SingleTransferContext context = GetSingleTransferContext(checkpoint);
    CancellationTokenSource cancellationSource = new CancellationTokenSource();
    Console.WriteLine("\nTransfer started...\nPress 'c' to temporarily cancel your transfer...\n");

    Stopwatch stopWatch = Stopwatch.StartNew();
    Task task;
    ConsoleKeyInfo keyinfo;
    try
    {
        task = TransferManager.UploadAsync(localFilePath, blob, null, context, cancellationSource.Token);
        while(!task.IsCompleted)
        {
            if(Console.KeyAvailable)
            {
                keyinfo = Console.ReadKey(true);
                if(keyinfo.Key == ConsoleKey.C)
                {
                    cancellationSource.Cancel();
                }
            }
        }
        await task;
    }
    catch(Exception e)
    {
        Console.WriteLine("\nThe transfer is canceled: {0}", e.Message);
    }

    if(cancellationSource.IsCancellationRequested)
    {
        Console.WriteLine("\nTransfer will resume in 3 seconds...");
        Thread.Sleep(3000);
        checkpoint = context.LastCheckpoint;
        context = GetSingleTransferContext(checkpoint);
        Console.WriteLine("\nResuming transfer...\n");
        await TransferManager.UploadAsync(localFilePath, blob, null, context);
    }

    stopWatch.Stop();
    Console.WriteLine("\nTransfer operation completed in " + stopWatch.Elapsed.TotalSeconds + " seconds.");
    ExecuteChoice(account);
}

Eddig az értékünk checkpoint a következőre nullvan állítva: . Most, ha megszakítjuk az átvitelt, lekérjük az átvitel utolsó ellenőrzőpontját, majd ezt az új ellenőrzőpontot használjuk az átvitel kontextusában.

Helyi könyvtár áthelyezése a Blob Storage-ba

Az Adatáthelyezési kódtár lehetővé teszi egy fájlkönyvtár és annak összes alkönyvtárának átvitelét az alábbi példában látható módon.

Először adja hozzá a metódust GetBlobDirectory a következőhöz Program.cs:

public static CloudBlobDirectory GetBlobDirectory(CloudStorageAccount account)
{
    CloudBlobClient blobClient = account.CreateCloudBlobClient();

    Console.WriteLine("\nProvide name of Blob container. This can be a new or existing Blob container:");
    string containerName = Console.ReadLine();
    CloudBlobContainer container = blobClient.GetContainerReference(containerName);
    container.CreateIfNotExistsAsync().Wait();

    CloudBlobDirectory blobDirectory = container.GetDirectoryReference("");

    return blobDirectory;
}

Ezután módosítsa TransferLocalDirectoryToAzureBlobDirectorya következőt:

public static async Task TransferLocalDirectoryToAzureBlobDirectory(CloudStorageAccount account)
{
    string localDirectoryPath = GetSourcePath();
    CloudBlobDirectory blobDirectory = GetBlobDirectory(account);
    TransferCheckpoint checkpoint = null;
    DirectoryTransferContext context = GetDirectoryTransferContext(checkpoint);
    CancellationTokenSource cancellationSource = new CancellationTokenSource();
    Console.WriteLine("\nTransfer started...\nPress 'c' to temporarily cancel your transfer...\n");

    Stopwatch stopWatch = Stopwatch.StartNew();
    Task task;
    ConsoleKeyInfo keyinfo;
    UploadDirectoryOptions options = new UploadDirectoryOptions()
    {
        Recursive = true
    };

    try
    {
        task = TransferManager.UploadDirectoryAsync(localDirectoryPath, blobDirectory, options, context, cancellationSource.Token);
        while(!task.IsCompleted)
        {
            if(Console.KeyAvailable)
            {
                keyinfo = Console.ReadKey(true);
                if(keyinfo.Key == ConsoleKey.C)
                {
                    cancellationSource.Cancel();
                }
            }
        }
        await task;
    }
    catch(Exception e)
    {
        Console.WriteLine("\nThe transfer is canceled: {0}", e.Message);
    }

    if(cancellationSource.IsCancellationRequested)
    {
        Console.WriteLine("\nTransfer will resume in 3 seconds...");
        Thread.Sleep(3000);
        checkpoint = context.LastCheckpoint;
        context = GetDirectoryTransferContext(checkpoint);
        Console.WriteLine("\nResuming transfer...\n");
        await TransferManager.UploadDirectoryAsync(localDirectoryPath, blobDirectory, options, context);
    }

    stopWatch.Stop();
    Console.WriteLine("\nTransfer operation completed in " + stopWatch.Elapsed.TotalSeconds + " seconds.");
    ExecuteChoice(account);
}

Ez a módszer és az egyetlen fájl feltöltésének módja között van néhány különbség. Most már használjuk TransferManager.UploadDirectoryAsync és a getDirectoryTransferContext korábban létrehozott metódust. Emellett most megadunk egy options értéket a feltöltési műveletnek, amely lehetővé teszi számunkra, hogy jelezzük, hogy alkönyvtárakat szeretnénk belefoglalni a feltöltésbe.

Fájl másolása URL-címről blobba

Most adjunk hozzá egy kódot, amely lehetővé teszi egy fájl másolását egy URL-címről egy Azure Blobba.

Módosítás TransferUrlToAzureBlob:

public static async Task TransferUrlToAzureBlob(CloudStorageAccount account)
{
    Uri uri = new Uri(GetSourcePath());
    CloudBlockBlob blob = GetBlob(account);
    TransferCheckpoint checkpoint = null;
    SingleTransferContext context = GetSingleTransferContext(checkpoint);
    CancellationTokenSource cancellationSource = new CancellationTokenSource();
    Console.WriteLine("\nTransfer started...\nPress 'c' to temporarily cancel your transfer...\n");

    Stopwatch stopWatch = Stopwatch.StartNew();
    Task task;
    ConsoleKeyInfo keyinfo;
    try
    {
        task = TransferManager.CopyAsync(uri, blob, CopyMethod.ServiceSideAsyncCopy, null, context, cancellationSource.Token);
        while(!task.IsCompleted)
        {
            if(Console.KeyAvailable)
            {
                keyinfo = Console.ReadKey(true);
                if(keyinfo.Key == ConsoleKey.C)
                {
                    cancellationSource.Cancel();
                }
            }
        }
        await task;
    }
    catch(Exception e)
    {
        Console.WriteLine("\nThe transfer is canceled: {0}", e.Message);
    }

    if(cancellationSource.IsCancellationRequested)
    {
        Console.WriteLine("\nTransfer will resume in 3 seconds...");
        Thread.Sleep(3000);
        checkpoint = context.LastCheckpoint;
        context = GetSingleTransferContext(checkpoint);
        Console.WriteLine("\nResuming transfer...\n");
        await TransferManager.CopyAsync(uri, blob, CopyMethod.ServiceSideAsyncCopy, null, context, cancellationSource.Token);
    }

    stopWatch.Stop();
    Console.WriteLine("\nTransfer operation completed in " + stopWatch.Elapsed.TotalSeconds + " seconds.");
    ExecuteChoice(account);
}

A funkció egyik fontos felhasználási esete, ha adatokat kell áthelyeznie egy másik felhőszolgáltatásból az Azure-ba. Ha rendelkezik olyan URL-címvel, amely hozzáférést biztosít az erőforráshoz, a metódus használatával egyszerűen áthelyezheti az erőforrást az TransferManager.CopyAsync Azure Blobokba. Ez a metódus egy CopyMethod paramétert is bevezet. Az alábbi táblázat a paraméter elérhető beállításait mutatja be:

Tag neve	Érték	Leírás
SyncCopy	0	Töltse le az adatokat forrásról memóriára, és töltse fel az adatokat a memóriából a célhelyre. Jelenleg csak az egyik Azure Storage-erőforrásból a másikba történő másoláshoz érhető el.
ServiceSideAsyncCopy	0	Küldjön egy másolásindítási kérést az Azure Storage-nak, hogy elvégezhesse a másolást; a másolási művelet előrehaladásának figyelése a másolás befejezéséig.
ServiceSideSyncCopy	2	Másolja az egyes adattömbek tartalmát a Put Block From URL, a Append Block From URL vagy a Put Page From URL címmel.

Blob másolása

Az adatáthelyezési kódtár egy másik funkciója, hogy az egyik Azure Storage-erőforrásból a másikba másolhat.

Módosítsa a metódust TransferAzureBlobToAzureBlob:

public static async Task TransferAzureBlobToAzureBlob(CloudStorageAccount account)
{
    CloudBlockBlob sourceBlob = GetBlob(account);
    CloudBlockBlob destinationBlob = GetBlob(account);
    TransferCheckpoint checkpoint = null;
    SingleTransferContext context = GetSingleTransferContext(checkpoint);
    CancellationTokenSource cancellationSource = new CancellationTokenSource();
    Console.WriteLine("\nTransfer started...\nPress 'c' to temporarily cancel your transfer...\n");

    Stopwatch stopWatch = Stopwatch.StartNew();
    Task task;
    ConsoleKeyInfo keyinfo;
    try
    {
        task = TransferManager.CopyAsync(sourceBlob, destinationBlob, CopyMethod.SyncCopy, null, context, cancellationSource.Token);
        while(!task.IsCompleted)
        {
            if(Console.KeyAvailable)
            {
                keyinfo = Console.ReadKey(true);
                if(keyinfo.Key == ConsoleKey.C)
                {
                    cancellationSource.Cancel();
                }
            }
        }
        await task;
    }
    catch(Exception e)
    {
        Console.WriteLine("\nThe transfer is canceled: {0}", e.Message);
    }

    if(cancellationSource.IsCancellationRequested)
    {
        Console.WriteLine("\nTransfer will resume in 3 seconds...");
        Thread.Sleep(3000);
        checkpoint = context.LastCheckpoint;
        context = GetSingleTransferContext(checkpoint);
        Console.WriteLine("\nResuming transfer...\n");
        await TransferManager.CopyAsync(sourceBlob, destinationBlob, CopyMethod.SyncCopy, null, context, cancellationSource.Token);
    }

    stopWatch.Stop();
    Console.WriteLine("\nTransfer operation completed in " + stopWatch.Elapsed.TotalSeconds + " seconds.");
    ExecuteChoice(account);
}

Ebben a példában a logikai paramétert úgy állítjuk be TransferManager.CopyAsync CopyMethod.SyncCopy , hogy jelezzük, hogy szinkron másolatot szeretnénk készíteni. Ez a konfiguráció azt jelenti, hogy az erőforrás először letöltődik a helyi gépre, majd feltöltődik az Azure Blobba. A szinkron másolási lehetőség nagyszerű módja annak, hogy a másolási művelet konzisztens sebességet biztosítson. Ezzel szemben az aszinkron kiszolgálóoldali másolat sebessége a kiszolgálón elérhető hálózati sávszélességtől függ, ami ingadozhat. A szinkron másolás azonban további kimenő költséget eredményezhet az aszinkron másolathoz képest. Az ajánlott módszer a szinkron másolat használata egy olyan Azure-beli virtuális gépen, amely ugyanabban a régióban található, mint a forrás tárfiókja, így elkerülhető a kimenő forgalom költsége.

Az adatáthelyezési alkalmazás elkészült. A teljes kódminta elérhető a GitHubon.

Következő lépések

Az Azure Storage adatáthelyezési kódtár referenciadokumentációja.

Tipp.

Azure Blob Storage-erőforrások kezelése az Azure Storage Explorerrel. Az Azure Storage Explorer a Microsoft ingyenes, önálló alkalmazása, amely lehetővé teszi az Azure Blob Storage-erőforrások kezelését. Az Azure Storage Explorer használatával vizuálisan hozhat létre, olvashat, frissíthet és törölhet blobtárolókat és blobokat, valamint kezelheti a blobtárolókhoz és blobokhoz való hozzáférést.