Dela via

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 tidsintervall med fast storlek, icke-överlappande och sammanhängande. 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.

En utlösare för rullande fönster är ett mer tungviktsalternativ för en schemautlösare. Den erbjuder en uppsättning funktioner för komplexa scenarier som (beroende av andra utlösare för rullande fönster, omkörning av ett misslyckat jobb och inställning av användarens återförsök för pipelines). Mer information om skillnaden mellan en schemautlösare och en utlösare för rullande fönster finns i Jämförelse av utlösaretyp.

Azure Data Factory och Azure 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. Definiera sedan utlösaregenskaperna 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
type Typ av utlösare. type är det fasta värdet TumblingWindowTrigger. String TumblingWindowTrigger Ja
runtimeState Det aktuella tillståndet för körningstiden för utlösaren.
Det här elementet är <readOnly>.		 String Started, , StoppedDisabled Ja
frequency En sträng som representerar frekvensenheten (minuter, timmar eller månader) där utlösaren upprepas. startTime Om datumvärdena är mer detaljerade än frequency värdet beaktas datumen startTime när fönstergränserna beräknas. Om värdet till exempel frequency är hourly 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, , HourMonth Ja
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 hour, återkommer utlösaren var 3:e timme.
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 + interval). DateTime Ett DateTime värde. Ja
endTime Den sista förekomsten, som kan vara tidigare. DateTime Ett DateTime värde. Ja
delay 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önstret startTime. Till exempel innebär värdet delay 00:10:00 en fördröjning på 10 minuter. Timespan
(hh:mm:ss)		 Ett timespan vä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. Till exempel att återfylla varje timme körs för igår resulterar 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 maxConcurrency på = 10 finns det 10 windows klara, så finns det totalt 10 pipelinekörningar. Om bara ett fönster är klart körs bara en pipeline. Integer Ett heltal mellan 1 och 50. Ja
retryPolicy: Count Antalet återförsök innan pipelinekörningen markeras som Failed. 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: type Typen av TumblingWindowTriggerReference. Krävs om ett beroende har angetts. String TumblingWindowTriggerDependencyReference, SelfDependencyTumblingWindowTriggerReference Nej
dependsOn: size Storleken på beroendets rullande fönster. Timespan
(hh:mm:ss)		 Ett positivt timespan värde där standardvärdet är fönsterstorleken för den underordnade utlösaren. Nej
dependsOn: offset Förskjutningen av beroendeutlösaren. Timespan
(hh:mm:ss)		 Ett timespan vä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 interval kan värdena och frequency inte redigeras.

WindowStart- och WindowEnd-systemvariabler

Du kan använda WindowStart systemvariablerna och WindowEnd för 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 WindowStart värdena och WindowEnd systemvariabeln 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 utlösaren startTime är i det förflutna, sedan baserat på formeln M=(CurrentTime- TriggerStartTime)/TumblingWindowSize, genererar utlösaren {M} återfyllnad(tidigare) körs parallellt och respekterar samtidighet i utlösaren innan framtida körningar körs. 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

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 inledande 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 elementet frequency (eller fönsterstorleken) för utlösaren tillsammans med elementet interval när utlösaren har skapats. Den här begränsningen krävs för att återkörningar och beroendeutvärderingar ska fungera triggerRun korrekt.
  • Om värdet för elementet i endTime utlösaren ändras (genom att lägga till eller uppdatera) å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 en utlösare för rullande fönster försöka köra den refererade pipelinen automatiskt igen med hjälp av samma indataparametrar, utan användarintervention. Använd egenskapen retryPolicy i utlösardefinitionen för att ange den här åtgärden.

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 en rullande fönsterkörning

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 ett körningstillstånd avbryter du den associerade pipelinekörningen och utlösarkörningen markeras som Avbryt efteråt.
  • Om fönstret är i beroendetillståndet Väntar eller Väntar på 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. Beroenden för det angivna fönstret omvärderas 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. 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.

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 elementet startTime till aktuell UTC-tid (Coordinated Universal Time). Ange värdet för elementet endTime 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. 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"

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

Relaterat innehåll