Průběžná integrace a doručování v Azure Data FactoryContinuous integration and delivery in Azure Data Factory

PřehledOverview

Nepřetržitá integrace je postup testování každé změny provedené v základu kódu automaticky a co nejdříve.Continuous integration is the practice of testing each change made to your codebase automatically and as early as possible. Průběžné doručování se řídí testováním, které se provádí během nepřetržité integrace a vkládání změn do pracovního nebo produkčního systému. Continuous delivery follows the testing that happens during continuous integration and pushes changes to a staging or production system.

V Azure Data Factory průběžná integrace a doručování (CI/CD) znamená přesun Data Factory kanálů z jednoho prostředí (vývoj, testování, produkce) do jiného.In Azure Data Factory, continuous integration and delivery (CI/CD) means moving Data Factory pipelines from one environment (development, test, production) to another. K provedení CI/CD můžete použít Data Factory Integration prostředí s Azure Resource Manager šablony.You can use Data Factory UX integration with Azure Resource Manager templates to do CI/CD.

V prostředí Data Factory UX můžete vygenerovat Správce prostředků šablonu z rozevírací nabídky Šablona ARM .In the Data Factory UX, you can generate a Resource Manager template from the ARM Template drop-down menu. Když vyberete Exportovat šablonu ARM, portál vygeneruje šablonu správce prostředků pro objekt pro vytváření dat a konfigurační soubor, který obsahuje všechny připojovací řetězce a další parametry.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 connection strings and other parameters. Pak vytvoříte jeden konfigurační soubor pro každé prostředí (vývoj, testování, produkce).Then you create one configuration file for each environment (development, test, production). Hlavní soubor šablony Správce prostředků zůstává stejný pro všechna prostředí.The main Resource Manager template file remains the same for all the environments.

9 minut Úvod k této funkci a ukázce najdete v tomto videu:For a nine-minute introduction to this feature and a demonstration, watch this video:

Poznámka

Tento článek je aktualizovaný a využívá nový modul Az Azure PowerShellu.This article has been updated to use the new Azure PowerShell Az module. Můžete dál využívat modul AzureRM, který bude dostávat opravy chyb nejméně do prosince 2020.You can still use the AzureRM module, which will continue to receive bug fixes until at least December 2020. Další informace o kompatibilitě nového modulu Az a modulu AzureRM najdete v tématu Seznámení s novým modulem Az Azure PowerShellu.To learn more about the new Az module and AzureRM compatibility, see Introducing the new Azure PowerShell Az module. Pokyny k instalaci modulu Az najdete v tématu věnovaném instalaci Azure PowerShellu.For Az module installation instructions, see Install Azure PowerShell.

Životní cyklus CI/CDCI/CD lifecycle

Níže najdete ukázkový Přehled životního cyklu CI/CD v objektu pro vytváření dat Azure, který je nakonfigurovaný pomocí Azure Repos Git.Below is a sample overview of the CI/CD lifecycle in an Azure data factory that's configured with Azure Repos Git. Další informace o tom, jak nakonfigurovat úložiště Git, najdete v tématu Správa zdrojového kódu v Azure Data Factory.For more information on how to configure a Git repository, see Source control in Azure Data Factory.

  1. Vývojovou datovou továrnu vytvoří a nakonfiguruje s Azure Repos Git.A development data factory is created and configured with Azure Repos Git. Všichni vývojáři by měli mít oprávnění k vytváření Data Factorych prostředků, jako jsou kanály a datové sady.All developers should have permission to author Data Factory resources like pipelines and datasets.

  2. Vzhledem k tomu, že vývojáři provádějí změny ve svých větvích funkcí, ladí jejich kanál spuštění s nejnovějšími změnami.As the developers make changes in their feature branches, they debug their pipeline runs with their most recent changes. Další informace o tom, jak ladit spuštění kanálu, najdete v tématu iterativní vývoj a ladění pomocí Azure Data Factory.For more information on how to debug a pipeline run, see Iterative development and debugging with Azure Data Factory.

  3. Jakmile se vývojářům splní jejich změny, vytvoří žádost o přijetí změn ze své větve funkce do hlavní větve nebo do větve pro spolupráci, aby bylo možné jejich změny zkontrolovat v partnerských vztazích.After 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. Po schválení žádosti o přijetí změn a jejich sloučení do hlavní větve můžete změny publikovat do továrny pro vývoj.After a pull request is approved and changes are merged in the master branch, the changes can be published to the development factory.

  5. Když je tým připraven k nasazení změn do testovací továrny a následně do výrobní továrny, tým Exportuje šablonu Správce prostředků z hlavní větve.When the team is ready to deploy the changes to the test factory and then to the production factory, the team exports the Resource Manager template from the master branch.

  6. Exportovaná šablona Správce prostředků je nasazena s různými soubory parametrů do testovací továrny a produkční továrny.The exported Resource Manager template is deployed with different parameter files to the test factory and the production factory.

Vytvoření šablony Správce prostředků pro každé prostředíCreate a Resource Manager template for each environment

  1. V seznamu šablon ARM vyberte Exportovat šablonu ARM a exportujte šablonu správce prostředků pro vaši datovou továrnu ve vývojovém prostředí.In the ARM Template list, select Export ARM Template to export the Resource Manager template for your data factory in the development environment.

    Export šablony Správce prostředků

  2. V továrnách testovacích a produkčních dat vyberte Importovat šablonu ARM.In your test and production data factories, select Import ARM Template. Tato akce přejde do Azure Portal, kde můžete importovat exportovanou šablonu.This action takes you to the Azure portal, where you can import the exported template. Vyberte vytvořit vlastní šablonu v editoru a otevřete tak editor šablon Správce prostředků.Select Build your own template in the editor to open the Resource Manager template editor.

    Vytvoření vlastní šablony

  3. Vyberte načíst soubora pak vyberte vygenerovanou šablonu správce prostředků.Select Load file, and then select the generated Resource Manager template.

    Upravit šablonu

  4. V části nastavení zadejte hodnoty konfigurace, jako jsou přihlašovací údaje k propojeným službám.In the settings section, enter the configuration values, like linked service credentials. Až budete hotovi, vyberte koupit a nasaďte šablonu správce prostředků.When you're done, select Purchase to deploy the Resource Manager template.

    Oddíl nastavení

Připojovací řetězceConnection strings

Informace o tom, jak nakonfigurovat připojovací řetězce, najdete v článku konektoru.For information on how to configure connection strings, see the connector's article. Například pro Azure SQL Database, přečtěte si téma kopírování dat do nebo z Azure SQL Database pomocí Azure Data Factory.For example, for Azure SQL Database, see Copy data to or from Azure SQL Database by using Azure Data Factory. Chcete-li ověřit připojovací řetězec, můžete otevřít zobrazení kódu pro prostředek v prostředí Data Factoryho uživatelského rozhraní.To verify a connection string, you can open the code view for the resource in the Data Factory UX. V zobrazení kódu je odstraněna část hesla nebo klíč účtu v připojovacím řetězci.In code view, the password or account key portion of the connection string is removed. Chcete-li otevřít zobrazení kódu, vyberte ikonu zvýrazněnou zde:To open code view, select the icon highlighted here:

Otevřením zobrazení kódu zobrazíte připojovací řetězec.

Automatizace kontinuální integrace pomocí Azure Pipelinesch verzíAutomate continuous integration by using Azure Pipelines releases

Následuje návod pro nastavení verze Azure Pipelines, která automatizuje nasazení datové továrny do více prostředí.Following is a guide for setting up an Azure Pipelines release, which automates the deployment of a data factory to multiple environments.

Diagram kontinuální integrace s Azure Pipelines

PožadavkyRequirements

Nastavení verze Azure PipelinesSet up an Azure Pipelines release

  1. V Azure DevOpsotevřete projekt, který je nakonfigurovaný s vaší datovou továrnou.In Azure DevOps, open the project that's configured with your data factory.

  2. Na levé straně stránky vyberte kanálya pak vyberte vydané verze.On the left side of the page, select Pipelines, and then select Releases.

    Výběr kanálů, vydání

  3. Vyberte Nový kanál, nebo pokud už máte kanály, vyberte Nový a pak Nový kanál verze.Select New pipeline, or, if you have existing pipelines, select New and then New release pipeline.

  4. Vyberte prázdnou šablonu úlohy .Select the Empty job template.

    Vybrat prázdnou úlohu

  5. Do pole název fáze zadejte název vašeho prostředí.In the Stage name box, enter the name of your environment.

  6. Vyberte Přidat artefakta pak vyberte úložiště nakonfigurované pro vaši datovou továrnu.Select Add artifact, and then select the repository configured with your data factory. Pro výchozí větevvyberte adf_publish .Select adf_publish for the Default branch. U výchozí verzevyberte možnost nejnovější z výchozí větve.For the Default version, select Latest from default branch.

    Přidání artefaktu

  7. Přidat úlohu nasazení Azure Resource Manager:Add an Azure Resource Manager Deployment task:

    a.a. V zobrazení fáze vyberte možnost Zobrazit úlohy fáze.In the stage view, select View stage tasks.

    Zobrazení fáze

    b.b. Vytvoří nový úkol.Create a new task. Vyhledejte nasazení skupiny prostředků Azurea pak vyberte Přidat.Search for Azure Resource Group Deployment, and then select Add.

    c.c. V úloze nasazení vyberte předplatné, skupinu prostředků a umístění pro cílovou datovou továrnu.In the Deployment task, select the subscription, resource group, and location for the target data factory. V případě potřeby zadejte přihlašovací údaje.Provide credentials if necessary.

    d.d. V seznamu Akce vyberte vytvořit nebo aktualizovat skupinu prostředků.In the Action list, select Create or update resource group.

    e.e. Vyberte tlačítko se třemi tečkami ( ... ) vedle pole Šablona .Select the ellipsis button () next to the Template box. Vyhledejte šablonu Azure Resource Manager vytvořenou pomocí importu šablony ARM v části Vytvoření správce prostředků šablony pro každé prostředí tohoto článku.Browse for the Azure Resource Manager template that you created by using Import ARM Template in the Create a Resource Manager template for each environment section of this article. Vyhledejte tento soubor ve složce větve adf_publish.Look for this file in the folder of the adf_publish branch.

    f.f. Vybrat ...Select vedle pole parametry šablony pro výběr souboru parametrů.next to the Template parameters box to choose the parameters file. Soubor, který zvolíte, bude záviset na tom, zda jste vytvořili kopii nebo používáte výchozí soubor ARMTemplateParametersForFactory. JSON.The file you choose will depend on whether you created a copy or are using the default file, ARMTemplateParametersForFactory.json.

    g.g. Vybrat ...Select vedle pole přepsat parametry šablony a zadejte informace pro cílovou datovou továrnu.next to the Override template parameters box, and enter the information for the target data factory. Pro přihlašovací údaje pocházející z Azure Key Vault zadejte název tajného kódu mezi dvojité uvozovky.For credentials that come from Azure Key Vault, enter the secret's name between double quotation marks. Pokud je například název tajného klíče cred1, zadejte pro tuto hodnotu "$ (cred1)" .For example, if the secret's name is cred1, enter "$(cred1)" for this value.

    h.h. Vyberte přírůstkový režim nasazení.Select Incremental for the Deployment mode.

    Varování

    Pokud pro režim nasazenívyberete Dokončit , můžou se odstranit existující prostředky, včetně všech prostředků v cílové skupině prostředků, které nejsou definované v šabloně správce prostředků.If you select Complete for the Deployment mode, existing resources might be deleted, including all resources in the target resource group that aren't defined in the Resource Manager template.

    Data Factory výrobního nasazení

  8. Uložte kanál pro vydávání verzí.Save the release pipeline.

  9. Pokud chcete aktivovat vydanou verzi, vyberte vytvořit vydání.To trigger a release, select Create release.

    Vyberte vytvořit vydání.

Důležité

Ve scénářích CI/CD musí být typ prostředí Integration runtime (IR) v různých prostředích stejný.In CI/CD scenarios, the integration runtime (IR) type in different environments must be the same. Například pokud máte v prostředí pro vývoj v místním prostředí IR, stejný IR musí být také typu v místním prostředí v jiných prostředích, jako je například test a produkce.For example, if you have a self-hosted IR in the development environment, the same IR must also be of type self-hosted in other environments, such as test and production. Podobně pokud sdílíte prostředí Integration runtime v několika fázích, je nutné nakonfigurovat prostředí Integration runtime jako propojená místně ve všech prostředích, jako je vývoj, testování a produkce.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.

Získání tajných kódů z Azure Key VaultGet secrets from Azure Key Vault

Pokud máte tajné kódy, které byste měli předat do šablony Azure Resource Manager, doporučujeme používat Azure Key Vault s Azure Pipelinesou verzí.If you have secrets to pass in an Azure Resource Manager template, we recommend that you use Azure Key Vault with the Azure Pipelines release.

Existují dva způsoby, jak pokládat s tajnými kódy:There are two ways to handle secrets:

  1. Přidejte tajné klíče do souboru Parameters.Add the secrets to parameters file. Další informace najdete v tématu použití Azure Key Vault k předání hodnoty zabezpečeného parametru během nasazování.For more info, see Use Azure Key Vault to pass secure parameter value during deployment.

    Vytvořte kopii souboru parametrů, který se nahraje do větve publikování.Create a copy of the parameters file that's uploaded to the publish branch. Pomocí tohoto formátu nastavte hodnoty parametrů, které chcete získat z Key Vault:Set the values of the parameters that you want to get from Key Vault by using this format:

    {
        "parameters": {
            "azureSqlReportingDbPassword": {
                "reference": {
                    "keyVault": {
                        "id": "/subscriptions/<subId>/resourceGroups/<resourcegroupId> /providers/Microsoft.KeyVault/vaults/<vault-name> "
                    },
                    "secretName": " < secret - name > "
                }
            }
        }
    }
    

    Když použijete tuto metodu, tajný kód se automaticky načte z trezoru klíčů.When you use this method, the secret is pulled from the key vault automatically.

    Soubor parametrů musí být také ve větvi publikování.The parameters file needs to be in the publish branch as well.

  • Přidejte úlohu Azure Key Vault před úlohu nasazení Azure Resource Manager popsané v předchozí části:Add an Azure Key Vault task before the Azure Resource Manager Deployment task described in the previous section:

    1. Na kartě úlohy vytvořte novou úlohu.On the Tasks tab, create a new task. Vyhledejte Azure Key Vault a přidejte ji.Search for Azure Key Vault and add it.

    2. V úloze Key Vault vyberte předplatné, ve kterém jste Trezor klíčů vytvořili.In the Key Vault task, select the subscription in which you created the key vault. V případě potřeby zadejte přihlašovací údaje a pak vyberte Trezor klíčů.Provide credentials if necessary, and then select the key vault.

    Přidat úlohu Key Vault

    Udělit oprávnění agentovi Azure PipelinesGrant permissions to the Azure Pipelines agent

    Azure Key Vault úloha může selhat s chybou odepření přístupu, pokud nejsou nastavená správná oprávnění.The Azure Key Vault task might fail with an Access Denied error if the correct permissions aren't set. Stáhněte si protokoly pro vydání a vyhledejte soubor. ps1, který obsahuje příkaz pro udělení oprávnění agentovi Azure Pipelines.Download the logs for the release, and locate the .ps1 file that contains the command to give permissions to the Azure Pipelines agent. Příkaz lze spustit přímo.You can run the command directly. Případně můžete ze souboru zkopírovat ID objektu zabezpečení a zásadu přístupu přidat ručně v Azure Portal.Or you can copy the principal ID from the file and add the access policy manually in the Azure portal. minimálními potřebnými oprávněními jsou Get a List.Get and List are the minimum permissions required.

Aktualizovat aktivní aktivační událostiUpdate active triggers

Pokud se pokusíte aktualizovat aktivní aktivační události, může nasazení selhat.Deployment can fail if you try to update active triggers. Chcete-li aktualizovat aktivní aktivační události, je nutné je ručně zastavit a po nasazení je znovu spustit.To update active triggers, you need to manually stop them and then restart them after the deployment. Můžete to provést pomocí úlohy Azure PowerShell:You can do this by using an Azure PowerShell task:

  1. Na kartě úlohy ve vydané verzi přidejte úlohu Azure PowerShell .On the Tasks tab of the release, add an Azure PowerShell task. Vyberte úlohu verze 4. *.Choose task version 4.*.

  2. Vyberte předplatné, ve kterém je váš objekt pro vytváření.Select the subscription your factory is in.

  3. Jako typ skriptu vyberte cestu k souboru skriptu .Select Script File Path as the script type. To vyžaduje uložení skriptu PowerShellu do úložiště.This requires you to save your PowerShell script in your repository. K zastavení aktivačních událostí můžete použít následující skript prostředí PowerShell:The following PowerShell script can be used to stop triggers:

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

Můžete provést podobný postup (pomocí funkce Start-AzDataFactoryV2Trigger) a restartovat triggery po nasazení.You can complete similar steps (with the Start-AzDataFactoryV2Trigger function) to restart the triggers after deployment.

Ukázka skriptu předběžného a po nasazeníSample pre- and post-deployment script

Pomocí následujícího ukázkového skriptu můžete před nasazením zastavit triggery a potom je znovu restartovat.The following sample script can be used to stop triggers before deployment and restart them afterward. Skript také obsahuje kód pro odstranění odebraných prostředků.The script also includes code to delete resources that have been removed. Uložte skript do úložiště Git Azure DevOps a prokažte ho pomocí úlohy Azure PowerShell s použitím verze 4. *.Save the script in an Azure DevOps git repository and reference it via an Azure PowerShell task using version 4.*.

Při spuštění skriptu předběžného nasazení bude nutné zadat variaci následujících parametrů v poli argumenty skriptu .When running a pre-deployment script, you will need to specify a variation of the following parameters in the Script Arguments field.

-armTemplate "$(System.DefaultWorkingDirectory)/<your-arm-template-location>" -ResourceGroupName <your-resource-group-name> -DataFactoryName <your-data-factory-name> -predeployment $true -deleteDeployment $false

Při spuštění skriptu po nasazení bude nutné zadat variaci následujících parametrů v poli argumenty skriptu .When running a post-deployment script, you will need to specify a variation of the following parameters in the Script Arguments field.

-armTemplate "$(System.DefaultWorkingDirectory)/<your-arm-template-location>" -ResourceGroupName <your-resource-group-name> -DataFactoryName <your-data-factory-name> -predeployment $false -deleteDeployment $true

![Azure PowerShell task](media/continuous-integration-deployment/continuous-integration-image11.png)

Tady je skript, který se dá použít k předběžnému a následnému nasazení.Here is the script that can be used for pre- and post-deployment. Účty IT pro odstraněné prostředky a odkazy na prostředky.It accounts for deleted resources and resource references.

param
(
    [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
)

function getPipelineDependencies {
    param([System.Object] $activity)
    if ($activity.Pipeline) {
        return @($activity.Pipeline.ReferenceName)
    } elseif ($activity.Activities) {
        $result = @()
        return $activity.Activities | ForEach-Object{ $result += getPipelineDependencies -activity $_ }
    } elseif ($activity.ifFalseActivities -or $activity.ifTrueActivities) {
        $result = @()
        $activity.ifFalseActivities | Where-Object {$_ -ne $null} | ForEach-Object{ $result += getPipelineDependencies -activity $_ }
        $activity.ifTrueActivities | Where-Object {$_ -ne $null} | ForEach-Object{ $result += getPipelineDependencies -activity $_ }
    } elseif ($activity.defaultActivities) {
        $result = @()
        $activity.defaultActivities | ForEach-Object{ $result += getPipelineDependencies -activity $_ }
        if ($activity.cases) {
            $activity.cases | ForEach-Object{ $_.activities } | ForEach-Object{$result += getPipelineDependencies -activity $_ }
        }
        return $result
    }
}

function pipelineSortUtil {
    param([Microsoft.Azure.Commands.DataFactoryV2.Models.PSPipeline]$pipeline,
    [Hashtable] $pipelineNameResourceDict,
    [Hashtable] $visited,
    [System.Collections.Stack] $sortedList)
    if ($visited[$pipeline.Name] -eq $true) {
        return;
    }
    $visited[$pipeline.Name] = $true;
    $pipeline.Activities | ForEach-Object{ getPipelineDependencies -activity $_ -pipelineNameResourceDict $pipelineNameResourceDict}  | ForEach-Object{
        pipelineSortUtil -pipeline $pipelineNameResourceDict[$_] -pipelineNameResourceDict $pipelineNameResourceDict -visited $visited -sortedList $sortedList
    }
    $sortedList.Push($pipeline)

}

function Get-SortedPipelines {
    param(
        [string] $DataFactoryName,
        [string] $ResourceGroupName
    )
    $pipelines = Get-AzDataFactoryV2Pipeline -DataFactoryName $DataFactoryName -ResourceGroupName $ResourceGroupName
    $ppDict = @{}
    $visited = @{}
    $stack = new-object System.Collections.Stack
    $pipelines | ForEach-Object{ $ppDict[$_.Name] = $_ }
    $pipelines | ForEach-Object{ pipelineSortUtil -pipeline $_ -pipelineNameResourceDict $ppDict -visited $visited -sortedList $stack }
    $sortedList = new-object Collections.Generic.List[Microsoft.Azure.Commands.DataFactoryV2.Models.PSPipeline]
    
    while ($stack.Count -gt 0) {
        $sortedList.Add($stack.Pop())
    }
    $sortedList
}

function triggerSortUtil {
    param([Microsoft.Azure.Commands.DataFactoryV2.Models.PSTrigger]$trigger,
    [Hashtable] $triggerNameResourceDict,
    [Hashtable] $visited,
    [System.Collections.Stack] $sortedList)
    if ($visited[$trigger.Name] -eq $true) {
        return;
    }
    $visited[$trigger.Name] = $true;
    $trigger.Properties.DependsOn | Where-Object {$_ -and $_.ReferenceTrigger} | ForEach-Object{
        triggerSortUtil -trigger $triggerNameResourceDict[$_.ReferenceTrigger.ReferenceName] -triggerNameResourceDict $triggerNameResourceDict -visited $visited -sortedList $sortedList
    }
    $sortedList.Push($trigger)
}

function Get-SortedTriggers {
    param(
        [string] $DataFactoryName,
        [string] $ResourceGroupName
    )
    $triggers = Get-AzDataFactoryV2Trigger -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName
    $triggerDict = @{}
    $visited = @{}
    $stack = new-object System.Collections.Stack
    $triggers | ForEach-Object{ $triggerDict[$_.Name] = $_ }
    $triggers | ForEach-Object{ triggerSortUtil -trigger $_ -triggerNameResourceDict $triggerDict -visited $visited -sortedList $stack }
    $sortedList = new-object Collections.Generic.List[Microsoft.Azure.Commands.DataFactoryV2.Models.PSTrigger]
    
    while ($stack.Count -gt 0) {
        $sortedList.Add($stack.Pop())
    }
    $sortedList
}

function Get-SortedLinkedServices {
    param(
        [string] $DataFactoryName,
        [string] $ResourceGroupName
    )
    $linkedServices = Get-AzDataFactoryV2LinkedService -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName
    $LinkedServiceHasDependencies = @('HDInsightLinkedService', 'HDInsightOnDemandLinkedService', 'AzureBatchLinkedService')
    $Akv = 'AzureKeyVaultLinkedService'
    $HighOrderList = New-Object Collections.Generic.List[Microsoft.Azure.Commands.DataFactoryV2.Models.PSLinkedService]
    $RegularList = New-Object Collections.Generic.List[Microsoft.Azure.Commands.DataFactoryV2.Models.PSLinkedService]
    $AkvList = New-Object Collections.Generic.List[Microsoft.Azure.Commands.DataFactoryV2.Models.PSLinkedService]

    $linkedServices | ForEach-Object {
        if ($_.Properties.GetType().Name -in $LinkedServiceHasDependencies) {
            $HighOrderList.Add($_)
        }
        elseif ($_.Properties.GetType().Name -eq $Akv) {
            $AkvList.Add($_)
        }
        else {
            $RegularList.Add($_)
        }
    }

    $SortedList = New-Object Collections.Generic.List[Microsoft.Azure.Commands.DataFactoryV2.Models.PSLinkedService]($HighOrderList.Count + $RegularList.Count + $AkvList.Count)
    $SortedList.AddRange($HighOrderList)
    $SortedList.AddRange($RegularList)
    $SortedList.AddRange($AkvList)
    $SortedList
}

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

#Triggers 
Write-Host "Getting triggers"
$triggersADF = Get-SortedTriggers -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-SortedPipelines -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 }
    #dataflows
    $dataflowsADF = Get-AzDataFactoryV2DataFlow -DataFactoryName $DataFactoryName -ResourceGroupName $ResourceGroupName
    $dataflowsTemplate = $resources | Where-Object { $_.type -eq "Microsoft.DataFactory/factories/dataflows" }
    $dataflowsNames = $dataflowsTemplate | ForEach-Object {$_.name.Substring(37, $_.name.Length-40) }
    $deleteddataflow = $dataflowsADF | Where-Object { $dataflowsNames -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-SortedLinkedServices -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 dataflows"
    $deleteddataflow | ForEach-Object { 
        Write-Host "Deleting dataflow " $_.Name
        Remove-AzDataFactoryV2DataFlow -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 
    }
}

Použití vlastních parametrů se šablonou Správce prostředkůUse custom parameters with the Resource Manager template

Pokud jste v režimu GIT, můžete přepsat výchozí vlastnosti v šabloně Správce prostředků, abyste nastavili vlastnosti, které jsou parametrizované v šabloně, a vlastnosti, které jsou pevně kódované.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. V těchto scénářích možná budete chtít přepsat výchozí šablonu Parametrizace:You might want to override the default parameterization template in these scenarios:

  • Používáte automatizované CI/CD a chcete změnit některé vlastnosti během nasazení Správce prostředků, ale vlastnosti nejsou ve výchozím nastavení parametrizované.You use automated CI/CD and you want to change some properties during Resource Manager deployment, but the properties aren't parameterized by default.
  • Vaše továrna je tak velká, že výchozí šablona Správce prostředků je neplatná, protože má více než maximální povolený počet parametrů (256).Your factory is so large that the default Resource Manager template is invalid because it has more than the maximum allowed parameters (256).

Pokud za těchto podmínek chcete přepsat výchozí šablonu Parametrizace, vytvořte soubor s názvem ARM-Template-Parameters-definition. JSON ve složce zadané jako kořenová složka pro integraci Git služby Data Factory.Under these conditions, to override the default parameterization template, create a file named arm-template-parameters-definition.json in the folder specified as the root folder for the data factory git integration. Je nutné použít tento přesný název souboru.You must use that exact file name. Data Factory přečte tento soubor z jakékoli větve, na které jste právě na portálu Azure Data Factory, a ne jenom z větve pro spolupráci.Data Factory reads this file from whichever branch you're currently on in the Azure Data Factory portal, not just from the collaboration branch. Můžete vytvořit nebo upravit soubor z privátní větve, kde můžete testovat své změny výběrem možnosti Exportovat šablonu ARM v uživatelském rozhraní.You can create or edit the file from a private branch, where you can test your changes by selecting Export ARM Template in the UI. Pak můžete soubor sloučit do větve pro spolupráci.You can then merge the file into the collaboration branch. Pokud se nenajde žádný soubor, použije se výchozí šablona.If no file is found, the default template is used.

Syntaxe souboru vlastních parametrůSyntax of a custom parameters file

Při vytváření souboru vlastních parametrů je třeba postupovat podle následujících pokynů.Following are some guidelines to follow when you create the custom parameters file. Soubor se skládá z oddílu pro každý typ entity: aktivační událost, kanál, propojená služba, datová sada, prostředí Integration runtime atd.The file consists of a section for each entity type: trigger, pipeline, linked service, dataset, integration runtime, and so on.

  • Zadejte cestu k vlastnosti pod odpovídajícím typem entity.Enter the property path under the relevant entity type.
  • Nastavení názvu vlastnosti na * označuje, že chcete parametrizovat všechny vlastnosti (jenom na první úrovni, ne rekurzivně).Setting a property name to * indicates that you want to parameterize all properties under it (only down to the first level, not recursively). V této konfiguraci můžete také zadat výjimky.You can also provide exceptions to this configuration.
  • Nastavení hodnoty vlastnosti jako řetězce označuje, že chcete vlastnost parametrizovat.Setting the value of a property as a string indicates that you want to parameterize the property. Použijte <action>:<name>:<stype>formátu.Use the format <action>:<name>:<stype>.
    • <action> může být jedním z těchto znaků:<action> can be one of these characters:
      • = znamená, že aktuální hodnota je jako výchozí hodnota parametru.= means keep the current value as the default value for the parameter.
      • - znamená, že nezachovají výchozí hodnotu parametru.- means don't keep the default value for the parameter.
      • | je zvláštní případ pro tajné klíče z Azure Key Vault pro připojovací řetězce nebo klíče.| is a special case for secrets from Azure Key Vault for connection strings or keys.
    • <name> je název parametru.<name> is the name of the parameter. Pokud je prázdný, převezme název vlastnosti.If it's blank, it takes the name of the property. Pokud hodnota začíná znakem -, název se zkrátí.If the value starts with a - character, the name is shortened. Například AzureStorage1_properties_typeProperties_connectionString by se zkrátila na AzureStorage1_connectionString.For example, AzureStorage1_properties_typeProperties_connectionString would be shortened to AzureStorage1_connectionString.
    • <stype> je typ parametru.<stype> is the type of parameter. Je-li <stype> prázdné, je výchozí typ string.If <stype> is blank, the default type is string. Podporované hodnoty: string, bool, number, objecta securestring.Supported values: string, bool, number, object, and securestring.
  • Zadání pole v definičním souboru znamená, že vlastnost Matching v šabloně je pole.Specifying an array in the definition file indicates that the matching property in the template is an array. Data Factory projde všemi objekty v poli pomocí definice, která je zadána v objektu Integration runtime daného pole.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. Druhý objekt, řetězec, se zobrazí jako název vlastnosti, která se používá jako název parametru pro každou iteraci.The second object, a string, becomes the name of the property, which is used as the name for the parameter for each iteration.
  • Definice nemůže být specifická pro instanci prostředku.A definition can't be specific to a resource instance. Každá definice se vztahuje na všechny prostředky daného typu.Any definition applies to all resources of that type.
  • Ve výchozím nastavení jsou všechny zabezpečené řetězce, jako jsou Key Vault tajné klíče a zabezpečené řetězce, jako jsou připojovací řetězce, klíče a tokeny, parametrizované.By default, all secure strings, like Key Vault secrets, and secure strings, like connection strings, keys, and tokens, are parameterized.

Ukázková šablona ParametrizaceSample parameterization template

Tady je příklad toho, co může šablona Parametrizace vypadat jako:Here's an example of what a parameterization template might 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": {
                "*": "="
            }
        }
    }
}

Zde je vysvětlení, jak je předchozí šablona vytvořena, rozdělená podle typu prostředku.Here's an explanation of how the preceding template is constructed, broken down by resource type.

KanályPipelines

  • Jakákoli vlastnost v cestě activities/typeProperties/waitTimeInSeconds je parametrizovaná.Any property in the path activities/typeProperties/waitTimeInSeconds is parameterized. Všechny aktivity v kanálu, které mají vlastnost na úrovni kódu s názvem waitTimeInSeconds (například aktivita Wait), jsou parametrizované jako číslo s výchozím názvem.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. V šabloně Správce prostředků ale nebude mít výchozí hodnotu.But it won't have a default value in the Resource Manager template. Během nasazení Správce prostředků se bude jednat o povinný vstup.It will be a mandatory input during the Resource Manager deployment.
  • Podobně vlastnost s názvem headers (například v aktivitě Web) je parametrizovaná pomocí typu object (JObject).Similarly, a property called headers (for example, in a Web activity) is parameterized with type object (JObject). Má výchozí hodnotu, která je stejná jako hodnota zdrojové továrny.It has a default value, which is the same value as that of the source factory.

IntegrationRuntimesIntegrationRuntimes

  • Všechny vlastnosti v rámci cesty typeProperties jsou parametrizované s příslušnými výchozími hodnotami.All properties under the path typeProperties are parameterized with their respective default values. Například existují dvě vlastnosti v rámci IntegrationRuntimes vlastnosti typu: computeProperties a ssisProperties.For example, there are two properties under IntegrationRuntimes type properties: computeProperties and ssisProperties. Oba typy vlastností jsou vytvořeny s příslušnými výchozími hodnotami a typy (Object).Both property types are created with their respective default values and types (Object).

Aktivační událostiTriggers

  • V části typePropertiesjsou parametrizované dvě vlastnosti.Under typeProperties, two properties are parameterized. První z nich je maxConcurrency, která má mít výchozí hodnotu a je typustring.The first one is maxConcurrency, which is specified to have a default value and is of typestring. Má výchozí název parametru <entityName>_properties_typeProperties_maxConcurrency.It has the default parameter name <entityName>_properties_typeProperties_maxConcurrency.
  • Vlastnost recurrence je také Parametrizovaná.The recurrence property also is parameterized. V takovém případě jsou všechny vlastnosti na dané úrovni parametrizované jako řetězce s výchozími hodnotami a názvy parametrů.Under it, all properties at that level are specified to be parameterized as strings, with default values and parameter names. Výjimkou je vlastnost interval, která je parametrizovaná jako typ number.An exception is the interval property, which is parameterized as type number. Název parametru má příponu <entityName>_properties_typeProperties_recurrence_triggerSuffix.The parameter name is suffixed with <entityName>_properties_typeProperties_recurrence_triggerSuffix. Podobně vlastnost freq je řetězec a je parametrizovaná jako řetězec.Similarly, the freq property is a string and is parameterized as a string. Vlastnost freq je však Parametrizovaná bez výchozí hodnoty.However, the freq property is parameterized without a default value. Název je zkrácen a přípona.The name is shortened and suffixed. například <entityName>_freq.For example, <entityName>_freq.

LinkedServicesLinkedServices

  • Propojené služby jsou jedinečné.Linked services are unique. Vzhledem k tomu, že propojené služby a datové sady mají široké rozsahy typů, můžete zadat vlastní nastavení pro konkrétní typ.Because linked services and datasets have a wide range of types, you can provide type-specific customization. V tomto příkladu se použije konkrétní šablona pro všechny propojené služby typu AzureDataLakeStore.In this example, for all linked services of type AzureDataLakeStore, a specific template will be applied. Pro všechny ostatní (prostřednictvím *) se použije jiná šablona.For all others (via *), a different template will be applied.
  • Vlastnost connectionString bude parametrizovaná jako hodnota securestring.The connectionString property will be parameterized as a securestring value. Nebude mít výchozí hodnotu.It won't have a default value. Bude mít zkrácený název parametru, který je connectionStrings příponou.It will have a shortened parameter name that's suffixed with connectionString.
  • Vlastnost secretAccessKey se stává AzureKeyVaultSecret (například v propojené službě Amazon S3).The property secretAccessKey happens to be an AzureKeyVaultSecret (for example, in an Amazon S3 linked service). Je automaticky Parametrizovaná jako Azure Key Vault tajný klíč a načítá se z nakonfigurovaného trezoru klíčů.It's automatically parameterized as an Azure Key Vault secret and fetched from the configured key vault. Můžete také parametrizovat samotný Trezor klíčů.You can also parameterize the key vault itself.

Datové sadyDatasets

  • I když je pro datové sady k dispozici přizpůsobení specifické pro typ, můžete zadat konfiguraci bez explicitního použití konfigurace na úrovni *.Although type-specific customization is available for datasets, you can provide configuration without explicitly having a *-level configuration. V předchozím příkladu jsou parametrizované všechny vlastnosti datové sady v rámci typeProperties.In the preceding example, all dataset properties under typeProperties are parameterized.

Výchozí šablona ParametrizaceDefault parameterization template

Následuje aktuální výchozí šablona Parametrizace.Following is the current default parameterization template. Pokud potřebujete přidat jenom několik parametrů, může být vhodné upravit přímo tuto šablonu, protože nepřijdete o existující strukturu Parametrizace.If you need to add only a few parameters, editing this template directly might be a good idea because you won't lose the existing parameterization structure.

{
    "Microsoft.DataFactory/factories/pipelines": {
    },
    "Microsoft.DataFactory/factories/dataflows": {
    },
    "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": "=",
            "poolName": "=",
                    "databaseName": "=",
                    "systemNumber": "=",
                    "server": "=",
                    "url":"=",
                    "aadResourceId": "=",
                    "connectionString": "|:-connectionString:secureString"
                }
            }
        },
        "Odbc": {
            "properties": {
                "typeProperties": {
                    "userName": "=",
                    "connectionString": {
                        "secretName": "="
                    }
                }
            }
        }
    },
    "Microsoft.DataFactory/factories/datasets": {
        "*": {
            "properties": {
                "typeProperties": {
                    "folderPath": "=",
                    "fileName": "="
                }
            }
        }}
}

Následující příklad ukazuje, jak přidat jednu hodnotu do výchozí šablony Parametrizace. Pro propojenou službu datacihly se souborem parametrů chceme přidat jenom existující Azure Databricks interaktivní ID clusteru. Všimněte si, že tento soubor je stejný jako předchozí soubor s výjimkou přidání existingClusterId v poli vlastnosti Microsoft.DataFactory/factories/linkedServices.Note that this file is the same as the previous file except for the addition of existingClusterId under the properties field of Microsoft.DataFactory/factories/linkedServices.

{
    "Microsoft.DataFactory/factories/pipelines": {
    },
    "Microsoft.DataFactory/factories/dataflows": {
    },
    "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": "=",
            "poolName": "=",
                    "databaseName": "=",
                    "systemNumber": "=",
                    "server": "=",
                    "url":"=",
                    "aadResourceId": "=",
                    "connectionString": "|:-connectionString:secureString",
                    "existingClusterId": "-"
                }
            }
        },
        "Odbc": {
            "properties": {
                "typeProperties": {
                    "userName": "=",
                    "connectionString": {
                        "secretName": "="
                    }
                }
            }
        }
    },
    "Microsoft.DataFactory/factories/datasets": {
        "*": {
            "properties": {
                "typeProperties": {
                    "folderPath": "=",
                    "fileName": "="
                }
            }
        }}
}

Propojené šablony Správce prostředkůLinked Resource Manager templates

Pokud jste pro své datové továrny nastavili CI/CD, můžete překročit omezení šablony Azure Resource Manager, protože vaše továrna roste větší.If you've set up CI/CD for your data factories, you might exceed the Azure Resource Manager template limits as your factory grows bigger. Například jeden limit je maximální počet prostředků v šabloně Správce prostředků.For example, one limit is the maximum number of resources in a Resource Manager template. Aby se při generování úplné šablony Správce prostředků pro objekt pro vytváření vešly velké továrny, Data Factory nyní generuje propojené šablony Správce prostředků.To accommodate large factories while generating the full Resource Manager template for a factory, Data Factory now generates linked Resource Manager templates. Pomocí této funkce je celá datová část továrny rozdělena do několika souborů, takže omezení neomezíte.With this feature, the entire factory payload is broken down into several files so that you aren't constrained by the limits.

Pokud jste nakonfigurovali Git, propojené šablony se generují a ukládají společně s úplnými Správce prostředků šablonami v adf_publish větvi v nové složce s názvem linkedTemplates:If you've configured Git, the linked templates are generated and saved alongside the full Resource Manager templates in the adf_publish branch in a new folder called linkedTemplates:

Složka propojených šablon Správce prostředků

Propojené šablony Správce prostředků obvykle sestávají z hlavní šablony a sady podřízených šablon, které jsou propojeny s hlavním serverem.The linked Resource Manager templates usually consist of a master template and a set of child templates that are linked to the master. Nadřazená šablona se nazývá ArmTemplate_master. JSON a podřízené šablony jsou pojmenovány vzorovým ArmTemplate_0. JSON, ArmTemplate_1. JSON atd.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.

Pokud chcete místo úplné Správce prostředků šablony použít propojené šablony, aktualizujte úlohu CI/CD tak, aby odkazovala na ArmTemplate_master. JSON místo ArmTemplateForFactory. JSON (úplná šablona Správce prostředků).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). Správce prostředků také vyžaduje, abyste nahráli propojené šablony do účtu úložiště, aby k nim Azure během nasazení mohl přistupovat.Resource Manager also requires that you upload the linked templates into a storage account so Azure can access them during deployment. Další informace najdete v tématu nasazení propojených správce prostředků šablon pomocí VSTS.For more info, see Deploying linked Resource Manager templates with VSTS.

Nezapomeňte přidat skripty Data Factory do kanálu CI/CD před a po úloze nasazení.Remember to add the Data Factory scripts in your CI/CD pipeline before and after the deployment task.

Pokud nemáte nakonfigurovaný Git, můžete k propojeným šablonám přistupovat pomocí šablony pro export ARM v seznamu šablon ARM .If you don't have Git configured, you can access the linked templates via Export ARM Template in the ARM Template list.

Produkční větev s opravou hotfixHotfix production branch

Pokud nasadíte továrnu do produkčního prostředí a zjistíte chybu, kterou je potřeba opravit hned, ale nemůžete nasadit aktuální větev spolupráce, možná budete muset nasadit opravu hotfix.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 might need to deploy a hotfix. Tento přístup je známý jako rychlý opravový technický nebo QFE.This approach is as known as quick-fix engineering or QFE.

  1. Ve službě Azure DevOps si Projděte verzi, která byla nasazena do produkčního prostředí.In Azure DevOps, go to the release that was deployed to production. Vyhledá poslední přivedený zápis.Find the last commit that was deployed.

  2. Z zprávy potvrzení Získejte ID potvrzení větve pro spolupráci.From the commit message, get the commit ID of the collaboration branch.

  3. Vytvořte novou větev hotfix z tohoto potvrzení.Create a new hotfix branch from that commit.

  4. Přejděte do Azure Data Factory uživatelského rozhraní a přepněte do větve hotfix.Go to the Azure Data Factory UX and switch to the hotfix branch.

  5. Pomocí Azure Data Factoryho uživatelského rozhraní opravíte chybu.By using the Azure Data Factory UX, fix the bug. Otestujte provedené změny.Test your changes.

  6. Po ověření opravy vyberte Exportovat šablonu ARM , abyste získali Správce prostředků šablonu oprav hotfix.After the fix is verified, select Export ARM Template to get the hotfix Resource Manager template.

  7. Toto sestavení ručně zkontrolujete do větve adf_publish.Manually check this build into the adf_publish branch.

  8. Pokud jste nakonfigurovali svůj kanál pro vydávání verzí tak, aby se automaticky spouštěl na základě adf_publish vrácení se změnami, automaticky se spustí nová verze.If you've configured your release pipeline to automatically trigger based on adf_publish check-ins, a new release will start automatically. V opačném případě ručně vyřadí vydanou verzi.Otherwise, manually queue a release.

  9. Nasaďte verzi opravy hotfix do testovacího a produkčního továrny.Deploy the hotfix release to the test and production factories. Tato verze obsahuje předchozí provozní datovou část a opravu, kterou jste provedli v kroku 5.This release contains the previous production payload plus the fix that you made in step 5.

  10. Přidejte změny z opravy hotfix do vývojové větve, aby pozdější verze neobsahovaly stejnou chybu.Add the changes from the hotfix to the development branch so that later releases won't include the same bug.

Osvědčené postupy pro CI/CDBest practices for CI/CD

Pokud používáte integraci Git s datovou továrnou a máte kanál CI/CD, který přesouvá vaše změny z vývoje do testu a následně do produkčního prostředí, doporučujeme tyto osvědčené postupy:If you're using Git integration with your data factory and have a CI/CD pipeline that moves your changes from development into test and then to production, we recommend these best practices:

  • Integrace Gitu.Git integration. Je potřeba nakonfigurovat jenom svůj vývojový objekt pro vytváření dat s integrací Gitu.You need to configure only your development data factory with Git integration. Změny v testovacích a produkčních prostředích se nasazují přes CI/CD a nepotřebují integraci Git.Changes to test and production are deployed via CI/CD and don't need Git integration.

  • Data Factory skript CI/CD.Data Factory CI/CD script. Před krokem nasazení Správce prostředků v CI/CD je potřeba provést určité úlohy, jako je zastavení a restartování triggerů a provádění čištění.Before the Resource Manager deployment step in CI/CD, you need to complete certain tasks, like stopping and restarting triggers and performing cleanup. Doporučujeme používat skripty prostředí PowerShell před nasazením a po něm.We recommend that you use PowerShell scripts before and after deployment. Další informace najdete v tématu aktualizace aktivních aktivačních událostí.For more information, see Update active triggers.

  • Prostředí Integration runtime a sdílení.Integration runtimes and sharing. Prostředí Integration runtime se často nemění a jsou ve všech fázích CI/CD stejné.Integration runtimes don't change often and are similar across all stages in your CI/CD. Takže Data Factory očekává, že budete mít stejný název a typ prostředí Integration runtime ve všech fázích CI/CD.So Data Factory expects you to have the same name and type of integration runtime across all stages of CI/CD. Pokud chcete sdílet prostředí Integration runtime ve všech fázích, zvažte použití Ternární továrny jenom k zahrnutí sdílených prostředí Integration runtime.If you want to share integration runtimes across all stages, consider using a ternary factory just to contain the shared integration runtimes. Tuto sdílenou továrnu můžete použít ve všech prostředích jako typ propojeného prostředí Integration runtime.You can use this shared factory in all of your environments as a linked integration runtime type.

  • Key Vault.Key Vault. Když použijete propojené služby založené na Azure Key Vault, můžete je využít dál tím, že zachováte oddělené trezory klíčů pro různá prostředí.When you use linked services based on Azure Key Vault, you can take advantage of them further by keeping separate key vaults for different environments. Pro každý Trezor klíčů můžete nakonfigurovat také samostatné úrovně oprávnění.You can also configure separate permission levels for each key vault. Například nebudete chtít, aby členové týmu měli oprávnění k produkčním tajným klíčům.For example, you might not want your team members to have permissions to production secrets. Pokud budete postupovat podle tohoto přístupu, doporučujeme, abyste zachovali stejné tajné názvy ve všech fázích.If you follow this approach, we recommend that you to keep the same secret names across all stages. Pokud zachováte stejné názvy, nemusíte měnit šablony Správce prostředků napříč prostředími CI/CD, protože jediná věc, kterou mění, je název trezoru klíčů, což je jeden z parametrů Správce prostředků šablony.If you keep the same names, you don't have to change your Resource Manager templates across CI/CD environments because the only thing that changes is the key vault name, which is one of the Resource Manager template parameters.

Nepodporované funkceUnsupported features

  • Data Factory tak, že neumožňuje vybírání položek potvrzení nebo selektivního publikování prostředků.By design, Data Factory doesn't allow cherry-picking of commits or selective publishing of resources. Publikování budou zahrnovat všechny změny provedené v datové továrně.Publishes will include all changes made in the data factory.

    • Entity Data Factory jsou vzájemně závislé.Data factory entities depend on each other. Například triggery závisejí na kanálech a kanály závisí na datových sadách a dalších kanálech.For example, triggers depend on pipelines, and pipelines depend on datasets and other pipelines. Selektivní publikování podmnožiny prostředků by mohlo vést k neočekávanému chování a chybám.Selective publishing of a subset of resources could lead to unexpected behaviors and errors.
    • Ve výjimečných případech když potřebujete selektivní publikování, zvažte použití opravy hotfix.On rare occasions when you need selective publishing, consider using a hotfix. Další informace najdete v tématu produkční větev hotfix.For more information, see Hotfix production branch.
  • Nemůžete publikovat z privátních větví.You can't publish from private branches.

  • V současné době nemůžete hostovat projekty v Bitbucket.You can't currently host projects on Bitbucket.