Skapa en utlösare som kör en pipeline enligt ett schema

Artikel
06/27/2024

GÄLLER FÖR: Azure Data Factory Azure Synapse Analytics

Dricks

Prova Data Factory i Microsoft Fabric, en allt-i-ett-analyslösning för företag. Microsoft Fabric omfattar allt från dataflytt till datavetenskap, realtidsanalys, business intelligence och rapportering. Lär dig hur du startar en ny utvärderingsversion kostnadsfritt!

Den här artikeln innehåller information om schemautlösaren och stegen för att skapa, starta och övervaka en schemautlösare. Andra typer av utlösare finns i Pipelinekörning och utlösare.

När du skapar en schemautlösare anger du ett schema som startdatum, upprepning eller slutdatum för utlösaren och associerar det med en pipeline. Pipeliner och utlösare har en många-till-många-relation. Flera utlösare kan starta en pipeline. En enskild utlösare kan starta flera pipeliner.

Följande avsnitt innehåller steg för att skapa en schemautlösare på olika sätt.

Azure Data Factory och Azure Synapse-portalen

Du kan skapa en schemautlösare för att schemalägga en pipeline som ska köras regelbundet, till exempel varje timme eller varje dag.

Kommentar

En fullständig genomgång av hur du skapar en pipeline och en schemautlösare, som associerar utlösaren med pipelinen och kör och övervakar pipelinen, finns i Snabbstart: Skapa en datafabrik med hjälp av Data Factory-användargränssnittet.

Växla till fliken Redigera i Data Factory eller fliken Integrera i Azure Synapse.
- Azure Data Factory
- Azure Synapse

Välj Utlösare på menyn och välj sedan Ny/redigera.
På sidan Lägg till utlösare väljer du Välj utlösare och sedan Nytt.
På sidan Ny utlösare :
1. Bekräfta att Schema har valts för Typ.
2. Ange startdatumtiden för utlösaren för startdatum. Den är inställd på aktuell datetime i Coordinated Universal Time (UTC) som standard.
3. Ange den tidszon där utlösaren skapas. Tidszonsinställningen gäller startdatum, slutdatum och schemakörningstider i avancerade upprepningsalternativ. Om du ändrar inställningen Tidszon ändras inte startdatumet automatiskt. Kontrollera att startdatumet är korrekt i den angivna tidszonen. Den schemalagda körningstiden för utlösaren anses vara efter startdatumet. (Kontrollera att startdatumet är minst 1 minut mindre än körningstiden, annars utlöses pipelinen i nästa upprepning.)
  
  Kommentar
  
  För tidszoner som observerar sommartid justeras utlösartiden automatiskt för ändringen två gånger om året, om upprepningen är inställd på Dagar eller högre. Om du vill välja bort sommartidsändringen väljer du en tidszon som inte observerar sommartid, till exempel UTC.
  
  Sommartidsjustering sker endast för en utlösare med upprepningen inställd på Dagar eller senare. Om utlösaren är inställd på Frekvens för timmar eller minuter fortsätter den att utlösas med jämna mellanrum.
4. Ange Upprepning för utlösaren. Välj ett av värdena i listrutan (Varje minut, Varje minut, Varje timme, Varje dag, Varje vecka eller Varje månad). Ange multiplikatorn i textrutan. Om du till exempel vill att utlösaren ska köras en gång var 15:e minut väljer du Varje minut och anger 15 i textrutan.
5. Om du väljer Dag(er), Vecka(er) eller Month(s) i listrutan under Upprepning kan du se avancerade upprepningsalternativ.
6. Om du vill ange en slutdatumstid väljer du Ange ett slutdatum. Ange informationen Slutar på och välj sedan OK.
  
  En kostnad associeras med varje pipelinekörning. Om du testar kanske du vill se till att pipelinen bara utlöses ett par gånger. Se dock till att det finns tillräckligt med tid för pipelinen att köras mellan publiceringstiden och sluttiden. Utlösaren träder i kraft först när du har publicerat lösningen, inte när du sparar utlösaren i användargränssnittet.
I fönstret Ny utlösare väljer du Ja i alternativet Aktiverad och väljer sedan OK. Du kan använda den här kryssrutan för att inaktivera utlösaren senare.
I fönstret Ny utlösare granskar du varningsmeddelandet och väljer sedan OK.
Välj Publicera alla för att publicera ändringarna. Innan du publicerar ändringarna börjar utlösaren inte utlösa pipelinekörningarna.
Växla till fliken Pipelinekörningar till vänster och välj sedan Uppdatera för att uppdatera listan. Du ser pipelinekörningarna som utlöses av den schemalagda utlösaren. Observera värdena i kolumnen Aktiverad av. Om du använder alternativet Utlösare nu visas den manuella utlösaren i listan.
- Azure Data Factory
- Azure Synapse

Växla till schemavyn Utlösare körs>.
- Azure Data Factory
- Azure Synapse

Azure PowerShell

Kommentar

Vi rekommenderar att du använder Azure Az PowerShell-modulen för att interagera med Azure. Information om hur du kommer igång finns i Installera Azure PowerShell. Information om hur du migrerar till Az PowerShell-modulen finns i artikeln om att migrera Azure PowerShell från AzureRM till Az.

Det här avsnittet visar hur du använder Azure PowerShell för att skapa, starta och övervaka en schemautlösare. Om du vill se att det här exemplet fungerar går du först igenom Snabbstart: Skapa en datafabrik med hjälp av Azure PowerShell. Lägg sedan till följande kod i huvudmetoden, som skapar och startar en schemautlösare som körs var 15:e minut. Utlösaren är associerad med en pipeline med namnet Adfv2QuickStartPipeline som du skapar som en del av snabbstarten.

Förutsättningar

Azure-prenumeration. Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.
Azure PowerShell. Följ anvisningarna i Installera Azure PowerShell i Windows med PowerShellGet.

Exempelkod

Skapa en JSON-fil med namnet MyTrigger.json i mappen *C:\ADFv2QuickStartPSH* med följande innehåll:

Viktigt!

Innan du sparar JSON-filen anger du värdet för elementet startTime till aktuell UTC-tid. Ange värdet för elementet endTime till en timme efter den aktuella UTC-tiden.
```
{
    "properties": {
        "name": "MyTrigger",
        "type": "ScheduleTrigger",
        "typeProperties": {
            "recurrence": {
                "frequency": "Minute",
                "interval": 15,
                "startTime": "2017-12-08T00:00:00Z",
                "endTime": "2017-12-08T01:00:00Z",
                "timeZone": "UTC"
            }
        },
        "pipelines": [{
                "pipelineReference": {
                    "type": "PipelineReference",
                    "referenceName": "Adfv2QuickStartPipeline"
                },
                "parameters": {
                    "inputPath": "adftutorial/input",
                    "outputPath": "adftutorial/output"
                }
            }
        ]
    }
}
```
I JSON-kodfragmentet:
- Utlösarens type element är inställt på ScheduleTrigger.
- Elementet frequency är inställt på Minute och elementet interval är inställt på 15. Därför kör utlösaren pipelinen var 15:e minut mellan start- och sluttiderna.
- Elementet timeZone anger den tidszon där utlösaren skapas. Den här inställningen påverkar både startTime och endTime.
- Elementet endTime är en timme efter elementets startTime värde. Därför kör utlösaren pipelinen 15 minuter, 30 minuter och 45 minuter efter starttiden. Glöm inte att uppdatera starttiden till den aktuella UTC-tiden och sluttiden till en timme efter starttiden.
  
  Viktigt!
  
  För UTC-tidszonen startTime och endTime måste följa formatet yyyy-MM-ddTHH:mm:ssZ. För andra tidszoner startTime och endTime följ yyyy-MM-ddTHH:mm:ss formatet.
  
  Enligt ISO 8601-standarden används suffixet Z för att tidsstämpeln markera datetime till UTC-tidszonen timeZone och göra fältet värdelöst. Om suffixet Z för UTC-tidszonen saknas är resultatet ett fel vid aktivering av utlösaren.
- Utlösaren är associerad med pipelinen Adfv2QuickStartPipeline . Om du vill associera flera pipelines med en utlösare lägger du till fler pipelineReference avsnitt.
- Pipelinen i snabbstarten tar två parameters värden: inputPath och outputPath. Du skickar värden för dessa parametrar från utlösaren.

Skapa en utlösare med hjälp av cmdleten Set-AzDataFactoryV2Trigger :

Set-AzDataFactoryV2Trigger -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Name "MyTrigger" -DefinitionFile "C:\ADFv2QuickStartPSH\MyTrigger.json"

Bekräfta att statusen för utlösaren har stoppats med hjälp av cmdleten Get-AzDataFactoryV2Trigger :

Get-AzDataFactoryV2Trigger -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Name "MyTrigger"

Starta utlösaren med hjälp av cmdleten Start-AzDataFactoryV2Trigger :

Start-AzDataFactoryV2Trigger -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Name "MyTrigger"

Bekräfta att statusen för utlösaren är Startad med hjälp av cmdleten Get-AzDataFactoryV2Trigger :

Get-AzDataFactoryV2Trigger -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -Name "MyTrigger"

Hämta utlösaren körs i Azure PowerShell med hjälp av cmdleten Get-AzDataFactoryV2TriggerRun . Kör följande kommando med jämna mellanrum för att hämta information om utlösarkörningarna. TriggerRunStartedAfter Uppdatera värdena och TriggerRunStartedBefore så att de matchar värdena i utlösardefinitionen:
```
Get-AzDataFactoryV2TriggerRun -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -TriggerName "MyTrigger" -TriggerRunStartedAfter "2017-12-08T00:00:00" -TriggerRunStartedBefore "2017-12-08T01:00:00"
```
Kommentar

Utlösarens tid för schemautlösare anges i UTC-tidsstämpeln. TriggerRunStartedAfter och TriggerRunStartedBefore förvänta dig även UTC-tidsstämpeln.

Information om hur du övervakar utlösarkörningar och pipelinekörningar i Azure-portalen finns i Övervaka pipelinekörningar.

Azure CLI

Det här avsnittet visar hur du använder Azure CLI för att skapa, starta och övervaka en schemautlösare. Om du vill se att det här exemplet fungerar går du först igenom Snabbstart: Skapa en Azure Data Factory med hjälp av Azure CLI. Följ sedan stegen för att skapa och starta en schemautlösare som körs var 15:e minut. Utlösaren är associerad med en pipeline med namnet Adfv2QuickStartPipeline som du skapar som en del av snabbstarten.

Förutsättningar

Använd Bash-miljön i Azure Cloud Shell. Mer information finns i Snabbstart för Bash i Azure Cloud Shell.
Om du föredrar att köra CLI-referenskommandon lokalt installerar du Azure CLI. Om du kör i Windows eller macOS kan du köra Azure CLI i en Docker-container. Mer information finns i Så här kör du Azure CLI i en Docker-container.
- Om du använder en lokal installation loggar du in på Azure CLI med hjälp av kommandot az login. Slutför autentiseringsprocessen genom att följa stegen som visas i terminalen. Andra inloggningsalternativ finns i Logga in med Azure CLI.
- När du uppmanas att installera Azure CLI-tillägget vid första användningen. Mer information om tillägg finns i Använda tillägg med Azure CLI.
- Kör az version om du vill hitta versionen och de beroende bibliotek som är installerade. Om du vill uppgradera till den senaste versionen kör du az upgrade.

Exempelkod

I arbetskatalogen skapar du en JSON-fil med namnet MyTrigger.json med utlösarens egenskaper. I det här exemplet använder du följande innehåll:

Viktigt!

Innan du sparar JSON-filen anger du värdet för elementet startTime till aktuell UTC-tid. Ange värdet för elementet endTime till en timme efter den aktuella UTC-tiden.
```
{
    "name": "MyTrigger",
    "type": "ScheduleTrigger",
    "typeProperties": {
        "recurrence": {
            "frequency": "Minute",
            "interval": 15,
            "startTime": "2017-12-08T00:00:00Z",
            "endTime": "2017-12-08T01:00:00Z",
            "timeZone": "UTC"
        }
    },
    "pipelines": [{
            "pipelineReference": {
                "type": "PipelineReference",
                "referenceName": "Adfv2QuickStartPipeline"
            },
            "parameters": {
                "inputPath": "adftutorial/input",
                "outputPath": "adftutorial/output"
            }
        }
    ]
}
```
I JSON-kodfragmentet:
- Utlösarens type element är inställt på ScheduleTrigger.
- Elementet frequency är inställt på Minute och elementet interval är inställt på 15. Därför kör utlösaren pipelinen var 15:e minut mellan start- och sluttiderna.
- Elementet timeZone anger den tidszon där utlösaren skapas. Den här inställningen påverkar både startTime och endTime.
- Elementet endTime är en timme efter elementets startTime värde. Därför kör utlösaren pipelinen 15 minuter, 30 minuter och 45 minuter efter starttiden. Glöm inte att uppdatera starttiden till den aktuella UTC-tiden och sluttiden till en timme efter starttiden.
  
  Viktigt!
  
  För UTC-tidszonen startTime måste och endTime följa formatet yyyy-MM-ddTHH:mm:ssZ. För andra tidszoner startTime och endTime följ yyyy-MM-ddTHH:mm:ss formatet.
  
  Enligt STANDARDEN ISO 8601 används Z-suffixet för att tidsstämpeln markera datetime till UTC-tidszonen timeZone och göra fältet värdelöst. Om Z-suffixet saknas för UTC-tidszonen är resultatet ett fel vid aktivering av utlösaren.
- Utlösaren är associerad med pipelinen Adfv2QuickStartPipeline . Om du vill associera flera pipelines med en utlösare lägger du till fler pipelineReference avsnitt.
- Pipelinen i snabbstarten tar två parameters värden: inputPath och outputPath. Du skickar värden för dessa parametrar från utlösaren.

Skapa en utlösare med kommandot az datafactory trigger create :

az datafactory trigger create --resource-group "ADFQuickStartRG" --factory-name "ADFTutorialFactory"  --name "MyTrigger" --properties @MyTrigger.json

Bekräfta att statusen för utlösaren stoppas med kommandot az datafactory trigger show:

az datafactory trigger show --resource-group "ADFQuickStartRG" --factory-name "ADFTutorialFactory" --name "MyTrigger"

Starta utlösaren med hjälp av kommandot az datafactory trigger start :

az datafactory trigger start --resource-group "ADFQuickStartRG" --factory-name "ADFTutorialFactory" --name "MyTrigger"

Bekräfta att statusen för utlösaren är Startad med kommandot az datafactory trigger show :

az datafactory trigger show --resource-group "ADFQuickStartRG" --factory-name "ADFTutorialFactory" --name "MyTrigger"

Hämta utlösaren körs i Azure CLI med hjälp av kommandot az datafactory trigger-run query-by-factory . Kör följande kommando med jämna mellanrum för att få information om utlösarkörningarna. last-updated-after Uppdatera värdena och last-updated-before så att de matchar värdena i utlösardefinitionen:
```
az datafactory trigger-run query-by-factory --resource-group "ADFQuickStartRG" --factory-name "ADFTutorialFactory" --filters operand="TriggerName" operator="Equals" values="MyTrigger" --last-updated-after "2017-12-08T00:00:00" --last-updated-before "2017-12-08T01:00:00"
```
Kommentar

Utlösartiderna för schemautlösare anges i UTC-tidsstämpeln. last-updated-after och last-updated-before förväntar sig också UTC-tidsstämpeln.

Information om hur du övervakar utlösarkörningar och pipelinekörningar i Azure-portalen finns i Övervaka pipelinekörningar.

.NET SDK

Det här avsnittet visar hur du använder .NET SDK för att skapa, starta och övervaka en utlösare. Om du vill se att det här exemplet fungerar går du först igenom Snabbstart: Skapa en datafabrik med hjälp av .NET SDK. Lägg sedan till följande kod i huvudmetoden, som skapar och startar en schemautlösare som körs var 15:e minut. Utlösaren är associerad med en pipeline med namnet Adfv2QuickStartPipeline som du skapar som en del av snabbstarten.

Om du vill skapa och starta en schemautlösare som körs var 15:e minut lägger du till följande kod i huvudmetoden:

            // Create the trigger
            Console.WriteLine("Creating the trigger");

            // Set the start time to the current UTC time
            DateTime startTime = DateTime.UtcNow;

            // Specify values for the inputPath and outputPath parameters
            Dictionary<string, object> pipelineParameters = new Dictionary<string, object>();
            pipelineParameters.Add("inputPath", "adftutorial/input");
            pipelineParameters.Add("outputPath", "adftutorial/output");

            // Create a schedule trigger
            string triggerName = "MyTrigger";
            ScheduleTrigger myTrigger = new ScheduleTrigger()
            {
                Pipelines = new List<TriggerPipelineReference>()
                {
                    // Associate the Adfv2QuickStartPipeline pipeline with the trigger
                    new TriggerPipelineReference()
                    {
                        PipelineReference = new PipelineReference(pipelineName),
                        Parameters = pipelineParameters,
                    }
                },
                Recurrence = new ScheduleTriggerRecurrence()
                {
                    // Set the start time to the current UTC time and the end time to one hour after the start time
                    StartTime = startTime,
                    TimeZone = "UTC",
                    EndTime = startTime.AddHours(1),
                    Frequency = RecurrenceFrequency.Minute,
                    Interval = 15,
                }
            };

            // Now, create the trigger by invoking the CreateOrUpdate method
            TriggerResource triggerResource = new TriggerResource()
            {
                Properties = myTrigger
            };
            client.Triggers.CreateOrUpdate(resourceGroup, dataFactoryName, triggerName, triggerResource);

            // Start the trigger
            Console.WriteLine("Starting the trigger");
            client.Triggers.Start(resourceGroup, dataFactoryName, triggerName);

Följande inställningar krävs för att skapa utlösare i en annan tidszon än UTC:

<<ClientInstance>>.SerializationSettings.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat;
<<ClientInstance>>.SerializationSettings.DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Unspecified;
<<ClientInstance>>.SerializationSettings.DateParseHandling = DateParseHandling.None;
<<ClientInstance>>.DeserializationSettings.DateParseHandling = DateParseHandling.None;
<<ClientInstance>>.DeserializationSettings.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat;
<<ClientInstance>>.DeserializationSettings.DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Unspecified;

Om du vill övervaka en utlösarkörning lägger du till följande kod före den sista Console.WriteLine instruktionen i exemplet:

            // Check that the trigger runs every 15 minutes
            Console.WriteLine("Trigger runs. You see the output every 15 minutes");

            for (int i = 0; i < 3; i++)
            {
                System.Threading.Thread.Sleep(TimeSpan.FromMinutes(15));
                List<TriggerRun> triggerRuns = client.Triggers.ListRuns(resourceGroup, dataFactoryName, triggerName, DateTime.UtcNow.AddMinutes(-15 * (i + 1)), DateTime.UtcNow.AddMinutes(2)).ToList();
                Console.WriteLine("{0} trigger runs found", triggerRuns.Count);

                foreach (TriggerRun run in triggerRuns)
                {
                    foreach (KeyValuePair<string, string> triggeredPipeline in run.TriggeredPipelines)
                    {
                        PipelineRun triggeredPipelineRun = client.PipelineRuns.Get(resourceGroup, dataFactoryName, triggeredPipeline.Value);
                        Console.WriteLine("Pipeline run ID: {0}, Status: {1}", triggeredPipelineRun.RunId, triggeredPipelineRun.Status);
                        List<ActivityRun> runs = client.ActivityRuns.ListByPipelineRun(resourceGroup, dataFactoryName, triggeredPipelineRun.RunId, run.TriggerRunTimestamp.Value, run.TriggerRunTimestamp.Value.AddMinutes(20)).ToList();
                    }
                }
            }

Information om hur du övervakar utlösarkörningar och pipelinekörningar i Azure-portalen finns i Övervaka pipelinekörningar.

Python SDK

Det här avsnittet visar hur du använder Python SDK för att skapa, starta och övervaka en utlösare. Om du vill se att det här exemplet fungerar går du först igenom Snabbstart: Skapa en datafabrik med hjälp av Python SDK. Lägg sedan till följande kodblock efter kodblocket monitor the pipeline run i Python-skriptet. Den här koden skapar en schemautlösare som körs var 15:e minut mellan de angivna start- och sluttiderna. Uppdatera variabeln start_time till aktuell UTC-tid och variabeln end_time till en timme efter den aktuella UTC-tiden.

    # Create a trigger
    tr_name = 'mytrigger'
    scheduler_recurrence = ScheduleTriggerRecurrence(frequency='Minute', interval='15',start_time='2017-12-12T04:00:00Z', end_time='2017-12-12T05:00:00Z', time_zone='UTC')
    pipeline_parameters = {'inputPath':'adftutorial/input', 'outputPath':'adftutorial/output'}
    pipelines_to_run = []
    pipeline_reference = PipelineReference('copyPipeline')
    pipelines_to_run.append(TriggerPipelineReference(pipeline_reference, pipeline_parameters))
    tr_properties = TriggerResource(properties=ScheduleTrigger(description='My scheduler trigger', pipelines = pipelines_to_run, recurrence=scheduler_recurrence))
    adf_client.triggers.create_or_update(rg_name, df_name, tr_name, tr_properties)

    # Start the trigger
    adf_client.triggers.start(rg_name, df_name, tr_name)

Information om hur du övervakar utlösarkörningar och pipelinekörningar i Azure-portalen finns i Övervaka pipelinekörningar.

Azure Resource Manager-mall

Du kan använda en Azure Resource Manager-mall för att skapa en utlösare. Stegvisa instruktioner finns i Skapa en Azure-datafabrik med hjälp av en Azure Resource Manager-mall.

Skicka utlösarens starttid till en pipeline

Azure Data Factory version 1 stöder läsning eller skrivning av partitionerade data med hjälp av systemvariablerna SliceStart, SliceEnd, WindowStartoch WindowEnd. I den aktuella versionen av Data Factory- och Azure Synapse-pipelines kan du uppnå det här beteendet med hjälp av en pipelineparameter. Starttiden och den schemalagda tiden för utlösaren anges som värde för pipelineparametern. I följande exempel skickas den schemalagda tiden för utlösaren som ett värde till pipelineparametern scheduledRunTime :

"parameters": {
    "scheduledRunTime": "@trigger().scheduledTime"
}

JSON-schema

Följande JSON-definition visar hur du skapar en schemautlösare med schemaläggning och upprepning:

{
  "properties": {
    "type": "ScheduleTrigger",
    "typeProperties": {
      "recurrence": {
        "frequency": <<Minute, Hour, Day, Week, Month>>,
        "interval": <<int>>,             // Optional, specifies how often to fire (default to 1)
        "startTime": <<datetime>>,
        "endTime": <<datetime - optional>>,
        "timeZone": "UTC"
        "schedule": {                    // Optional (advanced scheduling specifics)
          "hours": [<<0-23>>],
          "weekDays": [<<Monday-Sunday>>],
          "minutes": [<<0-59>>],
          "monthDays": [<<1-31>>],
          "monthlyOccurrences": [
               {
                    "day": <<Monday-Sunday>>,
                    "occurrence": <<1-5>>
               }
           ]
        }
      }
    },
   "pipelines": [
            {
                "pipelineReference": {
                    "type": "PipelineReference",
                    "referenceName": "<Name of your pipeline>"
                },
                "parameters": {
                    "<parameter 1 Name>": {
                        "type": "Expression",
                        "value": "<parameter 1 Value>"
                    },
                    "<parameter 2 Name>" : "<parameter 2 Value>"
                }
           }
      ]
  }
}

Viktigt!

Egenskapen parameters är en obligatorisk egenskap för elementet pipelines . Om pipelinen inte tar några parametrar måste du inkludera en tom JSON-definition för parameters egenskapen.

Schemaöversikt

Följande tabell innehåller en översikt på hög nivå över de viktigaste schemaelementen som är relaterade till upprepning och schemaläggning av en utlösare.

JSON-egenskap	beskrivning
`startTime`	Ett datum/tid-värde. För enkla scheman gäller värdet för `startTime` egenskapen för den första förekomsten. För komplexa scheman startar utlösaren inte tidigare än det angivna `startTime` värdet. För UTC-tidszonen är `'yyyy-MM-ddTHH:mm:ssZ'`formatet . För andra tidszoner är `yyyy-MM-ddTHH:mm:ss`formatet .
`endTime`	Slutdatum och tidpunkt för utlösaren. Utlösaren körs inte efter angivet slutdatum och sluttid. Värdet för egenskapen kan inte ha passerat. Den här egenskapen är valfri. För UTC-tidszonen är `'yyyy-MM-ddTHH:mm:ssZ'`formatet . För andra tidszoner är `yyyy-MM-ddTHH:mm:ss`formatet .
`timeZone`	Tidszonen där utlösaren skapas. Den här inställningen påverkar `startTime`, `endTime`och `schedule`. Se en lista över tidszoner som stöds.
`recurrence`	Ett upprepningsobjekt som anger upprepningsregler för utlösaren. Upprepningsobjektet stöder elementen `frequency`, `interval`, `endTime`, `count`och `schedule` . När ett upprepningsobjekt har definierats krävs elementet `frequency` . De andra elementen är valfria.
`frequency`	Frekvensen som utlösaren ska upprepas med. De värden som stöds är `minute,` `hour,` `day`, `week`och `month`.
`interval`	Ett positivt heltal som anger intervallet för `frequency` värdet, vilket avgör hur ofta utlösaren körs. Om t.ex `interval` . är `3` och `frequency` är `week`, återkommer utlösaren var tredje vecka.
`schedule`	Upprepningsschemat för utlösaren. En utlösare med ett angivet `frequency` värde ändrar upprepningen baserat på ett upprepningsschema. Egenskapen `schedule` innehåller ändringar för upprepningen som baseras på minuter, timmar, vardagar, månadsdagar och veckonummer.

Viktigt!

För UTC-tidszonen startTime och endTime måste följa formatet yyyy-MM-ddTHH:mm:ssZ. För andra tidszoner startTime och endTime följ yyyy-MM-ddTHH:mm:ss formatet.

Enligt STANDARDEN ISO 8601 används Z-suffixet för att tidsstämpeln markera datetime till UTC-tidszonen timeZone och göra fältet värdelöst. Om Z-suffixet saknas för UTC-tidszonen är resultatet ett fel vid aktivering av utlösaren.

Standardvärden för scheman, begränsningar och exempel

JSON-egenskap	Typ	Obligatoriskt	Standardvärde	Giltiga värden	Exempel
`startTime`	String	Ja	None	ISO 8601-datum/tid	För UTC-tidszonen: `"startTime" : "2013-01-09T09:30:00-08:00Z"` För andra tidszoner: `"2013-01-09T09:30:00-08:00"`
`timeZone`	String	Ja	None	Tidszonsvärden	`"UTC"`
`recurrence`	Objekt	Ja	None	Upprepningsobjekt	`"recurrence" : { "frequency" : "monthly", "interval" : 1 }`
`interval`	Antal	Nej	1	1 till 1 000	`"interval":10`
`endTime`	String	Ja	None	Datum/tid-värde som representerar en tid i framtiden	För UTC-tidszonen: `"endTime" : "2013-02-09T09:30:00-08:00Z"` För andra tidszoner: `"endTime" : "2013-02-09T09:30:00-08:00"`
`schedule`	Objekt	Nej	Ingen	Schemaobjekt	`"schedule" : { "minute" : [30], "hour" : [8,17] }`

Alternativ för tidszon

Här är några av de tidszoner som stöds för schemautlösare.

Time zone	UTC-förskjutning (icke-sommartid)	timeZone-värde	Observera sommartid	Tidsstämpelformat
Samordnad universell tid	0	`UTC`	Nej	`'yyyy-MM-ddTHH:mm:ssZ'`
Pacific Time (PT)	-8	`Pacific Standard Time`	Ja	`'yyyy-MM-ddTHH:mm:ss'`
Central tid (CT)	-6	`Central Standard Time`	Ja	`'yyyy-MM-ddTHH:mm:ss'`
Eastern Time (ET)	-5	`Eastern Standard Time`	Ja	`'yyyy-MM-ddTHH:mm:ss'`
Greenwich Mean Time (GMT)	0	`GMT Standard Time`	Ja	`'yyyy-MM-ddTHH:mm:ss'`
Centraleuropeiska standardtid	1+	`W. Europe Standard Time`	Ja	`'yyyy-MM-ddTHH:mm:ss'`
Indien, standardtid (IST)	+5:30	`India Standard Time`	Nej	`'yyyy-MM-ddTHH:mm:ss'`
Kina, standardtid	+8	`China Standard Time`	Nej	`'yyyy-MM-ddTHH:mm:ss'`

Den här listan är ofullständig. En fullständig lista över tidszonsalternativ finns på sidan Skapa utlösare i portalen.

Egenskapen startTime

I följande tabell visas hur egenskapen startTime styr en utlösarkörning.

startTime-värde	Upprepning utan schema	Upprepning med schema
Starttid i förfluten tid	Beräknar första framtida körningstid efter starttiden och körs vid den tidpunkten. Utför efterföljande körningar baserat på beräkningar från senaste körningstid. Se exemplet som följer den här tabellen.	Utlösaren startar tidigast den angivna starttiden. Den första förekomsten baseras på schemat som beräknas från starttiden. Kör efterföljande körningar baserat på upprepningsschemat.
Starttid i framtiden eller aktuell tid	Körs en gång på angiven starttid. Utför efterföljande körningar baserat på beräkningar från senaste körningstid.	Utlösaren startar tidigast den angivna starttiden. Den första förekomsten baseras på schemat som beräknas från starttiden. Kör efterföljande körningar baserat på upprepningsschemat.

Låt oss se vad som händer när starttiden har passerat, med upprepning men utan schema. Anta att den aktuella tiden är 2017-04-08 13:00, starttiden är 2017-04-07 14:00 och upprepningen är varannan dag. (Värdet recurrence definieras genom att egenskapen anges frequency till day och egenskapen interval till 2.) Observera att värdet startTime är tidigare och inträffar före den aktuella tiden.

Under dessa förhållanden är den första körningen på 2017-04-09 14:00. Scheduler-motor beräknar körningsförekomster från starttiden. Alla tidigare instanser ignoreras. Motorn använder nästa förekomst som förekommer i framtiden. I det här scenariot är 2017-04-07 starttiden på 2:00pm, så nästa instans är två dagar från den tiden, som är 2017-04-09 på 2:00pm.

Den första körningstiden är densamma även om startTime värdet är 2017-04-05 14:00 eller 2017-04-01 14:00. Efter den första körningen beräknas efterföljande körningar med hjälp av schemat. Därför är de efterföljande körningarna på 2017-04-11 2:00pm, sedan 2017-04-13 vid 2:00pm, sedan 2017-04-15 vid 2:00pm, och så vidare.

När timmarna eller minuterna inte anges i schemat för en utlösare används slutligen timmarna eller minuterna för den första körningen som standard.

Egenskapen schedule

Användningen av ett schema kan begränsa antalet utlösarkörningar. Om en utlösare med månatlig frekvens till exempel har ett schema som bara körs dag 31 så körs utlösaren bara de månader som har en 31:a dag.

Ett schema kan också utöka antalet utlösarkörningar. En utlösare med månatlig frekvens som har schemalagts för att köras dag 1 och 2 körs den första och andra dagen i månaden snarare än en gång i månaden.

Om flera schedule element anges är utvärderingsordningen från den största till den minsta schemainställningen. Utvärderingen börjar med veckonumret och sedan månadsdagen, veckodag, timme och slutligen minut.

I följande tabell beskrivs elementen schedule i detalj.

JSON-element	beskrivning	Giltiga värden
`minutes`	Minuter för den timme då utlösaren körs.	Integer Heltalsmatris
`hours`	Timmar på dagen då utlösaren körs.	Integer Heltalsmatris
`weekDays`	Veckodagar som utlösaren körs på. Värdet kan bara anges med en veckofrekvens.	Måndag, tisdag, onsdag, torsdag, fredag, lördag, söndag. Matris med dagvärden (maximal matrisstorlek är 7). Dagvärden är inte skiftlägeskänsliga.
`monthlyOccurrences`	Dagar i månaden som utlösaren körs på. Värdet kan bara anges med en månadsfrekvens.	Matris med `monthlyOccurrences` objekt: `{ "day": day, "occurrence": occurrence }`. Attributet `day` är den veckodag då utlösaren körs. En egenskap med värdet `day` `{Sunday}` betyder till exempel `monthlyOccurrences` varje söndag i månaden. Attributet `day` krävs. Attributet `occurrence` är förekomsten av den angivna `day` under månaden. Till exempel innebär en `monthlyOccurrences` egenskap med `day` och `occurrence` värden `{Sunday, -1}` för den sista söndagen i månaden. Attributet `occurrence` är valfritt.
`monthDays`	Dagar i månaden som utlösaren körs på. Värdet kan bara anges med en månadsfrekvens.	Valfritt värde <= -1 och >= -31 Valfritt värde >= 1 och <= 31 Matris med värden

Exempel på scheman för upprepning av utlösare

Det här avsnittet innehåller exempel på upprepningsscheman och fokuserar på schedule objektet och dess element.

Exemplen interval förutsätter att värdet är 1 och att frequency värdet är korrekt enligt schemadefinitionen. Du kan till exempel inte ha ett frequency värde för day och även ha en monthDays ändring i objektet schedule . De här begränsningarna tas upp i tabellen i föregående avsnitt.

Exempel	beskrivning
`{"hours":[5]}`	Kör kl. 05.00 varje dag.
`{"minutes":[15], "hours":[5]}`	Kör kl. 05.15 varje dag.
`{"minutes":[15], "hours":[5,17]}`	Kör kl. 05.15 och 17.15 varje dag
`{"minutes":[15,45], "hours":[5,17]}`	Kör kl. 05.15, 5.45, 17.15 och 17.45 varje dag.
`{"minutes":[0,15,30,45]}`	Kör var 15:e minut.
`{hours":[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]}`	Kör varje timme. Den här utlösaren körs varje timme. Minuterna styrs av `startTime` värdet när ett värde anges. Om du inte anger något värde styrs minuterna av tiden för skapandet. Om starttiden eller skapandetiden (beroende på vilken som gäller) till exempel är 00.25 körs utlösaren 00.25, 01.25, 02.25, …, 23:25. Det här schemat motsvarar att ha en utlösare med `frequency` värdet , värdet `interval` `1`, och nej `schedule`.`hour` Det här schemat kan användas med olika `frequency` värden och `interval` för att skapa andra utlösare. När värdet `frequency` till exempel är `month`körs schemat bara en gång i månaden, i stället för varje dag, när `frequency` värdet är `day`.
`{"minutes":[0]}`	Körs varje hel timme. Den här utlösaren körs varje timma med början vid 00.00, 01.00, 02.00 och så vidare. Det här schemat motsvarar en utlösare med värdet `frequency` och värdet `startTime` noll minuter, eller inget `schedule` annat än värdet `frequency` `day`.`hour` Om värdet `frequency` är `week` eller `month`körs schemat endast en dag i veckan eller en dag i månaden.
`{"minutes":[15]}`	Körs 15 minuter efter varje hel timme. Den här utlösaren körs 15 minuter efter varje timme med början vid 00.15, 01.15, 02.15 och så vidare.
`{"hours":[17], "weekDays":["saturday"]}`	Körs 17.00 varje lördag.
`{"hours":[17], "weekDays":["monday", "wednesday", "friday"]}`	Körs 17.00 varje måndag, onsdag och fredag.
`{"minutes":[15,45], "hours":[17], "weekDays":["monday", "wednesday", "friday"]}`	Körs 17.15 och 17.45 varje måndag, onsdag och fredag.
`{"minutes":[0,15,30,45], "weekDays":["monday", "tuesday", "wednesday", "thursday", "friday"]}`	Körs var 15:e minut på vardagar.
`{"minutes":[0,15,30,45], "hours": [9, 10, 11, 12, 13, 14, 15, 16] "weekDays":["monday", "tuesday", "wednesday", "thursday", "friday"]}`	Körs var 15:e minut på vardagar mellan 09.00 och 16.45.
`{"weekDays":["tuesday", "thursday"]}`	Körs varje tisdag och torsdag den angivna starttiden.
`{"minutes":[0], "hours":[6], "monthDays":[28]}`	Kör kl. 06:00 den 28:e dagen i varje månad (med ett `frequency` värde på `month`).
`{"minutes":[0], "hours":[6], "monthDays":[-1]}`	Körs 06.00 den sista dagen i månaden. Om du vill köra en utlösare den sista dagen i månaden ska du använda -1 istället för dag 28, 29, 30 eller 31.
`{"minutes":[0], "hours":[6], "monthDays":[1,-1]}`	Körs 06.00 den första och sista dagen varje månad.
`{monthDays":[1,14]}`	Körs den första och den fjortonde dagen i varje månad den angivna starttiden.
`{"minutes":[0], "hours":[5], "monthlyOccurrences":[{"day":"friday", "occurrence":1}]}`	Körs den första fredagen i varje månad 05.00.
`{"monthlyOccurrences":[{"day":"friday", "occurrence":1}]}`	Körs den första fredagen i varje månad vid den angivna starttiden.
`{"monthlyOccurrences":[{"day":"friday", "occurrence":-3}]}`	Körs den tredje fredagen från slutet av månad, varje månad, vid den angivna starttiden.
`{"minutes":[15], "hours":[5], "monthlyOccurrences":[{"day":"friday", "occurrence":1},{"day":"friday", "occurrence":-1}]}`	Körs den första och sista fredagen i varje månad 05.15.
`{"monthlyOccurrences":[{"day":"friday", "occurrence":1},{"day":"friday", "occurrence":-1}]}`	Körs den första och sista fredagen i varje månad vid den angivna starttiden.
`{"monthlyOccurrences":[{"day":"friday", "occurrence":5}]}`	Körs den femte fredagen i varje månad vid den angivna starttiden. När det inte finns någon femte fredag på en månad körs inte pipelinen eftersom den endast är planerad att köras på femte fredagar. Om du vill köra utlösaren den senaste fredagen i månaden bör du överväga att använda -1 i stället för 5 för `occurrence` värdet.
`{"minutes":[0,15,30,45], "monthlyOccurrences":[{"day":"friday", "occurrence":-1}]}`	Körs var 15:e minut den sista fredagen i månaden.
`{"minutes":[15,45], "hours":[5,17], "monthlyOccurrences":[{"day":"wednesday", "occurrence":3}]}`	Körs 05.15, 05.45, 17.15 och 17.45 den tredje onsdagen varje månad.

Mer information om utlösare finns i Pipelinekörning och utlösare.
Information om hur du refererar till utlösarmetadata i pipeline finns i Referensutlösarmetadata i pipelinekörningar.

Dela via

Skapa en utlösare som kör en pipeline enligt ett schema

Azure Data Factory och Azure Synapse-portalen

Azure PowerShell

Förutsättningar

Exempelkod

Azure CLI

Förutsättningar

Exempelkod

.NET SDK

Python SDK

Azure Resource Manager-mall

Skicka utlösarens starttid till en pipeline

JSON-schema

Schemaöversikt

Standardvärden för scheman, begränsningar och exempel

Alternativ för tidszon

Egenskapen startTime

Egenskapen schedule

Exempel på scheman för upprepning av utlösare

Feedback

Ytterligare resurser

Dela via

Skapa en utlösare som kör en pipeline enligt ett schema

Azure Data Factory och Azure Synapse-portalen

Azure PowerShell

Förutsättningar

Exempelkod

Azure CLI

Förutsättningar

Exempelkod

.NET SDK

Python SDK

Azure Resource Manager-mall

Skicka utlösarens starttid till en pipeline

JSON-schema

Schemaöversikt

Standardvärden för scheman, begränsningar och exempel

Alternativ för tidszon

Egenskapen startTime

Egenskapen schedule

Exempel på scheman för upprepning av utlösare

Relaterat innehåll

Feedback

Ytterligare resurser