Caricamento ed esecuzione di un pacchetto remoto a livello di programmazione

Si applica a: SQL Server SSIS Integration Runtime in Azure Data Factory

Per eseguire pacchetti remoti da un computer locale in cui non è installato Integration Services, avviare i pacchetti in modo che vengano eseguiti nel computer remoto in cui è installato Integration Services. A tale scopo, configurare il computer locale per l'uso di SQL Server Agent, un servizio Web o un componente remoto per avviare i pacchetti nel computer remoto. Se si tenta di avviare i pacchetti remoti direttamente dal computer locale, i pacchetti verranno caricati e ne verrà effettuato il tentativo di esecuzione dal computer locale. Se nel computer locale non è installato Integration Services, i pacchetti non verranno eseguiti.

In alternativa, è possibile eseguire un pacchetto remoto da un computer locale in cui è installato Integration Services. Per altre informazioni, vedere Caricamento ed esecuzione di un pacchetto locale a livello di programmazione.

Esecuzione di un pacchetto remoto nel computer remoto

Come accennato in precedenza, è possibile eseguire un pacchetto remoto in un server remoto in vari modi:

• Usare SQL Server Agent per eseguire il pacchetto remoto a livello di programmazione

• Usare un servizio Web o un componente remoto per eseguire il pacchetto remoto a livello di programmazione

Quasi tutti i metodi usati in questo argomento per caricare e salvare pacchetti richiedono un riferimento all'assembly Microsoft.SqlServer.ManagedDTS. Fa eccezione l'approccio ADO.NET illustrato in questo argomento per l'esecuzione della stored procedure sp_start_job, che richiede solo un riferimento a System.Data. Dopo aver aggiunto il riferimento all'assembly Microsoft.SqlServer.ManagedDTS in un nuovo progetto, importare lo spazio dei nomi Microsoft.SqlServer.Dts.Runtime con un'istruzione using o Imports.

Uso di SQL Server Agent per eseguire un pacchetto remoto a livello di codice nel server

L'esempio di codice seguente dimostra come usare SQL Server Agent a livello di programmazione per eseguire un pacchetto remoto nel server. Il codice di esempio chiama la stored procedure di sistema sp_start_job, che avvia un processo di SQL Server Agent. Il processo avviato dalla stored procedure è denominato RunSSISPackage e si trova nel computer remoto. Il processo RunSSISPackage esegue quindi il pacchetto nel computer remoto.

Per informazioni su come risolvere i problemi legati all'esecuzione di pacchetti dai processi di SQL Server Agent, vedere l'articolo Microsoft Il pacchetto SSIS non viene eseguito quando viene chiamato da un passaggio del processo di SQL Server Agent.

Codice di esempio

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();  
    }  
  }  
}  

Uso di un servizio Web o di un componente remoto per eseguire un pacchetto remoto a livello di codice

La soluzione precedente per l'esecuzione dei pacchetti a livello di programmazione nel server non richiede codice personalizzato nel server. Tuttavia, può essere preferibile una soluzione che non si basa su SQL Server Agent per l'esecuzione dei pacchetti. Nell'esempio seguente sono illustrati un servizio Web che è possibile creare nel server per avviare i pacchetti di Integration Services in locale e un'applicazione di test che può essere usata per chiamare il servizio Web da un computer client. Se si preferisce creare un componente remoto anziché un servizio Web, è possibile usare lo stesso codice con poche modifiche in un computer remoto. Tuttavia, un componente remoto può richiedere una configurazione più estesa rispetto a un servizio Web.

Codice di esempio

Negli esempi di codice seguenti è illustrato come creare e testare il servizio Web.

Creazione del servizio Web

Un pacchetto di Integration Services può essere caricato direttamente da un file, direttamente da SQL Server o dall'archivio pacchetti SSIS, che gestisce l'archiviazione di pacchetti in SQL Server e in cartelle speciali del file system. Questo esempio supporta tutte le opzioni disponibili usando un costrutto Select Case o switch per selezionare la sintassi appropriata per l'avvio del pacchetto e per concatenare gli argomenti di input in modo appropriato. Il metodo LaunchPackage del servizio Web restituisce il risultato dell'esecuzione del pacchetto come numero intero anziché come valore DTSExecResult, per cui i computer client non richiedono un riferimento agli assembly di Integration Services.

Per creare un servizio Web per eseguire i pacchetti nel server a livello di programmazione

1. Aprire Visual Studio e creare un progetto di servizio Web nel linguaggio di programmazione preferito. Nel codice di esempio viene utilizzato il nome LaunchSSISPackageService per il progetto.

2. Aggiungere un riferimento a Microsoft.SqlServer.ManagedDTS e un'istruzione Imports o using al file codice per lo spazio dei nomi Microsoft.SqlServer.Dts.Runtime.

3. Incollare il codice di esempio per il metodo LaunchPackage del servizio Web nella classe. In questo esempio viene visualizzato l'intero contenuto della finestra del codice.

4. Compilare e testare il servizio Web fornendo un set di valori validi per gli argomenti di input del metodo LaunchPackage che puntano a un pacchetto esistente. Ad esempio, se package1.dtsx è archiviato nel server in C:\My Packages, passare "file" come valore di sourceType, "C:\My Packages" come valore di sourceLocation e "package1" (senza l'estensione) come valore di 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 del servizio Web

Nell'applicazione console di esempio seguente viene utilizzato il servizio Web per eseguire un pacchetto. Il metodo LaunchPackage del servizio Web restituisce il risultato dell'esecuzione del pacchetto come numero intero anziché come valore DTSExecResult, per cui i computer client non richiedono un riferimento agli assembly di Integration Services. Nell'esempio viene creata un'enumerazione privata i cui valori rispecchiano i valori DTSExecResult per riportare i risultati dell'esecuzione.

Per creare un'applicazione console per testare il servizio Web

1. In Visual Studio aggiungere una nuova applicazione console, utilizzando il linguaggio di programmazione preferito, nella stessa soluzione che contiene il progetto di servizio Web. Nell'esempio di codice viene utilizzato il nome LaunchSSISPackageTest per il progetto.

2. Impostare la nuova applicazione console come progetto di avvio nella soluzione.

3. Aggiungere un riferimento Web per il progetto di servizio Web. Se necessario, modificare la dichiarazione di variabili nell'esempio di codice per il nome assegnato all'oggetto proxy del servizio Web.

4. Incollare l'esempio di codice per la routine principale e l'enumerazione privata nel codice. In questo esempio viene visualizzato l'intero contenuto della finestra del codice.

5. Modificare la riga di codice che chiama il metodo LaunchPackage per fornire un set di valori validi per gli argomenti di input che puntano a un pacchetto esistente. Ad esempio, se package1.dtsx è archiviato nel server in C:\My Packages, passare "file" come valore di sourceType, "C:\My Packages" come valore di sourceLocation e "package1" (senza l'estensione) come valore di packageName.

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

Risorse esterne

• Video relativo alla procedura sull'automazione dell'esecuzione di un pacchetto SSIS usando SQL Server Agent (video di SQL Server) nel sito technet.microsoft.com

Vedi anche

Differenze tra l'esecuzione locale e remota
Caricamento ed esecuzione di un pacchetto locale a livello di programmazione
Caricamento dell'output di un pacchetto locale