Équilibrage de charge de packages sur des serveurs distants à l'aide de l'Agent SQL ServerLoad-Balancing Packages on Remote Servers by Using SQL Server Agent

Lorsque plusieurs packages doivent être exécutés, il convient d'utiliser d'autres serveurs disponibles.When many packages have to be run, it is convenient to use other servers that are available. Cette méthode qui consiste à utiliser d'autres serveurs pour exécuter des packages lorsque les packages sont tous sous le contrôle d'un package parent est qualifiée d'équilibrage de charge.This method of using other servers to run packages when the packages are all under the control of one parent package is called load balancing. Dans SQL ServerSQL Server Integration ServicesIntegration Services, l'équilibrage de charge est une procédure manuelle qui doit être mise en œuvre par les propriétaires des packages.In SQL ServerSQL Server Integration ServicesIntegration Services, load balancing is a manual procedure that must be architected by the owners of the packages. L'équilibrage de charge n'est pas exécuté automatiquement par les serveurs.Load balancing is not performed automatically by the servers. En outre, les packages qui sont exécutés sur des serveurs distants doivent être des packages complets, et non des tâches individuelles contenues dans d'autres packages.Also, the packages that are run on the remote servers must be whole packages, not individual tasks in other packages.

L'équilibrage de charge peut être utile dans les scénarios suivants :Load balancing is useful in the following scenarios:

  • Des packages peuvent être exécutés simultanément.Packages can run at the same time.

  • Des packages sont volumineux et, s'ils sont exécutés en séquence, peuvent s'exécuter plus longtemps que la période impartie au traitement.Packages are large and, if run sequentially, can run longer than the time allowed for processing.

    Les administrateurs et les architectes peuvent déterminer si l'utilisation de serveurs supplémentaires pour le traitement sera avantageuse pour leurs processus.Administrators and architects can determine whether using additional servers for processing would benefit their processes.

Illustration de l'équilibrage de chargeIllustration of Load-Balancing

Le schéma ci-dessous représente un package parent sur un serveur.The following diagram shows a parent package on a server. Le package parent contient plusieurs tâches Exécuter le travail de l'Agent SQL Server.The parent package contains multiple Execute SQL Job Agent tasks. Chaque tâche dans le package parent appelle un Agent SQL Server sur un serveur distant.Each task in the parent package calls a SQL Server Agent on a remote server. Ces serveurs distants contiennent des travaux de l'Agent SQL Server qui incluent une étape appelant un package sur ce serveur.Those remote servers contain SQL Server Agent jobs that include a step that calls a package on that server.

Aperçu de l’architecture de l’équilibrage de charge SSISOverview of SSIS load balancing architecture

Les étapes requises pour l'équilibrage de charge dans cette architecture ne sont pas de nouveaux concepts.The steps required for load balancing in this architecture are not new concepts. L'équilibrage de charge est plutôt obtenu en utilisant autrement des concepts existants et des objets SSIS communs.Instead, load balancing is achieved by using existing concepts and common SSIS objects in a new way.

Exécution de packages sur une instance distante à l'aide de l'Agent SQL ServerExecution of Packages on a Remote Instance by using SQL Server Agent

Dans l'architecture de base pour l'exécution de packages distants, un package central réside sur l'instance de SQL Server qui contrôle les autres packages distants.In the basic architecture for remote package execution, a central package resides on the instance of SQL Server that controls the other remote packages. Le schéma montre ce package central, nommé le SSIS parent.The diagram shows this central package, named the SSIS Parent. L'instance où réside ce package parent contrôle l'exécution des travaux de l'Agent SQL Server qui s'exécutent sur les packages enfants.The instance where this parent package resides controls execution of the SQL Server Agent jobs that run the child packages. Les packages enfants ne sont pas exécutés selon une planification fixe contrôlée par l'Agent SQL Server sur le serveur distant.The child packages are not run according to a fixed schedule controlled by the SQL Server Agent on the remote server. Les packages enfants sont plutôt démarrés par l'Agent SQL Server lorsqu'ils sont appelés par le package parent et ils s'exécutent sur l'instance de SQL Server sur laquelle réside l'Agent SQL Server.Instead, the child packages are started by the SQL Server Agent when called by the parent package and are run on the same instance of SQL Server on which the SQL Server Agent resides.

Avant que vous puissiez exécuter un package distant à l'aide de l'Agent SQL Server, vous devez configurer les packages parents et enfants et configurer les travaux de l'Agent SQL Server qui contrôlent les packages enfants.Before you can run a remote package by using SQL Server Agent, you must configure the parent and child packages and set up the SQL Server Agent jobs that control the child packages. Les sections suivantes fournissent d'autres informations sur la création, la configuration, l'exécution et la maintenance de packages exécutés sur des serveurs distants.The following sections provide more information about how to create, configure, run, and maintain packages that run on remote servers. Ce processus comporte plusieurs étapes :There are several steps to this process:

  • Création des packages enfants et installation de ceux-ci sur des serveurs distants.Creating the child packages and installing them on remote servers.

  • Création des travaux de l'Agent SQL Server sur les instances distantes qui exécuteront les packages.Creating the SQL Server Agent jobs on the remote instances that will run the packages.

  • Création du package parent.Creating the parent package.

  • Déterminez le scénario de journalisation pour les packages enfants.Determine the logging scenario for the child packages.

Implémentation de packages enfantsImplementation of Child Packages

Quand vous implémentez un équilibrage de charge avec Integration ServicesIntegration Services, des packages enfants sont installés sur d’autres serveurs pour tirer parti du temps UC ou serveur disponible.When you implement load balancing using Integration ServicesIntegration Services, child packages are installed on other servers to take advantage of the available CPU or server time. Pour créer et exécuter les packages enfants, les opérations suivantes sont nécessaires :To create and run the child packages requires the following steps:

  • Conception des packages enfants.Designing the child packages.

  • Déplacement des packages sur le serveur distant.Moving the packages to the remote server.

  • Création d'un travail de SQL Server Agent sur le serveur distant qui contient une étape exécutant le package enfant.Creating a SQL Server Agent Job on the remote server that contains a step that runs the child package.

  • Test et débogage du travail de SQL Server Agent et des packages enfants.Testing and debugging the SQL Server Agent Job and child packages.

    Lorsque vous concevez les packages enfants, les packages n'ont pas de limites dans leur conception, et vous pouvez inclure toutes les fonctionnalités souhaitées.When you design the child packages, the packages have no limitations in their design, and you can put in any functionality you desire. Cependant, si le package accède à des données, vous devez vous assurer que le serveur qui exécute le package a accès aux données.However, if the package accesses data, you must ensure that the server that runs the package has access to the data.

    Pour identifier le package parent qui exécute les packages enfants, dans Outils de données SQL Server (SSDT)SQL Server Data Tools (SSDT) , cliquez avec le bouton droit sur le package dans l’Explorateur de solutions et sélectionnez Package de point d’entrée.To identify the parent package that executes child packages, in Outils de données SQL Server (SSDT)SQL Server Data Tools (SSDT) right click the package in Solution Explorer and then click Entry-point Package.

    Une fois que les packages enfants ont été conçus, l'étape suivante consiste à les déployer sur les serveurs distants.After the child packages have been designed, the next step is to deploy them on the remote servers.

Déplacement du package enfant sur le serveur distant.Moving the Child Package to the Remote Instance

Il existe plusieurs façons de déplacer des packages sur d'autres serveurs.There are multiple ways to move packages to other servers. Les deux méthodes suggérées sont les suivantes :The two suggested methods are:

  • Exportation des packages à l'aide de SQL Server Management StudioSQL Server Management Studio.Exporting packages by using SQL Server Management StudioSQL Server Management Studio.

  • Déploiement de packages en créant un utilitaire de déploiement pour le projet qui contient les packages que vous voulez déployer, puis en exécutant l'Assistant Installation de package pour installer les packages sur le système de fichiers ou sur une instance de SQL ServerSQL Server.Deploying packages by building a deployment utility for the project that contains the packages you want to deploy, and then running the Package Installation Wizard to install the packages to the file system or to an instance of SQL ServerSQL Server. Pour plus d’informations, consultez Déploiement de packages hérités (SSIS).For more information, see Legacy Package Deployment (SSIS).

    Vous devez recommencer le déploiement sur chaque serveur distant à utiliser.You must repeat the deployment to each remote server you want to use.

Création des travaux de SQL Server AgentCreating the SQL Server Agent Jobs

Une fois que les packages enfants ont été déployés sur les divers serveurs, créez un travail de SQL Server Agent sur chaque serveur contenant un package enfant.After the child packages have been deployed to the various servers, create a SQL Server Agent job on each server that contains a child package. Le travail de SQL Server Agent contient une étape qui exécute le package enfant lors de l'appel de l'agent du travail.The SQL Server Agent job contains a step that runs the child package when the job agent is called. Les travaux de SQL Server Agent ne sont pas des travaux planifiés ; ils exécutent les packages enfants uniquement lorsqu'ils sont appelés par le package parent.The SQL Server Agent jobs are not scheduled jobs; they run the child packages only when they are called by the parent package. La notification de la réussite ou de l'échec du travail au package parent reflète la réussite ou l'échec du travail de SQL Server Agent et l'aboutissement de son appel, et non la réussite ou l'échec du package enfant ou son éventuelle exécution.Notification of success or failure of the job back to the parent package reflects the success or failure of the SQL Server Agent job and whether it was called successfully, not the success or failure of the child package or whether it was executed.

Débogage des travaux de SQL Server Agent et des packages enfants.Debugging the SQL Server Agent Jobs and Child Packages

Vous pouvez tester les travaux de SQL Server Agent et leurs packages enfants à l'aide de l'une des méthodes suivantes :You can test the SQL Server Agent jobs and their child packages by using one of the following methods:

  • Exécution de chaque package enfant dans le concepteur SSIS, en cliquant sur Déboguer / Exécuter sans débogage.Running each child package in SSIS Designer, by clicking Debug / Start Without Debugging.

  • Exécution du travail individuel de SQL Server Agent sur l’ordinateur distant à l’aide de SQL Server Management StudioSQL Server Management Studio, pour vérifier que le package fonctionne.Running the individual SQL Server Agent job on the remote computer by using SQL Server Management StudioSQL Server Management Studio, to make sure that the package runs.

    Pour plus d’informations sur la résolution des problèmes liés aux packages que vous exécutez à partir des travaux de SQL ServerSQL Server Agent, consultez Un package SSIS ne s’exécute pas lorsque vous appelez le package SSIS à partir d’une étape de travail de SQL Server Agent dans la Base de connaissances du support technique MicrosoftMicrosoft .For information about how to troubleshoot packages that you run from SQL ServerSQL Server Agent jobs, see An SSIS package does not run when you call the SSIS package from a SQL Server Agent job step in the MicrosoftMicrosoft Support Knowledge Base.

    SQL Server Agent vérifie l'accès au sous-système pour un proxy et donne accès au proxy à chaque exécution de l'étape de travail.The SQL Server Agent checks subsystem access for a proxy and gives access to the proxy every time the job step runs.

    Vous pouvez créer un proxy dans SQL Server Management StudioSQL Server Management Studio.You can create a proxy in SQL Server Management StudioSQL Server Management Studio.

Implémentation du package parentImplementation of the Parent Package

Lors d'un équilibrage de charge de packages SSIS entre serveurs, l'étape suivante après la création et le déploiement des packages enfants, puis la création des travaux de SQL Server Agent distants pour les exécuter, consiste à créer le package parent.When load balancing SSIS packages across various servers, the next step after the child packages have been created, deployed, and remote SQL Server Agent Jobs created to run them, is to create the parent package. Le package parent contient de nombreuses tâches Exécuter le travail de SQL Server Agent, chaque tâche étant responsable de l'appel d'un travail de SQL Server Agent qui exécute l'un des packages enfants.The parent package will contain many Execute SQL Server Agent Job tasks, each task responsible for calling a different SQL Server Agent job that runs one of the child packages. Les tâches Exécuter le travail de SQL Server Agent dans le package parent exécutent les différents travaux de SQL Server Agent.The Execute SQL Server Agent Job tasks in the parent package in turn run the various SQL Server Agent jobs. Chaque tâche dans le package parent contient des informations précisant notamment comment établir la connexion au serveur distant et quel travail exécuter sur ce serveur.Each task in the parent package contains information such as how to connect to the remote server and what job to run on that server. Pour plus d'informations, consultez Execute SQL Server Agent Job Task.For more information, see Execute SQL Server Agent Job Task.

Pour identifier le package parent qui exécute les packages enfants, dans Outils de données SQL Server (SSDT)SQL Server Data Tools (SSDT) , cliquez avec le bouton droit sur le package dans l’Explorateur de solutions et sélectionnez Package de point d’entrée.To identify the parent package that executes child packages, in Outils de données SQL Server (SSDT)SQL Server Data Tools (SSDT) right click the package in Solution Explorer and then click Entry-point Package.

Liste des packages enfantsListing Child Packages

Si vous déployez votre projet qui contient un package parent et des packages enfants sur le serveur Integration ServicesIntegration Services , vous pouvez afficher une liste des packages enfants qui sont exécutés par le package parent.If you deploy your project that contains a parent package and child package(s) to the Integration ServicesIntegration Services server, you can view a list of the child packages that are executed by the parent package. Lorsque vous exécutez le package parent, un rapport Vue d'ensemble sur ce package est généré automatiquement dans SQL Server Management StudioSQL Server Management Studio.When you run the parent package, an Overview report for the parent package is automatically generated in SQL Server Management StudioSQL Server Management Studio. Ce rapport répertorie les packages enfants qui ont été exécutés par la tâche Exécuter le package contenue dans le package parent, comme illustré par l'image ci-dessous.The report lists the child packages that were executed by the Execute Package task contained in the parent package, as shown in the following image.

Rapport Vue d’ensemble avec liste des packages enfantsOverview Report with list of child packages

Pour plus d'informations sur l'accès au rapport Vue d'ensemble , consultez Reports for the Integration Services Server.For information about accessing the Overview report, see Reports for the Integration Services Server.

Contraintes de priorité dans le package parentPrecedence Constraints in the Parent Package

Lorsque vous créez des contraintes de priorité entre les tâches Exécuter le travail de SQL Server Agent dans le package parent, ces contraintes de priorité contrôlent uniquement le moment de démarrage des travaux de SQL Server Agent sur les serveurs distants.When you create precedence constraints between the Execute SQL Server Agent Job tasks in the parent package, these precedence constraints control only the time that the SQL Server Agent jobs on the remote servers are started. Les contraintes de priorité ne peuvent pas recevoir d'informations sur la réussite ou l'échec des packages enfants qui sont exécutés à partir à des étapes des travaux de SQL Server Agent.Precedence constraints cannot receive information regarding the success or failure of the child packages that are run from the steps of the SQL Server Agent jobs.

Cela signifie que le succès ou l'échec d'un package enfant ne se propage pas au parent, puisque la seule fonction de la tâche Exécuter le travail de SQL Server Agent dans le package parent consiste à demander au travail de SQL Server Agent d'exécuter le package enfant.This means that success or failure of a child package does not propagate to the parent, because the sole function of the Execute SQL Server Agent job in the parent package is to request the SQL Server Agent job to run the child package. Une fois que le travail de SQL Server Agent a été appelé, le package parent reçoit un résultat de Success.After the SQL Server Agent job is called successfully, the parent package receives a result of Success.

L'échec de ce scénario signifie uniquement que l'appel de la tâche Exécuter le travail de SQL Server Agent a échoué.Failure in this scenario means only that there has been a failure in calling the remote SQL Server Agent Job task. Cette situation peut notamment se produire lorsque le serveur distant est hors service et que l'agent ne répond pas.One situation where this can occur is when the remote server is down and the agent does not respond. Cependant, tant que l'agent se déclenche, le package a exécuté sa tâche avec succès.However, as long as the agent fires, the parent package has successfully completed its task.

Note

Vous pouvez utiliser une tâche d’exécution SQL qui contient une instruction Transact-SQL sp_start_job N'nom_package'.You can use an Execute SQL Task that contains a Transact-SQL statement of sp_start_job N'package_name'. Pour plus d’informations, consultez sp_start_job (Transact-SQL).For more information, see sp_start_job (Transact-SQL).

Environnement de débogageDebugging Environment

Lors du test du package parent, utilisez l'environnement de débogage du concepteur en l'exécutant à l'aide des commandes Déboguer / Démarrer le débogage (F5).When testing the parent package, use the debugging environment of the designer by running it using Debug / Start Debugging (F5). Vous pouvez également utiliser l'utilitaire d'invite de commandes, dtexec.Alternatively, you can use the command prompt utility, dtexec. Pour plus d’informations, voir dtexec Utility.For more information, see dtexec Utility.

Journalisation des packages à charge équilibrée sur les serveurs distantsLogging for Load Balanced Packages on Remote Servers

Il est plus facile pour un administrateur de gérer les journaux de tous les packages enfants en cours d'exécution sur différents serveurs lorsque tous ces packages enfants utilisent le même module fournisseur d'informations et qu'ils écrivent tous dans la même destination.It is easier for an administrator to manage the logs for all the child packages that are running on various servers when all the child packages use the same log provider and they all write to the same destination. Une manière de créer un fichier journal commun pour tous les packages enfants est de configurer les packages enfants de telle sorte qu'ils inscrivent leurs événements dans un module fournisseur d'informations SQL Server.One way that you can create a common log file for all child packages is to configure the child packages to log their events to a SQL Server log provider. Vous pouvez configurer tous les packages pour qu'ils utilisent la même base de données, le même serveur et la même instance du serveur.You can configure all the packages to use the same database, the same server, and the same instance of the server.

Pour afficher les fichiers journaux, l'administrateur n'a à se connecter qu'à un seul serveur pour afficher les fichiers journaux de tous les packages enfants.To view the log files, the administrator only has to log on to a single server to view the log files for all child packages.

Pour plus d’informations sur l’activation de la journalisation dans un package, consultez Journalisation d’Integration Services (SSIS).For information about how to enable logging in a package, see Integration Services (SSIS) Logging.

Travaux de SQL Server Agent pour les packagesSQL Server Agent Jobs for Packages