Esecuzione di un pacchetto SSIS in fase di programmazione su un computer remoto

Se su un computer client (locale) non è installato Integration Services o se il computer non dispone dell'accesso a tutte le risorse richieste da un pacchetto, è necessario avviare il pacchetto in modo che venga eseguito sul computer remoto in cui è archiviato. È necessario eseguire passaggi aggiuntivi per assicurarsi che il pacchetto possa essere eseguito sul computer remoto, perché un pacchetto viene eseguito sullo stesso computer dell'applicazione che avvia il pacchetto. In questo modo, se si esegue un pacchetto remoto direttamente da un'applicazione sul computer locale, il pacchetto verrà caricato ed eseguito dal computer locale. Poiché sul computer locale non è installato Integration Services o il computer non dispone dell'accesso a tutte le risorse che il pacchetto richiede, quest'ultimo non verrà eseguito correttamente.

Nota

Su un computer client potrebbe non essere installato Integration Services perché i termini della licenza di SQL Server potrebbero non consentire l'installazione di Integration Services su computer aggiuntivi. Integration Services è un componente server e non è ridistribuibile a computer client. Tuttavia, se sul computer locale è installato Integration Services e il computer dispone dell'accesso a tutte le risorse che il pacchetto richiede, è possibile utilizzare il computer locale per eseguire un pacchetto remoto. Per ulteriori informazioni, vedere Esecuzione di un pacchetto SSIS a livello di programmazione sul computer locale.

Per avviare il pacchetto sul computer remoto, chiamare uno dei programmi seguenti:

• SQL Server Agent.

• Un'altra applicazione, componente o servizio Web che è in esecuzione sul computer remoto.

Sezioni dell'argomento Prerequisiti per il computer remoto Esecuzione di un pacchetto in modalità remota chiamando SQL Server Agent Esecuzione di un pacchetto in modalità remota chiamando un componente o servizio remoto

Prerequisiti per il computer remoto

È necessario assicurarsi che il processo che esegue il pacchetto sul computer remoto disponga delle autorizzazioni necessarie. Questo processo richiede l'autorizzazione non solo per avviare il pacchetto, ma anche per trovare e aprire tutte le risorse che il pacchetto utilizza. Le autorizzazioni predefinite spesso non sono sufficienti, specialmente in una soluzione basata sul Web. Una descrizione completa delle autorizzazioni e dell'autenticazione esula dall'ambito di questo argomento.

La rappresentazione di un altro account per eseguire il pacchetto spesso non è la soluzione corretta. Anche se il pacchetto viene avviato con l'account rappresentato, i thread aggiuntivi creati dal pacchetto vengono ripristinati sull'account utilizzato dal processo che ha avviato il pacchetto. Questi thread includono quelli utilizzati dal flusso di dati per caricare e salvare i dati. Pertanto, l'account del processo stesso richiede l'autorizzazione per la maggior parte delle risorse esterne utilizzate dal pacchetto.

Esecuzione di un pacchetto SSIS in modalità remota chiamando SQL Server Agent

Nel codice di esempio seguente è illustrato come chiamare SQL Server Agent a livello di programmazione per eseguire un pacchetto sul computer remoto. Tramite il codice di esempio viene chiamata la stored procedure di sistema, sp_start_job, tramite cui a sua volta viene avviato un processo SQL Server Agent denominato RunSSISPackage che si trova sul computer remoto. Il processo RunSSISPackage consente di eseguire quindi il pacchetto sul computer remoto in cui è in esecuzione il processo stesso.

Nota

Il valore restituito della stored procedure sp_start_job indica se tramite tale stored procedure è stata possibile avviare correttamente il processo SQL Server Agent. ma non indica se il pacchetto è stato o meno eseguito correttamente.

Per informazioni su come risolvere i problemi relativi all'esecuzione di pacchetti dai processi di SQL Server Agent, vedere l'articolo Microsoft, An SSIS package does not run when you call the SSIS package from a SQL Server Agent job step.

Codice di esempio

Per gli esempi di codice seguenti è richiesto un riferimento all'assembly System.Data.

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

Torna all'inizio

Esecuzione di un pacchetto SSIS in modalità remota chiamando un componente o servizio remoto

Nella sezione precedente, la soluzione per l'esecuzione di pacchetti a livello di programmazione su un computer remoto non richiede codice personalizzato sul computer. Tuttavia, può essere preferibile una soluzione che non si basa su SQL Server Agent per l'esecuzione dei pacchetti.

Nell'esempio seguente viene fornito codice parziale che potrebbe essere utilizzato in un componente remoto o un servizio Web sul server per avviare pacchetti Integration Services sul computer remoto.

Codice di esempio

Negli esempi di codice seguenti viene suggerito un approccio per la creazione e il test di una classe remota che esegue un pacchetto in modalità remota. Questi esempi non sono completi, ma forniscono codice che potrebbe essere utilizzato come parte di una soluzione creata come componente remoto o come servizio Web.

Per questo esempio è richiesto un riferimento all'assembly Microsoft.SqlServer.ManagedDTS.

Creazione della funzione per eseguire il pacchetto SSIS in modalità remota

Un pacchetto Integration Services può essere caricato direttamente da un file, da SQL Server o dall'archivio pacchetti SSIS, tramite cui viene gestita l'archiviazione di pacchetti in SQL Server e in cartelle speciali del file system. Per supportare tutte le opzioni di caricamento disponibili, in questo esempio viene utilizzato 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.

Importante
I metodi della classe Application per l'utilizzo dell'archivio pacchetti SSIS supportano solo ".", localhost o il nome del server locale. Non è possibile utilizzare "(local)".

Il metodo LaunchPackage restituisce il risultato dell'esecuzione del pacchetto come integer anziché come valore DTSExecResult per cui i computer client non richiedono un riferimento agli assembly di Integration Services.

Importante
Questo esempio non è completo, ma fornisce codice che potrebbe essere utilizzato come parte di una soluzione creata come componente remoto o come servizio Web. L'esempio non include il codice, gli attributi o i riferimenti che potrebbero essere necessari per compilare ed esporre un componente o un servizio remoto.

Per creare una classe remota per eseguire i pacchetti sul server a livello di programmazione

1. Aprire Visual Studio e creare un progetto del tipo appropriato nel linguaggio di programmazione preferito.

   Nel codice di esempio seguente viene utilizzato il nome LaunchSSISPackageService per il progetto.

2. Aggiungere un riferimento all'assembly Microsoft.SqlServer.ManagedDTS.

3. Incollare il codice di esempio nel file della classe.

   In questo esempio viene visualizzato l'intero contenuto della finestra del codice.

4. Aggiungere il codice, gli attributi o i riferimenti che potrebbero essere necessari per compilare ed esporre un componente o un servizio remoto.

5. Compilare e testare il progetto che include il codice di esempio.

Imports Microsoft.SqlServer.Dts.Runtime
Imports System.IO

Public Class LaunchSSISPackageService

  ' 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

  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 Microsoft.SqlServer.Dts.Runtime;
using System.IO;

public class LaunchSSISPackageServiceCS
{
  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

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

  }

}

Chiamata della funzione per eseguire il pacchetto SSIS in modalità remota

Nell'applicazione console di esempio seguente viene utilizzato il componente o servizio remoto per eseguire un pacchetto.

Il metodo LaunchPackage della classe remota 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 la classe remota

1. In Visual Studio, creare una nuova applicazione console utilizzando il linguaggio di programmazione preferito.

   Nel codice di esempio viene utilizzato il nome LaunchSSISPackageTest per il progetto.

2. Aggiungere un riferimento all'assembly del proxy locale che rappresenta il componente o il servizio remoto. Se necessario, modificare la dichiarazione di variabili nell'esempio di codice per il nome assegnato all'oggetto proxy.

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

4. 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
      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)
      {
        Console.WriteLine("The following exception occurred: " + ex.Message);
      }

      Console.WriteLine(((PackageExecutionResult)packageResult).ToString());
      Console.ReadKey();

    }

    private enum PackageExecutionResult
    {
      PackageSucceeded,
      PackageFailed,
      PackageCompleted,
      PackageWasCancelled
    };

  }
}

Torna all'inizio

Risorse esterne

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

Rimanere aggiornati con Integration Services Per informazioni sui download, gli articoli, gli esempi e i video Microsoft più recenti, nonché sulle soluzioni selezionate dalla community, visitare la pagina Integration Services su MSDN: Visitare la pagina relativa a Integration Services su MSDN Per ricevere notifiche automatiche su questi aggiornamenti, sottoscrivere i feed RSS disponibili nella pagina.

Vedere anche

Attivitá

Esecuzione di un pacchetto SSIS a livello di programmazione sul computer locale

Caricamento dell'output di un pacchetto in un altro programma