Utilisation des activités personnalisées dans un pipeline Azure Data FactoryUse custom activities in an Azure Data Factory pipeline

Notes

Cet article s’applique à la version 1 de Data Factory.This article applies to version 1 of Data Factory. Si vous utilisez la version actuelle du service Data Factory, consultez Activités personnalisées dans V2.If you are using the current version of the Data Factory service, see Custom activities in V2.

Vous pouvez utiliser deux types d’activités dans un pipeline Azure Data Factory.There are two types of activities that you can use in an Azure Data Factory pipeline.

Pour déplacer des données vers ou à partir d’un magasin de données qui n’est pas pris en charge par Data Factory, créez une activité personnalisée avec votre propre logique de déplacement des données et utilisez cette activité dans un pipeline.To move data to/from a data store that Data Factory does not support, create a custom activity with your own data movement logic and use the activity in a pipeline. De même, si vous devez transformer et traiter les données d’une manière qui n’est pas prise en charge par Data Factory, créez une activité personnalisée avec votre propre logique de transformation des données et utilisez cette activité dans un pipeline.Similarly, to transform/process data in a way that isn't supported by Data Factory, create a custom activity with your own data transformation logic and use the activity in a pipeline.

Vous pouvez configurer une activité personnalisée pour qu’elle s’exécute sur un pool Azure Batch de machines virtuelles.You can configure a custom activity to run on an Azure Batch pool of virtual machines. Lorsque vous utilisez Azure Batch, vous pouvez utiliser uniquement un pool Azure Batch.When using Azure Batch, you can use only an existing Azure Batch pool.

La procédure suivante fournit des instructions pas à pas pour créer une activité .NET personnalisée et utiliser cette activité personnalisée dans un pipeline.The following walkthrough provides step-by-step instructions for creating a custom .NET activity and using the custom activity in a pipeline. La procédure pas à pas utilise un service lié Azure Batch.The walkthrough uses an Azure Batch linked service.

Important

  • Il n’est pas possible d’utiliser une passerelle de gestion des données à partir d’une activité personnalisée pour accéder à des sources de données locales.It is not possible to use a Data Management Gateway from a custom activity to access on-premises data sources. Actuellement, la passerelle de gestion des données prend en charge uniquement l’activité de copie et l’activité de procédure stockée dans Data Factory.Currently, Data Management Gateway supports only the copy activity and stored procedure activity in Data Factory.

Procédure pas à pas : création d’une activité personnaliséeWalkthrough: create a custom activity

PrérequisPrerequisites

Configuration requise pour Azure BatchAzure Batch prerequisites

Dans la procédure pas à pas, vous allez exécuter vos activités .NET personnalisées à l’aide de la ressource de calcul Azure Batch.In the walkthrough, you run your custom .NET activities using Azure Batch as a compute resource. Azure Batch est une plateforme qui permet d’exécuter efficacement des applications de calcul haute performance (HPC) en parallèle et à grande échelle dans le cloud.Azure Batch is a platform service for running large-scale parallel and high-performance computing (HPC) applications efficiently in the cloud. Azure Batch planifie les travaux nécessitant une grande quantité de ressources système à exécuter sur une collection gérée de machines virtuelles. Il peut mettre automatiquement à l’échelle les ressources de calcul pour répondre aux besoins de vos travaux.Azure Batch schedules compute-intensive work to run on a managed collection of virtual machines, and can automatically scale compute resources to meet the needs of your jobs. Consultez l’article Notions de base d’Azure Batch pour une présentation détaillée du service Azure Batch.See Azure Batch basics article for a detailed overview of the Azure Batch service.

Pour ce didacticiel, créez un compte Azure Batch avec un pool de machines virtuelles.For the tutorial, create an Azure Batch account with a pool of VMs. Voici la procédure à suivre :Here are the steps:

  1. Créez un compte Azure Batch via le portail Azure.Create an Azure Batch account using the Azure portal. Consultez l’article Créer et gérer un compte Azure Batch pour obtenir des instructions.See Create and manage an Azure Batch account article for instructions.

  2. Notez le nom du pool, l’URI, la clé et le nom du compte Azure Batch.Note down the Azure Batch account name, account key, URI, and pool name. Vous en avez besoin pour créer un service lié Azure Batch.You need them to create an Azure Batch linked service.

    1. Sur la page d’accueil du compte Azure Batch, vous voyez une URL au format suivant : https://myaccount.westus.batch.azure.com.On the home page for Azure Batch account, you see a URL in the following format: https://myaccount.westus.batch.azure.com. Dans cet exemple, myaccount est le nom du compte Azure Batch.In this example, myaccount is the name of the Azure Batch account. L’URI que vous utilisez dans la définition de service lié est l’URL sans le nom du compte.URI you use in the linked service definition is the URL without the name of the account. Par exemple : https://<region>.batch.azure.com.For example: https://<region>.batch.azure.com.
    2. Cliquez sur Clés dans le menu de gauche et copiez la CLÉ D’ACCÈS PRIMAIRE.Click Keys on the left menu, and copy the PRIMARY ACCESS KEY.
    3. Pour utiliser un pool existant, cliquez sur Pools dans le menu, puis notez l’ID du pool.To use an existing pool, click Pools on the menu, and note down the ID of the pool. Si vous n’avez pas de pool existant, passez à l’étape suivante.If you don't have an existing pool, move to the next step.
  3. Créez un pool Azure Batch.Create an Azure Batch pool.

    1. Dans le portail Azure, cliquez sur Parcourir dans le menu de gauche, puis cliquez sur Comptes Batch.In the Azure portal, click Browse in the left menu, and click Batch Accounts.
    2. Sélectionnez votre compte Azure Batch pour ouvrir le panneau Compte Batch .Select your Azure Batch account to open the Batch Account blade.
    3. Cliquez sur la vignette Pools .Click Pools tile.
    4. Dans le panneau Pools , cliquez sur le bouton Ajouter de la barre d’outils pour ajouter un pool.In the Pools blade, click Add button on the toolbar to add a pool.
      1. Entrez un ID pour le pool (ID du pool).Enter an ID for the pool (Pool ID). Notez l’ID du pool, car vous en aurez besoin lors de la création de la solution Data Factory.Note the ID of the pool; you need it when creating the Data Factory solution.
      2. Spécifiez Windows Server 2012 R2 pour le paramètre de famille du système d’exploitation.Specify Windows Server 2012 R2 for the Operating System Family setting.
      3. Sélectionnez le niveau tarifaire du nœud.Select a node pricing tier.
      4. Entrez 2 comme valeur du paramètre Quantité dédiée cible.Enter 2 as value for the Target Dedicated setting.
      5. Entrez 2 comme valeur du paramètre Nombre maximal de tâches par nœud.Enter 2 as value for the Max tasks per node setting.
    5. Cliquez sur OK pour créer le pool.Click OK to create the pool.
    6. Notez l’ID du pool.Note down the ID of the pool.

Procédure généraleHigh-level steps

Voici les deux étapes principales que vous effectuez dans le cadre de cette procédure pas à pas :Here are the two high-level steps you perform as part of this walkthrough:

  1. Créer une activité personnalisée qui contient une logique simple de transformation/traitement des données.Create a custom activity that contains simple data transformation/processing logic.
  2. Créer une fabrique de données Azure avec un pipeline qui utilise l’activité personnalisée.Create an Azure data factory with a pipeline that uses the custom activity.

création d'une activité personnaliséeCreate a custom activity

Pour créer une activité .NET personnalisée, créez un projet de bibliothèque de classes .NET contenant une classe qui implémente l’interface IDotNetActivity.To create a .NET custom activity, create a .NET Class Library project with a class that implements that IDotNetActivity interface. Cette interface ne possède qu’une méthode : Execute et sa signature est :This interface has only one method: Execute and its signature is:

public IDictionary<string, string> Execute(
    IEnumerable<LinkedService> linkedServices,
    IEnumerable<Dataset> datasets,
    Activity activity,
    IActivityLogger logger)

La méthode accepte quatre paramètres :The method takes four parameters:

  • linkedServices.linkedServices. Cette propriété est une liste énumérable de services liés Data Store référencés par les jeux de données d’entrée/sortie de l’activité.This property is an enumerable list of Data Store linked services referenced by input/output datasets for the activity.
  • jeux de données.datasets. Cette propriété est une liste énumérable de jeux de données d’entrée/sortie de l’activité.This property is an enumerable list of input/output datasets for the activity. Vous pouvez utiliser ce paramètre pour obtenir les emplacements et les schémas définis par les jeux de données d’entrée et de sortie.You can use this parameter to get the locations and schemas defined by input and output datasets.
  • activity.activity. Cette propriété représente l’activité actuelle.This property represents the current activity. Elle peut être utilisée pour accéder aux propriétés étendues associées à l’activité personnalisée.It can be used to access extended properties associated with the custom activity. Consultez la section Accéder aux propriétés étendues pour plus d’informations.See Access extended properties for details.
  • logger.logger. Cet objet vous permet d’écrire des commentaires de débogage qui apparaîtront dans le journal utilisateur pour le pipeline.This object lets you write debug comments that surface in the user log for the pipeline.

La méthode retourne un dictionnaire qui peut être utilisé pour enchaîner ultérieurement des activités personnalisées.The method returns a dictionary that can be used to chain custom activities together in the future. Cette fonctionnalité n’étant pas encore implémentée, seul un dictionnaire vide est retourné par la méthode.This feature is not implemented yet, so return an empty dictionary from the method.

ProcédureProcedure

  1. Créez un projet de bibliothèque de classes .NET .Create a .NET Class Library project.

    1. Lancez Visual Studio.Launch Visual Studio.
    2. Cliquez sur Fichier, pointez le curseur de la souris sur Nouveau, puis cliquez sur Projet.Click File, point to New, and click Project.
    3. Développez Modèles, puis sélectionnez Visual C#.Expand Templates, and select Visual C#. Dans cette procédure pas à pas, vous utilisez C#, mais vous pouvez utiliser un autre langage .NET pour développer l’activité personnalisée.In this walkthrough, you use C#, but you can use any .NET language to develop the custom activity.
    4. Sélectionnez Bibliothèque de classes dans la liste des types de projet, sur la droite.Select Class Library from the list of project types on the right. Dans Visual Studio, choisissez Bibliothèque de classes (.NET Framework) .In Visual Studio, choose Class Library (.NET Framework)
    5. Entrez MyDotNetActivity for the Nom.Enter MyDotNetActivity for the Name.
    6. Sélectionnez C:\ADFGetStarted comme Emplacement.Select C:\ADFGetStarted for the Location.
    7. Cliquez sur OK pour créer le projet.Click OK to create the project.
  2. Cliquez sur Outils, pointez le curseur de la souris sur Gestionnaire de package NuGet, puis cliquez sur Console du gestionnaire de package.Click Tools, point to NuGet Package Manager, and click Package Manager Console.

  3. Dans la Console du gestionnaire de package, exécutez la commande suivante pour importer l’élément Microsoft.Azure.Management.DataFactories.In the Package Manager Console, execute the following command to import Microsoft.Azure.Management.DataFactories.

    Install-Package Microsoft.Azure.Management.DataFactories
    
  4. Importez le package NuGet Azure Storage dans le projet.Import the Azure Storage NuGet package in to the project.

    Install-Package WindowsAzure.Storage -Version 4.3.0
    

    Important

    Le lanceur du service Data Factory requiert la version 4.3 du package Windows Azure Storage.Data Factory service launcher requires the 4.3 version of WindowsAzure.Storage. Si vous ajoutez une référence à une version ultérieure de l’assembly Azure Storage à votre projet d’activité personnalisée, vous obtenez une erreur lors de l’exécution de l’activité.If you add a reference to a later version of Azure Storage assembly in your custom activity project, you see an error when the activity executes. Pour résoudre l’erreur, consultez la section Isolation du domaine d’application.To resolve the error, see Appdomain isolation section.

  5. Ajoutez les instructions using ci-après dans le fichier source du projet.Add the following using statements to the source file in the project.

    
    // Comment these lines if using VS 2017
    using System.IO;
    using System.Globalization;
    using System.Diagnostics;
    using System.Linq;
    // --------------------
    
    // Comment these lines if using <= VS 2015
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    // ---------------------
    
    using Microsoft.Azure.Management.DataFactories.Models;
    using Microsoft.Azure.Management.DataFactories.Runtime;
    
    using Microsoft.WindowsAzure.Storage;
    using Microsoft.WindowsAzure.Storage.Blob;
    
  6. Remplacez le nom de l’espace de noms par MyDotNetActivityNS.Change the name of the namespace to MyDotNetActivityNS.

    namespace MyDotNetActivityNS
    
  7. Remplacez le nom de la classe par MyDotNetActivity et dérivez-le de l’interface IDotNetActivity, comme indiqué dans l’extrait de code suivant :Change the name of the class to MyDotNetActivity and derive it from the IDotNetActivity interface as shown in the following code snippet:

    public class MyDotNetActivity : IDotNetActivity
    
  8. Implémentez (ajoutez) la méthode Execute de l’interface IDotNetActivity dans la classe MyDotNetActivity et copiez l’exemple de code suivant dans la méthode.Implement (Add) the Execute method of the IDotNetActivity interface to the MyDotNetActivity class and copy the following sample code to the method.

    L’exemple suivant compte le nombre d’occurrences du terme recherché (Microsoft) dans chaque objet blob associé à une tranche de données.The following sample counts the number of occurrences of the search term (“Microsoft”) in each blob associated with a data slice.

    /// <summary>
    /// Execute method is the only method of IDotNetActivity interface you must implement.
    /// In this sample, the method invokes the Calculate method to perform the core logic.
    /// </summary>
    
    public IDictionary<string, string> Execute(
        IEnumerable<LinkedService> linkedServices,
        IEnumerable<Dataset> datasets,
        Activity activity,
        IActivityLogger logger)
    {
        // get extended properties defined in activity JSON definition
        // (for example: SliceStart)
        DotNetActivity dotNetActivity = (DotNetActivity)activity.TypeProperties;
        string sliceStartString = dotNetActivity.ExtendedProperties["SliceStart"];
    
        // to log information, use the logger object
        // log all extended properties
        IDictionary<string, string> extendedProperties = dotNetActivity.ExtendedProperties;
        logger.Write("Logging extended properties if any...");
        foreach (KeyValuePair<string, string> entry in extendedProperties)
        {
            logger.Write("<key:{0}> <value:{1}>", entry.Key, entry.Value);
        }
    
        // linked service for input and output data stores
        // in this example, same storage is used for both input/output
        AzureStorageLinkedService inputLinkedService;
    
        // get the input dataset
        Dataset inputDataset = datasets.Single(dataset => dataset.Name == activity.Inputs.Single().Name);
    
        // declare variables to hold type properties of input/output datasets
        AzureBlobDataset inputTypeProperties, outputTypeProperties;
    
        // get type properties from the dataset object
        inputTypeProperties = inputDataset.Properties.TypeProperties as AzureBlobDataset;
    
        // log linked services passed in linkedServices parameter
        // you will see two linked services of type: AzureStorage
        // one for input dataset and the other for output dataset
        foreach (LinkedService ls in linkedServices)
            logger.Write("linkedService.Name {0}", ls.Name);
    
        // get the first Azure Storage linked service from linkedServices object
        // using First method instead of Single since we are using the same
        // Azure Storage linked service for input and output.
        inputLinkedService = linkedServices.First(
            linkedService =>
            linkedService.Name ==
            inputDataset.Properties.LinkedServiceName).Properties.TypeProperties
            as AzureStorageLinkedService;
    
        // get the connection string in the linked service
        string connectionString = inputLinkedService.ConnectionString;
    
        // get the folder path from the input dataset definition
        string folderPath = GetFolderPath(inputDataset);
        string output = string.Empty; // for use later.
    
        // create storage client for input. Pass the connection string.
        CloudStorageAccount inputStorageAccount = CloudStorageAccount.Parse(connectionString);
        CloudBlobClient inputClient = inputStorageAccount.CreateCloudBlobClient();
    
        // initialize the continuation token before using it in the do-while loop.
        BlobContinuationToken continuationToken = null;
        do
        {   // get the list of input blobs from the input storage client object.
            BlobResultSegment blobList = inputClient.ListBlobsSegmented(folderPath,
                                     true,
                                     BlobListingDetails.Metadata,
                                     null,
                                     continuationToken,
                                     null,
                                     null);
    
            // Calculate method returns the number of occurrences of
            // the search term (“Microsoft”) in each blob associated
            // with the data slice. definition of the method is shown in the next step.
    
            output = Calculate(blobList, logger, folderPath, ref continuationToken, "Microsoft");
    
        } while (continuationToken != null);
    
        // get the output dataset using the name of the dataset matched to a name in the Activity output collection.
        Dataset outputDataset = datasets.Single(dataset => dataset.Name == activity.Outputs.Single().Name);
    
        // get type properties for the output dataset
        outputTypeProperties = outputDataset.Properties.TypeProperties as AzureBlobDataset;
    
        // get the folder path from the output dataset definition
        folderPath = GetFolderPath(outputDataset);
    
        // log the output folder path
        logger.Write("Writing blob to the folder: {0}", folderPath);
    
        // create a storage object for the output blob.
        CloudStorageAccount outputStorageAccount = CloudStorageAccount.Parse(connectionString);
        // write the name of the file.
        Uri outputBlobUri = new Uri(outputStorageAccount.BlobEndpoint, folderPath + "/" + GetFileName(outputDataset));
    
        // log the output file name
        logger.Write("output blob URI: {0}", outputBlobUri.ToString());
    
        // create a blob and upload the output text.
        CloudBlockBlob outputBlob = new CloudBlockBlob(outputBlobUri, outputStorageAccount.Credentials);
        logger.Write("Writing {0} to the output blob", output);
        outputBlob.UploadText(output);
    
        // The dictionary can be used to chain custom activities together in the future.
        // This feature is not implemented yet, so just return an empty dictionary.
    
        return new Dictionary<string, string>();
    }
    
  9. Ajoutez les méthodes d’assistance suivantes :Add the following helper methods:

    /// <summary>
    /// Gets the folderPath value from the input/output dataset.
    /// </summary>
    
    private static string GetFolderPath(Dataset dataArtifact)
    {
        if (dataArtifact == null || dataArtifact.Properties == null)
        {
            return null;
        }
    
        // get type properties of the dataset
        AzureBlobDataset blobDataset = dataArtifact.Properties.TypeProperties as AzureBlobDataset;
        if (blobDataset == null)
        {
            return null;
        }
    
        // return the folder path found in the type properties
        return blobDataset.FolderPath;
    }
    
    /// <summary>
    /// Gets the fileName value from the input/output dataset.
    /// </summary>
    
    private static string GetFileName(Dataset dataArtifact)
    {
        if (dataArtifact == null || dataArtifact.Properties == null)
        {
            return null;
        }
    
        // get type properties of the dataset
        AzureBlobDataset blobDataset = dataArtifact.Properties.TypeProperties as AzureBlobDataset;
        if (blobDataset == null)
        {
            return null;
        }
    
        // return the blob/file name in the type properties
        return blobDataset.FileName;
    }
    
    /// <summary>
    /// Iterates through each blob (file) in the folder, counts the number of instances of search term in the file,
    /// and prepares the output text that is written to the output blob.
    /// </summary>
    
    public static string Calculate(BlobResultSegment Bresult, IActivityLogger logger, string folderPath, ref BlobContinuationToken token, string searchTerm)
    {
        string output = string.Empty;
        logger.Write("number of blobs found: {0}", Bresult.Results.Count<IListBlobItem>());
        foreach (IListBlobItem listBlobItem in Bresult.Results)
        {
            CloudBlockBlob inputBlob = listBlobItem as CloudBlockBlob;
            if ((inputBlob != null) && (inputBlob.Name.IndexOf("$$$.$$$") == -1))
            {
                string blobText = inputBlob.DownloadText(Encoding.ASCII, null, null, null);
                logger.Write("input blob text: {0}", blobText);
                string[] source = blobText.Split(new char[] { '.', '?', '!', ' ', ';', ':', ',' }, StringSplitOptions.RemoveEmptyEntries);
                var matchQuery = from word in source
                                 where word.ToLowerInvariant() == searchTerm.ToLowerInvariant()
                                 select word;
                int wordCount = matchQuery.Count();
                output += string.Format("{0} occurrences(s) of the search term \"{1}\" were found in the file {2}.\r\n", wordCount, searchTerm, inputBlob.Name);
            }
        }
        return output;
    }
    

    La méthode GetFolderPath renvoie le chemin d’accès au dossier vers lequel pointe le jeu de données et la méthode GetFileName renvoie le nom de l’objet blob/fichier vers lequel pointe le jeu de données.The GetFolderPath method returns the path to the folder that the dataset points to and the GetFileName method returns the name of the blob/file that the dataset points to. Si folderPath est défini avec des variables telles que {Year}, {Month}, {Day}, etc., la méthode retourne la chaîne en l’état, sans remplacer les variables par les valeurs d’exécution.If you have folderPath defines using variables such as {Year}, {Month}, {Day} etc., the method returns the string as it is without replacing them with runtime values. Consultez la section Accéder aux propriétés étendues pour plus d’informations sur l’accès à SliceStart, SliceEnd, etc.See Access extended properties section for details on accessing SliceStart, SliceEnd, etc.

    "name": "InputDataset",
    "properties": {
        "type": "AzureBlob",
        "linkedServiceName": "AzureStorageLinkedService",
        "typeProperties": {
            "fileName": "file.txt",
            "folderPath": "adftutorial/inputfolder/",
    

    La méthode Calculate calcule le nombre d’instances du mot-clé Microsoft dans les fichiers d’entrée (objets blob du dossier).The Calculate method calculates the number of instances of keyword Microsoft in the input files (blobs in the folder). Le terme de recherche (« Microsoft ») est codé en dur dans le code.The search term (“Microsoft”) is hard-coded in the code.

  10. Compilez le projet.Compile the project. Cliquez sur l’option Générer du menu, puis sur Générer la solution.Click Build from the menu and click Build Solution.

    Important

    Définissez la version 4.5.2 de .NET Framework comme infrastructure cible pour votre projet : cliquez avec le bouton droit sur le projet et cliquez sur Propriétés pour définir l’infrastructure cible.Set 4.5.2 version of .NET Framework as the target framework for your project: right-click the project, and click Properties to set the target framework. Data Factory ne prend pas en charge les activités personnalisées compilées avec les versions de .NET Framework ultérieures à la version 4.5.2.Data Factory does not support custom activities compiled against .NET Framework versions later than 4.5.2.

  11. Lancez l’Explorateur Windows et accédez au dossier bin\debug ou bin\release (selon le type de build).Launch Windows Explorer, and navigate to bin\debug or bin\release folder depending on the type of build.

  12. Créez un fichier zip MyDotNetActivity.zip contenant tous les fichiers binaires dans le <dossier projet>\bin\Debug.Create a zip file MyDotNetActivity.zip that contains all the binaries in the <project folder>\bin\Debug folder. Incluez le fichier MyDotNetActivity.pdb afin d’obtenir des détails supplémentaires tels que le numéro de ligne du code source à l’origine du problème en cas de défaillance.Include the MyDotNetActivity.pdb file so that you get additional details such as line number in the source code that caused the issue if there was a failure.

    Important

    Tous les fichiers contenus dans le fichier zip de l’activité personnalisée doivent se trouver au premier niveau et ne doivent pas contenir de sous-dossiers.All the files in the zip file for the custom activity must be at the top level with no sub folders.

    Fichiers de sortie binaires

  13. Si nécessaire, créez un conteneur de blobs nommé customactivitycontainer.Create a blob container named customactivitycontainer if it does not already exist.

  14. Chargez MyDotNetActivity.zip en tant qu’objet blob dans le customactivitycontainer dans un compte Stockage Blob Azure à usage général (pas un Stockage Blob chaud/froid) référencé par AzureStorageLinkedService.Upload MyDotNetActivity.zip as a blob to the customactivitycontainer in a general-purpose Azure blob storage (not hot/cool Blob storage) that is referred by AzureStorageLinkedService.

Important

Si vous ajoutez ce projet d’activité .NET à une solution dans Visual Studio qui contient un projet Data Factory, et que vous ajoutez une référence au projet d’activité .NET à partir du projet d’application Data Factory, vous n’avez pas besoin d’effectuer les deux dernières étapes pour créer manuellement le fichier zip et le télécharger dans le stockage Blob Azure à usage général.If you add this .NET activity project to a solution in Visual Studio that contains a Data Factory project, and add a reference to .NET activity project from the Data Factory application project, you do not need to perform the last two steps of manually creating the zip file and uploading it to the general-purpose Azure blob storage. Lorsque vous publiez des entités Data Factory à l'aide de Visual Studio, ces étapes sont effectuées automatiquement par le processus de publication.When you publish Data Factory entities using Visual Studio, these steps are automatically done by the publishing process. Pour plus d’informations, consultez la section Projet Data Factory dans Visual Studio.For more information, see Data Factory project in Visual Studio section.

Créer un pipeline avec une activité personnaliséeCreate a pipeline with custom activity

Vous avez créé une activité personnalisée et chargé le fichier zip avec des fichiers binaires dans un conteneur de blobs dans un compte de stockage Azure à usage général.You have created a custom activity and uploaded the zip file with binaries to a blob container in a general-purpose Azure Storage Account. Dans cette section, vous allez créer une fabrique de données Azure avec un pipeline qui utilise l’activité personnalisée.In this section, you create an Azure data factory with a pipeline that uses the custom activity.

Le jeu de données d’entrée de l’activité personnalisée représente les blobs (fichiers) contenus dans le dossier customactivityinput du conteneur adftutorial dans le stockage Blob.The input dataset for the custom activity represents blobs (files) in the customactivityinput folder of adftutorial container in the blob storage. Le jeu de données de sortie de l’activité représente les blobs de sortie contenus dans le dossier customactivityoutput du conteneur adftutorial dans le stockage Blob.The output dataset for the activity represents output blobs in the customactivityoutput folder of adftutorial container in the blob storage.

Créez le fichier file.txt avec le contenu suivant, puis chargez-le dans le dossier customactivityinput du conteneur adftutorial.Create file.txt file with the following content and upload it to customactivityinput folder of the adftutorial container. S’il n’existe pas déjà, créez le conteneur adftutorial.Create the adftutorial container if it does not exist already.

test custom activity Microsoft test custom activity Microsoft

Le dossier d’entrée correspond à une tranche dans Azure Data Factory, même si le dossier contient au moins deux fichiers.The input folder corresponds to a slice in Azure Data Factory even if the folder has two or more files. Lorsque chaque tranche est traitée par le pipeline, l’activité personnalisée effectue une itération dans tous les objets blob du dossier d’entrée pour la tranche en question.When each slice is processed by the pipeline, the custom activity iterates through all the blobs in the input folder for that slice.

Un fichier de sortie à une ou plusieurs lignes (le même nombre de lignes que le nombre de blobs contenus dans le dossier d’entrée) apparaîtra dans le dossier adftutorial\customactivityoutput :You see one output file with in the adftutorial\customactivityoutput folder with one or more lines (same as number of blobs in the input folder):

2 occurrences(s) of the search term "Microsoft" were found in the file inputfolder/2016-11-16-00/file.txt.

Voici les étapes que vous effectuez dans cette section :Here are the steps you perform in this section:

  1. Création d'une fabrique de données.Create a data factory.
  2. Créez des services liés pour le pool Azure Batch de machines virtuelles sur lesquelles l’activité personnalisée doit être exécutée et le stockage Azure qui contient les blobs d’entrée et de sortie.Create Linked services for the Azure Batch pool of VMs on which the custom activity runs and the Azure Storage that holds the input/output blobs.
  3. Créez des jeux de données d’entrée et de sortie qui représentent les entrées/sorties de l’activité personnalisée.Create input and output datasets that represent input and output of the custom activity.
  4. Créez un pipeline qui utilise l’activité personnalisée.Create a pipeline that uses the custom activity.

Notes

Créez le fichier file.txt et chargez-le dans un conteneur d’objets blob, si vous ne l’avez pas déjà fait.Create the file.txt and upload it to a blob container if you haven't already done so. Consultez les instructions fournies dans la section précédente.See instructions in the preceding section.

Étape 1 : Création de la fabrique de donnéesStep 1: Create the data factory

  1. Une fois connecté au portail Azure, procédez comme suit :After logging in to the Azure portal, do the following steps:

    1. Dans le menu de gauche, sélectionnez Créer une ressource.Click Create a resource on the left menu.

    2. Dans le panneau Nouveau, cliquez sur Données et analyses.Click Data + Analytics in the New blade.

    3. Cliquez sur Data Factory dans le panneau Analyse des données.Click Data Factory on the Data analytics blade.

      Nouveau menu Azure Data Factory

  2. Dans le panneau Nouvelle fabrique de données, spécifiez le nom CustomActivityFactory.In the New data factory blade, enter CustomActivityFactory for the Name. Le nom de la fabrique de données Azure doit être un nom global unique.The name of the Azure data factory must be globally unique. Si vous recevez le message d’erreur : Data factory name “CustomActivityFactory” is not available (Le nom de la fabrique de données « CustomActivityFactory » n’est pas disponible), changez le nom de la fabrique de données (par exemple, votrenomCustomActivityFactory), puis tentez de la recréer.If you receive the error: Data factory name “CustomActivityFactory” is not available, change the name of the data factory (for example, yournameCustomActivityFactory) and try creating again.

    Nouveau panneau Azure Data Factory

  3. Cliquez sur NOM DU GROUPE DE RESSOURCESpour sélectionner un groupe de ressources existant, ou créez un groupe de ressources.Click RESOURCE GROUP NAME, and select an existing resource group or create a resource group.

  4. Veillez à utiliser l’abonnement et la région correspondant à ceux dans lesquels vous voulez créer la fabrique de données.Verify that you are using the correct subscription and region where you want the data factory to be created.

  5. Cliquez sur Créer dans le panneau Nouvelle fabrique de données.Click Create on the New data factory blade.

  6. La fabrique de données apparaît comme étant en cours de création dans le Tableau de bord du portail Azure.You see the data factory being created in the Dashboard of the Azure portal.

  7. Une fois la fabrique de données créée, son contenu apparaîtra dans le panneau correspondant indiquant.After the data factory has been created successfully, you see the Data Factory blade, which shows you the contents of the data factory.

    Panneau Data Factory

Étape 2 : Créez des services liésStep 2: Create linked services

Les services liés se chargent de lier des magasins de données ou des services de calcul à une fabrique de données Azure.Linked services link data stores or compute services to an Azure data factory. Dans cette étape, vous allez lier vos comptes Stockage Azure et Azure Batch à votre fabrique de données.In this step, you link your Azure Storage account and Azure Batch account to your data factory.

Créer le service lié Stockage AzureCreate Azure Storage linked service

  1. Cliquez sur la vignette Créer et déployer dans le panneau DATA FACTORY de CustomActivityFactory.Click the Author and deploy tile on the DATA FACTORY blade for CustomActivityFactory. Data Factory Editor s’affiche.You see the Data Factory Editor.

  2. Cliquez sur Nouvelle banque de données dans la barre de commandes et choisissez Stockage Azure.Click New data store on the command bar and choose Azure storage. Le script JSON de création d’un service lié Stockage Microsoft Azure doit apparaître dans l’éditeur.You should see the JSON script for creating an Azure Storage linked service in the editor.

    Nouveau magasin de données - Stockage Azure

  3. Remplacez <accountname> par le nom de votre compte de stockage Azure et <accountkey> par la clé d’accès du compte de stockage Azure.Replace <accountname> with name of your Azure storage account and <accountkey> with access key of the Azure storage account. Pour savoir comment obtenir votre clé d’accès de stockage, voir Affichage, copie et régénération de clés d’accès de stockage.To learn how to get your storage access key, see View, copy and regenerate storage access keys.

    Service lié Stockage Azure

  4. Cliquez sur l’option Déployer de la barre de commandes pour déployer le service lié.Click Deploy on the command bar to deploy the linked service.

Créer un service lié Azure BatchCreate Azure Batch linked service

  1. Dans Data Factory Editor, dans la barre d’outils, cliquez sur ... Plus dans la barre de commandes, cliquez sur Nouveau calcul, puis sélectionnez Azure Batch dans le menu.In the Data Factory Editor, click ... More on the command bar, click New compute, and then select Azure Batch from the menu.

    Nouveau calcul - Azure Batch

  2. Apportez les modifications suivantes au script JSON :Make the following changes to the JSON script:

    1. Spécifiez le nom du compte Azure Batch pour la propriété accountName .Specify Azure Batch account name for the accountName property. L’URL dans le panneau du compte Azure Batch est au format suivant : http://accountname.region.batch.azure.com.The URL from the Azure Batch account blade is in the following format: http://accountname.region.batch.azure.com. Pour la propriété batchUri dans le JSON, vous devez supprimer accountname. de l’URL et utiliser accountname pour la propriété JSON accountName.For the batchUri property in the JSON, you need to remove accountname. from the URL and use the accountname for the accountName JSON property.

    2. Spécifiez la clé du compte Azure Batch pour la propriété accessKey .Specify the Azure Batch account key for the accessKey property.

    3. Spécifiez le nom du pool que vous avez créé dans le cadre de la configuration requise pour la propriété poolName .Specify the name of the pool you created as part of prerequisites for the poolName property. Vous pouvez aussi spécifier l’ID du pool au lieu du nom du pool.You can also specify the ID of the pool instead of the name of the pool.

    4. Spécifiez l’URI Azure Batch pour la propriété batchUri .Specify Azure Batch URI for the batchUri property. Exemple : https://westus.batch.azure.com.Example: https://westus.batch.azure.com.

    5. Spécifiez AzureStorageLinkedService for the linkedServiceName .Specify the AzureStorageLinkedService for the linkedServiceName property.

      {
        "name": "AzureBatchLinkedService",
        "properties": {
          "type": "AzureBatch",
          "typeProperties": {
            "accountName": "myazurebatchaccount",
            "batchUri": "https://westus.batch.azure.com",
            "accessKey": "<yourbatchaccountkey>",
            "poolName": "myazurebatchpool",
            "linkedServiceName": "AzureStorageLinkedService"
          }
        }
      }
      

      Pour la propriété poolName , vous pouvez également spécifier l’ID du pool au lieu du nom du pool.For the poolName property, you can also specify the ID of the pool instead of the name of the pool.

Étape 3 : Créez les jeux de donnéesStep 3: Create datasets

Dans cette étape, vous allez créer des jeux de données pour représenter les données d’entrée et de sortie.In this step, you create datasets to represent input and output data.

Créer le jeu de données d’entréeCreate input dataset

  1. Dans l’éditeur de la fabrique de données, cliquez sur ... Plus dans la barre de commandes, cliquez sur Nouveau jeu de données, puis sélectionnez Stockage Blob Azure dans le menu déroulant.In the Editor for the Data Factory, click ... More on the command bar, click New dataset, and then select Azure Blob storage from the drop-down menu.

  2. Remplacez le script JSON affiché dans le volet droit par l’extrait de code JSON suivant :Replace the JSON in the right pane with the following JSON snippet:

    {
        "name": "InputDataset",
        "properties": {
            "type": "AzureBlob",
            "linkedServiceName": "AzureStorageLinkedService",
            "typeProperties": {
                "folderPath": "adftutorial/customactivityinput/",
                "format": {
                    "type": "TextFormat"
                }
            },
            "availability": {
                "frequency": "Hour",
                "interval": 1
            },
            "external": true,
            "policy": {}
        }
    }
    

    Vous créerez un pipeline plus loin dans cette procédure pas à pas avec comme heure de début : 2016-11-16T00:00:00Z et comme heure de fin : 2016-11-16T05:00:00Z.You create a pipeline later in this walkthrough with start time: 2016-11-16T00:00:00Z and end time: 2016-11-16T05:00:00Z. Ce pipeline est planifié pour produire des données toutes les heures, ce qui signifie que l’on obtient cinq tranches d’entrée/sortie comprises entre 00:00:00 -> 05:00:00.It is scheduled to produce data hourly, so there are five input/output slices (between 00:00:00 -> 05:00:00).

    Les paramètres frequency et interval du jeu de données d’entrée sont respectivement définis sur Hour et sur 1, ce qui signifie que la tranche d’entrée est disponible toutes les heures.The frequency and interval for the input dataset is set to Hour and 1, which means that the input slice is available hourly. Dans cet exemple, il s’agit du même fichier (file.txt) que celui contenu dans le dossier d’entrée.In this sample, it is the same file (file.txt) in the intputfolder.

    Voici les heures de début de chaque tranche, chacune étant représentée par la variable système SliceStart dans l’extrait de code JSON ci-dessus.Here are the start times for each slice, which is represented by SliceStart system variable in the above JSON snippet.

  3. Cliquez sur Déployer sur la barre d’outils pour créer et déployer le jeu de données d’entrée.Click Deploy on the toolbar to create and deploy the InputDataset. Vérifiez que le message TABLE CORRECTEMENT CRÉÉE s’affiche dans la barre de titre de l’éditeur.Confirm that you see the TABLE CREATED SUCCESSFULLY message on the title bar of the Editor.

Créer un jeu de données de sortieCreate an output dataset

  1. Dans Data Factory Editor, cliquez sur ... Plus dans la barre de commandes, cliquez sur Nouveau jeu de données, puis sélectionnez Stockage Blob Azure.In the Data Factory editor, click ... More on the command bar, click New dataset, and then select Azure Blob storage.

  2. Remplacez le script JSON affiché dans le volet droit par le script JSON suivant :Replace the JSON script in the right pane with the following JSON script:

    {
        "name": "OutputDataset",
        "properties": {
            "type": "AzureBlob",
            "linkedServiceName": "AzureStorageLinkedService",
            "typeProperties": {
                "fileName": "{slice}.txt",
                "folderPath": "adftutorial/customactivityoutput/",
                "partitionedBy": [
                    {
                        "name": "slice",
                        "value": {
                            "type": "DateTime",
                            "date": "SliceStart",
                            "format": "yyyy-MM-dd-HH"
                        }
                    }
                ]
            },
            "availability": {
                "frequency": "Hour",
                "interval": 1
            }
        }
    }
    

    L’emplacement de sortie est le suivant : adftutorial/customactivityoutput/ et le nom du fichier de sortie est aaaa-MM-dd-HH.txt, où « aaaa-MM-dd-HH.txt » correspond à l’année, au mois, au jour et à l’heure de la tranche produite.Output location is adftutorial/customactivityoutput/ and output file name is yyyy-MM-dd-HH.txt where yyyy-MM-dd-HH is the year, month, date, and hour of the slice being produced. Pour en savoir plus, consultez la page Référence du développeur.See Developer Reference for details.

    Un objet blob/fichier de sortie est généré pour chaque tranche d’entrée.An output blob/file is generated for each input slice. Voici la procédure de nommage des fichiers de sortie pour chaque tranche.Here is how an output file is named for each slice. Tous les fichiers de sortie sont générés dans un seul dossier de sortie : adftutorial\customactivityoutput.All the output files are generated in one output folder: adftutorial\customactivityoutput.

    TrancheSlice Heure de débutStart time Fichier de sortieOutput file
    11 2016-11-16T00:00:002016-11-16T00:00:00 2016-11-16-00.txt2016-11-16-00.txt
    22 2016-11-16T01:00:002016-11-16T01:00:00 2016-11-16-01.txt2016-11-16-01.txt
    33 2016-11-16T02:00:002016-11-16T02:00:00 2016-11-16-02.txt2016-11-16-02.txt
    44 2016-11-16T03:00:002016-11-16T03:00:00 2016-11-16-03.txt2016-11-16-03.txt
    5.5 2016-11-16T04:00:002016-11-16T04:00:00 2016-11-16-04.txt2016-11-16-04.txt

    N’oubliez pas que tous les fichiers d’un dossier d’entrée font partie d’une tranche associée aux heures de début indiquées ci-dessus.Remember that all the files in an input folder are part of a slice with the start times mentioned above. Lorsque cette tranche est traitée, l’activité personnalisée parcourt chaque fichier et génère une ligne dans le fichier de sortie avec le nombre d’occurrences du terme de recherche (« Microsoft »).When this slice is processed, the custom activity scans through each file and produces a line in the output file with the number of occurrences of search term (“Microsoft”). Si le dossier d’entrée comporte trois fichiers, trois lignes apparaissent dans le fichier de sortie pour chaque tranche horaire : 2016-11-16-00.txt, 2016-11-16:01:00:00.txt, et ainsi de suite.If there are three files in the inputfolder, there are three lines in the output file for each hourly slice: 2016-11-16-00.txt, 2016-11-16:01:00:00.txt, etc.

  3. Cliquez sur Déployer dans la barre de commandes pour déployer le jeu de données de sortie.To deploy the OutputDataset, click Deploy on the command bar.

Créer et exécuter un pipeline qui utilise l’activité personnaliséeCreate and run a pipeline that uses the custom activity

  1. Dans Data Factory Editor, dans la barre d’outils, cliquez sur ... Plus, puis sélectionnez Nouveau pipeline dans la barre de commandes.In the Data Factory Editor, click ... More, and then select New pipeline on the command bar.

  2. Remplacez le script JSON affiché dans le volet droit par le script JSON suivant :Replace the JSON in the right pane with the following JSON script:

    {
      "name": "ADFTutorialPipelineCustom",
      "properties": {
        "description": "Use custom activity",
        "activities": [
          {
            "Name": "MyDotNetActivity",
            "Type": "DotNetActivity",
            "Inputs": [
              {
                "Name": "InputDataset"
              }
            ],
            "Outputs": [
              {
                "Name": "OutputDataset"
              }
            ],
            "LinkedServiceName": "AzureBatchLinkedService",
            "typeProperties": {
              "AssemblyName": "MyDotNetActivity.dll",
              "EntryPoint": "MyDotNetActivityNS.MyDotNetActivity",
              "PackageLinkedService": "AzureStorageLinkedService",
              "PackageFile": "customactivitycontainer/MyDotNetActivity.zip",
              "extendedProperties": {
                "SliceStart": "$$Text.Format('{0:yyyyMMddHH-mm}', Time.AddMinutes(SliceStart, 0))"
              }
            },
            "Policy": {
              "Concurrency": 2,
              "ExecutionPriorityOrder": "OldestFirst",
              "Retry": 3,
              "Timeout": "00:30:00",
              "Delay": "00:00:00"
            }
          }
        ],
        "start": "2016-11-16T00:00:00Z",
        "end": "2016-11-16T05:00:00Z",
        "isPaused": false
      }
    }
    

    Notez les points suivants :Note the following points:

    • Concurrency est défini sur 2 pour que les deux tranches soient traitées en parallèle sur 2 machines virtuelles dans le pool Azure Batch.Concurrency is set to 2 so that two slices are processed in parallel by 2 VMs in the Azure Batch pool.
    • Il existe une activité dans la section des activités ; elle est du type suivant : DotNetActivity.There is one activity in the activities section and it is of type: DotNetActivity.
    • AssemblyName est défini sur le nom de la DLL : MyDotnetActivity.dll.AssemblyName is set to the name of the DLL: MyDotnetActivity.dll.
    • Le paramètre EntryPoint est défini sur MyDotNetActivityNS.MyDotNetActivity.EntryPoint is set to MyDotNetActivityNS.MyDotNetActivity.
    • PackageLinkedService est défini sur AzureStorageLinkedService, qui pointe vers le stockage d’objets blob contenant le fichier .zip de l’activité personnalisée.PackageLinkedService is set to AzureStorageLinkedService that points to the blob storage that contains the custom activity zip file. Si vous utilisez des comptes de stockage différents pour les fichiers d’entrée/sortie et le fichier zip de l’activité personnalisée, vous créez un autre service lié Stockage Azure.If you are using different Azure Storage accounts for input/output files and the custom activity zip file, you create another Azure Storage linked service. Cet article suppose que vous utilisez le même compte Stockage Azure.This article assumes that you are using the same Azure Storage account.
    • Le paramètre PackageFile est défini sur customactivitycontainer/MyDotNetActivity.zip.PackageFile is set to customactivitycontainer/MyDotNetActivity.zip. Il est au format : conteneur_du_zip/nom_du_zip.zip.It is in the format: containerforthezip/nameofthezip.zip.
    • L’activité personnalisée utilise InputDataset comme entrée et OutputDataset comme sortie.The custom activity takes InputDataset as input and OutputDataset as output.
    • La propriété linkedServiceName de l’activité personnalisée pointe vers AzureBatchLinkedService, ce qui indique à Azure Data Factory que l’activité personnalisée doit s’exécuter sur des machines virtuelles Azure Batch.The linkedServiceName property of the custom activity points to the AzureBatchLinkedService, which tells Azure Data Factory that the custom activity needs to run on Azure Batch VMs.
    • La propriété isPaused est définie sur false.isPaused property is set to false by default. Le pipeline s’exécute immédiatement dans cet exemple car les tranches débutent à une date antérieure.The pipeline runs immediately in this example because the slices start in the past. Vous pouvez définir cette propriété sur true pour suspendre le pipeline et lui réaffecter la valeur false pour reprendre l’exécution.You can set this property to true to pause the pipeline and set it back to false to restart.
    • Cinq heures séparent les heures de début et de fin, et les tranches sont produites toutes les heures, ce qui signifie que cinq tranches sont produites par le pipeline.The start time and end times are five hours apart and slices are produced hourly, so five slices are produced by the pipeline.
  3. Cliquez sur Déployer dans la barre de commandes pour déployer le pipeline.To deploy the pipeline, click Deploy on the command bar.

Surveiller le pipelineMonitor the pipeline

  1. Dans le panneau Data Factory du portail Azure, cliquez sur Diagramme.In the Data Factory blade in the Azure portal, click Diagram.

    Vignette de diagramme

  2. Dans la vue de diagramme, cliquez sur OutputDataset.In the Diagram View, now click the OutputDataset.

    Vue schématique

  3. Les cinq tranches de sortie doivent être à l’état Prêt.You should see that the five output slices are in the Ready state. Dans le cas contraire, cela signifie qu’elles n’ont pas encore été générées.If they are not in the Ready state, they haven't been produced yet.

    Tranches de sortie

  4. Vérifiez que les fichiers de sortie sont générés dans le stockage d’objets blob, dans le conteneur adftutorial .Verify that the output files are generated in the blob storage in the adftutorial container.

    Sortie de l’activité personnalisée

  5. Si vous ouvrez le fichier de sortie, la sortie doit avoir l’aspect suivant :If you open the output file, you should see the output similar to the following output:

    2 occurrences(s) of the search term "Microsoft" were found in the file inputfolder/2016-11-16-00/file.txt.
    
  6. Utilisez le portail Azure ou les applets de commande Azure PowerShell pour surveiller votre fabrique de données, pipelines et jeux de données.Use the Azure portal or Azure PowerShell cmdlets to monitor your data factory, pipelines, and data sets. Vous pouvez voir les messages de l’outil ActivityLogger dans le code concernant l’activité personnalisée dans les journaux d’activité (plus précisément, user-0.log) que vous pouvez télécharger à partir du portail ou à l’aide d’applets de commande.You can see messages from the ActivityLogger in the code for the custom activity in the logs (specifically user-0.log) that you can download from the portal or using cmdlets.

    Téléchargement des journaux d’activités personnalisées

Pour découvrir la procédure détaillée de surveillance des jeux de données et des pipelines, consultez l’article Surveiller et gérer les pipelines .See Monitor and Manage Pipelines for detailed steps for monitoring datasets and pipelines.

Projet Data Factory dans Visual StudioData Factory project in Visual Studio

Vous pouvez créer et publier des entités Data Factory à l’aide de Visual Studio au lieu d’utiliser le portail Azure.You can create and publish Data Factory entities by using Visual Studio instead of using Azure portal. Pour en savoir plus sur la création et la publication d’entités Data Factory à l’aide de Visual Studio, consultez Créer votre premier pipeline à l’aide de Visual Studio et Copier des données à partir d’un objet blob Azure vers SQL Azure.For detailed information about creating and publishing Data Factory entities by using Visual Studio, See Build your first pipeline using Visual Studio and Copy data from Azure Blob to Azure SQL articles.

Si vous créez un projet Data Factory dans Visual Studio, suivez les étapes supplémentaires ci-dessous :Do the following additional steps if you are creating Data Factory project in Visual Studio:

  1. Ajoutez le projet Data Factory à la solution Visual Studio qui contient le projet d’activité personnalisée.Add the Data Factory project to the Visual Studio solution that contains the custom activity project.

  2. Ajoutez une référence au projet d’activité .NET à partir du projet Data Factory.Add a reference to the .NET activity project from the Data Factory project. Cliquez avec le bouton droit sur le projet Data Factory, pointez sur Ajouter, puis cliquez sur Référence.Right-click Data Factory project, point to Add, and then click Reference.

  3. Dans la boîte de dialogue Ajouter une référence, sélectionnez le projet MyDotNetActivity, puis cliquez sur OK.In the Add Reference dialog box, select the MyDotNetActivity project, and click OK.

  4. Créez et publiez la solution.Build and publish the solution.

    Important

    Lorsque vous publiez des entités Data Factory, un fichier zip est automatiquement créé pour vous et chargé vers le conteneur d’objets blob customactivitycontainer.When you publish Data Factory entities, a zip file is automatically created for you and is uploaded to the blob container: customactivitycontainer. Si le conteneur n’existe pas, il est également créé automatiquement.If the blob container does not exist, it is automatically created too.

Intégration de Data Factory et BatchData Factory and Batch integration

Le service Data Factory crée un travail dans Azure Batch sous le nom adf-poolname:job-xxx.The Data Factory service creates a job in Azure Batch with the name: adf-poolname: job-xxx. Cliquez sur Travaux dans le menu de gauche.Click Jobs from the left menu.

Azure Data Factory - Travaux Batch

Une tâche est créée pour chaque exécution d’activité d’une tranche.A task is created for each activity run of a slice. Si cinq tranches sont prêtes à être traitées, cinq tâches seront créées dans ce travail.If there are five slices ready to be processed, five tasks are created in this job. S’il existe plusieurs nœuds de calcul dans le pool Batch, deux tranches ou plus peuvent s’exécuter en parallèle.If there are multiple compute nodes in the Batch pool, two or more slices can run in parallel. Vous pouvez également avoir plusieurs tranches exécutées sur le même nœud de calcul si le nombre maximum de tâches par nœud de calcul est défini sur une valeur supérieure à 1.If the maximum tasks per compute node is set to > 1, you can also have more than one slice running on the same compute.

Azure Data Factory - Tâches de travaux Batch

Le diagramme suivant illustre la relation entre les tâches Azure Data Factory et les tâches Batch.The following diagram illustrates the relationship between Azure Data Factory and Batch tasks.

Data Factory et Batch

Résoudre les défaillancesTroubleshoot failures

Quelques techniques de base peuvent être utilisées pour résoudre les défaillances :Troubleshooting consists of a few basic techniques:

  1. Si vous voyez l’erreur suivante, vous utilisez peut-être un stockage Blob chaud/froid plutôt qu’un stockage Blob Azure à usage général.If you see the following error, you may be using a Hot/Cool blob storage instead of using a general-purpose Azure blob storage. Chargez le fichier zip dans un compte de stockage Blob Azure à usage général.Upload the zip file to a general-purpose Azure Storage Account.

    Error in Activity: Job encountered scheduling error. Code: BlobDownloadMiscError Category: ServerError Message: Miscellaneous error encountered while downloading one of the specified Azure Blob(s).
    
  2. Si vous voyez l’erreur suivante, confirmez que le nom de la classe figurant dans le fichier CS correspond au nom que vous avez spécifié pour la propriété EntryPoint dans le JSON du pipeline.If you see the following error, confirm that the name of the class in the CS file matches the name you specified for the EntryPoint property in the pipeline JSON. Dans la procédure pas à pas, le nom de la classe est : MyDotNetActivity et le point d’entrée dans le JSON est : MyDotNetActivityNS.MyDotNetActivity.In the walkthrough, name of the class is: MyDotNetActivity, and the EntryPoint in the JSON is: MyDotNetActivityNS.MyDotNetActivity.

    MyDotNetActivity assembly does not exist or doesn't implement the type Microsoft.DataFactories.Runtime.IDotNetActivity properly
    

    Si les noms ne correspondent pas, vérifiez que tous les fichiers binaires se trouvent dans le dossier racine du fichier zip.If the names do match, confirm that all the binaries are in the root folder of the zip file. Autrement dit, lorsque vous ouvrez le fichier .zip, vous devez voir tous les fichiers dans le dossier racine, et non dans les sous-dossiers.That is, when you open the zip file, you should see all the files in the root folder, not in any sub folders.

  3. Si la tranche d’entrée n’est pas définie sur Prêt, vérifiez que la structure du dossier d’entrée est correcte et que le fichier file.txt est présent dans les dossiers d’entrée.If the input slice is not set to Ready, confirm that the input folder structure is correct and file.txt exists in the input folders.

  4. Dans la méthode Execute de votre activité personnalisée, utilisez l’objet IActivityLogger pour journaliser les informations qui vous aident à résoudre d’éventuels problèmes.In the Execute method of your custom activity, use the IActivityLogger object to log information that helps you troubleshoot issues. Les messages enregistrés s’affichent dans les fichiers journaux utilisateur (un ou plusieurs fichiers nommés user-0.log, user-1.log, user-2.log, etc.).The logged messages show up in the user log files (one or more files named: user-0.log, user-1.log, user-2.log, etc.).

    Dans le panneau OutputDataset, cliquez sur la tranche pour afficher le panneau TRANCHE DE DONNÉES correspondant à cette tranche.In the OutputDataset blade, click the slice to see the DATA SLICE blade for that slice. Les activités exécutées pour cette tranche s’affichent.You see activity runs for that slice. Vous devez normalement voir une exécution d’activité pour la tranche.You should see one activity run for the slice. Si vous cliquez sur Exécuter dans la barre de commandes, vous pouvez démarrer une autre exécution d’activité pour la même tranche.If you click Run in the command bar, you can start another activity run for the same slice.

    Lorsque vous cliquez sur l’exécution d’activité, le panneau DÉTAILS DE L’EXÉCUTION D’ACTIVITÉ s’affiche avec une liste de fichiers journaux.When you click the activity run, you see the ACTIVITY RUN DETAILS blade with a list of log files. Les messages consignés s’afficheront dans le fichier user_0.log.You see logged messages in the user_0.log file. Lorsqu’une erreur se produit, vous verrez trois exécutions d’activité car le nombre de tentatives est défini sur 3 dans le script JSON du pipeline et de l’activité.When an error occurs, you see three activity runs because the retry count is set to 3 in the pipeline/activity JSON. Lorsque vous cliquez sur l’exécution de l’activité, vous accédez aux fichiers journaux qui vous permettront de résoudre l’erreur.When you click the activity run, you see the log files that you can review to troubleshoot the error.

    Dans la liste des fichiers journaux, cliquez sur le fichier user-0.log.In the list of log files, click the user-0.log. Le volet droit affiche les résultats de l’utilisation de la méthode IActivityLogger.Write .In the right panel are the results of using the IActivityLogger.Write method. Si vous ne voyez pas tous les messages, vérifiez si vous avez plusieurs fichiers journaux nommés user_1.log, user_2.log, etc. Si ce n’est pas le cas, le code peut avoir échoué après le dernier message enregistré.If you don't see all messages, check if you have more log files named: user_1.log, user_2.log etc. Otherwise, the code may have failed after the last logged message.

    En outre, consultez system-0.log pour vérifier les exceptions et messages d’erreur système éventuels.In addition, check system-0.log for any system error messages and exceptions.

  5. Incluez le fichier PDB dans le fichier zip afin que les détails de l’erreur incluent des informations telles que la pile des appels quand une erreur se produit.Include the PDB file in the zip file so that the error details have information such as call stack when an error occurs.

  6. Tous les fichiers contenus dans le fichier zip de l’activité personnalisée doivent se trouver au premier niveau et ne doivent pas contenir de sous-dossiers.All the files in the zip file for the custom activity must be at the top level with no sub folders.

  7. Assurez-vous que les paramètres assemblyName (MyDotNetActivity.dll), entryPoint (MyDotNetActivityNS.MyDotNetActivity), packageFile (customactivitycontainer/Mydotnetactivity.zip) et packageLinkedService (qui doit pointer vers le Stockage Blob Azure à usage général contenant le fichier .zip) sont définis sur des valeurs correctes.Ensure that the assemblyName (MyDotNetActivity.dll), entryPoint(MyDotNetActivityNS.MyDotNetActivity), packageFile (customactivitycontainer/MyDotNetActivity.zip), and packageLinkedService (should point to the general-purposeAzure blob storage that contains the zip file) are set to correct values.

  8. Si vous avez corrigé une erreur et souhaitez relancer le traitement de la tranche, cliquez avec le bouton droit sur la tranche dans le panneau OutputDataset puis cliquez sur Exécuter.If you fixed an error and want to reprocess the slice, right-click the slice in the OutputDataset blade and click Run.

  9. Si vous voyez l’erreur suivante, vous utilisez une version du package Stockage Azure supérieure à 4.3.0.If you see the following error, you are using the Azure Storage package of version > 4.3.0. Le lanceur du service Data Factory requiert la version 4.3 du package Windows Azure Storage.Data Factory service launcher requires the 4.3 version of WindowsAzure.Storage. Consultez la section Isolation du domaine d’application pour obtenir une autre solution si vous devez utiliser la dernière version de l’assembly du stockage Azure.See Appdomain isolation section for a work-around if you must use the later version of Azure Storage assembly.

    Error in Activity: Unknown error in module: System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation. ---> System.TypeLoadException: Could not load type 'Microsoft.WindowsAzure.Storage.Blob.CloudBlob' from assembly 'Microsoft.WindowsAzure.Storage, Version=4.3.0.0, Culture=neutral,
    

    Si vous pouvez utiliser la version 4.3.0 du package du stockage Azure, supprimez la référence existante à la version supérieure à 4.3.0 du package du stockage Azure.If you can use the 4.3.0 version of Azure Storage package, remove the existing reference to Azure Storage package of version > 4.3.0. Exécutez ensuite la commande suivante à partir de la console du gestionnaire de package NuGet.Then, run the following command from NuGet Package Manager Console.

    Install-Package WindowsAzure.Storage -Version 4.3.0
    

    Créez le projet.Build the project. Supprimez la version supérieure à 4.3.0 de l'assembly Stockage Azure du dossier bin/Debug.Delete Azure.Storage assembly of version > 4.3.0 from the bin\Debug folder. Créez un fichier zip avec les fichiers binaires et le fichier PDB.Create a zip file with binaries and the PDB file. Remplacez l’ancien fichier zip par celui-ci dans le conteneur d’objets blob (customactivitycontainer).Replace the old zip file with this one in the blob container (customactivitycontainer). Exécutez de nouveau les tranches ayant échoué (en cliquant avec le bouton droit sur la tranche, puis en choisissant Exécuter).Rerun the slices that failed (right-click slice, and click Run).

  10. L’activité personnalisée n’utilise pas le ficher app.config de votre package.The custom activity does not use the app.config file from your package. Par conséquent, si votre code lit des chaînes de connexion dans le fichier de configuration, il ne fonctionne pas lors de l’exécution.Therefore, if your code reads any connection strings from the configuration file, it does not work at runtime. Quand vous utilisez Azure Batch, la meilleure pratique consiste à stocker les clés secrètes dans un coffre de clés Azure KeyVault, à utiliser un principal de service basé sur certificat pour protéger le coffre de clés et à distribuer le certificat à un pool Azure Batch.The best practice when using Azure Batch is to hold any secrets in an Azure KeyVault, use a certificate-based service principal to protect the keyvault, and distribute the certificate to Azure Batch pool. L’activité personnalisée .NET peut alors accéder aux secrets du coffre de clés au moment de l’exécution.The .NET custom activity then can access secrets from the KeyVault at runtime. Cette solution est générique et peut s’adapter à n’importe quel type de clé secrète, et pas uniquement aux chaînes de connexion.This solution is a generic solution and can scale to any type of secret, not just connection string.

    Il existe une solution plus simple (mais non recommandée) : vous pouvez créer un service lié SQL Azure avec des paramètres de chaîne de connexion, puis créer un jeu de données qui utilise le service lié et chaîner le jeu de données à l’activité .NET personnalisée en tant que jeu de données d’entrée factice.There is an easier workaround (but not a best practice): you can create an Azure SQL linked service with connection string settings, create a dataset that uses the linked service, and chain the dataset as a dummy input dataset to the custom .NET activity. Vous pouvez ensuite accéder à la chaîne de connexion du service lié dans le code de l’activité personnalisée.You can then access the linked service's connection string in the custom activity code.

Mettre à jour l’activité personnaliséeUpdate custom activity

Si vous mettez à jour le code de l’activité personnalisée, créez et téléchargez le fichier .zip qui contient les nouveaux fichiers binaires pour le stockage d’objets blob.If you update the code for the custom activity, build it, and upload the zip file that contains new binaries to the blob storage.

Isolation du domaine d’applicationAppdomain isolation

Consultez Cross AppDomain Sample (Exemple d’isolation entre domaines d’application) pour savoir comment créer une activité personnalisée qui n’est pas limitée aux versions d’assembly utilisées par le lanceur d’Azure Data Factory (par exemple, WindowsAzure.Storage v4.3.0, Newtonsoft.Json v6.0.x, et ainsi de suite).See Cross AppDomain Sample that shows you how to create a custom activity that is not constrained to assembly versions used by the Data Factory launcher (example: WindowsAzure.Storage v4.3.0, Newtonsoft.Json v6.0.x, etc.).

Accéder aux propriétés étenduesAccess extended properties

Vous pouvez déclarer des propriétés étendues dans l’activité JSON, comme dans l’exemple suivant :You can declare extended properties in the activity JSON as shown in the following sample:

"typeProperties": {
  "AssemblyName": "MyDotNetActivity.dll",
  "EntryPoint": "MyDotNetActivityNS.MyDotNetActivity",
  "PackageLinkedService": "AzureStorageLinkedService",
  "PackageFile": "customactivitycontainer/MyDotNetActivity.zip",
  "extendedProperties": {
    "SliceStart": "$$Text.Format('{0:yyyyMMddHH-mm}', Time.AddMinutes(SliceStart, 0))",
    "DataFactoryName": "CustomActivityFactory"
  }
},

Dans l’exemple, il existe deux propriétés étendues : SliceStart et DataFactoryName.In the example, there are two extended properties: SliceStart and DataFactoryName. La valeur de SliceStart est basée sur la variable système SliceStart.The value for SliceStart is based on the SliceStart system variable. Consultez Variables système pour obtenir la liste des variables système prises en charge.See System Variables for a list of supported system variables. La valeur de DataFactoryName est codée en dur sous la forme CustomActivityFactory.The value for DataFactoryName is hard-coded to CustomActivityFactory.

Pour accéder à ces propriétés étendues dans la méthode Execute, utilisez un code semblable au suivant :To access these extended properties in the Execute method, use code similar to the following code:

// to get extended properties (for example: SliceStart)
DotNetActivity dotNetActivity = (DotNetActivity)activity.TypeProperties;
string sliceStartString = dotNetActivity.ExtendedProperties["SliceStart"];

// to log all extended properties
IDictionary<string, string> extendedProperties = dotNetActivity.ExtendedProperties;
logger.Write("Logging extended properties if any...");
foreach (KeyValuePair<string, string> entry in extendedProperties)
{
    logger.Write("<key:{0}> <value:{1}>", entry.Key, entry.Value);
}

Mise à l’échelle automatique d’Azure BatchAuto-scaling of Azure Batch

Vous pouvez aussi créer un pool Azure Batch avec la fonctionnalité autoscale .You can also create an Azure Batch pool with autoscale feature. Par exemple, vous pouvez créer un pool Azure Batch avec 0 machine virtuelle dédiée et une formule de mise à l’échelle automatique en fonction du nombre de tâches en attente.For example, you could create an azure batch pool with 0 dedicated VMs and an autoscale formula based on the number of pending tasks.

L’exemple de formule fourni ici entraîne le comportement suivant : Lors de sa création, le pool ne contient qu’une seule machine virtuelle.The sample formula here achieves the following behavior: When the pool is initially created, it starts with 1 VM. La métrique $PendingTasks définit le nombre de tâches dans l’état En cours d’exécution + Actif (en file d’attente).$PendingTasks metric defines the number of tasks in running + active (queued) state. Cette formule recherche le nombre moyen de tâches en attente au cours des 180 dernières secondes et définit TargetDedicated en conséquence.The formula finds the average number of pending tasks in the last 180 seconds and sets TargetDedicated accordingly. Elle garantit que TargetDedicated ne va jamais au-delà de 25 machines virtuelles.It ensures that TargetDedicated never goes beyond 25 VMs. Par conséquent, à mesure que de nouvelles tâches sont envoyées, le pool s’accroît automatiquement et, au fil de la réalisation des tâches, les machines virtuelles se libèrent une à une et la mise à l’échelle automatique réduit ces machines virtuelles.So, as new tasks are submitted, pool automatically grows and as tasks complete, VMs become free one by one and the autoscaling shrinks those VMs. Vous pouvez ajuster startingNumberOfVMs et maxNumberofVMs selon vos besoins.startingNumberOfVMs and maxNumberofVMs can be adjusted to your needs.

Formule de mise à l’échelle automatique :Autoscale formula:

startingNumberOfVMs = 1;
maxNumberofVMs = 25;
pendingTaskSamplePercent = $PendingTasks.GetSamplePercent(180 * TimeInterval_Second);
pendingTaskSamples = pendingTaskSamplePercent < 70 ? startingNumberOfVMs : avg($PendingTasks.GetSample(180 * TimeInterval_Second));
$TargetDedicated=min(maxNumberofVMs,pendingTaskSamples);

Pour plus d’informations, consultez Mettre automatiquement à l’échelle les nœuds de calcul dans un pool Azure Batch .See Automatically scale compute nodes in an Azure Batch pool for details.

Si le pool utilise la valeur par défaut du paramètre autoScaleEvaluationInterval, le service Batch peut mettre 15 à 30 minutes à préparer la machine virtuelle avant d’exécuter l’activité personnalisée.If the pool is using the default autoScaleEvaluationInterval, the Batch service could take 15-30 minutes to prepare the VM before running the custom activity. Si le pool utilise une autre valeur pour autoScaleEvaluationInterval, le service Batch peut prendre la durée d’autoScaleEvaluationInterval + 10 minutes.If the pool is using a different autoScaleEvaluationInterval, the Batch service could take autoScaleEvaluationInterval + 10 minutes.

Créer une activité personnalisée à l’aide du kit .NET SDKCreate a custom activity by using .NET SDK

Dans la procédure pas à pas de cet article, vous créez une fabrique de données avec un pipeline qui utilise l’activité personnalisée à l’aide du portail Azure.In the walkthrough in this article, you create a data factory with a pipeline that uses the custom activity by using the Azure portal. Le code suivant montre comment créer la fabrique de données à l’aide du kit .NET SDK à la place.The following code shows you how to create the data factory by using .NET SDK instead. Vous trouverez plus d’informations sur l’utilisation du Kit SDK pour créer des pipelines par programme dans l’article Créer un pipeline avec une activité de copie à l’aide de l’API .NET.You can find more details about using SDK to programmatically create pipelines in the create a pipeline with copy activity by using .NET API article.

using System;
using System.Configuration;
using System.Collections.ObjectModel;
using System.Threading;
using System.Threading.Tasks;

using Microsoft.Azure;
using Microsoft.Azure.Management.DataFactories;
using Microsoft.Azure.Management.DataFactories.Models;
using Microsoft.Azure.Management.DataFactories.Common.Models;

using Microsoft.IdentityModel.Clients.ActiveDirectory;
using System.Collections.Generic;

namespace DataFactoryAPITestApp
{
    class Program
    {
        static void Main(string[] args)
        {
            // create data factory management client

            // TODO: replace ADFTutorialResourceGroup with the name of your resource group.
            string resourceGroupName = "ADFTutorialResourceGroup";

            // TODO: replace APITutorialFactory with a name that is globally unique. For example: APITutorialFactory04212017
            string dataFactoryName = "APITutorialFactory";

            TokenCloudCredentials aadTokenCredentials = new TokenCloudCredentials(
                ConfigurationManager.AppSettings["SubscriptionId"],
                GetAuthorizationHeader().Result);

            Uri resourceManagerUri = new Uri(ConfigurationManager.AppSettings["ResourceManagerEndpoint"]);

            DataFactoryManagementClient client = new DataFactoryManagementClient(aadTokenCredentials, resourceManagerUri);

            Console.WriteLine("Creating a data factory");
            client.DataFactories.CreateOrUpdate(resourceGroupName,
                new DataFactoryCreateOrUpdateParameters()
                {
                    DataFactory = new DataFactory()
                    {
                        Name = dataFactoryName,
                        Location = "westus",
                        Properties = new DataFactoryProperties()
                    }
                }
            );

            // create a linked service for input data store: Azure Storage
            Console.WriteLine("Creating Azure Storage linked service");
            client.LinkedServices.CreateOrUpdate(resourceGroupName, dataFactoryName,
                new LinkedServiceCreateOrUpdateParameters()
                {
                    LinkedService = new LinkedService()
                    {
                        Name = "AzureStorageLinkedService",
                        Properties = new LinkedServiceProperties
                        (
                            // TODO: Replace <accountname> and <accountkey> with name and key of your Azure Storage account.
                            new AzureStorageLinkedService("DefaultEndpointsProtocol=https;AccountName=<accountname>;AccountKey=<accountkey>")
                        )
                    }
                }
            );

            // create a linked service for output data store: Azure SQL Database
            Console.WriteLine("Creating Azure Batch linked service");
            client.LinkedServices.CreateOrUpdate(resourceGroupName, dataFactoryName,
                new LinkedServiceCreateOrUpdateParameters()
                {
                    LinkedService = new LinkedService()
                    {
                        Name = "AzureBatchLinkedService",
                        Properties = new LinkedServiceProperties
                        (
                            // TODO: replace <batchaccountname> and <yourbatchaccountkey> with name and key of your Azure Batch account
                            new AzureBatchLinkedService("<batchaccountname>", "https://westus.batch.azure.com", "<yourbatchaccountkey>", "myazurebatchpool", "AzureStorageLinkedService")
                        )
                    }
                }
            );

            // create input and output datasets
            Console.WriteLine("Creating input and output datasets");
            string Dataset_Source = "InputDataset";
            string Dataset_Destination = "OutputDataset";

            Console.WriteLine("Creating input dataset of type: Azure Blob");
            client.Datasets.CreateOrUpdate(resourceGroupName, dataFactoryName,

                new DatasetCreateOrUpdateParameters()
                {
                    Dataset = new Dataset()
                    {
                        Name = Dataset_Source,
                        Properties = new DatasetProperties()
                        {
                            LinkedServiceName = "AzureStorageLinkedService",
                            TypeProperties = new AzureBlobDataset()
                            {
                                FolderPath = "adftutorial/customactivityinput/",
                                Format = new TextFormat()
                            },
                            External = true,
                            Availability = new Availability()
                            {
                                Frequency = SchedulePeriod.Hour,
                                Interval = 1,
                            },

                            Policy = new Policy() { }
                        }
                    }
                });

            Console.WriteLine("Creating output dataset of type: Azure Blob");
            client.Datasets.CreateOrUpdate(resourceGroupName, dataFactoryName,
                new DatasetCreateOrUpdateParameters()
                {
                    Dataset = new Dataset()
                    {
                        Name = Dataset_Destination,
                        Properties = new DatasetProperties()
                        {
                            LinkedServiceName = "AzureStorageLinkedService",
                            TypeProperties = new AzureBlobDataset()
                            {
                                FileName = "{slice}.txt",
                                FolderPath = "adftutorial/customactivityoutput/",
                                PartitionedBy = new List<Partition>()
                                {
                                    new Partition()
                                    {
                                        Name = "slice",
                                        Value = new DateTimePartitionValue()
                                        {
                                            Date = "SliceStart",
                                            Format = "yyyy-MM-dd-HH"
                                        }
                                    }
                                }
                            },
                            Availability = new Availability()
                            {
                                Frequency = SchedulePeriod.Hour,
                                Interval = 1,
                            },
                        }
                    }
                });

            Console.WriteLine("Creating a custom activity pipeline");
            DateTime PipelineActivePeriodStartTime = new DateTime(2017, 3, 9, 0, 0, 0, 0, DateTimeKind.Utc);
            DateTime PipelineActivePeriodEndTime = PipelineActivePeriodStartTime.AddMinutes(60);
            string PipelineName = "ADFTutorialPipelineCustom";

            client.Pipelines.CreateOrUpdate(resourceGroupName, dataFactoryName,
                new PipelineCreateOrUpdateParameters()
                {
                    Pipeline = new Pipeline()
                    {
                        Name = PipelineName,
                        Properties = new PipelineProperties()
                        {
                            Description = "Use custom activity",

                            // Initial value for pipeline's active period. With this, you won't need to set slice status
                            Start = PipelineActivePeriodStartTime,
                            End = PipelineActivePeriodEndTime,
                            IsPaused = false,

                            Activities = new List<Activity>()
                            {
                                new Activity()
                                {
                                    Name = "MyDotNetActivity",
                                    Inputs = new List<ActivityInput>()
                                    {
                                        new ActivityInput() {
                                            Name = Dataset_Source
                                        }
                                    },
                                    Outputs = new List<ActivityOutput>()
                                    {
                                        new ActivityOutput()
                                        {
                                            Name = Dataset_Destination
                                        }
                                    },
                                    LinkedServiceName = "AzureBatchLinkedService",
                                    TypeProperties = new DotNetActivity()
                                    {
                                        AssemblyName = "MyDotNetActivity.dll",
                                        EntryPoint = "MyDotNetActivityNS.MyDotNetActivity",
                                        PackageLinkedService = "AzureStorageLinkedService",
                                        PackageFile = "customactivitycontainer/MyDotNetActivity.zip",
                                        ExtendedProperties = new Dictionary<string, string>()
                                        {
                                            { "SliceStart", "$$Text.Format('{0:yyyyMMddHH-mm}', Time.AddMinutes(SliceStart, 0))"}
                                        }
                                    },
                                    Policy = new ActivityPolicy()
                                    {
                                        Concurrency = 2,
                                        ExecutionPriorityOrder = "OldestFirst",
                                        Retry = 3,
                                        Timeout = new TimeSpan(0,0,30,0),
                                        Delay = new TimeSpan()
                                    }
                                }
                            }
                        }
                    }
                });
        }

        public static async Task<string> GetAuthorizationHeader()
        {
            AuthenticationContext context = new AuthenticationContext(ConfigurationManager.AppSettings["ActiveDirectoryEndpoint"] + ConfigurationManager.AppSettings["ActiveDirectoryTenantId"]);
            ClientCredential credential = new ClientCredential(
                ConfigurationManager.AppSettings["ApplicationId"],
                ConfigurationManager.AppSettings["Password"]);
            AuthenticationResult result = await context.AcquireTokenAsync(
                resource: ConfigurationManager.AppSettings["WindowsManagementUri"],
                clientCredential: credential);

            if (result != null)
                return result.AccessToken;

            throw new InvalidOperationException("Failed to acquire token");
        }
    }
}

Déboguer une activité personnalisée dans Visual StudioDebug custom activity in Visual Studio

L’exemple Azure Data Factory - Environnement local sur GitHub inclut un outil qui vous permet de déboguer des activités .NET personnalisées dans Visual Studio.The Azure Data Factory - local environment sample on GitHub includes a tool that allows you to debug custom .NET activities within Visual Studio.

Exemples d’activités personnalisées sur GitHubSample custom activities on GitHub

ExempleSample Rôle des activités personnaliséesWhat custom activity does
Téléchargeur de données HTTP.HTTP Data Downloader. Télécharge des données à partir d'un point de terminaison HTTP vers Stockage Blob Azure à l'aide d’une activité C# personnalisée dans Data Factory.Downloads data from an HTTP Endpoint to Azure Blob Storage using custom C# Activity in Data Factory.
Exemple d’analyse d’opinions TwitterTwitter Sentiment Analysis sample Appelle un modèle Azure Machine Learning Studio et effectue l’analyse, la notation, la prédiction, etc. des opinions.Invokes an Azure Machine Learning studio model and do sentiment analysis, scoring, prediction etc.
Exécuter un script R.Run R Script. Appelle un script R en exécutant RScript.exe sur votre cluster HDInsight, sur lequel R est installé.Invokes R script by running RScript.exe on your HDInsight cluster that already has R Installed on it.
Activité .NET entre AppDomainsCross AppDomain .NET Activity Utilise des versions d’assembly différentes de celles utilisées par le lanceur de Data FactoryUses different assembly versions from ones used by the Data Factory launcher
Retraiter un modèle dans Azure Analysis ServicesReprocess a model in Azure Analysis Services Retraite un modèle dans Azure Analysis Services.Reprocesses a model in Azure Analysis Services.