Criar um acionador que execute um pipeline com base num agendamento

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 e gatilhos de pipeline.

Ao criar um gatilho de agenda, você especifica um cronograma como uma data de início, recorrência ou data de término para o gatilho e o associa a um pipeline. Os pipelines e os acionadores têm uma relação muitos para muitos. Múltiplos acionadores podem arrancar um pipeline individual. Um acionador único pode arrancar 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
   • Azure Synapse

   

2. Selecione Acionador no menu e 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 se a opção Agenda está selecionada para Tipo.

   2. Especifique a data/hora de início do gatilho para Data de início. É definido como a datetime atual em Tempo Universal Coordenado (UTC) por padrão.

   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 é 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, o tempo de gatilho se ajusta automaticamente para a alteração duas vezes por ano, se a recorrência estiver definida como Dias ou acima. 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 gatilho. 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 hora de data de término, selecione Especificar uma data de término. Especifique as informações Ends On e selecione OK.

      Um custo está associado a cada execução de pipeline. Se você estiver testando, convém garantir que o pipeline seja acionado apenas algumas vezes. No entanto, certifique-se de que há tempo suficiente para que o pipeline seja executado entre a hora de publicação e a hora de término. 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 à esquerda e selecione Atualizar para atualizar a lista. Você vê que o pipeline é executado acionado pelo gatilho agendado. Repare nos valores na coluna Acionado Por. Se você usar a opção Trigger Now , verá a execução manual do gatilho na lista.

   • Fábrica de Dados do Azure
   • Azure Synapse

   

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

   • Fábrica de Dados do Azure
   • Azure Synapse

   

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 gatilho está associado a um pipeline chamado Adfv2QuickStartPipeline que você cria como parte do início rápido.

Pré-requisitos

• Subscrição do Azure. Se não tiver uma subscrição 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 endTime valor do elemento para uma hora após a 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 fim.

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

   • O endTime elemento é uma hora após o valor do startTime elemento. Como tal, o gatilho executa o pipeline 15 minutos, 30 minutos e 45 minutos após a hora 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 ao Adfv2QuickStartPipeline pipeline. Para associar vários pipelines a um gatilho, adicione mais pipelineReference seções.

   • O pipeline no início rápido usa dois parameters valores: inputPath e outputPath. Você passa valores para esses parâmetros 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 se o status do gatilho é Interrompido usando 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 o gatilho executado no Azure PowerShell usando o cmdlet Get-AzDataFactoryV2TriggerRun . Para obter as informações sobre as execuções do gatilho, execute o seguinte comando periodicamente. Atualize os TriggerRunStartedAfter valores e TriggerRunStartedBefore para corresponder aos valores na 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"
   

   Nota

   A hora do gatilho dos gatilhos de agendamento é especificada no carimbo de data/hora UTC. TriggerRunStartedAfter e também espere TriggerRunStartedBefore o carimbo de data/hora UTC.

   Para monitorar as execuções de gatilho e pipeline no portal do Azure, consulte Monitorar 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 gatilho está associado a um pipeline chamado Adfv2QuickStartPipeline que você cria como parte do início rápido.

Pré-requisitos

• Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, consulte Guia de início rápido para Bash no 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 estiver a utilizar uma instalação local, inicie sessão no CLI do Azure ao utilizar 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 Entrar com a CLI do Azure.

  • Quando solicitado, instale a extensão da CLI do Azure na primeira utilização. Para obter mais informações sobre as extensões, veja Utilizar extensões com o CLI do Azure.

  • Execute o comando az version para localizar a versão e as bibliotecas dependentes instaladas. Para atualizar para a versão mais recente, execute o comando 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 endTime valor do elemento para uma hora após a 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 fim.

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

   • O endTime elemento é uma hora após o valor do startTime elemento. Como tal, o gatilho executa o pipeline 15 minutos, 30 minutos e 45 minutos após a hora 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, o e endTime startTime precisam 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 estiver ausente para o fuso horário UTC, o resultado será um erro na ativação do gatilho.

   • O gatilho está associado ao Adfv2QuickStartPipeline pipeline. Para associar vários pipelines a um gatilho, adicione mais pipelineReference seções.

   • O pipeline no início rápido usa dois parameters valores: inputPath e outputPath. Você passa valores para esses parâmetros 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 se o status do gatilho é Interrompido 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 gatilho na CLI do Azure usando o comando az datafactory trigger-run query-by-factory . Para obter informações sobre as execuções do gatilho, execute o seguinte comando periodicamente. Atualize os last-updated-after valores e last-updated-before para corresponder aos valores na sua definição de 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 espera o carimbo de data/hora UTC.

   Para monitorar as execuções de gatilho e pipeline no portal do Azure, consulte Monitorar 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 gatilho está associado a um pipeline chamado Adfv2QuickStartPipeline que você cria como parte do início 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 monitorar uma execução de gatilho, 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 monitorar as execuções de gatilho e pipeline no portal do Azure, consulte Monitorar 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 monitorar as execuções de gatilho e pipeline no portal do Azure, consulte Monitorar 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.

Passar 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 agendamento 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 de opções de fuso horário, consulte a página Criação de gatilho no portal.

Propriedade startTime

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

Vejamos um exemplo do que acontece quando a hora de início (startTime) se situa no passado, com periodicidade, mas sem agenda. 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-09 14:00. O motor do Scheduler calcula as ocorrências de execução a partir da hora de início. Quaisquer instâ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 é de dois dias a partir dessa 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 schedule

O uso de um cronograma pode limitar o número de execuções de gatilho. 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 agenda também pode expandir o número de execuções de 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 schedule elementos forem especificados, a ordem de avaliação será do maior para o menor cronograma. 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 periodicidade do acionador

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 Execução e gatilhos de pipeline.
• Para saber como fazer referência a metadados de gatilho em pipeline, consulte Metadados de gatilho de referência em execuções de pipeline.