Executando um pacote SSIS programaticamente em um computador remoto

Se um computador cliente (local) não tiver o Integration Services instalado ou não tiver acesso a todos os recursos que um pacote exige, você deverá iniciar o pacote de forma que ele seja executado no computador remoto onde está armazenado. Você deve realizar etapas adicionais para assegurar que o pacote seja executado no computador remoto, porque um pacote é executado no mesmo computador que o aplicativo que o inicia. Portanto, se você iniciar um pacote remoto diretamente do aplicativo no computador local, ele será carregado e tentará executar do computador local. Como o computador local ou não tem o Integration Services instalado ou não tem acesso a todos os recursos que o pacote requer, ele não será executado com êxito.

Observação

Um computador cliente pode não ter o Integration Services instalado porque as condições da licença do SQL Server podem não permitir instalar o Integration Services em computadores adicionais. (O Integration Services é um componente de servidor e não é redistribuível a computadores cliente.) Porém, se o computador local tiver o Integration Services instalado e tiver acesso a todos os recursos que o pacote exigir, você poderá usar o computador local para executar um pacote remoto. Para obter mais informações, consulte Executando um pacote SSIS programaticamente no computador local.

Para iniciar o pacote no computador remoto, você chama um dos seguintes programas:

• SQL Server Agent.

• Outro aplicativo, componente ou serviço Web que estão sendo executados no computador remoto.

Seções deste tópico Pré-requisitos para o computador remoto Executando um pacote remotamente chamando o SQL Server Agent Executando um pacote remotamente chamando um componente ou serviço remoto

Pré-requisitos para o computador remoto

Você precisa garantir que o processo que executa o pacote no computador remoto tenha as permissões necessárias. Este processo não somente exige permissão para iniciar o pacote, mas para localizar e abrir todos os recursos que o pacote usa. As permissões padrão geralmente não são suficientes, principalmente em uma solução baseada na Web. Uma discussão completa sobre permissões, autenticação e autorização está além do escopo deste tópico.

Representar outra conta para executar o pacote não é geralmente uma solução bem-sucedida. Embora o pacote inicie sob a conta representada, os threads adicionais que são criados pelo pacote revertem à conta que é usada pelo processo que iniciou o pacote. Estes threads incluem os usados pelo fluxo de dados para carregar e salvar dados. Portanto, a própria conta de processo precisa de permissão para a maioria dos recursos externos usados pelo pacote.

Executando um pacote SSIS de forma remota chamando o SQL Server Agent

O código de exemplo a seguir demonstra como chamar o SQL Server Agent programaticamente para executar um pacote no servidor remoto. O código de exemplo chama o procedimento armazenado do sistema, sp_start_job, que, por sua vez, inicia um trabalho do SQL Server Agent denominado RunSSISPackage e está no computador remoto. O trabalho RunSSISPackage executa o pacote no computador remoto onde o próprio trabalho está sendo executado.

Observação
O valor de retorno do procedimento armazenado sp_start_job indica se ele conseguiu iniciar o trabalho do SQL Server Agent com êxito. O valor de retorno não indica se o pacote teve sucesso ou falhou.

Para obter informações sobre como solucionar problemas de pacotes executados nos trabalhos do SQL Server Agent, consulte o artigo Microsoft, Um pacote SSIS não é executado quando chamado a partir de uma etapa de trabalho do SQL Server Agent.

Código de exemplo

Os exemplos de código a seguir exigem uma referência para o 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();
    }
  }
}

Voltar ao início

Executando um pacote SSIS de forma remota chamando um componente ou serviço remoto

Na seção anterior, a solução para executar pacotes programaticamente em um computador remoto não requer nenhum código personalizado no computador remoto. Porém, você pode preferir uma solução que não dependa do SQL Server Agent para executar pacotes.

O exemplo a seguir fornece código parcial que pode ser usado em um componente remoto ou um serviço Web no servidor para iniciar pacotes do Integration Services no computador remoto.

Código de exemplo

As amostras de código a seguir sugerem uma abordagem para criar e testar uma classe remota que executa um pacote remotamente. Estes exemplos não estão completos, mas fornecem código que pode ser usado como parte de uma solução compilada como um componente remoto ou como um serviço Web.

Estes exemplos exigem uma referência para o assembly Microsoft.SqlServer.ManagedDTS.

Criando a função para executar o pacote SSIS remotamente

Um pacote do Integration Services pode ser carregado diretamente de um arquivo, diretamente de um SQL Server ou do Repositório de Pacotes SSIS, que gerencia o armazenamento de pacotes no SQL Server e em pastas especiais de sistema de arquivos. A fim de dar suporte a todas as opções de carregamento disponíveis, esse exemplo usa uma construção Select Case ou switch para selecionar a sintaxe apropriada para iniciar o pacote e concatenar os argumentos de entrada adequadamente.

Importante
Os métodos da classe Application para trabalhar com o Repositório de Pacotes SSIS só dão suporte a ".", localhost ou ao nome do servidor local. Você não pode usar "(local)".

O método LaunchPackage do serviço Web retorna o resultado da execução do pacote como um valor inteiro em vez de um valor DTSExecResult, de forma que os computadores cliente não exijam uma referência a qualquer assembly do Integration Services.

Importante
Este exemplo não está completo, mas fornece código que pode ser usado como parte de uma solução compilada como um componente remoto ou como um serviço Web. O exemplo não inclui o código, atributos ou referências que podem ser necessários para compilar e expor um componente ou serviço remoto.

Para criar uma classe remota para executar pacotes programaticamente no servidor

1. Abra o Visual Studio e crie um projeto do tipo apropriado na linguagem de programação de sua preferência.

   O código de exemplo a seguir usa o nome LaunchSSISPackageService para o projeto.

2. Adicione uma referência ao assembly Microsoft.SqlServer.ManagedDTS.

3. Cole o código de exemplo no arquivo de classe.

   O exemplo mostra o conteúdo inteiro da janela de código.

4. Adicione o código, atributos ou referências que podem ser necessários para compilar e expor um componente ou serviço remoto.

5. Compile e teste o projeto que inclui o código de exemplo.

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

  }

}

Chamando a função para executar o pacote SSIS remotamente

O aplicativo de console do exemplo seguinte usa o componente ou serviço remoto para executar um pacote.

O método LaunchPackage da classe remota retorna o resultado da execução do pacote como um valor inteiro em vez de um valor DTSExecResult, de forma que os computadores cliente não exijam uma referência a qualquer assembly do Integration Services. O exemplo cria uma enumeração privada cujos valores espelham os valores DTSExecResult para informar os resultados da execução.

Para criar um aplicativo de console para testar a classe remota

1. Em Visual Studio, crie um novo aplicativo de console usando a linguagem de programação de sua preferência.

   O código de exemplo usa o nome LaunchSSISPackageTest para o projeto.

2. Acrescente uma referência ao assembly de proxy local que representa o componente ou serviço remoto. Se necessário, ajuste a declaração variável no código de exemplo para o nome que você atribui ao objeto de proxy.

3. Cole o código de exemplo para a rotina principal e a enumeração privada no código.

   O exemplo mostra o conteúdo inteiro da janela de código.

4. Edite a linha de código, que chama o método LaunchPackage para fornecer um conjunto de valores válidos para os argumentos de entrada, que aponte para um pacote existente.

   Por exemplo, se package1.dtsx estiver armazenado no servidor em C:\Meus Pacotes, passe "arquivo" como valor de sourceType, "C:\Meus Pacotes" como valor de sourceLocation e "package1" (sem a extensão) como valor de 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
    };

  }
}

Voltar ao início

Recursos externos

• Vídeo, Como automatizar a execução de pacotes usando o SQL Server Agent (vídeo do SQL Server), em technet.microsoft.com

Fique atualizado com o Integration Services Para obter os downloads, artigos, exemplos e vídeos da Microsoft mais recentes, bem como soluções selecionadas da comunidade, visite a página do Integration Services no MSDN: Visite a página do Integration Services no MSDN Para receber uma notificação automática sobre essas atualizações, assine os RSS feeds disponíveis na página.

Consulte também

Tarefas

Executando um pacote SSIS programaticamente no computador local

Carregando a saída de um pacote em outro programa