Consulta de flujos de trabajo mediante la AWS Glue API

AWS Glue proporciona una API enriquecida para administrar flujos de trabajo. Puede recuperar una vista estática de un flujo de trabajo o una vista dinámica de un flujo de trabajo en ejecución mediante la AWS Glue API. Para obtener más información, consulte Flujos de trabajo.

Consulta de vistas estáticas

Utilice la operación de la API de GetWorkflow para obtener una vista estática que indique el diseño de un flujo de trabajo. Esta operación devuelve un gráfico dirigido que consiste en nodos y perímetros en los que el nodo representa un desencadenador, un trabajo o un rastreador. Los perímetros definen las relaciones entre nodos. Se representan mediante conectores (flechas) en el gráfico en la consola de AWS Glue.

También puede utilizar esta operación con bibliotecas de procesamiento de gráficos conocidas, como NetworkX, igraph, JGraphT y el marco de trabajo Java Universal Network/Graph (JUNG). Puesto que todas estas bibliotecas representan gráficos de forma similar, se precisan transformaciones mínimas.

La vista estática devuelta por esta API es la vista más actualizada según la última definición de desencadenadores asociados a este flujo de trabajo.

Definición de gráfico

Un gráfico de flujo de trabajo G es un par ordenador (N, E), donde N es un conjunto de nodos y E un conjunto de perímetros. Un nodo es un vértice en el gráfico identificado mediante un número único. Un nodo puede ser de tipo desencadenador, trabajo o rastreador. Por ejemplo: {name:T1, type:Trigger, uniqueId:1}, {name:J1, type:Job, uniqueId:2}.

Un perímetro es una tupla doble del formulario (src, dest), donde src y dest son los nodos y hay un perímetro dirigido desde src a dest.

Ejemplo de consulta de una vista estática

Considere un desencadenador condicional T, que desencadena el trabajo J2 una vez que se completa el trabajo J1.

J1 ---> T ---> J2

Nodos: J1, T, J2

Perímetros: (J1, T), (T, J2)

Consulta de vistas dinámicas

Utilice la operación de la API de GetWorkflowRun para obtener una vista dinámica de un flujo de trabajo en ejecución. Esta operación devuelve la misma vista estática del gráfico junto con metadatos relacionados con la ejecución de flujo de datos.

Para la ejecución, los nodos que representan trabajos en la llamada de GetWorkflowRun tienen una lista de ejecuciones de trabajo iniciadas como parte de la última ejecución del flujo de trabajo. Puede utilizar esta lista para mostrar el estado de ejecución de cada trabajo en el propio gráfico. Para dependencias descendentes que no se están ejecutando aún, este campo se establece en null. La información del gráfico le permitirá conocer el estado actual de cualquier flujo de trabajo en cualquier momento.

La vista dinámica devuelta por esta API se basa en la vista estática que estuviera presente cuando se inició la ejecución de flujo de trabajo.

Ejemplo de nodos de tiempo de ejecución: {name:T1, type: Trigger, uniqueId:1}, {name:J1, type:Job, uniqueId:2, jobDetails:{jobRuns}}, {name:C1, type:Crawler, uniqueId:3, crawlerDetails:{crawls}}

Ejemplo 1: Vista dinámica

En el siguiente ejemplo se muestra un flujo de trabajo de dos desencadenadores simple.

• Nodos: t1, j1, t2, j2

• Perímetros: (t1, j1), (j1, t2), (t2, j2)

La respuesta GetWorkflow contiene lo siguiente.

{
    Nodes : [
        {
            "type" : Trigger,
            "name" : "t1",
            "uniqueId" : 1
        },
        {
            "type" : Job,
            "name" : "j1",
            "uniqueId" : 2
        },
        {
            "type" : Trigger,
            "name" : "t2",
            "uniqueId" : 3
        },
        {
            "type" : Job,
            "name" : "j2",
            "uniqueId" : 4
        }
    ],
    Edges : [
        {
            "sourceId" : 1,
            "destinationId" : 2
        },
        {
            "sourceId" : 2,
            "destinationId" : 3
        },
        {
            "sourceId" : 3,
            "destinationId" : 4
        }
}

La respuesta GetWorkflowRun contiene lo siguiente.

{
    Nodes : [
        {
            "type" : Trigger,
            "name" : "t1",
            "uniqueId" : 1,
            "jobDetails" : null,
            "crawlerDetails" : null
        },
        {
            "type" : Job,
            "name" : "j1",
            "uniqueId" : 2,
            "jobDetails" : [
                {
                    "id" : "jr_12334",
                    "jobRunState" : "SUCCEEDED",
                    "errorMessage" : "error string"
                }
            ],
            "crawlerDetails" : null
        },
        {
            "type" : Trigger,
            "name" : "t2",
            "uniqueId" : 3,
            "jobDetails" : null,
            "crawlerDetails" : null
        },
        {
            "type" : Job,
            "name" : "j2",
            "uniqueId" : 4,
            "jobDetails" : [
                {
                    "id" : "jr_1233sdf4",
                    "jobRunState" : "SUCCEEDED",
                    "errorMessage" : "error string"
                }
            ],
            "crawlerDetails" : null
        }
    ],
    Edges : [
        {
            "sourceId" : 1,
            "destinationId" : 2
        },
        {
            "sourceId" : 2,
            "destinationId" : 3
        },
        {
            "sourceId" : 3,
            "destinationId" : 4
        }
}

Ejemplo 2: Varios trabajos con desencadenador condicional

En el siguiente ejemplo se muestra un flujo de trabajo con varios trabajos y un desencadenador condicional (t3).

Consider Flow:
T(t1) ---> J(j1) ---> T(t2) ---> J(j2)
             |                    |
             |                    |
             >+------> T(t3) <-----+
                        |
                        |
                      J(j3)

Graph generated:
Nodes: t1, t2, t3, j1, j2, j3
Edges: (t1, j1), (j1, t2), (t2, j2), (j1, t3), (j2, t3), (t3, j3)