Usare attività personalizzate in una pipeline di Azure Data FactoryUse custom activities in an Azure Data Factory pipeline

In una pipeline di Azure Data Factory è possibile usare due tipi di attività.There are two types of activities that you can use in an Azure Data Factory pipeline.

Per spostare dati da o verso un archivio dati non supportato da Data Factory oppure per trasformare o elaborare dati in un modo non supportato da Data Factory, è possibile creare un'attività personalizzata contenente la logica di spostamento o trasformazione dei dati necessaria e usare tale attività in una pipeline.To move data to/from a data store that Data Factory does not support, or to transform/process data in a way that isn't supported by Data Factory, you can create a Custom activity with your own data movement or transformation logic and use the activity in a pipeline. L'attività personalizzata esegue la logica del codice personalizzata in un pool di Azure Batch di macchine virtuali.The custom activity runs your customized code logic on an Azure Batch pool of virtual machines.

Nota

Questo articolo è stato aggiornato per usare il nuovo modulo Az di Azure PowerShell.This article has been updated to use the new Azure PowerShell Az module. È comunque possibile usare il modulo AzureRM, che continuerà a ricevere correzioni di bug almeno fino a dicembre 2020.You can still use the AzureRM module, which will continue to receive bug fixes until at least December 2020. Per altre informazioni sul nuovo modulo Az e sulla compatibilità di AzureRM, vedere Introduzione del nuovo modulo Az di Azure PowerShell.To learn more about the new Az module and AzureRM compatibility, see Introducing the new Azure PowerShell Az module. Per istruzioni sull'installazione del modulo Az, vedere Installare Azure PowerShell.For Az module installation instructions, see Install Azure PowerShell.

Vedere gli articoli seguenti se non si ha familiarità con il servizio Azure Batch:See following articles if you are new to Azure Batch service:

Servizio collegato Azure BatchAzure Batch linked service

Il codice JSON seguente definisce un servizio collegato Azure Batch di esempio.The following JSON defines a sample Azure Batch linked service. Per i dettagli, vedere Ambienti di calcolo supportati da Azure Data FactoryFor details, see Compute environments supported by Azure Data Factory

{
    "name": "AzureBatchLinkedService",
    "properties": {
        "type": "AzureBatch",
        "typeProperties": {
            "accountName": "batchaccount",
            "accessKey": {
                "type": "SecureString",
                "value": "access key"
            },
            "batchUri": "https://batchaccount.region.batch.azure.com",
            "poolName": "poolname",
            "linkedServiceName": {
                "referenceName": "StorageLinkedService",
                "type": "LinkedServiceReference"
            }
        }
    }
}

Per altre informazioni sul servizio collegato Azure Batch, vedere l'articolo Servizi collegati di calcolo.To learn more about Azure Batch linked service, see Compute linked services article.

Attività personalizzataCustom activity

Il frammento di codice JSON seguente definisce una pipeline con una semplice attività personalizzata.The following JSON snippet defines a pipeline with a simple Custom Activity. La definizione dell'attività contiene un riferimento al servizio collegato Azure Batch.The activity definition has a reference to the Azure Batch linked service.

{
  "name": "MyCustomActivityPipeline",
  "properties": {
    "description": "Custom activity sample",
    "activities": [{
      "type": "Custom",
      "name": "MyCustomActivity",
      "linkedServiceName": {
        "referenceName": "AzureBatchLinkedService",
        "type": "LinkedServiceReference"
      },
      "typeProperties": {
        "command": "helloworld.exe",
        "folderPath": "customactv2/helloworld",
        "resourceLinkedService": {
          "referenceName": "StorageLinkedService",
          "type": "LinkedServiceReference"
        }
      }
    }]
  }
}

In questo esempio, helloworld.exe è un'applicazione personalizzata salvata nella cartella customactv2/helloworld dell'account di Archiviazione di Azure usato in resourceLinkedService.In this sample, the helloworld.exe is a custom application stored in the customactv2/helloworld folder of the Azure Storage account used in the resourceLinkedService. L'attività personalizzata invia l'applicazione personalizzata per l'esecuzione in Azure Batch.The Custom activity submits this custom application to be executed on Azure Batch. Nel comando è possibile sostituire l'applicazione con qualsiasi altra applicazione che possa essere eseguita nel sistema operativo di destinazione dei nodi del pool di Azure Batch.You can replace the command to any preferred application that can be executed on the target Operation System of the Azure Batch Pool nodes.

Nella tabella seguente vengono descritti i nomi e le descrizioni delle proprietà specifiche per questa attività.The following table describes names and descriptions of properties that are specific to this activity.

ProprietàProperty DescriptionDescription ObbligatorioRequired
namename Nome dell'attività nella pipelineName of the activity in the pipeline Yes
descriptiondescription Testo che descrive l'attività.Text describing what the activity does. NoNo
typetype Per l'attività personalizzata, il tipo corrisponde a Custom.For Custom activity, the activity type is Custom. Yes
linkedServiceNamelinkedServiceName Servizio collegato ad Azure Batch.Linked Service to Azure Batch. Per informazioni su questo servizio collegato, vedere l'articolo Servizi collegati di calcolo.To learn about this linked service, see Compute linked services article. Yes
commandcommand Comando dell'applicazione personalizzata da eseguire.Command of the custom application to be executed. Se l'applicazione è già disponibile nel nodo del pool di Azure Batch, è possibile ignorare resourceLinkedService e folderPath.If the application is already available on the Azure Batch Pool Node, the resourceLinkedService and folderPath can be skipped. È ad esempio possibile specificare come comando cmd /c dir, supportato in modo nativo dal nodo del pool di batch di Windows.For example, you can specify the command to be cmd /c dir, which is natively supported by the Windows Batch Pool node. Yes
resourceLinkedServiceresourceLinkedService Servizio di Archiviazione di Azure collegato all'account di archiviazione in cui è archiviata l'applicazione personalizzataAzure Storage Linked Service to the Storage account where the custom application is stored No *No *
folderPathfolderPath Percorso della cartella dell'applicazione personalizzata e di tutte le relative dipendenzePath to the folder of the custom application and all its dependencies

Se sono presenti dipendenze archiviate nelle sottocartelle, vale a dire, in una struttura di cartelle gerarchiche in folderPath, la struttura di cartelle è attualmente di tipo flat quando i file vengono copiati in Azure Batch.If you have dependencies stored in subfolders - that is, in a hierarchical folder structure under folderPath - the folder structure is currently flattened when the files are copied to Azure Batch. Vale a dire, tutti i file vengono copiati in un'unica cartella senza sottocartelle.That is, all files are copied into a single folder with no subfolders. Per risolvere questo comportamento, è possibile comprimere i file, copiare il file compresso e quindi decomprimerlo con codice personalizzato nel percorso desiderato.To work around this behavior, consider compressing the files, copying the compressed file, and then unzipping it with custom code in the desired location.
No *No *
referenceObjectsreferenceObjects Matrice di servizi collegati e set di dati esistenti.An array of existing Linked Services and Datasets. I servizi collegati e i set di dati a cui si fa riferimento vengono passati all'applicazione personalizzata in formato JSON. Il codice personalizzato può quindi fare riferimento a risorse di Data FactoryThe referenced Linked Services and Datasets are passed to the custom application in JSON format so your custom code can reference resources of the Data Factory NoNo
extendedPropertiesextendedProperties Proprietà definite dall'utente che possono essere passate all'applicazione personalizzata in formato JSON. Il codice personalizzato può quindi fare riferimento a proprietà aggiuntiveUser-defined properties that can be passed to the custom application in JSON format so your custom code can reference additional properties NoNo
retentionTimeInDaysretentionTimeInDays Tempo di conservazione per i file inviati per l'attività personalizzata.The retention time for the files submitted for custom activity. Il valore predefinito è 30 giorni.Default value is 30 days. NoNo

* Le proprietà resourceLinkedService e folderPath devono essere specificate oppure omesse entrambe.* The properties resourceLinkedService and folderPath must either both be specified or both be omitted.

Nota

Se si passano servizi collegati come referenceObjects nell'attività personalizzata, è consigliabile passare un servizio collegato Azure Key Vault abilitato (poiché non contiene stringhe sicure) e recuperare le credenziali usando il nome del segreto direttamente dalla chiave Insieme di credenziali dal codice.If you are passing linked services as referenceObjects in Custom Activity, it is a good security practice to pass an Azure Key Vault enabled linked service (since it does not contain any secure strings) and fetch the credentials using secret name directly from Key Vault from the code. È possibile trovare un esempio che fa riferimento al servizio collegato abilitato per AKV, recupera le credenziali da Key Vault e quindi accede all'archiviazione nel codice.You can find an example here that references AKV enabled linked service, retrieves the credentials from Key Vault, and then accesses the storage in the code.

Autorizzazioni per le attività personalizzateCustom activity permissions

L'attività personalizzata imposta l'account utente automatico di Azure Batch sull'accesso senza privilegi di amministratore con ambito di attività (specifica di utente automatico predefinito).The custom activity sets the Azure Batch auto-user account to Non-admin access with task scope (the default auto-user specification). Non è possibile modificare il livello di autorizzazione dell'account utente automatico.You can't change the permission level of the auto-user account. Per altre informazioni, vedere Eseguire attività con account utente in Batch | Account utente automatici.For more info, see Run tasks under user accounts in Batch | Auto-user accounts.

Esecuzione di comandiExecuting commands

È possibile eseguire direttamente un comando tramite l'attività personalizzata.You can directly execute a command using Custom Activity. L'esempio seguente esegue un comando "echo hello world" nei nodi del pool di destinazione di Azure Batch e stampa l'output in stdout.The following example runs the "echo hello world" command on the target Azure Batch Pool nodes and prints the output to stdout.

{
  "name": "MyCustomActivity",
  "properties": {
    "description": "Custom activity sample",
    "activities": [{
      "type": "Custom",
      "name": "MyCustomActivity",
      "linkedServiceName": {
        "referenceName": "AzureBatchLinkedService",
        "type": "LinkedServiceReference"
      },
      "typeProperties": {
        "command": "cmd /c echo hello world"
      }
    }]
  }
}

Passaggio di oggetti e proprietàPassing objects and properties

Questo esempio illustra come usare le proprietà referenceObjects ed extendedProperties per passare oggetti e proprietà definite dall'utente di Data Factory all'applicazione personalizzata.This sample shows how you can use the referenceObjects and extendedProperties to pass Data Factory objects and user-defined properties to your custom application.

{
  "name": "MyCustomActivityPipeline",
  "properties": {
    "description": "Custom activity sample",
    "activities": [{
      "type": "Custom",
      "name": "MyCustomActivity",
      "linkedServiceName": {
        "referenceName": "AzureBatchLinkedService",
        "type": "LinkedServiceReference"
      },
      "typeProperties": {
        "command": "SampleApp.exe",
        "folderPath": "customactv2/SampleApp",
        "resourceLinkedService": {
          "referenceName": "StorageLinkedService",
          "type": "LinkedServiceReference"
        },
        "referenceObjects": {
          "linkedServices": [{
            "referenceName": "AzureBatchLinkedService",
            "type": "LinkedServiceReference"
          }]
        },
        "extendedProperties": {          
          "connectionString": {
            "type": "SecureString",
            "value": "aSampleSecureString"
          },
          "PropertyBagPropertyName1": "PropertyBagValue1",
          "propertyBagPropertyName2": "PropertyBagValue2",
          "dateTime1": "2015-04-12T12:13:14Z"
        }
      }
    }]
  }
}

Quando l'attività viene eseguita, le proprietà referenceObjects ed extendedProperties vengono archiviate nei file descritti di seguito, che vengono distribuiti nella stessa cartella di esecuzione di SampleApp.exe:When the activity is executed, referenceObjects and extendedProperties are stored in following files that are deployed to the same execution folder of the SampleApp.exe:

  • activity.json

    Contiene extendedProperties e le proprietà dell'attività personalizzata.Stores extendedProperties and properties of the custom activity.

  • linkedServices.json

    Contiene una matrice di servizi collegati definiti nella proprietà referenceObjects.Stores an array of Linked Services defined in the referenceObjects property.

  • datasets.json

    Contiene una matrice di set di dati definiti nella proprietà referenceObjects.Stores an array of Datasets defined in the referenceObjects property.

Il codice di esempio seguente illustra come SampleApp.exe è in grado di accedere alle informazioni necessarie dai file JSON:Following sample code demonstrate how the SampleApp.exe can access the required information from JSON files:

using Newtonsoft.Json;
using System;
using System.IO;

namespace SampleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            //From Extend Properties
            dynamic activity = JsonConvert.DeserializeObject(File.ReadAllText("activity.json"));
            Console.WriteLine(activity.typeProperties.extendedProperties.connectionString.value);

            // From LinkedServices
            dynamic linkedServices = JsonConvert.DeserializeObject(File.ReadAllText("linkedServices.json"));
            Console.WriteLine(linkedServices[0].properties.typeProperties.accountName);
        }
    }
}

Recuperare gli output di esecuzioneRetrieve execution outputs

Per avviare una pipeline, eseguire il comando di PowerShell seguente:You can start a pipeline run using the following PowerShell command:

$runId = Invoke-AzDataFactoryV2Pipeline -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -PipelineName $pipelineName

Quando la pipeline è in esecuzione, è possibile controllare l'output dell'esecuzione usando i comandi seguenti:When the pipeline is running, you can check the execution output using the following commands:

while ($True) {
    $result = Get-AzDataFactoryV2ActivityRun -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -PipelineRunId $runId -RunStartedAfter (Get-Date).AddMinutes(-30) -RunStartedBefore (Get-Date).AddMinutes(30)

    if(!$result) {
        Write-Host "Waiting for pipeline to start..." -foregroundcolor "Yellow"
    }
    elseif (($result | Where-Object { $_.Status -eq "InProgress" } | Measure-Object).count -ne 0) {
        Write-Host "Pipeline run status: In Progress" -foregroundcolor "Yellow"
    }
    else {
        Write-Host "Pipeline '"$pipelineName"' run finished. Result:" -foregroundcolor "Yellow"
        $result
        break
    }
    ($result | Format-List | Out-String)
    Start-Sleep -Seconds 15
}

Write-Host "Activity `Output` section:" -foregroundcolor "Yellow"
$result.Output -join "`r`n"

Write-Host "Activity `Error` section:" -foregroundcolor "Yellow"
$result.Error -join "`r`n"

stdout e stderr dell'applicazione personalizzata vengono salvati nel contenitore adfjobs nel servizio collegato di Archiviazione di Azure definito durante la creazione del servizio collegato Azure Batch con un GUID dell'attività.The stdout and stderr of your custom application are saved to the adfjobs container in the Azure Storage Linked Service you defined when creating Azure Batch Linked Service with a GUID of the task. È possibile ottenere il percorso dettagliato dall'output di Esecuzione attività, come illustrato nel frammento di codice seguente:You can get the detailed path from Activity Run output as shown in the following snippet:

Pipeline ' MyCustomActivity' run finished. Result:

ResourceGroupName : resourcegroupname
DataFactoryName   : datafactoryname
ActivityName      : MyCustomActivity
PipelineRunId     : xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
PipelineName      : MyCustomActivity
Input             : {command}
Output            : {exitcode, outputs, effectiveIntegrationRuntime}
LinkedServiceName :
ActivityRunStart  : 10/5/2017 3:33:06 PM
ActivityRunEnd    : 10/5/2017 3:33:28 PM
DurationInMs      : 21203
Status            : Succeeded
Error             : {errorCode, message, failureType, target}

Activity Output section:
"exitcode": 0
"outputs": [
  "https://<container>.blob.core.windows.net/adfjobs/<GUID>/output/stdout.txt",
  "https://<container>.blob.core.windows.net/adfjobs/<GUID>/output/stderr.txt"
]
"effectiveIntegrationRuntime": "DefaultIntegrationRuntime (East US)"
Activity Error section:
"errorCode": ""
"message": ""
"failureType": ""
"target": "MyCustomActivity"

Se si desidera usare il contenuto di stdout.txt nelle attività downstream, è possibile ottenere il percorso del file stdout.txt nell'espressione "@activity('MyCustomActivity').output.outputs[0]".If you would like to consume the content of stdout.txt in downstream activities, you can get the path to the stdout.txt file in expression "@activity('MyCustomActivity').output.outputs[0]".

Importante

  • Activity.json, linkedServices.json e datasets.json vengono archiviati nella cartella di runtime dell'attività Batch.The activity.json, linkedServices.json, and datasets.json are stored in the runtime folder of the Batch task. Per questo esempio, i file Activity. JSON, linkedServices. JSON e DataSets. JSON vengono archiviati nel percorso "https://adfv2storage.blob.core.windows.net/adfjobs/\<GUID>/runtime/".For this example, the activity.json, linkedServices.json, and datasets.json are stored in "https://adfv2storage.blob.core.windows.net/adfjobs/\<GUID>/runtime/" path. Se necessario, la pulizia di questi file deve essere eseguita separatamente.If needed, you need to clean them up separately.
  • Per i servizi collegati che usano il runtime di integrazione self-hosted, le informazioni riservate, come chiavi o password, vengono crittografate dal runtime di integrazione self-hosted per verificare che le credenziali rimangano nell'ambiente di rete privata definito dal cliente.For Linked Services that use the Self-Hosted Integration Runtime, the sensitive information like keys or passwords are encrypted by the Self-Hosted Integration Runtime to ensure credential stays in customer defined private network environment. Alcuni campi riservati potrebbero risultare mancanti se il codice dell'applicazione personalizzata fa riferimento a tali campi in questo modo.Some sensitive fields could be missing when referenced by your custom application code in this way. Se necessario, usare SecureString in extendedProperties anziché un riferimento a servizi collegati.Use SecureString in extendedProperties instead of using Linked Service reference if needed.

Passare gli output a un'altra attivitàPass outputs to another activity

È possibile inviare valori personalizzati dal codice di un'attività personalizzata ad Azure Data Factory.You can send custom values from your code in a Custom Activity back to Azure Data Factory. È possibile farlo scrivendoli in outputs.json dall'applicazione.You can do so by writing them into outputs.json from your application. Data Factory copia il contenuto di outputs.json e lo accoda all'output dell'attività come valore della proprietà customOutput.Data Factory copies the content of outputs.json and appends it into the Activity Output as the value of the customOutput property. Il limite delle dimensioni è 2MB. Se si desidera utilizzare il contenuto di outputs.json nelle attività downstream, è possibile ottenere il valore utilizzando l'espressione @activity('<MyCustomActivity>').output.customOutput.(The size limit is 2MB.) If you want to consume the content of outputs.json in downstream activities, you can get the value by using the expression @activity('<MyCustomActivity>').output.customOutput.

Recuperare gli output SecureStringRetrieve SecureString outputs

I valori delle proprietà sensibili designati come tipo SecureString, come illustrato in alcuni degli esempi in questo articolo, vengono mascherati nella scheda Monitoraggio nell'interfaccia utente di Data Factory.Sensitive property values designated as type SecureString, as shown in some of the examples in this article, are masked out in the Monitoring tab in the Data Factory user interface. Nell'esecuzione effettiva della pipeline, tuttavia, una proprietà SecureString viene serializzata come JSON all'interno del activity.json file come testo normale.In actual pipeline execution, however, a SecureString property is serialized as JSON within the activity.json file as plain text. Ad esempio:For example:

"extendedProperties": {
  "connectionString": {
    "type": "SecureString",
    "value": "aSampleSecureString"
  }
}

Questa serializzazione non è propriamente sicura e non è progettata per esserlo.This serialization is not truly secure, and is not intended to be secure. La finalità è quella di suggerire ad Azure Data Factory di mascherare il valore nella scheda Monitoraggio.The intent is to hint to Data Factory to mask the value in the Monitoring tab.

Per accedere a proprietà di tipo SecureString da un'attività personalizzata, leggere il file activity.json che viene inserito nella stessa cartella di .EXE, deserializzare JSON, quindi accedere alla proprietà JSON (extendedProperties => [propertyName] => value).To access properties of type SecureString from a custom activity, read the activity.json file, which is placed in the same folder as your .EXE, deserialize the JSON, and then access the JSON property (extendedProperties => [propertyName] => value).

Confrontare l'attività personalizzata della versione 2 e l'attività DotNet (personalizzata) della versione 1Compare v2 Custom Activity and version 1 (Custom) DotNet Activity

In Azure Data Factory versione 1 si implementa un'attività DotNet (personalizzata) creando un progetto libreria di classi .NET con una classe che implementa il metodo Execute dell'interfaccia IDotNetActivity.In Azure Data Factory version 1, you implement a (Custom) DotNet Activity by creating a .NET Class Library project with a class that implements the Execute method of the IDotNetActivity interface. I servizi collegati, i set di dati e le proprietà estese nel payload JSON di un'attività DotNet (personalizzata) vengono passati al metodo di esecuzione come oggetti fortemente tipizzati.The Linked Services, Datasets, and Extended Properties in the JSON payload of a (Custom) DotNet Activity are passed to the execution method as strongly-typed objects. Per informazioni dettagliate sul comportamento della versione 1, vedere Attività DotNet (personalizzate) nella versione 1.For details about the version 1 behavior, see (Custom) DotNet in version 1. A causa di questa implementazione, il codice dell'attività DotNet della versione 1 deve avere come destinazione .NET Framework 4.5.2.Because of this implementation, your version 1 DotNet Activity code has to target .NET Framework 4.5.2. L'attività DotNet della versione 1 deve inoltre essere eseguita sui nodi di pool di Azure Batch basati su Windows.The version 1 DotNet Activity also has to be executed on Windows-based Azure Batch Pool nodes.

Nell'attività personalizzata Azure Data Factory V2 non è necessario implementare un'interfaccia .NET.In the Azure Data Factory V2 Custom Activity, you are not required to implement a .NET interface. È ora possibile eseguire direttamente comandi, script e codice personalizzato, compilato come eseguibile.You can now directly run commands, scripts, and your own custom code, compiled as an executable. Per configurare questa implementazione, specificare la proprietà Command con la proprietà folderPath.To configure this implementation, you specify the Command property together with the folderPath property. L'attività personalizzata carica il file eseguibile e le relative dipendenze in folderpath ed esegue il comando automaticamente.The Custom Activity uploads the executable and its dependencies to folderpath and executes the command for you.

I servizi collegati, i set di dati definiti in referenceObjects e le proprietà estese definite nel payload JSON di un'attività personalizzata di Data Factory versione 2 sono accessibili dal file eseguibile come file JSON.The Linked Services, Datasets (defined in referenceObjects), and Extended Properties defined in the JSON payload of a Data Factory v2 Custom Activity can be accessed by your executable as JSON files. È possibile accedere alle proprietà obbligatorie tramite un serializzatore JSON, come illustrato nell'esempio di codice precedente SampleApp.exe.You can access the required properties using a JSON serializer as shown in the preceding SampleApp.exe code sample.

Con le modifiche introdotte nell'attività personalizzata di Data Factory versione 2, è possibile scrivere la logica del codice personalizzata nel linguaggio preferito ed eseguirla nei sistemi operativi Windows e Linux supportati da Azure Batch.With the changes introduced in the Data Factory V2 Custom Activity, you can write your custom code logic in your preferred language and execute it on Windows and Linux Operation Systems supported by Azure Batch.

La tabella seguente illustra le differenze tra l'attività personalizzata di Data Factory versione 2 e l'attività DotNet (personalizzata) di Data Factory versione 1:The following table describes the differences between the Data Factory V2 Custom Activity and the Data Factory version 1 (Custom) DotNet Activity:

DifferenzeDifferences Attività personalizzataCustom Activity Attività DotNet (personalizzata) versione 1version 1 (Custom) DotNet Activity
Modalità di definizione della logica personalizzataHow custom logic is defined Mediante l'uso di un file eseguibileBy providing an executable Implementando una DLL .NETBy implementing a .NET DLL
Ambiente di esecuzione della logica personalizzataExecution environment of the custom logic Windows o LinuxWindows or Linux Windows (.NET Framework 4.5.2)Windows (.NET Framework 4.5.2)
Esecuzione di scriptExecuting scripts Supporta l'esecuzione diretta di script, ad esempio "cmd /c echo hello world" su macchine virtuali WindowsSupports executing scripts directly (for example "cmd /c echo hello world" on Windows VM) Richiede l'implementazione nella DLL .NETRequires implementation in the .NET DLL
Set di dati obbligatorioDataset required FacoltativoOptional Richiesta per concatenare le attività e passare le informazioniRequired to chain activities and pass information
Passare le informazioni dall'attività alla logica personalizzataPass information from activity to custom logic Tramite ReferenceObjects (LinkedServices e Datasets) ed ExtendedProperties (proprietà personalizzate)Through ReferenceObjects (LinkedServices and Datasets) and ExtendedProperties (custom properties) Tramite ExtendedProperties (proprietà personalizzate), set di dati di input e outputThrough ExtendedProperties (custom properties), Input, and Output Datasets
Recuperare le informazioni nella logica personalizzataRetrieve information in custom logic Analizza i file activity.json, linkedServices.json e datasets.json archiviati nella stessa cartella del file eseguibileParses activity.json, linkedServices.json, and datasets.json stored in the same folder of the executable Tramite .NET SDK (.NET frame 4.5.2)Through .NET SDK (.NET Frame 4.5.2)
RegistrazioneLogging Scrive direttamente in STDOUTWrites directly to STDOUT Implementazione del logger nella DLL .NETImplementing Logger in .NET DLL

Se si dispone di codice .NET esistente scritto per un'attività DotNet della versione 1 (personalizzata), è necessario modificare il codice affinché funzioni con la versione corrente dell'attività personalizzata.If you have existing .NET code written for a version 1 (Custom) DotNet Activity, you need to modify your code for it to work with the current version of the Custom Activity. Aggiornare il codice seguendo queste linee guida generali:Update your code by following these high-level guidelines:

  • Modificare il progetto da una libreria di classi .NET a un'app console.Change the project from a .NET Class Library to a Console App.
  • Avviare l'applicazione con il metodo Main.Start your application with the Main method. Il metodo Execute dell'interfaccia IDotNetActivity non è più necessario.The Execute method of the IDotNetActivity interface is no longer required.
  • Leggere e analizzare i servizi collegati, i set di dati e l'attività con un serializzatore JSON e non come oggetti fortemente tipizzati.Read and parse the Linked Services, Datasets and Activity with a JSON serializer, and not as strongly-typed objects. Passare i valori delle proprietà obbligatorie alla logica del codice personalizzata principale.Pass the values of required properties to your main custom code logic. Fare riferimento all'esempio di codice precedente SampleApp.exe.Refer to the preceding SampleApp.exe code as an example.
  • L'oggetto Logger non è più supportato.The Logger object is no longer supported. L'output del file eseguibile può essere stampato nella console e viene salvato in stdout.txt.Output from your executable can be printed to the console and is saved to stdout.txt.
  • Il pacchetto NuGet Microsoft.Azure.Management.DataFactories non è più necessario.The Microsoft.Azure.Management.DataFactories NuGet package is no longer required.
  • Compilare il codice, caricare il file eseguibile e le relative dipendenze in Archiviazione di Azure e definire il percorso nella proprietà folderPath.Compile your code, upload the executable and its dependencies to Azure Storage, and define the path in the folderPath property.

Per un'illustrazione completa di come l'esempio end-to-end di DLL e pipeline, descritto nell'articolo relativo a Data Factory versione 1 Usare attività personalizzate in una pipeline di Azure Data Factory, può essere riscritto come attività personalizzata di Data Factory, vedere l'esempio di attività personalizzata di Data Factory.For a complete sample of how the end-to-end DLL and pipeline sample described in the Data Factory version 1 article Use custom activities in an Azure Data Factory pipeline can be rewritten as a Data Factory Custom Activity, see Data Factory Custom Activity sample.

Scalabilità automatica di Azure BatchAuto-scaling of Azure Batch

È anche possibile creare un pool di Azure Batch con la funzionalità Scalabilità automatica .You can also create an Azure Batch pool with autoscale feature. Ad esempio, è possibile creare un pool di Azure Batch con 0 VM dedicate e una formula di scalabilità basata sul numero di attività in sospeso.For example, you could create an azure batch pool with 0 dedicated VMs and an autoscale formula based on the number of pending tasks.

La formula di esempio seguente consente di ottenere il comportamento seguente: quando il pool viene creato inizialmente, inizia con 1 macchina virtuale.The sample formula here achieves the following behavior: When the pool is initially created, it starts with 1 VM. La metrica $PendingTasks definisce il numero di attività in esecuzione e quelle in coda.$PendingTasks metric defines the number of tasks in running + active (queued) state. La formula trova il numero medio di attività in sospeso negli ultimi 180 secondi e imposta TargetDedicated di conseguenza.The formula finds the average number of pending tasks in the last 180 seconds and sets TargetDedicated accordingly. Assicura che TargetDedicated non vada mai oltre 25 macchine virtuali.It ensures that TargetDedicated never goes beyond 25 VMs. Pertanto, quando vengono inviate nuove attività, il pool si espande automaticamente e al completamento delle attività le macchine virtuali diventano disponibili una alla volta e la scalabilità automatica le riduce.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. È possibile regolare startingNumberOfVMs e maxNumberofVMs in base alle esigenze.startingNumberOfVMs and maxNumberofVMs can be adjusted to your needs.

Formula di scalabilità automatica: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);

Per i dettagli, vedere Ridimensionare automaticamente i nodi di calcolo in un pool di Azure Batch .See Automatically scale compute nodes in an Azure Batch pool for details.

Se il pool usa il valore predefinito autoScaleEvaluationInterval, possono essere necessari 15-30 minuti perché il servizio Batch prepari la VM prima di eseguire l'attività personalizzata.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. Se il pool usa un valore autoScaleEvaluationInterval diverso, il servizio Batch può richiedere un valore autoScaleEvaluationInterval + 10 minuti.If the pool is using a different autoScaleEvaluationInterval, the Batch service could take autoScaleEvaluationInterval + 10 minutes.

Passaggi successiviNext steps

Vedere gli articoli seguenti, che illustrano altre modalità di trasformazione dei dati:See the following articles that explain how to transform data in other ways: