VENTAS: 1-800-867-1389
Collapse the table of content
Expand the table of content
Expandir Minimizar

Particionamiento de SSIS y componentes de Azure

Actualizado: abril de 2014

Cualquier conjunto de datos importante que se vaya a incluir en una base de datos SQL de Azure™ requerirá algún nivel de particionamiento. Para lograr el particionamiento en Microsoft® SQL Server® Integration Services (SSIS), utilice una división condicional y varios adaptadores de destino. No obstante, esta técnica sufre varias limitaciones:

  • El proceso de diseño es tedioso. La superficie de diseño de SSIS es difícil de manejar cuando se utilizan muchos componentes. Algunos esquemas de particionamiento pueden contener cientos de particiones. El diseño de un paquete de SSIS que alcance todos estos destinos requiere mucho tiempo y es propenso a generar errores porque es necesario abrir y configurar cada uno de los componentes. Cada componente debe tener también un administrador de conexiones que debe estar parametrizado si va a pasarlo del entorno de desarrollo al de producción sin volver a realizar el diseño.

    Para ver una discusión más completa del particionamiento, incluidas las razones y las técnicas, consulte la entrada de blog Sharding with SQL Azure.

  • Para cambiar de entorno de forma dinámica es necesario volver a realizar el diseño. Los parámetros permiten que los nombres de servidor y de base de datos cambien, pero no permiten la modificación de números de los destinos. En los almacenes de datos con particiones, el número de particiones puede cambiar con frecuencia. Para los componentes integrados tradicionales, los cambios requerirían un nuevo diseño y la implementación de un paquete de SSIS. El componente de destino del particionamiento de SSIS puede resolver este problema por medio de la lectura de un catálogo de particionamiento en cada ejecución y del establecimiento de las conexiones correctas según el contenido del catálogo de particionamiento.

  • Los nombres de tabla no son dinámicos en los destinos integrados. Para insertar datos en una base de datos SQL de Azure, se puede utilizar un adaptador de destino ADO.NET, ODBC u OLE DB. No obstante, en todos estos componentes, las tablas deben estar establecidas y no se pueden parametrizar. En algunos escenarios de particionamiento lógico, los nombres de tablas se pueden cambiar o se pueden agregar tablas adicionales. Los componentes de particionamiento permiten que los nombres de tabla también sean dinámicos en el destino.

  • No existen componentes de SSIS para Azure ni para la compresión. Cuando los datos se mueven a través de un área extensa o una conexión de ancho de banda limitado, debe comprimir los archivos y fragmentar los conjuntos de datos de gran tamaño para permitir el procesamiento en los destinos a medida que los datos se extraen de los orígenes. Los componentes de origen y de destino de blob permiten la fragmentación de datos, la compresión de archivos, la entrada y la salida del almacenamiento blob de Azure (como parte de un movimiento de dos pasos o de un movimiento al almacenamiento blob para el uso de HDInsight), y el uso opcional de colas para permitir que los paquetes de cada extremo de la red limitada procesen los datos fragmentados en una canalización.

Los componentes de particionamiento de la base de datos de SSIS pueden ayudarle a superar estos retos.

Los componentes y los scripts de configuración del catálogo de particionamiento están disponibles como descargas independientes del Centro de descarga de Microsoft. Para utilizar los componentes a todos los efectos, descargue e instale ambos archivos como se indica a continuación.

Para descargar e instalar los componentes:

  1. Descargue el archivo SSIS Database Sharding Components.zip del sitio de descarga.

  2. Abra el archivo y mueva el contenido a un directorio del equipo donde pretenda instalar los componentes de SSIS.

    noteNota
    SSIS de Microsoft SQL Server 2012 debe estar instalado en el equipo donde tenga previsto instalar los componentes.

  3. Ejecute el instalador SSISDatabaseSharding64.msi.

  4. Acepte el contrato de licencia y luego haga clic en Siguiente. Todos los componentes y las dependencias se instalarán.

  5. Abra SQL Server Data Tools e inicie un nuevo proyecto de SSIS.

  6. Arrastre una tarea de flujo de datos en la superficie de diseño y haga doble clic en ella.

  7. Observe la barra de herramientas de SSIS y asegúrese de que los componentes de destino de blob, de origen de blob y de particionamiento de la base de datos aparecen en el cuadro de herramientas como se muestra en la figura 1.

    Ilustración 1Figura 1. Los componentes de destino de blob, de origen de blob y de particionamiento de la base de datos aparecen en el cuadro de herramientas cuando los compontes se han instalado correctamente.

Para instalar el catálogo de particionamiento:

  • Descargue el archivo Sharding Catalog Setup Scripts.zip del sitio de descarga.

  • En una base de datos de SQL Server o una base de datos SQL de Azure que vaya a estar disponible para el paquete durante su diseño y ejecución, ejecute el script ShardingSchema.sql y luego el script ShardingStoredProcedures.sql. Estos dos scripts contienen las definiciones de tabla del catálogo de particionamiento, junto con los procedimientos almacenados que le ayudarán a configurar un catálogo de particionamiento válido.

  • El script TestAndExamples.sql contiene un ejemplo de cómo se pueden usar los procedimientos almacenados para configurar un catálogo de particionamiento.

Después de instalar los componentes y el catálogo de particionamiento, estará preparado para utilizar los componentes para establecer la conexión a un destino de datos de particionamiento de cualquier almacén de datos compatible con OLE DB, así como para mover datos a dicho destino.

Puede usar el destino de particionamiento para introducir destinos de datos manualmente. No obstante, para aprovechar al máximo las ventajas de poder cambiar el esquema de particionamiento del destino sin volver a desarrollar los paquetes, es necesario configurar un catálogo de particionamiento. Esta sección le guiará por los pasos de utilización de los procedimientos almacenados para configurar un catálogo de particionamiento.

Un catálogo de particionamiento completamente configurado contiene los elementos siguientes:

  1. Uno o más servidores de bases de datos. En el catálogo de particionamiento, se deben introducir todos los servidores que contengan una base de datos que se vaya a utilizar en el esquema de particionamiento. Esta información indica cómo se ubicarán los servidores e incluye el nombre del servidor que el componente de particionamiento utilizará para compilar la cadena de conexión.

  2. Una o más bases de datos que deben configurarse. Cada base de datos debe existir en un servidor que se haya introducido en el catálogo de particionamiento. El componente de destino del particionamiento utilizará el nombre de la base de datos para establecer las conexiones necesarias.

  3. Como mínimo, un conjunto de particiones que deberá crear. El conjunto de particiones determina la identificación del esquema de particionamiento que se utilizará para distribuir los datos. Idealmente, un conjunto de particiones es un almacén de datos con particiones.

  4. Como mínimo, una distribución de particionamiento que deberá crear para cada conjunto de particiones. Esta distribución define un esquema de particionamiento como POINT o RANGE, define la columna que se utilizará como clave de particionamiento y el tipo de datos de la columna. También proporciona información sobre la columna cuando se utilizan tipos de datos como FLOAT o DOUBLE.

  5. Los miembros que deben configurarse para cada distribución de particionamiento. Esta pertenencia define las filas de la tabla y la base de datos que contienen determinados valores que se van a enviar. Cada miembro de la partición debe estar relacionado con una base de datos.

A continuación se muestra una configuración de ejemplo completa.

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

En el conjunto de datos de la demo, se han configurado 11 particiones. Cada partición se encuentra en una base de datos independiente. Se ha configurado un conjunto de particiones único y una distribución de particionamiento. Los datos se particionan en ShardingKey (recuerde que distingue mayúsculas de minúsculas). Un miembro del conjunto de particiones se configura para cada partición a la que se dirigirán los datos. En este esquema, solo se enviarán destinos en ShardingKey de 0 a 10.

Se recomienda encarecidamente utilizar los procedimientos almacenados. No obstante, debido a la validación que realiza cada procedimiento almacenado para introducir los datos, puede buscar los datos que han introducido los procedimientos almacenados en las tablas de catálogo y modificarlos sin los procedimientos almacenados. Para buscar los datos que ha introducido en los procedimientos almacenados, observe las tablas del esquema ShardMeta.

Después de configurar un catálogo de particionamiento y orientarlo a las bases de datos reales, puede utilizarlo para realizar una transferencia de datos. Esta sección contiene un ejemplo de creación de un paquete que utilizará el componente de particionamiento y el catálogo de particionamiento.

En este ejemplo, las tablas de origen y de destino presentan un esquema que se define de la siguiente manera.

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
)
)

Puede crear esta tabla y rellenarla con datos aleatorios para seguirlos en la configuración de ejemplo con el esquema del catálogo de particiones que ha configurado anteriormente:

  1. Abra SQL Server Data Tools y cree un nuevo proyecto de SSIS.

  2. Cree un paquete en el proyecto.

  3. Agregue una tarea de flujo de datos al paquete y luego haga clic en la ficha Data Flow.

  4. Arrastre un origen ADO.NET en la superficie de diseño del flujo de datos.

  5. Siga los pasos para crear el administrador de conexiones y orientarlo a su tabla de datos de origen. Ciérrelo tras configurarlo completamente.

    noteNota
    En la configuración del esquema de particionamiento en la sección anterior, la clave de particionamiento es una columna denominada ShardingKey. Esta clave no existe en los datos de origen, pero debe existir en el flujo de datos de SSIS antes de que los datos lleguen al destino de particionamiento de la base de datos. Utilice una columna derivada para crear este columna en el flujo de datos de SSIS. Este paso no es necesario si la clave de la partición son los propios datos.

  6. Arrastre una transformación de columna derivada en la superficie de diseño del flujo de datos de SSIS y conecte la salida del origen de ADO.NET a este componente.

  7. Configure la transformación de columna derivada como se indica a continuación:

    1. Utilice ShardingKey como el nombre de la columna derivada. Este nombre distingue mayúsculas de minúsculas y debe coincidir con el nombre de columna de la clave de particionamiento del catálogo de particionamiento.

    2. Para la expresión, utilice [KeyCol] % 11. Este valor asignará a la clave de particionamiento los posibles valores de 0 a 10, que es como se configura el catálogo de particionamiento para dirigir las filas.

    Después de configurar la columna derivada, debería tener el aspecto de la figura 2.

    Ilustración 2Figura 2. Columna derivada completamente configurada que agrega la columna ShardingKey al flujo de datos y la define como el módulo 11 en KeyCol.

  8. Arrastre un destino de particionamiento de la base de datos en la superficie de diseño del flujo de datos y conecte la salida de la transformación de la columna derivada a dicho destino.

  9. Haga doble clic para abrir el diseño y luego siga los pasos siguientes:

    1. Haga clic en New en Please connect to the Sharding Catalog y luego siga los pasos para definir un administrador de conexiones que apunte a la base de datos de catálogos de particionamiento que ha creado anteriormente.

    2. En la lista Please select the Shard Set, seleccione el conjunto de particiones que ha creado para esta demo (Point Distro for demo).

    3. Haga clic en New en Destination Connection Manager. Aparecerá un nuevo administrador de conexiones de particionamiento (SHARDINGCM).

    4. Especifique el nombre de usuario y la contraseña que se usarán para la conexión a las bases de datos de destino. Para la base de datos de Azure, no se puede utilizar la interfaz del proveedor de compatibilidad para seguridad (SSPI).

      noteNota
      Solo puede definir un nombre de usuario y una contraseña para la conexión a todos los servidores y bases de datos que participan en el esquema de particionamiento. Asegúrese de que el nombre de usuario y la contraseña existen y de que dispone de privilegios suficientes para cada base de datos.

      noteNota
      Aunque defina el nombre de usuario y la contraseña directamente en esta demo, se pueden parametrizar, ya que son nombres de usuario y contraseñas en otros administradores de conexiones en SSIS. Dado que el nombre de usuario y la contraseña se pueden parametrizar, puede mover el paquete tras el desarrollo o modificar la información de inicio de sesión en el momento de la ejecución.

      La figura 3 muestra como aparece el editor del adaptador de destino de particionamiento después de seguir los pasos anteriores.

      Ilustración 3Figura 3. Página de ejemplo 1 de un adaptador de destino de particionamiento. El administrador de conexiones drxufmq90b.database.windows.net.ShardCatalog.AzureCat apunta al catálogo de particionamiento. El conjunto de particiones utilizado se denomina Point Distro For Azure CAT Summit. El administrador de conexiones denominado SQL Sharding Connection Manager contiene el nombre de usuario y la contraseña que se usarán para la conexión a todas las bases de datos de destino del esquema de particionamiento.

    5. Haga clic en OK para salir de la configuración del administrador de conexiones del destino de particionamiento.

    6. Haga clic en Connections en el panel izquierdo del adaptador de destino de particionamiento. En este punto, el editor se conecta al catálogo de particionamiento y muestra los destinos tal como están definidos actualmente en dicho catálogo, como se muestra en la figura 4. Observe que estos son solamente los datos que existen actualmente en el catálogo de particionamiento. Estos datos se pueden modificar tras el diseño porque con cada ejecución, el componente se conecta al catálogo de particionamiento para determinar el estado actual del catálogo. Active la casilla Use Bulk Insert en la mayoría de los casos, aunque quizás desee insertar filas de forma individual para controlar posibles infracciones de clave principal.

      Ilustración 4Figura 4. Página de conexiones en un adaptador de destino de particionamiento. La información de Expressions y Tables se ha extraído del catálogo de particionamiento definido en la página 1.

    7. Haga clic en Mappings en el panel izquierdo. El componente asigna columnas con el mismo nombre automáticamente, como se muestra en la figura 5. No obstante, si las columnas presentan nombres diferentes, pueden asignarse manualmente. En este caso, observe que todas las columnas excepto ShardingKey están asignadas. ShardingKey no existe en la tabla de destino y está presente en el flujo de datos solamente para permitir que el componente de destino del particionamiento dirija las filas a la partición correcta.

      Ilustración 5Figura 5. Página de asignaciones del adaptador de destino de particionamiento.

    8. Haga clic en OK para salir del editor.

  10. Seleccione el adaptador de destino de particionamiento de la base de datos y luego haga clic en la ficha Properties en SQL Server Data Tools. En las propiedades personalizadas, observe especialmente FaultToleranceRetryStrategy. El control de errores transitorios se genera en el destino de particionamiento. Aquí se establecen las propiedades para que pueda cambiar la estrategia de reintento, el número de reintentos que se van a realizar y los intervalos de los reintentos. Dado que todas ellas están configuradas como propiedades personalizadas, se pueden parametrizar para que puedan cambiarse en el momento de la ejecución.

En este punto, el paquete está listo para la ejecución o la implementación. Si se agregan o quitan particiones, o se cambian particiones entre las ejecuciones, la nueva configuración de particionamiento se leerá la próxima vez que se ejecute el paquete. Los datos se enviarán a las bases de datos y las tablas tal como existe en el catálogo al principio de la ejecución.

Además del destino de particionamiento de la base de datos, puede utilizar los componentes para enviar datos al almacenamiento blob de Azure o para recuperar datos de dicho almacenamiento. Estos son los componentes de origen y de destino de blob.

Completar la información del adaptador de destino de blob es cuestión de especificar la cuenta y la clave de almacenamiento de Azure, un tamaño de fragmento de destino para los datos sin comprimir y un nombre de archivo base con el que guardar los archivos. Utilice la lista Containers para seleccionar el contenedor de destino. La lista Blobs Present solo ofrece una vista de los archivos que ya están almacenados en el contenedor seleccionado, para ayudarle a evitar conflictos de nombres. Una vez rellenado, el editor podría tener un aspecto similar al de la figura 6.

Ilustración 6

Figura 6. Ejemplo de destino de blob de Azure para SSIS.

Cuando se ejecuta el paquete de SSIS, el destino de blob fragmenta los datos y crea archivos GNU comprimidos (gzip) en el contenedor de blob especificado. También crea una cola en la cuenta de almacenamiento con el mismo nombre que el del archivo especificado. El destino de blob coloca el nombre de cada archivo creado en la cola si los archivos comprimidos requieren procesamiento adicional. Utilice una herramienta como Neudesic Azure Storage Explorer para ver la cola y su contenido, o para borrar la cola en aquellos casos en que necesite comenzar desde cero.

El componente de origen de blob sirve de origen para los archivos de datos que ha creado el componente de destino de blob. Para utilizar el componente de origen de blob, rellene la información de los cuadros Storage Account Name y Storage Account Key. A continuación, la lista de los contenedores se rellena automáticamente. Seleccione el contenedor y luego elija si se requiere la recuperación desde la cola. (Se recomienda esta opción en cualquier caso. La opción es absolutamente necesaria si se va a ejecutar más de una instancia del paquete en el mismo conjunto de archivos de datos). En la figura 7 vemos un ejemplo.

Ilustración 7

Figura 7:

Dado que el destino de almacenamiento de blob solo almacena archivos delimitados comprimidos en el almacenamiento de blob, HDInsight puede consumir directamente los archivos que se han producido. Cada fila está delimitada por etiquetas delimitadoras de fila y cada columna está delimitada por etiquetas delimitadoras de columna. Los encabezados de columna se almacenan en el archivo de encabezados de columna que se carga en el contenedor donde se encuentran almacenados los archivos.

¿Te ha resultado útil?
(Caracteres restantes: 1500)
Gracias por sus comentarios
Mostrar:
© 2016 Microsoft