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

  • Cikk

Megjegyzé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

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. Kattintson az "igen" gombra. Egy másik kérés a megoldatlan függőségek visszaállítása. Kattintson a "visszaállítás" gombra.
  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. Kattintson a "visszaállítás" gombra. 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 csontvázának beállítása

Az első dolog, amit teszünk, hogy beállítjuk az alkalmazás "csontváz" kódjá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 Storage-fiók minden átviteli forgatókönyvben való kezelésére szolgál. 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)
        {

        }
    }
}

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áthelyezési kódtár egyik funkciója a párhuzamos műveletek számának beállítása 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érleteznie kell ezzel a beállítással, hogy meghatározza, mi működik a legjobban a rendelkezésre álló hálózati sávszélesség alapján.

Adjunk hozzá néhány kódot, amely lehetővé teszi a párhuzamos műveletek számának beállítását. Adjunk hozzá olyan kódot is, amely mennyi ideig tart az átvitel befejezéséhez.

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

Annak ismerete, hogy mennyi ideig tartott az adatok átvitele, hasznos. Az átadás előrehaladását azonban még jobb lenne látni az átadási művelet során . A forgatókönyv eléréséhez létre kell hoznunk egy objektumot TransferContext . Az TransferContext objektum két formában jelenik meg: SingleTransferContext és DirectoryTransferContext. Az előbbi egyetlen fájl átvitelére, az utóbbi pedig egy fájlkönyvtár átadására használható.

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 kényelmes funkciója a megszakított átvitel folytatásának lehetősége. Adjunk hozzá 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 folytassuk az átvitelt.

Módosítás 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 mindig a következőre nullvolt beá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

Kiábrándító lenne, ha az adatáthelyezési kódtár egyszerre csak egy fájlt tudna átvinni. Szerencsére ez nem így van. Az Adatáthelyezési kódtár lehetővé teszi egy fájlkönyvtár és annak összes alkönyvtárának átvitelét. Adjunk hozzá néhány kódot, amely lehetővé teszi számunkra, hogy csak ezt.

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 (például AWS) az Azure-ba. Ha rendelkezik olyan URL-címvel, amely hozzáférést biztosít az erőforráshoz, egyszerűen áthelyezheti az erőforrást az Azure Blobokba a TransferManager.CopyAsync metódus használatával. 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 Value Description
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 1 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 által egyedileg biztosított másik funkció az egyik Azure Storage-erőforrásból a másikba történő másolás lehetősége.

Módosítás 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.CopyAsyncCopyMethod.SyncCopy , hogy jelezzük, hogy szinkron másolatot szeretnénk készíteni. Ez 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.