CI/CD (integração e entrega contínuas) no Azure Data FactoryContinuous integration and delivery (CI/CD) in Azure Data Factory

Descrição geralOverview

A integração contínua é a prática de testar cada alteração feita na base de código automaticamente e o mais cedo possível.Continuous Integration is the practice of testing each change done to your codebase automatically and as early as possible. A entrega contínua segue os testes que ocorrem durante a integração contínua e envia por push as alterações para um sistema de preparo ou de produção. Continuous Delivery follows the testing that happens during Continuous Integration and pushes changes to a staging or production system.

Em Azure Data Factory, a integração contínua & entrega significa mover Data Factory pipelines de um ambiente (desenvolvimento, teste, produção) para outro.In Azure Data Factory, continuous integration & delivery means moving Data Factory pipelines from one environment (development, test, production) to another. Para fazer a integração contínua & entrega, você pode usar a integração do Data Factory UX com modelos de Azure Resource Manager.To do continuous integration & delivery, you can use Data Factory UX integration with Azure Resource Manager templates. O Data Factory UX pode gerar um modelo do Resource Manager a partir do menu suspenso do modelo ARM .The Data Factory UX can generate a Resource Manager template from the ARM template dropdown. Quando você seleciona Exportar modelo ARM, o portal gera o modelo do Resource Manager para o data Factory e um arquivo de configuração que inclui todas as suas cadeias de conexão e outros parâmetros.When you select Export ARM template, the portal generates the Resource Manager template for the data factory and a configuration file that includes all your connections strings and other parameters. Em seguida, você precisa criar um arquivo de configuração para cada ambiente (desenvolvimento, teste, produção).Then you've to create one configuration file for each environment (development, test, production). O arquivo de modelo principal do Resource Manager permanece o mesmo para todos os ambientes.The main Resource Manager template file remains the same for all the environments.

Para uma introdução e uma demonstração desse recurso de nove minutos, Assista ao vídeo a seguir:For a nine-minute introduction and demonstration of this feature, watch the following video:

Nota

Este artigo foi atualizado para utilizar o novo módulo AZ do Azure PowerShell.This article has been updated to use the new Azure PowerShell Az module. Pode continuar a utilizar o módulo AzureRM, que continuará a receber correções de erros 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 obter mais informações sobre o novo módulo Az e a compatibilidade do AzureRM, veja 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, veja Instalar o Azure PowerShell.For Az module installation instructions, see Install Azure PowerShell.

Ciclo de vida de integração contínuaContinuous integration lifecycle

Abaixo está um exemplo de visão geral do ciclo de vida de integração e entrega contínua em um Azure data Factory configurado com Azure Repos git.Below is a sample overview of the continuous integration and delivery lifecycle in an Azure Data factory configured with Azure Repos Git. Para obter mais informações sobre como configurar um repositório git, consulte controle do código-fonte em Azure data Factory.For more information on how to configure a Git Repository, see Source control in Azure Data Factory.

  1. Um data factory de desenvolvimento é criado e configurado com Azure Repos git, em que todos os desenvolvedores têm permissão para criar Data Factory recursos como pipelines e conjuntos de valores.A development data factory is created and configured with Azure Repos Git where all developers have permission to author Data Factory resources such as pipelines and datasets.

  2. À medida que os desenvolvedores fazem alterações na ramificação de recursos, eles depuram suas execuções de pipeline com suas alterações mais recentes.As the developers make changes in their feature branch, they debug their pipeline runs with their most recent changes. Para obter mais informações sobre como depurar uma execução de pipeline, consulte desenvolvimento iterativo e depuração com Azure data Factory.For more information on how to debug a pipeline run, see Iterative development and debugging with Azure Data Factory.

  3. Depois que os desenvolvedores estão satisfeitos com suas alterações, eles criam uma solicitação de pull de sua ramificação de recursos para o Branch mestre ou de colaboração para que suas alterações sejam revisadas por colegas.Once the developers are satisfied with their changes, they create a pull request from their feature branch to the master or collaboration branch to get their changes reviewed by peers.

  4. Depois que a solicitação de pull é aprovada e as alterações são mescladas no Branch mestre, elas podem publicar na fábrica de desenvolvimento.After the pull request is approved and changes are merged in the master branch, they can publish to the development factory.

  5. Quando a equipe estiver pronta para implantar as alterações na fábrica de testes e, em seguida, na fábrica de produção, elas exportarão o modelo do Resource Manager do Branch mestre.When the team is ready to deploy the changes to the test factory and then to the production factory, they export the Resource Manager template from the master branch.

  6. O modelo exportado do Resource Manager é implantado com arquivos de parâmetro diferentes na fábrica de teste e na fábrica de produção.The exported Resource Manager template gets deployed with different parameter files to the test factory and the production factory.

Criar um modelo do Resource Manager para cada ambienteCreate a Resource Manager template for each environment

No menu suspenso modelo do ARM , selecione Exportar modelo do ARM para exportar o modelo do Resource Manager para seu data Factory no ambiente de desenvolvimento.From the ARM template dropdown, select Export ARM template to export the Resource Manager template for your data factory in the development environment.

Em suas fábricas de dados de teste e de produção, selecione Importar modelo de ARM.In your test and production data factories, select Import ARM template. Essa ação leva você para a portal do Azure, onde você pode importar o modelo exportado.This action takes you to the Azure portal, where you can import the exported template. Selecione criar seu próprio modelo no editor para abrir o editor de modelos do Resource Manager.Select Build your own template in the editor to open the Resource Manager template editor.

Clique em carregar arquivo e selecione o modelo do Resource Manager gerado.Click Load file and select the generated Resource Manager template.

No painel configurações, insira os valores de configuração, como credenciais de serviço vinculado.In the settings pane, enter the configuration values such as linked service credentials. Depois de terminar, clique em comprar para implantar o modelo do Resource Manager.Once you're done, click Purchase to deploy the Resource Manager template.

Cadeias de ligaçãoConnection strings

Informações sobre como configurar cadeias de conexão podem ser encontradas no artigo de cada conector.Information on how to configure connection strings can be found in each connector's article. Por exemplo, para o banco de dados SQL do Azure, confira copiar ou fazer a partir do Azure SQL Database usando Azure data Factory.For example, for Azure SQL Database, see Copy data to or from Azure SQL Database by using Azure Data Factory. Para verificar uma cadeia de conexão, você pode abrir a exibição de código para o recurso no Data Factory UX.To verify a connection string, you can open the code view for the resource in the Data Factory UX. Na exibição de código, a parte de chave de conta ou senha da cadeia de conexão é removida.In code view, the password or account key portion of the connection string is removed. Para abrir o modo de exibição de código, selecione o ícone realçado na captura de tela a seguir.To open code view, select the icon highlighted in the following screenshot.

Abra a exibição de código para ver a cadeia de conexão

Automatizar a integração contínua com versões de Azure PipelinesAutomate continuous integration with Azure Pipelines releases

Veja abaixo um guia para configurar uma versão Azure Pipelines, que automatiza a implantação de um data factory em vários ambientes.Below is a guide to set up an Azure Pipelines release, which automates the deployment of a data factory to multiple environments.

Diagrama de integração contínua com o Azure Pipelines

RequisitosRequirements

Configurar uma versão Azure PipelinesSet up an Azure Pipelines release

  1. Na experiência do usuário do Azure DevOps, abra o projeto configurado com seu data Factory.In the Azure DevOps user experience, open the project configured with your Data Factory.

  2. No lado esquerdo da página, clique em pipelines e selecione versões.On the left side of the page, click Pipelines and then select Releases.

  3. Selecione novo pipeline ou, se você tiver pipelines existentes, novose, em seguida, novo pipeline de lançamento.Select New pipeline or if you have existing pipelines, New, and then New release pipeline.

  4. Selecione o modelo de trabalho vazio .Select the Empty job template.

  5. No campo nome do estágio , insira o nome do seu ambiente.In the Stage name field, enter the name of your environment.

  6. Selecione Adicionar um artefatoe selecione o mesmo repositório configurado com sua data Factory.Select Add an artifact, and select the same repository configured with your Data Factory. Escolha adf_publish como o Branch padrão com a versão padrão mais recente.Choose adf_publish as the default branch with latest default version.

  7. Adicionar uma tarefa de implantação de Azure Resource Manager:Add an Azure Resource Manager Deployment task:

    a.a. No modo de exibição de estágio, clique no link Exibir tarefas do estágio .In the stage view, click the View stage tasks link.

    b.b. Crie uma nova tarefa.Create a new task. Pesquise implantação do grupo de recursos do Azuree clique em Adicionar.Search for Azure Resource Group Deployment, and click Add.

    c.c. Na tarefa de implantação, escolha a assinatura, o grupo de recursos e o local para o Data Factory de destino e forneça as credenciais, se necessário.In the Deployment task, choose the subscription, resource group, and location for the target Data Factory, and provide credentials if necessary.

    d.d. Na lista suspensa ação, selecione criar ou atualizar grupo de recursos.In the action dropdown, select Create or update resource group.

    e.e. Selecionar ...Select no campo modelo .in the Template field. Procure a Azure Resource Manager modelo criar por meio da etapa Importar modelo do ARM em criar um modelo do Resource Manager para cada ambiente.Browse for the Azure Resource Manager template create via the Import ARM Template step in Create a resource manager template for each environment. Procure esse arquivo na pasta <FactoryName> da ramificação adf_publish.Look for this file in the folder <FactoryName> of the adf_publish branch.

    f.f. Selecionar ...Select no campo parâmetros do modelo.in the Template parameters field. para escolher o arquivo de parâmetros.to choose the parameters file. Escolha o arquivo correto dependendo se você criou uma cópia ou se está usando o arquivo padrão ARMTemplateParametersForFactory. JSON.Choose the correct file depending on whether you created a copy or you’re using the default file ARMTemplateParametersForFactory.json.

    g.g. Selecionar ...Select ao lado do campo Substituir parâmetros do modelo e preencha as informações do data Factory de destino.next to the Override template parameters field and fill in the information for the target Data Factory. Para credenciais provenientes do Key Vault, insira o nome do segredo entre aspas duplas.For credentials that come from key vault, enter the secret name between double quotes. Por exemplo, se o nome do segredo for cred1, insira "$(cred1)"para seu valor.For example, if the secret’s name is cred1, enter "$(cred1)"for its value.

    h.h. Selecione o modo de implantação incremental .Select the Incremental Deployment Mode.

    Aviso

    Se você selecionar o modo de implantação completo , os recursos existentes poderão ser excluídos, incluindo todos os recursos no grupo de recursos de destino que não estão definidos no modelo do Resource Manager.If you select Complete deployment mode, existing resources may be deleted, including all the resources in the target resource group that aren't defined in the Resource Manager template.

  8. Salve o pipeline de liberação.Save the release pipeline.

  9. Para disparar uma versão, clique em criar versãoTo trigger a release, click Create release

Obter segredos de Azure Key VaultGet secrets from Azure Key Vault

Se você tiver segredos para passar um modelo de Azure Resource Manager, é recomendável usar Azure Key Vault com a versão Azure Pipelines.If you've secrets to pass in an Azure Resource Manager template, we recommend using Azure Key Vault with the Azure Pipelines release.

Há duas maneiras de lidar com os segredos:There are two ways to handle secrets:

  1. Adicione os segredos ao arquivo de parâmetros.Add the secrets to parameters file. Para obter mais informações, consulte usar Azure Key Vault para passar o valor do parâmetro seguro durante a implantação.For more info, see Use Azure Key Vault to pass secure parameter value during deployment.

    • Crie uma cópia do arquivo de parâmetros que é carregado para a ramificação de publicação e defina os valores dos parâmetros que você deseja obter do Key Vault com o seguinte formato:Create a copy of the parameters file that is uploaded to the publish branch and set the values of the parameters you want to get from key vault with the following format:
    {
        "parameters": {
            "azureSqlReportingDbPassword": {
                "reference": {
                    "keyVault": {
                        "id": "/subscriptions/<subId>/resourceGroups/<resourcegroupId> /providers/Microsoft.KeyVault/vaults/<vault-name> "
                    },
                    "secretName": " < secret - name > "
                }
            }
        }
    }
    
    • Quando você usa esse método, o segredo é extraído do cofre de chaves automaticamente.When you use this method, the secret is pulled from the key vault automatically.

    • O arquivo de parâmetros também deve estar na ramificação de publicação.The parameters file needs to be in the publish branch as well.

  2. Adicione uma tarefa de Azure Key Vault antes da Azure Resource Manager implantação descrita na seção anterior:Add an Azure Key Vault task before the Azure Resource Manager Deployment described in the previous section:

    • Selecione a guia tarefas , crie uma nova tarefa, procure Azure Key Vault e adicione-a.Select the Tasks tab, create a new task, search for Azure Key Vault and add it.

    • Na tarefa Key Vault, escolha a assinatura na qual você criou o cofre de chaves, forneça as credenciais, se necessário, e escolha o cofre de chaves.In the Key Vault task, choose the subscription in which you created the key vault, provide credentials if necessary, and then choose the key vault.

Conceder permissões para o agente de Azure PipelinesGrant permissions to the Azure Pipelines agent

A tarefa Azure Key Vault poderá falhar com um erro de acesso negado se as permissões adequadas não estiverem presentes.The Azure Key Vault task may fail with an Access Denied error if the proper permissions aren't present. Baixe os logs da versão e localize o arquivo .ps1 com o comando para conceder permissões ao agente de Azure Pipelines.Download the logs for the release, and locate the .ps1 file with the command to give permissions to the Azure Pipelines agent. Você pode executar o comando diretamente ou pode copiar a ID da entidade de segurança do arquivo e adicionar a política de acesso manualmente no portal do Azure.You can run the command directly, or you can copy the principal ID from the file and add the access policy manually in the Azure portal. Obter e listar são as permissões mínimas necessárias.Get and List are the minimum permissions required.

Atualizar gatilhos ativosUpdate active triggers

A implantação poderá falhar se você tentar atualizar os gatilhos ativos.Deployment can fail if you try to update active triggers. Para atualizar os gatilhos ativos, você precisa interrompê-los manualmente e iniciá-los após a implantação.To update active triggers, you need to manually stop them and start them after the deployment. Você pode fazer isso por meio de uma tarefa do Azure PowerShell.You can do this via an Azure Powershell task.

  1. Na guia tarefas da versão, adicione uma tarefa do Azure PowerShell .In the Tasks tab of the release, add an Azure Powershell task.

  2. Escolha Azure Resource Manager como o tipo de conexão e selecione sua assinatura.Choose Azure Resource Manager as the connection type and select your subscription.

  3. Escolha script embutido como o tipo de script e, em seguida, forneça seu código.Choose Inline Script as the script type and then provide your code. O exemplo a seguir interrompe os gatilhos:The following example stops the triggers:

    $triggersADF = Get-AzDataFactoryV2Trigger -DataFactoryName $DataFactoryName -ResourceGroupName $ResourceGroupName
    
    $triggersADF | ForEach-Object { Stop-AzDataFactoryV2Trigger -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Name $_.name -Force }
    

Você pode seguir etapas semelhantes (com a função Start-AzDataFactoryV2Trigger) para reiniciar os gatilhos após a implantação.You can follow similar steps (with the Start-AzDataFactoryV2Trigger function) to restart the triggers after deployment.

Importante

Em cenários de integração e implantação contínuas, o tipo de Integration Runtime em ambientes diferentes deve ser o mesmo.In continuous integration and deployment scenarios, the Integration Runtime type across different environments must be the same. Por exemplo, se você tiver um IR ( autohospedado Integration Runtime) no ambiente de desenvolvimento, o mesmo ir deverá ser do tipo auto-hospedado em outros ambientes, como o teste e a produção também.For example, if you have a Self-Hosted Integration Runtime (IR) in the development environment, the same IR must be of type Self-Hosted in other environments such as test and production also. Da mesma forma, se você estiver compartilhando tempos de execução de integração em vários estágios, precisará configurar os tempos de execução de integração como vinculados internamente em todos os ambientes, como desenvolvimento, teste e produção.Similarly, if you're sharing integration runtimes across multiple stages, you have to configure the Integration Runtimes as Linked Self-Hosted in all environments, such as development, test, and production.

Exemplo de script de pré/pós-implantaçãoSample pre/postdeployment script

Veja abaixo um script de exemplo para parar os gatilhos antes da implantação e reiniciar os gatilhos posteriormente.Below is a sample script to stop triggers before deployment and to restart triggers afterwards. O script também inclui código para excluir os recursos que foram removidos.The script also includes code to delete resources that have been removed. Para instalar a versão mais recente do Azure PowerShell, consulte instalar Azure PowerShell no Windows com PowerShellGet.To install the latest version of Azure PowerShell, see Install Azure PowerShell on Windows with PowerShellGet.

param
(
    [parameter(Mandatory = $false)] [String] $rootFolder,
    [parameter(Mandatory = $false)] [String] $armTemplate,
    [parameter(Mandatory = $false)] [String] $ResourceGroupName,
    [parameter(Mandatory = $false)] [String] $DataFactoryName,
    [parameter(Mandatory = $false)] [Bool] $predeployment=$true,
    [parameter(Mandatory = $false)] [Bool] $deleteDeployment=$false
)

$templateJson = Get-Content $armTemplate | ConvertFrom-Json
$resources = $templateJson.resources

#Triggers 
Write-Host "Getting triggers"
$triggersADF = Get-AzDataFactoryV2Trigger -DataFactoryName $DataFactoryName -ResourceGroupName $ResourceGroupName
$triggersTemplate = $resources | Where-Object { $_.type -eq "Microsoft.DataFactory/factories/triggers" }
$triggerNames = $triggersTemplate | ForEach-Object {$_.name.Substring(37, $_.name.Length-40)}
$activeTriggerNames = $triggersTemplate | Where-Object { $_.properties.runtimeState -eq "Started" -and ($_.properties.pipelines.Count -gt 0 -or $_.properties.pipeline.pipelineReference -ne $null)} | ForEach-Object {$_.name.Substring(37, $_.name.Length-40)}
$deletedtriggers = $triggersADF | Where-Object { $triggerNames -notcontains $_.Name }
$triggerstostop = $triggerNames | where { ($triggersADF | Select-Object name).name -contains $_ }

if ($predeployment -eq $true) {
    #Stop all triggers
    Write-Host "Stopping deployed triggers"
    $triggerstostop | ForEach-Object { 
        Write-host "Disabling trigger " $_
        Stop-AzDataFactoryV2Trigger -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Name $_ -Force 
    }
}
else {
    #Deleted resources
    #pipelines
    Write-Host "Getting pipelines"
    $pipelinesADF = Get-AzDataFactoryV2Pipeline -DataFactoryName $DataFactoryName -ResourceGroupName $ResourceGroupName
    $pipelinesTemplate = $resources | Where-Object { $_.type -eq "Microsoft.DataFactory/factories/pipelines" }
    $pipelinesNames = $pipelinesTemplate | ForEach-Object {$_.name.Substring(37, $_.name.Length-40)}
    $deletedpipelines = $pipelinesADF | Where-Object { $pipelinesNames -notcontains $_.Name }
    #datasets
    Write-Host "Getting datasets"
    $datasetsADF = Get-AzDataFactoryV2Dataset -DataFactoryName $DataFactoryName -ResourceGroupName $ResourceGroupName
    $datasetsTemplate = $resources | Where-Object { $_.type -eq "Microsoft.DataFactory/factories/datasets" }
    $datasetsNames = $datasetsTemplate | ForEach-Object {$_.name.Substring(37, $_.name.Length-40) }
    $deleteddataset = $datasetsADF | Where-Object { $datasetsNames -notcontains $_.Name }
    #linkedservices
    Write-Host "Getting linked services"
    $linkedservicesADF = Get-AzDataFactoryV2LinkedService -DataFactoryName $DataFactoryName -ResourceGroupName $ResourceGroupName
    $linkedservicesTemplate = $resources | Where-Object { $_.type -eq "Microsoft.DataFactory/factories/linkedservices" }
    $linkedservicesNames = $linkedservicesTemplate | ForEach-Object {$_.name.Substring(37, $_.name.Length-40)}
    $deletedlinkedservices = $linkedservicesADF | Where-Object { $linkedservicesNames -notcontains $_.Name }
    #Integrationruntimes
    Write-Host "Getting integration runtimes"
    $integrationruntimesADF = Get-AzDataFactoryV2IntegrationRuntime -DataFactoryName $DataFactoryName -ResourceGroupName $ResourceGroupName
    $integrationruntimesTemplate = $resources | Where-Object { $_.type -eq "Microsoft.DataFactory/factories/integrationruntimes" }
    $integrationruntimesNames = $integrationruntimesTemplate | ForEach-Object {$_.name.Substring(37, $_.name.Length-40)}
    $deletedintegrationruntimes = $integrationruntimesADF | Where-Object { $integrationruntimesNames -notcontains $_.Name }

    #Delete resources
    Write-Host "Deleting triggers"
    $deletedtriggers | ForEach-Object { 
        Write-Host "Deleting trigger "  $_.Name
        $trig = Get-AzDataFactoryV2Trigger -name $_.Name -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName
        if ($trig.RuntimeState -eq "Started") {
            Stop-AzDataFactoryV2Trigger -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Name $_.Name -Force 
        }
        Remove-AzDataFactoryV2Trigger -Name $_.Name -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Force 
    }
    Write-Host "Deleting pipelines"
    $deletedpipelines | ForEach-Object { 
        Write-Host "Deleting pipeline " $_.Name
        Remove-AzDataFactoryV2Pipeline -Name $_.Name -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Force 
    }
    Write-Host "Deleting datasets"
    $deleteddataset | ForEach-Object { 
        Write-Host "Deleting dataset " $_.Name
        Remove-AzDataFactoryV2Dataset -Name $_.Name -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Force 
    }
    Write-Host "Deleting linked services"
    $deletedlinkedservices | ForEach-Object { 
        Write-Host "Deleting Linked Service " $_.Name
        Remove-AzDataFactoryV2LinkedService -Name $_.Name -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Force 
    }
    Write-Host "Deleting integration runtimes"
    $deletedintegrationruntimes | ForEach-Object { 
        Write-Host "Deleting integration runtime " $_.Name
        Remove-AzDataFactoryV2IntegrationRuntime -Name $_.Name -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Force 
    }

    if ($deleteDeployment -eq $true) {
        Write-Host "Deleting ARM deployment ... under resource group: " $ResourceGroupName
        $deployments = Get-AzResourceGroupDeployment -ResourceGroupName $ResourceGroupName
        $deploymentsToConsider = $deployments | Where { $_.DeploymentName -like "ArmTemplate_master*" -or $_.DeploymentName -like "ArmTemplateForFactory*" } | Sort-Object -Property Timestamp -Descending
        $deploymentName = $deploymentsToConsider[0].DeploymentName

       Write-Host "Deployment to be deleted: " $deploymentName
        $deploymentOperations = Get-AzResourceGroupDeploymentOperation -DeploymentName $deploymentName -ResourceGroupName $ResourceGroupName
        $deploymentsToDelete = $deploymentOperations | Where { $_.properties.targetResource.id -like "*Microsoft.Resources/deployments*" }

        $deploymentsToDelete | ForEach-Object { 
            Write-host "Deleting inner deployment: " $_.properties.targetResource.id
            Remove-AzResourceGroupDeployment -Id $_.properties.targetResource.id
        }
        Write-Host "Deleting deployment: " $deploymentName
        Remove-AzResourceGroupDeployment -ResourceGroupName $ResourceGroupName -Name $deploymentName
    }

    #Start Active triggers - After cleanup efforts
    Write-Host "Starting active triggers"
    $activeTriggerNames | ForEach-Object { 
        Write-host "Enabling trigger " $_
        Start-AzDataFactoryV2Trigger -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Name $_ -Force 
    }
}

Usar parâmetros personalizados com o modelo do Resource ManagerUse custom parameters with the Resource Manager template

Se você estiver no modo GIT, poderá substituir as propriedades padrão em seu modelo do Resource Manager para definir propriedades que são parametrizadas no modelo e propriedades que são embutidas em código.If you're in GIT mode, you can override the default properties in your Resource Manager template to set properties that are parameterized in the template and properties that are hard-coded. Talvez você queira substituir o modelo de parametrização padrão nesses cenários:You might want to override the default parameterization template in these scenarios:

  • Você usa CI/CD automatizado e deseja alterar algumas propriedades durante a implantação do Resource Manager, mas as propriedades não são parametrizadas por padrão.You use automated CI/CD and you want to change some properties during Resource Manager deployment, but the properties aren't parameterized by default.
  • Sua fábrica é tão grande que o modelo padrão do Resource Manager é inválido porque ele tem mais do que os parâmetros máximos permitidos (256).Your factory is so large that the default Resource Manager template is invalid because it has more than the maximum allowed parameters (256).

Sob essas condições, para substituir o modelo de parametrização padrão, crie um arquivo chamado ARM-template-Parameters-Definition. JSON na pasta raiz do repositório.Under these conditions, to override the default parameterization template, create a file named arm-template-parameters-definition.json in the root folder of the repository. O nome do arquivo deve corresponder exatamente.The file name must exactly match. Data Factory tenta ler esse arquivo de qualquer ramificação que você esteja no portal de Azure Data Factory, não apenas da ramificação de colaboração.Data Factory tries to read this file from whichever branch you're currently on in the Azure Data Factory portal, not just from the collaboration branch. Você pode criar ou editar o arquivo de um Branch privado, no qual você pode testar suas alterações usando o modelo de ARM de exportação na interface do usuário.You can create or edit the file from a private branch, where you can test your changes by using the Export ARM template in the UI. Em seguida, você pode mesclar o arquivo no Branch de colaboração.Then, you can merge the file into the collaboration branch. Se nenhum arquivo for encontrado, o modelo padrão será usado.If no file is found, the default template is used.

Sintaxe de um arquivo de parâmetros personalizadoSyntax of a custom parameters file

Aqui estão algumas diretrizes para usar ao criar o arquivo de parâmetros personalizados.Here are some guidelines to use when you author the custom parameters file. O arquivo consiste em uma seção para cada tipo de entidade: gatilho, pipeline, serviço vinculado, conjunto de serviços, tempo de execução de integração e assim por diante.The file consists of a section for each entity type: trigger, pipeline, linked service, dataset, integration runtime, and so on.

  • Insira o caminho da propriedade sob o tipo de entidade relevante.Enter the property path under the relevant entity type.
  • Ao definir um nome de propriedade como '*' ', você indica que deseja parametrizar todas as propriedades abaixo dele (somente até o primeiro nível, não recursivamente).When you set a property name to '*'', you indicate that you want to parameterize all properties under it (only down to the first level, not recursively). Você também pode fornecer qualquer exceção a isso.You can also provide any exceptions to this.
  • Quando você define o valor de uma propriedade como uma cadeia de caracteres, você indica que deseja parametrizar a propriedade.When you set the value of a property as a string, you indicate that you want to parameterize the property. Use o formato <action>:<name>:<stype>.Use the format <action>:<name>:<stype>.
    • <action> pode ser um dos seguintes caracteres:<action> can be one of the following characters:
      • = significa manter o valor atual como o valor padrão para o parâmetro.= means keep the current value as the default value for the parameter.
      • - significa não manter o valor padrão para o parâmetro.- means don't keep the default value for the parameter.
      • | é um caso especial para segredos de Azure Key Vault para cadeias de conexão ou chaves.| is a special case for secrets from Azure Key Vault for connection strings or keys.
    • <name> é o nome do parâmetro.<name> is the name of the parameter. Se estiver em branco, ele usará o nome da propriedade.If it's blank, it takes the name of the property. Se o valor começar com um caractere -, o nome será reduzido.If the value starts with a - character, the name is shortened. Por exemplo, AzureStorage1_properties_typeProperties_connectionString seria reduzido para AzureStorage1_connectionString.For example, AzureStorage1_properties_typeProperties_connectionString would be shortened to AzureStorage1_connectionString.
    • <stype> é o tipo de parâmetro.<stype> is the type of parameter. Se <stype> estiver em branco, o tipo padrão será string.If <stype> is blank, the default type is string. Valores com suporte: string, bool, number, object e securestring.Supported values: string, bool, number, object, and securestring.
  • Ao especificar uma matriz no arquivo de definição, você indica que a propriedade correspondente no modelo é uma matriz.When you specify an array in the definition file, you indicate that the matching property in the template is an array. Data Factory itera através de todos os objetos na matriz usando a definição especificada no objeto Integration Runtime da matriz.Data Factory iterates through all the objects in the array by using the definition that's specified in the Integration Runtime object of the array. O segundo objeto, uma cadeia de caracteres, torna-se o nome da propriedade, que é usado como o nome do parâmetro para cada iteração.The second object, a string, becomes the name of the property, which is used as the name for the parameter for each iteration.
  • Não é possível ter uma definição específica para uma instância de recurso.It's not possible to have a definition that's specific for a resource instance. Qualquer definição se aplica a todos os recursos desse tipo.Any definition applies to all resources of that type.
  • Por padrão, todas as cadeias de caracteres seguras, como segredos de Key Vault e cadeias de caracteres seguras, como cadeias de conexão, chaves e tokens, são parametrizadas.By default, all secure strings, such as Key Vault secrets, and secure strings, such as connection strings, keys, and tokens, are parameterized.

Modelo de parametrização de exemploSample parameterization template

Veja abaixo um exemplo de como um modelo de parametrização pode ser:Below is an example of what a parameterization template may look like:

{
    "Microsoft.DataFactory/factories/pipelines": {
        "properties": {
            "activities": [{
                "typeProperties": {
                    "waitTimeInSeconds": "-::number",
                    "headers": "=::object"
                }
            }]
        }
    },
    "Microsoft.DataFactory/factories/integrationRuntimes": {
        "properties": {
            "typeProperties": {
                "*": "="
            }
        }
    },
    "Microsoft.DataFactory/factories/triggers": {
        "properties": {
            "typeProperties": {
                "recurrence": {
                    "*": "=",
                    "interval": "=:triggerSuffix:number",
                    "frequency": "=:-freq"
                },
                "maxConcurrency": "="
            }
        }
    },
    "Microsoft.DataFactory/factories/linkedServices": {
        "*": {
            "properties": {
                "typeProperties": {
                    "accountName": "=",
                    "username": "=",
                    "connectionString": "|:-connectionString:secureString",
                    "secretAccessKey": "|"
                }
            }
        },
        "AzureDataLakeStore": {
            "properties": {
                "typeProperties": {
                    "dataLakeStoreUri": "="
                }
            }
        }
    },
    "Microsoft.DataFactory/factories/datasets": {
        "properties": {
            "typeProperties": {
                "*": "="
            }
        }
    }
}

Abaixo está uma explicação de como o modelo acima é construído, dividido por tipo de recurso.Below is an explanation of how the above template is constructed, broken down by resource type.

PipelinesPipelines

  • Qualquer propriedade no caminho Activities/typeproperties/waitTimeInSeconds é parametrizada.Any property in the path activities/typeProperties/waitTimeInSeconds is parameterized. Qualquer atividade em um pipeline que tenha uma propriedade de nível de código chamada waitTimeInSeconds (por exemplo, a atividade Wait) é parametrizada como um número, com um nome padrão.Any activity in a pipeline that has a code-level property named waitTimeInSeconds (for example, the Wait activity) is parameterized as a number, with a default name. Mas ele não terá um valor padrão no modelo do Resource Manager.But it won't have a default value in the Resource Manager template. Será uma entrada obrigatória durante a implantação do Gerenciador de recursos.It will be a mandatory input during the Resource Manager deployment.
  • Da mesma forma, uma propriedade chamada headers (por exemplo, em uma atividade Web) é parametrizada com o tipo object (JObject).Similarly, a property called headers (for example, in a Web activity) is parameterized with type object (JObject). Ele tem um valor padrão, que é o mesmo valor que na fábrica de origem.It has a default value, which is the same value as in the source factory.

IntegrationRuntimesIntegrationRuntimes

  • Todas as propriedades no caminho typeProperties são parametrizadas com seus respectivos valores padrão.All properties under the path typeProperties are parameterized with their respective default values. Por exemplo, há duas propriedades em Propriedades de tipo IntegrationRuntimes : computeProperties e ssisProperties.For example, there are two properties under IntegrationRuntimes type properties: computeProperties and ssisProperties. Ambos os tipos de propriedade são criados com seus respectivos valores e tipos padrão (objeto).Both property types are created with their respective default values and types (Object).

AcionadoresTriggers

  • Em typeProperties, duas propriedades são parametrizadas.Under typeProperties, two properties are parameterized. O primeiro é maxConcurrency, que é especificado para ter um valor padrão e é do tipostring.The first one is maxConcurrency, which is specified to have a default value and is of typestring. Ele tem o nome de parâmetro padrão de <entityName>_properties_typeProperties_maxConcurrency.It has the default parameter name of <entityName>_properties_typeProperties_maxConcurrency.
  • A propriedade recurrence também é parametrizada.The recurrence property also is parameterized. Sob ele, todas as propriedades nesse nível são especificadas para serem parametrizadas como cadeias de caracteres, com valores padrão e nomes de parâmetro.Under it, all properties at that level are specified to be parameterized as strings, with default values and parameter names. Uma exceção é a propriedade interval, que é parametrizada como um tipo numérico, e com o nome do parâmetro sufixado com <entityName>_properties_typeProperties_recurrence_triggerSuffix.An exception is the interval property, which is parameterized as number type, and with the parameter name suffixed with <entityName>_properties_typeProperties_recurrence_triggerSuffix. Da mesma forma, a propriedade freq é uma cadeia de caracteres e é parametrizada como uma cadeia de caracteres.Similarly, the freq property is a string and is parameterized as a string. No entanto, a propriedade freq é parametrizada sem um valor padrão.However, the freq property is parameterized without a default value. O nome é reduzido e sufixado.The name is shortened and suffixed. Por exemplo, <entityName>_freq.For example, <entityName>_freq.

LinkedServicesLinkedServices

  • Os serviços vinculados são exclusivos.Linked services are unique. Como os serviços vinculados e os conjuntos de linhas têm uma ampla gama de tipos, você pode fornecer personalização específica de tipo.Because linked services and datasets have a wide range of types, you can provide type-specific customization. Neste exemplo, todos os serviços vinculados do tipo AzureDataLakeStore, um modelo específico será aplicado e, para todos os outros (via *), um modelo diferente será aplicado.In this example, all linked services of type AzureDataLakeStore, a specific template will be applied, and for all others (via *) a different template will be applied.
  • A propriedade connectionString será parametrizada como um valor de securestring, não terá um valor padrão e terá um nome de parâmetro abreviado com connectionString.The connectionString property will be parameterized as a securestring value, it won't have a default value, and it will have a shortened parameter name that's suffixed with connectionString.
  • A propriedade secretAccessKey é um AzureKeyVaultSecret (por exemplo, em um serviço vinculado AmazonS3).The property secretAccessKey happens to be an AzureKeyVaultSecret (for example, in an AmazonS3 linked service). Ele é parametrizado automaticamente como um Azure Key Vault segredo e buscado a partir do cofre de chaves configurado.It's automatically parameterized as an Azure Key Vault secret and fetched from the configured key vault. Você também pode parametrizar o cofre de chaves em si.You can also parameterize the key vault itself.

Conjuntos de dadosDatasets

  • Embora a personalização específica de tipo esteja disponível para conjuntos de valores, a configuração pode ser fornecida sem ter explicitamente uma configuração de nível *.Although type-specific customization is available for datasets, configuration can be provided without explicitly having a *-level configuration. No exemplo acima, todas as propriedades de DataSet em typeProperties são parametrizadas.In the above example, all dataset properties under typeProperties are parameterized.

Modelo de parametrização padrãoDefault parameterization template

Veja abaixo o modelo de parametrização padrão atual.Below is the current default parameterization template. Se você só precisa adicionar um ou alguns parâmetros, editar isso diretamente pode ser útil, pois você não perderá a estrutura de parametrização existente.If you only need to add a one or a few parameters, editing this directly may be helpful as you will not lose the existing parameterization structure.

{
    "Microsoft.DataFactory/factories/pipelines": {
    },
    "Microsoft.DataFactory/factories/integrationRuntimes":{
        "properties": {
            "typeProperties": {
                "ssisProperties": {
                    "catalogInfo": {
                        "catalogServerEndpoint": "=",
                        "catalogAdminUserName": "=",
                        "catalogAdminPassword": {
                            "value": "-::secureString"
                        }
                    },
                    "customSetupScriptProperties": {
                        "sasToken": {
                            "value": "-::secureString"
                        }
                    }
                },
                "linkedInfo": {
                    "key": {
                        "value": "-::secureString"
                    },
                    "resourceId": "="
                }
            }
        }
    },
    "Microsoft.DataFactory/factories/triggers": {
        "properties": {
            "pipelines": [{
                    "parameters": {
                        "*": "="
                    }
                },  
                "pipelineReference.referenceName"
            ],
            "pipeline": {
                "parameters": {
                    "*": "="
                }
            },
            "typeProperties": {
                "scope": "="
            }

        }
    },
    "Microsoft.DataFactory/factories/linkedServices": {
        "*": {
            "properties": {
                "typeProperties": {
                    "accountName": "=",
                    "username": "=",
                    "userName": "=",
                    "accessKeyId": "=",
                    "servicePrincipalId": "=",
                    "userId": "=",
                    "clientId": "=",
                    "clusterUserName": "=",
                    "clusterSshUserName": "=",
                    "hostSubscriptionId": "=",
                    "clusterResourceGroup": "=",
                    "subscriptionId": "=",
                    "resourceGroupName": "=",
                    "tenant": "=",
                    "dataLakeStoreUri": "=",
                    "baseUrl": "=",
                    "database": "=",
                    "serviceEndpoint": "=",
                    "batchUri": "=",
                    "databaseName": "=",
                    "systemNumber": "=",
                    "server": "=",
                    "url":"=",
                    "aadResourceId": "=",
                    "connectionString": "|:-connectionString:secureString"
                }
            }
        },
        "Odbc": {
            "properties": {
                "typeProperties": {
                    "userName": "=",
                    "connectionString": {
                        "secretName": "="
                    }
                }
            }
        }
    },
    "Microsoft.DataFactory/factories/datasets": {
        "*": {
            "properties": {
                "typeProperties": {
                    "folderPath": "=",
                    "fileName": "="
                }
            }
        }}
}

Veja abaixo um exemplo de como adicionar um único valor ao modelo de parametrização padrão. Só queremos adicionar uma ID de cluster interativo do databricks interativo para um serviço vinculado do databricks ao arquivo de parâmetros. Observe que o arquivo abaixo é o mesmo que o arquivo acima, exceto para existingClusterId incluído no campo de propriedades de Microsoft.DataFactory/factories/linkedServices.Note the below file is the same as the above file except for existingClusterId included under the properties field of Microsoft.DataFactory/factories/linkedServices.

{
    "Microsoft.DataFactory/factories/pipelines": {
    },
    "Microsoft.DataFactory/factories/integrationRuntimes":{
        "properties": {
            "typeProperties": {
                "ssisProperties": {
                    "catalogInfo": {
                        "catalogServerEndpoint": "=",
                        "catalogAdminUserName": "=",
                        "catalogAdminPassword": {
                            "value": "-::secureString"
                        }
                    },
                    "customSetupScriptProperties": {
                        "sasToken": {
                            "value": "-::secureString"
                        }
                    }
                },
                "linkedInfo": {
                    "key": {
                        "value": "-::secureString"
                    },
                    "resourceId": "="
                }
            }
        }
    },
    "Microsoft.DataFactory/factories/triggers": {
        "properties": {
            "pipelines": [{
                    "parameters": {
                        "*": "="
                    }
                },  
                "pipelineReference.referenceName"
            ],
            "pipeline": {
                "parameters": {
                    "*": "="
                }
            },
            "typeProperties": {
                "scope": "="
            }
 
        }
    },
    "Microsoft.DataFactory/factories/linkedServices": {
        "*": {
            "properties": {
                "typeProperties": {
                    "accountName": "=",
                    "username": "=",
                    "userName": "=",
                    "accessKeyId": "=",
                    "servicePrincipalId": "=",
                    "userId": "=",
                    "clientId": "=",
                    "clusterUserName": "=",
                    "clusterSshUserName": "=",
                    "hostSubscriptionId": "=",
                    "clusterResourceGroup": "=",
                    "subscriptionId": "=",
                    "resourceGroupName": "=",
                    "tenant": "=",
                    "dataLakeStoreUri": "=",
                    "baseUrl": "=",
                    "database": "=",
                    "serviceEndpoint": "=",
                    "batchUri": "=",
                    "databaseName": "=",
                    "systemNumber": "=",
                    "server": "=",
                    "url":"=",
                    "aadResourceId": "=",
                    "connectionString": "|:-connectionString:secureString",
                    "existingClusterId": "-"
                }
            }
        },
        "Odbc": {
            "properties": {
                "typeProperties": {
                    "userName": "=",
                    "connectionString": {
                        "secretName": "="
                    }
                }
            }
        }
    },
    "Microsoft.DataFactory/factories/datasets": {
        "*": {
            "properties": {
                "typeProperties": {
                    "folderPath": "=",
                    "fileName": "="
                }
            }
        }}
}

Modelos vinculados do Resource ManagerLinked Resource Manager templates

Se você configurou CI/CD (integração e implantação contínuas) para suas fábricas de dados, poderá encontrar os limites do modelo de Azure Resource Manager à medida que sua fábrica aumentar.If you've set up continuous integration and deployment (CI/CD) for your Data Factories, you may run into the Azure Resource Manager template limits as your factory grows bigger. Um exemplo de limite é o número máximo de recursos em um modelo do Resource Manager.An Example of a limit is the maximum number of resources in a Resource Manager template. Para acomodar grandes fábricas, juntamente com a geração do modelo completo do Resource Manager para uma fábrica, Data Factory agora gera modelos vinculados do Resource Manager.To accommodate large factories, along with generating the full Resource Manager template for a factory, Data Factory now generates Linked Resource Manager templates. Com esse recurso, toda a carga de fábrica é dividida em vários arquivos, de forma que você não fique em limites.With this feature, the entire factory payload is broken down into several files so you don’t run into the limits.

Se você tiver configurado o Git, os modelos vinculados serão gerados e salvos junto com os modelos completos do Resource Manager na ramificação adf_publish em uma nova pasta chamada linkedTemplates.If you've configured Git, the linked templates are generated and saved alongside the full Resource Manager templates in the adf_publish branch under a new folder called linkedTemplates.

Pasta de modelos do Resource Manager vinculado

Os modelos vinculados do Resource Manager geralmente têm um modelo mestre e um conjunto de modelos filho vinculados ao mestre.The Linked Resource Manager templates usually have a master template and a set of child templates linked to the master. O modelo pai é chamado de ArmTemplate_master.json, e os modelos filho são nomeados com o padrão ArmTemplate_0.json, ArmTemplate_1.json e assim por diante.The parent template is called ArmTemplate_master.json, and child templates are named with the pattern ArmTemplate_0.json, ArmTemplate_1.json, and so on. Para usar modelos vinculados em vez do modelo completo do Resource Manager, atualize sua tarefa de CI/CD para apontar para ArmTemplate_master.json em vez de ArmTemplateForFactory.json (o modelo completo do Resource Manager).To use linked templates instead of the full Resource Manager template, update your CI/CD task to point to ArmTemplate_master.json instead of ArmTemplateForFactory.json (the full Resource Manager template). O Gerenciador de recursos também exige que você carregue os modelos vinculados em uma conta de armazenamento para que eles possam ser acessados pelo Azure durante a implantação.Resource Manager also requires you to upload the linked templates into a storage account so that they can be accessed by Azure during deployment. Para obter mais informações, consulte implantando modelos ARM vinculados com o VSTS.For more info, see Deploying Linked ARM Templates with VSTS.

Lembre-se de adicionar os scripts de Data Factory em seu pipeline de CI/CD antes e depois da tarefa de implantação.Remember to add the Data Factory scripts in your CI/CD pipeline before and after the deployment task.

Se você não tiver o Git configurado, os modelos vinculados poderão ser acessados por meio do gesto de exportação do modelo ARM .If you don’t have Git configured, the linked templates are accessible via the Export ARM template gesture.

Branch de produção de correção automáticaHot-fix production branch

Se você implantar uma fábrica na produção e perceber que há um bug que precisa ser corrigido imediatamente, mas não é possível implantar o Branch de colaboração atual, talvez seja necessário implantar uma correção automática.If you deploy a factory to production and realize there's a bug that needs to be fixed right away, but you can't deploy the current collaboration branch, you may need to deploy a hot-fix. Essa abordagem é conhecida como engenharia de correção rápida ou QFE.This approach is as known as quick-fix engineering or QFE.

  1. No Azure DevOps, vá para a versão que foi implantada para produção e localize a última confirmação implantada.In Azure DevOps, go to the release that was deployed to production and find the last commit that was deployed.

  2. Na mensagem de confirmação, obtenha a ID de confirmação da ramificação de colaboração.From the commit message, get the commit ID of collaboration branch.

  3. Crie uma nova ramificação de Hot Fix a partir dessa confirmação.Create a new hot-fix branch from that commit.

  4. Vá para o Azure Data Factory UX e alterne para essa ramificação.Go to the Azure Data Factory UX and switch to this branch.

  5. Usando o Azure Data Factory UX, corrija o bug.Using the Azure Data Factory UX, fix the bug. Teste suas alterações.Test your changes.

  6. Depois que a correção tiver sido verificada, clique em Exportar modelo do ARM para obter o modelo do Gerenciador de recursos de correção automática.Once the fix has been verified, click on Export ARM template to get the hot-fix Resource Manager template.

  7. Faça check-in manual dessa compilação para a ramificação adf_publish.Manually check in this build to the adf_publish branch.

  8. Se você configurou o pipeline de liberação para disparar automaticamente com base em adf_publish check-ins, uma nova versão será iniciada automaticamente.If you've configured your release pipeline to automatically trigger based on adf_publish check-ins, a new release will automatically start. Caso contrário, enfileirar manualmente uma versão.Otherwise, manually queue a release.

  9. Implante a versão de Hot Fix para as fábricas de teste e produção.Deploy the hot-fix release to the test and production factories. Esta versão contém a carga de produção anterior mais a correção feita na etapa 5.This release contains the previous production payload plus the fix made in step 5.

  10. Adicione as alterações da ramificação Hot-Fix para desenvolvimento para que as versões posteriores não sejam executadas no mesmo bug.Add the changes from the hot-fix to development branch so that later releases will not run into the same bug.

Práticas recomendadas para CI/CDBest practices for CI/CD

Se você estiver usando a integração do git com seu data factory e tiver um pipeline de CI/CD que move as alterações do desenvolvimento para o teste e, em seguida, para a produção, recomendamos as seguintes práticas recomendadas:If you're using Git integration with your data factory, and you have a CI/CD pipeline that moves your changes from Development into Test and then to Production, we recommend the following best practices:

  • Integração com o Git.Git Integration. Você só precisa configurar seu data factory de desenvolvimento com a integração do git.You're only required to configure your Development data factory with Git integration. As alterações no teste e na produção são implantadas por meio de CI/CD e não precisam de integração com o git.Changes to Test and Production are deployed via CI/CD, and don't need Git integration.

  • Script data Factory CI/CD.Data Factory CI/CD script. Antes da etapa de implantação do Gerenciador de recursos no CI/CD, determinadas tarefas são necessárias, como parar/iniciar de gatilhos e limpeza.Before the Resource Manager deployment step in CI/CD, certain tasks are required such as stopping/starting of triggers and cleanup. É recomendável usar scripts do PowerShell antes e depois da implantação.We recommend using powershell scripts before and after deployment. Para obter mais informações, consulte Atualizar gatilhos ativos.For more information, see Update active triggers.

  • Tempos de execução de integração e compartilhamento.Integration Runtimes and sharing. Os tempos de execução de integração não são alterados com frequência e são semelhantes em todos os estágios em seu CI/CD.Integration Runtimes don't change often and are similar across all stages in your CI/CD. Como resultado, Data Factory espera que você tenha o mesmo nome e o mesmo tipo de tempos de execução de integração em todos os estágios de CI/CD.As a result, Data Factory expects you to have the same name and same type of Integration Runtimes across all stages of CI/CD. Se você estiver procurando compartilhar tempos de execução de integração em todos os estágios, considere usar uma fábrica ternário apenas para conter os tempos de execução de integração compartilhados.If you're looking to share Integration Runtimes across all stages, consider using a ternary factory just for containing the shared Integration Runtimes. Você pode usar essa fábrica compartilhada em todos os seus ambientes como um tipo de tempo de execução de integração vinculado.You can use this shared factory in all of your environments as a linked integration runtime type.

  • Key Vault.Key Vault. Ao usar Azure Key Vault serviços vinculados, você pode aproveitar ainda mais as vantagens dele mantendo cofres de chaves separados para ambientes diferentes.When you use Azure Key Vault based linked services, you can take advantages of it further by keeping separate key vaults for different environments. Você também pode configurar níveis de permissão separados para cada um deles.You can also configure separate permission levels for each of them. Por exemplo, talvez você não queira que os membros da equipe tenham permissões para os segredos de produção.For example, you may not want your team members to have permissions to production secrets. Se você seguir essa abordagem, é recomendável manter os mesmos nomes de segredo em todos os estágios.If you follow this approach, it's recommended you to keep the same secret names across all stages. Se você mantiver os mesmos nomes, não precisará alterar seus modelos do Resource Manager em ambientes de CI/CD, pois a única coisa que muda é o nome do cofre de chaves, que é um dos parâmetros do modelo do Resource Manager.If you keep the same names, you don't have to change your Resource Manager templates across CI/CD environments since the only thing that changes is the key vault name, which is one of the Resource Manager template parameters.

Recursos sem suporteUnsupported features

  • Por design , o ADF não permite confirmações de seleção de Cherry ou publicação seletiva de recursos.By design, ADF does not allow cherry-picking commits or selective publishing of resources. As publicações incluirão todas as alterações feitas no data FactoryPublishes will include all changes made in the data factory

    • As entidades do data Factory dependem umas das outras, por exemplo, os gatilhos dependem de pipelines, os pipelines dependem de conjuntos de dados e outros pipelines, etc. A publicação seletiva de um subconjunto de recursos pode levar a comportamentos e erros inesperadosData factory entities depend on each other, for instance, triggers depend on pipelines, pipelines depend on datasets and other pipelines, etc. Selective publishing of a subset of resources may lead to unexpected behaviors and errors
    • Em raras ocasiões em que a publicação seletiva é necessária, você pode considerar uma correção automática.On rare occasions where selective publishing is required, you may consider a hot-fix. Para obter mais informações, consulte Branch de produção de correção automáticaFor more information, see Hot-Fix Production Branch
  • Não é possível publicar de branches particularesYou cannot publish from private branches

  • A partir de agora, você não pode hospedar projetos no bitbucketAs of now, you cannot host projects on Bitbucket