Pipeline Runs - Query By Factory

Servicio:

Data Factory

Versión de la API:

2018-06-01

La canalización de consulta se ejecuta en el generador en función de las condiciones del filtro de entrada.

POST https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataFactory/factories/{factoryName}/queryPipelineRuns?api-version=2018-06-01

Parámetros de identificador URI

Nombre	En	Requerido	Tipo	Description
factoryName	path	True	string	Nombre del generador. Patrón de Regex: ^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$
resourceGroupName	path	True	string	El nombre del grupo de recursos. Patrón de Regex: ^[-\w\._\(\)]+$
subscriptionId	path	True	string	Identificador de la suscripción.
api-version	query	True	string	Versión de la API.

Cuerpo de la solicitud

Nombre	Requerido	Tipo	Description
lastUpdatedAfter	True	string	Hora a la que se actualizó el evento de ejecución en formato "ISO 8601".
lastUpdatedBefore	True	string	Hora a la que se actualizó el evento de ejecución o antes en formato "ISO 8601".
continuationToken		string	Token de continuación para obtener la siguiente página de resultados. Null para la primera página.
filters		RunQueryFilter[]	Lista de filtros.
orderBy		RunQueryOrderBy[]	Lista de la opción OrderBy.

Respuestas

Nombre	Tipo	Description
200 OK	PipelineRunsQueryResponse	Aceptar.
Other Status Codes	CloudError	Respuesta de error recibida del servicio Azure Data Factory.

Seguridad

azure_auth

Flujo de OAuth2 de Azure Active Directory.

Tipo: oauth2
Flujo: implicit
Dirección URL de autorización: https://login.microsoftonline.com/common/oauth2/authorize

Ámbitos

Nombre	Description
user_impersonation	suplantación de su cuenta de usuario

Ejemplos

PipelineRuns_QueryByFactory

Solicitud de ejemplo

HTTP

POST https://management.azure.com/subscriptions/12345678-1234-1234-1234-12345678abc/resourceGroups/exampleResourceGroup/providers/Microsoft.DataFactory/factories/exampleFactoryName/queryPipelineRuns?api-version=2018-06-01

{
  "lastUpdatedAfter": "2018-06-16T00:36:44.3345758Z",
  "lastUpdatedBefore": "2018-06-16T00:49:48.3686473Z",
  "filters": [
    {
      "operand": "PipelineName",
      "operator": "Equals",
      "values": [
        "examplePipeline"
      ]
    }
  ]
}

Java

import com.azure.resourcemanager.datafactory.models.RunFilterParameters;
import com.azure.resourcemanager.datafactory.models.RunQueryFilter;
import com.azure.resourcemanager.datafactory.models.RunQueryFilterOperand;
import com.azure.resourcemanager.datafactory.models.RunQueryFilterOperator;
import java.time.OffsetDateTime;
import java.util.Arrays;

/**
 * Samples for PipelineRuns QueryByFactory.
 */
public final class Main {
    /*
     * x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/
     * PipelineRuns_QueryByFactory.json
     */
    /**
     * Sample code: PipelineRuns_QueryByFactory.
     * 
     * @param manager Entry point to DataFactoryManager.
     */
    public static void pipelineRunsQueryByFactory(com.azure.resourcemanager.datafactory.DataFactoryManager manager) {
        manager.pipelineRuns().queryByFactoryWithResponse("exampleResourceGroup", "exampleFactoryName",
            new RunFilterParameters().withLastUpdatedAfter(OffsetDateTime.parse("2018-06-16T00:36:44.3345758Z"))
                .withLastUpdatedBefore(OffsetDateTime.parse("2018-06-16T00:49:48.3686473Z"))
                .withFilters(Arrays.asList(new RunQueryFilter().withOperand(RunQueryFilterOperand.PIPELINE_NAME)
                    .withOperator(RunQueryFilterOperator.EQUALS).withValues(Arrays.asList("examplePipeline")))),
            com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Python

from azure.identity import DefaultAzureCredential

from azure.mgmt.datafactory import DataFactoryManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-datafactory
# USAGE
    python pipeline_runs_query_by_factory.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = DataFactoryManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="12345678-1234-1234-1234-12345678abc",
    )

    response = client.pipeline_runs.query_by_factory(
        resource_group_name="exampleResourceGroup",
        factory_name="exampleFactoryName",
        filter_parameters={
            "filters": [{"operand": "PipelineName", "operator": "Equals", "values": ["examplePipeline"]}],
            "lastUpdatedAfter": "2018-06-16T00:36:44.3345758Z",
            "lastUpdatedBefore": "2018-06-16T00:49:48.3686473Z",
        },
    )
    print(response)


# x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/PipelineRuns_QueryByFactory.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Go

package armdatafactory_test

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datafactory/armdatafactory/v9"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/ab04533261eff228f28e08900445d0edef3eb70c/specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/PipelineRuns_QueryByFactory.json
func ExamplePipelineRunsClient_QueryByFactory() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatafactory.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPipelineRunsClient().QueryByFactory(ctx, "exampleResourceGroup", "exampleFactoryName", armdatafactory.RunFilterParameters{
		Filters: []*armdatafactory.RunQueryFilter{
			{
				Operand:  to.Ptr(armdatafactory.RunQueryFilterOperandPipelineName),
				Operator: to.Ptr(armdatafactory.RunQueryFilterOperatorEquals),
				Values: []*string{
					to.Ptr("examplePipeline")},
			}},
		LastUpdatedAfter:  to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:36:44.334Z"); return t }()),
		LastUpdatedBefore: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:49:48.368Z"); return t }()),
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.PipelineRunsQueryResponse = armdatafactory.PipelineRunsQueryResponse{
	// 	Value: []*armdatafactory.PipelineRun{
	// 		{
	// 			AdditionalProperties: map[string]any{
	// 				"annotations": []any{
	// 				},
	// 				"runDimension": map[string]any{
	// 					"JobId": "79c1cc52-265f-41a5-9553-be65e736fbd3",
	// 				},
	// 			},
	// 			DurationInMs: to.Ptr[int32](28105),
	// 			InvokedBy: &armdatafactory.PipelineRunInvokedBy{
	// 				Name: to.Ptr("Manual"),
	// 				ID: to.Ptr("80a01654a9d34ad18b3fcac5d5d76b67"),
	// 			},
	// 			LastUpdated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:38:12.731Z"); return t}()),
	// 			Message: to.Ptr(""),
	// 			Parameters: map[string]*string{
	// 				"OutputBlobNameList": to.Ptr("[\"exampleoutput.csv\"]"),
	// 			},
	// 			PipelineName: to.Ptr("examplePipeline"),
	// 			RunEnd: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:38:12.731Z"); return t}()),
	// 			RunID: to.Ptr("2f7fdb90-5df1-4b8e-ac2f-064cfa58202b"),
	// 			RunStart: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:37:44.625Z"); return t}()),
	// 			Status: to.Ptr("Succeeded"),
	// 		},
	// 		{
	// 			AdditionalProperties: map[string]any{
	// 				"annotations": []any{
	// 				},
	// 				"runDimension": map[string]any{
	// 					"JobId": "84a3c493-0628-4b44-852f-ef5b3a11bdab",
	// 				},
	// 			},
	// 			InvokedBy: &armdatafactory.PipelineRunInvokedBy{
	// 				Name: to.Ptr("Manual"),
	// 				ID: to.Ptr("7c5fd7ef7e8a464b98b931cf15fcac66"),
	// 			},
	// 			LastUpdated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:39:51.216Z"); return t}()),
	// 			Message: to.Ptr(""),
	// 			Parameters: map[string]*string{
	// 				"OutputBlobNameList": to.Ptr("[\"exampleoutput.csv\"]"),
	// 			},
	// 			PipelineName: to.Ptr("examplePipeline"),
	// 			RunID: to.Ptr("16ac5348-ff82-4f95-a80d-638c1d47b721"),
	// 			RunStart: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-16T00:39:49.274Z"); return t}()),
	// 			Status: to.Ptr("Cancelled"),
	// 	}},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { DataFactoryManagementClient } = require("@azure/arm-datafactory");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Query pipeline runs in the factory based on input filter conditions.
 *
 * @summary Query pipeline runs in the factory based on input filter conditions.
 * x-ms-original-file: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/PipelineRuns_QueryByFactory.json
 */
async function pipelineRunsQueryByFactory() {
  const subscriptionId =
    process.env["DATAFACTORY_SUBSCRIPTION_ID"] || "12345678-1234-1234-1234-12345678abc";
  const resourceGroupName = process.env["DATAFACTORY_RESOURCE_GROUP"] || "exampleResourceGroup";
  const factoryName = "exampleFactoryName";
  const filterParameters = {
    filters: [
      {
        operand: "PipelineName",
        operator: "Equals",
        values: ["examplePipeline"],
      },
    ],
    lastUpdatedAfter: new Date("2018-06-16T00:36:44.3345758Z"),
    lastUpdatedBefore: new Date("2018-06-16T00:49:48.3686473Z"),
  };
  const credential = new DefaultAzureCredential();
  const client = new DataFactoryManagementClient(credential, subscriptionId);
  const result = await client.pipelineRuns.queryByFactory(
    resourceGroupName,
    factoryName,
    filterParameters,
  );
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

dotnet

using Azure;
using Azure.ResourceManager;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Core.Expressions.DataFactory;
using Azure.Identity;
using Azure.ResourceManager.DataFactory.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.DataFactory;

// Generated from example definition: specification/datafactory/resource-manager/Microsoft.DataFactory/stable/2018-06-01/examples/PipelineRuns_QueryByFactory.json
// this example is just showing the usage of "PipelineRuns_QueryByFactory" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this DataFactoryResource created on azure
// for more information of creating DataFactoryResource, please refer to the document of DataFactoryResource
string subscriptionId = "12345678-1234-1234-1234-12345678abc";
string resourceGroupName = "exampleResourceGroup";
string factoryName = "exampleFactoryName";
ResourceIdentifier dataFactoryResourceId = DataFactoryResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, factoryName);
DataFactoryResource dataFactory = client.GetDataFactoryResource(dataFactoryResourceId);

// invoke the operation and iterate over the result
RunFilterContent content = new RunFilterContent(DateTimeOffset.Parse("2018-06-16T00:36:44.3345758Z"), DateTimeOffset.Parse("2018-06-16T00:49:48.3686473Z"))
{
    Filters =
    {
    new RunQueryFilter(RunQueryFilterOperand.PipelineName,RunQueryFilterOperator.EqualsValue,new string[]
    {
    "examplePipeline"
    })
    },
};
await foreach (DataFactoryPipelineRunInfo item in dataFactory.GetPipelineRunsAsync(content))
{
    Console.WriteLine($"Succeeded: {item}");
}

Console.WriteLine($"Succeeded");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

CLI

az datafactory pipeline-run query-by-factory --factory-name "exampleFactoryName" --filters operand="PipelineName" operator="Equals" values="examplePipeline" --last-updated-after "2018-06-16T00:36:44.3345758Z" --last-updated-before "2018-06-16T00:49:48.3686473Z" --resource-group "exampleResourceGroup"

Click here to learn more about the Azure CLI command.

Respuesta de muestra

status code:

200

Date: Sat, 16 Jun 2018 00:40:01 GMT
X-Content-Type-Options: nosniff
x-ms-ratelimit-remaining-subscription-reads: 14989
x-ms-request-id: 2f955e10-c6df-45a7-97d4-81acdb8540cd
x-ms-correlation-request-id: 2f955e10-c6df-45a7-97d4-81acdb8540cd

{
  "value": [
    {
      "runId": "2f7fdb90-5df1-4b8e-ac2f-064cfa58202b",
      "pipelineName": "examplePipeline",
      "parameters": {
        "OutputBlobNameList": "[\"exampleoutput.csv\"]"
      },
      "invokedBy": {
        "id": "80a01654a9d34ad18b3fcac5d5d76b67",
        "name": "Manual"
      },
      "runStart": "2018-06-16T00:37:44.6257014Z",
      "runEnd": "2018-06-16T00:38:12.7314495Z",
      "durationInMs": 28105,
      "status": "Succeeded",
      "message": "",
      "lastUpdated": "2018-06-16T00:38:12.7314495Z",
      "annotations": [],
      "runDimension": {
        "JobId": "79c1cc52-265f-41a5-9553-be65e736fbd3"
      }
    },
    {
      "runId": "16ac5348-ff82-4f95-a80d-638c1d47b721",
      "pipelineName": "examplePipeline",
      "parameters": {
        "OutputBlobNameList": "[\"exampleoutput.csv\"]"
      },
      "invokedBy": {
        "id": "7c5fd7ef7e8a464b98b931cf15fcac66",
        "name": "Manual"
      },
      "runStart": "2018-06-16T00:39:49.2745128Z",
      "runEnd": null,
      "durationInMs": null,
      "status": "Cancelled",
      "message": "",
      "lastUpdated": "2018-06-16T00:39:51.216097Z",
      "annotations": [],
      "runDimension": {
        "JobId": "84a3c493-0628-4b44-852f-ef5b3a11bdab"
      }
    }
  ]
}

Definiciones

Nombre	Description
CloudError	Objeto que define la estructura de una Azure Data Factory respuesta de error.
PipelineRun	Información sobre una ejecución de canalización.
PipelineRunInvokedBy	Proporciona el nombre y el identificador de entidad que iniciaron la ejecución de la canalización.
PipelineRunsQueryResponse	Una canalización de lista se ejecuta.
RunFilterParameters	Parámetros de consulta para enumerar ejecuciones.
RunQueryFilter	Opción de filtro de consulta para enumerar ejecuciones.
RunQueryFilterOperand	Nombre de parámetro que se va a usar para el filtro. Los operandos permitidos para consultar las ejecuciones de canalización son PipelineName, RunStart, RunEnd y Status; para consultar las ejecuciones de actividad son ActivityName, ActivityRunStart, ActivityRunEnd, ActivityType y Status, y para las ejecuciones de desencadenador de consulta son TriggerName, TriggerRunTimestamp y Status.
RunQueryFilterOperator	Operador que se va a usar para el filtro.
RunQueryOrder	Criterio de ordenación del parámetro.
RunQueryOrderBy	Objeto para proporcionar el orden por opciones para enumerar ejecuciones.
RunQueryOrderByField	Nombre de parámetro que se va a usar para ordenar por. Los parámetros permitidos para ordenar por para las ejecuciones de canalización son PipelineName, RunStart, RunEnd y Status; para las ejecuciones de actividad son ActivityName, ActivityRunStart, ActivityRunEnd y Status; para las ejecuciones de desencadenador son TriggerName, TriggerRunTimestamp y Status.

CloudError

Objeto que define la estructura de una Azure Data Factory respuesta de error.

Nombre	Tipo	Description
error.code	string	Código de error.
error.details	CloudError[]	Matriz con detalles de error adicionales.
error.message	string	Mensaje de error.
error.target	string	Nombre o ruta de acceso de propiedad en la solicitud asociada al error.

PipelineRun

Información sobre una ejecución de canalización.

Nombre	Tipo	Description
durationInMs	integer	Duración de una ejecución de canalización.
invokedBy	PipelineRunInvokedBy	Entidad que inició la ejecución de la canalización.
isLatest	boolean	Indica si la ejecución de la canalización recuperada es la más reciente de su grupo.
lastUpdated	string	Marca de tiempo actualizada por última vez para el evento de ejecución de canalización en formato ISO8601.
message	string	Mensaje de una ejecución de canalización.
parameters	object	La lista completa o parcial del nombre de parámetro, el par de valores que se usa en la ejecución de la canalización.
pipelineName	string	El nombre de la canalización.
runDimensions	object	Ejecutar dimensiones emitidas por la ejecución de canalización.
runEnd	string	Hora de finalización de una ejecución de canalización en formato ISO8601.
runGroupId	string	Identificador que correlaciona todas las ejecuciones de recuperación de una ejecución de canalización.
runId	string	Identificador de una ejecución.
runStart	string	Hora de inicio de una ejecución de canalización en formato ISO8601.
status	string	Estado de una ejecución de canalización. Valores posibles: Queued, InProgress, Succeeded, Failed, Canceling, Cancelled

PipelineRunInvokedBy

Proporciona el nombre y el identificador de entidad que iniciaron la ejecución de la canalización.

Nombre	Tipo	Description
id	string	Identificador de la entidad que inició la ejecución.
invokedByType	string	Tipo de la entidad que inició la ejecución.
name	string	Nombre de la entidad que inició la ejecución de la canalización.
pipelineName	string	Nombre de la canalización que desencadenó la ejecución, si existe.
pipelineRunId	string	Identificador de ejecución de la canalización que desencadenó la ejecución, si existe.

PipelineRunsQueryResponse

Una canalización de lista se ejecuta.

Nombre	Tipo	Description
continuationToken	string	Token de continuación para obtener la siguiente página de resultados, si existen resultados restantes, null en caso contrario.
value	PipelineRun[]	Lista de ejecuciones de canalización.

RunFilterParameters

Parámetros de consulta para enumerar ejecuciones.

Nombre	Tipo	Description
continuationToken	string	Token de continuación para obtener la siguiente página de resultados. Null para la primera página.
filters	RunQueryFilter[]	Lista de filtros.
lastUpdatedAfter	string	Hora a la que se actualizó el evento de ejecución en formato "ISO 8601".
lastUpdatedBefore	string	Hora a la que se actualizó el evento de ejecución o antes en formato "ISO 8601".
orderBy	RunQueryOrderBy[]	Lista de la opción OrderBy.

RunQueryFilter

Opción de filtro de consulta para enumerar ejecuciones.

Nombre	Tipo	Description
operand	RunQueryFilterOperand	Nombre de parámetro que se va a usar para el filtro. Los operandos permitidos para consultar las ejecuciones de canalización son PipelineName, RunStart, RunEnd y Status; para consultar las ejecuciones de actividad son ActivityName, ActivityRunStart, ActivityRunEnd, ActivityType y Status, y para las ejecuciones de desencadenador de consulta son TriggerName, TriggerRunTimestamp y Status.
operator	RunQueryFilterOperator	Operador que se va a usar para el filtro.
values	string[]	Lista de valores de filtro.

RunQueryFilterOperand

Nombre de parámetro que se va a usar para el filtro. Los operandos permitidos para consultar las ejecuciones de canalización son PipelineName, RunStart, RunEnd y Status; para consultar las ejecuciones de actividad son ActivityName, ActivityRunStart, ActivityRunEnd, ActivityType y Status, y para las ejecuciones de desencadenador de consulta son TriggerName, TriggerRunTimestamp y Status.

Nombre	Tipo	Description
ActivityName	string
ActivityRunEnd	string
ActivityRunStart	string
ActivityType	string
LatestOnly	string
PipelineName	string
RunEnd	string
RunGroupId	string
RunStart	string
Status	string
TriggerName	string
TriggerRunTimestamp	string

RunQueryFilterOperator

Operador que se va a usar para el filtro.

Nombre	Tipo	Description
Equals	string
In	string
NotEquals	string
NotIn	string

RunQueryOrder

Criterio de ordenación del parámetro.

Nombre	Tipo	Description
ASC	string
DESC	string

RunQueryOrderBy

Objeto para proporcionar el orden por opciones para enumerar ejecuciones.

Nombre	Tipo	Description
order	RunQueryOrder	Criterio de ordenación del parámetro.
orderBy	RunQueryOrderByField	Nombre de parámetro que se va a usar para ordenar por. Los parámetros permitidos para ordenar por para las ejecuciones de canalización son PipelineName, RunStart, RunEnd y Status; para las ejecuciones de actividad son ActivityName, ActivityRunStart, ActivityRunEnd y Status; para las ejecuciones de desencadenador son TriggerName, TriggerRunTimestamp y Status.

RunQueryOrderByField

Nombre de parámetro que se va a usar para ordenar por. Los parámetros permitidos para ordenar por para las ejecuciones de canalización son PipelineName, RunStart, RunEnd y Status; para las ejecuciones de actividad son ActivityName, ActivityRunStart, ActivityRunEnd y Status; para las ejecuciones de desencadenador son TriggerName, TriggerRunTimestamp y Status.

Nombre	Tipo	Description
ActivityName	string
ActivityRunEnd	string
ActivityRunStart	string
PipelineName	string
RunEnd	string
RunStart	string
Status	string
TriggerName	string
TriggerRunTimestamp	string