Snabbstart: Skapa en datafabrik och pipeline med .NET SDK

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 konto (särskilt Blob Storage) som både käll- och måldatalager i den här snabbstarten. Om du inte har ett allmänt Azure Storage konto kan du läsa Skapa ett lagringskonto för att skapa ett.

Hämta lagringskontots namn

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

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

Du kan också söka efter och välja Storage konton från valfri sida.

Skapa en blobcontainer

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

  1. På lagringskontosidan väljer du ÖversiktContainers>.

  2. Välj Container i verktygsfältet på <sidan KontonamnContainers> - .

  3. I dialogrutan Ny container anger du adftutorial som namn och väljer OK. Sidan <KontonamnBehållare> - uppdateras så att den inkluderar adftutorial i listan över containrar.

    List of containers

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

I det här avsnittet skapar du en mapp med namnet input i containern som du skapade och laddar sedan upp en exempelfil till indatamappen. Innan du börjar öppnar du en textredigerare som Anteckningar och skapar en fil med namnet emp.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:

  1. På sidan <KontonamnContainers> - 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å menyn Azure Portal väljer du Alla tjänster och sedan Storage>Storage konton. Du kan också söka efter och välja Storage konton från valfri sida.
    3. Välj ditt lagringskonto och välj sedan Containraradftutorial>.
  2. I verktygsfältet för containersidan adftutorial väljer du Upload.

  3. På sidan Upload blob väljer du rutan Filer och bläddrar sedan till och väljer emp.txt-filen.

  4. Expandera rubriken Avancerat . Sidan visas nu som den visas:

    Select Advanced link

  5. I rutan Upload till mapp anger du indata.

  6. Välj knappen Ladda upp. Du bör se filen emp.txt och uppladdningens status i listan.

  7. Välj ikonen Stäng (ett X) för att stänga Upload blob-sidan.

Låt sidan adftutorial-container 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. Förfarandena för Visual Studio 2013, 2015 eller 2017 skiljer sig något.

Skapa ett program i Azure Active Directory

I avsnitten i How to: Use the portal to create an Azure AD application and service principal that can access resources (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 följande uppgifter:

  1. I Skapa ett Azure Active Directory program skapar 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).
  2. I Hämta värden för att logga in hämtar du program-ID :t och klientorganisations-ID:t och noterar dessa värden som du använder senare i den här självstudien.
  3. I Certifikat och hemligheter hämtar du autentiseringsnyckeln och noterar det här värdet som du använder senare i den här självstudien.
  4. I Tilldela programmet till en roll tilldelar du programmet 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:

  1. Starta Visual Studio.
  2. I fönstret Start väljer du Skapa ett nytt projektKonsolapp>(.NET Framework). .NET version 4.5.2 eller senare krävs.
  3. I Project anger du ADFv2QuickStart.
  4. Välj Skapa för att skapa projektet.

Installera NuGet-paket

  1. Välj Verktyg>NuGet-pakethanteraren>Pakethanterarkonsolen.

  2. I fönstret Package Manager Console (Pakethanterarens konsol ) kör du följande kommandon för att installera paket. 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.Identity.Client
    

Skapa en datafabriksklient

  1. Ö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.Identity.Client;
    
  2. 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 (Azure Storage, Azure SQL Database med mera) 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 US Azure Gov skulle du till exempel använda utfärdare för https://login.microsoftonline.us i stället för https://login.microsoftonline.com, och i https://management.usgovcloudapi.net stället för https://management.azure.com/och sedan skapa datafabrikens hanteringsklient. 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ö.

  1. 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
    IConfidentialClientApplication app = ConfidentialClientApplicationBuilder.Create(applicationId)
     .WithAuthority("https://login.microsoftonline.com/" + tenantID)
     .WithClientSecret(authenticationKey)
     .WithLegacyCacheCompatibility(false)
     .WithCacheOptions(CacheOptions.EnableSharedCacheOptions)
     .Build();
    
    AuthenticationResult result = await app.AcquireTokenForClient(
      new string[]{ "https://management.azure.com//.default"})
       .ExecuteAsync();
    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 mottagararkivet. 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 skapa "folderPath" som pekar på var 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: indatablobsökvägen och utdatablobsökvägen. 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 mottagarblob.

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

  1. 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;
    }
    
  2. Lägg till följande kod i Main-metoden som hämtar körningsinformation för kopieringsaktivitet, till exempel storleken på de data som läs- 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 emp.txt-filen från indatamappen till utdatamappen.

  1. I Azure Portal går du till sidan adftutorialcontainer som du stannade vid i avsnittet Lägg till en indatamapp och fil för blobcontainern ovan och väljer Uppdatera för att se utdatamappen.
  2. I mapplistan väljer du utdata.
  3. 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.