Outils complémentaires 09/09/2009

SSIS
Outils complémentaires
Version 1.0
Thibault Denizet
2
Outils complémentaires
09/09/2009
Sommaire
1
Introduction ..................................................................................................................................... 3
2
Transactions .................................................................................................................................... 4
3
2.1
Définition ................................................................................................................................. 4
2.2
Configuration ........................................................................................................................... 4
Checkpoints ..................................................................................................................................... 6
3.1
Définition ................................................................................................................................. 6
3.2
Configuration ........................................................................................................................... 6
4
Statut du package ............................................................................................................................ 7
5
Historique ........................................................................................................................................ 8
6
5.1
Définition ................................................................................................................................. 8
5.2
Configuration ........................................................................................................................... 8
Gestionnaire d’événements ............................................................................................................ 9
6.1
Définition ................................................................................................................................. 9
6.2
Configuration ........................................................................................................................... 9
7
Debugging ...................................................................................................................................... 10
8
Conclusion ..................................................................................................................................... 11
Dotnet France Association
3
Outils complémentaires
09/09/2009
1 Introduction
Maintenant que nous savons créer des packages grâce aux diverses tâches du chapitre
précédent, nous allons étudier les outils fournis par SSIS pour rendre notre package plus optimisé,
plus fonctionnel et plus autonome. En effet, nous verrons par exemple comment unir les tâches de
notre package grâce aux transactions, créer des points de sauvegarde grâce aux checkpoints, voir le
statut de notre package ou encore créer des historiques de l’exécution de nos packages. De plus,
nous allons voir comment gérer les erreurs et le debugging.
Dotnet France Association
4
Outils complémentaires
09/09/2009
2 Transactions
2.1 Définition
Les packages de SQL Server Integration Services effectuent des opérations en unités atomiques,
c’est-à-dire, une tâche ou une série de tâches est soit réussie et affecte les données, soit échoue et
renvoie les données avant l’exécution des tâches.
L’unité de travail qui doit être exécutée avec succès afin d’affecter les données est appelée une
transaction.
2.2 Configuration
Nous pouvons définir des transactions sur le package entier ou bien sur n’importe quelle tâche
individuellement. Les transactions dans SSIS utilisent la ressource Miscrosoft Distributed Transaction
Coordinator (MSDTC). Cette ressource doit être activée pour que les transactions fonctionnent.
Pour utiliser MSDTC dans SSIS, il nous faut mettre la
propriété TransactionOption de Supported (Option par
défaut) à Required.
De plus, tout service ou programme compatible avec MSDTC
peut faire parti d’une transaction dans SSIS.
Voici les règles importantes à respecter pour mettre en place des transactions au sein de notre
package.
1. Pour activer les transactions, il faut démarrer MSDTC (msdtc.exe) et le ou les services, tâches
ou programmes doivent être compatibles avec MSDTC.
2. Si une série de tâches doit être exécuté comme une seule unité, il faut placer les tâches dans
un conteneur de séquence et régler l’option TransactionOption à Required.
3. Une tâche peut hériter des propriétés de transaction de ses parents quand l’option
TransactionOption est mise à Supported.
4. Il est possible d’empêcher une tâche de participer à une transaction en mettant l’option
TransactionOption à NotSupported.
Dotnet France Association
5
Outils complémentaires
09/09/2009
5. Si nous définissons l’option TransactionOption d’une boucle Foreach ou d’une boucle For à
Required, une nouvelle transaction sera crée pour chaque itération de la boucle.
6. Les transactions fonctionnent au niveau du flux de contrôle mais pas à l’intérieur du flux de
données. Cela a pour effet que nous pouvons séparer des tâches dans le flux de contrôle
mais pas dans le flux de données. Soit le processus du flux de données entier sera exécuté
avec succès soit il sera annulé.
Dotnet France Association
6
Outils complémentaires
09/09/2009
3 Checkpoints
3.1 Définition
Parfois il est intéressant de redémarrer un package juste avant qu’il n’échoue au lieu de tout
recommencer au début, particulièrement lorsque nous travaillons sur des gros projets ayant un
temps d’exécution important. Il est possible d’avoir cette option en activant les checkpoints au sein
de notre package.
3.2 Configuration
La première étape est de permettre à notre package d’utiliser des checkpoints et la seconde
étape est de spécifier les tâches et les conteneurs où placer les checkpoints.
Pour activer les checkpoints, il suffit de suivre les étapes suivantes :
1. Dans notre package, cliquer sur l’onglet flux de contrôle pour obtenir les propriétés du
package en bas à droite par défaut.
2. Définir la propriété SaveCheckpoints au niveau du package à True. Cela permet à SSIS de
sauvegarder des checkpoints durant l’exécution du package.
3. Au niveau de la propriété CheckpointFileName, nous devons fournir un chemin d’accès valide
vers un fichier checkpoint. Les packages utilisent des fichiers pour maintenir les informations
de leur état. Ainsi si un package échoue et redémarre, il peut lire le fichier checkpoint et
déterminer où il doit reprendre l’exécution.
4. Définir la propriété CheckpointUsage à IfExists, qui permet au package de savoir qu’il doit se
ré-exécuter depuis le début si aucun fichier checkpoint n’est présent et que, dans le cas
contraire, il doit redémarrer à l’endroit que lui indique le fichier checkpoint. Si la propriété
est mise à Always, le package ne pourra démarrer que si un fichier checkpoint est présent.
5. Après avoir activé les checkpoints, la dernière étape est de placer les checkpoints au sein des
diverses tâches de notre package. Pour faire cela, nous devons mettre la propriété
FailPackageOnFailure de chaque tâche à True.
Une fois que tous ces éléments sont configurés, votre package pourra redémarrer depuis le
checkpoint le plus proche de l’erreur.
Dotnet France Association
7
Outils complémentaires
09/09/2009
4 Statut du package
Lors de l’exécution de notre package, SSIS rentre dans l’environnement de débogage, nous
pouvons ainsi voir le statut des tâches du flux de contrôle et du flux de données. Dans SSIS, les tâches
apparaissent en différentes couleurs selon leurs états.
Les éléments qui sont en noir n’ont pas encore été exécutés. Les éléments qui apparaissent en
jaune sont en cours d’exécution et ceux en rouge sont ceux dont l’exécution à échouée. Enfin, la
couleur verte des éléments correspond à la réussite.
Dotnet France Association
8
Outils complémentaires
09/09/2009
5 Historique
5.1 Définition
Les informations obtenues dans l’onglet « Progress » peuvent être enregistrées dans un fichier
ou une table afin de créer un historique grâce aux fonctionnalités prévues à cet effet.
5.2 Configuration
Pour activer l’historique (aussi appelé Journalisation), il faut tout d’abord sélectionner Logging
(Enregistrement sur la version française) dans le menu SSIS.
Après l’affichage de l’éditeur de journalisation, il nous faut sélectionner quelles parties de
notre package auront un historique. En général, nous souhaitons avoir l’historique de notre package
entier, nous devrons donc cocher l’élément tout en haut de l’arbre de navigation. Mais, nous
pouvons également ne sélectionner que certains éléments.
Nous devons ensuite choisir la destination des informations de notre historique. Nous avons le
choix entre Windows Event Log, les fichiers textes, les fichiers XML, les fichiers SQL Server ou encore
les fichiers SQL Profiler. Il nous faut ensuite créer la connexion vers le bon fichier dans la partie
Configuration.
Pour finir, il nous reste à sélectionner les événements à enregistrer, ci-dessous la liste de ces
événements.
Chaque événement possède une description, nous ne les détaillerons donc pas.
Dotnet France Association
9
Outils complémentaires
09/09/2009
6 Gestionnaire d’événements
6.1 Définition
SSIS fournit le moyen de surveiller l’exécution et le déclenchement de certains événements afin
d’exécuter d’autres opérations lorsque ces déclenchements arrivent. Par exemple, si une erreur
apparait, le gestionnaire d’événement Error peut envoyer une alerte ou tenter de fixer lui-même le
problème.
6.2 Configuration
Pour ajouter un événement, il faut aller dans l’onglet Event Handlers, choisir l’exécutable (la
tâche sur laquelle on souhaite appliquer un l’événement) ainsi que l’événement. Il suffit ensuite de
glisser les tâches que l’on souhaite utiliser.
Nous allons à présent détailler tous les événements disponibles :
-
OnError : s’exécute lorsqu’une tâche ou un conteneur rapporte une erreur.
OnExecStatusChanged : s’exécute pour toutes les tâches ou conteneurs quand le statut
d’exécution du package passe à In process, Success ou Failed.
OnInformation : s’exécute lorsque SSIS envoie des messages d’information durant
l’exécution d’une tâche ou d’un conteneur.
OnPostExecute : s’exécute après qu’une tâche ou qu’un conteneur se soit complètement
exécuté.
OnPostValidate : s’exécute après qu’une tâche ou qu’un conteneur ait été validé.
OnPreExecute : s’exécute juste avant qu’un conteneur ou qu’une tâche ne soit exécuté.
OnPreValidate : s’exécute avant qu’un conteneur ou qu’une tâche ne soit validé.
OnProgress : s’exécute quand un message d’avancement est envoyé par SSIS, indiquant
l’avancement de la tâche ou du conteneur.
OnQueryCancel : est utilisé quand une tâche Exécuter une requête SQL est annulée par une
intervention manuelle, comme un arrêt du package.
OnTaskFailed : Similaire à OnError, mais s’exécute quand une tâche échoue plutôt que
chaque fois qu’une erreur apparait.
OnVariableValueChanged : s’exécute quand la valeur d’une variable change et pour laquelle
la propriété RaiseChangeEvent est mise à True.
OnWarning : s’exécute lorsqu’une tâche renvoie un événement dangereux.
Dotnet France Association
10
Outils complémentaires
09/09/2009
7 Debugging
Le debugging des packages permet de savoir ce qu’il se passe durant l’exécution de notre
package, ainsi nous pouvons vérifier que tout se déroule bien. De plus, nous pouvons implémenter
des points d’arrêt au sein de notre flux de contrôle qui mettront en pause l’exécution afin d’observer
son état. Pour mettre en place des points d’arrêt, soit nous appuyons sur F9 soit menu Debug>Toggle
Breakpoint.
Lors d’une pause, il est possible d’effectuer des actions telles que voir toutes les variables et la
statut du package. Pour voir ces informations, il faut sélectionner Windows dans le menue Debug
puis Locals.
Dotnet France Association
11
Outils complémentaires
09/09/2009
8 Conclusion
Vous êtes maintenant complètement capable de créer un package fonctionnel répondant à vos
besoins. Vous devriez pouvoir vous plier à toutes les contraintes que vous souhaitez imposer à votre
package. Dans la suite du cours, nous verrons comment gérer notre package une fois que celui-ci est
terminé.
Dotnet France Association