Compartilhar via

Criar um gatilho que execute um pipeline em uma janela em cascata

  • Artigo

APLICA-SE A: Azure Data Factory Azure Synapse Analytics

Dica

Experimente o Data Factory no Microsoft Fabric, uma solução de análise tudo-em-um para empresas. O Microsoft Fabric abrange desde movimentação de dados até ciência de dados, análise em tempo real, business intelligence e relatórios. Saiba como iniciar uma avaliação gratuita!

Este artigo fornece etapas para criar, iniciar e monitorar um gatilho de janela em cascata. Para obter informações gerais sobre gatilhos e os tipos com suporte, consulte Gatilhos e execução de pipeline.

Os gatilhos de janela em cascata são um tipo de gatilho acionado em um intervalo de tempo periódico a partir de uma hora de início especificada, enquanto mantém o estado. Os periódicos são uma série de intervalos de tempo de tamanho fixo, não sobrepostos e contíguos. Um gatilho de janela em cascata tem uma relação de um para um com um pipeline, e só pode fazer referência a um único pipeline.

Um gatilho periódico é uma alternativa mais pesada para um gatilho de agendamento. Ele oferece um conjunto de recursos para cenários complexos, como (dependência de outros gatilhos periódicos, nova execução de um trabalho com falha e configuração de repetição de usuário para pipelines). Para entender melhor a diferença entre um gatilho de agendamento e um gatilho periódico, confira Comparação de tipos de gatilhos.

Experiência do portal do Azure Data Factory e do Azure Synapse

  1. Para criar um gatilho periódico no portal do Azure, selecione a guia Gatilhos e selecione Novo.
  2. Depois que o painel de configuração do gatilho for aberto, selecione Periódico. Em seguida, defina as propriedades do gatilho periódico.
  3. Quando terminar, selecione Salvar.

Propriedades do tipo de gatilho da janela em cascata

Uma janela em cascata tem as seguintes propriedades de tipo de gatilho:

{
    "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"
            }
        }
    }
}

A seguinte tabela fornece uma visão geral de alto nível dos principais elementos JSON relacionados à recorrência e ao agendamento de um gatilho periódico.

Elemento JSON Descrição Type Valores permitidos Obrigatório
type O tipo do gatilho. O type é o valor fixo TumblingWindowTrigger. String TumblingWindowTrigger Sim
runtimeState O estado atual do tempo de execução do gatilho.
Esse elemento é <readOnly>.		 String Started, Stopped, Disabled Sim
frequency Uma cadeia de caracteres que representa a unidade de frequência (minutos, horas ou meses) na qual o acionador é recorrente. Se os valores de data startTime forem mais granulares do que o valor frequency, as datas startTime serão consideradas quando os limites da janela forem calculados. Por exemplo, se o valor frequency for hourly e o valor startTime for 2017-09-01T10:10:10Z, a primeira janela será (2017-09-01T10:10:10Z, 2017-09-01T11:10:10Z). String Minute, Hour, Month Sim
interval Um número inteiro positivo que denota o intervalo do valor frequency, que determina a frequência de execução do gatilho. Por exemplo, se o interval for 3 e o frequency for hour, o gatilho se repetirá a cada 3 horas.
O intervalo mínimo de janela é de 5 minutos.		 Integer Um número inteiro positivo. Sim
startTime A primeira ocorrência, que pode estar no passado. O primeiro intervalo de gatilho é (startTime, startTime + interval). DateTime Um valor DateTime. Sim
endTime A última ocorrência, que pode estar no passado. DateTime Um valor DateTime. Sim
delay A quantidade de tempo para atrasar o início do processamento de dados para a janela. A execução do pipeline é iniciada após o tempo de execução esperado mais a quantidade de atraso. O atraso define quanto tempo o gatilho espera antes de disparar uma nova execução. O atraso não altera a janela startTime. Por exemplo, um valor delay de 00:10:00 implica um atraso de 10 minutos. Timespan
(hh:mm:ss)		 Um valor timespan em que o padrão é 00:00:00. Não
maxConcurrency O número de execuções do gatilho simultâneas que são acionadas para janelas prontas. Por exemplo, para execuções de provisionamento por hora para ontem resultará em 24 janelas. Se maxConcurrency = 10, os eventos de gatilho serão disparados somente para as primeiras 10 janelas (00:00-01:00 - 09:00-10:00). Após a conclusão das primeiras 10 execuções de pipeline disparada, as execuções de gatilho serão disparadas para as próximas 10 janelas (10:00-11:00-19:00 às 20:00). Continuando com esse exemplo de maxConcurrency = 10, se houver 10 janelas prontas, haverá um total de 10 execuções do pipeline. Se apenas uma janela estiver pronta, apenas um pipeline será executado. Integer Um número inteiro entre 1 e 50. Sim
retryPolicy: Count O número de repetições antes da execução de pipeline ser marcada como Failed. Integer Um inteiro, em que o padrão é 0 (sem repetições). Não
retryPolicy: intervalInSeconds O intervalo entre tentativas de repetição especificado em segundos. Integer O número de segundos, em que o padrão é 30. O valor mínimo é 30. Não
dependsOn: type O tipo de TumblingWindowTriggerReference. Necessário se uma dependência for definida. String TumblingWindowTriggerDependencyReference, SelfDependencyTumblingWindowTriggerReference Não
dependsOn: size Tamanho da janela em cascata de dependência. Timespan
(hh:mm:ss)		 Um valor timespan positivo em que o padrão é o tamanho da janela do gatilho filho. Não
dependsOn: offset Deslocamento do gatilho de dependência. Timespan
(hh:mm:ss)		 Um valor timespan que deve ser negativo em uma autodependência. Se nenhum valor for especificado, a janela será igual ao próprio gatilho. Autodependência: Sim
Other: No

Observação

Depois que um gatilho periódico for publicado, os valores interval e frequency não poderão ser editados.

Variáveis do sistema WindowStart e WindowEnd

Você pode usar as variáveis de sistema WindowStart e WindowEnd do gatilho periódico na definição do pipeline (ou seja, como parte de uma consulta). Passar as variáveis de sistema como parâmetros para o pipeline na definição de gatilho. O exemplo a seguir mostra como passar essas variáveis como parâmetros.

{
    "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'))}"
                }
            }
        }
    }
}

Para usar os valores das variáveis do sistema WindowStart e WindowEnd na definição do pipeline, use seus parâmetros MyWindowStart e MyWindowEnd de acordo.

Ordem de execução de janelas em um cenário de compensação

Se o gatilho startTime estiver no passado, com base na fórmula M=(CurrentTime- TriggerStartTime)/TumblingWindowSize, o gatilho gerará {M} execuções de provisionamento (passado) em paralelo, respeitando a simultaneidade do gatilho, antes de executar as execuções futuras. A ordem de execução das janelas é determinística, dos intervalos mais antigo aos mais recentes. Atualmente, esse comportamento não pode ser modificado.

Observação

Nesse cenário, todas as execuções startTime selecionadas serão executadas antes da execução de execuções futuras. Se você precisar fazer o provisionamento por um longo período de tempo, recomendamos fazer uma carga histórica inicial.

Elementos TriggerResource existentes

Os pontos a seguir se aplicam à atualização de elementos TriggerResource existentes:

  • O valor do elemento frequency (ou tamanho da janela) do gatilho, juntamente com o elemento interval, não poderá ser alterado após a criação do gatilho. Essa restrição é necessária para o funcionamento adequado de novas execuções de triggerRun e avaliações de dependência.
  • Se o valor do elemento endTime do gatilho for alterado (por adição ou atualização), o estado das janelas que já estão sendo processadas não será redefinido. O gatilho respeitará o novo valor endTime. Se o novo valor endTime for anterior às janelas que já foram executadas, o gatilho será interrompido. Caso contrário, o gatilho será interrompido quando o novo valor endTime for encontrado.

Novas tentativas de pipelines atribuídas pelo usuário

No caso de falhas de pipeline, um gatilho periódico poderá tentar novamente a execução do pipeline referenciado automaticamente usando os mesmos parâmetros de entrada, sem intervenção do usuário. Use a propriedade retryPolicy na definição do gatilho para especificar essa ação.

Dependência de gatilho de janela em cascata

Se você quiser garantir que um gatilho de janela em cascata seja executado somente após a execução bem-sucedida de outro gatilho de janela em cascata na data factory, crie uma dependência de gatilho de janela em cascata.

Cancelar a execução do periódico

Você pode cancelar as execuções de um gatilho periódico se a janela específica estiver nos estados Aguardando, Aguardando dependência ou Executando:

  • Se a janela estiver em um estado Em execução, cancele a Execução de Pipeline associada e a execução do gatilho será marcada como Cancelada posteriormente.
  • Se a janela estiver em um estado Aguardando ou Aguardando dependência, você poderá cancelar a janela em Monitoramento.

Você também pode executar novamente uma janela cancelada. A nova execução usará as definições publicadas mais recentes do gatilho. As dependências da janela especificada serão reavaliadas após a nova execução.

Exemplo do Azure PowerShell e da CLI do Azure

Esta seção mostra como usar o Azure PowerShell para criar, iniciar e monitorar um gatilho.

Observação

Recomendamos que você use o módulo Az PowerShell do Azure para interagir com o Azure. Para começar, consulte Instalar o Azure PowerShell. Para saber como migrar para o módulo Az PowerShell, confira Migrar o Azure PowerShell do AzureRM para o Az.

Pré-requisitos

Código de exemplo

  1. Crie um arquivo JSON chamado MyTrigger.json na pasta C:\ADFv2QuickStartPSH\ com o seguinte conteúdo:

    Importante

    Antes de salvar o arquivo JSON, defina o valor do elemento startTime como a hora atual do Tempo Universal Coordenado (UTC). Defina o valor do elemento endTime para uma hora após a hora UTC atual.

    {
  "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. Crie um gatilho usando o cmdletSet-AzDataFactoryV2Trigger:

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

  3. Confirme se o status do gatilho estáParadousando o cmdletGet-AzDataFactoryV2Trigger:

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

  4. Inicie o gatilho usando o cmdletStart-AzDataFactoryV2Trigger:

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

  5. Confirme se o status do gatilho estáIniciadousando o cmdletGet-AzDataFactoryV2Trigger:

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

  6. Obtenha as execuções do gatilho no Azure PowerShell usando o cmdlet Get-AzDataFactoryV2TriggerRun. Para obter informações sobre as execuções do gatilho, execute o comando a seguir periodicamente. Atualize os valores TriggerRunStartedAfter e TriggerRunStartedBefore para que correspondam aos valores em sua definição de gatilho:

    Get-AzDataFactoryV2TriggerRun -ResourceGroupName $ResourceGroupName -DataFactoryName $DataFactoryName -TriggerName "MyTrigger" -TriggerRunStartedAfter "2017-12-08T00:00:00" -TriggerRunStartedBefore "2017-12-08T01:00:00"

Para monitorar execuções de gatilho e de pipeline no portal do Azure, consulte Monitorar execuções de pipeline.

Conteúdo relacionado