Skapa en utlösare som kör en pipeline på ett rullande fönster

  • Artikel

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 steg för att skapa, starta och övervaka en utlösare för rullande fönster. Allmän information om utlösare och typer som stöds finns i Pipelinekörning och utlösare.

Utlösare för rullande fönster är en typ av utlösare som går igång med jämna tidsintervall från en angiven starttid och behåller sitt tillstånd. Rullande fönster är en serie sammanhängande tidsintervall med fast storlek som inte överlappar. En utlösare för rullande fönster har en en-till-en-relation med en pipeline och kan bara referera till en enskild pipeline. Utlösare för rullande fönster är ett mer tungt alternativ för schemautlösare som erbjuder en uppsättning funktioner för komplexa scenarier (beroende av andra utlösare för rullande fönster, omkörning av ett misslyckat jobb och ange användarförsök för pipelines). Mer information om skillnaden mellan schemautlösare och utlösare för rullande fönster finns här.

Azure Data Factory- och Synapse-portalen

  1. Om du vill skapa en utlösare för rullande fönster i Azure-portalen väljer du fliken Utlösare och väljer sedan Ny.
  2. När konfigurationsfönstret för utlösaren har öppnats väljer du Rullande fönster och definierar sedan egenskaperna för utlösaren för rullande fönster.
  3. När du är klar väljer du Spara.

Egenskaper för utlösartyp för rullande fönster

Ett rullande fönster har följande egenskaper för utlösartyp:

{
    "name": "MyTriggerName",
    "properties": {
        "type": "TumblingWindowTrigger",
        "runtimeState": "<<Started/Stopped/Disabled - readonly>>",
        "typeProperties": {
            "frequency": <<Minute/Hour>>,
            "interval": <<int>>,
            "startTime": "<<datetime>>",
            "endTime": <<datetime - optional>>,
            "delay": <<timespan - optional>>,
            "maxConcurrency": <<int>> (required, max allowed: 50),
            "retryPolicy": {
                "count": <<int - optional, default: 0>>,
                "intervalInSeconds": <<int>>,
            },
            "dependsOn": [
                {
                    "type": "TumblingWindowTriggerDependencyReference",
                    "size": <<timespan - optional>>,
                    "offset": <<timespan - optional>>,
                    "referenceTrigger": {
                        "referenceName": "MyTumblingWindowDependency1",
                        "type": "TriggerReference"
                    }
                },
                {
                    "type": "SelfDependencyTumblingWindowTriggerReference",
                    "size": <<timespan - optional>>,
                    "offset": <<timespan>>
                }
            ]
        },
        "pipeline": {
            "pipelineReference": {
                "type": "PipelineReference",
                "referenceName": "MyPipelineName"
            },
            "parameters": {
                "parameter1": {
                    "type": "Expression",
                    "value": "@{concat('output',formatDateTime(trigger().outputs.windowStartTime,'-dd-MM-yyyy-HH-mm-ss-ffff'))}"
                },
                "parameter2": {
                    "type": "Expression",
                    "value": "@{concat('output',formatDateTime(trigger().outputs.windowEndTime,'-dd-MM-yyyy-HH-mm-ss-ffff'))}"
                },
                "parameter3": "https://mydemo.azurewebsites.net/api/demoapi"
            }
        }
    }
}

Följande tabell innehåller en översikt på hög nivå över de viktigaste JSON-elementen som är relaterade till upprepning och schemaläggning av en utlösare för rullande fönster:

JSON-element beskrivning Typ Tillåtna värden Obligatoriskt
typ Typ av utlösare. Typen är det fasta värdet "TumblingWindowTrigger". String "TumblingWindowTrigger" Ja
runtimeState Det aktuella tillståndet för körningstiden för utlösaren.
Obs! Det här elementet är <readOnly>.		 String "Startad", "Stoppad", "Inaktiverad" Ja
frequency En sträng som representerar frekvensenheten (minuter, timmar eller månader) där utlösaren upprepas. Om startTime-datumvärdena är mer detaljerade än frekvensvärdet beaktas startTime-datumen när fönstergränserna beräknas. Om frekvensvärdet till exempel är varje timme och startTime-värdet är 2017-09-01T10:10:10Z är det första fönstret (2017-09-01T10:10:10Z, 2017-09-01T11:10:10Z). String "Minute", "Hour", "Month" Ja
interval Ett positivt heltal som anger intervallet för värdet för frequency och som avgör hur ofta utlösaren körs. Om intervallet till exempel är 3 och frekvensen är "timme" upprepas utlösaren var 3:e timme.
Obs! Minsta intervall för fönster är 5 minuter.		 Integer Ett positivt heltal. Ja
startTime Den första förekomsten, som kan vara tidigare. Det första utlösarintervallet är (startTime, startTime-intervall + ). Datum/tid Ett DateTime-värde. Ja
endTime Den sista förekomsten, som kan vara tidigare. Datum/tid Ett DateTime-värde. Ja
Försening Hur lång tid det går att fördröja starten av databehandlingen för fönstret. Pipelinekörningen startas efter den förväntade körningstiden plus fördröjningen. Fördröjningen definierar hur länge utlösaren väntar efter förfallstiden innan en ny körning utlöses. Fördröjningenändrar inte fönstrets startTime. Till exempel innebär ett fördröjningsvärde på 00:10:00 en fördröjning på 10 minuter. Tidsintervall
(hh:mm:ss)		 Ett tidsintervallvärde där standardvärdet är 00:00:00. Nej
maxConcurrency Antalet samtidiga utlösarkörningar som utlöses för fönster som är klara. Om du till exempel vill fylla varje timme för igår resulterar det i 24 fönster. Om maxConcurrency = 10 utlöses utlösarhändelser endast för de första 10 fönstren (00:00-01:00–09:00-10:00). När de första 10 utlösta pipelinekörningarna har slutförts utlöses utlösarkörningar för de kommande 10 fönstren (10:00-11:00–19:00-20:00). Om du fortsätter med det här exemplet med maxConcurrency = 10 finns det 10 windows klara, så finns det totalt 10 pipelinekörningar. Om det bara finns ett fönster klart finns det bara 1 pipelinekörning. Integer Ett heltal mellan 1 och 50. Ja
retryPolicy: Count Antalet återförsök innan pipelinekörningen markeras som "Misslyckades". Integer Ett heltal, där standardvärdet är 0 (inga återförsök). Nej
retryPolicy: intervalInSeconds Fördröjningen mellan återförsök som anges i sekunder. Integer Antalet sekunder, där standardvärdet är 30. Minimivärdet är 30. Nej
dependsOn: typ Typ av TumblingWindowTriggerReference. Krävs om ett beroende har angetts. String "TumblingWindowTriggerDependencyReference", "SelfDependencyTumblingWindowTriggerReference" Nej
dependsOn: storlek Storleken på beroendets rullande fönster. Tidsintervall
(hh:mm:ss)		 Ett positivt tidsintervallvärde där standardvärdet är fönsterstorleken för den underordnade utlösaren Nej
dependsOn: offset Förskjutningen av beroendeutlösaren. Tidsintervall
(hh:mm:ss)		 Ett tidsintervallvärde som måste vara negativt i ett självberoende. Om inget värde anges är fönstret samma som själva utlösaren. Självberoende: Ja
Övrigt: Nej

Kommentar

När en utlösare för rullande fönster har publicerats kan inte intervall och frekvens redigeras.

WindowStart- och WindowEnd-systemvariabler

Du kan använda systemvariablerna WindowStart och WindowEnd i utlösaren för rullande fönster i pipelinedefinitionen (det vill: för en del av en fråga). Skicka systemvariablerna som parametrar till din pipeline i utlösardefinitionen. I följande exempel visas hur du skickar dessa variabler som parametrar:

{
    "name": "MyTriggerName",
    "properties": {
        "type": "TumblingWindowTrigger",
            ...
        "pipeline": {
            "pipelineReference": {
                "type": "PipelineReference",
                "referenceName": "MyPipelineName"
            },
            "parameters": {
                "MyWindowStart": {
                    "type": "Expression",
                    "value": "@{concat('output',formatDateTime(trigger().outputs.windowStartTime,'-dd-MM-yyyy-HH-mm-ss-ffff'))}"
                },
                "MyWindowEnd": {
                    "type": "Expression",
                    "value": "@{concat('output',formatDateTime(trigger().outputs.windowEndTime,'-dd-MM-yyyy-HH-mm-ss-ffff'))}"
                }
            }
        }
    }
}

Om du vill använda systemvariabelvärdena WindowStart och WindowEnd i pipelinedefinitionen använder du parametrarna "MyWindowStart" och "MyWindowEnd" i enlighet med detta.

Körningsordning för fönster i ett scenario med återfyllnad

Om startTime för utlösaren är tidigare, kommer utlösaren att generera {M} backfill(past) körs parallellt och respekterar samtidighet för utlösare innan framtida körningar körs, baserat på den här formeln, M=(CurrentTime- TriggerStartTime)/TumblingWindowSize. Körningsordningen för windows är deterministisk, från äldsta till nyaste intervall. Det här beteendet kan för närvarande inte ändras.

Kommentar

Tänk på att i det här scenariot körs alla körningar från den valda startTime innan framtida körningar körs. Om du behöver fylla på en lång tid rekommenderar vi att du utför en intial historisk belastning.

Befintliga TriggerResource-element

Följande punkter gäller för uppdatering av befintliga TriggerResource-element :

  • Det går inte att ändra värdet för frekvenselementet (eller fönsterstorleken) för utlösaren tillsammans med intervallelementet när utlösaren har skapats. Detta krävs för korrekt funktion av triggerRun-omkörningar och beroendeutvärderingar
  • Om värdet för endTime-elementet i utlösaren ändras (läggs till eller uppdateras) återställs inte tillståndet för de fönster som redan har bearbetats. Utlösaren respekterar det nya endTime-värdet . Om det nya endTime-värdet ligger före de fönster som redan körs stoppas utlösaren. Annars stoppas utlösaren när det nya endTime-värdet påträffas.

Användartilldelade återförsök av pipelines

Vid pipelinefel kan utlösare för rullande fönster försöka köra den refererade pipelinen automatiskt igen med samma indataparametrar utan att användaren gör något. Detta kan anges med egenskapen "retryPolicy" i utlösardefinitionen.

Utlösarberoende för rullande fönster

Om du vill se till att en utlösare för rullande fönster körs först efter att en annan utlösare för rullande fönster har körts i datafabriken skapar du ett beroende av utlösare för rullande fönster.

Avbryt körning av rullande fönster

Du kan avbryta körningar för en utlösare för rullande fönster, om det specifika fönstret är i tillståndet Väntar, Väntar på beroende eller Körs

  • Om fönstret är i körningstillstånd avbryter du den associerade pipelinekörningen och utlösarkörningen markeras som Avbryt efteråt
  • Om fönstret är i vänteläge eller väntar på beroendetillstånd kan du avbryta fönstret från Övervakning:

Du kan också köra ett avbrutet fönster igen. Omkörningen tar de senaste publicerade definitionerna av utlösaren och beroenden för det angivna fönstret utvärderas igen vid omkörning

Exempel för Azure PowerShell och Azure CLI

Det här avsnittet visar hur du använder Azure PowerShell för att skapa, starta och övervaka en utlösare.

Kommentar

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

Förutsättningar

Exempelkod

  1. 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 startTime-elementet till aktuell UTC-tid. Ange värdet för endTime-elementet till en timme efter den aktuella UTC-tiden.

    {
  "name": "PerfTWTrigger",
  "properties": {
    "type": "TumblingWindowTrigger",
    "typeProperties": {
      "frequency": "Minute",
      "interval": "15",
      "startTime": "2017-09-08T05:30:00Z",
      "endTime" : "2017-09-08T06:30:00Z",
      "delay": "00:00:01",
      "retryPolicy": {
        "count": 2,
        "intervalInSeconds": 30
      },
      "maxConcurrency": 50
    },
    "pipeline": {
      "pipelineReference": {
        "type": "PipelineReference",
        "referenceName": "DynamicsToBlobPerfPipeline"
      },
      "parameters": {
        "windowStart": "@trigger().outputs.windowStartTime",
        "windowEnd": "@trigger().outputs.windowEndTime"
      }
    },
    "runtimeState": "Started"
  }
}

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

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

  3. 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"

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

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

  5. 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"

  6. 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 få information om utlösarkörningarna. Uppdatera värdena TriggerRunStartedAfter 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"

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

Relaterat innehåll