Freigeben über

Schnellstart: Erstellen einer Data Factory und Pipeline mit dem .NET SDK

Gilt für: Azure Data Factory Azure Synapse Analytics

Tipp

Data Factory in Microsoft Fabric ist die nächste Generation von Azure Data Factory mit einer einfacheren Architektur, integrierter KI und neuen Features. Wenn Sie mit der Datenintegration noch nicht vertraut sind, beginnen Sie mit Fabric Data Factory. Vorhandene ADF-Workloads können auf Fabric aktualisiert werden, um auf neue Funktionen in der Datenwissenschaft, Echtzeitanalysen und Berichterstellung zuzugreifen.

In dieser Schnellstartanleitung wird beschrieben, wie Sie .NET SDK zum Erstellen eines Azure Data Factory verwenden. Die Pipeline, die Sie in dieser Data Factory erstellen, kopiert Daten aus einem Ordner in einen anderen Ordner in einem Azure Blob Storage. Ein Lernprogramm zum transform von Daten mithilfe von Azure Data Factory finden Sie unter Tutorial: Transformieren von Daten mithilfe von Spark.

Voraussetzungen

Azure-Abonnement

Wenn Sie kein Azure-Abonnement haben, erstellen Sie ein free-Konto, bevor Sie beginnen.

Azure-Rollen

Zum Erstellen von Data Factory-Instanzen muss das Benutzerkonto, mit dem Sie sich bei Azure anmelden, Mitglied der Rolle contributor oder owner oder ein administrator des Azure-Abonnements sein. Um die Berechtigungen anzuzeigen, die Sie im Abonnement haben, wechseln Sie zum portal Azure wählen Sie Ihren Benutzernamen in der oberen rechten Ecke aus, wählen Sie "... "-Symbol für weitere Optionen aus, und wählen Sie dann My permissions aus. Wenn Sie Zugriff auf mehrere Abonnements besitzen, wählen Sie das entsprechende Abonnement aus.

Für das Erstellen und Verwalten von untergeordneten Ressourcen für Data Factory – z.B. Datasets, verknüpfte Dienste, Pipelines, Trigger und Integration Runtimes – gelten die folgenden Anforderungen:

  • Um untergeordnete Ressourcen im Azure-Portal zu erstellen und zu verwalten, müssen Sie zur Rolle Data Factory Contributor auf Ressourcengruppenebene oder höher gehören.
  • Zum Erstellen und Verwalten von untergeordneten Ressourcen mit PowerShell oder dem SDK auf Ressourcenebene oder höher ist die Rolle Mitwirkender ausreichend.

Eine Beispielanleitung zum Hinzufügen eines Benutzers zu einer Rolle finden Sie im Artikel Rollen hinzufügen.

Weitere Informationen finden Sie in den folgenden Artikeln:

Azure Storage Konto

Sie verwenden in diesem Schnellstart ein allgemeines Azure Storage-Konto (Blobspeicher) als Datenspeicher vom Typ Quelle und vom Typ Ziel. Wenn Sie nicht über ein Allzweck-Azure-Storage-Konto verfügen, lesen Sie Create a storage account, um eines zu erstellen.

Speicherkontonamen abrufen

Sie benötigen den Namen Ihres Azure Storage Kontos für diese Schnellstartanleitung. Das folgende Verfahren beschreibt die Schritte, um den Namen Ihres Speicherkontos abzurufen:

  1. Wechseln Sie in einem Webbrowser zum portal Azure und melden Sie sich mit Ihrem Azure Benutzernamen und Kennwort an.
  2. Wählen Sie im Azure Portalmenü All services und dann Storage>Storage accounts aus. Alternativ können Sie auf einer beliebigen Seite nach Speicherkonten suchen und die entsprechende Option auswählen.
  3. Filtern Sie auf der Seite Speicherkonten nach Ihrem Speicherkonto (falls erforderlich), und wählen Sie dann Ihr Speicherkonto aus.

Alternativ können Sie auf einer beliebigen Seite nach Speicherkonten suchen und die entsprechende Option auswählen.

Erstellen eines Blobcontainers

In diesem Abschnitt erstellen Sie einen Blobcontainer mit dem Namen adftutorial in Azure Blob Storage.

  1. Wählen Sie auf der Seite „Speicherkonto“ die Optionen Übersicht>Container aus.

  2. Wählen Sie auf der Symbolleiste der Seite <Kontoname> - Container die Option Container aus.

  3. Geben Sie im Dialogfeld Neuer Container als Namen adftutorial ein, und klicken Sie auf OK. Die Seite <Kontoname> - Container wird aktualisiert, woraufhin die Liste der Container den Eintrag adftutorial enthält.

    Liste der Container

Hinzufügen eines Eingabeordners und einer Datei für den Blobcontainer

In diesem Abschnitt erstellen Sie einen Ordner mit dem Namen input in dem Container, den Sie erstellt haben, und laden eine Beispieldatei in den Eingabeordner hoch. Öffnen Sie zunächst einen Text-Editor wie Notepad, und erstellen Sie eine Datei mit dem Namen emp.txt und folgendem Inhalt:

John, Doe
Jane, Doe

Speichern Sie die Datei im Ordner C:\ADFv2QuickStartPSH. (Wenn der Ordner noch nicht vorhanden ist, erstellen Sie ihn.) Kehren Sie dann zum Azure Portal zurück, und führen Sie die folgenden Schritte aus:

  1. Wählen Sie auf der Seite <Kontoname> - Container, auf der Sie Ihre Arbeit unterbrochen haben, in der aktualisierten Liste der Container den Eintrag adftutorial aus.

    1. Wenn Sie das Fenster geschlossen oder zu einer anderen Seite gewechselt haben, melden Sie sich erneut beim portal Azure an.
    2. Wählen Sie im Azure Portalmenü All services und dann Storage>Storage accounts aus. Alternativ können Sie auf einer beliebigen Seite nach Speicherkonten suchen und die entsprechende Option auswählen.
    3. Wählen Sie Ihr Speicherkonto und anschließend Container>adftutorial aus.

  2. Wählen Sie auf der Symbolleiste der Seite des Containers adftutorial die Option Hochladen aus.

  3. Wählen Sie auf der Seite Blob hochladen das Feld Dateien aus und navigieren Sie dann zur Datei emp.txt, um die Datei auszuwählen.

  4. Erweitern Sie die Überschrift Erweitert. Die Seite wird jetzt wie folgt angezeigt:

    Klicken auf den Link „Erweitert“

  5. Geben Sie im Feld In Ordner hochladeninput ein.

  6. Wählen Sie die Schaltfläche Hochladen. Daraufhin sollten in der Liste die Datei emp.txt und der Status des Uploads angezeigt werden.

  7. Wählen Sie das Symbol Schließen (das X) aus, um die Seite Blob hochladen zu schließen.

Lassen Sie die Seite des Containers adftutorial geöffnet. Sie verwenden es, um am Ende dieser Schnellstartanleitung die Ausgabe zu überprüfen.

Visual Studio

Die Beispielanleitung in diesem Artikel verwendet Visual Studio 2019. Die Verfahren für Visual Studio 2013, 2015 oder 2017 unterscheiden sich geringfügig.

Erstellen einer Anwendung in Microsoft Entra ID

In den Abschnitten unter Anleitung: Verwenden des Portals zum Erstellen einer Microsoft Entra-Anwendung und eines Dienstprinzipals, der auf Ressourcen zugreifen kann folgend Sie den Anweisungen zum Durchführen dieser Aufgaben:

  1. Erstellen Sie in Erstellen einer Microsoft Entra Anwendung eine Anwendung, die die .NET Anwendung darstellt, die Sie in diesem Lernprogramm erstellen. Als Anmelde-URL können Sie wie in diesem Artikel gezeigt eine Platzhalter-URL (https://contoso.org/exampleapp) angeben.
  2. Rufen Sie unter Abrufen von Werten für die Anmeldung die Anwendungs-ID und die Mandanten-ID ab, und notieren Sie sich diese Werte zur späteren Verwendung in diesem Tutorial.
  3. Rufen Sie unter Zertifikate und Geheimnisse den Authentifizierungsschlüssel ab, und notieren Sie sich diesen Wert zur späteren Verwendung in diesem Tutorial.
  4. Weisen Sie unter Zuweisen der Anwendung zu einer Rolle die Anwendung der Rolle Mitwirkender auf Abonnementebene zu, damit die Anwendung Data Factorys im Abonnement erstellen kann.

Erstellen eines Visual Studio Projekts

Erstellen Sie als Nächstes eine C#-.NET Konsolenanwendung in Visual Studio:

  1. Starten Sie Visual Studio.
  2. Wählen Sie im Startfenster Neues Projekt erstellen>Console App (.NET Framework) aus. .NET Version 4.5.2 oder höher ist erforderlich.
  3. Geben Sie in Project nameADFv2QuickStart ein.
  4. Wählen Sie Create (Erstellen), um das Projekt zu erstellen.

Installieren von NuGet-Paketen

  1. Wählen Sie Tools>NuGet Paket-Manager>Paket-Manager Console aus.

  2. Führen Sie im Bereich Paket-Manager Console die folgenden Befehle aus, um Pakete zu installieren. Weitere Informationen finden Sie im Azure. ResourceManager.DataFactory NuGet-Paket.

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

Erstellen einer Data Factory

  1. Öffnen Sie Program.cs , und fügen Sie die folgenden Anweisungen ein, um Verweise auf Namespaces hinzuzufügen.

    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. Fügen Sie der Main-Methode den folgenden Code hinzu, der die Variablen festlegt. Ersetzen Sie die Platzhalter durch Ihre eigenen Werte. Wählen Sie für eine Liste Azure Regionen, in denen Data Factory zurzeit verfügbar ist, die Regionen aus, die Sie auf der folgenden Seite interessieren, und erweitern Sie dann Analytics, um Data Factory: Products available by region zu finden. Die Datenspeicher (Azure Storage, Azure SQL-Datenbank und mehr) und Berechnungen (HDInsight und andere), die von der Datenfactory verwendet werden, können in anderen Regionen sein.

    // 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. Fügen Sie der Main-Methode den folgenden Code hinzu, der eine Data Factory erstellt.

    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;

Erstellen eines verknüpften Diensts

Fügen Sie der methode Main den folgenden Code hinzu, der einen Azure Storage verknüpften Dienst erstellt.

Um Ihre Datenspeicher und Compute Services mit der Data Factory zu verknüpfen, können Sie verknüpfte Dienste in einer Data Factory erstellen. In dieser Schnellstartanleitung müssen Sie nur einen Azure Blob Storage verknüpften Dienst sowohl für die Kopierquelle als auch für den Senkenspeicher erstellen. Es heißt "AzureBlobStorageLinkedService" im Beispiel.

// 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);

Erstellen eines Datasets

Fügen Sie der Main-Methode den folgenden Code hinzu, der ein durch Trennzeichen getrenntes Text-Dataset erstellt.

Sie definieren ein Dataset, das die Daten repräsentiert, die aus einer Quelle in eine Senke kopiert werden sollen. In diesem Beispiel verweist dieser durch Trennzeichen getrennte Datensatz auf den verknüpften Azure Blob Storage-Dienst, den Sie im vorherigen Schritt erstellt haben. Das Dataset akzeptiert zwei Parameter, dessen Wert in einer Aktivität festgelegt ist, die das Dataset verwendet. Die Parameter werden verwendet, um den „Container“ und den „folderPath“ zu konstruieren, der auf den Ort verweist, an dem die Daten gespeichert sind.

// 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);

Erstellen einer Pipeline

Fügen Sie der Main-Methode den folgenden Code hinzu, der eine Pipeline mit einer Kopieraktivität erstellt.

In diesem Beispiel enthält diese Pipeline eine Aktivität und akzeptiert vier Parameter: den Eingabe-Blob-Container und -Pfad sowie den Ausgabe-Blob-Container und -Pfad. Die Werte für diese Parameter werden festgelegt, wenn die Pipeline ausgelöst bzw. ausgeführt wird. Die Kopieraktivität verweist für die Eingabe und Ausgabe auf das gleiche Blobdataset, das im vorherigen Schritt erstellt wurde. Wenn das Dataset als Eingabedatensatz verwendet wird, werden Eingabecontainer und Pfad angegeben. Und wenn das Dataset als Ausgabedatensatz verwendet wird, werden der Ausgabecontainer und der Pfad angegeben.

// 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);

Erstellen einer Pipelineausführung

Fügen Sie der Main-Methode den folgenden Code hinzu, der eine Pipelineausführung auslöst.

Mit diesem Code werden auch die Werte der Parameter inputContainer, inputPath, outputContainer und outputPath festgelegt, die in der Pipeline mit den tatsächlichen Werten der Quell- und Senken-Blob-Pfade angegeben sind.

// 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);

Überwachen eines Pipeline-Laufs

  1. Fügen Sie den folgenden Code zur Main-Methode hinzu, um den Status kontinuierlich zu überprüfen, bis das Kopieren der Daten abgeschlossen ist.

    // 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. Fügen Sie der Main-Methode den folgenden Code hinzu, der Ausführungsdetails zur Kopieraktivität abruft, z.B. die Größe der Daten, die gelesen oder geschrieben werden.

    // 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();

Ausführen des Codes

Erstellen und starten Sie die Anwendung, und überprüfen Sie dann die Pipeline-Ausführung.

Die Konsole druckt den Status der Erstellung der Data Factory, des verknüpften Diensts, der Datasets, der Pipeline und der Pipelineausführung aus. Danach wird der Status der Pipelineausführung überprüft. Warten Sie, bis Sie die Ausführungsdetails der Kopieraktivität mit der Größe der gelesen/geschriebenen Daten sehen. Verwenden Sie dann Tools wie Azure Storage-Explorer um zu überprüfen, ob die Blobs in "outputBlobPath" aus "inputBlobPath" kopiert werden, wie Sie in den Variablen angegeben haben.

Beispielausgabe

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...

Überprüfen Sie die Ausgabe

Die Pipeline erstellt den Ausgabeordner automatisch im Blobcontainer adftutorial. Anschließend wird die Datei emp.txt aus dem Eingabe- in den Ausgabeordner kopiert.

  1. Wählen Sie im Azure Portal auf der adftutorial Containerseite, die Sie im Abschnitt Fügen Sie einen Eingabeordner und eine Datei für den Blobcontainer hinzu oben gestoppt haben, Refresh aus, um den Ausgabeordner anzuzeigen.
  2. Wählen Sie in der Ordnerliste output aus.
  3. Überprüfen Sie, ob die Datei emp.txt in den Ausgabeordner kopiert wurde.

Bereinigen von Ressourcen

Um die Data Factory programmgesteuert zu löschen, fügen Sie dem Programm die folgenden Codezeilen hinzu:

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

Nächste Schritte

Die Pipeline in diesem Beispiel kopiert Daten von einem Speicherort an einen anderen Speicherort in einem Azure BLOB-Speicher. Arbeiten Sie die Tutorials durch, um zu erfahren, wie Sie Data Factory in anderen Szenarien verwenden können.

  • Last updated on