Kontinuerlig integrering och leverans i Azure Data FactoryContinuous integration and delivery in Azure Data Factory

ÖversiktOverview

Kontinuerlig integrering är en metod för att testa varje ändring av kodbasen automatiskt och så tidigt som möjligt.Continuous integration is the practice of testing each change made to your codebase automatically and as early as possible. Kontinuerlig leverans följer testerna som sker under kontinuerlig integrering och skickar ändringar till ett mellanlagrings-eller produktions system. Continuous delivery follows the testing that happens during continuous integration and pushes changes to a staging or production system.

I Azure Data Factory innebär kontinuerlig integrering och leverans (CI/CD) flytt av Data Factory pipelines från en miljö (utveckling, testning, produktion) till en annan.In Azure Data Factory, continuous integration and delivery (CI/CD) means moving Data Factory pipelines from one environment (development, test, production) to another. Du kan använda Data Factory UX-integrering med Azure Resource Manager mallar för att göra CI/CD.You can use Data Factory UX integration with Azure Resource Manager templates to do CI/CD.

I Data Factory UX kan du skapa en Resource Manager-mall från den nedrullningsbara menyn arm-mall .In the Data Factory UX, you can generate a Resource Manager template from the ARM Template drop-down menu. När du väljer Exportera arm-mallgenererar portalen Resource Manager-mallen för data fabriken och en konfigurations fil som innehåller alla anslutnings strängar och andra parametrar.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. Sedan skapar du en konfigurations fil för varje miljö (utveckling, test, produktion).Then you create one configuration file for each environment (development, test, production). Den huvudsakliga Resource Manager-mallfilen är densamma för alla miljöer.The main Resource Manager template file remains the same for all the environments.

För en nio minuters introduktion till den här funktionen och en demonstration, titta på den här videon:For a nine-minute introduction to this feature and a demonstration, watch this video:

Anteckning

Den här artikeln har uppdaterats till att använda den nya Azure PowerShell Az-modulen.This article has been updated to use the new Azure PowerShell Az module. Du kan fortfarande använda modulen AzureRM som kommer att fortsätta att ta emot felkorrigeringar fram till december 2020 eller längre.You can still use the AzureRM module, which will continue to receive bug fixes until at least December 2020. Mer information om den nya Az-modulen och AzureRM-kompatibilitet finns i Introduktion till den nya Azure PowerShell Az-modulen.To learn more about the new Az module and AzureRM compatibility, see Introducing the new Azure PowerShell Az module. Instruktioner för installation av Az-modulen finns i Installera Azure PowerShell.For Az module installation instructions, see Install Azure PowerShell.

CI/CD-livscykelCI/CD lifecycle

Nedan visas ett exempel på en översikt över CI/CD-livscykeln i en Azure-datafabrik som är konfigurerad med Azure databaser git.Below is a sample overview of the CI/CD lifecycle in an Azure data factory that's configured with Azure Repos Git. Mer information om hur du konfigurerar en git-lagringsplats finns i käll kontroll i Azure Data Factory.For more information on how to configure a Git repository, see Source control in Azure Data Factory.

  1. En utvecklings data fabrik skapas och konfigureras med Azure databaser git.A development data factory is created and configured with Azure Repos Git. Alla utvecklare måste ha behörighet att redigera Data Factory resurser som pipelines och data uppsättningar.All developers should have permission to author Data Factory resources like pipelines and datasets.

  2. När utvecklare gör ändringar i sina funktions grenar, så att de kan felsöka sina pipeliner med de senaste ändringarna.As the developers make changes in their feature branches, they debug their pipeline runs with their most recent changes. Mer information om hur du felsöker en pipeline-körning finns i iterativ utveckling och fel sökning med Azure Data Factory.For more information on how to debug a pipeline run, see Iterative development and debugging with Azure Data Factory.

  3. När utvecklarna är nöjd med sina ändringar, skapar de en pull-begäran från sina funktions grenar till huvud-eller samarbets grenen för att få sina ändringar granskade av peer-datorer.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. När en pull-begäran har godkänts och ändringar slås samman i huvud grenen, kan ändringarna publiceras i utvecklings fabriken.After a pull request is approved and changes are merged in the master branch, the changes can be published to the development factory.

  5. När teamet är redo att distribuera ändringarna till test fabriken och sedan till produktions fabriken, exporterar teamet Resource Manager-mallen från huvud grenen.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. Den exporterade Resource Manager-mallen distribueras med olika parameterstyrda filer till test fabriken och produktions fabriken.The exported Resource Manager template is deployed with different parameter files to the test factory and the production factory.

Skapa en Resource Manager-mall för varje miljöCreate a Resource Manager template for each environment

  1. I listan arm-mall väljer du Exportera arm -mall för att exportera Resource Manager-mallen för din data fabrik i utvecklings miljön.In the ARM Template list, select Export ARM Template to export the Resource Manager template for your data factory in the development environment.

    Exportera en Resource Manager-mall

  2. I test-och produktions data fabrikerna väljer du Importera arm-mall.In your test and production data factories, select Import ARM Template. Den här åtgärden tar dig till Azure Portal, där du kan importera den exporterade mallen.This action takes you to the Azure portal, where you can import the exported template. Välj skapa en egen mall i redigeraren för att öppna Principeditorn i Resource Manager.Select Build your own template in the editor to open the Resource Manager template editor.

    Bygg en egen mall

  3. Välj Läs in filoch välj sedan den genererade Resource Manager-mallen.Select Load file, and then select the generated Resource Manager template.

    Redigera mall

  4. I avsnittet inställningar anger du konfigurations värden, t. ex. länkade tjänst uppgifter.In the settings section, enter the configuration values, like linked service credentials. När du är klar väljer du köp för att distribuera Resource Manager-mallen.When you're done, select Purchase to deploy the Resource Manager template.

    Avsnittet Inställningar

AnslutningssträngarConnection strings

Information om hur du konfigurerar anslutnings strängar finns i Connector-artikeln.For information on how to configure connection strings, see the connector's article. Till exempel, för Azure SQL Database, se Kopiera data till eller från Azure SQL Database med Azure Data Factory.For example, for Azure SQL Database, see Copy data to or from Azure SQL Database by using Azure Data Factory. Om du vill verifiera en anslutnings sträng kan du öppna vyn kod för resursen i Data Factory UX.To verify a connection string, you can open the code view for the resource in the Data Factory UX. I kodvyn tas lösen ordet eller konto nyckel delen av anslutnings strängen bort.In code view, the password or account key portion of the connection string is removed. Öppna kodvyn genom att välja ikonen som marker ATS här:To open code view, select the icon highlighted here:

Öppna kodvyn för att se anslutnings strängen

Automatisera kontinuerlig integrering med hjälp av Azure pipelines-versionerAutomate continuous integration by using Azure Pipelines releases

Nedan följer en guide för hur du konfigurerar en version av en Azure-pipeline, som automatiserar distributionen av en data fabrik till flera miljöer.Following is a guide for setting up an Azure Pipelines release, which automates the deployment of a data factory to multiple environments.

Diagram över kontinuerlig integrering med Azure-pipelines

KravRequirements

  • En Azure-prenumeration som är länkad till Visual Studio Team Foundation Server eller Azure-databaser som använder Azure Resource Manager tjänstens slut punkt.An Azure subscription linked to Visual Studio Team Foundation Server or Azure Repos that uses the Azure Resource Manager service endpoint.

  • En data fabrik som kon figurer ATS med Azure databaser git-integrering.A data factory configured with Azure Repos Git integration.

  • Ett Azure Key Vault som innehåller hemligheterna för varje miljö.An Azure key vault that contains the secrets for each environment.

Konfigurera en version av Azure pipelinesSet up an Azure Pipelines release

  1. Öppna det projekt som har kon figurer ATS med din data fabrik i Azure-DevOps.In Azure DevOps, open the project that's configured with your data factory.

  2. Välj pipelinespå vänster sida av sidan och välj sedan versioner.On the left side of the page, select Pipelines, and then select Releases.

    Välj pipeliner, versioner

  3. Välj ny pipelineeller, om du har befintliga pipeliner, väljer du ny och sedan ny versions pipeline.Select New pipeline, or, if you have existing pipelines, select New and then New release pipeline.

  4. Välj den tomma jobb mal len.Select the Empty job template.

    Välj tomt jobb

  5. I rutan scen namn anger du namnet på din miljö.In the Stage name box, enter the name of your environment.

  6. Välj Lägg till artefaktoch välj sedan den databas som kon figurer ATS med din data fabrik.Select Add artifact, and then select the repository configured with your data factory. Välj adf_publish för standard grenen.Select adf_publish for the Default branch. Välj senaste från standard grenför standard versionen.For the Default version, select Latest from default branch.

    Lägg till en artefakt

  7. Lägg till en Azure Resource Manager distributions uppgift:Add an Azure Resource Manager Deployment task:

    a.a. I vyn fas väljer du Visa fas aktiviteter.In the stage view, select View stage tasks.

    Vyn fas

    b.b. Skapa en ny uppgift.Create a new task. Sök efter Azure Resource Group-distributionoch välj sedan Lägg till.Search for Azure Resource Group Deployment, and then select Add.

    c.c. I distributions aktiviteten väljer du prenumeration, resurs grupp och plats för mål data fabriken.In the Deployment task, select the subscription, resource group, and location for the target data factory. Ange autentiseringsuppgifter om det behövs.Provide credentials if necessary.

    d.d. I listan åtgärd väljer du skapa eller uppdatera resurs grupp.In the Action list, select Create or update resource group.

    e.e. Välj knappen med tre punkter ( ... ) bredvid rutan mall .Select the ellipsis button () next to the Template box. Bläddra till Azure Resource Manager mall som du skapade med hjälp av Importera arm-mall i avsnittet skapa en Resource Manager-mall för varje miljö i den här artikeln.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. Leta efter den här filen i mappen i adf_publish grenen.Look for this file in the folder of the adf_publish branch.

    f.f. Välj ...Select bredvid rutan mallparametrar för att välja parameter filen.next to the Template parameters box to choose the parameters file. Vilken fil du väljer beror på om du har skapat en kopia eller använder standard filen ARMTemplateParametersForFactory. JSON.The file you choose will depend on whether you created a copy or are using the default file, ARMTemplateParametersForFactory.json.

    g.g. Välj ...Select bredvid rutan Åsidosätt mallparametrar och ange informationen för mål data fabriken.next to the Override template parameters box, and enter the information for the target data factory. För autentiseringsuppgifter som kommer från Azure Key Vault anger du hemlighetens namn mellan dubbla citat tecken.For credentials that come from Azure Key Vault, enter the secret's name between double quotation marks. Om t. ex. hemlighetens namn är cred1 anger du "$ (cred1)" för det här värdet.For example, if the secret's name is cred1, enter "$(cred1)" for this value.

    h.h. Välj stegvis för distributions läget.Select Incremental for the Deployment mode.

    Varning

    Om du väljer Slutför för distributions lägetkan befintliga resurser tas bort, inklusive alla resurser i mål resurs gruppen som inte har definierats i Resource Manager-mallen.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 Prod. distribution

  8. Spara versions pipelinen.Save the release pipeline.

  9. Om du vill utlösa en version väljer du Skapa version.To trigger a release, select Create release.

    Välj Skapa version

Viktigt

I CI/CD-scenarier måste integrerings körnings typen (IR) i olika miljöer vara densamma.In CI/CD scenarios, the integration runtime (IR) type in different environments must be the same. Om du till exempel har en lokal IR-anslutning i utvecklings miljön, måste samma IR också vara av typen egen värd i andra miljöer, till exempel test och produktion.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. Om du däremot delar integrerings körningar över flera steg, måste du konfigurera integration runtime som länkad egen värd i alla miljöer, till exempel utveckling, testning och produktion.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.

Hämta hemligheter från Azure Key VaultGet secrets from Azure Key Vault

Om du har hemligheter som ska skickas i en Azure Resource Manager-mall rekommenderar vi att du använder Azure Key Vault med Azure pipelines-versionen.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.

Det finns två sätt att hantera hemligheter:There are two ways to handle secrets:

  1. Lägg till filen hemligheter till Parameters.Add the secrets to parameters file. Mer information finns i använda Azure Key Vault för att skicka ett säkert parameter värde under distributionen.For more info, see Use Azure Key Vault to pass secure parameter value during deployment.

    Skapa en kopia av parameter filen som överförs till publicerings grenen.Create a copy of the parameters file that's uploaded to the publish branch. Ange värdena för de parametrar som du vill hämta från Key Vault med det här formatet: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 > "
                }
            }
        }
    }
    

    När du använder den här metoden hämtas hemligheten automatiskt från nyckel valvet.When you use this method, the secret is pulled from the key vault automatically.

    Parameter filen måste också finnas i publicerings grenen.The parameters file needs to be in the publish branch as well.

  • Lägg till en Azure Key Vault aktivitet före Azure Resource Manager distributions aktivitet som beskrivs i föregående avsnitt:Add an Azure Key Vault task before the Azure Resource Manager Deployment task described in the previous section:

    1. På fliken aktiviteter skapar du en ny uppgift.On the Tasks tab, create a new task. Sök efter Azure Key Vault och Lägg till det.Search for Azure Key Vault and add it.

    2. I Key Vault aktiviteten väljer du den prenumeration där du skapade nyckel valvet.In the Key Vault task, select the subscription in which you created the key vault. Ange autentiseringsuppgifter om det behövs och välj sedan nyckel valvet.Provide credentials if necessary, and then select the key vault.

    Lägg till en Key Vault uppgift

    Bevilja behörighet till Azure pipelines-agentenGrant permissions to the Azure Pipelines agent

    Azure Key Vault aktiviteten kan Miss Miss kan ett fel meddelande om nekad åtkomst om rätt behörigheter inte har angetts.The Azure Key Vault task might fail with an Access Denied error if the correct permissions aren't set. Hämta loggarna för versionen och leta upp den. ps1-fil som innehåller kommandot för att ge behörighet till Azure pipelines-agenten.Download the logs for the release, and locate the .ps1 file that contains the command to give permissions to the Azure Pipelines agent. Du kan köra kommandot direkt.You can run the command directly. Du kan också kopiera ägar-ID: t från filen och lägga till åtkomst principen manuellt i Azure Portal.Or you can copy the principal ID from the file and add the access policy manually in the Azure portal. Get och List är de lägsta behörigheter som krävs.Get and List are the minimum permissions required.

Uppdatera aktiva utlösareUpdate active triggers

Distributionen kan inte utföras om du försöker uppdatera aktiva utlösare.Deployment can fail if you try to update active triggers. Om du vill uppdatera aktiva utlösare måste du stoppa dem manuellt och sedan starta om dem efter distributionen.To update active triggers, you need to manually stop them and then restart them after the deployment. Du kan göra detta med hjälp av en Azure PowerShell uppgift:You can do this by using an Azure PowerShell task:

  1. Lägg till en Azure PowerShell aktivitet på fliken aktiviteter i versionen.On the Tasks tab of the release, add an Azure PowerShell task. Välj aktivitet version 4. *.Choose task version 4.*.

  2. Välj den prenumeration som din fabrik är i.Select the subscription your factory is in.

  3. Välj skript fil Sök väg som skript typ.Select Script File Path as the script type. Detta kräver att du sparar ditt PowerShell-skript i din lagrings plats.This requires you to save your PowerShell script in your repository. Följande PowerShell-skript kan användas för att stoppa utlösare: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 }
    

Du kan slutföra liknande steg (med funktionen Start-AzDataFactoryV2Trigger) för att starta om utlösarna efter distributionen.You can complete similar steps (with the Start-AzDataFactoryV2Trigger function) to restart the triggers after deployment.

Exempel skript för för-och efter distributionSample pre- and post-deployment script

Följande exempel skript kan användas för att stoppa utlösare före distribution och starta om dem efteråt.The following sample script can be used to stop triggers before deployment and restart them afterward. Skriptet innehåller också kod för att ta bort resurser som har tagits bort.The script also includes code to delete resources that have been removed. Spara skriptet i en Azure DevOps git-lagringsplats och referera till den via en Azure PowerShell aktivitet som använder version 4. *.Save the script in an Azure DevOps git repository and reference it via an Azure PowerShell task using version 4.*.

När du kör ett skript för för distribution måste du ange en variant av följande parametrar i fältet skript argument .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

När du kör ett skript efter distribution måste du ange en variant av följande parametrar i fältet skript argument .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)

Här är det skript som kan användas för för-och-distribution.Here is the script that can be used for pre- and post-deployment. IT-konton för borttagna resurser och resurs referenser.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 
    }
}

Använd anpassade parametrar med Resource Manager-mallenUse custom parameters with the Resource Manager template

Om du är i GIT-läge kan du åsidosätta standard egenskaperna i Resource Manager-mallen för att ange egenskaper som är parameterstyrda i mallen och de egenskaper som är hårdkodade.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. Du kanske vill åsidosätta standard mal len för parameterisering i följande scenarier:You might want to override the default parameterization template in these scenarios:

  • Du använder automatiserad CI/CD och du vill ändra vissa egenskaper under distributionen av Resource Manager, men egenskaperna är inte parameterstyrda som standard.You use automated CI/CD and you want to change some properties during Resource Manager deployment, but the properties aren't parameterized by default.
  • Fabriken är så stor att Resource Manager-standardmallen är ogiltig eftersom den har fler än det högsta tillåtna antalet parametrar (256).Your factory is so large that the default Resource Manager template is invalid because it has more than the maximum allowed parameters (256).

Om du under dessa omständigheter vill åsidosätta standard mal len Parameterisering skapar du en fil med namnet arm-Template-Parameters-definition. json i mappen som anges som rotmapp för git-integreringen för 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. Du måste använda det exakta fil namnet.You must use that exact file name. Data Factory läser filen från den gren som du är närvarande på i Azure Data Factory portalen, inte bara från samarbets grenen.Data Factory reads this file from whichever branch you're currently on in the Azure Data Factory portal, not just from the collaboration branch. Du kan skapa eller redigera filen från en privat gren, där du kan testa dina ändringar genom att välja Exportera arm-mall i användar gränssnittet.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. Sedan kan du slå samman filen till samarbets grenen.You can then merge the file into the collaboration branch. Om ingen fil hittas används standard mal len.If no file is found, the default template is used.

Syntax för en anpassad parameter filSyntax of a custom parameters file

Nedan följer några rikt linjer som du följer när du skapar filen med anpassade parametrar.Following are some guidelines to follow when you create the custom parameters file. Filen består av ett avsnitt för varje entitetstyp: utlösare, pipeline, länkad tjänst, data uppsättning, integration Runtime och så vidare.The file consists of a section for each entity type: trigger, pipeline, linked service, dataset, integration runtime, and so on.

  • Ange sökvägen till egenskapen under den relevanta entitetstypen.Enter the property path under the relevant entity type.
  • Om du anger ett egenskaps namn som * anger du att du vill Parameterisera alla egenskaper under den (endast ned till den första nivån, inte rekursivt).Setting a property name to * indicates that you want to parameterize all properties under it (only down to the first level, not recursively). Du kan också ange undantag för den här konfigurationen.You can also provide exceptions to this configuration.
  • Att ange värdet för en egenskap som en sträng anger att du vill Parameterisera egenskapen.Setting the value of a property as a string indicates that you want to parameterize the property. Använd formatet <action>:<name>:<stype>.Use the format <action>:<name>:<stype>.
    • <action> kan vara något av följande tecken:<action> can be one of these characters:
      • = innebär att det aktuella värdet är standardvärdet för parametern.= means keep the current value as the default value for the parameter.
      • - innebär att inte behålla standardvärdet för parametern.- means don't keep the default value for the parameter.
      • | är ett specialfall för hemligheter från Azure Key Vault för anslutnings strängar eller nycklar.| is a special case for secrets from Azure Key Vault for connection strings or keys.
    • <name> är namnet på parametern.<name> is the name of the parameter. Om det är tomt tar det med namnet på egenskapen.If it's blank, it takes the name of the property. Om värdet börjar med ett --kort, förkortas namnet.If the value starts with a - character, the name is shortened. AzureStorage1_properties_typeProperties_connectionString skulle till exempel kortas till AzureStorage1_connectionString.For example, AzureStorage1_properties_typeProperties_connectionString would be shortened to AzureStorage1_connectionString.
    • <stype> är typ av parameter.<stype> is the type of parameter. Om <stype> är tomt är standard typen string.If <stype> is blank, the default type is string. Värden som stöds: string, bool, number, objectoch securestring.Supported values: string, bool, number, object, and securestring.
  • Att ange en matris i definitions filen anger att den matchande egenskapen i mallen är en matris.Specifying an array in the definition file indicates that the matching property in the template is an array. Data Factory itererar igenom alla objekt i matrisen med hjälp av definitionen som anges i integration runtime-objektet i matrisen.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. Det andra objektet, en sträng, blir namnet på egenskapen, som används som namn för parametern för varje iteration.The second object, a string, becomes the name of the property, which is used as the name for the parameter for each iteration.
  • En definition kan inte vara unik för en resurs instans.A definition can't be specific to a resource instance. Alla definitioner gäller för alla resurser av den typen.Any definition applies to all resources of that type.
  • Som standard är alla säkra strängar, som Key Vault hemligheter och säkra strängar, som anslutnings strängar, nycklar och tokens, parameterstyrda.By default, all secure strings, like Key Vault secrets, and secure strings, like connection strings, keys, and tokens, are parameterized.

Exempel på Parameterisering-mallSample parameterization template

Här är ett exempel på hur en Parameterisering-mall kan se ut så här: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": {
                "*": "="
            }
        }
    }
}

Här är en förklaring av hur föregående mall skapas, uppdelat efter resurs typ.Here's an explanation of how the preceding template is constructed, broken down by resource type.

PipelinesPipelines

  • Alla egenskaper i sökvägen activities/typeProperties/waitTimeInSeconds är parameterstyrda.Any property in the path activities/typeProperties/waitTimeInSeconds is parameterized. Alla aktiviteter i en pipeline som har en kod nivå egenskap med namnet waitTimeInSeconds (till exempel Wait aktivitet) är parameterstyrda som ett tal med ett standard namn.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. Men det finns inget standardvärde i Resource Manager-mallen.But it won't have a default value in the Resource Manager template. Det är en obligatorisk Indatatyp under distributionen av Resource Manager.It will be a mandatory input during the Resource Manager deployment.
  • På samma sätt har en egenskap som kallas headers (till exempel i en Web aktivitet) en parameter med typen object (JObject).Similarly, a property called headers (for example, in a Web activity) is parameterized with type object (JObject). Det har ett standardvärde, vilket är samma värde som käll fabriken.It has a default value, which is the same value as that of the source factory.

IntegrationRuntimesIntegrationRuntimes

  • Alla egenskaper under Sök vägs typeProperties är parameterstyrda med respektive standardvärden.All properties under the path typeProperties are parameterized with their respective default values. Det finns till exempel två egenskaper under IntegrationRuntimes typ egenskaper: computeProperties och ssisProperties.For example, there are two properties under IntegrationRuntimes type properties: computeProperties and ssisProperties. Båda egenskaps typerna skapas med deras respektive standardvärden och typer (objekt).Both property types are created with their respective default values and types (Object).

UtlösareTriggers

  • Under typePropertiesär två egenskaper parameterstyrda.Under typeProperties, two properties are parameterized. Den första är maxConcurrency, som har angetts som standardvärde och är av typenstring.The first one is maxConcurrency, which is specified to have a default value and is of typestring. Den har standard parameter namnet <entityName>_properties_typeProperties_maxConcurrency.It has the default parameter name <entityName>_properties_typeProperties_maxConcurrency.
  • Egenskapen recurrence är också parametriserad.The recurrence property also is parameterized. Under den här nivån anges alla egenskaper på den nivån som parameterstyrda som strängar, med standardvärden och parameter namn.Under it, all properties at that level are specified to be parameterized as strings, with default values and parameter names. Ett undantag är interval-egenskapen, som är parameterstyrda som typ number.An exception is the interval property, which is parameterized as type number. Parameter namnet är suffixet med <entityName>_properties_typeProperties_recurrence_triggerSuffix.The parameter name is suffixed with <entityName>_properties_typeProperties_recurrence_triggerSuffix. På samma sätt är egenskapen freq en sträng och är parameterstyrda som en sträng.Similarly, the freq property is a string and is parameterized as a string. Men egenskapen freq är parameterstyrda utan ett standardvärde.However, the freq property is parameterized without a default value. Namnet är kortare och suffixet.The name is shortened and suffixed. Till exempel <entityName>_freq.For example, <entityName>_freq.

LinkedServicesLinkedServices

  • Länkade tjänster är unika.Linked services are unique. Eftersom länkade tjänster och data uppsättningar har en mängd olika typer, kan du ange en typ bestämd anpassning.Because linked services and datasets have a wide range of types, you can provide type-specific customization. I det här exemplet används en speciell mall för alla länkade tjänster av typen AzureDataLakeStore.In this example, for all linked services of type AzureDataLakeStore, a specific template will be applied. För alla andra (via *) kommer en annan mall att tillämpas.For all others (via *), a different template will be applied.
  • Egenskapen connectionString är parameterstyrda som ett securestring värde.The connectionString property will be parameterized as a securestring value. Det har inget standardvärde.It won't have a default value. Det kommer att ha ett förkortat parameter namn som är suffix med connectionString.It will have a shortened parameter name that's suffixed with connectionString.
  • Egenskapen secretAccessKey sker som ett AzureKeyVaultSecret (till exempel i en länkad Amazon S3-tjänst).The property secretAccessKey happens to be an AzureKeyVaultSecret (for example, in an Amazon S3 linked service). Den är automatiskt parameterstyrda som en Azure Key Vault hemlighet och hämtas från det konfigurerade nyckel valvet.It's automatically parameterized as an Azure Key Vault secret and fetched from the configured key vault. Du kan också Parameterisera själva nyckel valvet.You can also parameterize the key vault itself.

DatauppsättningarDatasets

  • Även om typ specifik anpassning är tillgänglig för data uppsättningar kan du ange konfiguration utan att uttryckligen ha en konfiguration på *nivå.Although type-specific customization is available for datasets, you can provide configuration without explicitly having a *-level configuration. I föregående exempel är alla data uppsättnings egenskaper under typeProperties parameterstyrda.In the preceding example, all dataset properties under typeProperties are parameterized.

Standard Parameterisering-mallDefault parameterization template

Följande är den aktuella standard Parameterisering-mallen.Following is the current default parameterization template. Om du bara behöver lägga till några få parametrar kan det vara en bra idé att redigera mallen direkt eftersom du inte förlorar den befintliga Parameterisering-strukturen.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": "="
                }
            }
        }}
}

I följande exempel visas hur du lägger till ett enda värde i standard mal len Parameterisering. Vi vill bara lägga till ett befintligt Azure Databricks interaktiva kluster-ID: t för en länkad Databricks-tjänst till parameter filen. Observera att den här filen är samma som föregående fil, förutom att du kan lägga till existingClusterId under fältet egenskaper för 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": "="
                }
            }
        }}
}

Länkade Resource Manager-mallarLinked Resource Manager templates

Om du har konfigurerat CI/CD för dina data fabriker kan du överskrida gränserna för Azure Resource Manager mal len när fabriken växer större.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. Till exempel är en gräns det maximala antalet resurser i en Resource Manager-mall.For example, one limit is the maximum number of resources in a Resource Manager template. För att kunna hantera stora fabriker samtidigt som du skapar en fullständig Resource Manager-mall för en fabrik, skapar Data Factory nu länkade Resource Manager-mallar.To accommodate large factories while generating the full Resource Manager template for a factory, Data Factory now generates linked Resource Manager templates. Med den här funktionen delas hela fabriks nytto lasten upp i flera filer så att du inte begränsas av gränserna.With this feature, the entire factory payload is broken down into several files so that you aren't constrained by the limits.

Om du har konfigurerat git skapas och sparas de länkade mallarna tillsammans med de fullständiga Resource Manager-mallarna i adf_publish grenen i en ny mapp med namnet 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:

Mapp för länkade Resource Manager-mallar

De länkade Resource Manager-mallarna består vanligt vis av en huvud mal len och en uppsättning underordnade mallar som är länkade till huvud servern.The linked Resource Manager templates usually consist of a master template and a set of child templates that are linked to the master. Den överordnade mallen kallas ArmTemplate_master. JSON och underordnade mallar får namnet med mönstret ArmTemplate_0. JSON, ArmTemplate_1. JSON och så vidare.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.

Om du vill använda länkade mallar i stället för den fullständiga Resource Manager-mallen uppdaterar du CI/CD-aktiviteten så att den pekar på ArmTemplate_master. json i stället för ArmTemplateForFactory. JSON (fullständig Resource Manager-mall).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). Resource Manager kräver också att du överför de länkade mallarna till ett lagrings konto så att Azure kan komma åt dem under distributionen.Resource Manager also requires that you upload the linked templates into a storage account so Azure can access them during deployment. Mer information finns i distribuera länkade Resource Manager-mallar med VSTS.For more info, see Deploying linked Resource Manager templates with VSTS.

Kom ihåg att lägga till Data Factory skript i CI/CD-pipeline innan och efter distributions aktiviteten.Remember to add the Data Factory scripts in your CI/CD pipeline before and after the deployment task.

Om du inte har git konfigurerat kan du komma åt de länkade mallarna via export arm-mallen i listan arm-mall .If you don't have Git configured, you can access the linked templates via Export ARM Template in the ARM Template list.

Produktions gren för snabb korrigeringarHotfix production branch

Om du distribuerar en fabrik till produktion och inser att det finns en bugg som måste åtgärdas direkt, men du inte kan distribuera den aktuella samarbets grenen, kan du behöva distribuera en snabb korrigering.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. Den här metoden kallas snabb korrigerings teknik eller QFE.This approach is as known as quick-fix engineering or QFE.

  1. I Azure DevOps går du till den version som distribuerades till produktionen.In Azure DevOps, go to the release that was deployed to production. Hitta den senaste incheckning som har distribuerats.Find the last commit that was deployed.

  2. Hämta genomförande-ID: t för samarbets grenen från bekräftelse meddelandet.From the commit message, get the commit ID of the collaboration branch.

  3. Skapa en ny gren för snabb korrigeringar från det genomförandet.Create a new hotfix branch from that commit.

  4. Gå till Azure Data Factory UX och växla till snabb korrigerings grenen.Go to the Azure Data Factory UX and switch to the hotfix branch.

  5. Åtgärda felet genom att använda Azure Data Factory UX.By using the Azure Data Factory UX, fix the bug. Testa dina ändringar.Test your changes.

  6. När korrigeringen har verifierats väljer du Exportera arm-mall för att hämta mallen för snabb korrigeringar för Resource Manager.After the fix is verified, select Export ARM Template to get the hotfix Resource Manager template.

  7. Kontrol lera den här versionen manuellt i adf_publish grenen.Manually check this build into the adf_publish branch.

  8. Om du har konfigurerat din versions pipeline så att den automatiskt utlöses baserat på adf_publish incheckningar startar en ny version automatiskt.If you've configured your release pipeline to automatically trigger based on adf_publish check-ins, a new release will start automatically. Annars måste du köa en version manuellt.Otherwise, manually queue a release.

  9. Distribuera snabb korrigerings versionen till test-och produktions fabrikerna.Deploy the hotfix release to the test and production factories. Den här versionen innehåller föregående produktions nytto Last plus den korrigering som du gjorde i steg 5.This release contains the previous production payload plus the fix that you made in step 5.

  10. Lägg till ändringarna från snabb korrigeringen till utvecklings grenen så att senare versioner inte tar med samma fel.Add the changes from the hotfix to the development branch so that later releases won't include the same bug.

Metod tips för CI/CDBest practices for CI/CD

Om du använder git-integrering med din data fabrik och har en CI/CD-pipeline som flyttar dina ändringar från utveckling till test och sedan till produktion, rekommenderar vi följande metod tips: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:

  • Git-integrering.Git integration. Du behöver bara konfigurera din utvecklings data fabrik med git-integrering.You need to configure only your development data factory with Git integration. Ändringar av test och produktion distribueras via CI/CD och kräver inte git-integrering.Changes to test and production are deployed via CI/CD and don't need Git integration.

  • Data Factory CI/CD-skript.Data Factory CI/CD script. Innan du utför distributions steget i Resource Manager i CI/CD måste du slutföra vissa åtgärder, t. ex. stoppa och starta om utlösare och rensning.Before the Resource Manager deployment step in CI/CD, you need to complete certain tasks, like stopping and restarting triggers and performing cleanup. Vi rekommenderar att du använder PowerShell-skript före och efter distributionen.We recommend that you use PowerShell scripts before and after deployment. Mer information finns i Uppdatera aktiva utlösare.For more information, see Update active triggers.

  • Integrerings körningar och delning.Integration runtimes and sharing. Integrerings körningar ändras inte ofta och liknar varandra i alla steg i CI/CD.Integration runtimes don't change often and are similar across all stages in your CI/CD. Så Data Factory förväntar dig att du har samma namn och typ av integration runtime i alla stadier av CI/CD.So Data Factory expects you to have the same name and type of integration runtime across all stages of CI/CD. Om du vill dela integrerings körningar i alla faser bör du överväga att använda en ternär fabrik som bara innehåller de delade integrerings körningarna.If you want to share integration runtimes across all stages, consider using a ternary factory just to contain the shared integration runtimes. Du kan använda den här delade fabriken i alla dina miljöer som en länkad integration runtime-typ.You can use this shared factory in all of your environments as a linked integration runtime type.

  • Key Vault.Key Vault. När du använder länkade tjänster baserat på Azure Key Vault kan du dra nytta av dem ytterligare genom att hålla separata nyckel valv för olika miljöer.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. Du kan också konfigurera separata behörighets nivåer för varje nyckel valv.You can also configure separate permission levels for each key vault. Till exempel kanske du inte vill att dina team medlemmar ska ha behörighet till produktions hemligheter.For example, you might not want your team members to have permissions to production secrets. Om du följer den här metoden rekommenderar vi att du behåller samma hemliga namn i alla steg.If you follow this approach, we recommend that you to keep the same secret names across all stages. Om du behåller samma namn behöver du inte ändra dina Resource Manager-mallar i CI/CD-miljöer eftersom det enda som ändras är nyckel valvets namn, vilket är en av parametrarna för Resource Manager-mallen.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.

Funktioner som inte stödsUnsupported features

  • Enligt design tillåter Data Factory inte körsbär-plockning av incheckningar eller selektiv publicering av resurser.By design, Data Factory doesn't allow cherry-picking of commits or selective publishing of resources. Publiceringar tar med alla ändringar som gjorts i data fabriken.Publishes will include all changes made in the data factory.

    • Data Factory-entiteter är beroende av varandra.Data factory entities depend on each other. Utlösare är exempelvis beroende av pipeliner och pipeliner beror på data uppsättningar och andra pipeliner.For example, triggers depend on pipelines, and pipelines depend on datasets and other pipelines. Selektiv publicering av en del av resurser kan leda till oväntade beteenden och fel.Selective publishing of a subset of resources could lead to unexpected behaviors and errors.
    • Vid sällsynta tillfällen när du behöver selektiv publicering bör du överväga att använda en snabb korrigering.On rare occasions when you need selective publishing, consider using a hotfix. Mer information finns i avsnittet om snabb korrigeringar för produktions gren.For more information, see Hotfix production branch.
  • Du kan inte publicera från privata grenar.You can't publish from private branches.

  • Du kan för närvarande inte vara värd för projekt på Bitbucket.You can't currently host projects on Bitbucket.