Caricare dati in modo incrementale da database SQL di Azure a Archiviazione BLOB di Azure usando le informazioni sul rilevamento delle modifiche tramite PowerShell

APPLICABILE A: Azure Data Factory Azure Synapse Analytics

In questa esercitazione, crei una data factory di Azure con una pipeline che carica dati differenziali basati sulle informazioni di tracciamento delle modifiche nel database di origine di database SQL di Azure in un'archiviazione BLOB di Azure.

In questa esercitazione vengono completati i passaggi seguenti:

Panoramica

In una soluzione di integrazione dei dati il caricamento incrementale di dati dopo i caricamenti di dati iniziali è uno scenario ampiamente diffuso. In alcuni casi, i dati modificati entro un periodo di tempo nell'archivio dati di origine possono essere suddivisi facilmente, ad esempio con LastModifyTime e CreationTime. In alcuni casi, non esiste un modo esplicito per identificare i dati differenziali dall'ultima elaborazione dei dati. La tecnologia Rilevamento modifiche supportata dagli archivi dati, ad esempio database SQL di Azure e SQL Server, può essere usata per identificare i dati delta. Questa esercitazione descrive come usare Azure Data Factory con la tecnologia SQL Change Tracking per caricare in modo incrementale i dati delta da database SQL di Azure in Archiviazione BLOB di Azure. Per informazioni più concrete sulla tecnologia rilevamento modifiche SQL, vedere Change tracking in SQL Server.

Flusso di lavoro completo

Ecco alcuni passaggi del tipico flusso di lavoro end-to-end per caricare dati in modo incrementale usando la tecnologia Rilevamento modifiche.

1. Caricamento iniziale dei dati cronologici (esecuzione una sola volta):
   1. Abilitare la tecnologia Rilevamento modifiche nel database di origine in database SQL di Azure.
   2. Ottenere il valore iniziale di SYS_CHANGE_VERSION nel database come base per acquisire i dati modificati.
   3. Caricare dati completi dal database di origine in un archivio BLOB Azure.
2. Caricamento incrementale dei dati differenziali in base a una pianificazione (eseguito periodicamente dopo il caricamento iniziale dei dati):
   1. Ottieni i valori precedenti e nuovi di SYS_CHANGE_VERSION.
   2. Caricare i dati delta unendo le chiavi primarie delle righe modificate (tra due valori di SYS_CHANGE_VERSION) da sys.change_tracking_tables con i dati nella tabella di origine e quindi trasferire i dati delta nella destinazione.
   3. Aggiornare SYS_CHANGE_VERSION per il successivo caricamento differenziale.

Soluzione di alto livello

In questa esercitazione vengono create due pipeline che eseguono le due operazioni seguenti:

1. Initial load: si crea una pipeline con un'attività di copia che copia l'intero dati dall'archivio dati di origine (database SQL di Azure) all'archivio dati di destinazione (Archiviazione BLOB di Azure).

   

2. Caricamento incrementale: viene creata una pipeline con le attività seguenti, eseguita periodicamente.

   1. Creare due attività di ricerca per ottenere il SYS_CHANGE_VERSION precedente e nuovo da database SQL di Azure e passarlo all'attività di copia.
   2. Creare one attività di copia per copiare i dati inseriti/aggiornati/eliminati tra i due valori SYS_CHANGE_VERSION da database SQL di Azure a Archiviazione BLOB di Azure.
   3. Creare un'attività di stored procedure per aggiornare il valore di SYS_CHANGE_VERSION per la successiva esecuzione della pipeline.

   

Se non si ha una sottoscrizione Azure, creare un account free prima di iniziare.

Prerequisiti

• Azure PowerShell. Installare i moduli di Azure PowerShell più recenti seguendo le istruzioni riportate in Come installare e configurare Azure PowerShell.
• database SQL di Azure. Usare il database come archivio dati di origine. Se non si dispone di un database in database SQL di Azure, vedere l'articolo Creare un database in database SQL di Azure per la procedura per crearne uno.
• Archiviazione di Azure account. Usare l'archivio BLOB come archivio dati sink. Se non si ha un account di archiviazione Azure, vedere l'articolo Creare un account di archiviazione per la procedura per crearne uno. Creare un contenitore denominato adftutorial.

Creare una tabella di origine dati nel database

1. Avviare SQL Server Management Studio e connettersi al database SQL.

2. In Esplora server fare clic con il pulsante destro del mouse sul database e scegliere Nuova query.

3. Eseguire questo comando SQL sul database per creare una tabella denominata data_source_table come archivio dell'origine dati.

   create table data_source_table
   (
       PersonID int NOT NULL,
       Name varchar(255),
       Age int
       PRIMARY KEY (PersonID)
   );
   
   INSERT INTO data_source_table
       (PersonID, Name, Age)
   VALUES
       (1, 'aaaa', 21),
       (2, 'bbbb', 24),
       (3, 'cccc', 20),
       (4, 'dddd', 26),
       (5, 'eeee', 22);
   
   

4. Abilitare il meccanismo Rilevamento modifiche nel database e nella tabella di origine (data_source_table) eseguendo la query SQL seguente:

   Nota

   • Sostituire <your database name> con il nome del database che include data_source_table.
   • Nell'esempio corrente i dati modificati vengono mantenuti per due giorni. Se i dati modificati vengono caricati ogni tre giorni o più, alcuni non verranno inclusi. In questo caso, è necessario modificare il valore di CHANGE_RETENTION impostando un numero maggiore. In alternativa, assicurarsi che il periodo per il caricamento dei dati modificati sia non più di due giorni. Per altre informazioni, vedere Abilitare il rilevamento delle modifiche per un database

   ALTER DATABASE <your database name>
   SET CHANGE_TRACKING = ON  
   (CHANGE_RETENTION = 2 DAYS, AUTO_CLEANUP = ON)  
   
   ALTER TABLE data_source_table
   ENABLE CHANGE_TRACKING  
   WITH (TRACK_COLUMNS_UPDATED = ON)
   

5. Creare una nuova tabella e archiviare ChangeTracking_version con un valore predefinito eseguendo la query seguente:

   create table table_store_ChangeTracking_version
   (
       TableName varchar(255),
       SYS_CHANGE_VERSION BIGINT,
   );
   
   DECLARE @ChangeTracking_version BIGINT
   SET @ChangeTracking_version = CHANGE_TRACKING_CURRENT_VERSION();  
   
   INSERT INTO table_store_ChangeTracking_version
   VALUES ('data_source_table', @ChangeTracking_version)
   

   Nota

   Se i dati non vengono modificati dopo aver abilitato il rilevamento delle modifiche per il database SQL, il valore della versione di rilevamento delle modifiche è 0.

6. Eseguire la query seguente per creare una procedura memorizzata nel database. La pipeline richiama questa procedura memorizzata per aggiornare la versione di rilevamento delle modifiche nella tabella creata nel passaggio precedente.

   CREATE PROCEDURE Update_ChangeTracking_Version @CurrentTrackingVersion BIGINT, @TableName varchar(50)
   AS
   
   BEGIN
   
   UPDATE table_store_ChangeTracking_version
   SET [SYS_CHANGE_VERSION] = @CurrentTrackingVersion
   WHERE [TableName] = @TableName
   
   END    
   

Azure PowerShell

Installare i moduli di Azure PowerShell più recenti seguendo le istruzioni riportate in Come installare e configurare Azure PowerShell.

Creare una data factory

1. Definire una variabile per il nome del gruppo di risorse usato in seguito nei comandi di PowerShell. Copiare il testo del comando seguente in PowerShell, specificare un nome per il gruppo di risorse Azure tra virgolette doppie e quindi eseguire il comando . Ad esempio: "adfrg".

   $resourceGroupName = "ADFTutorialResourceGroup";
   

   Se il gruppo di risorse esiste già, potrebbe essere preferibile non sovrascriverlo. Assegnare un valore diverso alla variabile $resourceGroupName ed eseguire di nuovo il comando.

2. Definire una variabile per la località della data factory:

   $location = "East US"
   

3. Per creare il gruppo di risorse Azure, eseguire il comando seguente:

   New-AzResourceGroup $resourceGroupName $location
   

   Se il gruppo di risorse esiste già, potrebbe essere preferibile non sovrascriverlo. Assegnare un valore diverso alla variabile $resourceGroupName ed eseguire di nuovo il comando.

4. Definire una variabile per il nome della data factory.

   Importante

   Aggiornare il nome della data factory in modo che sia univoco a livello globale.

   $dataFactoryName = "IncCopyChgTrackingDF";
   

5. Per creare la data factory, eseguire questo cmdlet Set-AzDataFactoryV2:

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

Notare i punti seguenti:

• Il nome della data factory Azure deve essere univoco a livello globale. Se viene visualizzato l'errore seguente, modificare il nome e riprovare.

  The specified Data Factory name 'ADFIncCopyChangeTrackingTestFactory' is already in use. Data Factory names must be globally unique.
  

• Per creare istanze di Data Factory, l'account utente usato per accedere a Azure deve essere membro di ruoli contributor o owner o di un amministratore della sottoscrizione Azure.

• Per un elenco di aree Azure in cui Data Factory è attualmente disponibile, selezionare le aree a cui si è interessati nella pagina seguente e quindi espandere Analytics per individuare Data Factory: Products disponibile in base all'area. Gli archivi dati (Archiviazione di Azure, database SQL di Azure e così via) e i calcoli (HDInsight e così via) usati dalla data factory possono trovarsi in altre aree.

Creare servizi collegati

Si creano servizi collegati in una data factory per collegare gli archivi dati e i servizi di calcolo alla data factory. In questa sezione vengono creati servizi collegati all'account Archiviazione di Azure e al database in database SQL di Azure.

Creare servizio collegato ad Archiviazione di Azure.

In questo passaggio si collega l'account Archiviazione di Azure alla data factory.

1. Creare un file JSON denominato AzureStorageLinkedService.json nella cartella C:\ADFTutorials\IncCopyChangeTrackingTutorial con il contenuto seguente. Creare la cartella se non esiste già. Sostituire <accountName>, <accountKey> con il nome e la chiave dell'account di archiviazione Azure prima di salvare il file.

   {
       "name": "AzureStorageLinkedService",
       "properties": {
           "type": "AzureStorage",
           "typeProperties": {
               "connectionString": "DefaultEndpointsProtocol=https;AccountName=<accountName>;AccountKey=<accountKey>"
           }
       }
   }
   

2. In Azure PowerShell passare alla cartella C:\ADFTutorials\IncCopyChangeTrackingTutorial.

3. Eseguire il cmdlet Set-AzDataFactoryV2LinkedService per creare il servizio collegato AzureStorageLinkedService. Nell'esempio seguente si passano i valori per i parametri ResourceGroupName e DataFactoryName.

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

   Di seguito è riportato l'output di esempio:

   LinkedServiceName : AzureStorageLinkedService
   ResourceGroupName : ADFTutorialResourceGroup
   DataFactoryName   : IncCopyChgTrackingDF
   Properties        : Microsoft.Azure.Management.DataFactory.Models.AzureStorageLinkedService
   

Creare un servizio collegato di database SQL di Azure.

In questo passaggio si collega il database alla data factory.

1. Creare un file JSON denominato AzureSQLDatabaseLinkedService.json nella cartella C:\ADFTutorials\IncCopyChangeTrackingTutorial con il contenuto seguente: Sostituire <your-server-name> e <your-database-name> con il nome del server e del database prima di salvare il file. È anche necessario configurare l'SQL Server di Azure per concedere l'accesso all'identità gestita della data factory.

   {
   "name": "AzureSqlDatabaseLinkedService",
   "properties": {
           "type": "AzureSqlDatabase",
           "typeProperties": {
               "connectionString": "Server=tcp:<your-server-name>.database.windows.net,1433;Database=<your-database-name>;"
           },
           "authenticationType": "ManagedIdentity",
           "annotations": []
       }
   }
   

2. In Azure PowerShell eseguire il cmdlet Set-AzDataFactoryV2LinkedService per creare il servizio collegato: AzureSQLDatabaseLinkedService.

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

   Di seguito è riportato l'output di esempio:

   LinkedServiceName : AzureSQLDatabaseLinkedService
   ResourceGroupName : ADFTutorialResourceGroup
   DataFactoryName   : IncCopyChgTrackingDF
   Properties        : Microsoft.Azure.Management.DataFactory.Models.AzureSqlDatabaseLinkedService
   

Creare i set di dati

In questo passaggio vengono creati i set di dati per rappresentare l'origine dati, la destinazione dati e la posizione in cui archiviare SYS_CHANGE_VERSION.

Creare set di dati di origine

In questo passaggio viene creato un set di dati per rappresentare i dati di origine.

1. Creare un file JSON denominato SourceDataset.json nella stessa cartella con il contenuto seguente:

   {
       "name": "SourceDataset",
       "properties": {
           "type": "AzureSqlTable",
           "typeProperties": {
               "tableName": "data_source_table"
           },
           "linkedServiceName": {
               "referenceName": "AzureSQLDatabaseLinkedService",
               "type": "LinkedServiceReference"
           }
       }
   }   
   

2. Eseguire il cmdlet Set-AzDataFactoryV2Dataset per creare il set di dati: SourceDataset

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

   Ecco l'output di esempio del cmdlet:

   DatasetName       : SourceDataset
   ResourceGroupName : ADFTutorialResourceGroup
   DataFactoryName   : IncCopyChgTrackingDF
   Structure         :
   Properties        : Microsoft.Azure.Management.DataFactory.Models.AzureSqlTableDataset
   

Creare un set di dati sink

In questo passaggio viene creato un set di dati per rappresentare i dati copiati dall'archivio dati di origine.

1. Creare un file JSON denominato SinkDataset.json nella stessa cartella con il contenuto seguente:

   {
       "name": "SinkDataset",
       "properties": {
           "type": "AzureBlob",
           "typeProperties": {
               "folderPath": "adftutorial/incchgtracking",
               "fileName": "@CONCAT('Incremental-', pipeline().RunId, '.txt')",
               "format": {
                   "type": "TextFormat"
               }
           },
           "linkedServiceName": {
               "referenceName": "AzureStorageLinkedService",
               "type": "LinkedServiceReference"
           }
       }
   }
   

   Crea il contenitore adftutorial nel tuo Archiviazione BLOB di Azure come parte dei requisiti preliminari. Creare il contenitore se non esiste oppure impostare il nome di un contenitore esistente. In questa esercitazione il nome del file di output viene generato dinamicamente usando l'espressione : @CONCAT('Incremental-', pipeline(). RunId, '.txt').

2. Eseguire il cmdlet Set-AzDataFactoryV2Dataset per creare il set di dati: SinkDataset

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

   Ecco l'output di esempio del cmdlet:

   DatasetName       : SinkDataset
   ResourceGroupName : ADFTutorialResourceGroup
   DataFactoryName   : IncCopyChgTrackingDF
   Structure         :
   Properties        : Microsoft.Azure.Management.DataFactory.Models.AzureBlobDataset
   

Creare un set di dati di rilevamento delle modifiche

In questo passaggio viene creato un set di dati per l'archiviazione della versione di rilevamento delle modifiche.

1. Creare un file JSON denominato ChangeTrackingDataset.json nella stessa cartella con il contenuto seguente:

   {
       "name": " ChangeTrackingDataset",
       "properties": {
           "type": "AzureSqlTable",
           "typeProperties": {
               "tableName": "table_store_ChangeTracking_version"
           },
           "linkedServiceName": {
               "referenceName": "AzureSQLDatabaseLinkedService",
               "type": "LinkedServiceReference"
           }
       }
   }
   

   Come parte dei prerequisiti, crei la tabella table_store_ChangeTracking_version.

2. Eseguire il cmdlet Set-AzDataFactoryV2Dataset per creare il set di dati: ChangeTrackingDataset

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

   Ecco l'output di esempio del cmdlet:

   DatasetName       : ChangeTrackingDataset
   ResourceGroupName : ADFTutorialResourceGroup
   DataFactoryName   : IncCopyChgTrackingDF
   Structure         :
   Properties        : Microsoft.Azure.Management.DataFactory.Models.AzureSqlTableDataset
   

Creare una pipeline per la copia completa

In questo passaggio si crea una pipeline con un'attività di copia che copia tutti i dati dall'archivio dati di origine (database SQL di Azure) all'archivio dati di destinazione (Archiviazione BLOB di Azure).

1. Creare un file JSON denominato FullCopyPipeline.json nella stessa cartella con il contenuto seguente:

   {
       "name": "FullCopyPipeline",
       "properties": {
           "activities": [{
               "name": "FullCopyActivity",
               "type": "Copy",
               "typeProperties": {
                   "source": {
                       "type": "SqlSource"
                   },
                   "sink": {
                       "type": "BlobSink"
                   }
               },
   
               "inputs": [{
                   "referenceName": "SourceDataset",
                   "type": "DatasetReference"
               }],
               "outputs": [{
                   "referenceName": "SinkDataset",
                   "type": "DatasetReference"
               }]
           }]
       }
   }
   

2. Eseguire il cmdlet Set-AzDataFactoryV2Pipeline per creare la pipeline FullCopyPipeline.

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

   Di seguito è riportato l'output di esempio:

    PipelineName      : FullCopyPipeline
    ResourceGroupName : ADFTutorialResourceGroup
    DataFactoryName   : IncCopyChgTrackingDF
    Activities        : {FullCopyActivity}
    Parameters        :
   

Eseguire la pipeline di copia completa

Eseguire la pipeline: FullCopyPipeline utilizzando il cmdlet Invoke-AzDataFactoryV2Pipeline.

Invoke-AzDataFactoryV2Pipeline -PipelineName "FullCopyPipeline" -ResourceGroup $resourceGroupName -dataFactoryName $dataFactoryName        

Monitorare l'intera pipeline di copia

1. Accedere al portale di Azure.

2. Fare clic su Tutti i servizi, eseguire una ricerca con la parola chiave data factories e selezionare Data factory.

   

3. Cercare la propria data factory nell'elenco delle data factory e selezionarla per avviare la pagina Data factory.

   

4. Nella pagina Data factory fare clic sul riquadro Monitoraggio e gestione.

   

5. L'applicazione Integrazione dei dati viene avviata in una scheda separata. È possibile visualizzare tutte le esecuzioni della pipeline e i relativi stati. Notare che nell'esempio seguente lo stato dell'esecuzione della pipeline è Completato con successo. È possibile controllare i parametri passati alla pipeline facendo clic sul collegamento nella colonna Parametri. Se si è verificato un errore, verrà visualizzato un collegamento nella colonna Errore. Fare clic sul collegamento nella colonna Azioni.

   

6. Quando si fa clic sul collegamento nella colonna Azioni, viene visualizzata la pagina seguente, che mostra tutte le esecuzioni di attività per la pipeline.

   

7. Per tornare alla visualizzazione Esecuzioni di pipeline, fare clic su Pipeline, come mostrato nell'immagine.

Esaminare i risultati

Viene visualizzato un file denominato incremental-<GUID>.txt nella cartella incchgtracking del contenitore adftutorial.

Il file conterrà i dati del database:

1,aaaa,21
2,bbbb,24
3,cccc,20
4,dddd,26
5,eeee,22

Aggiungere altri dati alla tabella di origine

Esegui la seguente query sul tuo database per aggiungere e aggiornare una riga.

INSERT INTO data_source_table
(PersonID, Name, Age)
VALUES
(6, 'new','50');


UPDATE data_source_table
SET [Age] = '10', [name]='update' where [PersonID] = 1

Creare una pipeline per la copia differenziale

In questo passaggio viene creata una pipeline con le attività seguenti, eseguita periodicamente. Le attività lookup ottengono le versioni SYS_CHANGE_VERSION precedenti e nuove da database SQL di Azure e passarle all'attività di copia. L'attività copy copia i dati inseriti/aggiornati/eliminati tra i due valori SYS_CHANGE_VERSION da database SQL di Azure a Archiviazione BLOB di Azure. L'attività di stored procedure aggiorna il valore di SYS_CHANGE_VERSION per la successiva esecuzione della pipeline.

1. Creare un file JSON denominato IncrementalCopyPipeline.json nella stessa cartella con il contenuto seguente:

   {
       "name": "IncrementalCopyPipeline",
       "properties": {
           "activities": [
               {
                   "name": "LookupLastChangeTrackingVersionActivity",
                   "type": "Lookup",
                   "typeProperties": {
                       "source": {
                           "type": "SqlSource",
                           "sqlReaderQuery": "select * from table_store_ChangeTracking_version"
                       },
                       "dataset": {
                           "referenceName": "ChangeTrackingDataset",
                           "type": "DatasetReference"
                       }
                   }
               },
               {
                   "name": "LookupCurrentChangeTrackingVersionActivity",
                   "type": "Lookup",
                   "typeProperties": {
                       "source": {
                           "type": "SqlSource",
                           "sqlReaderQuery": "SELECT CHANGE_TRACKING_CURRENT_VERSION() as CurrentChangeTrackingVersion"
                       },
                       "dataset": {
                           "referenceName": "SourceDataset",
                           "type": "DatasetReference"
                       }
                   }
               },
               {
                   "name": "IncrementalCopyActivity",
                   "type": "Copy",
                   "typeProperties": {
                       "source": {
                           "type": "SqlSource",
                           "sqlReaderQuery": "select data_source_table.PersonID,data_source_table.Name,data_source_table.Age, CT.SYS_CHANGE_VERSION, SYS_CHANGE_OPERATION from data_source_table RIGHT OUTER JOIN CHANGETABLE(CHANGES data_source_table, @{activity('LookupLastChangeTrackingVersionActivity').output.firstRow.SYS_CHANGE_VERSION}) as CT on data_source_table.PersonID = CT.PersonID where CT.SYS_CHANGE_VERSION <= @{activity('LookupCurrentChangeTrackingVersionActivity').output.firstRow.CurrentChangeTrackingVersion}"
                       },
                       "sink": {
                           "type": "BlobSink"
                       }
                   },
                   "dependsOn": [
                       {
                           "activity": "LookupLastChangeTrackingVersionActivity",
                           "dependencyConditions": [
                               "Succeeded"
                           ]
                       },
                       {
                           "activity": "LookupCurrentChangeTrackingVersionActivity",
                           "dependencyConditions": [
                               "Succeeded"
                           ]
                       }
                   ],
                   "inputs": [
                       {
                           "referenceName": "SourceDataset",
                           "type": "DatasetReference"
                       }
                   ],
                   "outputs": [
                       {
                           "referenceName": "SinkDataset",
                           "type": "DatasetReference"
                       }
                   ]
               },
               {
                   "name": "StoredProceduretoUpdateChangeTrackingActivity",
                   "type": "SqlServerStoredProcedure",
                   "typeProperties": {
                       "storedProcedureName": "Update_ChangeTracking_Version",
                       "storedProcedureParameters": {
                           "CurrentTrackingVersion": {
                               "value": "@{activity('LookupCurrentChangeTrackingVersionActivity').output.firstRow.CurrentChangeTrackingVersion}",
                               "type": "INT64"
                           },
                           "TableName": {
                               "value": "@{activity('LookupLastChangeTrackingVersionActivity').output.firstRow.TableName}",
                               "type": "String"
                           }
                       }
                   },
                   "linkedServiceName": {
                       "referenceName": "AzureSQLDatabaseLinkedService",
                       "type": "LinkedServiceReference"
                   },
                   "dependsOn": [
                       {
                           "activity": "IncrementalCopyActivity",
                           "dependencyConditions": [
                               "Succeeded"
                           ]
                       }
                   ]
               }
           ]
       }
   }
   

2. Eseguire il cmdlet Set-AzDataFactoryV2Pipeline per creare la pipeline FullCopyPipeline.

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

   Di seguito è riportato l'output di esempio:

    PipelineName      : IncrementalCopyPipeline
    ResourceGroupName : ADFTutorialResourceGroup
    DataFactoryName   : IncCopyChgTrackingDF
    Activities        : {LookupLastChangeTrackingVersionActivity, LookupCurrentChangeTrackingVersionActivity, IncrementalCopyActivity, StoredProceduretoUpdateChangeTrackingActivity}
    Parameters        :
   

Eseguire la pipeline di copia incrementale

Eseguire la pipeline: IncrementalCopyPipeline usando il cmdlet Invoke-AzDataFactoryV2Pipeline.

Invoke-AzDataFactoryV2Pipeline -PipelineName "IncrementalCopyPipeline" -ResourceGroup $resourceGroupName -dataFactoryName $dataFactoryName     

Monitorare la pipeline di copia incrementale

1. Nell'applicazione Integrazione dati, aggiorna la visualizzazione delle esecuzioni di pipeline. Verificare che la pipeline IncrementalCopyPipeline sia visualizzata nell'elenco. Fare clic sul collegamento nella colonna Azioni.

   

2. Quando si fa clic sul collegamento nella colonna Azioni, viene visualizzata la pagina seguente, che mostra tutte le esecuzioni di attività per la pipeline.

   

3. Per tornare alla visualizzazione Esecuzioni di pipeline, fare clic su Pipeline, come mostrato nell'immagine.

Esaminare i risultati

Il secondo file viene visualizzato nella cartella incchgtracking del contenitore adftutorial.

Il file conterrà solo i dati differenziali del database. Il record con U è la riga aggiornata nel database e I è la riga aggiunta.

1,update,10,2,U
6,new,50,1,I

Le prime tre colonne sono i dati modificati da data_source_table. Le ultime due colonne sono i metadati dalla tabella di sistema del rilevamento delle modifiche. La quarta colonna è SYS_CHANGE_VERSION per ogni riga modificata. La quinta colonna è l'operazione: U = aggiornamento, I = inserimento. Per tutti i dettagli sulle informazioni di rilevamento delle modifiche, vedere CHANGETABLE.

==================================================================
PersonID Name    Age    SYS_CHANGE_VERSION    SYS_CHANGE_OPERATION
==================================================================
1        update  10            2                                 U
6        new     50            1                                 I

Contenuto correlato

Passare all'esercitazione successiva per copiare file nuovi o modificati solo in base a "LastModifiedDate":