Gatilhos de fila

Importante:

• Você pode criar um único acionador de fila para uma fila. Isso também se aplica a filas que são compartilhadas entre várias pastas.
• Fusos horários do gatilho: o fuso horário definido em um gatilho não é restrito pelo fuso horário do tenant. No entanto, se você usar calendários de dias não úteis, não poderá definir fusos horários diferentes. Os gatilhos da fila são inicializados de acordo com o fuso horário definido no nível do gatilho. Os gatilhos de fila são iniciados com base no processamento de itens da fila. Os gatilhos da fila são desabilitados com base no fuso horário dos gatilhos.

Os gatilhos da fila iniciam instantaneamente um processo ao ser criado um disparo ou sempre que você adicionar um novo item a uma fila. O disparador é executado no ambiente associado ao processo selecionado.

Quando um grande número de itens de fila é adicionado em um curto espaço de tempo (por exemplo, usando AddQueueItem ou BulkAddQueueItems), o processo pode não iniciar imediatamente.Para lidar com essas situações, há um mecanismo de nova verificação implementado para garantir que o processo seja acionado quando os recursos estiverem disponíveis.

Importante:

A implementação de gatilhos de fila é otimizada para consumir processos que possuem um loop interno para processar todos os itens de fila disponíveis antes do término. Se um processo não implementar essa estratégia, a experiência resultante será abaixo do ideal e pode não atender aos requisitos de negócios desejados.

Essas opções ajudam você a parametrizar as regras para o disparo de processo:

	Description
Número mínimo de itens para disparar o primeiro trabalho	O trabalho de processamento de itens é iniciado apenas após a fila de destino ter pelo menos esse número de novos itens. Os itens da fila adiados não são contados.
Número máximo de trabalhos pendentes e em execução permitidos ao mesmo tempo	O número máximo permitido de trabalhos pendentes e em execução, contados juntos. Para dois ou mais trabalhos permitidos simultaneamente, a terceira opção precisa ser definida conforme descrito abaixo.
Outro trabalho é disparado para cada - novo item.	Um novo trabalho é disparado para cada número de novos itens adicionados além do número de itens definidos para a primeira opção. Habilitado apenas se houver 2 ou mais trabalhos permitidos ao mesmo tempo (definidos usando a opção descrita acima).
Após concluir os trabalhos, reavalie as condições e inicie novos trabalhos se possível	Se selecionado, o gatilho de fila é avaliado após a conclusão de cada trabalho e novos trabalhos são iniciados se houver robôs disponíveis. Isso complementa a verificação automática que ocorre a cada 30 minutos e ajuda a garantir que os itens da fila restantes sejam processados sem atrasos, quando possível.

Para lidar com itens em fila que não sejam processados no momento que são enfileirados, incluindo itens recriados, uma vez a cada 30 minutos, uma verificação para itens não processados é executada por padrão e se a condição de acionamento for atendida, o gatilho é iniciado mais uma vez.

Você pode usar o parâmetro Filas - Frequência de verificação de itens de fila não processados (minutos) para ajustar o intervalo de verificação padrão de 30 minutos.

Essa verificação garante que todos os itens na fila sejam processados nas seguintes situações:

• Os itens da fila são adicionados à fila muito mais rápido do que podem ser processados com os recursos disponíveis.
• Os itens da fila são adicionados a uma fila em dias não úteis, mas só podem ser processados durante o horário comercial.
• O processamento de itens da fila é adiado para mais tarde. Após esse tempo passar, eles estão prontos para serem processados assim que forem identificados pela verificação de 30 minutos.
  Observação:

  Devido à verificação padrão de 30 minutos, há um risco de obstrução dos recursos durante o horário não comercial. Para evitar isso, certifique-se de que não haja itens não processados no fim do dia útil. Se isso não for uma possibilidade, certifique-se de que o processo disparado não exija intervenção humana.

Algoritmo de processamento de gatilho de fila

Variáveis

Variável	Description
newItems	Número de novos itens de fila disponíveis na fila.
minItemsToTrigger	Número mínimo de itens necessários para disparar o primeiro trabalho. O primeiro trabalho só é iniciado quando há pelo menos esta quantidade de itens novos.
maxConcurrentJobs	Número máximo de trabalhos pendentes e em execução permitidos ao mesmo tempo. Esse é o limite para trabalhos paralelos.
itemsPerJob	Número de itens adicionais necessários para disparar cada trabalho subsequente. Quando minItemsToTrigger é atingido, um trabalho é iniciado. Para cada itemsPerJob itens adicionais além de minItemsToTrigger, mais um trabalho é iniciado — até maxConcurrentJobs.
pendingJobs	Número de trabalhos atualmente em estado Pendente.
runningJobs	Número de trabalhos nos estados Retomado, Em Execução, Parando ou Encerrando.
enablePendingJobsStrategy	Configuração booleana que determina se os trabalhos em execução são contados em relação à capacidade restante.

A configuração Gatilhos - Gatilhos de fila - habilitar estratégia de tarefas pendentes determina como o Orchestrator calcula a capacidade restante — o número de trabalhos adicionais que é permitido agendar:

• True – Capacidade restante = maxConcurrentJobs menos pendingJobs. Use esta configuração quando se espera que os trabalhos em execução já tenham reivindicado seus itens de fila do status Novo .
• Falso - Capacidade restante = maxConcurrentJobs menos pendingJobs menos runningJobs. Use esta configuração quando se espera que os trabalhos em execução ainda não tenham reivindicado seus itens de fila do status Novo .

O Orchestrator agenda o menor entre dois valores: a capacidade restante e o número de trabalhos desejados com base nas contagens de itens da fila. Portanto, a configuração controla o modo como os novos trabalhos são agendados de forma conservadora ou robusta.

Fórmulas

1. Capacidade restante

if enablePendingJobsStrategy = true:
    remainingCapacity = maxConcurrentJobs - pendingJobs

if enablePendingJobsStrategy = false:
    remainingCapacity = maxConcurrentJobs - pendingJobs - runningJobs

2. Trabalhos desejados (antes do limite de capacidade)

if newItems < minItemsToTrigger:
    desiredJobs = 0
else:
    desiredJobs = 1 + (newItems - minItemsToTrigger) / itemsPerJob   [integer division]

3. Trabalhos a serem agendados

jobsToSchedule = min(desiredJobs, remainingCapacity)

Observações importantes

• Essa avaliação ocorre sempre que um único item de fila é adicionado, inclusive por meio de adição em massa.
• Para garantir que os itens de fila postergados (adiados) sejam levados em conta, cada gatilho de fila tem um agendamento associado que verifica novamente todo o algoritmo acima. Isso acontece por padrão a cada 30 minutos, mas pode ser reduzido para um mínimo de 10 minutos por meio da configuração do tenant Filas - Frequência de verificação de itens de fila não processados (minutos).
  Observação:

  Os itens adiados são processados apenas após o tempo de adiamento ter passado. O trabalho integrado que verifica itens adiados é executado a cada 30 minutos. No entanto, se um novo item for adicionado à mesma fila depois que um item adiado já tiver sido disponibilizado, o gatilho da fila será acionado novamente imediatamente, e o item adiado poderá ser coletado sem esperar pela próxima verificação agendada.

• O algoritmo é projetado para garantir que um trabalho seja iniciado assim que um limite for atingido e que, quando o limite for ultrapassado, trabalhos adicionais comecem a ajudar a processar o aumento acumulado. Ele não foi projetado para distribuir a carga de trabalho uniformemente entre as máquinas, mas para garantir a presença suficiente de trabalhos.
• Não há vínculo físico entre os trabalhos iniciados e os itens de fila que eles processam. O trabalho J não está necessariamente atribuído aos itens de fila a, b ou c.
• Os resultados do algoritmo diferem dependendo se os itens de fila foram adicionados em massa ou individualmente, pois isso influencia o número de avaliações realizadas.
• Ao usar gatilhos de fila, você pode encontrar o seguinte alerta: The trigger could not create a job as the maximum number of jobs has been reached. Este alertar é informativo e geralmente significa que um trabalho já estava em execução quando o Orchestrator tentou iniciar outro. Se você estiver confortável com sua capacidade de trabalho atual, pode ignorá-lo com segurança.

Exemplo

Cenário 1 - itens de fila adicionados individualmente

Para esse cenário, o parâmetro Habilitar estratégia de tarefas pendentes é definido como False. Para obter mais informações sobre como atualizar o valor, consulte Configurações de tenant.

Dois trabalhos são usados neste cenário:

• Um adiciona 3 itens por segundo por 20 segundos à fila de destino (60 itens no total).
• Um processa 1 item por segundo da fila de destino.

O gatilho é configurado da seguinte forma:

• Número mínimo de itens para disparar o primeiro trabalho: 31
• Número máximo de trabalhos pendentes e em execução permitidos ao mesmo tempo: 3
• Outro trabalho é disparado para cada: 10 novo(s) item

Após o trabalho que adiciona itens à fila ser iniciado:

1. Após 11 segundos (33 itens), o primeiro trabalho de processamento de itens é disparado.
2. Após mais 4 segundos (12 itens), o segundo trabalho de processamento de itens é disparado.
3. Após mais 4 segundos (12 itens), o terceiro trabalho de processamento de itens é disparado.

Quando a adição de itens na fila terminar, o primeiro trabalho já terá processado 9 itens, o segundo 5 itens e o terceiro 1 item — 15 itens em 20 segundos processados por três trabalhos.

Os 45 itens restantes (60 - 15) são processados por 3 trabalhos em 1 item por segundo cada, sendo concluído em mais 15 segundos. Tempo total de processamento: 35 segundos.

Cenário 2 - itens de fila adicionados em massa

Para esse cenário, o parâmetro Habilitar estratégia de tarefas pendentes é definido como False. Para obter mais informações sobre como atualizar o valor, consulte Configurações de tenant.

Se os 60 itens de fila do Cenário 1 forem adicionados com uma operação em massa (quando nenhum trabalho estiver em execução ou pendente), 3 trabalhos serão criados.

Se pelo menos um trabalho for concluído antes do cronograma de reavaliação, outros trabalhos serão criados.

Habilitar exemplos de estratégia de trabalhos pendentes

Esses exemplos mostram como a configuração Habilitar estratégia de tarefas pendentes pode causar um excesso de agendamento quando habilitada e subprogramação quando desabilitada.

Configuração do gatilho

Configuração	Valor
Itens mínimos de fila a serem disparados	1
Número máximo de trabalhos pendentes e em execução	1.000
Outro trabalho disparado a cada	1 novo item
Após concluir o trabalho, reavaliar	True
Habilitar estratégia de trabalhos pendentes	Verdadeiro (Parte 1)

Suposição: leva 30 segundos para que um trabalho mova um item de fila para fora do status Novo .

Parte 1: agendamento em excesso com a estratégia Habilitar trabalhos pendentes habilitada

Etapa 1: 1.100 itens são adicionados à fila em massa, disparando 1.000 trabalhos.

Etapa 2: apenas 200 robôs estão disponíveis. 200 trabalhos são executados e 800 permanecem pendentes.

Trabalhos	Contagem
Em execução	200
Pendente	800

Itens de Fila	Status
200	Em Processo
900	Novo

Etapa 3: os 200 trabalhos em execução foram concluídos, disparando mais 200 trabalhos a serem executados.

Trabalhos	Contagem
Em execução	200
Pendente	600

Itens de Fila	Status
200	Bem-sucedido
200	Em Processo
700	Novo

Etapa 4: como a reavaliação está habilitada, o gatilho é executado novamente em segundos. Com a estratégia Habilitar tarefas pendentes habilitada, o Orchestrator supõe que todos os 200 trabalhos em execução já moveram seus itens de fila para fora do status Novo — embora isso realmente leve 30 segundos.

Etapa 5: o cálculo do gatilho neste momento:

remainingCapacity = maxConcurrentJobs - pendingJobs = 1000 - 600 = 400
desiredJobs       = newItems - pendingJobs          = 700 - 600  = 100
jobsToSchedule    = min(100, 400)                               = 100

Mais 100 trabalhos estão agendados. No entanto, como os 200 trabalhos em execução ainda não retiraram seus itens do status Novo (leva 30 segundos), o Orchestrator está tratando 700 novos itens como descobertos quando apenas ~500 precisam realmente de novos trabalhos. O resultado é aproximadamente 100 trabalhos agendados em excesso.

Observação:

O Orchestrator não rastreia a relação entre trabalhos individuais e itens de fila individuais, portanto, não pode detectar o excesso de agendamento por conta própria. A identificação de agendamento excessivo requer rastreamento de estado externo.

Etapa 6: com a estratégia Habilitar tarefas pendentes desabilitada, a mesma situação produz:

remainingCapacity = maxConcurrentJobs - pendingJobs - runningJobs = 1000 - 600 - 200 = 200
desiredJobs       = newItems - pendingJobs - runningJobs           = 700 - 600 - 200 = -100 → 0
jobsToSchedule    = min(0, 200)                                                      = 0

Nenhum trabalho adicional está agendado, o que está mais próximo da correção neste cenário.

Parte 2: subagendamento com a estratégia Habilitar trabalhos pendentes desabilitada

Etapa 1: nesse cenário, os trabalhos não são concluídos simultaneamente. Dos 200 trabalhos iniciais, 100 são concluídos após 60 segundos e os outros 100 são concluídos após 90 segundos.

Etapa 2: os primeiros 100 trabalhos são concluídos, disparando mais 100 trabalhos.

Trabalhos	Contagem
Em execução	200
Pendente	700

Itens de Fila	Status
100	Bem-sucedido
200	Em Processo
700	Novo

Etapa 3: como a reavaliação está habilitada, o gatilho é executado novamente em segundos.

Etapa 4: com a estratégia Habilitar tarefas pendentes habilitada:

remainingCapacity = maxConcurrentJobs - pendingJobs          = 1000 - 700 = 300
desiredJobs       = newItems - pendingJobs                   = 700 - 700  = 0
jobsToSchedule    = min(0, 300)                                           = 0

Nenhum trabalho adicional está agendado. Correto — há 700 trabalhos pendentes para 700 Novos itens.

Etapa 5: com a estratégia Habilitar tarefas pendentes desabilitada:

remainingCapacity = maxConcurrentJobs - pendingJobs - runningJobs = 1000 - 700 - 200 = 100
desiredJobs       = newItems - pendingJobs - runningJobs           = 700 - 700 - 200 = -200 → 0
jobsToSchedule    = min(0, 100)                                                       = 0

Também não há trabalhos adicionais agendados aqui. No entanto, se houvesse menos trabalhos pendentes, a fórmula seria subagendada: ela pressupõe que os 200 trabalhos em execução ainda não reivindicaram seus itens do status Novo , mesmo que 100 deles já o tenham feito.

Etapa 6: os trabalhos não agendados devido ao subagendamento são eventualmente selecionados quando a verificação de Itens da fila não processados for executada em seu agendamento periódico. Esse é o propósito dessa verificação.

Summary

Configuração	Suposição sobre a execução de trabalhos	Consequência
Habilitado (true)	Já reivindicaram seus itens de fila	Pode agendar em excesso
Desabilitado (false)	Ainda não reivindicaram os itens da fila	Pode estar abaixo do prazo (mitigado por novas verificações periódicas)

Destino de Execução

Você pode configurar várias regras, dependendo de quais processos associados são executados.

Description
Conta	O processo é executado sob uma conta específica. Especificar apenas a conta resulta na alocação dinâmica da máquina pelo Orchestrator. Especificar a conta e o modelo de máquina significa que os trabalhos serão iniciados nesse par de conta-máquina.
Máquina	O processo será executado em uma das máquinas do host conectadas ao modelo de máquina selecionado. Especificar apenas o modelo de máquina resulta no Orchestrator alocando a conta dinamicamente. Especificar a conta e o modelo de máquina significa que os trabalhos serão iniciados nesse par de conta-máquina. Observação: certifique-se de que as licenças de runtime necessárias para executar o trabalho estejam alocadas para o modelo de máquina associado.
Hostname	Hostname Após selecionar um modelo de máquina, a opção Nome do host é exibida, permitindo selecionar a sessão de estação de trabalho/robô desejada para executar o processo. Todas as sessões disponíveis na pasta ativa são exibidas: não conectadas, desconectadas ou conectadas. Observação: certifique-se de que as licenças de runtime necessárias para executar o trabalho estejam alocadas para o modelo de máquina associado.

Gatilho de fila criados usando UiPath Activities

Gatilhos de fila também podem ser criados por desenvolvedores de RPA no momento do design no Studio usando a atividade When New Item Added to Queue do pacote UiPath.Core.Activities .

O Orchestrator identifica esses tipos de gatilho como requisitos de pacote, e a única maneira de adicioná-los no Orchestrator é pela página Requisitos do pacote.

Qualquer configuração definida em tempo de design é refletida no Orchestrator e não pode ser modificada.

Por exemplo: quando um item de fila é adicionado à minha fila, desejo receber seus metadados como uma mensagem de registro. A diferença aqui é que o gatilho de fila instrui a automação a iniciar de dentro do fluxo de trabalho, em oposição aos gatilhos de fila do Orchestrator, que instruem a automação a iniciar de fora do fluxo de trabalho.