Criar um gatilho que execute um pipeline num horário programado

APLICA-SE A: Azure Data Factory Azure Synapse Analytics

Este artigo fornece informações sobre o gatilho de agendamento e as etapas para criar, iniciar e monitorar um gatilho de agendamento. Para outros tipos de gatilhos, consulte Execução de pipeline e gatilhos.

Ao criar um gatilho de agenda, especifica uma programação, como uma data de início, recorrência ou data de término para o gatilho, e associa-o a um pipeline. Os pipelines e os acionadores têm uma relação muitos para muitos. Múltiplos acionadores podem iniciar um único pipeline. Um único gatilho pode iniciar vários pipelines.

As seções a seguir fornecem etapas para criar um gatilho de agenda de maneiras diferentes.

Experiência do portal Azure Data Factory e Azure Synapse

Você pode criar um gatilho de agendamento para agendar um pipeline para ser executado periodicamente, como por hora ou diariamente.

1. Mude para o separador Editar no Data Factory ou para o separador Integrar no Azure Synapse.

   • Fábrica de Dados do Azure
   • Sinapse do Azure

   

2. Selecione Gatilho no menu e, em seguida, selecione Novo/Editar.

   

3. Na página Adicionar gatilhos , selecione Escolher gatilho e, em seguida, selecione Novo.

   

4. Na página Novo gatilho:

   1. Confirme que Agenda está selecionada para Tipo.

   2. Especifique a data/hora de início do gatilho para Data de início. Por defeito, é definida para a data e hora atuais no Tempo Universal Coordenado (UTC).

   3. Especifique o fuso horário no qual o gatilho é criado. A configuração de fuso horário se aplica a Data de Início, Data de Término e Horários de Execução de Agendamento nas opções de recorrência Avançadas. Alterar a configuração de Fuso horário não altera automaticamente sua data de início. Verifique se a data de início está correta no fuso horário especificado. O tempo de execução agendada do gatilho será considerado após a data de início. (Certifique-se de que a data de início seja pelo menos 1 minuto menor do que o tempo de execução ou então aciona o pipeline na próxima recorrência.)

      Nota

      Para fusos horários que observam o horário de verão, a hora de ativação ajusta-se automaticamente durante a mudança que ocorre duas vezes por ano, se a recorrência estiver definida como Dias ou superior. Para desativar a alteração do horário de verão, selecione um fuso horário que não observe o horário de verão, por exemplo, UTC.

      O ajuste do horário de verão só acontece para um gatilho com a recorrência definida como Dias ou acima. Se o gatilho estiver definido como frequência de Horas ou Minutos , ele continuará a disparar em intervalos regulares.

   4. Especifique Recorrência para o disparador. Selecione um dos valores na lista suspensa (Cada minuto, Horária, Diária, Semanal ou Mensal). Insira o multiplicador na caixa de texto. Por exemplo, se quiser que o gatilho seja executado uma vez a cada 15 minutos, selecione Cada minuto e digite 15 na caixa de texto.

   5. Em Recorrência, se escolher Dia(s),Semana(s) ou Mês(es) na lista pendente, pode ver Opções avançadas de recorrência.

      

   6. Para especificar uma data de fim, selecione Especificar uma data de término. Especifique a informação de Termina em e, em seguida, selecione OK.

      Há um custo associado a cada execução de pipeline. Se estiver a testar, convém garantir que o pipeline seja acionado apenas algumas vezes. No entanto, certifique-se de que há tempo suficiente para que o pipeline funcione entre o momento de publicação e o momento de conclusão. O gatilho entra em vigor somente depois que você publica a solução, não quando você salva o gatilho na interface do usuário.

      

      

5. Na janela Novo gatilho, selecione Sim na opção Ativado e, em seguida, selecione OK. Você pode usar essa caixa de seleção para desativar o gatilho mais tarde.

   

6. Na janela Novo gatilho, reveja a mensagem de aviso e, em seguida, selecione OK.

   

7. Selecione Publicar tudo para publicar as alterações. Até que você publique as alterações, o gatilho não começa a acionar as execuções do pipeline.

   

8. Alterne para a guia Pipeline runs na esquerda e selecione Atualizar para atualizar a lista. Você vê que o pipeline se executa através do gatilho agendado. Observe os valores na coluna Acionado por . Se utilizar a opção Trigger Now, verá a execução manual do gatilho na lista.

   • Fábrica de Dados do Azure
   • Sinapse do Azure

   

9. Alterne para o modo de exibição Trigger runs>Schedule.

   • Fábrica de Dados do Azure
   • Sinapse do Azure

   

Azure PowerShell

Esta seção mostra como usar o Azure PowerShell para criar, iniciar e monitorar um gatilho de agendamento. Para ver este exemplo funcionando, primeiro passe por Guia de início rápido: criar uma fábrica de dados usando o Azure PowerShell. Em seguida, adicione o seguinte código ao método principal, que cria e inicia um gatilho de agendamento que é executado a cada 15 minutos. O disparador está associado a um pipeline chamado Adfv2QuickStartPipeline que se cria como parte do arranque rápido.

Pré-requisitos

• Subscrição do Azure. Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.
• Azure PowerShell. Siga as instruções em Instalar o Azure PowerShell no Windows com PowerShellGet.

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 startTime valor do elemento para a hora UTC atual. Defina o valor do elemento endTime para uma hora depois da hora UTC atual.

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

   No trecho JSON:

   • O type elemento do gatilho é definido como ScheduleTrigger.

   • O frequency elemento é definido como Minute e o interval elemento é definido como 15. Como tal, o gatilho executa o pipeline a cada 15 minutos entre os horários de início e de término.

   • O timeZone elemento especifica o fuso horário no qual o gatilho é criado. Esta configuração afeta ambos startTime e endTime.

   • O endTime elemento é uma hora após o valor do startTime elemento. Como tal, o gatilho executa o pipeline aos 15 minutos, 30 minutos e 45 minutos após o tempo de início. Não se esqueça de atualizar a hora de início para a hora UTC atual e a hora de término para uma hora após a hora de início.

     Importante

     Para o fuso horário UTC, startTime e endTime precisa seguir o formato yyyy-MM-ddTHH:mm:ssZ. Para outros fusos horários, startTime e endTime siga o yyyy-MM-ddTHH:mm:ss formato.

     De acordo com a norma ISO 8601, o sufixo Z é usado para marcar a data/hora no fuso horário UTC e tornar o timeZone campo inútil. Se o sufixo Z para o fuso horário UTC estiver faltando, o resultado será um erro na ativação do gatilho.

   • O gatilho está associado à canalização Adfv2QuickStartPipeline. Para associar vários pipelines a um gatilho, adicione mais seções pipelineReference.

   • O pipeline no quickstart assume dois parameters valores: inputPath e outputPath. Você passa valores para esses parâmetros a partir do gatilho.

2. Crie um gatilho usando o cmdlet Set-AzDataFactoryV2Trigger :

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

3. Confirme que o estado do gatilho é Interrompido utilizando o cmdlet Get-AzDataFactoryV2Trigger:

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

4. Inicie o gatilho usando o cmdlet Start-AzDataFactoryV2Trigger :

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

5. Confirme se o status do gatilho é Iniciado usando o cmdlet Get-AzDataFactoryV2Trigger :

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

6. Obtenha as execuções do gatilho no PowerShell do Azure usando o cmdlet Get-AzDataFactoryV2TriggerRun. Para obter as informações sobre as execuções do gatilho, execute o seguinte comando periodicamente. Atualize os valores TriggerRunStartedAfter e TriggerRunStartedBefore de modo a corresponder aos valores na definição do seu gatilho.

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

   Nota

   O horário dos gatilhos de agendamento é especificado no carimbo de data/hora UTC. TriggerRunStartedAfter e TriggerRunStartedBefore também esperam o carimbo de data/hora UTC.

   Para monitorizar as execuções de gatilhos e de pipelines no portal do Azure, consulte Monitorizar execuções de pipeline.

CLI do Azure

Esta seção mostra como usar a CLI do Azure para criar, iniciar e monitorar um gatilho de agendamento. Para ver este exemplo funcionando, primeiro passe por Guia de início rápido: criar um Azure Data Factory usando a CLI do Azure. Em seguida, siga as etapas para criar e iniciar um gatilho de agendamento que é executado a cada 15 minutos. O disparador está associado a um pipeline chamado Adfv2QuickStartPipeline que se cria como parte do arranque rápido.

Pré-requisitos

• Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, consulte Introdução ao Azure Cloud Shell.

  

• Se preferir executar comandos de referência da CLI localmente, instale a CLI do Azure. Se estiver a utilizar o Windows ou macOS, considere executar a CLI do Azure num contentor Docker. Para obter mais informações, consulte Como executar a CLI do Azure em um contêiner do Docker.

  • Se você estiver usando uma instalação local, entre na CLI do Azure usando o comando az login . Para concluir o processo de autenticação, siga os passos apresentados no seu terminal. Para outras opções de entrada, consulte Autenticar no Azure usando a CLI do Azure.

  • Quando solicitado, instale a extensão da CLI do Azure na primeira utilização. Para obter mais informações sobre extensões, consulte Usar e gerenciar extensões com a CLI do Azure.

  • Execute az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.

Código de exemplo

1. No diretório de trabalho, crie um arquivo JSON chamado MyTrigger.json com as propriedades do gatilho. Para este exemplo, use o seguinte conteúdo:

   Importante

   Antes de salvar o arquivo JSON, defina o startTime valor do elemento para a hora UTC atual. Defina o valor do elemento endTime para uma hora depois da hora UTC atual.

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

   No trecho JSON:

   • O type elemento do gatilho é definido como ScheduleTrigger.

   • O frequency elemento é definido como Minute e o interval elemento é definido como 15. Como tal, o gatilho executa o pipeline a cada 15 minutos entre os horários de início e de término.

   • O timeZone elemento especifica o fuso horário no qual o gatilho é criado. Esta configuração afeta ambos startTime e endTime.

   • O endTime elemento é uma hora após o valor do startTime elemento. Como tal, o gatilho executa o pipeline aos 15 minutos, 30 minutos e 45 minutos após o tempo de início. Não se esqueça de atualizar a hora de início para a hora UTC atual e a hora de término para uma hora após a hora de início.

     Importante

     Para o fuso horário UTC, startTime e endTime precisam seguir o formato yyyy-MM-ddTHH:mm:ssZ. Para outros fusos horários, startTime e endTime sigam o formato yyyy-MM-ddTHH:mm:ss.

     De acordo com a norma ISO 8601, o sufixo Z é usado para marcar a data/hora no fuso horário UTC e tornar o timeZone campo inútil. Se o sufixo Z estiver ausente para o fuso horário UTC, o resultado será um erro na ativação do gatilho.

   • O gatilho está associado à canalização Adfv2QuickStartPipeline. Para associar vários pipelines a um gatilho, adicione mais seções pipelineReference.

   • O pipeline no quickstart assume dois parameters valores: inputPath e outputPath. Você passa valores para esses parâmetros a partir do gatilho.

2. Crie um gatilho usando o comando az datafactory trigger create :

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

3. Confirme que o estado do gatilho é Parado usando o comando az datafactory trigger show:

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

4. Inicie o gatilho usando o comando az datafactory trigger start :

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

5. Confirme se o status do gatilho é Iniciado usando o comando az datafactory trigger show :

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

6. Obtenha as execuções de desencadeamento na CLI do Azure com o comando az datafactory trigger-run query-by-factory. Para obter informações sobre as execuções dos triggers, execute o seguinte comando de forma periódica. Atualize os valores last-updated-after e last-updated-before de modo a corresponder aos valores na definição do seu gatilho.

   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"
   

   Nota

   Os tempos de gatilho dos gatilhos de agendamento são especificados no carimbo de data/hora UTC. last-updated-after e last-updated-before também esperam o timestamp UTC.

   Para monitorizar as execuções de gatilhos e de pipelines no portal do Azure, consulte Monitorizar execuções de pipeline.

SDK do .NET

Esta seção mostra como usar o SDK do .NET para criar, iniciar e monitorar um gatilho. Para ver este exemplo funcionando, primeiro passe por Guia de início rápido: criar uma fábrica de dados usando o SDK do .NET. Em seguida, adicione o seguinte código ao método principal, que cria e inicia um gatilho de agendamento que é executado a cada 15 minutos. O disparador está associado a um pipeline chamado Adfv2QuickStartPipeline que se cria como parte do arranque rápido.

Para criar e iniciar um gatilho de agendamento que é executado a cada 15 minutos, adicione o seguinte código ao método principal:

            // 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);

Para criar gatilhos em um fuso horário diferente, diferente do UTC, as seguintes configurações são necessárias:

<<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;

Para monitorizar uma execução de disparador, adicione o seguinte código antes da última Console.WriteLine instrução no exemplo:

            // 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();
                    }
                }
            }

Para monitorizar as execuções de gatilhos e de pipelines no portal do Azure, consulte Monitorizar execuções de pipeline.

Python SDK

Esta seção mostra como usar o SDK do Python para criar, iniciar e monitorar um gatilho. Para ver este exemplo funcionando, primeiro passe por Guia de início rápido: criar uma fábrica de dados usando o Python SDK. Em seguida, adicione o seguinte bloco de código após o monitor the pipeline run bloco de código no script Python. Esse código cria um gatilho de agendamento que é executado a cada 15 minutos entre as horas de início e término especificadas. Atualize a start_time variável para a hora UTC atual e a end_time variável para uma hora após a hora UTC atual.

    # 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)

Para monitorizar as execuções de gatilhos e de pipelines no portal do Azure, consulte Monitorizar execuções de pipeline.

Modelo Azure Resource Manager

Você pode usar um modelo do Azure Resource Manager para criar um gatilho. Para obter instruções passo a passo, consulte Criar uma fábrica de dados do Azure usando um modelo do Azure Resource Manager.

Transmitir a hora de início do gatilho para um pipeline

O Azure Data Factory versão 1 dá suporte à leitura ou gravação de dados particionados usando as variáveis SliceStartde sistema , , SliceEndWindowStarte WindowEnd. Na versão atual dos pipelines do Data Factory e do Azure Synapse, você pode obter esse comportamento usando um parâmetro de pipeline. A hora de início e a hora agendada para o gatilho são definidas como o valor para o parâmetro pipeline. No exemplo a seguir, a hora agendada para o gatilho é passada como um valor para o parâmetro pipeline scheduledRunTime :

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

Esquema do JSON

A definição JSON a seguir mostra como criar um gatilho de agendamento com programação e recorrência:

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

Descrição geral do esquema

A tabela a seguir fornece uma visão geral de alto nível dos principais elementos do esquema relacionados à recorrência e ao agendamento de um gatilho.

Predefinições, limites e exemplos do esquema

Opção de fuso horário

Aqui estão alguns dos fusos horários suportados para gatilhos de agenda.

Esta lista está incompleta. Para obter uma lista completa das opções de fusos horários, consulte a página de criação de gatilhos no portal.

Propriedade startTime

A tabela a seguir mostra como a propriedade startTime controla uma execução do gatilho.

Vejamos um exemplo do que acontece quando a hora de início se situa no passado, com uma recorrência, mas sem programação. Parta do princípio de que a hora atual é 2017-04-08 13:00, a hora de início é 2017-04-07 14:00 e a periodicidade é de dois em dois dias. (O recurrence valor é definido definindo a frequency propriedade como day e a interval propriedade como 2.) Observe que o startTime valor está no passado e ocorre antes da hora atual.

Nestas condições, a primeira execução é em 2017-04-0914:00. O motor de agendamento calcula as ocorrências de execução a partir da hora de início. Quaisquer ocorrências no passado são eliminadas. O motor utiliza a instância seguinte que ocorre no futuro. Nesse cenário, a hora de início está 2017-04-07 em 2:00pm, portanto, a próxima instância ocorre dois dias após essa hora, que está 2017-04-09 em 2:00pm.

O primeiro tempo de execução é o mesmo, mesmo que o startTime valor seja 2017-04-05 14:00 ou 2017-04-01 14:00. Após a primeira execução, as execuções subsequentes são calculadas com base na agenda. Portanto, as execuções subsequentes estão em 2017-04-11 , 2:00pmdepois 2017-04-13 em 2:00pm, depois 2017-04-15 em 2:00pm, e assim por diante.

Finalmente, quando as horas ou minutos não são definidos na programação de um gatilho, as horas ou minutos da primeira execução são usados como padrão.

Propriedade de programação

O uso de uma agenda pode limitar o número de ativações de gatilhos. Por exemplo, se um acionador com uma frequência mensal estiver agendado de modo a ser executado apenas no dia 31, o acionador só é executado nos meses que têm 31 dias.

Uma programação também pode expandir o número de execuções do gatilho. Por exemplo, um acionador com uma frequência mensal que esteja agendado de maneira a ser executado nos dias 1 e 2 do mês é executado no primeiro e segundo dias do mês, em vez de uma vez por mês.

Se vários elementos schedule forem especificados, a ordem de avaliação será da maior para a menor configuração de calendário. A avaliação começa com o número da semana e, em seguida, o dia do mês, dia da semana, hora e, finalmente, minuto.

A tabela a seguir descreve os schedule elementos em detalhes.

Exemplos de agendas de recorrência do gatilho

Esta seção fornece exemplos de agendas de recorrência e se concentra no schedule objeto e em seus elementos.

Os exemplos assumem que o interval valor é 1 e que o frequency valor está correto de acordo com a definição de agenda. Por exemplo, você não pode ter um frequency valor de day e também ter uma monthDays modificação no schedule objeto. Este género de restrições é mencionado na tabela da secção anterior.

Conteúdos relacionados

• Para obter mais informações sobre gatilhos, consulte Pipeline: Execução e gatilhos.
• Para saber como fazer referência a metadados de gatilho em um pipeline, consulte Referenciar metadados de gatilho em execuções de pipeline.