Copiare dati da BLOB Azure a database SQL di Azure usando Azure Data Factory

APPLICABILE A: Azure Data Factory Azure Synapse Analytics

Suggerimento

Data Factory in Microsoft Fabric è la nuova generazione di Azure Data Factory, con un'architettura più semplice, un'intelligenza artificiale predefinita e nuove funzionalità. Se non si ha familiarità con l'integrazione dei dati, iniziare con Fabric Data Factory. I carichi di lavoro di Azure Data Factory esistenti possono eseguire l'aggiornamento a Fabric per accedere a nuove funzionalità tra data science, analisi in tempo reale e creazione di report.

In questa esercitazione viene creata una pipeline di Data Factory che copia i dati da Archiviazione BLOB di Azure a database SQL di Azure. Il modello di configurazione di questa esercitazione si applica alla copia da un archivio dati basato su file a un archivio dati relazionale. Per un elenco degli archivi dati supportati come origini e destinazioni, vedere archivi dati e formati supportati.

In questa esercitazione vengono completati i passaggi seguenti:

Creare una fabbrica di dati.
Creare Archiviazione di Azure e database SQL di Azure servizi collegati.
Creare set di dati Azure BLOB e database SQL di Azure.
Creare una pipeline che contiene un'attività di copia.
Avviare un'esecuzione della pipeline.
Monitora le esecuzioni delle pipeline e delle attività.

Questa esercitazione usa .NET SDK. È possibile usare altri meccanismi per interagire con Azure Data Factory. Vedere gli esempi in Quickstarts.

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

Prerequisiti

Archiviazione di Azure account. Usi l'archivio BLOB come archivio dati di origine. Se non si ha un account di archiviazione Azure, vedere Creare un account di archiviazione per utilizzo generico.
database SQL di Azure. Usare il database come archivio dati sink. Se non si dispone di un database in database SQL di Azure, vedere Creare un database in database SQL di Azure.
Visual Studio. La procedura dettagliata in questo articolo usa Visual Studio 2019.
Azure SDK per .NET.
applicazione Microsoft Entra. Se non si dispone di un'applicazione Microsoft Entra, vedere la sezione Creare un'applicazione Microsoft Entra di Come: Usare il portale per creare un'applicazione Microsoft Entra. Copiare i valori seguenti da usare nei passaggi successivi: ID applicazione (client), chiave di autenticazione e ID directory (tenant). Assegnare l'applicazione al ruolo Collaboratore seguendo le istruzioni disponibili nello stesso articolo.

Creare un BLOB e una tabella SQL

Preparare ora Azure Blob e database SQL di Azure per il tutorial creando un Blob di origine e una tabella di destinazione SQL.

Creare un BLOB di origine

Prima di tutto, creare un BLOB di origine creando un contenitore e caricando al suo interno un file di testo di input:

Apri il Blocco note. Copiare il testo seguente e salvarlo in locale in un file denominato inputEmp.txt.
```
John|Doe
Jane|Doe
```
Usare uno strumento come Azure Storage Explorer per creare il contenitore adfv2tutorial e caricare il file inputEmp.txt nel contenitore.

Creare una tabella SQL sink

Quindi, crea una tabella SQL di "sink":

Usare lo script SQL seguente per creare la tabella dbo.emp nel database SQL di Azure.

CREATE TABLE dbo.emp
(
    ID int IDENTITY(1,1) NOT NULL,
    FirstName varchar(50),
    LastName varchar(50)
)
GO

CREATE CLUSTERED INDEX IX_emp_ID ON dbo.emp (ID);

Consentire ai servizi di Azure di accedere al database SQL. Assicurarsi di consentire l'accesso ai servizi di Azure nel server in modo che il servizio Data Factory possa scrivere dati nel database SQL. Per verificare e attivare l'impostazione, seguire questa procedura:
1. Passare al portale Azure per gestire SQL Server. Cercare e selezionare Server SQL.
2. Selezionare il server.
3. Nell'intestazione Sicurezza menu del server SQL selezionare Firewall e reti virtuali.
4. Nella pagina Firewall e reti virtuali, in Allow Azure services and resources to access this server selezionare ON.

Creare un progetto Visual Studio

Usando Visual Studio, creare un'applicazione console C# .NET.

Apri Visual Studio.
Nella finestra iniziale selezionare Crea un nuovo progetto.
Nella finestra Creare un nuovo progetto finestra scegliere la versione C# di Console App (.NET Framework) dall'elenco dei tipi di progetto. Quindi seleziona Avanti.
Nella finestra Configurare la nuova finestra di project immettere un nome Project di ADFv2Tutorial. Per Percorso, individuare e/o creare la directory in cui salvare il progetto. Selezionare Crea. Il nuovo progetto viene visualizzato nella IDE di Visual Studio.

Installare i pacchetti NuGet

Installare quindi i pacchetti di libreria necessari usando Gestione pacchetti NuGet.

Nella barra dei menu scegliere Tools>NuGet Gestione pacchetti>Gestione pacchetti Console.
Nel riquadro Gestione pacchetti Console eseguire i comandi seguenti per installare i pacchetti. Per informazioni sul pacchetto NuGet Azure Data Factory, vedere Microsoft.Azure. Management.DataFactory.
```
Install-Package Microsoft.Azure.Management.DataFactory
Install-Package Microsoft.Azure.Management.ResourceManager -PreRelease
Install-Package Microsoft.IdentityModel.Clients.ActiveDirectory
```

Creare un client di Data Factory

Per creare un client di data factory, seguire questa procedura.

Aprire Program.cs, quindi sovrascrivere le istruzioni esistenti using con il codice seguente per aggiungere i riferimenti ai namespace.

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Rest;
using Microsoft.Rest.Serialization;
using Microsoft.Azure.Management.ResourceManager;
using Microsoft.Azure.Management.DataFactory;
using Microsoft.Azure.Management.DataFactory.Models;
using Microsoft.IdentityModel.Clients.ActiveDirectory;

Aggiungere il codice seguente al metodo Main per impostare le variabili. Sostituire i 14 segnaposto con i valori personalizzati.

Per visualizzare l'elenco delle aree Azure in cui Data Factory è attualmente disponibile, vedere Products disponibile in base all'area. Nell'elenco a discesa Prodotti scegliere Esplora>Analisi>Data Factory. Quindi nell'elenco a discesa Aree selezionare le aree a cui si è interessati. Verrà visualizzata una griglia con lo stato di disponibilità dei prodotti Data Factory per le aree selezionate.

Nota

Gli archivi dati, ad esempio Archiviazione di Azure e database SQL di Azure, e le risorse di calcolo, ad esempio HDInsight, che Data Factory usa possono trovarsi in altre aree rispetto a quelle scelte per Data Factory.

// Set variables
string tenantID = "<your tenant ID>";
string applicationId = "<your application ID>";
string authenticationKey = "<your authentication key for the application>";
string subscriptionId = "<your subscription ID to create the factory>";
string resourceGroup = "<your resource group to create the factory>";

string region = "<location to create the data factory in, such as East US>";
string dataFactoryName = "<name of data factory to create (must be globally unique)>";

// Specify the source Azure Blob information
string storageAccount = "<your storage account name to copy data>";
string storageKey = "<your storage account key>";
string inputBlobPath = "adfv2tutorial/";
string inputBlobName = "inputEmp.txt";

// Specify the sink Azure SQL Database information
string azureSqlConnString =
    "Server=tcp:<your server name>.database.windows.net,1433;" +
    "Database=<your database name>;" +
    "User ID=<your username>@<your server name>;" +
    "Password=<your password>;" +
    "Trusted_Connection=False;Encrypt=True;Connection Timeout=30";
string azureSqlTableName = "dbo.emp";

string storageLinkedServiceName = "AzureStorageLinkedService";
string sqlDbLinkedServiceName = "AzureSqlDbLinkedService";
string blobDatasetName = "BlobDataset";
string sqlDatasetName = "SqlDataset";
string pipelineName = "Adfv2TutorialBlobToSqlCopy";

Aggiungere il codice seguente al metodo Main per creare un'istanza della classe DataFactoryManagementClient. Usi questo oggetto per creare una data factory, un servizio collegato, dei set di dati e una pipeline. È possibile usare questo oggetto anche per monitorare i dettagli sull'esecuzione della pipeline.

// Authenticate and create a data factory management client
var context = new AuthenticationContext("https://login.windows.net/" + tenantID);
ClientCredential cc = new ClientCredential(applicationId, authenticationKey);
AuthenticationResult result = context.AcquireTokenAsync(
    "https://management.azure.com/", cc
).Result;
ServiceClientCredentials cred = new TokenCredentials(result.AccessToken);
var client = new DataFactoryManagementClient(cred) { SubscriptionId = subscriptionId };

Creare una data factory

Aggiungere il codice seguente al metodo Main per creare una data factory.

// Create a data factory
Console.WriteLine("Creating a data factory " + dataFactoryName + "...");
Factory dataFactory = new Factory
{
    Location = region,
    Identity = new FactoryIdentity()
};

client.Factories.CreateOrUpdate(resourceGroup, dataFactoryName, dataFactory);
Console.WriteLine(
    SafeJsonConvert.SerializeObject(dataFactory, client.SerializationSettings)
);

while (
    client.Factories.Get(
        resourceGroup, dataFactoryName
    ).ProvisioningState == "PendingCreation"
)
{
    System.Threading.Thread.Sleep(1000);
}

Creare servizi collegati

In questa esercitazione verranno creati due servizi collegati, rispettivamente per l'origine e il sink.

Creare un servizio collegato Archiviazione di Azure

Aggiungere il codice seguente al metodo Main che crea un servizio collegato Archiviazione di Azure. Per informazioni sulle proprietà e i dettagli supportati, vedere proprietà del servizio collegato Azure Blob.

// Create an Azure Storage linked service
Console.WriteLine("Creating linked service " + storageLinkedServiceName + "...");

LinkedServiceResource storageLinkedService = new LinkedServiceResource(
    new AzureStorageLinkedService
    {
        ConnectionString = new SecureString(
            "DefaultEndpointsProtocol=https;AccountName=" + storageAccount +
            ";AccountKey=" + storageKey
        )
    }
);

client.LinkedServices.CreateOrUpdate(
    resourceGroup, dataFactoryName, storageLinkedServiceName, storageLinkedService
);
Console.WriteLine(
    SafeJsonConvert.SerializeObject(storageLinkedService, client.SerializationSettings)
);

Creare un servizio di collegamento per database SQL di Azure

Aggiungere il codice seguente al metodo Main che crea un servizio collegato database SQL di Azure. Per informazioni sulle proprietà e sui dettagli supportati, vedere le proprietà del servizio collegato di database SQL di Azure.

// Create an Azure SQL Database linked service
Console.WriteLine("Creating linked service " + sqlDbLinkedServiceName + "...");

LinkedServiceResource sqlDbLinkedService = new LinkedServiceResource(
    new AzureSqlDatabaseLinkedService
    {
        ConnectionString = new SecureString(azureSqlConnString)
    }
);

client.LinkedServices.CreateOrUpdate(
    resourceGroup, dataFactoryName, sqlDbLinkedServiceName, sqlDbLinkedService
);
Console.WriteLine(
    SafeJsonConvert.SerializeObject(sqlDbLinkedService, client.SerializationSettings)
);

Creare i set di dati

In questa sezione vengono creati due set di dati: uno per l'origine e l'altro per il sink.

Creare un set di dati per l'origine Azure BLOB

Aggiungere il codice seguente al metodo Main che crea un set di dati BLOB Azure. Per informazioni sulle proprietà e i dettagli supportati, vedere proprietà del set di dati di Azure Blob.

Si definisce un set di dati che rappresenta i dati di origine in Azure BLOB. Questo set di dati BLOB fa riferimento al servizio collegato Archiviazione di Azure creato nel passaggio precedente e descrive:

Posizione del BLOB da cui eseguire la copia: FolderPath e FileName
Formato del BLOB che indica come analizzare il contenuto: TextFormat e relative impostazioni, ad esempio il delimitatore di colonna
La struttura dei dati, compresi i nomi delle colonne e i tipi di dati, che sono mappati in questo esempio alla tabella SQL di sink

// Create an Azure Blob dataset
Console.WriteLine("Creating dataset " + blobDatasetName + "...");
DatasetResource blobDataset = new DatasetResource(
    new AzureBlobDataset
    {
        LinkedServiceName = new LinkedServiceReference {
            ReferenceName = storageLinkedServiceName
        },
        FolderPath = inputBlobPath,
        FileName = inputBlobName,
        Format = new TextFormat { ColumnDelimiter = "|" },
        Structure = new List<DatasetDataElement>
        {
            new DatasetDataElement { Name = "FirstName", Type = "String" },
            new DatasetDataElement { Name = "LastName", Type = "String" }
        }
    }
);

client.Datasets.CreateOrUpdate(
    resourceGroup, dataFactoryName, blobDatasetName, blobDataset
);
Console.WriteLine(
    SafeJsonConvert.SerializeObject(blobDataset, client.SerializationSettings)
);

Creare un set di dati per database SQL di Azure sink

Aggiungere il codice seguente al metodo Main che crea un set di dati database SQL di Azure. Per informazioni sulle proprietà e i dettagli supportati, vedere database SQL di Azure proprietà del set di dati.

Si definisce un set di dati che rappresenta i dati sink in database SQL di Azure. Questo set di dati fa riferimento al servizio collegato database SQL di Azure creato nel passaggio precedente. e specifica anche la tabella SQL contenente i dati copiati.

// Create an Azure SQL Database dataset
Console.WriteLine("Creating dataset " + sqlDatasetName + "...");
DatasetResource sqlDataset = new DatasetResource(
    new AzureSqlTableDataset
    {
        LinkedServiceName = new LinkedServiceReference
        {
            ReferenceName = sqlDbLinkedServiceName
        },
        TableName = azureSqlTableName
    }
);

client.Datasets.CreateOrUpdate(
    resourceGroup, dataFactoryName, sqlDatasetName, sqlDataset
);
Console.WriteLine(
    SafeJsonConvert.SerializeObject(sqlDataset, client.SerializationSettings)
);

Creare una pipeline

Aggiungere il codice seguente al metodo Main per creare una pipeline con un'attività di copia. In questa esercitazione la pipeline contiene solo un'attività, CopyActivity, che usa il set di dati del BLOB come origine e il set di dati SQL come sink. Per informazioni dettagliate sui copy activity, vedere attività Copy in Azure Data Factory.

// Create a pipeline with copy activity
Console.WriteLine("Creating pipeline " + pipelineName + "...");
PipelineResource pipeline = new PipelineResource
{
    Activities = new List<Activity>
    {
        new CopyActivity
        {
            Name = "CopyFromBlobToSQL",
            Inputs = new List<DatasetReference>
            {
                new DatasetReference() { ReferenceName = blobDatasetName }
            },
            Outputs = new List<DatasetReference>
            {
                new DatasetReference { ReferenceName = sqlDatasetName }
            },
            Source = new BlobSource { },
            Sink = new SqlSink { }
        }
    }
};

client.Pipelines.CreateOrUpdate(resourceGroup, dataFactoryName, pipelineName, pipeline);
Console.WriteLine(
    SafeJsonConvert.SerializeObject(pipeline, client.SerializationSettings)
);

Creare un'esecuzione della pipeline

Aggiungere il codice seguente al metodo Main per attivare un'esecuzione della pipeline.

// Create a pipeline run
Console.WriteLine("Creating pipeline run...");
CreateRunResponse runResponse = client.Pipelines.CreateRunWithHttpMessagesAsync(
    resourceGroup, dataFactoryName, pipelineName
).Result.Body;
Console.WriteLine("Pipeline run ID: " + runResponse.RunId);

Monitorare un'esecuzione della pipeline

A questo punto, inserire il codice per controllare gli stati di esecuzione della pipeline e per ottenere i dettagli sull'esecuzione dell'attività di copia.

Aggiungere il codice seguente al metodo Main per controllare continuamente gli stati dell'esecuzione della pipeline fino al termine della copia dei dati.

// Monitor the pipeline run
Console.WriteLine("Checking pipeline run status...");
PipelineRun pipelineRun;
while (true)
{
    pipelineRun = client.PipelineRuns.Get(
        resourceGroup, dataFactoryName, runResponse.RunId
    );
    Console.WriteLine("Status: " + pipelineRun.Status);
    if (pipelineRun.Status == "InProgress")
        System.Threading.Thread.Sleep(15000);
    else
        break;
}

Aggiungere il codice seguente al metodo Main per recuperare i dettagli dell'esecuzione dell'attività di copia, ad esempio le dimensioni dei dati letti o scritti.

// Check the copy activity run details
Console.WriteLine("Checking copy activity run details...");

RunFilterParameters filterParams = new RunFilterParameters(
    DateTime.UtcNow.AddMinutes(-10), DateTime.UtcNow.AddMinutes(10)
);

ActivityRunsQueryResponse queryResponse = client.ActivityRuns.QueryByPipelineRun(
    resourceGroup, dataFactoryName, runResponse.RunId, filterParams
);

if (pipelineRun.Status == "Succeeded")
{
    Console.WriteLine(queryResponse.Value.First().Output);
}
else
    Console.WriteLine(queryResponse.Value.First().Error);

Console.WriteLine("\nPress any key to exit...");
Console.ReadKey();

Eseguire il codice

Per compilare l'applicazione scegliere Compila>Compila soluzione. Avviare quindi l'applicazione e scegliere Debug>Avvia debug e verificare l'esecuzione della pipeline.

La console stampa lo stato di avanzamento della creazione di una data factory, del servizio collegato, dei set di dati, della pipeline e della relativa esecuzione. Controlla quindi lo stato di esecuzione della pipeline. Attendere fino a quando vengono visualizzati i dettagli sull'esecuzione dell'attività di copia con le dimensioni dei dati letti/scritti. Usando quindi strumenti come SQL Server Management Studio (SSMS) o Visual Studio, è possibile connettersi al database SQL di Azure di destinazione e verificare se la tabella di destinazione specificata contiene i dati copiati.

Output di esempio

Creating a data factory AdfV2Tutorial...
{
  "identity": {
    "type": "SystemAssigned"
  },
  "location": "East US"
}
Creating linked service AzureStorageLinkedService...
{
  "properties": {
    "type": "AzureStorage",
    "typeProperties": {
      "connectionString": {
        "type": "SecureString",
        "value": "DefaultEndpointsProtocol=https;AccountName=<accountName>;AccountKey=<accountKey>"
      }
    }
  }
}
Creating linked service AzureSqlDbLinkedService...
{
  "properties": {
    "type": "AzureSqlDatabase",
    "typeProperties": {
      "connectionString": {
        "type": "SecureString",
        "value": "Server=tcp:<servername>.database.windows.net,1433;Database=<databasename>;User ID=<username>@<servername>;Password=<password>;Trusted_Connection=False;Encrypt=True;Connection Timeout=30"
      }
    }
  }
}
Creating dataset BlobDataset...
{
  "properties": {
    "type": "AzureBlob",
    "typeProperties": {
      "folderPath": "adfv2tutorial/",
      "fileName": "inputEmp.txt",
      "format": {
        "type": "TextFormat",
        "columnDelimiter": "|"
      }
    },
    "structure": [
      {
        "name": "FirstName",
        "type": "String"
      },
      {
        "name": "LastName",
        "type": "String"
      }
    ],
    "linkedServiceName": {
      "type": "LinkedServiceReference",
      "referenceName": "AzureStorageLinkedService"
    }
  }
}
Creating dataset SqlDataset...
{
  "properties": {
    "type": "AzureSqlTable",
    "typeProperties": {
      "tableName": "dbo.emp"
    },
    "linkedServiceName": {
      "type": "LinkedServiceReference",
      "referenceName": "AzureSqlDbLinkedService"
    }
  }
}
Creating pipeline Adfv2TutorialBlobToSqlCopy...
{
  "properties": {
    "activities": [
      {
        "type": "Copy",
        "typeProperties": {
          "source": {
            "type": "BlobSource"
          },
          "sink": {
            "type": "SqlSink"
          }
        },
        "inputs": [
          {
            "type": "DatasetReference",
            "referenceName": "BlobDataset"
          }
        ],
        "outputs": [
          {
            "type": "DatasetReference",
            "referenceName": "SqlDataset"
          }
        ],
        "name": "CopyFromBlobToSQL"
      }
    ]
  }
}
Creating pipeline run...
Pipeline run ID: 1cd03653-88a0-4c90-aabc-ae12d843e252
Checking pipeline run status...
Status: InProgress
Status: InProgress
Status: Succeeded
Checking copy activity run details...
{
  "dataRead": 18,
  "dataWritten": 28,
  "rowsCopied": 2,
  "copyDuration": 2,
  "throughput": 0.01,
  "errors": [],
  "effectiveIntegrationRuntime": "DefaultIntegrationRuntime (East US)",
  "usedDataIntegrationUnits": 2,
  "billedDuration": 2
}

Press any key to exit...

La pipeline in questo esempio copia i dati da una posizione a un'altra in un archivio BLOB Azure. Hai imparato come:

Creare una fabbrica di dati.
Creare Archiviazione di Azure e database SQL di Azure servizi collegati.
Creare set di dati Azure BLOB e database SQL di Azure.
Creare una pipeline contenente un'attività di copia.
Avviare un'esecuzione della pipeline.
Monitora le esecuzioni delle pipeline e delle attività.

Passare all'esercitazione successiva per ottenere informazioni sulla copia di dati dall'ambiente locale al cloud:

Copiare dati dall'ambiente locale al cloud

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-04-07