Orchestrator
2023.10
False
Managing Jobs - Automation Suite 2023.10
Imagen de fondo del banner
Logotipo
Guía del usuario de Orchestrator
Última actualización 19 de dic. de 2023

Gestionar trabajos

Iniciar un trabajo

Antes de seguir los pasos a continuación, debes crear un proceso.

  1. Ve a Automatizaciones > Trabajos en la carpeta en la que reside el proceso.
  2. Haz clic en Iniciar. Se mostrará la ventana Iniciar trabajo.
  3. En el menú desplegable Nombre del proceso, selecciona un proceso que se haya implementado previamente en la carpeta actual.
  4. Configura los campos necesarios tal como se describe en las siguientes secciones.
  5. Haz clic en Iniciar. La ventana Iniciar trabajo se cierra y, si hay tiempos de ejecución disponibles en la carpeta actualmente activa, la tarea se iniciará en un Robot según la configuración que hayas establecido. El Estado de la tarea se muestra en tiempo real en la página Trabajos.

Establecer la prioridad del trabajo

En el menú desplegable Prioridad de tareas, selecciona la prioridad de la tarea que se ejecutará si quieres que sea diferente de la prioridad establecida en el nivel de proceso. Este campo se rellena automáticamente con la prioridad heredada del paquete.

Seleccionar el runtime de ejecución

Desde el menú desplegable Tipo de runtime, selecciona el tipo de runtime utilizado para ejecutar el trabajo.

El número de tiempos de ejecución disponibles y conectados se muestra debajo del menú desplegable.

  • _ Disponible: el número de tiempos de ejecución disponibles, calculado como el número total de tiempos de ejecución menos el número de trabajos en ejecución.
  • _ Conectado: el número total de tiempos de ejecución, calculado como la suma de los tiempos de ejecución en todas las máquinas conectadas a Orchestrator que está asociado a la carpeta activa.

    Tipo de runtime

    Descripción

    Producción (desatendida)

    El trabajo se ejecuta en modo desatendido consumiendo un tiempo de ejecución Unattended.

    Pruebas

    El trabajo se ejecuta en modo desatendido consumiendo un tiempo de ejecución de Pruebas.

    No producción

    El trabajo se ejecuta en modo desatendido consumiendo un tiempo de ejecución NonProduction.

Ejemplo: digamos que tienes 2 tiempos de ejecución de no producción y 1 tiempo de ejecución Desatendido en la plantilla de máquina A, y 3 tiempos de ejecución de NonProduction y 2 tiempos de ejecución Desatendidos en la plantilla de máquina B. Ambos están asociados a una carpeta. En cada plantilla, conectas una máquina de host. El estado del tiempo de ejecución resultante es el siguiente:

  • Desatendido: 3 Available, 3 Connected
  • NonProduction: 5 Available, 5 Connected

Un trabajo en ejecución que ocupa un tiempo de ejecución resta 1 al número de tiempos de ejecución disponibles para ese tipo.

Nota:

En tiempo de publicación, Orchestrator elige entre los tiempos de ejecución del espacio de trabajo personal disponibles para ejecutar el trabajo. La precedencia de tiempos de ejecución es la siguiente:

  • Sin servidor
  • Producción (desatendida)
  • No producción

Por ejemplo, si no existe un tiempo de ejecución de Production, Orchestrator utiliza un tiempo de ejecución de NonProduction disponible. Si no existe ninguno, fallará el trabajo.

Si el runtime seleccionado deja de estar disponible entre ejecuciones de trabajo, la próxima ejecución de trabajo falla, ya que Orchestrator no busca la siguiente disponible.

Configura el destino de ejecución

Configura tu objetivo de ejecución estableciendo las siguientes opciones como desees en la pestaña Objetivo de ejecución .



Asignar dinámicamente

La asignación dinámica sin ninguna selección de cuenta y máquina te permite ejecutar un proceso en primer plano varias veces con la cuenta y la máquina que estén disponibles primero. Los procesos en segundo plano se ejecutan en cualquier cuenta, independientemente de si esta está ocupada o no, siempre y cuando tengas tiempos de ejecución suficientes.

Con esta opción se puede ejecutar un proceso hasta 10 000 veces en un solo trabajo.

Cuenta

Puedes elegir uno de estos enfoques:

  • Especificar una cuenta significa que el proceso se ejecuta bajo esa cuenta específica de usuario o robot.
  • Especificar tanto la cuenta como la máquina significa que el trabajo se lanza en ese mismo par cuenta-máquina. Solo se pueden seleccionar los pares cuenta-máquina válidos.
  • Si no se especifica ninguna cuenta, Orchestrator asignará la cuenta de forma dinámica.

Máquina

Puedes elegir uno de estos enfoques:

  • Especificar un objeto de la máquina significa que el proceso se ejecuta en una de las máquinas host adjuntas a la plantilla de la máquina seleccionada. Selecciona una máquina anfitriona específica del grupo de máquinas anfitrionas conectadas en el campo Máquinas conectadas.
  • Especificar tanto la cuenta como la máquina significa que el trabajo se lanza en ese mismo par cuenta-máquina. Solo se pueden seleccionar los pares cuenta-máquina válidos.
  • Si no se especifica ninguna máquina, Orchestrator asigna la máquina host de forma dinámica.

Asegúrate de que los tiempos de ejecución que coinciden con el tipo de trabajo se asignan a la plantilla de máquina asociada. Solo se muestran las máquinas del host conectadas asociadas a la carpeta activa.

Selecciona una asignación de cuenta-máquina válida

Elige qué par cuenta-máquina específico ejecutará el trabajo.
docs image
Puedes hacer clic en Agregar asignación de cuenta-máquina si deseas que tu trabajo se ejecute en varios de estos pares. Al hacerlo, se crea un trabajo Pendiente para cada par de cuenta-máquina.
Nota: Esto solo funciona si se selecciona la opción Habilitar asignación de usuario-máquina en la pestaña General de tu configuración de tenant.

Mantener la asignación de cuenta/máquina en la reanudación del trabajo

Este campo permite configurar si los diferentes fragmentos de un trabajo de larga duración se ejecutan en el mismo par cuenta-máquina.

Por defecto, un trabajo suspendido lo reanuda cualquier Robot disponible en cualquier máquina disponible.

En función de tus requisitos de licencia o recursos, tienes la opción de reanudar un trabajo en la misma máquina y en el mismo contexto de cuenta que inició el trabajo.

Digamos que necesitas una licencia SAP para ejecutar un trabajo. En lugar de instalar una licencia SAP en cada máquina disponible (lo que aumenta los costes), se puede instalar en una sola máquina y utilizarla para iniciar y reanudar el trabajo. La misma estrategia puede aplicarse a las licencias de usuario. Puedes asignar una sola licencia de usuario y utilizarla para ejecutar el trabajo.

Programar la finalización de la ejecución del trabajo

En ocasiones, la ejecución del proceso puede ser defectuosa, provocando que el trabajo permanezca en estado pendiente. Activar la alternancia te permite (haz clic para ampliar):

  • Selecciona Detener en el menú desplegable: esto intenta detener la ejecución de forma correcta una vez transcurrido el intervalo de tiempo definido desde que el trabajo se encuentra en estado pendiente (establece el tiempo en un mínimo de 1 minuto y un máximo de 10 días, 23 horas y 59 minutos).


  • Selecciona Cancelar en el menú desplegable: esto intenta detener la ejecución de forma correcta una vez transcurrido el intervalo de tiempo definido desde que el trabajo se encuentra en estado pendiente (establece el tiempo en un mínimo de 1 minuto y un máximo de 10 días, 23 horas y 59 minutos).


  • Selecciona Detener en el menú desplegable y habilita la opción Programar «cancelación» automática, si el trabajo no se detiene: esto intenta terminar la ejecución correctamente después de que haya pasado el intervalo de tiempo definido desde que el trabajo se encuentra en estado pendiente. Luego intenta terminarlo de forma forzada una vez pasado el intervalo de tiempo definido desde que el trabajo está atascado en un estado deteniendo (establece el tiempo en un mínimo de 1 minuto y un máximo de 10 días, 23 horas y 59 minutos).


Generar una alerta si el trabajo está atascado en pendiente

Al activar la alternancia, se activan las alertas sobre los trabajos que permanecen en el estado pendiente o reanudado más tiempo que la duración especificada.

La duración configurable es como mínimo de un minuto y como máximo de once días.

Si el trabajo supera la duración configurada, una ventana emergente de alerta de gravedad de «Error» te informa con el texto siguiente:

"N trabajos para el #proceso {process_number} han estado pendientes o se han reanudado durante más de X horas e Y minutos.", donde:

  • N: es el número de trabajos que desencadenaron la alerta
  • {process_number}: el identificador del proceso
  • X: el número de horas configurado que el trabajo ha excedido mientras mostraba un estado pendiente o reanudado. Los días se convierten a horas.

  • Y: el número de minutos configurado que superó el trabajo con el estado pendiente o reanudado.

Genere una alerta si el trabajo comenzó y no se ha completado

Al activar la alternancia, se activan alertas sobre trabajos que no se completan en la duración especificada.

La duración configurable es como mínimo de un minuto y como máximo de once días.

Si el trabajo supera la duración configurada, una ventana emergente de alerta de gravedad de «Error» te informa con el texto siguiente:

«El trabajo para #process {process_number} lleva pendiente en ejecución más de X horas y Y minutos»,Donde:

  • {process_number}: el identificador del proceso
  • X: el número de horas configurado que el trabajo ha excedido mientras intentaba completarse. Los días se convierten a horas.

  • Y es el número de minutos configurado que ha superado el trabajo al intentar completarse.

Orchestrator impide que se inicien trabajos con configuraciones no válidas. Si se intenta iniciar un trabajo con una configuración no válida, aparecerá un mensaje de error descriptivo que te indicará cómo ajustar la configuración.



Iniciar un trabajo utilizando asignación dinámica es decir, no se ha especificado ninguna máquina o cuenta, con una configuración de carpetas incompatibles da lugar a un error. Asegúrate de corregir la configuración, de lo contrario, los trabajos quedan pendientes indefinidamente. Por ejemplo, intentar ejecutar un trabajo en segundo plano de .NET Framework 4.6.1 cuando solo hay plantillas multiplataforma en la carpeta no funciona, ya que los trabajos quedan pendientes hasta que se arregla la configuración.

Adición de argumentos

En la pestaña Argumentos, proporciona argumentos de entrada para el proceso seleccionado. Esta pestaña se rellena automáticamente con todos los argumentos de entrada aceptados por el proceso seleccionado, y los valores correspondientes heredados del paquete.

Iniciar un trabajo mediante un desencadenador API

Puedes iniciar un trabajo a través de un desencadenador de API desde la aplicación de terceros que prefieras. Sigue los siguientes pasos:

  1. Crea un desencadenador de API basado en el proceso que deseas ejecutar. Esto genera la URL necesaria para iniciar el trabajo. Para ello, sigue las instrucciones del tema Crear un desencadenador de API.
  2. Crea un token de acceso personal dedicado y concédele acceso a los recursos necesarios. Esto se realiza a nivel de organización, desde la página Preferencias > Token de acceso personal. Una vez guardado, asegúrate de copiar el token de acceso personal en el momento, ya que no volverá a aparecer.
  3. Pega el token de acceso personal en el campo de token al portador para autorizar tu solicitud.
  4. Obtén la URL del trabajo haciendo clic en la opción Copiar la URL completa de Slug situada junto al tenant deseado en la lista de desencadenadores y, a continuación, pégala en tu herramienta.
  5. Configura tus argumentos según sea necesario.

    Puedes introducir argumentos como los siguientes:

    Parámetros de la cadena de consulta

    En trabajos con hw-process de Slug y con los argumentos files y folders, el cURL que puedes utilizar en la línea de comandos tendrá el siguiente aspecto:
    curl --location --request POST 'https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/6ea73196-ca89-446c-81e1-5279bdd36dc2/hw-process?argument1=files&argument2=folders' \
    --header 'Cookie: __cf_bm=_5E_r3oulk6zLCr6.CUij.RFN4lCeTgYMR31gradWtI-1697542233-0-AdP+xhO+SE5PQ6wnoEum5qRu4wzUgGgOrezRhHrR4dcVvhsvl9yV/V3KAFhi/TmomqMtmxc426WT83lDMoL1seQ='curl --location --request POST 'https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/6ea73196-ca89-446c-81e1-5279bdd36dc2/hw-process?argument1=files&argument2=folders' \
    --header 'Cookie: __cf_bm=_5E_r3oulk6zLCr6.CUij.RFN4lCeTgYMR31gradWtI-1697542233-0-AdP+xhO+SE5PQ6wnoEum5qRu4wzUgGgOrezRhHrR4dcVvhsvl9yV/V3KAFhi/TmomqMtmxc426WT83lDMoL1seQ='

    Datos del formulario

    En trabajos con hw-process de Slug y con los argumentos files y folders, el cURL que puedes utilizar en la línea de comandos tendrá el siguiente aspecto:
    curl --location 'https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/6ea73196-ca89-446c-81e1-5279bdd36dc2/hw-process' \
    --header 'Cookie: __cf_bm=_5E_r3oulk6zLCr6.CUij.RFN4lCeTgYMR31gradWtI-1697542233-0-AdP+xhO+SE5PQ6wnoEum5qRu4wzUgGgOrezRhHrR4dcVvhsvl9yV/V3KAFhi/TmomqMtmxc426WT83lDMoL1seQ=' \
    --form 'argument1="files"' \
    --form 'argument2="folders"'curl --location 'https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/6ea73196-ca89-446c-81e1-5279bdd36dc2/hw-process' \
    --header 'Cookie: __cf_bm=_5E_r3oulk6zLCr6.CUij.RFN4lCeTgYMR31gradWtI-1697542233-0-AdP+xhO+SE5PQ6wnoEum5qRu4wzUgGgOrezRhHrR4dcVvhsvl9yV/V3KAFhi/TmomqMtmxc426WT83lDMoL1seQ=' \
    --form 'argument1="files"' \
    --form 'argument2="folders"'

    Texto del cuerpo JSON

    En trabajos con hw-process de Slug y con los argumentos files y folders, el cURL que puedes utilizar en la línea de comandos tendrá el siguiente aspecto:
    curl --location 'https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/6ea73196-ca89-446c-81e1-5279bdd36dc2/hw-process' \
    --header 'Content-Type: application/json' \
    --data '{
        "argument1" = "files"
        "argument2" = "folders"
    }
    'curl --location 'https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/6ea73196-ca89-446c-81e1-5279bdd36dc2/hw-process' \
    --header 'Content-Type: application/json' \
    --data '{
        "argument1" = "files"
        "argument2" = "folders"
    }
    '

    Los argumentos también pueden introducirse mediante una combinación de los métodos mencionados.

  6. Ejecuta el trabajo.

    En función del modo de llamada que hayas seleccionado en la definición del desencadenador, el trabajo se ejecutará del siguiente modo:

    • Sondeo asíncrono

    • Enviar y olvidar asíncrono

    • Sincronización (sondeo largo)

    Ten en cuenta que el modo de llamada puede anularse en la cadena de consulta o en el cuerpo utilizando el parámetro $callMode.

    Para obtener más detalles sobre estas opciones, consulta la sección Explicación de los modos de llamada.

Explicación de los modos de llamada

Los modos de llamada de los desencadenadores de la API están diseñados específicamente para crear y seguir ejecuciones de trabajos en Orchestrator.

El reto fundamental de la comunicación basada en HTTP es que es intrínsecamente sincrónica: normalmente, el cliente envía una solicitud y espera la respuesta del servidor. Sin embargo, en el contexto de los trabajos de UiPath Robot, Orchestrator no permite mantener la conexión abierta hasta que el trabajo haya finalizado.

Con el fin de evitarlo, hemos utilizado el protocolo HTTP para modelar varios modos de llamada. Estos modos se basan en métodos, códigos de estado y encabezados HTTP estándar para crear, supervisar y obtener el resultado de los trabajos dentro del sistema, sin mantener la conexión abierta innecesariamente. Cada uno de los modos de llamada propuestos tiene ventajas e inconvenientes, así que puedes elegir el que mejor se adapte a tus necesidades de integración. Ten en cuenta que, para garantizar una comunicación segura, cada llamada requiere la autenticación adecuada mediante tokens al portador.

Sondeo asíncrono

Este modo de llamada implica realizar una llamada con el verbo HTTP preconfigurado para desencadenar un nuevo trabajo y recibir un URI de estado. El URI de estado debe sondearse manualmente hasta que se complete el trabajo. En este punto, la llamada se redirige a otro punto final, que se utiliza para recuperar el resultado del trabajo (salida o error).

Flujo de trabajo de sondeo asíncrono en el que la finalización del trabajo depende de llamadas manuales intermedias a la ubicación de respuesta.

docs image

La llamada inicial se realiza utilizando el verbo HTTP configurado (OBTENER, PUBLICAR, PONER, ELIMINAR), que crea el trabajo asociado en Orchestrator. Una vez creado el trabajo, el sistema responde con un código de estado HTTP 202 (Aceptado) y un URI de estado en el encabezado Ubicación.

Una vez creado el trabajo, deberás comprobar periódicamente su estado. Durante este proceso de sondeo, mientras el trabajo esté en ejecución, cada petición OBTENER al URI de estado devuelve un código de estado HTTP 200 (OK). Cuando se completa el trabajo, la siguiente solicitud OBTENER al URI de estado devuelve un código de estado HTTP 303 (ver Otros), redirigiendo al URI de salida (a través del encabezado Ubicación). Se espera que siga el URI de salida para recuperar el resultado del trabajo (salida o error).

Asegúrate siempre de incluir un token al portador válido en el encabezado de cada llamada para que la autenticación se realice correctamente.

Ejemplo de JavaScript

Este ejemplo ilustra cómo iniciar un trabajo a través de un desencadenador de API desde un explorador, utilizando el modo de llamada de sondeo asíncrono.

const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

const url = 'https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/<INVOKE_URL>';
const token = '<PERSONAL_ACCESS_TOKEN>'; // could also be an access token retrieved via OAuth

const body = {
  'argument1': 123,
  'argument2': 'my string',
  '$callMode': 'AsyncRequestReply' // optional argument to force call mode to AsyncRequestReply
}

// if invocation is done by GET, place the parameters in query string and remove the 'Content-Type' header
const invokeRequestOptions = {
  method: 'POST',
  headers: new Headers({ 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }),
  body: JSON.stringify(body),
};

const redirectRequestOptions = {
  method: "GET",
  credentials: 'same-origin',
  headers: new Headers({ Authorization: `Bearer ${token}` }),
  redirect: "follow", // this option must be set to follow, otherwise an 'opaqueredirect' response is returned
};

const response = await fetch(url, invokeRequestOptions);
let newLocation = response.headers.get("Location");

// first response should be 202 and have a location header
console.log(`Got ${response.status}, with location: ${newLocation}`);

for (let i = 0; i < 20; i++) {
  await sleep(SLEEP_DURATION);

  // follow the location header to the new endpoint
  const statusResponse = await fetch(newLocation, redirectRequestOptions);

  // if the response was redirected (and automatically followed), then the output endpoint has been reached
  // the output of the job can be found in the body of the response in JSON format
  if (statusResponse.status != 200 || statusResponse.redirected)
  {
    // read the job output
    const output = await statusResponse.json();
    console.log(`Got ${statusResponse.status}, with body: ${JSON.stringify(output)}`);

    break;
}const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

const url = 'https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/<INVOKE_URL>';
const token = '<PERSONAL_ACCESS_TOKEN>'; // could also be an access token retrieved via OAuth

const body = {
  'argument1': 123,
  'argument2': 'my string',
  '$callMode': 'AsyncRequestReply' // optional argument to force call mode to AsyncRequestReply
}

// if invocation is done by GET, place the parameters in query string and remove the 'Content-Type' header
const invokeRequestOptions = {
  method: 'POST',
  headers: new Headers({ 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }),
  body: JSON.stringify(body),
};

const redirectRequestOptions = {
  method: "GET",
  credentials: 'same-origin',
  headers: new Headers({ Authorization: `Bearer ${token}` }),
  redirect: "follow", // this option must be set to follow, otherwise an 'opaqueredirect' response is returned
};

const response = await fetch(url, invokeRequestOptions);
let newLocation = response.headers.get("Location");

// first response should be 202 and have a location header
console.log(`Got ${response.status}, with location: ${newLocation}`);

for (let i = 0; i < 20; i++) {
  await sleep(SLEEP_DURATION);

  // follow the location header to the new endpoint
  const statusResponse = await fetch(newLocation, redirectRequestOptions);

  // if the response was redirected (and automatically followed), then the output endpoint has been reached
  // the output of the job can be found in the body of the response in JSON format
  if (statusResponse.status != 200 || statusResponse.redirected)
  {
    // read the job output
    const output = await statusResponse.json();
    console.log(`Got ${statusResponse.status}, with body: ${JSON.stringify(output)}`);

    break;
}
Ejemplo de C#

Este ejemplo ilustra cómo iniciar un trabajo a través de un desencadenador de API desde una aplicación basada en C#, utilizando el modo de llamada de sondeo asíncrono.

public async Task<string> AsyncPollingExample()
{
    const string url = "https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/<INVOKE_URL>";
    const string token = "<PERSONAL_ACCESS_TOKEN>"; // could also be an access token retrieved via OAuth

    // create an http client that does not follow redirects and adds a bearer token on each call
    var httpClient = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false });
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

    var arguments = new Dictionary<string, object>
    {
        { "argument1", 123 },
        { "argument2", "my string" },
        { "$callMode", "AsyncRequestReply" }, // optional argument to force call mode to AsyncRequestReply
    };

    var httpResponseStart = await httpClient.PostAsJsonAsync(url, arguments);
    var redirectUri = httpResponseStart.Headers.Location;

    if (httpResponseStart.StatusCode != HttpStatusCode.Accepted)
        throw new Exception("Could not invoke workflow");

    while (true)
    {
        var httpPollingResponse = await httpClient.GetAsync(redirectUri);

        if (httpPollingResponse.StatusCode == HttpStatusCode.Redirect)
        {
            var outputLocation = httpPollingResponse.Headers.Location;
            var outputResponse = await httpClient.GetAsync(outputLocation);
            var jobOutput = await outputResponse.Content.ReadAsStringAsync();

            return jobOutput;
        }

        await Task.Delay(1000);
    }
}public async Task<string> AsyncPollingExample()
{
    const string url = "https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/<INVOKE_URL>";
    const string token = "<PERSONAL_ACCESS_TOKEN>"; // could also be an access token retrieved via OAuth

    // create an http client that does not follow redirects and adds a bearer token on each call
    var httpClient = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false });
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

    var arguments = new Dictionary<string, object>
    {
        { "argument1", 123 },
        { "argument2", "my string" },
        { "$callMode", "AsyncRequestReply" }, // optional argument to force call mode to AsyncRequestReply
    };

    var httpResponseStart = await httpClient.PostAsJsonAsync(url, arguments);
    var redirectUri = httpResponseStart.Headers.Location;

    if (httpResponseStart.StatusCode != HttpStatusCode.Accepted)
        throw new Exception("Could not invoke workflow");

    while (true)
    {
        var httpPollingResponse = await httpClient.GetAsync(redirectUri);

        if (httpPollingResponse.StatusCode == HttpStatusCode.Redirect)
        {
            var outputLocation = httpPollingResponse.Headers.Location;
            var outputResponse = await httpClient.GetAsync(outputLocation);
            var jobOutput = await outputResponse.Content.ReadAsStringAsync();

            return jobOutput;
        }

        await Task.Delay(1000);
    }
}
Enviar y olvidar asíncrono

El modo de llamada inmediato devuelve un estado 200 OK al crearse correctamente el trabajo, sin ninguna otra información sobre el mismo.

Flujo de trabajo asíncrono en el que el trabajo se completa sin llamadas intermedias.

docs image
Ejemplo de JavaScript

Este ejemplo ilustra cómo iniciar un trabajo a través de un desencadenador de API desde un explorador, utilizando el modo de llamada inmediato asíncrono.

const url = 'https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/<INVOKE_URL>';
const token = '<PERSONAL_ACCESS_TOKEN>'; // could also be an access token retrieved via OAuth
  
const body = {
  'argument1': 123,
  'argument2': 'my string',
  '$callMode': 'FireAndForget' // optional argument to force call mode to FireAndForget
}

const options = {
  method: 'POST',
  headers: new Headers({ 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }),
  body: JSON.stringify(body),
};

let response = await fetch(url, options);

console.log(`Got ${response.status}`);const url = 'https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/<INVOKE_URL>';
const token = '<PERSONAL_ACCESS_TOKEN>'; // could also be an access token retrieved via OAuth
  
const body = {
  'argument1': 123,
  'argument2': 'my string',
  '$callMode': 'FireAndForget' // optional argument to force call mode to FireAndForget
}

const options = {
  method: 'POST',
  headers: new Headers({ 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }),
  body: JSON.stringify(body),
};

let response = await fetch(url, options);

console.log(`Got ${response.status}`);
Ejemplo de C#

Este ejemplo ilustra cómo iniciar un trabajo a través de un desencadenador de API desde una aplicación basada en C#, utilizando el modo de llamada inmediato asíncrono.

public async Task FireAndForgetExample()
{
    const string url = "https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/<INVOKE_URL>";
    const string token = "<PERSONAL_ACCESS_TOKEN>"; // could also be an access token retrieved via OAuth

    // create an http client that does not follow redirects and adds Bearer <token> on each call
    // if the follow redirects option is enabled, C# will not add a bearer token by default after the redirect
    var httpClient = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false });
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

    var arguments = new Dictionary<string, object>
    {
        { "argument1", 123 },
        { "argument2", "my string" },
        { "$callMode", "FireAndForget" }, // optional argument to force call mode to LongPolling
    };

    var response = await httpClient.PostAsJsonAsync(url, arguments);

    Console.WriteLine(response.StatusCode);
}public async Task FireAndForgetExample()
{
    const string url = "https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/<INVOKE_URL>";
    const string token = "<PERSONAL_ACCESS_TOKEN>"; // could also be an access token retrieved via OAuth

    // create an http client that does not follow redirects and adds Bearer <token> on each call
    // if the follow redirects option is enabled, C# will not add a bearer token by default after the redirect
    var httpClient = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false });
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

    var arguments = new Dictionary<string, object>
    {
        { "argument1", 123 },
        { "argument2", "my string" },
        { "$callMode", "FireAndForget" }, // optional argument to force call mode to LongPolling
    };

    var response = await httpClient.PostAsJsonAsync(url, arguments);

    Console.WriteLine(response.StatusCode);
}
Sincronización (sondeo largo)

Este modo de llamada implica una llamada inicial que se bloquea y espera un tiempo a que se complete el trabajo, seguida de varias posibles llamadas de bloqueo y redireccionamientos. Por último, una vez finalizado el trabajo, se recupera el resultado del trabajo (salida o error).

En función de la configuración del tenant, la autenticación puede ser necesaria para todas las llamadas o solo para la llamada inicial.

Flujo de trabajo de sincronización (sondeo largo) en el que el resultado, ya sea correcto o incorrecto, se devuelve con la llamada inicial.

docs image

Flujo de trabajo de sincronización (sondeo largo) en el que se realizan automáticamente varias llamadas para completar el trabajo.

docs image

La llamada inicial se realiza utilizando el verbo HTTP configurado (OBTENER, PUBLICAR, PONER, ELIMINAR), que crea el trabajo asociado en Orchestrator. Una vez creado el trabajo con éxito, el sistema bloquea la llamada actual mientras espera a que se complete el trabajo. Cuando el trabajo finaliza, se libera la llamada bloqueada y se devuelve una respuesta que incluye los argumentos de salida del trabajo.

Si transcurrido un tiempo de espera el trabajo aún no ha finalizado, el sistema responde con un código de estado HTTP 303 (ver Otros) y redirige al URI de estado (a través del encabezado Ubicación). Debes seguir el URI de estado, que se bloquea hasta que se completa el trabajo. Si el trabajo no se completa después de un tiempo de espera, se te redirige de nuevo a la URI de estado, creando así un bucle de redirección. Una vez completado con éxito el trabajo, el resultado del trabajo (salida o error) se recupera como parte de la respuesta HTTP.

Por defecto, todas las llamadas deben incluir un token al portador válido para su autorización. Sin embargo, si no se selecciona la opción de configuración de tenant Requerir encabezado de autenticación para las redirecciones de desencadenadores de API de sincronización, solo la llamada inicial al desencadenador requiere el encabezado de autenticación. Las llamadas posteriores al punto final de estado pueden realizarse sin un encabezado de autorización.

La duración máxima del trabajo para este modo de llamada es de 15 minutos.

Ejemplo de JavaScript

Este ejemplo ilustra cómo iniciar un trabajo a través de un desencadenador de API desde un explorador, utilizando el modo de llamada de sincronización (sondeo largo).

const url = 'https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/<INVOKE_URL>';
const token = '<PERSONAL_ACCESS_TOKEN>'; // could also be an access token retrieved via OAuth

const body = {
  'argument1': 123,
  'argument2': 'my string',
  '$callMode': 'LongPolling' // optional argument to force call mode to LongPolling
}

const options = {
  method: 'POST',
  headers: new Headers({ 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }),
  body: JSON.stringify(body),
  redirect: "follow", // follow redirects automatically
};

let response = await fetch(url, options);
const output = await response.json();

console.log(`Got ${response.status} with body ${JSON.stringify(output)}`);const url = 'https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/<INVOKE_URL>';
const token = '<PERSONAL_ACCESS_TOKEN>'; // could also be an access token retrieved via OAuth

const body = {
  'argument1': 123,
  'argument2': 'my string',
  '$callMode': 'LongPolling' // optional argument to force call mode to LongPolling
}

const options = {
  method: 'POST',
  headers: new Headers({ 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }),
  body: JSON.stringify(body),
  redirect: "follow", // follow redirects automatically
};

let response = await fetch(url, options);
const output = await response.json();

console.log(`Got ${response.status} with body ${JSON.stringify(output)}`);
Ejemplo de C#

Este ejemplo ilustra cómo iniciar un trabajo a través de un desencadenador de API desde una aplicación basada en C#, utilizando el modo de llamada de sincronización (sondeo largo).

public async Task SyncExample()
{
    const string url = "https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/<INVOKE_URL>";
    const string token = "<PERSONAL_ACCESS_TOKEN>"; // could also be an access token retrieved via OAuth

    // create an http client that does not follow redirects and adds Bearer <token> on each call
    // if the follow redirects option is enabled, C# will not add a bearer token by default after the redirect
    var httpClient = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false });
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

    var arguments = new Dictionary<string, object>
    {
        { "argument1", 123 },
        { "argument2", "my string" },
        { "$callMode", "LongPolling" }, // optional argument to force call mode to LongPolling
    };

    var response = await httpClient.PostAsJsonAsync(url, arguments);

    while(response.StatusCode == HttpStatusCode.Redirect)
    {
        // in case of redirection, keep following the latest location in the header
        var location = response.Headers.Location;
        response = await httpClient.GetAsync(location);
    }

    // read the job output/error from the last request
    var jobOutput = response.Content.ReadAsStringAsync();

    Console.WriteLine(jobOutput);
}public async Task SyncExample()
{
    const string url = "https://{yourDomain}/{organizationName}/{tenantName}/orchestrator_/t/<INVOKE_URL>";
    const string token = "<PERSONAL_ACCESS_TOKEN>"; // could also be an access token retrieved via OAuth

    // create an http client that does not follow redirects and adds Bearer <token> on each call
    // if the follow redirects option is enabled, C# will not add a bearer token by default after the redirect
    var httpClient = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false });
    httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

    var arguments = new Dictionary<string, object>
    {
        { "argument1", 123 },
        { "argument2", "my string" },
        { "$callMode", "LongPolling" }, // optional argument to force call mode to LongPolling
    };

    var response = await httpClient.PostAsJsonAsync(url, arguments);

    while(response.StatusCode == HttpStatusCode.Redirect)
    {
        // in case of redirection, keep following the latest location in the header
        var location = response.Headers.Location;
        response = await httpClient.GetAsync(location);
    }

    // read the job output/error from the last request
    var jobOutput = response.Content.ReadAsStringAsync();

    Console.WriteLine(jobOutput);
}

Limitación de tasa

El número de solicitudes que se pueden realizar al punto final de estado está limitado a 10 por cada 10 segundos para cada trabajo iniciado.

Límite de trabajos pendientes

El número máximo de trabajos pendientes iniciados a través de desencadenadores de API es 100. Esto puede cambiarse utilizando el parámetro Desencadenadores - Desencadenadores de API - Límite máximo de trabajos pendientes, que tiene un valor por defecto de 10.

Detener un trabajo

Haz clic en el botón Más acciones correspondiente y, a continuación, en Detener. El proyecto de automatización se ejecuta hasta que encuentra un la actividad Debe detenerse. Durante este tiempo, el trabajo está Detenido. Si se encuentra la actividad, se detiene la ejecución y el estado final del trabajo es Exitoso. Si no se encuentra una actividad Debe detenerse, la ejecución del trabajo no se detiene hasta que llega al final del proyecto. En este caso, el estado final también es Exitoso.

Nota:
  • Los trabajos iniciados desde Orchestrator solo pueden detenerse desde Orchestrator.
  • Los trabajos iniciados desde Assistant pueden detenerse tanto en Orchestrator, en la página Trabajos, como con UiPath Assistant.
  • Una vez que se ha detenido un trabajo, se pierden las programaciones de finalización del trabajo y es necesario volver a configurar las opciones de Programar la finalización de la ejecución del trabajo al reiniciarlo.

Reanudar una tarea

Haz clic en el botón Más acciones correspondiente y, a continuación, en Reanudar.

Cancelar un trabajo

Haz clic en el botón Más acciones y luego en Eliminar. El proyecto de automatización se detiene a la fuerza, el trabajo se marca como detenidoy se muestra "Trabajo cancelado" en la ventana de detalles del trabajo.

Nota:
  • Un trabajo iniciado desde Orchestrator puede cancelarse tanto en Orchestrator, en la página Trabajos, como con UiPath Assistant.
  • Los trabajos iniciados desde Assistant pueden cancelarse tanto en Orchestrator, en la página Trabajos, como con UiPath Assistant.
  • Una vez eliminado un trabajo, se pierden las programaciones de finalización del trabajo y es necesario volver a configurar las opciones de Programar la finalización de la ejecución del trabajo al reiniciarlo.

Reiniciar una tarea

Esta característica te permite ejecutar una tarea rápidamente desde la lista de tareas, sin pasar del flujo de trabajo configuración. Puedes reiniciar cualquier tarea con un estado final: Detenida, Fallida o Éxito.

Nota:
  • No se pueden reiniciar trabajos activados por agentes como UiPath Assistant o a través de sesiones de depuración remota de Studio.
  • Al reiniciar un trabajo que tenía activas las opciones de Programar la finalización de la ejecución del trabajo, es necesario volver a reconfigurarlas.

Este procedimiento parte de la presunción de que previamente iniciaste una tarea que ya ha alcanzado un estado final.

  1. Haz clic en el botón Más acciones correspondiente y, a continuación, en Reiniciar. Se mostrará la ventana Iniciar tarea con la configuración inicial de la tarea.
  2. Realiza los cambios deseados.
  3. Haz clic en Iniciar. La ventana Iniciar trabajos se cierra y se inicia la ejecución. El estado de cada trabajo se muestra en tiempo real en la página Trabajos.

Ver registros del trabajo

Para ver los registros de un trabajo específico, haz clic en el botón Más acciones y luego Ver registros. Se muestra la página de Registros, que contiene datos sobre el trabajo indicado.

Nota: Los registros generados para los trabajos iniciados a través de sesiones de depuración remotas no están disponibles en la página Registros de trabajo. Se encuentran en la página Registros globales.

Ver detalles del trabajo

Para ver los detalles de un trabajo específico, haz clic en el botón Ver detalles correspondiente. Esto muestra la ventana Detalles del trabajo , donde puede encontrar diversa información como:

  • el nombre del proceso subyacente
  • el robot y la máquina en ejecución
  • las razones del fallo en los trabajos
  • razones por las que el trabajo no se inicia
  • acciones que puedes tomar para solucionar cualquier incidencia y desencadenar el inicio del trabajo

Detalles del trabajo completado



Detalles del trabajo pendiente

docs image
Nota: el campo Información no muestra las cuestiones relativas a las licencias de los trabajos que fallan. Utiliza la funcionalidad de supervisión para obtener más información sobre las licencias.

Descargar medios de ejecución

Para descargar la grabación de un trabajo fallido, haz clic en Más opciones > Descargar grabación.Los medios de ejecución se descargan según tu configuración.

Icono de soporte y servicios
Obtén la ayuda que necesitas
Icono de UiPath Academy
RPA para el aprendizaje - Cursos de automatización
Icono de UiPath Forum
Foro de la comunidad UiPath
Logotipo blanco de UiPath
Confianza y seguridad
© 2005-2024 UiPath. All rights reserved.