Partilhar via

Carregando e executando um pacote remoto programaticamente

Aplica-se a:SQL Server SSIS Integration Runtime em Azure Data Factory

Para executar pacotes remotos a partir de um computador local que não tenha o Integration Services instalado, inicie os pacotes para que corram no computador remoto onde o Integration Services está instalado. Para alcançar este objetivo, faça com que o computador local utilize o SQL Server Agent, um serviço Web ou um componente remoto para iniciar os pacotes no computador remoto. Se tentares iniciar os pacotes remotos diretamente a partir do computador local, os pacotes carregam e tentam correr a partir do computador local. Se o computador local não tiver os Serviços de Integração instalados, os pacotes não funcionam.

Observação

Não podes executar pacotes fora do SQL Server Data Tools num computador cliente a menos que o Integration Services esteja instalado. Os termos da sua licença SQL Server podem não permitir instalar os Serviços de Integração noutros computadores. O Integration Services é um componente servidor e não pode ser redistribuído para computadores clientes.

Em alternativa, pode executar um pacote remoto a partir de um computador local que tenha os Serviços de Integração instalados. Para mais informações, consulte Carregar e Executar um Pacote Local Programáticamente.

Executar um pacote remoto no computador remoto

Existem várias formas de executar um pacote remoto num servidor remoto:

Quase todos os métodos usados neste tópico para carregar e guardar pacotes requerem uma referência ao assembly Microsoft.SqlServer.ManagedDTS . A exceção é a abordagem ADO.NET demonstrada neste tópico para executar o procedimento armazenado sp_start_job , que requer apenas referências ao System.Data e ao Microsoft.Data.SqlClient. Depois de adicionar a referência ao assembly Microsoft.SqlServer.ManagedDTS num novo projeto, importe o Microsoft.SqlServer.Dts.Runtime namespace com uma instrução using or Imports .

Usar o Agente SQL Server para Executar um Pacote Remoto Programáticamente no Servidor

O exemplo de código seguinte demonstra como usar programaticamente o SQL Server Agent para executar um pacote remoto no servidor. O exemplo de código chama o procedimento armazenado do sistema, sp_start_job, que inicia um trabalho SQL Server Agent. O trabalho que o procedimento inicia chama-se RunSSISPackage, e este trabalho está no computador remoto. O RunSSISPackage trabalho executa então o pacote no computador remoto.

Observação

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

Para informações sobre a resolução de problemas de pacotes executados a partir de jobs SQL Server Agent, veja o artigo da Microsoft, Um pacote SSIS não executa quando chama o pacote SSIS a partir de uma etapa de trabalho SQL Server Agent.

Código de Exemplo

Imports System.Data  
Imports Microsoft.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, RunSSISPackage, started successfully.")  
      Case Else  
        Console.WriteLine("SQL Server Agent job, RunSSISPackage, failed to start.")  
    End Select  
    Console.Read()  
  
  End Sub  
  
End Module  

using System;  
using System.Data;  
using Microsoft.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, RunSSISPackage, started successfully.");  
          break;  
        default:  
          Console.WriteLine("SQL Server Agent job, RunSSISPackage, failed to start.");  
          break;  
      }  
      Console.Read();  
    }  
  }  
}

Utilização de um serviço web ou componente remoto para executar um pacote remoto de forma programática

A solução anterior para executar pacotes programaticamente no servidor não requer qualquer código personalizado no servidor. No entanto, pode preferir uma solução que não dependa do SQL Server Agent para executar pacotes. O exemplo seguinte mostra como criar um serviço Web no servidor para iniciar pacotes de Serviços de Integração localmente, e uma aplicação de teste para chamar o serviço Web a partir de um computador cliente. Se preferir criar um componente remoto em vez de um serviço Web, pode usar a mesma lógica de código com poucas alterações num componente remoto. No entanto, um componente remoto pode exigir uma configuração mais extensa do que um serviço Web.

Importante

Com as suas definições padrão para autenticação e autorização, um serviço Web geralmente não tem permissões suficientes para aceder ao SQL Server ou ao sistema de ficheiros para carregar e executar pacotes. Pode ter de atribuir permissões apropriadas ao serviço Web, configurando as suas definições de autenticação e autorização no ficheiroweb.config e atribuindo permissões à base de dados e ao sistema de ficheiros, conforme apropriado. Uma discussão completa sobre permissões Web, bases de dados e sistemas de ficheiros está fora do âmbito deste tema.

Importante

Os métodos da Application classe para trabalhar com o SSIS Package Store suportam apenas ".", localhost, ou o nome do servidor local. Não podes usar "(local)".

Código de Exemplo

Os exemplos de código seguintes mostram como criar e testar o serviço Web.

Criação do Serviço Web

Pode carregar um pacote de Serviços de Integração diretamente a partir de um ficheiro, do SQL Server ou da Loja de Pacotes SSIS. A Loja de Pacotes SSIS gere o armazenamento de pacotes tanto no SQL Server como em pastas especiais do sistema de ficheiros. Este exemplo suporta todas as opções disponíveis usando uma construção Select Case ou switch para selecionar a sintaxe adequada para iniciar o pacote e para concatenar os argumentos de entrada de forma adequada. O método de serviço Web LaunchPackage devolve o resultado da execução do pacote como um inteiro em vez de um DTSExecResult valor, para que os computadores clientes não necessitem de referência a quaisquer assemblies de Serviços de Integração.

Criar um serviço Web para executar pacotes no servidor programaticamente

  1. Abra o Visual Studio e crie um projeto de serviço Web na sua linguagem de programação preferida. O código de exemplo utiliza o nome LaunchSSISPackageService para o projeto.

  2. Adicione uma referência ao Microsoft.SqlServer.ManagedDTS e adicione uma instrução Imports ou using ao ficheiro de código para o espaço de nomes Microsoft.SqlServer.Dts.Runtime .

  3. Cole o código de exemplo do método do serviço Web LaunchPackage na classe. (O exemplo mostra todo o conteúdo da janela de código.)

  4. Construa e teste o serviço Web fornecendo um conjunto de valores válidos para os argumentos de entrada do método LaunchPackage que apontam para um pacote existente. Por exemplo, se o package1.dtsx estiver armazenado no servidor em C:\My Packages, passe "file" como valor do sourceType, "C:\My Packages" como valor de sourceLocation, e "package1" (sem a extensão) como valor 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();  
  
  }  
  
}

Testar o Serviço Web

A seguinte aplicação de consola de exemplo utiliza o serviço Web para executar um pacote. O método LaunchPackage do serviço Web devolve o resultado da execução do pacote como um inteiro em vez de um DTSExecResult valor, para que os computadores clientes não necessitem de referência a quaisquer assemblies de Serviços de Integração. A amostra cria uma enumeração privada cujos valores espelham os DTSExecResult valores para reportar os resultados da execução.

Criar uma aplicação de consola para testar o serviço Web

  1. No Visual Studio, adicione uma nova aplicação de consola, usando a sua linguagem de programação preferida, à mesma solução que contém o projeto de serviço Web. O código de exemplo utiliza o nome LaunchSSISPackageTest para o projeto.

  2. Defina a nova aplicação de consola como o projeto de arranque na solução.

  3. Adicione uma referência Web para o projeto de serviço Web. Se necessário, ajuste a declaração da variável no código de exemplo para o nome que atribui ao objeto proxy do serviço Web.

  4. Cole o código de exemplo para a rotina principal e a enumeração privada no código. (O exemplo mostra todo o conteúdo da janela de código.)

  5. Editar 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 apontam para um pacote existente. Por exemplo, se o package1.dtsx estiver armazenado no servidor em C:\My Packages, passe "file" como valor de sourceType, "C:\My Packages" 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  
      ' 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  
    };  
  
  }  
}

Recursos Externos

Conteúdo relacionado

Compreender as diferenças entre a execução local e remota
Carregando e executando um pacote local programaticamente
Carregamento da saída de um pacote local

  • Last updated on