VENDITE: 1-800-867-1389

Partizionamento orizzontale SSIS e componenti di Azure

I set di dati da inserire in un database SQL di Azure™ richiedono in genere un certo livello di partizionamento orizzontale che può essere realizzato in Microsoft® SQL Server® Integration Services (SSIS) tramite la suddivisione condizionale e più adattatori di destinazione. Questa tecnica presenta tuttavia diverse limitazioni che sono indicate di seguito.

  • Processo di progettazione impegnativo. Le dimensioni dell'area di progettazione per SSIS aumentano eccessivamente quando si utilizzano molti componenti e alcuni schemi di partizionamento orizzontale possono contenere centinaia di partizioni. La progettazione di un pacchetto SSIS per accedere a tutte le destinazioni può richiedere molto tempo ed essere soggetta a errori perché è necessario aprire e configurare ogni componente. A ogni componente deve inoltre essere associato uno strumento di gestione connessione da parametrizzare qualora il componente venga in seguito spostato dall'ambiente di sviluppo a quello di produzione senza essere riprogettato.

    Per una discussione più dettagliata sul partizionamento orizzontale, inclusi motivi e tecniche di applicazione, vedere il post del blog relativo al partizionamento orizzontale con SQL Azure.

  • Riprogettazione di un ambiente con modifiche dinamiche. I parametri consentono di modificare nomi di server e di database, ma non consentono di modificare i numeri delle destinazioni. In archivi dati partizionati il numero di partizioni può cambiare di frequente e per componenti tradizionali incorporati le modifiche richiederebbero una riprogettazione e una nuova distribuzione di un pacchetto SSIS. I componenti di destinazione del partizionamento orizzontale SSIS consentono di superare il problema grazie alla lettura di un catalogo di partizionamento a ogni esecuzione e alla determinazione delle connessioni corrette in base al contenuto del catalogo.

  • Nomi di tabella non dinamici nelle destinazioni incorporate. Per inserire dati in un database SQL di Azure, è possibile utilizzare un adattatore di destinazione ADO.NET, ODBC oppure OLE DB. In tutti questi componenti, tuttavia, le tabelle devono essere impostate in modo definitivo e non possono essere parametrizzate. In alcuni scenari di partizionamento orizzontale logico è possibile modificare effettivamente i nomi di tabella o aggiungere altre tabelle. I componenti di partizionamento orizzontale consentono inoltre di utilizzare nomi di tabella dinamici nella destinazione.

  • Per Azure o per la compressione non esiste alcun componente SSIS. Quando i dati vengono spostati in una vasta area o tramite una connessione con larghezza di banda limitata, è necessario comprimere i file e bloccare i set di dati di dimensioni elevate per consentire l'elaborazione nelle destinazioni quando i dati vengono estratti dalle origini. I componenti Blob di origine e destinazione consentono il blocco dei dati, la compressione dei file, lo spostamento nel e dal servizio BLOB di Azure (come parte di uno spostamento in due passaggi o di uno spostamento nell'archiviazione BLOB per l'utilizzo di HDInsight) e l'utilizzo facoltativo di code per consentire ai pacchetti in ogni estremità della rete limitata di elaborare i dati bloccati in una pipeline.

I componenti di partizionamento orizzontale del database SSIS consentono di risolvere i problemi descritti.

I componenti e gli script di installazione del catalogo di partizionamento orizzontale sono disponibili come download separato nell'Area download Microsoft. Per utilizzare i componenti in modo ottimale, scaricare e installare entrambi i file come indicato di seguito.

Per scaricare e installare i componenti:

  1. Scaricare il file SSIS Database Sharding Components.zip disponibile nel sito di download.

  2. Aprire il file e spostare il contenuto in una directory sul computer in cui si desidera installare i componenti SSIS.

    noteNota
    Il componente SSIS di Microsoft SQL Server 2012 deve essere installato nel computer in cui si intende installare i componenti.

  3. Eseguire il programma di installazione SSISDatabaseSharding64.msi.

  4. Accettare il Contratto di licenza, quindi fare clic su Next. Verranno installati tutti i componenti e tutte le dipendenze.

  5. Aprire SQL Server Data Tools e avviare un nuovo progetto SSIS.

  6. Fare doppio clic su un'attività di flusso di dati dopo averla trascinata sull'area di progettazione.

  7. Verificare che nella barra degli strumenti SSIS la destinazione e l'origine Blob e i componenti di partizionamento orizzontale del database siano presenti nella casella degli strumenti, come illustrato in Figura 1.

    Figura 1. Se i componenti sono installati in modo corretto, la destinazione Blob, l'origine Blob e i componenti di partizionamento orizzontale del database sono visualizzati nella casella degli strumenti relativa al flusso di dati.

Per installare il catalogo di partizionamento orizzontale:

  • Scaricare il file Sharding Catalog Setup Scripts.zip disponibile nel sito di download.

  • In un database SQL Server oppure in un database SQL di Azure che sarà disponibile nel pacchetto una volta progettato e in esecuzione, eseguire lo script ShardingSchema.sql, quindi lo script ShardingStoredProcedures.sql. I due script contengono le definizioni di tabella per il catalogo di partizionamento orizzontale nonché le stored procedure che consentono di configurare un catalogo di partizionamento orizzontale valido.

  • Lo script TestAndExamples.sql contiene un esempio di come utilizzare le stored procedure per configurare un catalogo di partizionamento orizzontale.

Dopo aver installato i componenti e il catalogo di partizionamento orizzontale, è possibile utilizzare i componenti per connettersi a una destinazione dati partizionata in un qualsiasi archivio dati compatibile con OLE DB e per spostarvi i dati.

La destinazione di partizionamento orizzontale consente di immettere le destinazioni dati manualmente. Per sfruttare completamente la possibilità di modificare lo schema di partizionamento orizzontale della destinazione senza la necessità di sviluppare nuovamente i pacchetti, è necessario tuttavia configurare un catalogo di partizionamento orizzontale. In questa sezione vengono descritti i passaggi per utilizzare le stored procedure per la configurazione di un catalogo di partizionamento orizzontale.

In un catalogo completamente configurato sono contenuti gli elementi seguenti:

  1. Uno o più server di database. Nel catalogo di partizionamento orizzontale è necessario inserire ogni server che contiene un database da utilizzare nello schema di partizionamento. Questa informazione indica il modo in cui i server verranno posizionati e include il nome del server che il componente di partizionamento orizzontale utilizzerà per creare la stringa di connessione.

  2. Uno o più database da configurare. Ogni database deve essere presente in un server inserito nel catalogo di partizionamento. Il componente di destinazione del partizionamento orizzontale utilizzerà il nome del database per stabilire le connessioni necessarie.

  3. Almeno un set di partizioni da creare. Il set di partizioni definisce il modo in cui verrà identificato lo schema di partizionamento che verrà utilizzato per distribuire i dati. Idealmente, un set di partizioni è costituito da un archivio dati partizionato.

  4. Almeno una distribuzione di partizionamento orizzontale da creare per ogni set di partizioni. Tale distribuzione definisce uno schema di partizionamento come POINT o RANGE nonché la colonna utilizzata come chiave di partizionamento orizzontale e il tipo di dati relativo. La distribuzione fornisce inoltre informazioni sulla colonna quando vengono utilizzati tipi di dati quali FLOAT o DOUBLE.

  5. Membri da configurare per ogni distribuzione di partizionamento orizzontale. Questa appartenenza definisce la tabella e le righe di database che contengono determinati valori da inviare. Ogni membro della partizione deve essere correlato a un database.

Di seguito viene riportato un esempio di configurazione completo.

-- First, add the server.
DECLARE @srvid INT

EXEC [ShardMeta].[AddServerToShardingScheme] 
@ServerName= 'changed.database.windows.net'
,@Descr= 'Destination Server for the Demo'
,@ServerID = @srvid OUTPUT

-- Next, add the shard databases.

DECLARE @shard0ID INT
DECLARE @shard1ID INT
DECLARE @shard2ID INT
DECLARE @shard3ID INT
DECLARE @shard4ID INT
DECLARE @shard5ID INT
DECLARE @shard6ID INT
DECLARE @shard7ID INT
DECLARE @shard8ID INT
DECLARE @shard9ID INT
DECLARE @shard10ID INT

EXEC [ShardMeta].[AddDatabaseToShardingScheme]
@ServerID= @srvid
,@DatabaseName= 'SHARD000'
,@Descr= 'Destination Database for the Demo'
,@DatabaseID= @shard0ID OUTPUT

EXEC [ShardMeta].[AddDatabaseToShardingScheme]
@ServerID= @srvid
,@DatabaseName= 'SHARD001'
,@Descr= 'Destination Database for the Demo'
,@DatabaseID= @shard1ID OUTPUT

EXEC [ShardMeta].[AddDatabaseToShardingScheme]
@ServerID= @srvid
,@DatabaseName= 'SHARD002'
,@Descr= 'Destination Database for the Demo'
,@DatabaseID= @shard2ID OUTPUT

EXEC [ShardMeta].[AddDatabaseToShardingScheme]
@ServerID= @srvid
,@DatabaseName= 'SHARD003'
,@Descr= 'Destination Database for the Demo'
,@DatabaseID= @shard3ID OUTPUT

EXEC [ShardMeta].[AddDatabaseToShardingScheme]
@ServerID= @srvid
,@DatabaseName= 'SHARD004'
,@Descr= 'Destination Database for the Demo'
,@DatabaseID= @shard4ID OUTPUT


EXEC [ShardMeta].[AddDatabaseToShardingScheme]
@ServerID= @srvid
,@DatabaseName= 'SHARD005'
,@Descr= 'Destination Database for the Demo'
,@DatabaseID= @shard5ID OUTPUT

EXEC [ShardMeta].[AddDatabaseToShardingScheme]
@ServerID= @srvid
,@DatabaseName= 'SHARD006'
,@Descr= 'Destination Database for the Demo'
,@DatabaseID= @shard6ID OUTPUT


EXEC [ShardMeta].[AddDatabaseToShardingScheme]
@ServerID= @srvid
,@DatabaseName= 'SHARD007'
,@Descr= 'Destination Database for the Demo'
,@DatabaseID= @shard7ID OUTPUT

EXEC [ShardMeta].[AddDatabaseToShardingScheme]
@ServerID= @srvid
,@DatabaseName= 'SHARD008'
,@Descr= 'Destination Database for the Demo'
,@DatabaseID= @shard8ID OUTPUT

EXEC [ShardMeta].[AddDatabaseToShardingScheme]
@ServerID= @srvid
,@DatabaseName= 'SHARD009'
,@Descr= 'Destination Database for the Demo'
,@DatabaseID= @shard9ID OUTPUT


EXEC [ShardMeta].[AddDatabaseToShardingScheme]
@ServerID= @srvid
,@DatabaseName= 'SHARD010'
,@Descr= 'Destination Database for the Demo'
,@DatabaseID= @shard10ID OUTPUT

-- Next, add the shard set.

DECLARE @ShardSID INT

EXEC [ShardMeta].[AddShardSetToShardingScheme]
@name= 'Point Distro For demo'
,@Descr= 'Point Distribution for Demo'
,@ShardSetID= @ShardSID OUTPUT

-- Add a distribution to the shard set.

-- There are only two types of @Distribution_type:
-- POINT and RANGE
-- POINT means only one value per shard. Example: col1 = 1 or col1 = 2
-- RANGE means a range goes into the shard. Example: -1 < col1 <= 2
-- When @Boundary_value_in_high, the upper bound of a range is included
-- in the shard, but not the lower. So when this is set to 1,
-- a range of -1 to 2 would be: -1 < col1 <= 2
-- Conversely, if it is set to 0, the range from -1 to 2 would be
-- defined as: -1 <= col1 < 2
-- If the sharding column is a system data type, both the
-- @System_Type_Name and @User_type_name parameters contain the system data type name.
-- If the user type is different, name the type name in the @User_Type_Name 
-- parameter.


EXEC [ShardMeta].[AddShardDistributionToShardingScheme]
@ShardSetID= @ShardSID
,@Distribution_Name= 'Point Distro For demo'
,@Distribution_Type= 'POINT'
,@System_Type_Name= 'INT'
,@User_type_name= 'INT'
,@Boundary_value_in_high = 1

-- Add in the members for the “Point Distro For demo” distribution.

-- @MemberID must be unique within each @ShardSetID.
-- The order of MemberID is the order in which the conditions will be
-- evaluated for placement into a shard.
-- @Name is the case-sensitive name of the column as it
-- will appear in the SSIS dataflow. If this is the name
-- of the column in the source, nothing must be done
-- to change this in the SSIS dataflow. However, if it does
-- not exist in the source, use a derived column to create the 
-- column in the dataflow before it reaches the sharding destination.
-- For POINT distributions, @Range_Low and @Range_High are the same.


EXEC [ShardMeta].[AddShardSetMemberToShardingScheme]
@ShardSetID= @ShardSID
,@MemberID= 0
,@Distribution_Name= 'Point Distro For demo'
,@Name= 'ShardingKey'
,@DatabaseID= @Shard0ID
,@TableName= 'dbo.TestData'
,@Range_Low= 0
,@Range_High= 0

EXEC [ShardMeta].[AddShardSetMemberToShardingScheme]
@ShardSetID= @ShardSID
,@MemberID= 1
,@Distribution_Name= 'Point Distro For demo'
,@Name= 'ShardingKey'
,@DatabaseID= @Shard1ID
,@TableName= 'dbo.TestData'
,@Range_Low= 1
,@Range_High= 1

EXEC [ShardMeta].[AddShardSetMemberToShardingScheme]
@ShardSetID= @ShardSID
,@MemberID= 2
,@Distribution_Name= 'Point Distro For demo'
,@Name= 'ShardingKey'
,@DatabaseID= @Shard2ID
,@TableName= 'dbo.TestData'
,@Range_Low= 2
,@Range_High= 2

EXEC [ShardMeta].[AddShardSetMemberToShardingScheme]
@ShardSetID= @ShardSID
,@MemberID= 3
,@Distribution_Name= 'Point Distro For demo'
,@Name= 'ShardingKey'
,@DatabaseID= @Shard3ID
,@TableName= 'dbo.TestData'
,@Range_Low= 3
,@Range_High= 3

EXEC [ShardMeta].[AddShardSetMemberToShardingScheme]
@ShardSetID= @ShardSID
,@MemberID= 4
,@Distribution_Name= 'Point Distro For demo'
,@Name= 'ShardingKey'
,@DatabaseID= @Shard4ID
,@TableName= 'dbo.TestData'
,@Range_Low= 4
,@Range_High= 4

EXEC [ShardMeta].[AddShardSetMemberToShardingScheme]
@ShardSetID= @ShardSID
,@MemberID= 5
,@Distribution_Name= 'Point Distro For demo'
,@Name= 'ShardingKey'
,@DatabaseID= @Shard5ID
,@TableName= 'dbo.TestData'
,@Range_Low= 5
,@Range_High= 5

EXEC [ShardMeta].[AddShardSetMemberToShardingScheme]
@ShardSetID= @ShardSID
,@MemberID= 6
,@Distribution_Name= 'Point Distro For demo'
,@Name= 'ShardingKey'
,@DatabaseID= @Shard6ID
,@TableName= 'dbo.TestData'
,@Range_Low= 6
,@Range_High= 6

EXEC [ShardMeta].[AddShardSetMemberToShardingScheme]
@ShardSetID= @ShardSID
,@MemberID= 7
,@Distribution_Name= 'Point Distro For demo'
,@Name= 'ShardingKey'
,@DatabaseID= @Shard7ID
,@TableName= 'dbo.TestData'
,@Range_Low= 7
,@Range_High= 7

EXEC [ShardMeta].[AddShardSetMemberToShardingScheme]
@ShardSetID= @ShardSID
,@MemberID= 8
,@Distribution_Name= 'Point Distro For demo'
,@Name= 'ShardingKey'
,@DatabaseID= @Shard8ID
,@TableName= 'dbo.TestData'
,@Range_Low= 8
,@Range_High= 8

EXEC [ShardMeta].[AddShardSetMemberToShardingScheme]
@ShardSetID= @ShardSID
,@MemberID= 9
,@Distribution_Name= 'Point Distro For demo'
,@Name= 'ShardingKey'
,@DatabaseID= @Shard9ID
,@TableName= 'dbo.TestData'
,@Range_Low= 9
,@Range_High= 9

EXEC [ShardMeta].[AddShardSetMemberToShardingScheme]
@ShardSetID= @ShardSID
,@MemberID= 10
,@Distribution_Name= 'Point Distro For demo'
,@Name= 'ShardingKey'
,@DatabaseID= @Shard10ID
,@TableName= 'dbo.TestData'
,@Range_Low= 10
,@Range_High= 10

Nel set di dati dimostrativo vengono configurate 11 partizioni. Ogni partizione si trova in un database separato e vengono configurati un singolo set di partizioni e una singola distribuzione di partizionamento orizzontale. I dati vengono partizionali in ShardingKey (tenere presente che viene rispettata la distinzione tra maiuscole e minuscole). Ogni membro del set di partizioni viene configurato per ogni partizione in cui verranno indirizzati i dati. In questo schema solo i valori presenti negli elementi ShardingKey da 0 a 10 verranno inviati alle destinazioni.

Si consiglia di utilizzare le stored procedure. A causa della convalida eseguita da ogni stored procedure per inserire i dati, è possibile comunque individuare i dati inseriti dalle stored procedure nelle tabelle del catalogo nonché modificarli senza le stored procedure stesse. Per individuare i dati inseriti nelle stored procedure, esaminare le tabelle nello schema ShardMeta.

Dopo che il catalogo di partizionamento orizzontale è stato configurato o indirizzato al database effettivo, è possibile utilizzarlo per eseguire un trasferimento di dati. In questa sezione è contenuto un esempio di creazione di un pacchetto che utilizzerà il componente e il catalogo di partizionamento orizzontale.

Lo schema delle tabelle di origine e di destinazione dell'esempio è definito nel modo indicato di seguito.

CREATE TABLE [dbo].[TestData](
[KeyCol] [bigint] NOT NULL,
[IntCol1] [int] NOT NULL,
[IntCol2] [int] NOT NULL,
[IntCol3] [int] NOT NULL,
[CharCol1] [nvarchar](50) NOT NULL,
[CharCol2] [nvarchar](50) NOT NULL,
[CharCol3] [nvarchar](50) NOT NULL,
[CharCol4] [nvarchar](50) NOT NULL,
PRIMARY KEY CLUSTERED 
(
[KeyCol] ASC
)
)

È possibile creare questa tabella e popolarla con dati casuali per completare la configurazione di esempio utilizzando lo schema del catalogo della partizione configurato in precedenza:

  1. Aprire SQL Server Data Tools e creare un nuovo progetto SSIS.

  2. Creare un pacchetto nel progetto.

  3. Aggiungere un'attività di flusso di dati al pacchetto, quindi fare clic sulla scheda Data Flow.

  4. Trascinare un'origine ADO.NET nell'area di progettazione del flusso di dati.

  5. Seguire i passaggi descritti per creare lo strumento di gestione connessione e indirizzarlo alla tabella dati di origine. Chiuderlo dopo averne completato la configurazione.

    noteNota
    Nella configurazione dello schema di partizionamento orizzontale della sezione precedente la chiave di partizionamento è rappresentata da una colonna denominata ShardingKey. Tale chiave non esiste nei dati di origine, ma deve essere presente nel flusso di dati SSIS prima che i dati raggiungano la destinazione di partizionamento orizzontale del database. Utilizzare una colonna derivata per creare tale colonna nel flusso di dati SSIS. Questo passaggio non è necessario se la chiave di partizione esiste nei dati stessi.

  6. Trascinare una trasformazione della colonna derivata nell'area di progettazione del flusso dati SSIS e connettere l'output dell'origine ADO.NET a questo componente.

  7. Configurare la trasformazione della colonna derivata nel modo indicato di seguito:

    1. Utilizzare ShardingKey come nome della colonna derivata. Tale nome rispetta la distinzione tra maiuscole e minuscole e deve corrispondere al nome della colonna chiave di partizionamento orizzontale nel catalogo di partizionamento.

    2. Per l'espressione, utilizzare [KeyCol] % 11. In questo modo alla chiave di partizionamento orizzontale verrà assegnato un possibile valore compreso nell'intervallo da 0 a 10, che rispecchia il modo in cui il catalogo è configurato per indirizzare le righe.

    Dopo la configurazione, la colonna derivata deve essere analoga a quanto illustrato in Figura 2.

    Figura 2. Colonna derivata completamente configurata che aggiunge la colonna ShardingKey al flusso di dati e la definisce come il modulo 11 su KeyCol.

  8. Trascinare una destinazione di partizionamento orizzontale del database nell'area di progettazione del flusso di dati e connettervi l'output della trasformazione della colonna derivata.

  9. Fare doppio clic per aprire il progetto, quindi effettuare le operazioni seguenti:

    1. Fare clic su New in Please connect to the Sharding Catalog, quindi seguire i passaggi per definire uno strumento di gestione connessione che punti al database del catalogo di partizionamento orizzontale creato in precedenza.

    2. Nell'elenco Please select the Shard Set selezionare il set di partizioni creato per questa demo (Point Distro for demo).

    3. Fare clic su New in Destination Connection Manager. Verrà visualizzato un nuovo strumento di gestione connessione di partizionamento orizzontale (SHARDINGCM).

    4. Specificare il nome utente e la password che verranno utilizzati per connettersi ai database di destinazione. Per il database di Azure non è possibile utilizzare il protocollo SSPI (Security Support Provider Interface).

      noteNota
      È possibile definire solo un nome utente e una password per connettersi a tutti i server e database presenti nello schema di partizionamento orizzontale. Verificare che il nome utente e la password siano definiti e che dispongano di privilegi sufficienti in ogni database.

      noteNota
      Sebbene vengano impostati direttamente in questa demo, nome utente e password sono parametrizzabili, in modo analogo ai nomi utente e alle password in altri strumenti di gestione connessione in SSIS. Poiché il nome utente e la password sono parametrizzabili, è possibile spostare il pacchetto creato dopo lo sviluppo oppure è possibile modificare le informazioni di accesso in fase di runtime.

      In Figura 3 viene illustrato l'aspetto dell'editor per l'adattatore di destinazione del partizionamento orizzontale dopo aver eseguito le operazioni descritte nei passaggi precedenti.

      Figura 3. Pagina 1 di esempio di un adattatore di destinazione di partizionamento orizzontale. Lo strumento di gestione connessione drxufmq90b.database.windows.net.ShardCatalog.AzureCat punta al catalogo di partizionamento orizzontale. Il set di partizioni utilizzato è denominato Point Distro For Azure CAT Summit. Lo strumento di gestione connessione denominato SQL Sharding Connection Manager contiene il nome utente e la password che verranno utilizzati per connettersi a tutti i database di destinazione nello schema di partizionamento orizzontale.

    5. Fare clic su OK per uscire dal programma di impostazione dello strumento di gestione connessione della destinazione di partizionamento orizzontale.

    6. Fare clic su Connections nel riquadro sinistro dell'editor per l'adattatore di destinazione di partizionamento orizzontale. A questo punto l'editor si connette al catalogo di partizionamento orizzontale e visualizza le destinazioni attualmente definite nel catalogo, come illustrato in Figura 4. Si noti che si tratta solo dei dati attualmente presenti nel catalogo di partizionamento orizzontale. È possibile modificare tali dati dopo il progetto perché a ogni esecuzione il componente si connette al catalogo di partizionamento orizzontale per determinarne lo stato corrente. Selezionare la casella di controllo Use Bulk Insert per la maggior parte dei casi, anche se si desidera inserire singolarmente righe per gestire possibili violazioni di chiave primaria.

      Figura 4. Pagina di connessioni in un adattatore di destinazione di partizionamento orizzontale. Le informazioni nelle espressioni e nelle tabelle sono state estratte dal catalogo di partizionamento orizzontale definito nella pagina 1.

    7. Fare clic su Mappings nel riquadro sinistro. Il componente esegue automaticamente il mapping di colonne con lo stesso nome, come illustrato in Figura 5. Se i nomi delle colonne sono diversi, è tuttavia possibile eseguirne il mapping manualmente. In questo caso, si noti che viene eseguito il mapping di tutte le colonne ad eccezione di ShardingKey. La colonna ShardingKey non esiste nella tabella di destinazione e si trova nel flusso di dati esclusivamente per consentire al componente di destinazione di partizionamento orizzontale di indirizzare le righe nella partizione corretta.

      Figura 5. Pagina dei mapping dall'adattatore di destinazione di partizionamento orizzontale.

    8. Fare clic su OK per uscire dall'editor.

  10. Selezionare l'adattatore di destinazione di partizionamento orizzontale del database, quindi fare clic sulla scheda Properties in SQL Server Data Tools. Nelle proprietà personalizzate si noti in particolare FaultToleranceRetryStrategy. La gestione di errori temporanei è incorporata nella destinazione di partizionamento orizzontale. Le proprietà vengono impostate qui in modo che sia possibile modificare la strategia di tentativi, il numero di tentativi da eseguire e gli intervalli tra i tentativi. Poiché tutti questi elementi sono configurati come proprietà personalizzate, è possibile parametrizzarli per modificarli in fase di runtime.

A questo punto il pacchetto è pronto per l'esecuzione o la distribuzione. Se si aggiungono o si rimuovono partizioni o si modificano partizioni da un'esecuzione a un'altra, la nuova configurazione di partizionamento orizzontale verrà letta alla successiva esecuzione del pacchetto. I dati verranno inviati ai database e alle tabelle esattamente come definiti nel catalogo all'inizio dell'esecuzione.

Oltre alla destinazione di partizionamento orizzontale del database, è possibile utilizzare componenti per inviare o per recuperare dati dall'archiviazione BLOB di Azure. Tali componenti sono i componenti di origine e destinazione Blob.

Il completamento delle informazioni per l'adattatore di destinazione Blob consiste nella specifica dell'account e della chiave di archiviazione di Azure, di una dimensione dei blocchi di destinazione per i dati non compressi e di un nome file di base con cui salvare i file. Utilizzare l'elenco Containers per selezionare il contenitore di destinazione. Nell'elenco Blobs Present vengono visualizzati i file già archiviati nel contenitore selezionato per evitare conflitti di nomi. Quando l'editor è compilato, l'aspetto è analogo a quello in Figura 6.

Figura 6. Esempio di destinazione Blob di Azure per SSIS.

Quando si esegue il pacchetto SSIS, la destinazione Blob blocca i dati e crea file GNU zip (con estensione gzip) nel contenitore Blob specificato. La destinazione crea inoltre una coda nell'account di archiviazione con lo stesso nome del nome di file specificato. La destinazione Blob inserisce in questa coda il nome di ogni file creato quando è necessario elaborare ulteriormente i file compressi. Utilizzare uno strumento come Azure Storage Explorer di Neudesic per visualizzare la coda e il relativo contenuto o per cancellare la coda nei casi in cui sia necessario ripartire dall'inizio.

Il componente di origine Blob viene utilizzato come un'origine per i file di dati creati dal componente di destinazione Blob. Per utilizzare il componente di origine Blob, completare le informazioni nelle caselle relative al nome e alla chiave dell'account di archiviazione. A questo punto l'elenco per i contenitori viene popolato automaticamente. Selezionare il contenitore, quindi scegliere se è necessario recuperare i dati dalla coda. Si consiglia di utilizzare sempre questa opzione. L'opzione è assolutamente necessaria se in relazione allo stesso set di file di dati verrà eseguita più di un'istanza del pacchetto. Un esempio è illustrato in Figura 7.

Figura 7

Poiché nella destinazione di archiviazione Blob vengono archiviati solo file compressi e delimitati, HDInsight può utilizzare direttamente i file creati. Ogni riga è delimitata da tag delimitatori di riga e ogni colonna è delimitata da tag delimitatori di colonna. Le intestazioni di colonna vengono archiviate nel file di intestazione di colonna caricato nel contenitore in cui sono archiviati i file.

Il documento è risultato utile?
(1500 caratteri rimanenti)
Grazie per i commenti inviati.
Mostra:
© 2014 Microsoft