Usar atividades personalizadas em um pipeline do Data Factory do AzureUse custom activities in an Azure Data Factory pipeline

APLICA-SE A: Azure Data Factory Azure Synapse Analytics

Há dois tipos de atividades que você pode usar em um pipeline do Azure Data Factory.There are two types of activities that you can use in an Azure Data Factory pipeline.

Para mover dados de/para um armazenamento de dados sem suporte do Data Factory ou para transformar/processar dados de uma forma que não tenha suporte do Data Factory, você pode criar uma Atividade personalizada com a sua própria lógica de movimentação ou de transformação de dados e usar essa atividade em um 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. A atividade personalizada executa a sua lógica de código personalizada em um pool de máquinas virtuais do Lote do Azure .The custom activity runs your customized code logic on an Azure Batch pool of virtual machines.

Observação

Este artigo foi atualizado para usar o novo módulo Az do Azure PowerShell.This article has been updated to use the new Azure PowerShell Az module. Você ainda pode usar o módulo AzureRM, que continuará a receber as correções de bugs até pelo menos dezembro de 2020.You can still use the AzureRM module, which will continue to receive bug fixes until at least December 2020. Para saber mais sobre o novo módulo Az e a compatibilidade com o AzureRM, confira Apresentação do novo módulo Az do Azure PowerShell.To learn more about the new Az module and AzureRM compatibility, see Introducing the new Azure PowerShell Az module. Para obter instruções de instalação do módulo Az, confira Instalar o Azure PowerShell.For Az module installation instructions, see Install Azure PowerShell.

Veja os artigos a seguir se você for novo no serviço de Lote do Azure:See following articles if you are new to Azure Batch service:

Serviço vinculado do Lote do AzureAzure Batch linked service

O JSON a seguir define um serviço vinculado de exemplo do Lote do Azure.The following JSON defines a sample Azure Batch linked service. Para obter detalhes, consulte Compute environments supported by Azure Data Factory (Ambientes de computação com suporte do Azure Data Factory)For 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"
            }
        }
    }
}

Para saber mais sobre o serviço vinculado do Lote do Azure, consulte o artigo Compute linked services (Serviços de computação vinculados).To learn more about Azure Batch linked service, see Compute linked services article.

Atividade personalizadaCustom activity

O snippet de código JSON a seguir define um pipeline com uma atividade personalizada simples.The following JSON snippet defines a pipeline with a simple Custom Activity. A definição da atividade tem uma referência ao serviço vinculado do Lote do Azure.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"
        }
      }
    }]
  }
}

Neste exemplo, helloworld.exe é um aplicativo personalizado armazenado na pasta customactv2/helloworld da conta de Armazenamento do Azure usada no 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. A atividade personalizada envia esse aplicativo personalizado para ser executado no Lote do Azure.The Custom activity submits this custom application to be executed on Azure Batch. Você pode substituir o comando para qualquer aplicativo preferencial que possa ser executado no sistema operacional de destino dos nós do pool do Lote do Azure.You can replace the command to any preferred application that can be executed on the target Operation System of the Azure Batch Pool nodes.

A tabela a seguir descreve os nomes e as descrições de propriedades que são específicas a esta atividade.The following table describes names and descriptions of properties that are specific to this activity.

PropriedadeProperty DescriçãoDescription ObrigatórioRequired
namename Nome da atividade no pipelineName of the activity in the pipeline SimYes
descriçãodescription Texto que descreve o que a atividade faz.Text describing what the activity does. NãoNo
typetype Para a atividade personalizada, o tipo de atividade é Personalizado .For Custom activity, the activity type is Custom . SimYes
linkedServiceNamelinkedServiceName Serviço vinculado ao Lote do Azure.Linked Service to Azure Batch. Para saber mais sobre esse serviço vinculado, consulte o artigo Compute linked services (Serviços de computação vinculados).To learn about this linked service, see Compute linked services article. SimYes
.command Comando do aplicativo personalizado a ser executado.Command of the custom application to be executed. Se o aplicativo já estiver disponível no nó do pool do Lote do Azure, resourceLinkedService e folderPath poderão ser ignorados.If the application is already available on the Azure Batch Pool Node, the resourceLinkedService and folderPath can be skipped. Por exemplo, você pode especificar o comando como cmd /c dir, que tem suporte nativo no nó do pool do Lote do Windows.For example, you can specify the command to be cmd /c dir, which is natively supported by the Windows Batch Pool node. SimYes
resourceLinkedServiceresourceLinkedService Serviço de vinculado do Armazenamento do Azure para a conta de armazenamento na qual o aplicativo personalizado é armazenadoAzure Storage Linked Service to the Storage account where the custom application is stored Nenhum *No *
folderPathfolderPath Caminho para a pasta do aplicativo personalizado e de todas as suas dependênciasPath to the folder of the custom application and all its dependencies

Se você tiver dependências armazenadas em subpastas - ou seja, em uma estrutura hierárquica de pastas em folderPath - a estrutura de pastas estará nivelada quando os arquivos forem copiados para o Lote do Azure.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. Ou seja, todos os arquivos são copiados em uma única pasta sem subpastas.That is, all files are copied into a single folder with no subfolders. Para contornar esse comportamento, considere compactar os arquivos, copiando o arquivo compactado e, em seguida, descompactá-lo com código personalizado no local desejado.To work around this behavior, consider compressing the files, copying the compressed file, and then unzipping it with custom code in the desired location.
Nenhum *No *
referenceObjectsreferenceObjects Uma matriz de serviços vinculados e conjuntos de dados existentes.An array of existing Linked Services and Datasets. Os serviços vinculados e os conjuntos de dados referenciados são passados para o aplicativo personalizado no formato JSON para que o seu código personalizado possa referenciar os recursos do 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 NãoNo
extendedPropertiesextendedProperties Propriedades definidas pelo usuário que podem ser passadas para o aplicativo personalizado no formato JSON para que o seu código personalizado possa referenciar propriedades adicionaisUser-defined properties that can be passed to the custom application in JSON format so your custom code can reference additional properties NãoNo
retentionTimeInDaysretentionTimeInDays O tempo de retenção para os arquivos enviados para a atividade personalizada.The retention time for the files submitted for custom activity. O valor padrão é 30 dias.Default value is 30 days. NãoNo

* As propriedades resourceLinkedService e folderPath devem ser ambas especificadas ou ambas omitidas.* The properties resourceLinkedService and folderPath must either both be specified or both be omitted.

Observação

Se você estiver passando serviços vinculados como referenceObjects na atividade personalizada, é uma boa prática de segurança passar um serviço vinculado Azure Key Vault habilitado (já que ele não contém nenhuma cadeia de caracteres segura) e buscar as credenciais usando o nome secreto diretamente do Key Vault do código.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. Você pode encontrar um exemplo aqui que faz referência ao serviço vinculado akv habilitado, recupera as credenciais de Key Vault e, em seguida, acessa o armazenamento no código.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.

Permissões de atividade personalizadaCustom activity permissions

A atividade personalizada define a conta de usuário automático do Lote do Azure para acesso de não administrador com escopo de tarefa (a especificação de usuário automático padrão).The custom activity sets the Azure Batch auto-user account to Non-admin access with task scope (the default auto-user specification). Você não pode alterar o nível de permissão da conta de usuário automático.You can't change the permission level of the auto-user account. Para obter mais informações, veja Executar tarefas em contas de usuário no Lote | Contas de usuário automático.For more info, see Run tasks under user accounts in Batch | Auto-user accounts.

Executando comandosExecuting commands

É possível executar diretamente um comando usando a Atividade Personalizada.You can directly execute a command using Custom Activity. O exemplo a seguir executa o comando "eco Olá, mundo" nos nós de destino do Pool do Lote do Azure e imprime a saída para 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"
      }
    }]
  }
}

Passando objetos e propriedadesPassing objects and properties

Este exemplo mostra como você pode usar referenceObjects e extendedProperties para passar objetos do Data Factory e propriedades definidas pelo usuário para seu aplicativo personalizado.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 a atividade é executada, referenceObjects e extendedProperties são armazenados nos seguintes arquivos que são implantados na mesma pasta de execução do 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

    Armazena extendedProperties e as propriedades da atividade personalizada.Stores extendedProperties and properties of the custom activity.

  • linkedServices.json

    Armazena uma matriz de serviços vinculados definidos na propriedade referenceObjects.Stores an array of Linked Services defined in the referenceObjects property.

  • datasets.json

    Armazena uma matriz de conjuntos de dados definidos na propriedade referenceObjects.Stores an array of Datasets defined in the referenceObjects property.

O exemplo de código a seguir demonstra como o SampleApp.exe pode acessar as informações necessárias dos arquivos 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);
        }
    }
}

Recuperar as saídas de execuçãoRetrieve execution outputs

É possível iniciar uma execução de pipeline, usando este comando do PowerShell:You can start a pipeline run using the following PowerShell command:

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

Quando o pipeline é executado, verifique a saída de execução usando os seguintes comandos: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"

O stdout e stderr do aplicativo personalizado são salvos no contêiner adfjobs no serviço vinculado do Armazenamento do Azure que você definiu durante a criação do serviço vinculado do Lote do Azure com um GUID da tarefa.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. Você pode obter o caminho detalhado da saída da execução da atividade, conforme é mostrado no snippet de código a seguir: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 você deseja consumir o conteúdo de stdout.txt nas atividades de downstream, você pode obter o caminho para o arquivo stdout.txt na expressão "@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

  • O activity.json, o linkedServices.json e o datasets.json são armazenados na pasta de runtime da tarefa Batch.The activity.json, linkedServices.json, and datasets.json are stored in the runtime folder of the Batch task. Para este exemplo, o activity.json, linkedServices.json e datasets.json são armazenados em "https://adfv2storage.blob.core.windows.net/adfjobs/\<GUID>/runtime/" Path.For this example, the activity.json, linkedServices.json, and datasets.json are stored in "https://adfv2storage.blob.core.windows.net/adfjobs/\<GUID>/runtime/" path. Caso seja necessário, limpe-os separadamente.If needed, you need to clean them up separately.
  • Como os serviços vinculados que usam o Integration Runtime (auto-hospedado), as informações confidenciais, como chaves ou senhas, são criptografadas pelo Integration Runtime (auto-hospedado) para garantir que a credencial permaneça no ambiente de rede privada definido pelo 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. Por esse motivo, alguns campos confidenciais podem ficar faltando na referência do código do aplicativo personalizado.Some sensitive fields could be missing when referenced by your custom application code in this way. Use SecureString em extendedProperties em vez de usar a referência do serviço vinculado, se necessário.Use SecureString in extendedProperties instead of using Linked Service reference if needed.

Saídas de passagem para outra atividadePass outputs to another activity

Você pode enviar valores personalizados do seu código em uma atividade personalizada de volta para o Azure Data Factory.You can send custom values from your code in a Custom Activity back to Azure Data Factory. Você pode fazer isso, escrevendo-os em outputs.json seu aplicativo.You can do so by writing them into outputs.json from your application. O Data Factory copia o conteúdo do outputs.json e acrescenta-o para a saída da atividade como o valor da customOutput propriedade.Data Factory copies the content of outputs.json and appends it into the Activity Output as the value of the customOutput property. (O limite de tamanho é de 2MB.) Se você quiser consumir o conteúdo de outputs.json em atividades de downstream, poderá obter o valor usando a expressão @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.

Recuperar saídas do SecureStringRetrieve SecureString outputs

Os valores de propriedades confidenciais designados como tipo SecureString , conforme mostrado em alguns dos exemplos deste artigo, são mascarados na guia Monitoramento na interface do usuário do 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. Na execução real do pipeline, no entanto, uma propriedade SecureString é serializada como JSON no arquivo activity.json como texto simples.In actual pipeline execution, however, a SecureString property is serialized as JSON within the activity.json file as plain text. Por exemplo:For example:

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

Essa serialização não é verdadeiramente segura e não é destinada a ser segura.This serialization is not truly secure, and is not intended to be secure. A intenção é sugerir ao Data Factory para mascarar o valor na guia Monitoramento.The intent is to hint to Data Factory to mask the value in the Monitoring tab.

Para acessar as propriedades do tipo SecureString de uma atividade personalizada, leia o arquivo activity.json, que é colocado na mesma pasta que o .EXE, desserialize o JSON e, em seguida, acesse a propriedade JSON (extendedProperties => [propertyName] => valor).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).

Comparar a atividade personalizada da v2 e a atividade DotNet (personalizada) da versão 1Compare v2 Custom Activity and version 1 (Custom) DotNet Activity

No Azure Data Factory versão 1, você implementa uma atividade DotNet (personalizada) criando um projeto de biblioteca de classes .NET com uma classe que implementa o Execute método da IDotNetActivity interface.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. Os Serviços Vinculados, os Conjuntos de Dados e as Propriedades Estendidas no conteúdo JSON de uma Atividade DotNet (Personalizada) são passados para o método de execução como objetos fortemente tipados.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. Para obter detalhes sobre o comportamento da versão 1, consulte DotNet (personalizado) na versão 1.For details about the version 1 behavior, see (Custom) DotNet in version 1. Devido a essa implementação, seu código de atividade DotNet versão 1 tem que direcionar .NET Framework 4.5.2.Because of this implementation, your version 1 DotNet Activity code has to target .NET Framework 4.5.2. A Atividade DotNet versão1 também precisa ser executada em nós de Pool do Lote do Azure baseado no Windows.The version 1 DotNet Activity also has to be executed on Windows-based Azure Batch Pool nodes.

Na atividade personalizada do Azure Data Factory v2, não é necessário implementar uma interface .NET.In the Azure Data Factory V2 Custom Activity, you are not required to implement a .NET interface. Agora, é possível executar diretamente os comandos, scripts e seu próprio código personalizado compilado como um executável.You can now directly run commands, scripts, and your own custom code, compiled as an executable. Para configurar essa implementação, você deve especificar a propriedade Command junto com a propriedade folderPath.To configure this implementation, you specify the Command property together with the folderPath property. A Atividade Personalizada carrega o executável e suas dependências em folderpath e executa o comando para você.The Custom Activity uploads the executable and its dependencies to folderpath and executes the command for you.

Os Serviços Vinculados, os Conjuntos de Dados (definidos no referenceObjects) e as Propriedades Estendidas definidas no payload JSON de uma Atividade Personalizada do Data Factory v2 podem ser acessadas pelo executável como arquivos 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. É possível acessar as propriedades necessárias usando o serializador JSON, conforme mostrado no exemplo de código anterior SampleApp.exe.You can access the required properties using a JSON serializer as shown in the preceding SampleApp.exe code sample.

Com as alterações apresentadas na Atividade Personalizada do Data Factory V2, é possível escrever sua lógica de código personalizada em sua linguagem preferida e executá-la no Windows e em sistemas operacionais do Linux com suporte do Lote do Azure.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.

A tabela a seguir descreve as diferenças entre a Atividade Personalizada do Data Factory V2 e a Atividade de DotNet do Data Factory versão 1 (Personalizada):The following table describes the differences between the Data Factory V2 Custom Activity and the Data Factory version 1 (Custom) DotNet Activity:

DiferençasDifferences Atividade personalizadaCustom Activity versão 1 da Atividade do DotNet (personalizada)version 1 (Custom) DotNet Activity
Como a lógica personalizada é definidaHow custom logic is defined Fornecendo um executávelBy providing an executable Implementando uma DLL do .NETBy implementing a .NET DLL
Ambiente de execução da lógica personalizadaExecution environment of the custom logic Windows ou LinuxWindows or Linux Windows (.NET Framework 4.5.2)Windows (.NET Framework 4.5.2)
Execução de scriptsExecuting scripts Oferece suporte à execução direta de scripts (por exemplo "cmd /c echo hello world" na VM do Windows)Supports executing scripts directly (for example "cmd /c echo hello world" on Windows VM) Requer implementação na DLL do .NETRequires implementation in the .NET DLL
Conjunto de dados necessárioDataset required OpcionalOptional Necessário para atividades de cadeia e transmitir informaçõesRequired to chain activities and pass information
Transmitir informações de atividade para lógica personalizadaPass information from activity to custom logic Por meio de ReferenceObjects (LinkedServices e conjuntos de dados) e ExtendedProperties (propriedades personalizadas)Through ReferenceObjects (LinkedServices and Datasets) and ExtendedProperties (custom properties) Por meio de conjuntos de dados de ExtendedProperties (propriedades personalizadas), de entrada e de saídaThrough ExtendedProperties (custom properties), Input, and Output Datasets
Recuperar informações em lógica personalizadaRetrieve information in custom logic Analisa o activity.json, o linkedServices.json e o datasets.json armazenados na mesma pasta do executávelParses activity.json, linkedServices.json, and datasets.json stored in the same folder of the executable Por meio do SDK do .NET (.NET frame 4.5.2)Through .NET SDK (.NET Frame 4.5.2)
Registrando em logLogging Grava diretamente no STDOUTWrites directly to STDOUT Implementando o agente de log na DLL do .NETImplementing Logger in .NET DLL

Se você tiver um código .NET escrito para uma atividade DotNet da versão 1 (personalizada), precisará modificar seu código para que ele funcione com a versão atual da atividade personalizada.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. Atualize seu código seguindo estas diretrizes de alto nível:Update your code by following these high-level guidelines:

  • Altere o projeto de uma biblioteca de classes .NET para um aplicativo de console.Change the project from a .NET Class Library to a Console App.
  • Inicie o aplicativo com o método Main.Start your application with the Main method. O método Execute da interface IDotNetActivity não é mais necessário.The Execute method of the IDotNetActivity interface is no longer required.
  • Leia e analise os Serviços Vinculados, Conjuntos de dados e a Atividade com um serializador JSON, e não como objetos fortemente tipados.Read and parse the Linked Services, Datasets and Activity with a JSON serializer, and not as strongly-typed objects. Passe os valores das propriedades necessárias para a lógica principal do código personalizado.Pass the values of required properties to your main custom code logic. Consulte o código de SampleApp.exe anterior como exemplo.Refer to the preceding SampleApp.exe code as an example.
  • Não há mais suporte para o objeto Logger.The Logger object is no longer supported. A saída de seu executável pode ser impressa no console e salva em stdout.txt.Output from your executable can be printed to the console and is saved to stdout.txt.
  • O pacote NuGet Microsoft.Azure.Management.DataFactories não é mais necessário.The Microsoft.Azure.Management.DataFactories NuGet package is no longer required.
  • Compile seu código, carregue o executável e as dependências para o Armazenamento do Azure e defina o caminho na propriedade folderPath.Compile your code, upload the executable and its dependencies to Azure Storage, and define the path in the folderPath property.

Para obter um exemplo completo de como o exemplo DLL e pipeline de ponta a ponta descritos na versão de fábrica de dados 1 artigo usar atividades personalizadas em um pipeline da fábrica de dados do Azure pode ser reescrita como uma atividade personalizada de fábrica de dados, consulte Exemplo de atividade personalizado de fábrica de dados.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.

Dimensionamento automático do Lote do AzureAuto-scaling of Azure Batch

Você também pode criar um pool de Lotes do Azure com o recurso autoscale .You can also create an Azure Batch pool with autoscale feature. Por exemplo, você poderia criar um pool do Lote do Azure sem nenhuma VM dedicada e uma fórmula de escala automática com base no número de tarefas pendentes.For example, you could create an azure batch pool with 0 dedicated VMs and an autoscale formula based on the number of pending tasks.

A fórmula de exemplo alcança o seguinte comportamento: quando o pool é criado pela primeira vez, ele começa com uma VM.The sample formula here achieves the following behavior: When the pool is initially created, it starts with 1 VM. A métrica de $PendingTasks define o número de tarefas em execução + estado ativo (em fila).$PendingTasks metric defines the number of tasks in running + active (queued) state. A fórmula localiza o número médio de tarefas pendentes nos últimos 180 segundos e define TargetDedicated adequadamente.The formula finds the average number of pending tasks in the last 180 seconds and sets TargetDedicated accordingly. Isso garante que TargetDedicated nunca ultrapasse 25 VMs.It ensures that TargetDedicated never goes beyond 25 VMs. Assim, o pool aumenta automaticamente conforme novas tarefas são enviadas e, conforme as tarefas são concluídas, as VMs se liberam uma a uma e são reduzidas pelo dimensionamento automático.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. startingNumberOfVMs e maxNumberofVMs podem ser ajustados às suas necessidades.startingNumberOfVMs and maxNumberofVMs can be adjusted to your needs.

Fórmula de dimensionamento automático: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);

Consulte Dimensionar automaticamente os nós de computação em um pool de Lotes do Azure para obter detalhes.See Automatically scale compute nodes in an Azure Batch pool for details.

Se o pool estiver usando o padrão autoScaleEvaluationInterval, o serviço Lote poderá demorar de 15 a 30 minutos para preparar a VM antes de executar a atividade personalizada.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 o pool estiver usando um autoScaleEvaluationInterval diferente, o serviço de lote pode levar autoScaleEvaluationInterval + 10 minutos.If the pool is using a different autoScaleEvaluationInterval, the Batch service could take autoScaleEvaluationInterval + 10 minutes.

Próximas etapasNext steps

Consulte os seguintes artigos que explicam como transformar dados de outras maneiras:See the following articles that explain how to transform data in other ways: