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


Rövid útmutató: Adat-előállító és folyamat létrehozása .NET SDK használatával

A következőkre vonatkozik: Azure Data Factory Azure Synapse Analytics

Tipp.

Próbálja ki a Data Factoryt a Microsoft Fabricben, amely egy teljes körű elemzési megoldás a nagyvállalatok számára. A Microsoft Fabric az adattovábbítástól az adatelemzésig, a valós idejű elemzésig, az üzleti intelligenciáig és a jelentéskészítésig mindent lefed. Ismerje meg, hogyan indíthat új próbaverziót ingyenesen!

Ez a rövid útmutató bemutatja, hogyan hozhat létre Azure Data Factoryt a .NET SDK használatával. Az adat-előállítóban létrehozott folyamat adatokat másol egy Azure-blobtároló egyik mappájából egy másikba. Az adatok Azure Data Factoryval történő átalakításának útmutatásáért olvassa el az az adatok Spark segítségével történő átalakítását ismertető oktatóanyagot.

Feljegyzés

Ez a cikk nem mutatja be részletesen a Data Factory szolgáltatást. Ha szeretné megismerni az Azure Data Factoryt, tekintse meg Az Azure Data Factory bemutatását.

Előfeltételek

Azure-előfizetés

Ha még nincs Azure-előfizetése, kezdés előtt hozzon létre egy ingyenes fiókot.

Azure-szerepkörök

Data Factory-példányok létrehozásához az Azure-ba történő bejelentkezéshez használt felhasználói fióknak a közreműködő vagy tulajdonos szerepkör tagjának, vagy az Azure-előfizetés rendszergazdájának kell lennie. Az előfizetésben lévő engedélyek megtekintéséhez nyissa meg az Azure Portalt, válassza ki a felhasználónevét a jobb felső sarokban, válassza a "..." ikont a további lehetőségekhez, majd válassza a Saját engedélyek lehetőséget. Ha több előfizetéshez is rendelkezik hozzáféréssel, válassza ki a megfelelő előfizetést.

A Data Factory gyermekerőforrásai – beleértve az adatkészletek, társított szolgáltatások, folyamatok, eseményindítók és integrációs modulok – létrehozására és kezelésére az alábbi követelmények vonatkoznak:

  • A gyermekerőforrások Microsoft Azure Portalon való létrehozásához és kezeléséhez a Data Factory közreműködője szerepkörhöz kell tartoznia az erőforráscsoport szintjén vagy felette.
  • A gyermekerőforrások PowerShell-lel vagy az SDK-val való létrehozásához és kezeléséhez a közreműködő szerepkör is elegendő az erőforráscsoport szintjén vagy felette.

Ha szeretne példautasításokat látni arra, hogyan kell egy felhasználót a szerepkörhöz adni, olvassa el a Szerepkörök hozzáadása című cikket.

További információkért tekintse meg a következő cikkeket:

Azure Storage-fiók

Ebben a rövid útmutatóban egy általános célú Azure Storage-fiókot (pontosabban Blob Storage-t) használ forrás- és céladattárként. Ha nem rendelkezik általános célú Azure Storage-fiókkal, a tárfiók létrehozásához tekintse meg a Tárfiók létrehozása című témakört.

A tárfiók nevének lekérése

Ehhez a rövid útmutatóhoz szüksége van az Azure Storage-fiók nevére. Az alábbi eljárás lépéseket tartalmaz a tárfiók nevének lekéréséhez:

  1. Egy webböngészőben nyissa meg az Azure Portalt , és jelentkezzen be az Azure-felhasználónevével és jelszavával.
  2. Az Azure Portal menüjében válassza a Minden szolgáltatás, majd a Storage-fiókok> lehetőséget. A Tárfiókokat bármelyik lapról megkeresheti és kiválaszthatja.
  3. A Tárfiókok lapon szűrjön a tárfiókra (ha szükséges), majd válassza ki a tárfiókot.

A Tárfiókokat bármelyik lapról megkeresheti és kiválaszthatja.

Blobtároló létrehozása

Ebben a szakaszban egy adftutorial nevű blobtárolót hoz létre az Azure Blob Storage-ban.

  1. A tárfiók lapján válassza az Áttekintés>tárolók lehetőséget.

  2. <A Fióknév> - tárolók lap eszköztárán válassza a Tároló lehetőséget.

  3. Az Új tároló párbeszédablakban adja meg az adftutorial nevet, és kattintson az OK gombra. A <Fióknév> - tárolók lapja úgy frissül, hogy az adftutorial szerepeljen a tárolók listájában.

    Tárolók listája

Bemeneti mappa és fájl hozzáadása a blobtárolóhoz

Ebben a szakaszban létrehoz egy bemenet nevű mappát a létrehozott tárolóban, majd feltölt egy mintafájlt a bemeneti mappába. Mielőtt hozzákezdene, nyisson meg egy szövegszerkesztőt, például a Jegyzettömbet, és hozzon létre egy emp.txt nevű fájlt a következő tartalommal:

John, Doe
Jane, Doe

Mentse a fájlt a C:\ADFv2QuickStartPSH mappába. (Ha a mappa még nem létezik, hozza létre.) Ezután térjen vissza az Azure Portalra, és kövesse az alábbi lépéseket:

  1. <A Fióknév> - tárolók lapján, ahol abbahagyta, válassza az adftutorial lehetőséget a frissített tárolók listájából.

    1. Ha bezárta az ablakot, vagy egy másik oldalra ment, jelentkezzen be újra az Azure Portalra .
    2. Az Azure Portal menüjében válassza a Minden szolgáltatás, majd a Storage-fiókok> lehetőséget. A Tárfiókokat bármelyik lapról megkeresheti és kiválaszthatja.
    3. Válassza ki a tárfiókot, majd válassza a Tárolók>adftutorial lehetőséget.
  2. Az adftutorial tárolóoldal eszköztárán válassza a Feltöltés lehetőséget.

  3. A Blob feltöltése lapon válassza a Fájlok mezőt, majd keresse meg és válassza ki a emp.txt fájlt.

  4. Bontsa ki a Speciális címsort. A lap most az alábbi módon jelenik meg:

    Kattintás a Speciális hivatkozásra

  5. A Feltöltés mappába mezőbe írja be a bemenetet.

  6. Kattintson a Feltöltés gombra. A listában meg kell jelennie az emp.txt fájlnak és a feltöltés állapotának.

  7. A Blob feltöltése lap bezárásához válassza a Bezárás ikont (X).

Tartsa nyitva az adftutorial tárolólapot. A segítségével ellenőrizheti ennek a rövid útmutatónak az eredményét.

Visual Studio

A cikk bemutatója a Visual Studio 2019-et használja. A Visual Studio 2013, 2015 vagy 2017 eljárásai kissé eltérnek egymástól.

Alkalmazás létrehozása a Microsoft Entra-azonosítóban

A Útmutató: A portál használatával erőforrásokhoz hozzáférő Microsoft Entra-alkalmazás és szolgáltatásnév létrehozásához kövesse az alábbi lépéseket:

  1. Microsoft Entra-alkalmazás létrehozásakor hozzon létre egy alkalmazást, amely az oktatóanyagban létrehozott .NET-alkalmazást jelöli. A bejelentkezési URL-hez megadhat egy hamis URL-t, a cikkben láthatóak szerint (https://contoso.org/exampleapp).
  2. A Bejelentkezéshez szükséges értékek lekérése területen kérje le az alkalmazásazonosítót és a bérlőazonosítót, és jegyezze fel az oktatóanyag későbbi részében használt értékeket.
  3. A tanúsítványokban és titkos kódokban szerezze be a hitelesítési kulcsot, és jegyezze fel ezt az értéket, amelyet az oktatóanyag későbbi részében használ.
  4. Az alkalmazás szerepkörhöz rendelése során rendelje hozzá az alkalmazást a közreműködői szerepkörhöz az előfizetés szintjén, hogy az alkalmazás adat-előállítókat hozhasson létre az előfizetésben.

Visual Studio-projekt létrehozása

Ezután hozzon létre egy C# .NET-konzolalkalmazást a Visual Studióban:

  1. Indítsa el a Visual Studiót.
  2. A Start ablakban válassza az Új projekt>konzolalkalmazás létrehozása (.NET-keretrendszer) lehetőséget. A lépések elvégzéséhez a .NET 4.5.2-es vagy újabb verziója szükséges.
  3. A Projekt nevében adja meg az ADFv2QuickStart nevet.
  4. A projekt létrehozásához válassza a Létrehozás lehetőséget.

NuGet-csomagok telepítése

  1. Válassza az Eszközök>NuGet Csomagkezelő> Csomagkezelő konzol lehetőséget.

  2. A Csomagkezelő Konzol panelen futtassa az alábbi parancsokat a csomagok telepítéséhez. További információ: Azure.ResourceManager.DataFactory NuGet csomag.

    Install-Package Azure.ResourceManager.DataFactory -IncludePrerelease
    Install-Package Azure.Identity 
    

Adat-előállító létrehozása

  1. Nyissa meg a Program.cs fájlt, majd illessze be az alábbi utasításokat, hogy a névterekre mutató hivatkozásokat tudjon felvenni.

    using Azure;
    using Azure.Core;
    using Azure.Core.Expressions.DataFactory;
    using Azure.Identity;
    using Azure.ResourceManager;
    using Azure.ResourceManager.DataFactory;
    using Azure.ResourceManager.DataFactory.Models;
    using Azure.ResourceManager.Resources;
    using System;
    using System.Collections.Generic;
    
  2. Adja hozzá az alábbi kódot a Main metódushoz, amely beállítja a változókat. A helyőrzőket cserélje le a saját értékeire. Azon Azure-régiók megtekintéséhez, amelyekben jelenleg elérhető a Data Factory, a következő lapon válassza ki az Önt érdeklő régiókat, majd bontsa ki az Elemzés részt, és keresse meg a Data Factory: Elérhető termékek régiók szerint szakaszt. Az adat-előállító által használt adattárak (Azure Storage, Azure SQL Database és egyebek) és számítások (HDInsight és egyéb) más régiókban is lehetnek.

    // Set variables
    string tenantID = "<your tenant ID>";
    string applicationId = "<your application ID>";
    string authenticationKey = "<your authentication key for the application>";
    string subscriptionId = "<your subscription ID where the data factory resides>";
    string resourceGroup = "<your resource group where the data factory resides>";
    string region = "<the location of your resource group>";
    string dataFactoryName = 
        "<specify the name of data factory to create. It must be globally unique.>";
    string storageAccountName = "<your storage account name to copy data>";
    string storageKey = "<your storage account key>";
    // specify the container and input folder from which all files 
    // need to be copied to the output folder. 
    string inputBlobContainer = "<blob container to copy data from, e.g. containername>";
    string inputBlobPath = "<path to existing blob(s) to copy data from, e.g. inputdir/file>";
    //specify the contains and output folder where the files are copied
    string outputBlobContainer = "<blob container to copy data from, e.g. containername>";
    string outputBlobPath = "<the blob path to copy data to, e.g. outputdir/file>";
    
    // name of the Azure Storage linked service, blob dataset, and the pipeline
    string storageLinkedServiceName = "AzureStorageLinkedService";
    string blobDatasetName = "BlobDataset";
    string pipelineName = "Adfv2QuickStartPipeline";
    
  3. Adja hozzá a következő kódot a Main metódushoz, amely létrehozza az adat-előállítót.

    ArmClient armClient = new ArmClient(
        new ClientSecretCredential(tenantID, applicationId, authenticationKey, new TokenCredentialOptions
        {
            AuthorityHost = AzureAuthorityHosts.AzurePublicCloud
        }), 
        subscriptionId, 
        new ArmClientOptions { Environment = ArmEnvironment.AzurePublicCloud }
    );
    
    ResourceIdentifier resourceIdentifier = SubscriptionResource.CreateResourceIdentifier(subscriptionId);
    SubscriptionResource subscriptionResource = armClient.GetSubscriptionResource(resourceIdentifier);
    
    Console.WriteLine("Get an existing resource group " + resourceGroupName + "...");
    var resourceGroupOperation = subscriptionResource.GetResourceGroups().Get(resourceGroupName);
    ResourceGroupResource resourceGroupResource = resourceGroupOperation.Value;
    
    Console.WriteLine("Create a data factory " + dataFactoryName + "...");
    DataFactoryData dataFactoryData = new DataFactoryData(AzureLocation.EastUS2);
    var dataFactoryOperation = resourceGroupResource.GetDataFactories().CreateOrUpdate(WaitUntil.Completed, dataFactoryName, dataFactoryData);
    Console.WriteLine(dataFactoryOperation.WaitForCompletionResponse().Content);
    
    // Get the data factory resource
    DataFactoryResource dataFactoryResource = dataFactoryOperation.Value;
    

Társított szolgáltatás létrehozása

Adja hozzá a következő kódot a Main metódushoz, amely létrehoz egy Azure Storage-beli társított szolgáltatást.

Társított szolgáltatásokat hoz létre egy adat-előállítóban az adattárak és a számítási szolgáltatások adat-előállítóval történő társításához. Ebben a rövid útmutatóban csak egy Azure Blob Storage-társított szolgáltatást kell létrehoznia mind a másolási forráshoz, mind a fogadótárhoz; a minta neve "AzureBlobStorageLinkedService".

// Create an Azure Storage linked service
Console.WriteLine("Create a linked service " + storageLinkedServiceName + "...");
AzureBlobStorageLinkedService azureBlobStorage = new AzureBlobStorageLinkedService()
{
    ConnectionString = azureBlobStorageConnectionString
};

DataFactoryLinkedServiceData linkedServiceData = new DataFactoryLinkedServiceData(azureBlobStorage);

var linkedServiceOperation = dataFactoryResource.GetDataFactoryLinkedServices().CreateOrUpdate(WaitUntil.Completed, storageLinkedServiceName, linkedServiceData);
Console.WriteLine(linkedServiceOperation.WaitForCompletionResponse().Content);

Adathalmaz létrehozása

Adja hozzá a következő kódot a metódushoz, amely tagolt szöveges adatkészletet hoz létre.

Megadhat egy adatkészletet, amely a forrásból a fogadóba másolt adatokat jelöli. Ebben a példában ez a tagolt szöveges adatkészlet az előző lépésben létrehozott Azure Blob Storage társított szolgáltatásra hivatkozik. Az adatkészlet két paramétert használ, amelyek értékét egy olyan tevékenységben állítja be, amely az adathalmazt használja. A paraméterek a "tároló" és a "folderPath" létrehozására szolgálnak, amely az adatok tárolási helyére mutat.

// Create an Azure Blob dataset
DataFactoryLinkedServiceReference linkedServiceReference = new DataFactoryLinkedServiceReference(DataFactoryLinkedServiceReferenceType.LinkedServiceReference, storageLinkedServiceName);
DelimitedTextDataset delimitedTextDataset = new DelimitedTextDataset(linkedServiceReference)
{
    DataLocation = new AzureBlobStorageLocation
    {
        Container = DataFactoryElement<string>.FromExpression("@dataset().container"),
        FileName = DataFactoryElement<string>.FromExpression("@dataset().path")
    },
    Parameters =
    {
        new KeyValuePair<string, EntityParameterSpecification>("container",new EntityParameterSpecification(EntityParameterType.String)),
        new KeyValuePair<string, EntityParameterSpecification>("path",new EntityParameterSpecification(EntityParameterType.String))
    },
    FirstRowAsHeader = false,
    QuoteChar = "\"",
    EscapeChar = "\\",
    ColumnDelimiter = ","
};

DataFactoryDatasetData datasetData = new DataFactoryDatasetData(delimitedTextDataset);

var datasetOperation = dataFactoryResource.GetDataFactoryDatasets().CreateOrUpdate(WaitUntil.Completed, blobDatasetName, datasetData);
Console.WriteLine(datasetOperation.WaitForCompletionResponse().Content);

Folyamat létrehozása

Adja hozzá a következő kódot a Main metódushoz, amely létrehozza a másolási tevékenységet tartalmazó folyamatot.

Ebben a példában ez a folyamat egy tevékenységet tartalmaz, és négy paramétert vesz fel: a bemeneti blobtárolót és az elérési utat, valamint a kimeneti blobtárolót és elérési utat. A paraméterek értékei a folyamat indításakor/futtatásakor lesznek beállítva. A másolási tevékenység az előző lépésben kimenetként és bemenetként létrehozott blob-adatkészletre hivatkozik. Ha az adathalmazt bemeneti adathalmazként használják, a bemeneti tároló és az elérési út meg lesz adva. Ha pedig az adatkészletet kimeneti adatkészletként használja, a kimeneti tároló és az elérési út lesz megadva.

// Create a pipeline with a copy activity
Console.WriteLine("Creating pipeline " + pipelineName + "...");
DataFactoryPipelineData pipelineData = new DataFactoryPipelineData()
{
    Parameters =
    {
        new KeyValuePair<string, EntityParameterSpecification>("inputContainer",new EntityParameterSpecification(EntityParameterType.String)),
        new KeyValuePair<string, EntityParameterSpecification>("inputPath",new EntityParameterSpecification(EntityParameterType.String)),
        new KeyValuePair<string, EntityParameterSpecification>("outputContainer",new EntityParameterSpecification(EntityParameterType.String)),
        new KeyValuePair<string, EntityParameterSpecification>("outputPath",new EntityParameterSpecification(EntityParameterType.String))
    },
    Activities =
    {
        new CopyActivity("CopyFromBlobToBlob",new DataFactoryBlobSource(),new DataFactoryBlobSink())
        {
            Inputs =
            {
                new DatasetReference(DatasetReferenceType.DatasetReference,blobDatasetName)
                {
                    Parameters =
                    {
                        new KeyValuePair<string, BinaryData>("container", BinaryData.FromString("\"@pipeline().parameters.inputContainer\"")),
                        new KeyValuePair<string, BinaryData>("path", BinaryData.FromString("\"@pipeline().parameters.inputPath\""))
                    }
                }
            },
            Outputs =
            {
                new DatasetReference(DatasetReferenceType.DatasetReference,blobDatasetName)
                {
                    Parameters =
                    {
                        new KeyValuePair<string, BinaryData>("container", BinaryData.FromString("\"@pipeline().parameters.outputContainer\"")),
                        new KeyValuePair<string, BinaryData>("path", BinaryData.FromString("\"@pipeline().parameters.outputPath\""))
                    }
                }
            }
        }
    }
};

var pipelineOperation = dataFactoryResource.GetDataFactoryPipelines().CreateOrUpdate(WaitUntil.Completed, pipelineName, pipelineData);
Console.WriteLine(pipelineOperation.WaitForCompletionResponse().Content);

Folyamat futásának létrehozása

Adja hozzá a következő kódot a Main metódushoz, amely elindítja a folyamat futását.

Ez a kód a folyamatban megadott inputContainer, inputPath, outputContainer és outputPath paraméterek értékeit is beállítja a forrás- és fogadó blobútvonalak tényleges értékeivel.

// Create a pipeline run
Console.WriteLine("Creating pipeline run...");
Dictionary<string, BinaryData> parameters = new Dictionary<string, BinaryData>()
{
    { "inputContainer",BinaryData.FromObjectAsJson(inputBlobContainer) },
    { "inputPath",BinaryData.FromObjectAsJson(inputBlobPath) },
    { "outputContainer",BinaryData.FromObjectAsJson(outputBlobContainer) },
    { "outputPath",BinaryData.FromObjectAsJson(outputBlobPath) }
};

var pipelineResource = dataFactoryResource.GetDataFactoryPipeline(pipelineName);
var runResponse = pipelineResource.Value.CreateRun(parameters);
Console.WriteLine("Pipeline run ID: " + runResponse.Value.RunId);

Folyamat futásának monitorozása

  1. Adja hozzá a következő kódot a Main metódushoz az állapot folyamatos, az adatok másolásának befejezéséig tartó ellenőrzéséhez.

    // Monitor the pipeline run
    Console.WriteLine("Checking pipeline run status...");
    DataFactoryPipelineRunInfo pipelineRun;
    while (true)
    {
        pipelineRun = dataFactoryResource.GetPipelineRun(runResponse.Value.RunId.ToString());
        Console.WriteLine("Status: " + pipelineRun.Status);
        if (pipelineRun.Status == "InProgress" || pipelineRun.Status == "Queued")
            System.Threading.Thread.Sleep(15000);
        else
            break;
    }
    
  2. Adja hozzá a következő kódot a másolási tevékenység futtatásának részleteit lekérő Fő metódushoz, például az olvasott vagy írott adatok méretéhez.

    // Check the copy activity run details
    Console.WriteLine("Checking copy activity run details...");
    
    var queryResponse = dataFactoryResource.GetActivityRun(pipelineRun.RunId.ToString(), 
        new RunFilterContent(DateTime.UtcNow.AddMinutes(-10), DateTime.UtcNow.AddMinutes(10)));
    
    var enumerator = queryResponse.GetEnumerator();
    enumerator.MoveNext();
    
    if (pipelineRun.Status == "Succeeded")
        Console.WriteLine(enumerator.Current.Output);
    else
        Console.WriteLine(enumerator.Current.Error);
    Console.WriteLine("\nPress any key to exit...");
    Console.ReadKey();
    

A kód futtatása

Állítsa össze és indítsa el az alkalmazást, majd ellenőrizze a folyamat-végrehajtást.

A konzol megjeleníti az adat-előállító, a társított szolgáltatás, az adatkészletek, a folyamat, valamint a folyamat futása létrehozási állapotát. Ezután ellenőrzi a folyamat futási állapotát. Várjon, amíg meg nem jelenik a másolási tevékenység részletei az olvasási/írási adatok méretével. Ezután az olyan eszközökkel, mint az Azure Storage Explorer , ellenőrizze, hogy a blob(ok) a változókban megadott "inputBlobPath" fájlból a "outputBlobPath" fájlba lesznek-e másolva.

Példakimenet

Create a data factory quickstart-adf...
{
  "name": "quickstart-adf",
  "type": "Microsoft.DataFactory/factories",
  "properties": {
    "provisioningState": "Succeeded",
    "version": "2018-06-01"
  },
  "location": "eastus2"
}
Create a linked service AzureBlobStorage...
{
  "name": "AzureBlobStorage",
  "type": "Microsoft.DataFactory/factories/linkedservices",
  "properties": {
    "type": "AzureBlobStorage",
    "typeProperties": {
      "connectionString": "DefaultEndpointsProtocol=https;AccountName=<storageAccountName>;",
      "encryptedCredential": "<encryptedCredential>"
    }
  }
}
Creating dataset BlobDelimitedDataset...
{
  "name": "BlobDelimitedDataset",
  "type": "Microsoft.DataFactory/factories/datasets",
  "properties": {
    "type": "DelimitedText",
    "linkedServiceName": {
      "type": "LinkedServiceReference",
      "referenceName": "AzureBlobStorage"
    },
    "parameters": {
      "container": {
        "type": "String"
      },
      "path": {
        "type": "String"
      }
    },
    "typeProperties": {
      "location": {
        "container": {
          "type": "Expression",
          "value": "@dataset().container"
        },
        "type": "AzureBlobStorageLocation",
        "fileName": {
          "type": "Expression",
          "value": "@dataset().path"
        }
      },
      "columnDelimiter": ",",
      "quoteChar": "\"",
      "escapeChar": "\\",
      "firstRowAsHeader": false
    }
  }
}
Creating pipeline Adfv2QuickStartPipeline...
{
  "properties": {
    "activities": [
      {
        "inputs": [
          {
            "type": "DatasetReference",
            "referenceName": "BlobDelimitedDataset",
            "parameters": {
              "container": "@pipeline().parameters.inputContainer",
              "path": "@pipeline().parameters.inputPath"
            }
          }
        ],
        "outputs": [
          {
            "type": "DatasetReference",
            "referenceName": "BlobDelimitedDataset",
            "parameters": {
              "container": "@pipeline().parameters.outputContainer",
              "path": "@pipeline().parameters.outputPath"
            }
          }
        ],
        "name": "CopyFromBlobToBlob",
        "type": "Copy",
        "typeProperties": {
          "source": {
            "type": "BlobSource"
          },
          "sink": {
            "type": "BlobSink"
          }
        }
      }
    ],
    "parameters": {
      "inputContainer": {
        "type": "String"
      },
      "inputPath": {
        "type": "String"
      },
      "outputContainer": {
        "type": "String"
      },
      "outputPath": {
        "type": "String"
      }
    }
  }
}
Creating pipeline run...
Pipeline run ID: 3aa26ffc-5bee-4db9-8bac-ccbc2d7b51c1
Checking pipeline run status...
Status: InProgress
Status: Succeeded
Checking copy activity run details...
{
  "dataRead": 1048,
  "dataWritten": 1048,
  "filesRead": 1,
  "filesWritten": 1,
  "sourcePeakConnections": 1,
  "sinkPeakConnections": 1,
  "copyDuration": 8,
  "throughput": 1.048,
  "errors": [],
  "effectiveIntegrationRuntime": "AutoResolveIntegrationRuntime (East US 2)",
  "usedDataIntegrationUnits": 4,
  "billingReference": {
    "activityType": "DataMovement",
    "billableDuration": [
      {
        "meterType": "AzureIR",
        "duration": 0.06666666666666667,
        "unit": "DIUHours"
      }
    ],
    "totalBillableDuration": [
      {
        "meterType": "AzureIR",
        "duration": 0.06666666666666667,
        "unit": "DIUHours"
      }
    ]
  },
  "usedParallelCopies": 1,
  "executionDetails": [
    {
      "source": {
        "type": "AzureBlobStorage"
      },
      "sink": {
        "type": "AzureBlobStorage"
      },
      "status": "Succeeded",
      "start": "2023-12-15T10:25:33.9991558Z",
      "duration": 8,
      "usedDataIntegrationUnits": 4,
      "usedParallelCopies": 1,
      "profile": {
        "queue": {
          "status": "Completed",
          "duration": 5
        },
        "transfer": {
          "status": "Completed",
          "duration": 1,
          "details": {
            "listingSource": {
              "type": "AzureBlobStorage",
              "workingDuration": 0
            },
            "readingFromSource": {
              "type": "AzureBlobStorage",
              "workingDuration": 0
            },
            "writingToSink": {
              "type": "AzureBlobStorage",
              "workingDuration": 0
            }
          }
        }
      },
      "detailedDurations": {
        "queuingDuration": 5,
        "transferDuration": 1
      }
    }
  ],
  "dataConsistencyVerification": {
    "VerificationResult": "NotVerified"
  }
}

Press any key to exit...

Kimenet ellenőrzése

A folyamat automatikusan létrehozza a kimeneti mappát az adftutorial blobtárolóban. Ezután átmásolja a emp.txt fájlt a bemeneti mappából a kimeneti mappába.

  1. Az Azure Portalon az adftutorial tárolólapon, amelyet a fenti Blob-tárolóhoz tartozó Bemeneti mappa és fájl hozzáadása szakaszban állított le, válassza a Frissítés lehetőséget a kimeneti mappa megtekintéséhez.
  2. A mappalistában válassza ki a kimenetet.
  3. Ellenőrizze, hogy az emp.txt fájl bekerült-e a kimeneti mappába.

Az erőforrások eltávolítása

Az adat-előállító programozott törléséhez adja hozzá a következő kódsorokat a programhoz:

Console.WriteLine("Deleting the data factory");
dataFactoryResource.Delete(WaitUntil.Completed);

Következő lépések

A példában szereplő folyamat adatokat másol az egyik helyről egy másikra egy Azure Blob Storage-ban. A Data Factory más forgatókönyvekben való használatát ismertető további információkért tekintse meg az oktatóanyagokat.