Snabbstart: Skapa en Azure Data Factory och pipeline med hjälp av REST-API:et

GÄLLER FÖR: Azure Data Factory Azure Synapse Analytics

Tips

Data Factory i Microsoft Fabric är nästa generations Azure Data Factory, med en enklare arkitektur, inbyggd AI och nya funktioner. Om dataintegrering är nytt för dig börjar du med Fabric Data Factory. Befintliga ADF-arbetsbelastningar kan uppgraderas till Fabric för att få åtkomst till nya funktioner inom datavetenskap, realtidsanalys och rapportering.

Azure Data Factory är en molnbaserad dataintegreringstjänst som gör att du kan skapa datadrivna arbetsflöden i molnet för att orkestrera och automatisera dataflytt och datatransformering. Med hjälp av Azure Data Factory kan du skapa och schemalägga datadrivna arbetsflöden (kallas pipelines) som kan mata in data från olika datalager, bearbeta/transformera data med hjälp av beräkningstjänster som Azure HDInsight Hadoop, Spark, Azure Data Lake Analytics och Azure Machine Learning och publicera utdata till datalager, till exempel Azure Synapse Analytics för BI-program (Business Intelligence) att använda.

Den här snabbstarten beskriver hur du använder REST API för att skapa en Azure Data Factory. Pipelinen i den här datafabriken kopierar data från en plats till en annan plats i en Azure bloblagring.

Om du inte har en Azure-prenumeration skapar du ett free-konto innan du börjar.

Förutsättningar

Anteckning

Vi rekommenderar att du använder modulen Azure Az PowerShell för att interagera med Azure. Kom igång genom att läsa Installera Azure PowerShell. Information om hur du migrerar till Az PowerShell-modulen finns i Migrera Azure PowerShell från AzureRM till Az.

  • Azure prenumeration. Om du inte har en prenumeration kan du skapa ett kostnadsfritt utvärderingskonto.
  • Azure Storage konto. Du kan använda blob-lagringen som källa och mottagare för datalagringen. Om du inte har ett Azure lagringskonto kan du läsa artikeln Skapa ett lagringskonto för steg för att skapa ett.
  • Skapa en blob-container i Blob Storage, skapa en indata folder i containern och ladda upp några filer till mappen. Du kan använda verktyg som Azure Storage Explorer för att ansluta till Azure Blob Storage, skapa en blobcontainer, ladda upp indatafil och verifiera utdatafilen.
  • Installera Azure PowerShell. Följ anvisningarna i Så här installerar och konfigurerar du Azure PowerShell. I den här snabbstarten används PowerShell för att göra REST API-anrop.
  • Skapa ett program i Microsoft Entra ID efter den här instruktionen. Anteckna följande värden som du använder i senare steg: program-ID, clientSecrets och klient-ID. Tilldela applikationen rollen "Deltagare" på prenumerations- eller resursgruppsnivå.

Anteckning

För nationella moln måste du använda lämpliga molnspecifika slutpunkter för ActiveDirectoryAuthority och ResourceManagerUrl (BaseUri). Du kan använda PowerShell för att enkelt hämta slutpunkts-URL:er för olika moln genom att köra "Get-AzEnvironment | Format-List", som returnerar en lista över slutpunkter för varje molnmiljö.

Ange globala variabler

  1. Starta PowerShell. Håll Azure PowerShell öppna till slutet av den här snabbstarten. Om du stänger och öppnar det igen måste du köra kommandona en gång till.

    Kör följande kommando och ange det användarnamn och lösenord som du använder för att logga in på Azure-portalen:

    Connect-AzAccount

    Kör följande kommando för att visa alla prenumerationer för det här kontot:

    Get-AzSubscription

    Kör följande kommando för att välja den prenumeration som du vill arbeta med. Ersätt SubscriptionId med ID:t för din Azure-prenumeration:

    Select-AzSubscription -SubscriptionId "<SubscriptionId>"

  2. Kör följande kommandon när du har ersatt platshållarna med dina egna värden, för att ange globala variabler som ska användas i senare steg.

    $tenantID = "<your tenant ID>"
$appId = "<your application ID>"
$clientSecrets = "<your clientSecrets for the application>"
$subscriptionId = "<your subscription ID to create the factory>"
$resourceGroupName = "<your resource group to create the factory>"
$factoryName = "<specify the name of data factory to create. It must be globally unique.>"
$apiVersion = "2018-06-01"

Autentisera med Microsoft Entra ID

Kör följande kommandon för att autentisera med Microsoft Entra ID:

$credentials = Get-Credential -UserName $appId
Connect-AzAccount -ServicePrincipal  -Credential $credentials -Tenant $tenantID

Du uppmanas att ange lösenordet och använda värdet i variabeln clientSecrets.

Om du behöver hämta åtkomsttoken


GetToken

Skapa en datafabrik

Skapa en datafabrik genom att köra följande kommandon:

$body = @"
{
    "location": "East US",
    "properties": {},
    "identity": {
        "type": "SystemAssigned"
    }
}
"@

$response =   Invoke-AzRestMethod -SubscriptionId ${subscriptionId}  -ResourceGroupName ${resourceGroupName} -ResourceProviderName  Microsoft.DataFactory -ResourceType "factories" -Name  ${factoryName} -ApiVersion ${apiVersion} -Method PUT -Payload ${body}
$response.Content

Observera följande:

  • Namnet på Azure Data Factory måste vara globalt unikt. Om du får följande felmeddelande ändrar du namnet och försöker igen.

    Data factory name "ADFv2QuickStartDataFactory" is not available.

  • Om du vill ha en lista över Azure regioner där Data Factory är tillgängligt för närvarande väljer du de regioner som intresserar dig på följande sida och expanderar sedan Analytics för att hitta Data Factory: Produkter tillgängliga per region. Datalager (Azure Storage, Azure SQL Database osv.) och beräkningar (HDInsight osv.) som används av datafabriken kan finnas i andra regioner.

Här är exempelsvarsinnehållet:


{  
    "name":"<dataFactoryName>",
    "identity":{  
        "type":"SystemAssigned",
        "principalId":"<service principal ID>",
        "tenantId":"<tenant ID>"
    },
    "id":"/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<dataFactoryName>",
    "type":"Microsoft.DataFactory/factories",
    "properties":{  
        "provisioningState":"Succeeded",
        "createTime":"2019-09-03T02:10:27.056273Z",
        "version":"2018-06-01"
    },
    "eTag":"\"0200c876-0000-0100-0000-5d6dcb930000\"",
    "location":"East US",
    "tags":{  

    }
}

Skapa länkade tjänster

Du kan skapa länkade tjänster i en datafabrik för att länka ditt datalager och beräkna datafabrik-tjänster. I den här snabbstarten behöver du bara skapa en Azure Storage länkad tjänst som både kopieringskälla och mottagararkiv med namnet "AzureStorageLinkedService" i exemplet.

Kör följande kommandon för att skapa en länkad tjänst med namnet AzureStorageLinkedService:

Ersätt <accountName> och <accountKey> med namnet och nyckeln för ditt Azure lagringskonto innan du kör kommandona.

$path = "/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DataFactory/factories/${factoryName}/linkedservices/AzureStorageLinkedService?api-version=${apiVersion}"

$body = @"
{  
    "name":"AzureStorageLinkedService",
    "properties":{  
        "annotations":[  

        ],
        "type":"AzureBlobStorage",
        "typeProperties":{  
            "connectionString":"DefaultEndpointsProtocol=https;AccountName=<accountName>;AccountKey=<accountKey>"
        }
    }
}
"@
$response =  Invoke-AzRestMethod  -Path ${path}  -Method PUT -Payload $body
$response.content

Här är exempel på utdata:

{  
    "id":"/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<dataFactoryName>/linkedservices/AzureStorageLinkedService",
    "name":"AzureStorageLinkedService",
    "type":"Microsoft.DataFactory/factories/linkedservices",
    "properties":{  
        "annotations":[  

        ],
        "type":"AzureBlobStorage",
        "typeProperties":{  
            "connectionString":"DefaultEndpointsProtocol=https;AccountName=<accountName>;"
        }
    },
    "etag":"07011a57-0000-0100-0000-5d6e14a20000"
}

Skapa datauppsättningar

Du definierar en datauppsättning som representerar data som ska kopieras från en källa till en mottagare. I det här exemplet skapar du två datauppsättningar: InputDataset och OutputDataset. De refererar till den Azure Storage länkade tjänsten som du skapade i föregående avsnitt. Datauppsättningen för indata representerar källdata i indatamappen. I definitionen av datauppsättningen för indata anger du blobcontainern (adftutorial), mappen (input) och filen (emp.txt) som innehåller källdata. Datauppsättningen för utdata representerar de data som kopieras till målet. I definitionen av datauppsättningen för utdata anger du blobcontainern (adftutorial), mappen (output) och filen som data ska kopieras till.

Skapa Inmatningsdataset


$path = "/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DataFactory/factories/${factoryName}/datasets/InputDataset?api-version=${apiVersion}"

$body = @"
{  
    "name":"InputDataset",
    "properties":{  
        "linkedServiceName":{  
            "referenceName":"AzureStorageLinkedService",
            "type":"LinkedServiceReference"
        },
        "annotations":[  

        ],
        "type":"Binary",
        "typeProperties":{  
            "location":{  
                "type":"AzureBlobStorageLocation",
                "fileName":"emp.txt",
                "folderPath":"input",
                "container":"adftutorial"
            }
        }
    }
}
"@

$response =  Invoke-AzRestMethod  -Path ${path}  -Method PUT -Payload $body
$response

Här är exempel på utdata:

{  
    "id":"/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<dataFactoryName>/datasets/InputDataset",
    "name":"InputDataset",
    "type":"Microsoft.DataFactory/factories/datasets",
    "properties":{  
        "linkedServiceName":{  
            "referenceName":"AzureStorageLinkedService",
            "type":"LinkedServiceReference"
        },
        "annotations":[  

        ],
        "type":"Binary",
        "typeProperties":{  
            "location":"@{type=AzureBlobStorageLocation; fileName=emp.txt; folderPath=input; container=adftutorial}"
        }
    },
    "etag":"07011c57-0000-0100-0000-5d6e14b40000"
}

Skapa utdatauppsättning

$path = "/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DataFactory/factories/${factoryName}/datasets/OutputDataset?api-version=${apiVersion}"

$body = @"
{  
    "name":"OutputDataset",
    "properties":{  
        "linkedServiceName":{  
            "referenceName":"AzureStorageLinkedService",
            "type":"LinkedServiceReference"
        },
        "annotations":[  

        ],
        "type":"Binary",
        "typeProperties":{  
            "location":{  
                "type":"AzureBlobStorageLocation",
                "folderPath":"output",
                "container":"adftutorial"
            }
        }
    }
}
"@

$response =  Invoke-AzRestMethod  -Path ${path}  -Method PUT -Payload $body
$response.content

Här är exempel på utdata:

{  
    "id":"/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<dataFactoryName>/datasets/OutputDataset",
    "name":"OutputDataset",
    "type":"Microsoft.DataFactory/factories/datasets",
    "properties":{  
        "linkedServiceName":{  
            "referenceName":"AzureStorageLinkedService",
            "type":"LinkedServiceReference"
        },
        "annotations":[  

        ],
        "type":"Binary",
        "typeProperties":{  
            "location":"@{type=AzureBlobStorageLocation; folderPath=output; container=adftutorial}"
        }
    },
    "etag":"07013257-0000-0100-0000-5d6e18920000"
}

Skapa en pipeline

I det här exemplet innehåller den här pipelinen en Copy activity. Kopiera-aktiviteten refererar till "InputDataset" och "OutputDataset" som skapades i det föregående steget som indata och utdata.

$path = "/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DataFactory/factories/${factoryName}/pipelines/Adfv2QuickStartPipeline?api-version=${apiVersion}"

$body = @"
{
    "name": "Adfv2QuickStartPipeline",
    "properties": {
        "activities": [
            {
                "name": "CopyFromBlobToBlob",
                "type": "Copy",
                "dependsOn": [],
                "policy": {
                    "timeout": "7.00:00:00",
                    "retry": 0,
                    "retryIntervalInSeconds": 30,
                    "secureOutput": false,
                    "secureInput": false
                },
                "userProperties": [],
                "typeProperties": {
                    "source": {
                        "type": "BinarySource",
                        "storeSettings": {
                            "type": "AzureBlobStorageReadSettings",
                            "recursive": true
                        }
                    },
                    "sink": {
                        "type": "BinarySink",
                        "storeSettings": {
                            "type": "AzureBlobStorageWriteSettings"
                        }
                    },
                    "enableStaging": false
                },
                "inputs": [
                    {
                        "referenceName": "InputDataset",
                        "type": "DatasetReference"
                    }
                ],
                "outputs": [
                    {
                        "referenceName": "OutputDataset",
                        "type": "DatasetReference"
                    }
                ]
            }
        ],
        "annotations": []
    }
}
"@
$response =  Invoke-AzRestMethod  -Path ${path}  -Method PUT -Payload $body
$response.content

Här är exempel på utdata:

{  
    "id":"/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<dataFactoryName>/pipelines/Adfv2QuickStartPipeline",
    "name":"Adfv2QuickStartPipeline",
    "type":"Microsoft.DataFactory/factories/pipelines",
    "properties":{  
        "activities":[  
            "@{name=CopyFromBlobToBlob; type=Copy; dependsOn=System.Object[]; policy=; userProperties=System.Object[]; typeProperties=; inputs=System.Object[]; outputs=System.Object[]}"
        ],
        "annotations":[  

        ]
    },
    "etag":"07012057-0000-0100-0000-5d6e14c00000"
}

Skapa pipelinekörning

I det här steget utlöser du en pipelinekörning. Pipelinens kör-ID som returneras i svarskroppen används i API:et för senare övervakning.

$path = "/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DataFactory/factories/${factoryName}/pipelines/Adfv2QuickStartPipeline/createRun?api-version=${apiVersion}"

$response =  Invoke-AzRestMethod  -Path ${path}  -Method POST 
$response.content

Här är exempel på utdata:

{  
    "runId":"04a2bb9a-71ea-4c31-b46e-75276b61bafc"
}

Du kan också hämta runId med hjälp av följande kommando


($response.content | ConvertFrom-Json).runId

Parametrisera din processflöde

Du kan skapa en pipeline med parametrar. I följande exempel skapar vi en indatauppsättning och en utdatauppsättning som kan ta in- och utdatafilnamn som parametrar som ges till pipelinen.

Skapa parameteriserad indatauppsättning

Definiera en parameter med namnet strInputFileName och använd den som filnamn för datauppsättningen.


$path = "/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DataFactory/factories/${factoryName}/datasets/ParamInputDataset?api-version=${apiVersion}"

$body = @"
{
    "name": "ParamInputDataset",
    "properties": {
        "linkedServiceName": {
            "referenceName": "AzureStorageLinkedService",
            "type": "LinkedServiceReference"
        },
        "parameters": {
            "strInputFileName": {
                "type": "string"
            }
        },
        "annotations": [],
        "type": "Binary",
        "typeProperties": {
            "location": {
                "type": "AzureBlobStorageLocation",
                "fileName": {
                    "value": "@dataset().strInputFileName",
                    "type": "Expression"
                },
                "folderPath": "input",
                "container": "adftutorial"
            }
        }
    },
    "type": "Microsoft.DataFactory/factories/datasets"
}
"@

$response =  Invoke-AzRestMethod  -Path ${path}  -Method PUT -Payload $body
$response.content

Här är exempel på utdata:

{
    "id": "/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<factoryName>/datasets/ParamInputDataset",
    "name": "ParamInputDataset",
    "type": "Microsoft.DataFactory/factories/datasets",
    "properties": {
        "linkedServiceName": {
            "referenceName": "AzureStorageLinkedService",
            "type": "LinkedServiceReference"
        },
        "parameters": {
            "strInputFileName": {
                "type": "string"
            }
        },
        "annotations": [],
        "type": "Binary",
        "typeProperties": {
            "location": {
                "type": "AzureBlobStorageLocation",
                "fileName": {
                    "value": "@dataset().strInputFileName",
                    "type": "Expression"
                },
                "folderPath": "input",
                "container": "adftutorial"
            }
        }
    },
    "etag": "00000000-0000-0000-0000-000000000000"
}

Skapa parameteriserad utdatauppsättning

Definiera en parameter med namnet strOutputFileName och använd den som filnamn för datauppsättningen.



$path = "/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DataFactory/factories/${factoryName}/datasets/ParamOutputDataset?api-version=${apiVersion}"
$body = @"
{
    "name": "ParamOutputDataset",
    "properties": {
        "linkedServiceName": {
            "referenceName": "AzureStorageLinkedService",
            "type": "LinkedServiceReference"
        },
        "parameters": {
            "strOutPutFileName": {
                "type": "string"
            }
        },
        "annotations": [],
        "type": "Binary",
        "typeProperties": {
            "location": {
                "type": "AzureBlobStorageLocation",
                "fileName": {
                    "value": "@dataset().strOutPutFileName",
                    "type": "Expression"
                },
                "folderPath": "output",
                "container": "adftutorial"
            }
        }
    },
    "type": "Microsoft.DataFactory/factories/datasets"
}

"@

$response =  Invoke-AzRestMethod  -Path ${path}  -Method PUT -Payload $body
$response.content

Här är exempel på utdata:

{
    "id": "/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<factoryName>/datasets/ParamOutputDataset",
    "name": "ParamOutputDataset",
    "type": "Microsoft.DataFactory/factories/datasets",
    "properties": {
        "linkedServiceName": {
            "referenceName": "AzureStorageLinkedService",
            "type": "LinkedServiceReference"
        },
        "parameters": {
            "strOutPutFileName": {
                "type": "string"
            }
        },
        "annotations": [],
        "type": "Binary",
        "typeProperties": {
            "location": {
                "type": "AzureBlobStorageLocation",
                "fileName": {
                    "value": "@dataset().strOutPutFileName",
                    "type": "Expression"
                },
                "folderPath": "output",
                "container": "adftutorial"
            }
        }
    },
    "etag": "00000000-0000-0000-0000-000000000000"
}

Skapa parametriserad pipeline

Definiera en pipeline med två parametrar på pipelinenivå: strParamInputFileName och strParamOutputFileName. Länka sedan dessa två parametrar till parametrarna strInputFileName och strOutputFileName för datauppsättningarna.


$path = "/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DataFactory/factories/${factoryName}/pipelines/Adfv2QuickStartParamPipeline?api-version=${apiVersion}"

$body = @"
{
    "name": "Adfv2QuickStartParamPipeline",
    "properties": {
        "activities": [
            {
                "name": "CopyFromBlobToBlob",
                "type": "Copy",
                "dependsOn": [],
                "policy": {
                    "timeout": "7.00:00:00",
                    "retry": 0,
                    "retryIntervalInSeconds": 30,
                    "secureOutput": false,
                    "secureInput": false
                },
                "userProperties": [],
                "typeProperties": {
                    "source": {
                        "type": "BinarySource",
                        "storeSettings": {
                            "type": "AzureBlobStorageReadSettings",
                            "recursive": true
                        }
                    },
                    "sink": {
                        "type": "BinarySink",
                        "storeSettings": {
                            "type": "AzureBlobStorageWriteSettings"
                        }
                    },
                    "enableStaging": false
                },
                "inputs": [
                    {
                        "referenceName": "ParamInputDataset",
                        "type": "DatasetReference",
                        "parameters": {
                            "strInputFileName": {
                                "value": "@pipeline().parameters.strParamInputFileName",
                                "type": "Expression"
                            }
                        }
                    }
                ],
                "outputs": [
                    {
                        "referenceName": "ParamOutputDataset",
                        "type": "DatasetReference",
                        "parameters": {
                            "strOutPutFileName": {
                                "value": "@pipeline().parameters.strParamOutputFileName",
                                "type": "Expression"
                            }
                        }
                    }
                ]
            }
        ],   

        "parameters": {
            "strParamInputFileName": {
              "type": "String"
            },
            "strParamOutputFileName": {
              "type": "String"
            }
          }
    }
}
"@

$response =  Invoke-AzRestMethod  -Path ${path}  -Method PUT -Payload $body
$response.content

Här är exempel på utdata:


{
    "id": "/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<factoryName>/pipelines/Adfv2QuickStartParamPipeline",
    "name": "Adfv2QuickStartParamPipeline",
    "type": "Microsoft.DataFactory/factories/pipelines",
    "properties": {
        "activities": [
            {
                "name": "CopyFromBlobToBlob",
                "type": "Copy",
                "dependsOn": [],
                "policy": {
                    "timeout": "7.00:00:00",
                    "retry": 0,
                    "retryIntervalInSeconds": 30,
                    "secureOutput": false,
                    "secureInput": false
                },
                "userProperties": [],
                "typeProperties": {
                    "source": {
                        "type": "BinarySource",
                        "storeSettings": {
                            "type": "AzureBlobStorageReadSettings",
                            "recursive": true
                        }
                    },
                    "sink": {
                        "type": "BinarySink",
                        "storeSettings": {
                            "type": "AzureBlobStorageWriteSettings"
                        }
                    },
                    "enableStaging": false
                },
                "inputs": [
                    {
                        "referenceName": "ParamInputDataset",
                        "type": "DatasetReference",
                        "parameters": {
                            "strInputFileName": {
                                "value": "@pipeline().parameters.strParamInputFileName",
                                "type": "Expression"
                            }
                        }
                    }
                ],
                "outputs": [
                    {
                        "referenceName": "ParamOutputDataset",
                        "type": "DatasetReference",
                        "parameters": {
                            "strOutPutFileName": {
                                "value": "@pipeline().parameters.strParamOutputFileName",
                                "type": "Expression"
                            }
                        }
                    }
                ]
            }
        ],
        "parameters": {
            "strParamInputFileName": {
                "type": "String"
            },
            "strParamOutputFileName": {
                "type": "String"
            }
        }
    },
    "etag": "5e01918d-0000-0100-0000-60d569a90000"
}

Skapa pipelinekörning med parametrar

Nu kan du specificera värden för parametern när du skapar en pipelinekörning.


$path = "/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DataFactory/factories/${factoryName}/pipelines/Adfv2QuickStartParamPipeline/createRun?api-version=${apiVersion}"

$body = @"
{  
        "strParamInputFileName": "emp2.txt",
        "strParamOutputFileName": "aloha.txt"
}
"@

$response =  Invoke-AzRestMethod  -Path ${path}  -Method POST -Payload $body
$response.content
$runId  = ($response.content | ConvertFrom-Json).runId

Här är exempel på utdata:

{"runId":"aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e"}

Övervaka pipeline

  1. Kör följande skript för att kontinuerligt kontrollera pipelinekörningens status tills kopieringen av data är klar.

        $path = "/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DataFactory/factories/${factoryName}/pipelineruns/${runId}?api-version=${apiVersion}"


    while ($True) {

        $response =  Invoke-AzRestMethod  -Path ${path}  -Method GET 
        $response = $response.content | ConvertFrom-Json

        Write-Host  "Pipeline run status: " $response.Status -foregroundcolor "Yellow"

        if ( ($response.Status -eq "InProgress") -or ($response.Status -eq "Queued") -or ($response.Status -eq "In Progress") ) {
            Start-Sleep -Seconds 10
        }
        else {
            $response | ConvertTo-Json
            break
        }
    }

    Här är exempel på utdata:

        {
      "id": "/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<factoryName>/pipelineruns/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
      "runId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
      "debugRunId": null,
      "runGroupId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
      "pipelineName": "Adfv2QuickStartParamPipeline",
      "parameters": {
        "strParamInputFileName": "emp2.txt",
        "strParamOutputFileName": "aloha.txt"
      },
      "invokedBy": {
        "id": "9c0275ed99994c18932317a325276544",
        "name": "Manual",
        "invokedByType": "Manual"
      },
      "runStart": "2021-06-25T05:34:06.8424413Z",
      "runEnd": "2021-06-25T05:34:13.2936585Z",
      "durationInMs": 6451,
      "status": "Succeeded",
      "message": "",
      "lastUpdated": "2021-06-25T05:34:13.2936585Z",
      "annotations": [],
      "runDimension": {},
      "isLatest": true
    }

  2. Kör följande skript för att hämta detaljer om kopieringskörningen, till exempel storleken på den data som har lästs eller skrivits.

         $path = "/subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.DataFactory/factories/${factoryName}/pipelineruns/${runId}/queryActivityruns?api-version=${apiVersion}"


    while ($True) {

        $response =  Invoke-AzRestMethod  -Path ${path}  -Method POST 
        $responseContent = $response.content | ConvertFrom-Json
        $responseContentValue = $responseContent.value

        Write-Host  "Activity run status: " $responseContentValue.Status -foregroundcolor "Yellow"

        if ( ($responseContentValue.Status -eq "InProgress") -or ($responseContentValue.Status -eq "Queued") -or ($responseContentValue.Status -eq "In Progress") ) {
            Start-Sleep -Seconds 10
        }
        else {
            $responseContentValue | ConvertTo-Json
            break
        }
    }

    Här är exempel på utdata:

        {
      "activityRunEnd": "2021-06-25T05:34:11.9536764Z",
      "activityName": "CopyFromBlobToBlob",
      "activityRunStart": "2021-06-25T05:34:07.5161151Z",
      "activityType": "Copy",
      "durationInMs": 4437,
      "retryAttempt": null,
      "error": {
        "errorCode": "",
        "message": "",
        "failureType": "",
        "target": "CopyFromBlobToBlob",
        "details": ""
      },
      "activityRunId": "bbbb1b1b-cc2c-dd3d-ee4e-ffffff5f5f5f",
      "iterationHash": "",
      "input": {
        "source": {
          "type": "BinarySource",
          "storeSettings": "@{type=AzureBlobStorageReadSettings; recursive=True}"
        },
        "sink": {
          "type": "BinarySink",
          "storeSettings": "@{type=AzureBlobStorageWriteSettings}"
        },
        "enableStaging": false
      },
      "linkedServiceName": "",
      "output": {
        "dataRead": 134,
        "dataWritten": 134,
        "filesRead": 1,
        "filesWritten": 1,
        "sourcePeakConnections": 1,
        "sinkPeakConnections": 1,
        "copyDuration": 3,
        "throughput": 0.044,
        "errors": [],
        "effectiveIntegrationRuntime": "DefaultIntegrationRuntime (East US)",
        "usedDataIntegrationUnits": 4,
        "billingReference": {
          "activityType": "DataMovement",
          "billableDuration": ""
        },
        "usedParallelCopies": 1,
        "executionDetails": [
          "@{source=; sink=; status=Succeeded; start=06/25/2021 05:34:07; duration=3; usedDataIntegrationUnits=4; usedParallelCopies=1; profile=; detailedDurations=}"
        ],
        "dataConsistencyVerification": {
          "VerificationResult": "NotVerified"
        },
        "durationInQueue": {
          "integrationRuntimeQueue": 0
        }
      },
      "userProperties": {},
      "pipelineName": "Adfv2QuickStartParamPipeline",
      "pipelineRunId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e",
      "status": "Succeeded",
      "recoveryStatus": "None",
      "integrationRuntimeNames": [
        "defaultintegrationruntime"
      ],
      "executionDetails": {
        "integrationRuntime": [
          "@{name=DefaultIntegrationRuntime; type=Managed; location=East US; nodes=}"
        ]
      },
      "id": "/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<factoryName>/pipelineruns/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/activityruns/bbbb1b1b-cc2c-dd3d-ee4e-ffffff5f5f5f"
    }

Verifiera resultatet

Använd Azure Storage explorer för att kontrollera att filen kopieras till "outputPath" från "inputPath" som du angav när du skapade en pipelinekörning.

Rensa resurser

Du kan rensa de resurser som du skapade i snabbstarten på två sätt. Du kan ta bort resursgruppen Azure som innehåller alla resurser i resursgruppen. Om du vill behålla de andra resurserna intakta ska du bara ta bort den datafabrik du har skapat i den här självstudiekursen.

Kör följande kommando om du vill ta bort hela resursgruppen:

Remove-AzResourceGroup -ResourceGroupName $resourcegroupname

Kör följande kommando om du bara vill ta bort datafabriken:

Remove-AzDataFactoryV2 -Name "<NameOfYourDataFactory>" -ResourceGroupName "<NameOfResourceGroup>"

Relaterat innehåll

Pipeline i det här exemplet kopierar data från en plats till en annan i en Azure Blob-lagring. Gå igenom självstudiekurserna om du vill lära dig hur du använder Data Factory i fler scenarier.

  • Last updated on