Rychlé zprovoznění: Vytvoření datové továrny Azure a kanálu pomocí rozhraní REST API

  • Článek
  • 11 min ke čtení

PLATÍ PRO: Azure Data Factory Azure Synapse Analytics

Azure Data Factory je cloudová služba pro integraci dat umožňující vytváření pracovních postupů řízených daty v cloudu za účelem orchestrace a automatizace přesunu a transformace dat. pomocí Azure Data Factory můžete vytvářet a plánovat pracovní postupy řízené daty (nazývané kanály), které mohou ingestovat data z různorodých úložišť dat, zpracovávat nebo transformovat data pomocí výpočetních služeb, jako jsou Azure HDInsight Hadoop, Spark, Azure Data Lake Analytics a Azure Machine Learning a publikujte výstupní data do úložišť dat, jako je Azure synapse Analytics pro aplikace business intelligence (BI), která se mají spotřebovat.

Tento rychlý start popisuje použití rozhraní REST API k vytvoření datové továrny Azure. Kanál v této datové továrně kopíruje data z jednoho umístění do jiného umístění v úložišti objektů blob v Azure.

Pokud ještě nemáte předplatné Azure, vytvořte si bezplatný účet před tím, než začnete.

Požadavky

Poznámka

Tento článek používá modul Azure Az PowerShell, což je doporučený modul PowerShellu pro interakci s Azure. Pokud chcete začít s modulem Az PowerShell, projděte si téma věnované instalaci Azure PowerShellu. Informace o tom, jak migrovat na modul Az PowerShell, najdete v tématu Migrace Azure PowerShellu z AzureRM na Az.

  • Předplatné Azure. Pokud předplatné nemáte, můžete si vytvořit bezplatný zkušební účet.
  • účet Azure Storage. Úložiště objektů blob použijete jako úložiště dat pro zdroj a jímku. Pokud nemáte účet úložiště Azure, přečtěte si článek Vytvoření účtu úložiště , kde najdete kroky, jak ho vytvořit.
  • Vytvořte kontejner objektů blob ve službě Blob Storage, v tomto kontejneru vytvořte vstupní složku a uložte do ní nějaké soubory. pomocí nástrojů, jako je Průzkumník služby Azure Storage , se můžete připojit k úložišti objektů blob v Azure, vytvořit kontejner objektů blob, nahrát vstupní soubor a ověřit výstupní soubor.
  • Nainstalujte Azure PowerShell. Postupujte podle pokynů v tématu Jak nainstalovat a nakonfigurovat Azure PowerShell. Tento rychlý start využívá PowerShell k vyvolání volání rozhraní REST API.
  • V Azure Active Directory vytvořte aplikaci s využitím těchto pokynů. Poznamenejte si následující hodnoty, které použijete v pozdějších krocích: ID aplikace, clientSecrets a ID tenanta. Přiřaďte aplikaci roli Přispěvatel na úrovni předplatného nebo skupiny prostředků.

Poznámka

V případě cloudů v rámci svrchovaného cloudu je nutné použít příslušné koncové body specifické pro Cloud pro ActiveDirectoryAuthority a ResourceManagerUrl (BaseUri). Pomocí PowerShellu můžete snadno získat adresy URL koncových bodů pro různé cloudy spuštěním příkazu Get-AzEnvironment |. Format-list, který vrátí seznam koncových bodů pro každé cloudové prostředí.

Nastavení globálních proměnných

  1. Spusťte PowerShell. Nechte prostředí Azure PowerShell otevřené až do konce tohoto kurzu Rychlý start. Pokud ho zavřete a znovu otevřete, bude potřeba tyto příkazy spustit znovu.

    Spusťte následující příkaz a zadejte uživatelské jméno a heslo, které používáte k přihlášení na web Azure Portal:

    Connect-AzAccount

    Spuštěním následujícího příkazu zobrazíte všechna předplatná pro tento účet:

    Get-AzSubscription

    Spuštěním následujícího příkazu vyberte předplatné, se kterým chcete pracovat. Nahraďte SubscriptionId číslem ID vašeho předplatného Azure:

    Select-AzSubscription -SubscriptionId "<SubscriptionId>"

  2. Po nahrazení zástupných znaků vlastními hodnotami spusťte následující příkazy, které nastaví globální proměnné pro použití v dalších krocích.

    $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"

Ověřování pomocí Azure AD

Spuštěním následujících příkazů proveďte ověření pomocí služby Azure Active Directory (AAD):

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

Zobrazí se výzva k zadání hesla, použijte hodnotu v proměnné clientSecrets.

Pokud potřebujete získat přístupový token


GetToken

Vytvoření datové továrny

Spuštěním následujících příkazů vytvořte datovou továrnu:

$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

Je třeba počítat s následujícím:

  • Název objektu pro vytváření dat Azure musí být globálně jedinečný. Pokud se zobrazí následující chyba, změňte název a zkuste to znovu.

    Data factory name "ADFv2QuickStartDataFactory" is not available.

  • Pokud chcete zobrazit seznam oblastí Azure, ve kterých je služba Data Factory aktuálně dostupná, na následující stránce vyberte oblasti, které vás zajímají, pak rozbalte Analýza a vyhledejte Data Factory:Dostupné produkty v jednotlivých oblastech. Úložiště dat (Azure Storage, Azure SQL Database atd.) a výpočetní prostředí (HDInsight atd.) používané datovou továrnou mohou být v jiných oblastech.

Tady je ukázka obsahu odpovědi:


{  
    "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":{  

    }
}

Vytvoření propojených služeb

V datové továrně vytvoříte propojené služby, abyste svá úložiště dat a výpočetní služby spojili s datovou továrnou. V tomto rychlém startu stačí jako zdroj kopírování i úložiště jímky vytvořit jednu propojenou službu Azure Storage s názvem AzureStorageLinkedService.

Spuštěním následujících příkazů vytvořte propojenou službu s názvem AzureStorageLinkedService:

Než příkazy spustíte, položky <accountName> a <accountKey> nahraďte názvem svého účtu úložiště Azure a jeho klíčem.

$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-RestMethod -Method PUT -Uri $request -Header $authHeader -Body $body
$response.content

Zde je ukázkový výstup:

{  
    "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"
}

Vytvoření datových sad

Definujete datovou sadu, která představuje data pro kopírování ze zdroje do jímky. V tomto příkladu vytvoříte dvě datové sady: InputDataset a OutputDataset. Odkazují na propojenou službu Azure Storage, kterou jste vytvořili v předchozí části. Vstupní datová sada představuje zdrojová data ve vstupní složce. V definici vstupní datové sady určíte kontejner objektů blob (adftutorial), složku (input) a soubor (emp.txt) obsahující zdrojová data. Výstupní datová sada představuje data kopírovaná do cíle. V definici výstupní datové sady určíte kontejner objektů blob (adftutorial), složku (output) a soubor, do kterého se data kopírují.

Vytvořit InputDataset


$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

Zde je ukázkový výstup:

{  
    "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"
}

Vytvořit OutputDataset

$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

Zde je ukázkový výstup:

{  
    "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"
}

Vytvoření kanálu

V tomto příkladu tento kanál obsahuje jednu aktivitu kopírování. Aktivita kopírování odkazuje na "InputDataset" a "OutputDataset" vytvořená v předchozím kroku jako vstup a výstup.

$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

Zde je ukázkový výstup:

{  
    "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"
}

Vytvoření spuštění kanálu

V tomto kroku aktivujete spuštění kanálu. ID spuštění kanálu vrácené v textu odpovědi se použije později v rozhraní API pro monitorování.

$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

Zde je ukázkový výstup:

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

RunId můžete taky získat pomocí následujícího příkazu.


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

Parametrizovat kanál

Můžete vytvořit kanál s parametry. V následujícím příkladu vytvoříme vstupní datovou sadu a výstupní datovou sadu, která může přebírat vstupní a výstupní názvy souborů jako parametry daného kanálu.

Vytvořit parametrizovanou vstupní datovou sadu

Definujte parametr s názvem strInputFileName a použijte jej jako název souboru pro datovou sadu.


$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

Zde je ukázkový výstup:

{
    "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"
}

Vytvořit parametrizovanou výstupní datovou sadu

Definujte parametr s názvem strOutputFileName a použijte jej jako název souboru pro datovou sadu.



$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

Zde je ukázkový výstup:

{
    "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"
}

Vytvoření parametrizovaného kanálu

Definujte kanál se dvěma parametry úrovně kanálu: strParamInputFileName a strParamOutputFileName. Pak tyto dva parametry propojte s parametry strInputFileName a strOutputFileName datových sad.


$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

Zde je ukázkový výstup:


{
    "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"
}

Vytvoření spuštění kanálu s parametry

V okamžiku vytvoření běhu kanálu teď můžete zadat hodnoty parametru.


$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

Zde je ukázkový výstup:

{"runId":"ffc9c2a8-d86a-46d5-9208-28b3551007d8"}

Monitorování kanálu

  1. Spusťte následující skript, který bude nepřetržitě kontrolovat stav spuštění kanálu, dokud nedokončí kopírování dat.

        $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
        }
    }

    Zde je ukázkový výstup:

        {
      "id": "/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<factoryName>/pipelineruns/ffc9c2a8-d86a-46d5-9208-28b3551007d8",
      "runId": "ffc9c2a8-d86a-46d5-9208-28b3551007d8",
      "debugRunId": null,
      "runGroupId": "ffc9c2a8-d86a-46d5-9208-28b3551007d8",
      "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. Spusťte následující skript, který načte podrobnosti o spuštění aktivity kopírování, například velikost načtených/zapsaných dat.

         $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
        }
    }

    Zde je ukázkový výstup:

        {
      "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": "40bab243-9bbf-4538-9336-b797a2f98e2b",
      "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": "ffc9c2a8-d86a-46d5-9208-28b3551007d8",
      "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/ffc9c2a8-d86a-46d5-9208-28b3551007d8/activityruns/40bab243-9bbf-4538-9336-b797a2f98e2b"
    }

Ověření výstupu

pomocí nástroje Azure Storage explorer ověřte, zda je soubor zkopírován do "outputPath" z "inputPath", jak jste určili při vytváření spuštění kanálu.

Vyčištění prostředků

Prostředky, které jste vytvořili v rámci tohoto rychlého startu, můžete vyčistit dvěma způsoby. Můžete odstranit skupinu prostředků Azure, což zahrnuje odstranění všech prostředků v této skupině prostředků. Pokud chcete ostatní prostředky zachovat beze změny, odstraňte pouze datovou továrnu, kterou jste vytvořili v tomto kurzu.

Spuštěním následujícího příkazu odstraníte celou skupinu prostředků:

Remove-AzResourceGroup -ResourceGroupName $resourcegroupname

Spuštěním následujícího příkazu odstraníte pouze datovou továrnu:

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

Další kroky

Kanál v této ukázce kopíruje data z jednoho umístění do jiného umístění v úložišti objektů blob Azure. Projděte si kurzy, kde se dozvíte o použití služby Data Factory ve více scénářích.