Tutorial: Copiar dados de um banco de dados do SQL Server para o Armazenamento de Blobs do Azure

APLICA-SE A: Azure Data Factory Azure Synapse Analytics

Neste tutorial, você usa o Azure PowerShell para criar um pipeline de data factory que copia dados de um banco de dados do SQL Server para o Armazenamento de Blobs do Azure. Você cria e usa um runtime de integração auto-hospedada, o qual move dados entre locais e armazenamentos de dados da nuvem.

Neste tutorial, você executa as seguintes etapas:

Pré-requisitos

Assinatura do Azure

Antes de começar, se você ainda não tiver uma assinatura do Azure, crie uma conta gratuita.

Funções do Azure

Para criar instâncias de data factory, a conta de usuário usada para entrar no Azure deve ter uma função de Colaborador ou Proprietário atribuída, ou deve ser de um administrador da assinatura do Azure.

Para exibir as permissões que você tem com a assinatura, vá até o portal do Azure, selecione seu nome de usuário no canto superior direito e depois Permissões. Se tiver acesso a várias assinaturas, selecione a que for adequada. Para ver instruções de exemplo de como adicionar um usuário a uma função, confira o artigo Atribuir funções do Azure usando o portal do Azure.

SQL Server 2014, 2016 e 2017

Neste tutorial, você usa um banco de dados do SQL Server como um armazenamento de dados de origem. O pipeline no data factory criado neste tutorial copia dados desse banco de dados do SQL Server (origem) para um Armazenamento de Blobs do Azure (coletor). Depois, crie uma tabela chamada emp no seu banco de dados do SQL Server e insira algumas entradas de exemplo na tabela.

1. Inicie o SQL Server Management Studio. Se ainda não estiver instalado em seu computador, vá para Baixar o SQL Server Management Studio.

2. Conecte-se à sua instância do SQL Server usando suas credenciais.

3. Crie um banco de dados de exemplo. No modo de exibição de árvore, clique com o botão direito do mouse em Bancos de Dados e selecione Novo Banco de Dados.

4. Na janela Novo Banco de Dados, digite um nome para o banco de dados e selecione OK.

5. Para criar a tabela emp e inserir alguns dados de exemplo nela, execute o seguinte script de consulta no banco de dados. No modo de exibição de árvore, clique com o botão direito do mouse no banco de dados que você criou e selecione Nova Consulta.

   CREATE TABLE dbo.emp
   (
       ID int IDENTITY(1,1) NOT NULL,
       FirstName varchar(50),
       LastName varchar(50)
   )
   GO
   
   INSERT INTO emp (FirstName, LastName) VALUES ('John', 'Doe')
   INSERT INTO emp (FirstName, LastName) VALUES ('Jane', 'Doe')
   GO
   

Conta de Armazenamento do Azure

Neste tutorial, use uma conta de armazenamento do Azure de uso geral (especificamente o Armazenamento de Blobs do Azure) como um armazenamento de dados de destino/coletor. Se você não tiver uma conta de armazenamento de uso geral do Azure, consulte Criar uma conta de armazenamento. O pipeline no data factory criado neste tutorial copia dados do banco de dados do SQL Server (origem) para esse Armazenamento de Blobs do Azure (coletor).

Obter o nome da conta de armazenamento e a chave da conta

Você usa o nome e a chave da sua conta de armazenamento do Azure neste tutorial. Obtenha o nome e a chave da sua conta de armazenamento fazendo o seguinte:

1. Entre no portal do Azure com sua conta e senha do Azure.

2. No painel esquerdo, selecione Mais serviços, filtre usando a palavra-chave Armazenamento e selecione Contas de armazenamento.

   

3. Na lista de contas de armazenamento, filtre pela sua conta de armazenamento (se necessário) e, em seguida, selecione a sua conta de armazenamento.

4. Na janela Conta de armazenamento, selecione Chaves de acesso.

5. Nas caixas Nome da conta de armazenamento e key1, copie os valores e depois cole-os no Bloco de Notas ou outro editor para uso posterior neste tutorial.

Criar o contêiner adftutorial

Nesta seção, você cria um contêiner de blob chamado adftutorial no armazenamento de Blobs do Azure.

1. Na janela Conta de armazenamento, alterne para Visão geral e depois selecione Blobs.

   

2. Na janela Serviço Blob, selecione Contêiner.

3. Na janela Novo contêiner, na caixa Nome, insira adftutorial e depois selecione OK.

   

4. Na lista de contêineres, selecione adftutorial.

5. Mantenha aberta a janela contêiner para adftutorial. Use-a para verificar a saída no final do tutorial. O Data Factory cria automaticamente a pasta de saída nesse contêiner, portanto você não precisa criar uma.

Windows PowerShell

Instalar o Azure PowerShell

Instale a versão mais recente do Azure PowerShell caos ainda não a tenha em seu computador. Para saber mais, confira Como instalar e configurar o Azure PowerShell.

Fazer logon no PowerShell

1. Inicie o PowerShell em seu computador e mantenha-o aberto até a conclusão deste tutorial de início rápido. Se você fechá-lo e reabri-lo, precisará executar esses comandos novamente.

2. Execute o comando a seguir e depois insira o nome de usuário e a senha do Azure que você usa para entrar no portal do Azure:

   Connect-AzAccount
   

3. Se você tiver várias assinaturas do Azure, execute o comando a seguir para selecionar as assinaturas com as quais quer trabalhar. Substitua SubscriptionId pela ID da assinatura do Azure:

   Select-AzSubscription -SubscriptionId "<SubscriptionId>"   	
   

Criar uma data factory

1. Defina uma variável para o nome do grupo de recursos que você usará nos comandos do PowerShell posteriormente. Copie o comando a seguir para o PowerShell, especifique um nome para o grupo de recursos do Azure (entre aspas duplas; por exemplo, "adfrg") e depois execute o comando.

   $resourceGroupName = "ADFTutorialResourceGroup"
   

2. Para criar o grupo de recursos do Azure, execute o seguinte comando:

   New-AzResourceGroup $resourceGroupName -location 'East US'
   

   Se o grupo de recursos já existir, não convém substituí-lo. Atribua um valor diferente para a variável $resourceGroupName e execute o comando novamente.

3. Defina uma variável para o nome do data factory que você pode usar nos comandos do PowerShell mais tarde. O nome deve começar com uma letra ou um número e pode conter apenas letras, números e o caractere traço (-).

   Importante

   Atualize o nome do data factory usando um nome globalmente exclusivo. Por exemplo, ADFTutorialFactorySP1127.

   $dataFactoryName = "ADFTutorialFactory"
   

4. Defina uma variável para o local do data factory:

   $location = "East US"
   

5. Para criar o data factory, execute o seguinte cmdlet Set-AzDataFactoryV2:

   Set-AzDataFactoryV2 -ResourceGroupName $resourceGroupName -Location $location -Name $dataFactoryName
   

Criar um Integration Runtime auto-hospedado

Nesta seção, você cria um Integration Runtime auto-hospedado e o associa a um computador local com o banco de dados do SQL Server. O Integration Runtime auto-hospedado é o componente que copia dados do banco de dados do SQL Server em seu computador para o armazenamento de Blobs do Azure.

1. Crie uma variável para o nome do Integration Runtime. Use um nome exclusivo e anote o nome. Você o usará posteriormente neste tutorial.

   $integrationRuntimeName = "ADFTutorialIR"
   

2. Criar um runtime de integração auto-hospedada.

   Set-AzDataFactoryV2IntegrationRuntime -ResourceGroupName $resourceGroupName -DataFactoryName $dataFactoryName -Name $integrationRuntimeName -Type SelfHosted -Description "selfhosted IR description"
   

   Veja o exemplo de saída:

   Name              : ADFTutorialIR
   Type              : SelfHosted
   ResourceGroupName : <resourceGroupName>
   DataFactoryName   : <dataFactoryName>
   Description       : selfhosted IR description
   Id                : /subscriptions/<subscription ID>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<dataFactoryName>/integrationruntimes/<integrationRuntimeName>
   

3. Para recuperar o status do Integration Runtime criado, execute o comando a seguir:

   Get-AzDataFactoryV2IntegrationRuntime -name $integrationRuntimeName -ResourceGroupName $resourceGroupName -DataFactoryName $dataFactoryName -Status
   

   Veja o exemplo de saída:

   State                     : NeedRegistration
   Version                   :
   CreateTime                : 9/10/2019 3:24:09 AM
   AutoUpdate                : On
   ScheduledUpdateDate       :
   UpdateDelayOffset         :
   LocalTimeZoneOffset       :
   InternalChannelEncryption :
   Capabilities              : {}
   ServiceUrls               : {eu.frontend.clouddatahub.net}
   Nodes                     : {}
   Links                     : {}
   Name                      : <Integration Runtime name>
   Type                      : SelfHosted
   ResourceGroupName         : <resourceGroup name>
   DataFactoryName           : <dataFactory name>
   Description               : selfhosted IR description
   Id                        : /subscriptions/<subscription ID>/resourceGroups/<resourceGroupName>/providers/Microsoft.DataFactory/factories/<dataFactoryName>/integrationruntimes/<integrationRuntimeName>
   

4. Para recuperar as chaves de autenticação para registrar o Integration Runtime auto-hospedado com o serviço Data Factory na nuvem, execute o comando a seguir. Copie uma das chaves (excluindo as aspas) para registrar Integration Runtime auto-hospedado instalado em seu computador na próxima etapa.

   Get-AzDataFactoryV2IntegrationRuntimeKey -Name $integrationRuntimeName -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName | ConvertTo-Json
   

   Veja o exemplo de saída:

   {
       "AuthKey1":  "IR@0000000000-0000-0000-0000-000000000000@xy0@xy@xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=",
       "AuthKey2":  "IR@0000000000-0000-0000-0000-000000000000@xy0@xy@yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy="
   }
   

Instalar o Integration Runtime

1. Baixe o Integration Runtime do Azure Data Factory em uma máquina local do Windows e execute a instalação.

2. No assistente Bem-vindo à instalação do Microsoft Integration Runtime, selecione Avançar.

3. Na janela Contrato de Licença do Usuário Final, aceite os termos e o contrato de licença e selecione Avançar.

4. No janela Pasta de Destino, selecione Avançar.

5. Na janela Pronto para instalar o Microsoft Integration Runtime, selecione Instalar.

6. No assistente Instalação do Microsoft Integration Runtime concluída, selecione Concluir.

7. Na janela Registrar Integration Runtime (auto-hospedado) , cole a chave que você salvou na seção anterior e selecione Registrar.

   

8. Na janela Novo Nó do Integration Runtime (auto-hospedado) , selecione Concluir.

   

9. Quando o Integration Runtime auto-hospedado for registrado com êxito, a mensagem a seguir será exibida:

   

10. Na janela Registrar Integration Runtime (auto-hospedado) , selecione Iniciar o Gerenciador de Configurações.

11. Quando o nó estiver conectado ao serviço de nuvem, a mensagem a seguir será exibida:

    

12. Teste a conectividade com o seu banco de dados do SQL Server fazendo o seguinte:

    a. Na janela Gerenciador de Configurações, alterne para a guia Diagnóstico.

    b. Na caixa Tipo da fonte de dados, selecione SqlServer.

    c. Insira o nome do servidor.

    d. Insira o nome do banco de dados.

    e. Selecione o modo de autenticação.

    f. Insira o nome de usuário.

    g. Insira a senha associada ao nome de usuário.

    h. Para confirmar que esse runtime de integração pode se conectar ao SQL Server, selecione Testar.
    

    Se a conexão tiver êxito, uma marca de seleção verde será exibida. Caso contrário, você receberá uma mensagem de erro associada à falha. Corrija quaisquer problemas e verifique se o Integration Runtime pode se conectar ao seu SQL Server.

    Anote todos os valores anteriores para uso posterior neste tutorial.

Criar serviços vinculados

Para vincular seus armazenamentos de dados e serviços de computação ao data factory, crie serviços vinculados no data factory. Neste tutorial, você vincula sua conta de armazenamento do Azure e a instância do SQL Server para o armazenamento de dados. Os serviços vinculados têm as informações de conexão que o serviço do Data Factory usa no runtime para se conectar a eles.

Criar um serviço vinculado do Armazenamento do Azure (destino/coletor)

Nesta etapa, você vincula a conta de armazenamento do Azure ao data factory.

1. Crie um arquivo JSON denominado AzureStorageLinkedService.json na pasta C:\ADFv2Tutorial, com o código a seguir. Se a pasta ADFv2Tutorial ainda não existir, crie-a.

   Importante

   Antes de salvar o arquivo, substitua <accountName> e <accountKey> pelo nome e a chave da sua conta do Armazenamento do Azure. Você os anotou na seção Pré-requisitos.

   {
       "name": "AzureStorageLinkedService",
       "properties": {
           "annotations": [],
           "type": "AzureBlobStorage",
           "typeProperties": {
               "connectionString": "DefaultEndpointsProtocol=https;AccountName=<accountName>;AccountKey=<accountKey>;EndpointSuffix=core.windows.net"
           }
       }
   }
   

2. No PowerShell, alterne para a pasta C:\ADFv2Tutorial.

   Set-Location 'C:\ADFv2Tutorial'
   

3. Para criar um serviço vinculado, AzureStorageLinkedService, execute o cmdlet Set-AzDataFactoryV2LinkedService a seguir:

   Set-AzDataFactoryV2LinkedService -DataFactoryName $dataFactoryName -ResourceGroupName $ResourceGroupName -Name "AzureStorageLinkedService" -File ".\AzureStorageLinkedService.json"
   

   Aqui está uma amostra de saída:

   LinkedServiceName : AzureStorageLinkedService
   ResourceGroupName : <resourceGroup name>
   DataFactoryName   : <dataFactory name>
   Properties        : Microsoft.Azure.Management.DataFactory.Models.AzureBlobStorageLinkedService
   

   Se você receber um erro "arquivo não encontrado", confirme que o arquivo existe executando o comando dir. Se o nome do arquivo tiver a extensão .txt (por exemplo, AzureStorageLinkedService.json.txt), remova-a e execute novamente o comando do PowerShell.

Criar e criptografar um serviço vinculado do SQL Server (origem)

Nesta etapa, você vincula sua instância do SQL Server ao data factory.

1. Crie um arquivo JSON file chamado SqlServerLinkedService.json na pasta C:\ADFv2Tutorial usando o seguinte código:

   Importante

   Selecione a seção que está baseada na autenticação usada para se conectar ao SQL Server.

   Usando a autenticação SQL (sa):

   {  
       "name":"SqlServerLinkedService",
       "type":"Microsoft.DataFactory/factories/linkedservices",
       "properties":{  
           "annotations":[  
   
           ],
           "type":"SqlServer",
           "typeProperties":{  
               "connectionString":"integrated security=False;data source=<serverName>;initial catalog=<databaseName>;user id=<userName>;password=<password>"
           },
           "connectVia":{  
               "referenceName":"<integration runtime name> ",
               "type":"IntegrationRuntimeReference"
           }
       }
   }
   

   Usando a autenticação do Windows:

   {  
       "name":"SqlServerLinkedService",
       "type":"Microsoft.DataFactory/factories/linkedservices",
       "properties":{  
           "annotations":[  
   
           ],
           "type":"SqlServer",
           "typeProperties":{  
               "connectionString":"integrated security=True;data source=<serverName>;initial catalog=<databaseName>",
               "userName":"<username> or <domain>\\<username>",
               "password":{  
                   "type":"SecureString",
                   "value":"<password>"
               }
           },
           "connectVia":{  
               "referenceName":"<integration runtime name>",
               "type":"IntegrationRuntimeReference"
           }
       }
   }
   

   Importante

   • Selecione a seção que está baseada na autenticação usada para se conectar à sua instância do SQL Server.
   • Substitua <integration runtime name> pelo nome do seu runtime de integração.
   • Antes de salvar o arquivo, substitua <servername>, <databasename>, <username> e <password> pelos valores da sua instância do SQL Server.
   • Se precisar usar um caractere de barra invertida (\) na conta de usuário e no nome do servidor, use o caractere de escape à frente (\). Por exemplo, use mydomain\\myuser.

2. Para criptografar os dados confidenciais (nome de usuário, senha e assim por diante), execute o cmdlet New-AzDataFactoryV2LinkedServiceEncryptedCredential.
   Essa criptografia garante que as credenciais sejam criptografadas usando a API de Proteção de Dados (DPAPI). As credenciais criptografadas são armazenadas localmente no nó do runtime de integração auto-hospedada (computador local). O conteúdo de saída pode ser redirecionado para outro arquivo JSON (nesse caso, encryptedLinkedService.json) que contém credenciais criptografadas.

   New-AzDataFactoryV2LinkedServiceEncryptedCredential -DataFactoryName $dataFactoryName -ResourceGroupName $ResourceGroupName -IntegrationRuntimeName $integrationRuntimeName -File ".\SQLServerLinkedService.json" > encryptedSQLServerLinkedService.json
   

3. Execute o comando a seguir, o qual cria EncryptedSqlServerLinkedService:

   Set-AzDataFactoryV2LinkedService -DataFactoryName $dataFactoryName -ResourceGroupName $ResourceGroupName -Name "EncryptedSqlServerLinkedService" -File ".\encryptedSqlServerLinkedService.json"
   

Criar conjuntos de dados

Nesta etapa, você cria conjuntos de dados de entrada e saída. Eles representam dados de entrada e saída da operação de cópia, que copia dados do banco de dados SQL Server para o Armazenamento de Blobs do Azure.

Criar um conjunto de dados para o banco de dados SQL Server fonte

Nesta etapa, você define um conjunto de dados que representa os dados na instância do banco de dados do SQL Server. O conjunto de dados é do tipo SqlServerTable. Ele se refere ao serviço vinculado do SQL Server criado na etapa anterior. O serviço vinculado tem as informações de conexão que o serviço do Data Factory usa para se conectar à sua instância do SQL Server no runtime. Esse conjunto de dados especifica a tabela SQL no banco de dados que contém os dados. Neste tutorial, a tabela emp contém os dados de origem.

1. Crie um arquivo JSON denominado SqlServerDataset.json na pasta C:\ADFv2Tutorial com o seguinte código:

   {  
       "name":"SqlServerDataset",
       "properties":{  
           "linkedServiceName":{  
               "referenceName":"EncryptedSqlServerLinkedService",
               "type":"LinkedServiceReference"
           },
           "annotations":[  
   
           ],
           "type":"SqlServerTable",
           "schema":[  
   
           ],
           "typeProperties":{  
               "schema":"dbo",
               "table":"emp"
           }
       }
   }
   

2. Para criar o conjunto de dados SqlServerDataset, execute o cmdlet Set-AzDataFactoryV2Dataset.

   Set-AzDataFactoryV2Dataset -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -Name "SqlServerDataset" -File ".\SqlServerDataset.json"
   

   Veja o exemplo de saída:

   DatasetName       : SqlServerDataset
   ResourceGroupName : <resourceGroupName>
   DataFactoryName   : <dataFactoryName>
   Structure         :
   Properties        : Microsoft.Azure.Management.DataFactory.Models.SqlServerTableDataset
   

Criar um conjunto de dados para o Armazenamento de Blobs do Azure (coletor)

Nesta etapa, você define um conjunto de dados que representa os dados que serão copiados para o Armazenamento de Blobs do Azure. O conjunto de dados é do tipo AzureBlob. Ele se refere ao serviço vinculado do Armazenamento do Azure criado anteriormente neste tutorial.

O serviço vinculado tem as informações de conexão que o serviço do data factory usa no runtime para se conectar à sua conta de Armazenamento do Azure. Esse conjunto de dados especifica a pasta no armazenamento do Azure para a qual os dados são copiados do banco de dados do SQL Server. Neste tutorial, a pasta é adftutorial/fromonprem, em que adftutorial é o contêiner de blob e fromonprem é a pasta.

1. Crie um arquivo JSON denominado AzureBlobDataset.json na pasta C:\ADFv2Tutorial com o seguinte código:

   {  
       "name":"AzureBlobDataset",
       "properties":{  
           "linkedServiceName":{  
               "referenceName":"AzureStorageLinkedService",
               "type":"LinkedServiceReference"
           },
           "annotations":[  
   
           ],
           "type":"DelimitedText",
           "typeProperties":{  
               "location":{  
                   "type":"AzureBlobStorageLocation",
                   "folderPath":"fromonprem",
                   "container":"adftutorial"
               },
               "columnDelimiter":",",
               "escapeChar":"\\",
               "quoteChar":"\""
           },
           "schema":[  
   
           ]
       },
       "type":"Microsoft.DataFactory/factories/datasets"
   }
   

2. Para criar o conjunto de dados AzureBlobDataset, execute o cmdlet Set-AzDataFactoryV2Dataset.

   Set-AzDataFactoryV2Dataset -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -Name "AzureBlobDataset" -File ".\AzureBlobDataset.json"
   

   Veja o exemplo de saída:

   DatasetName       : AzureBlobDataset
   ResourceGroupName : <resourceGroupName>
   DataFactoryName   : <dataFactoryName>
   Structure         :
   Properties        : Microsoft.Azure.Management.DataFactory.Models.DelimitedTextDataset
   

Criar um pipeline

Nesta tutorial, você cria um pipeline com uma atividade de cópia. A atividade de cópia usa o SqlServerDataset como o conjunto de dados de entrada e o AzureBlobDataset como o conjunto de dados de saída. O tipo de fonte está definido como SqlSource, e o tipo de coletor está definido como BlobSink.

1. Crie um arquivo JSON denominado SqlServerToBlobPipeline.json na pasta C:\ADFv2Tutorial com o seguinte código:

   {  
       "name":"SqlServerToBlobPipeline",
       "properties":{  
           "activities":[  
               {  
                   "name":"CopySqlServerToAzureBlobActivity",
                   "type":"Copy",
                   "dependsOn":[  
   
                   ],
                   "policy":{  
                       "timeout":"7.00:00:00",
                       "retry":0,
                       "retryIntervalInSeconds":30,
                       "secureOutput":false,
                       "secureInput":false
                   },
                   "userProperties":[  
   
                   ],
                   "typeProperties":{  
                       "source":{  
                           "type":"SqlServerSource"
                       },
                       "sink":{  
                           "type":"DelimitedTextSink",
                           "storeSettings":{  
                               "type":"AzureBlobStorageWriteSettings"
                           },
                           "formatSettings":{  
                               "type":"DelimitedTextWriteSettings",
                               "quoteAllText":true,
                               "fileExtension":".txt"
                           }
                       },
                       "enableStaging":false
                   },
                   "inputs":[  
                       {  
                           "referenceName":"SqlServerDataset",
                           "type":"DatasetReference"
                       }
                   ],
                   "outputs":[  
                       {  
                           "referenceName":"AzureBlobDataset",
                           "type":"DatasetReference"
                       }
                   ]
               }
           ],
           "annotations":[  
   
           ]
       }
   }
   

2. Para criar o pipeline SQLServerToBlobPipeline, execute o cmdlet Set-AzDataFactoryV2Pipeline.

   Set-AzDataFactoryV2Pipeline -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -Name "SQLServerToBlobPipeline" -File ".\SQLServerToBlobPipeline.json"
   

   Veja o exemplo de saída:

   PipelineName      : SQLServerToBlobPipeline
   ResourceGroupName : <resourceGroupName>
   DataFactoryName   : <dataFactoryName>
   Activities        : {CopySqlServerToAzureBlobActivity}
   Parameters        :  
   

Criar uma execução de pipeline

Inicie a execução de um pipeline para o pipeline SQLServerToBlobPipeline e capture a ID da execução de pipeline para monitoramento futuro.

$runId = Invoke-AzDataFactoryV2Pipeline -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -PipelineName 'SQLServerToBlobPipeline'

Monitorar a execução de pipeline

1. Para verificar continuamente o status de execução do pipeline SQLServerToBlobPipeline, execute o script a seguir no PowerShell e imprima o resultado final:

   while ($True) {
       $result = Get-AzDataFactoryV2ActivityRun -DataFactoryName $dataFactoryName -ResourceGroupName $resourceGroupName -PipelineRunId $runId -RunStartedAfter (Get-Date).AddMinutes(-30) -RunStartedBefore (Get-Date).AddMinutes(30)
   
       if (($result | Where-Object { $_.Status -eq "InProgress" } | Measure-Object).count -ne 0) {
           Write-Host "Pipeline run status: In Progress" -foregroundcolor "Yellow"
           Start-Sleep -Seconds 30
       }
       else {
           Write-Host "Pipeline 'SQLServerToBlobPipeline' run finished. Result:" -foregroundcolor "Yellow"
           $result
           break
       }
   }
   

   Aqui está a saída da execução de exemplo:

   ResourceGroupName    : <resourceGroupName>
   DataFactoryName      : <dataFactoryName>
   ActivityRunId        : 24af7cf6-efca-4a95-931d-067c5c921c25
   ActivityName         : CopySqlServerToAzureBlobActivity
   ActivityType         : Copy
   PipelineRunId        : 7b538846-fd4e-409c-99ef-2475329f5729
   PipelineName         : SQLServerToBlobPipeline
   Input                : {source, sink, enableStaging}
   Output               : {dataRead, dataWritten, filesWritten, sourcePeakConnections...}
   LinkedServiceName    :
   ActivityRunStart     : 9/11/2019 7:10:37 AM
   ActivityRunEnd       : 9/11/2019 7:10:58 AM
   DurationInMs         : 21094
   Status               : Succeeded
   Error                : {errorCode, message, failureType, target}
   AdditionalProperties : {[retryAttempt, ], [iterationHash, ], [userProperties, {}], [recoveryStatus, None]...}
   

2. Você pode obter a ID da execução de pipeline SQLServerToBlobPipeline e verificar o resultado detalhado da execução de atividade executando o seguinte comando:

   Write-Host "Pipeline 'SQLServerToBlobPipeline' run result:" -foregroundcolor "Yellow"
   ($result | Where-Object {$_.ActivityName -eq "CopySqlServerToAzureBlobActivity"}).Output.ToString()
   

   Aqui está a saída da execução de exemplo:

   {  
       "dataRead":36,
       "dataWritten":32,
       "filesWritten":1,
       "sourcePeakConnections":1,
       "sinkPeakConnections":1,
       "rowsRead":2,
       "rowsCopied":2,
       "copyDuration":18,
       "throughput":0.01,
       "errors":[  
   
       ],
       "effectiveIntegrationRuntime":"ADFTutorialIR",
       "usedParallelCopies":1,
       "executionDetails":[  
           {  
               "source":{  
                   "type":"SqlServer"
               },
               "sink":{  
                   "type":"AzureBlobStorage",
                   "region":"CentralUS"
               },
               "status":"Succeeded",
               "start":"2019-09-11T07:10:38.2342905Z",
               "duration":18,
               "usedParallelCopies":1,
               "detailedDurations":{  
                   "queuingDuration":6,
                   "timeToFirstByte":0,
                   "transferDuration":5
               }
           }
       ]
   }
   

Verificar a saída

O pipeline cria automaticamente a pasta de saída chamada fromonprem no contêiner de blobs adftutorial. Confirme que você vê o arquivo dbo.emp.txt na pasta de saída.

1. No portal do Azure, na janela de contêiner adftutorial, selecione Atualizar para ver a pasta de saída.

2. Selecione fromonprem na lista de pastas.

3. Confirme que você vê um arquivo com o nome dbo.emp.txt.

   

Conteúdo relacionado

O pipeline nesse exemplo copia dados de uma localização para outra no Armazenamento de Blobs do Azure. Você aprendeu a:

Para obter uma lista dos armazenamentos de dados com suporte pelo Data Factory, consulte armazenamentos de dados com suporte.

Para saber mais sobre copiar dados em massa de uma origem para um destino, avance para o tutorial a seguir: