Chargement et exécution d'un package distant par programme
S’applique à :
SQL Server SSIS Integration Runtime dans Azure Data Factory
Pour exécuter des packages distants à partir d'un ordinateur local sur lequel Integration Services n'est pas installé, démarrez les packages afin qu'ils s'exécutent sur l'ordinateur distant sur lequel Integration Services est installé. Pour cela, vous faites utiliser par l'ordinateur local l'Agent SQL Server, un service Web ou un composant distant pour démarrer les packages sur l'ordinateur distant. Si vous essayez de démarrer directement les packages distants à partir de l'ordinateur local, les packages se chargeront sur l'ordinateur local et essayeront de s'exécuter à partir de ce dernier. Si Integration Services n'est pas installé sur l'ordinateur local, les packages ne s'exécuteront pas.
Notes
Vous ne pouvez pas exécuter de packages en dehors de SQL Server Data Tools sur un ordinateur client sur lequel Integration Services n’est pas installé, et les termes de votre licence SQL Server ne vous permettent peut-être pas d’installer Integration Services sur d’autres ordinateurs. (Integration Services est un composant serveur et n'est pas redistribuable aux ordinateurs clients.)
Alternativement, vous pouvez exécuter un package distant à partir d'un ordinateur local sur lequel Integration Services est installé. Pour plus d’informations, consultez Chargement et exécution d’un package local par programmation.
Exécution d'un package distant sur l'ordinateur distant
Comme mentionné précédemment, il existe plusieurs manières d'exécuter un package distant sur un serveur distant :
Utiliser SQL Server Agent pour exécuter le package distant par programmation
Utiliser un service web ou un composant distant pour exécuter le package distant par programmation
Presque toutes les méthodes utilisées dans cette rubrique pour charger et enregistrer des packages nécessitent une référence à l’assembly Microsoft.SqlServer.ManagedDTS. L’approche ADO.NET décrite dans cette rubrique pour exécuter la procédure stockée sp_start_job, laquelle nécessite uniquement une référence à System.Data, constitue la seule exception. Après avoir ajouté la référence à l’assembly Microsoft.SqlServer.ManagedDTS dans un nouveau projet, importez l’espace de noms Microsoft.SqlServer.Dts.Runtime avec une instruction using ou Imports.
Utilisation de l'Agent SQL Server pour exécuter par programme un package distant sur le serveur
L'exemple de code suivant montre comment utiliser par programme l'Agent SQL Server pour exécuter un package distant sur le serveur. L’exemple de code appelle la procédure stockée système, sp_start_job, qui lance un travail de SQL Server Agent. Le travail que la procédure lance est nommé RunSSISPackage, et ce travail se trouve sur l'ordinateur distant. Le travail RunSSISPackage exécute alors le package sur l'ordinateur distant.
Notes
La valeur retournée par la procédure stockée sp_start_job indique si la procédure stockée a pu démarrer correctement le travail de SQL Server Agent. La valeur de retour n'indique pas si le package a réussi ou a échoué.
Pour plus d’informations sur la résolution des problèmes liés aux packages que vous exécutez à partir des travaux de SQL Server, consultez l’article Microsoft intitulé Un package SSIS n’est pas exécuté quand vous appelez le package SSIS à partir d’une étape de travail de SQL Server Agent.
Exemple de code
Imports System.Data
Imports System.Data.SqlClient
Module Module1
Sub Main()
Dim jobConnection As SqlConnection
Dim jobCommand As SqlCommand
Dim jobReturnValue As SqlParameter
Dim jobParameter As SqlParameter
Dim jobResult As Integer
jobConnection = New SqlConnection("Data Source=(local);Initial Catalog=msdb;Integrated Security=SSPI")
jobCommand = New SqlCommand("sp_start_job", jobConnection)
jobCommand.CommandType = CommandType.StoredProcedure
jobReturnValue = New SqlParameter("@RETURN_VALUE", SqlDbType.Int)
jobReturnValue.Direction = ParameterDirection.ReturnValue
jobCommand.Parameters.Add(jobReturnValue)
jobParameter = New SqlParameter("@job_name", SqlDbType.VarChar)
jobParameter.Direction = ParameterDirection.Input
jobCommand.Parameters.Add(jobParameter)
jobParameter.Value = "RunSSISPackage"
jobConnection.Open()
jobCommand.ExecuteNonQuery()
jobResult = DirectCast(jobCommand.Parameters("@RETURN_VALUE").Value, Integer)
jobConnection.Close()
Select Case jobResult
Case 0
Console.WriteLine("SQL Server Agent job, RunSISSPackage, started successfully.")
Case Else
Console.WriteLine("SQL Server Agent job, RunSISSPackage, failed to start.")
End Select
Console.Read()
End Sub
End Module
using System;
using System.Data;
using System.Data.SqlClient;
namespace LaunchSSISPackageAgent_CS
{
class Program
{
static void Main(string[] args)
{
SqlConnection jobConnection;
SqlCommand jobCommand;
SqlParameter jobReturnValue;
SqlParameter jobParameter;
int jobResult;
jobConnection = new SqlConnection("Data Source=(local);Initial Catalog=msdb;Integrated Security=SSPI");
jobCommand = new SqlCommand("sp_start_job", jobConnection);
jobCommand.CommandType = CommandType.StoredProcedure;
jobReturnValue = new SqlParameter("@RETURN_VALUE", SqlDbType.Int);
jobReturnValue.Direction = ParameterDirection.ReturnValue;
jobCommand.Parameters.Add(jobReturnValue);
jobParameter = new SqlParameter("@job_name", SqlDbType.VarChar);
jobParameter.Direction = ParameterDirection.Input;
jobCommand.Parameters.Add(jobParameter);
jobParameter.Value = "RunSSISPackage";
jobConnection.Open();
jobCommand.ExecuteNonQuery();
jobResult = (Int32)jobCommand.Parameters["@RETURN_VALUE"].Value;
jobConnection.Close();
switch (jobResult)
{
case 0:
Console.WriteLine("SQL Server Agent job, RunSISSPackage, started successfully.");
break;
default:
Console.WriteLine("SQL Server Agent job, RunSISSPackage, failed to start.");
break;
}
Console.Read();
}
}
}
Utilisation d'un service Web ou composant distant pour exécuter un package distant par programme
La solution précédente pour l'exécution de packages par programme sur le serveur ne requiert pas de code personnalisé sur le serveur. Toutefois, vous pouvez préférer une solution qui ne compte pas sur l'Agent SQL Server pour exécuter des packages. L'exemple suivant présente un service Web qui peut être créé sur le serveur pour démarrer des packages Integration Services localement, ainsi qu'une application de test qui peut être utilisée pour appeler le service Web à partir d'un ordinateur client. Si vous préférez créer un composant distant au lieu d’un service web, vous pouvez utiliser la même logique de code avec très peu de changements dans un composant distant. Toutefois, un composant distant risque de requérir une configuration plus approfondie qu'un service Web.
Important
Avec ses paramètres par défaut pour l'authentification et l'autorisation, un service Web ne dispose généralement pas des autorisations suffisantes pour accéder à SQL Server ou au système de fichiers afin de charger et d'exécuter des packages. Vous risquez de devoir attribuer les autorisations appropriées au service web en configurant ses paramètres d’authentification et d’autorisation dans le fichier web.config et en attribuant les autorisations d’accès appropriées à la base de données et au système de fichiers. La description complète des autorisations Web, de base de données et de système de fichiers sort de la portée de cette rubrique.
Important
Les méthodes de la classe Application qui permettent d’utiliser le magasin de packages SSIS prennent uniquement en charge « . », localhost ou le nom du serveur local. Vous ne pouvez pas utiliser « (local) ».
Exemple de code
Les exemples de code suivants indiquent comment créer et tester le service Web.
Création du service Web
Un package Integration Services peut être chargé directement à partir d'un fichier, directement à partir de SQL Server ou à partir du magasin de packages SSIS, lequel gère le stockage des packages dans SQL Server et des dossiers spéciaux du système de fichiers. Cet exemple prend en charge toutes les options disponibles en utilisant une construction Select Case ou switch pour sélectionner la syntaxe appropriée au démarrage du package et pour concaténer les arguments d’entrée convenablement. La méthode de service Web LaunchPackage renvoie le résultat de l'exécution du package sous la forme d'un entier plutôt que d'une valeur DTSExecResult afin que les ordinateurs clients ne requièrent pas de référence aux assemblys Integration Services.
Pour créer un service Web afin d'exécuter par programme des packages sur le serveur
Ouvrez Visual Studio et créez un projet de service Web dans votre langage de programmation préféré. L'exemple de code utilise le nom LaunchSSISPackageService pour le projet.
Ajoutez une référence à Microsoft.SqlServer.ManagedDTS et ajoutez une instruction Imports ou using au fichier de code de l’espace de noms Microsoft.SqlServer.Dts.Runtime.
Collez l'exemple de code pour la méthode de service Web LaunchPackage dans la classe. (L'exemple présente tout le contenu de la fenêtre de code.)
Générez et testez le service Web en fournissant un jeu de valeurs valides pour les arguments d'entrée de la méthode LaunchPackage qui pointent vers un package existant. Par exemple, si package1.dtsx est stocké sur le serveur dans C:\My Packages, passez « file » comme valeur de sourceType, « C:\My Packages » comme valeur de sourceLocation et « package1 » (sans l'extension) comme valeur de packageName.
Imports System.Web
Imports System.Web.Services
Imports System.Web.Services.Protocols
Imports Microsoft.SqlServer.Dts.Runtime
Imports System.IO
<WebService(Namespace:="https://dtsue/")> _
<WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Public Class LaunchSSISPackageService
Inherits System.Web.Services.WebService
' LaunchPackage Method Parameters:
' 1. sourceType: file, sql, dts
' 2. sourceLocation: file system folder, (none), logical folder
' 3. packageName: for file system, ".dtsx" extension is appended
<WebMethod()> _
Public Function LaunchPackage( _
ByVal sourceType As String, _
ByVal sourceLocation As String, _
ByVal packageName As String) As Integer 'DTSExecResult
Dim packagePath As String
Dim myPackage As Package
Dim integrationServices As New Application
' Combine path and file name.
packagePath = Path.Combine(sourceLocation, packageName)
Select Case sourceType
Case "file"
' Package is stored as a file.
' Add extension if not present.
If String.IsNullOrEmpty(Path.GetExtension(packagePath)) Then
packagePath = String.Concat(packagePath, ".dtsx")
End If
If File.Exists(packagePath) Then
myPackage = integrationServices.LoadPackage(packagePath, Nothing)
Else
Throw New ApplicationException( _
"Invalid file location: " & packagePath)
End If
Case "sql"
' Package is stored in MSDB.
' Combine logical path and package name.
If integrationServices.ExistsOnSqlServer(packagePath, ".", String.Empty, String.Empty) Then
myPackage = integrationServices.LoadFromSqlServer( _
packageName, "(local)", String.Empty, String.Empty, Nothing)
Else
Throw New ApplicationException( _
"Invalid package name or location: " & packagePath)
End If
Case "dts"
' Package is managed by SSIS Package Store.
' Default logical paths are File System and MSDB.
If integrationServices.ExistsOnDtsServer(packagePath, ".") Then
myPackage = integrationServices.LoadFromDtsServer(packagePath, "localhost", Nothing)
Else
Throw New ApplicationException( _
"Invalid package name or location: " & packagePath)
End If
Case Else
Throw New ApplicationException( _
"Invalid sourceType argument: valid values are 'file', 'sql', and 'dts'.")
End Select
Return myPackage.Execute()
End Function
End Class
using System;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;
using Microsoft.SqlServer.Dts.Runtime;
using System.IO;
[WebService(Namespace = "https://dtsue/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class LaunchSSISPackageServiceCS : System.Web.Services.WebService
{
public LaunchSSISPackageServiceCS()
{
}
// LaunchPackage Method Parameters:
// 1. sourceType: file, sql, dts
// 2. sourceLocation: file system folder, (none), logical folder
// 3. packageName: for file system, ".dtsx" extension is appended
[WebMethod]
public int LaunchPackage(string sourceType, string sourceLocation, string packageName)
{
string packagePath;
Package myPackage;
Application integrationServices = new Application();
// Combine path and file name.
packagePath = Path.Combine(sourceLocation, packageName);
switch(sourceType)
{
case "file":
// Package is stored as a file.
// Add extension if not present.
if (String.IsNullOrEmpty(Path.GetExtension(packagePath)))
{
packagePath = String.Concat(packagePath, ".dtsx");
}
if (File.Exists(packagePath))
{
myPackage = integrationServices.LoadPackage(packagePath, null);
}
else
{
throw new ApplicationException("Invalid file location: "+packagePath);
}
break;
case "sql":
// Package is stored in MSDB.
// Combine logical path and package name.
if (integrationServices.ExistsOnSqlServer(packagePath, ".", String.Empty, String.Empty))
{
myPackage = integrationServices.LoadFromSqlServer(packageName, "(local)", String.Empty, String.Empty, null);
}
else
{
throw new ApplicationException("Invalid package name or location: "+packagePath);
}
break;
case "dts":
// Package is managed by SSIS Package Store.
// Default logical paths are File System and MSDB.
if (integrationServices.ExistsOnDtsServer(packagePath, "."))
{
myPackage = integrationServices.LoadFromDtsServer(packagePath, "localhost", null);
}
else
{
throw new ApplicationException("Invalid package name or location: "+packagePath);
}
break;
default:
throw new ApplicationException("Invalid sourceType argument: valid values are 'file', 'sql', and 'dts'.");
}
return (Int32)myPackage.Execute();
}
}
Test du service Web
L'exemple d'application console suivant utilise le service Web pour exécuter un package. La méthode LaunchPackage du service Web renvoie le résultat de l'exécution du package sous la forme d'un entier plutôt que d'une valeur DTSExecResult afin que les ordinateurs clients ne requièrent pas de référence aux assemblys Integration Services. L'exemple crée une énumération privée dont les valeurs reflètent les valeurs DTSExecResult pour rapporter les résultats de l'exécution.
Pour créer une application console afin de tester le service Web
Dans Visual Studio, ajoutez une nouvelle application console, à l'aide de votre langage de programmation préféré, à la même solution que celle qui contient le projet de service Web. L'exemple de code utilise le nom LaunchSSISPackageTest pour le projet.
Définissez la nouvelle application console en tant que projet de démarrage dans la solution.
Ajoutez une référence Web pour le projet de service Web. Si nécessaire, ajustez la déclaration de variable dans l'exemple de code pour le nom que vous attribuez à l'objet proxy de service Web.
Collez l'exemple de code pour la routine principale et l'énumération privée dans le code. (L'exemple présente tout le contenu de la fenêtre de code.)
Modifiez la ligne de code qui appelle la méthode LaunchPackage afin de fournir un jeu de valeurs valides pour les arguments d'entrée qui pointent vers un package existant. Par exemple, si package1.dtsx est stocké sur le serveur dans C:\My Packages, passez « file » comme valeur de
sourceType, « C:\My Packages » comme valeur desourceLocationet « package1 » (sans l'extension) comme valeur depackageName.
Module LaunchSSISPackageTest
Sub Main()
Dim launchPackageService As New LaunchSSISPackageService.LaunchSSISPackageService
Dim packageResult As Integer
Try
packageResult = launchPackageService.LaunchPackage("sql", String.Empty, "SimpleTestPackage")
Catch ex As Exception
' The type of exception returned by a Web service is:
' System.Web.Services.Protocols.SoapException
Console.WriteLine("The following exception occurred: " & ex.Message)
End Try
Console.WriteLine(CType(packageResult, PackageExecutionResult).ToString)
Console.ReadKey()
End Sub
Private Enum PackageExecutionResult
PackageSucceeded
PackageFailed
PackageCompleted
PackageWasCancelled
End Enum
End Module
using System;
namespace LaunchSSISPackageSvcTestCS
{
class Program
{
static void Main(string[] args)
{
LaunchSSISPackageServiceCS.LaunchSSISPackageServiceCS launchPackageService = new LaunchSSISPackageServiceCS.LaunchSSISPackageServiceCS();
int packageResult = 0;
try
{
packageResult = launchPackageService.LaunchPackage("sql", String.Empty, "SimpleTestPackage");
}
catch (Exception ex)
{
// The type of exception returned by a Web service is:
// System.Web.Services.Protocols.SoapException
Console.WriteLine("The following exception occurred: " + ex.Message);
}
Console.WriteLine(((PackageExecutionResult)packageResult).ToString());
Console.ReadKey();
}
private enum PackageExecutionResult
{
PackageSucceeded,
PackageFailed,
PackageCompleted,
PackageWasCancelled
};
}
}
Ressources externes
- Vidéo, Procédure : automatiser l’exécution du package SSIS à l’aide de SQL Server Agent (vidéo de SQL Server), sur technet.microsoft.com
Voir aussi
Présentation des différences entre l’exécution locale et l’exécution distante
Chargement et exécution d'un package local par programme
Chargement de la sortie d'un package local
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour