Snabbstart: Skapa en datafabrik och pipeline med .NET SDK

Artikel
11/24/2021
12 minuter för att läsa

GÄLLER FÖR: Azure Data Factory Azure Synapse Analytics

Den här snabbstarten beskriver hur du använder .NET SDK för att skapa en Azure Data Factory. Den pipeline du skapar i den här datafabriken kopierar data från en mapp till en annan mapp i Azure Blob Storage. Om du vill se en självstudie som visar hur du omvandlar data med Azure Data Factory går du till Tutorial: Transform data using Spark (Självstudie: Omvandla data med Spark).

Anteckning

Den här artikeln ger inte någon detaljerad introduktion till Azure Data Factory-tjänsten. En introduktion till Azure Data Factory-tjänsten finns i Introduktion till Azure Data Factory.

Förutsättningar

Azure-prenumeration

Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.

Azure-roller

Om du vill skapa Data Factory-instanser måste det användarkonto du använder för att logga in på Azure vara medlem av rollerna deltagare eller ägare, eller vara administratör för Azure-prenumerationen. Om du vill visa de behörigheter som du har i prenumerationen går du till Azure Portal, väljer ditt användarnamn i det övre högra hörnet, väljer ikonen "..." för fler alternativ och väljer sedan Mina behörigheter. Om du har åtkomst till flera prenumerationer väljer du rätt prenumeration.

För att skapa och hantera underordnade resurser för Data Factory – inklusive datauppsättningar, länkade tjänster, pipelines, utlösare och integreringskörningar – gäller följande krav:

Om du vill skapa och hantera underordnade resurser i Azure Portal måste du tillhöra rollen Data Factory-deltagare på resursgruppsnivå eller högre.
För att skapa och hantera underordnade resurser med PowerShell eller SDK räcker det att du har rollen som deltagare på resursnivå eller högre.

För exempel på instruktioner om hur du lägger till en användare till en roll läser du artikeln Lägg till roller.

Mer information finns i följande artiklar:

Azure-lagringskonto

Du använder ett allmänt Azure Storage (särskilt Blob Storage) som både käll- och måldatalager i den här snabbstarten. Om du inte har något konto för generell användning Azure Storage du skapa ett i Skapa ett lagringskonto.

Hämta lagringskontots namn

Du behöver namnet på ditt Azure Storage för den här snabbstarten. Följande procedur innehåller steg för att hämta namnet på ditt lagringskonto:

I en webbläsare går du till den Azure Portal loggar in med ditt användarnamn och lösenord för Azure.
På Azure Portal väljer du Alla tjänster och sedan Lagringslagringskonton. > Du kan också söka efter och välja Lagringskonton på valfri sida.
På sidan Lagringskonton filtrerar du efter ditt lagringskonto (om det behövs) och väljer sedan ditt lagringskonto.

Du kan också söka efter och välja Lagringskonton på valfri sida.

Skapa en blobcontainer

I det här avsnittet skapar du en blobcontainer med namnet adftutorial i Azure Blob Storage.

På lagringskontosidan väljer du Översikt > Containrar.
På sidan <Account name> - Containrars verktygsfält väljer du Container.
I dialogrutan Ny container anger du adftutorial som namn och väljer OK. Sidan <Account name> - Containrar uppdateras för att inkludera adftutorial i listan över containrar.

Lägga till en indatamapp och fil för blobcontainern

I det här avsnittet skapar du en mapp med namnet input i containern du skapade och laddar sedan upp en exempelfil till indatamappen. Innan du börjar öppnar du en textredigerare, till exempel Anteckningar, och skapar en filemp.txt med följande innehåll:

John, Doe
Jane, Doe

Spara filen i mappen C:\ADFv2QuickStartPSH. (Om mappen inte redan finns skapar du den.) Gå sedan tillbaka till Azure Portal och följ dessa steg:

På sidan <Account name> - Containrar där du slutade väljer du adftutorial i den uppdaterade listan över containrar.
1. Om du stängde fönstret eller gick till en annan sida loggar du in på Azure Portal igen.
2. På Azure Portal väljer du Alla tjänster och sedan Lagringslagringskonton. > Du kan också söka efter och välja Lagringskonton på valfri sida.
3. Välj ditt lagringskonto och välj sedan Containers > adftutorial.
Välj Ladda upp på containersidan adftutorial i verktygsfältet.
På sidan Ladda upp blob väljer du rutan Filer och bläddrar sedan till och väljer emp.txt fil.
Expandera rubriken Avancerat. Sidan visas nu så här:
I rutan Ladda upp till mapp anger du indata.
Välj knappen Ladda upp. Du bör se filen emp.txt och uppladdningens status i listan.
Välj ikonen Stäng (ett X) för att stänga sidan Ladda upp blob.

Låt containersidan adftutorial vara öppen. Du kommer att använda den för att bekräfta utdata i slutet av snabbstarten.

Visual Studio

I genomgången i den här artikeln används Visual Studio 2019. Procedurerna för Visual Studio 2013, 2015 eller 2017 skiljer sig något.

Skapa ett program i Azure Active Directory

I avsnitten i Gör så här: Använd portalen för att skapa ett Azure AD-program och tjänstens huvudnamn som kan komma åt resurser följer du anvisningarna för att utföra dessa uppgifter:

I Skapa ett Azure Active Directory programskapar du ett program som representerar det .NET-program som du skapar i den här självstudien. För inloggnings-URL kan du ange en låtsas-URL enligt artikeln (https://contoso.org/exampleapp).
I Hämta värden för att logga inhämtar du program-ID och klientorganisations-ID och noterar dessa värden som du använder senare i den här självstudien.
I Certifikat och hemligheter hämtardu autentiseringsnyckeln och noterar det här värdet som du använder senare i den här självstudien.
I Tilldela programmet till en rolltilldelar du programmet till rollen Deltagare på prenumerationsnivå så att programmet kan skapa datafabriker i prenumerationen.

Skapa ett Visual Studio-projekt

Skapa sedan ett C# .NET-konsolprogram i Visual Studio:

Starta Visual Studio.
I startfönstret väljer du Skapa ett nytt projekt > konsolapp (.NET Framework). .NET version 4.5.2 eller senare krävs.
I Project anger du ADFv2QuickStart.
Välj Skapa för att skapa projektet.

Installera NuGet-paket

Välj Verktyg > NuGet-pakethanteraren > Pakethanterarkonsolen.

Installera paket genom att köra följande kommandon i fönstret Package Manager Console. Mer information finns i NuGet-paketet Microsoft.Azure.Management.DataFactory.

Install-Package Microsoft.Azure.Management.DataFactory
Install-Package Microsoft.Azure.Management.ResourceManager -IncludePrerelease
Install-Package Microsoft.IdentityModel.Clients.ActiveDirectory

Skapa en datafabriksklient

Öppna Program.cs, lägg till följande instruktioner för att lägga till referenser till namnområden.

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Rest;
using Microsoft.Rest.Serialization;
using Microsoft.Azure.Management.ResourceManager;
using Microsoft.Azure.Management.DataFactory;
using Microsoft.Azure.Management.DataFactory.Models;
using Microsoft.IdentityModel.Clients.ActiveDirectory;

Lägg till följande kod till Main-metoden som anger variablerna. Ersätt platshållarna med dina egna värden. Om du vill se en lista med Azure-regioner där Data Factory är tillgängligt för närvarande markerar du de regioner du är intresserad av på följande sida. Expandera sedan Analytics och leta rätt på Data Factory: Tillgängliga produkter per region. Datalager (som Azure Storage, Azure SQL Database och mycket mer) och beräkningar (HDInsight och andra) som används av datafabriken kan finnas i andra regioner.

// 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 storageAccount = "<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 inputBlobPath =
    "<path to existing blob(s) to copy data from, e.g. containername/inputdir>";
//specify the contains and output folder where the files are copied
string outputBlobPath =
    "<the blob path to copy data to, e.g. containername/outputdir>";

// name of the Azure Storage linked service, blob dataset, and the pipeline
string storageLinkedServiceName = "AzureStorageLinkedService";
string blobDatasetName = "BlobDataset";
string pipelineName = "Adfv2QuickStartPipeline";

Anteckning

För nationella moln måste du använda lämpliga molnspecifika slutpunkter för ActiveDirectoryAuthority och ResourceManagerUrl (BaseUri). I AZURE Gov i USA skulle du till exempel använda utfärdare i stället för , och använda i stället för https://login.microsoftonline.us https://login.microsoftonline.com och sedan skapa https://management.usgovcloudapi.net https://management.azure.com/ datafabrikshanteringsklienten. Du kan använda Powershell för att enkelt hämta slutpunkts-URL:er för olika moln genom att köra "Get-AzEnvironment | Format-List" som returnerar en lista över slutpunkter för varje molnmiljö.

Lägg till följande kod i Main-metoden som skapar en instans av klassen DataFactoryManagementClient. Du kan använda det här objektet för att skapa en datafabrik, en länkad tjänst, datauppsättningar och en pipeline. Du kan också använda det här objektet för att övervaka information om pipelinekörning.

// Authenticate and create a data factory management client
var context = new AuthenticationContext("https://login.microsoftonline.com/" + tenantID);
ClientCredential cc = new ClientCredential(applicationId, authenticationKey);
AuthenticationResult result = context.AcquireTokenAsync(
    "https://management.azure.com/", cc).Result;
ServiceClientCredentials cred = new TokenCredentials(result.AccessToken);
var client = new DataFactoryManagementClient(cred) {
    SubscriptionId = subscriptionId };

Skapa en datafabrik

Lägg till följande kod som skapar en datafabrik till Main-metoden.

// Create a data factory
Console.WriteLine("Creating data factory " + dataFactoryName + "...");
Factory dataFactory = new Factory
{
    Location = region,
    Identity = new FactoryIdentity()
};
client.Factories.CreateOrUpdate(resourceGroup, dataFactoryName, dataFactory);
Console.WriteLine(
    SafeJsonConvert.SerializeObject(dataFactory, client.SerializationSettings));

while (client.Factories.Get(resourceGroup, dataFactoryName).ProvisioningState ==
       "PendingCreation")
{
    System.Threading.Thread.Sleep(1000);
}

Skapa en länkad tjänst

Lägg till följande kod i Main-metoden som skapar en länkad Azure Storage-tjänst.

Du kan skapa länkade tjänster i en datafabrik för att länka ditt datalager och beräkna datafabrik-tjänster. I den här snabbstarten behöver du bara skapa en Azure Storage-länkad tjänst för både kopieringskällan och målarkivet. Den heter "AzureStorageLinkedService" i exemplet.

// Create an Azure Storage linked service
Console.WriteLine("Creating linked service " + storageLinkedServiceName + "...");

LinkedServiceResource storageLinkedService = new LinkedServiceResource(
    new AzureStorageLinkedService
    {
        ConnectionString = new SecureString(
            "DefaultEndpointsProtocol=https;AccountName=" + storageAccount +
            ";AccountKey=" + storageKey)
    }
);
client.LinkedServices.CreateOrUpdate(
    resourceGroup, dataFactoryName, storageLinkedServiceName, storageLinkedService);
Console.WriteLine(SafeJsonConvert.SerializeObject(
    storageLinkedService, client.SerializationSettings));

Skapa en datauppsättning

Lägg till följande kod i Main-metoden som skapar en Azure Blob-datauppsättning.

Du definierar en datauppsättning som representerar data som ska kopieras från en källa till en mottagare. I det här exemplet refererar denna blob-datauppsättning till den Azure Storage-länkade tjänst som du skapade i föregående steg. Datauppsättningen tar en parameter vars värde anges i en aktivitet som förbrukar datauppsättningen. Parametern används för att konstruera "folderPath" som pekar på den plats där data finns/lagras.

// Create an Azure Blob dataset
Console.WriteLine("Creating dataset " + blobDatasetName + "...");
DatasetResource blobDataset = new DatasetResource(
    new AzureBlobDataset
    {
        LinkedServiceName = new LinkedServiceReference
        {
            ReferenceName = storageLinkedServiceName
        },
        FolderPath = new Expression { Value = "@{dataset().path}" },
        Parameters = new Dictionary<string, ParameterSpecification>
        {
            { "path", new ParameterSpecification { Type = ParameterType.String } }
        }
    }
);
client.Datasets.CreateOrUpdate(
    resourceGroup, dataFactoryName, blobDatasetName, blobDataset);
Console.WriteLine(
    SafeJsonConvert.SerializeObject(blobDataset, client.SerializationSettings));

Skapa en pipeline

Lägg till följande kod som skapar och aktiverar en pipeline till Main-metoden.

I det här exemplet innehåller den här pipelinen en aktivitet och tar två parametrar: sökvägen till indatabloben och sökvägen till utdatabloben. Värdena för dessa parametrar anges när pipeline utlöses/körs. Kopieringsaktiviteten refererar till samma blobdatauppsättning som skapats i föregående steg som indata och utdata. När datauppsättningen används som indatauppsättning anges indatasökvägen. Och när datauppsättningen används som utdatauppsättning anges utdatasökvägen.

// Create a pipeline with a copy activity
Console.WriteLine("Creating pipeline " + pipelineName + "...");
PipelineResource pipeline = new PipelineResource
{
    Parameters = new Dictionary<string, ParameterSpecification>
    {
        { "inputPath", new ParameterSpecification { Type = ParameterType.String } },
        { "outputPath", new ParameterSpecification { Type = ParameterType.String } }
    },
    Activities = new List<Activity>
    {
        new CopyActivity
        {
            Name = "CopyFromBlobToBlob",
            Inputs = new List<DatasetReference>
            {
                new DatasetReference()
                {
                    ReferenceName = blobDatasetName,
                    Parameters = new Dictionary<string, object>
                    {
                        { "path", "@pipeline().parameters.inputPath" }
                    }
                }
            },
            Outputs = new List<DatasetReference>
            {
                new DatasetReference
                {
                    ReferenceName = blobDatasetName,
                    Parameters = new Dictionary<string, object>
                    {
                        { "path", "@pipeline().parameters.outputPath" }
                    }
                }
            },
            Source = new BlobSource { },
            Sink = new BlobSink { }
        }
    }
};
client.Pipelines.CreateOrUpdate(resourceGroup, dataFactoryName, pipelineName, pipeline);
Console.WriteLine(SafeJsonConvert.SerializeObject(pipeline, client.SerializationSettings));

Skapa en pipelinekörning

Lägg till följande kod i Main-metoden för att utlösa en pipelinekörning.

Den här koden anger också värden för parametrarna inputPath och outputPath som anges i pipelinen med de faktiska värdena för sökvägarna för käll- och sink-blob.

// Create a pipeline run
Console.WriteLine("Creating pipeline run...");
Dictionary<string, object> parameters = new Dictionary<string, object>
{
    { "inputPath", inputBlobPath },
    { "outputPath", outputBlobPath }
};
CreateRunResponse runResponse = client.Pipelines.CreateRunWithHttpMessagesAsync(
    resourceGroup, dataFactoryName, pipelineName, parameters: parameters
).Result.Body;
Console.WriteLine("Pipeline run ID: " + runResponse.RunId);

Övervaka en pipelinekörning

Lägg till följande kod i Main-metoden för att kontinuerligt kontrollera status tills den har slutat att kopiera data.

// Monitor the pipeline run
Console.WriteLine("Checking pipeline run status...");
PipelineRun pipelineRun;
while (true)
{
    pipelineRun = client.PipelineRuns.Get(
        resourceGroup, dataFactoryName, runResponse.RunId);
    Console.WriteLine("Status: " + pipelineRun.Status);
    if (pipelineRun.Status == "InProgress" || pipelineRun.Status == "Queued")
        System.Threading.Thread.Sleep(15000);
    else
        break;
}

Lägg till följande kod i Main-metoden som hämtar körningsinformation om kopieringsaktiviteten, till exempel storleken på de data som läses eller skrivs.

// Check the copy activity run details
Console.WriteLine("Checking copy activity run details...");

RunFilterParameters filterParams = new RunFilterParameters(
    DateTime.UtcNow.AddMinutes(-10), DateTime.UtcNow.AddMinutes(10));
ActivityRunsQueryResponse queryResponse = client.ActivityRuns.QueryByPipelineRun(
    resourceGroup, dataFactoryName, runResponse.RunId, filterParams);
if (pipelineRun.Status == "Succeeded")
    Console.WriteLine(queryResponse.Value.First().Output);
else
    Console.WriteLine(queryResponse.Value.First().Error);
Console.WriteLine("\nPress any key to exit...");
Console.ReadKey();

Kör koden

Skapa och starta programmet och kontrollera sedan pipelinekörningen.

Konsolen skriver ut förloppet för skapandet av datafabriken, den länkade tjänsten, datauppsättningar, pipeline och pipelinekörning. Sedan kontrolleras status för pipelinekörningen. Vänta tills du ser körningsinformationen för kopieringsaktiviteten med storleken på läs-/skrivdata. Använd sedan verktyg som Azure Storage Explorer för att kontrollera att blobarna kopieras till "outputBlobPath" från "inputBlobPath" som du angav i variablerna.

Exempelutdata

Creating data factory SPv2Factory0907...
{
  "identity": {
    "type": "SystemAssigned"
  },
  "location": "East US"
}
Creating linked service AzureStorageLinkedService...
{
  "properties": {
    "type": "AzureStorage",
    "typeProperties": {
      "connectionString": {
        "value": "DefaultEndpointsProtocol=https;AccountName=<storageAccountName>;AccountKey=<storageAccountKey>",
        "type": "SecureString"
      }
    }
  }
}
Creating dataset BlobDataset...
{
  "properties": {
    "type": "AzureBlob",
    "typeProperties": {
      "folderPath": {
        "value": "@{dataset().path}",
        "type": "Expression"
      }
    },
    "linkedServiceName": {
      "referenceName": "AzureStorageLinkedService",
      "type": "LinkedServiceReference"
    },
    "parameters": {
      "path": {
        "type": "String"
      }
    }
  }
}
Creating pipeline Adfv2QuickStartPipeline...
{
  "properties": {
    "activities": [
      {
        "type": "Copy",
        "typeProperties": {
          "source": {
            "type": "BlobSource"
          },
          "sink": {
            "type": "BlobSink"
          }
        },
        "inputs": [
          {
            "referenceName": "BlobDataset",
            "parameters": {
              "path": "@pipeline().parameters.inputPath"
            },
            "type": "DatasetReference"
          }
        ],
        "outputs": [
          {
            "referenceName": "BlobDataset",
            "parameters": {
              "path": "@pipeline().parameters.outputPath"
            },
            "type": "DatasetReference"
          }
        ],
        "name": "CopyFromBlobToBlob"
      }
    ],
    "parameters": {
      "inputPath": {
        "type": "String"
      },
      "outputPath": {
        "type": "String"
      }
    }
  }
}
Creating pipeline run...
Pipeline run ID: 308d222d-3858-48b1-9e66-acd921feaa09
Checking pipeline run status...
Status: InProgress
Status: InProgress
Checking copy activity run details...
{
    "dataRead": 331452208,
    "dataWritten": 331452208,
    "copyDuration": 23,
    "throughput": 14073.209,
    "errors": [],
    "effectiveIntegrationRuntime": "DefaultIntegrationRuntime (West US)",
    "usedDataIntegrationUnits": 2,
    "billedDuration": 23
}

Press any key to exit...

Verifiera utdata

Pipelinen skapar automatiskt utdatamappen i blobcontainern adftutorial. Sedan kopieras filen emp.txt från indatamappen till utdatamappen.

I Azure Portal klickar du på containersidan adftutorial som du stoppade på i avsnittet Lägg till en indatamapp och fil för blobcontainern ovan och väljer Uppdatera för att se utdatamappen.
I mapplistan väljer du utdata.
Kontrollera att emp.txt har kopierats till utdatamappen.

Rensa resurser

Om du vill ta bort datafabriken programmatiskt lägger du till följande kodrader i programmet:

Console.WriteLine("Deleting the data factory");
client.Factories.Delete(resourceGroup, dataFactoryName);

Nästa steg

Pipeline i det här exemplet kopierar data från en plats till en annan i Azure Blob Storage. Gå igenom självstudiekurserna om du vill lära dig hur du använder Data Factory i fler scenarier.