Sincronizar uma Subscrição Push

Aplica-se a:SQL ServerBanco de Dados SQL do Azure

Este tópico descreve como sincronizar uma subscrição push no SQL Server utilizando SQL Server Management Studio, agentes de replicação ou Objectos de Gestão de Replicação (RMO).

Usando o SQL Server Management Studio

As subscrições são sincronizadas pelo Agente de Distribuição (para replicação instantânea e transacional) ou pelo Agente de Fusão (para replicação de fusão). Os agentes podem funcionar de forma contínua, a pedido ou a funcionar com um horário. Para mais informações sobre a especificação de agendas de sincronização, consulte Especificar Agendas de Sincronização.

Sincronize uma subscrição sob demanda a partir das pastas Publicações Locais e Subscrições Locais no Microsoft SQL Server Management Studio e no separador Todas as Subscrições no Monitor de Replicação. As subscrições das publicações Oracle não podem ser sincronizadas a pedido do Assinante. Para informações sobre como iniciar o Monitor de Replicação, consulte Iniciar o Monitor de Replicação.

Para sincronizar uma subscrição push sob demanda no Management Studio (no Publicador)

1. Liga-te ao Publisher no Management Studio e depois expande o nó servidor.

2. Expanda a pasta Replicação e depois expanda a pasta Publicações Locais .

3. Expanda a publicação para a qual pretende sincronizar as subscrições.

4. Clique com o botão direito na subscrição que quer sincronizar e depois clique em Ver Estado de Sincronização.

5. Na caixa de diálogo View Synchronization State - <Subscriber>:<SubscriptionDatabase> , clique em Iniciar. Quando a sincronização termina, é exibida a mensagem Sincronização concluída .

6. Clique em Fechar.

Para sincronizar uma subscrição push a pedido no Management Studio (no Assinante)

1. Ligue-se ao Subscritor no Management Studio e expanda depois o nó do servidor.

2. Expanda a pasta Replicação e depois expanda a pasta Subscrições Locais .

3. Clique com o botão direito na subscrição que quer sincronizar e depois clique em Ver Estado de Sincronização.

4. É exibida uma mensagem sobre o estabelecimento de uma ligação ao Distribuidor. Clique em OK.

5. Na caixa de diálogo View Synchronization State - <Subscriber>:<SubscriptionDatabase> , clique em Iniciar. Quando a sincronização termina, é exibida a mensagem Sincronização concluída .

6. Clique em Fechar.

Para sincronizar uma subscrição push on demand no Replication Monitor

1. No Replication Monitor, expanda um grupo de Publishers no painel esquerdo, expanda um Publisher e depois clique numa publicação.

2. Clique no separador Todas as Subscrições .

3. Clique com o botão direito na subscrição que quer sincronizar e depois clique em Iniciar Sincronização.

4. Para ver o progresso da sincronização, clique com o botão direito na subscrição e depois clique em Ver Detalhes.

Utilização de Agentes de Replicação

As subscrições push podem ser sincronizadas programaticamente e sob demanda, invocando o ficheiro executável agente de replicação apropriado a partir do prompt de comandos. O ficheiro executável do agente de replicação que é invocado dependerá do tipo de publicação a que pertence a subscrição push.

Para iniciar o Agente de Distribuição para sincronizar uma subscrição push com uma publicação transacional

1. A partir do prompt de comandos ou num ficheiro batch no Distribuidor, execute distrib.exe. Especifique os seguintes argumentos de linha de comandos:

   • -Publicadora

   • -PublisherDB

   • -Distribuidor

   • -Assinante

   • -SubscriberDB

   • -SubscriptionType = 0

   Se estiver a usar Autenticação SQL Server, deve também especificar os seguintes argumentos:

   • -DistributorLogin

   • -DistributorPassword

   • -DistributorSecurityMode = 0

   • -PublisherLogin

   • -EditorPassword

   • -PublisherSecurityMode = 0

   • -Login do Assinante

   • -Palavra-passe do assinante

   • -Modo de Segurança dos Assinantes = 0

     Importante

     Quando possível, use a autenticação do Windows.

Para iniciar o Merge Agent para sincronizar uma subscrição de envio com uma publicação de fusão

1. A partir do prompt de comandos ou num ficheiro batch no Distribuidor, execute replmerg.exe. Especifique os seguintes argumentos de linha de comandos:

   • -Publicadora

   • -PublisherDB

   • -Publicação

   • -Distribuidor

   • -Assinante

   • -SubscriberDB

   • -SubscriptionType = 0

   Se estiver a usar Autenticação SQL Server, deve também especificar os seguintes argumentos:

   • -DistributorLogin

   • -DistribuidorPalavra-passe

   • -DistributorSecurityMode = 0

   • -PublisherLogin

   • -EditorPassword

   • -ModoSegurançaDeEditora = 0

   • LoginDeAssinante

   • -Palavra-passe do assinante

   • -Modo de Segurança dos Assinantes = 0

     Importante

     Quando possível, use a autenticação do Windows.

Exemplos (Agentes de Replicação)

O exemplo seguinte inicia o Agente de Distribuição para sincronizar uma subscrição push.

  
REM -- Declare the variables.  
SET Publisher=%instancename%  
SET Subscriber=%instancename%  
SET PublicationDB=AdventureWorks2022  
SET SubscriptionDB=AdventureWorks2022Replica   
SET Publication=AdvWorksProductsTran  
  
REM -- Start the Distribution Agent with four subscription streams.  
REM -- The following command must be supplied without line breaks.  
"C:\Program Files\Microsoft SQL Server\120\COM\DISTRIB.EXE" -Subscriber %Subscriber%   
-SubscriberDB %SubscriptionDB% -SubscriberSecurityMode 1 -Publication %Publication%   
-Publisher %Publisher% -PublisherDB %PublicationDB% -Distributor %Publisher%   
-DistributorSecurityMode 1 -Continuous -SubscriptionType 0 -SubscriptionStreams 4  
  

O exemplo seguinte inicia o Merge Agent para sincronizar uma subscrição push.

  
REM -- Declare the variables.  
SET Publisher=%instancename%  
SET Subscriber=%instancename%  
SET PublicationDB=AdventureWorks2022  
SET SubscriptionDB=AdventureWorks2022Replica   
SET Publication=AdvWorksSalesOrdersMerge  
  
REM -- Start the Merge Agent.  
REM -- The following command must be supplied without line breaks.  
"C:\Program Files\Microsoft SQL Server\120\COM\REPLMERG.EXE"  -Publisher %Publisher%   
-Subscriber  %Subscriber%  -Distributor %Publisher% -PublisherDB  %PublicationDB%   
-SubscriberDB %SubscriptionDB% -Publication %Publication% -PublisherSecurityMode 1   
-OutputVerboseLevel 3  -Output -SubscriberSecurityMode 1  -SubscriptionType 0   
-DistributorSecurityMode 1  
  

Utilização de Objetos de Gestão de Replicação (RMO)

Pode sincronizar subscrições push programaticamente usando Objetos de Gestão de Replicação (RMO) e acesso a código gerido às funcionalidades de agentes de replicação. As classes que utiliza para sincronizar uma subscrição push dependem do tipo de publicação a que a subscrição pertence.

Para sincronizar uma subscrição push com um snapshot ou publicação transacional

1. Crie uma ligação ao Distribuidor usando a ServerConnection classe.

2. Crie uma instância da TransSubscription classe e defina as seguintes propriedades:

   • O nome da base de dados de publicações para DatabaseName.

   • O nome da publicação à qual é atribuída a subscrição para PublicationName.

   • O nome da base de dados de subscrição para SubscriptionDBName.

   • O nome do Assinante para SubscriberName.

   • A ligação criada no passo 1 para ConnectionContext.

3. Chame o método LoadProperties para obter as propriedades restantes da subscrição. Se este método apresentar falso, verifique se a subscrição existe.

4. Inicie o Agente de Distribuição no Distribuidor de uma das seguintes formas:

   • Chame o método SynchronizeWithJob na instância de TransSubscription do passo 2. Este método inicia o Agente de Distribuição de forma assíncrona e o controlo retorna imediatamente à sua aplicação enquanto o trabalho do agente está a correr. Não pode chamar este método se a subscrição foi criada com um valor falso para CreateSyncAgentByDefault.

   • Obtenha uma instância da TransSynchronizationAgent classe a partir da SynchronizationAgent propriedade e chame o Synchronize método. Este método inicia o agente de forma síncrona, e o controlo permanece com a tarefa do agente em execução. Durante a execução síncrona, podes gerir o Status evento enquanto o agente está a correr.

Para sincronizar uma subscrição push com uma publicação de fusão

1. Crie uma ligação ao Distribuidor usando a ServerConnection classe.

2. Crie uma instância da MergeSubscription classe e defina as seguintes propriedades:

   • O nome da base de dados de publicações para DatabaseName.

   • O nome da publicação à qual pertence a subscrição para PublicationName.

   • O nome da base de dados de subscrição para SubscriptionDBName.

   • O nome do Assinante para SubscriberName.

   • A ligação criada no passo 1 para ConnectionContext.

3. Chame o método LoadProperties para obter as propriedades de subscrição restantes. Se este método apresentar falso, verifique se a subscrição existe.

4. Inicie o Agente de Fusão no Distribuidor de uma das seguintes formas:

   • Chame o método SynchronizeWithJob na instância de MergeSubscription do passo 2. Este método inicia o Merge Agent de forma assíncrona e o controlo retorna imediatamente à sua aplicação enquanto o trabalho do agente está a correr. Não pode chamar este método se a subscrição foi criada com um valor falso para CreateSyncAgentByDefault.

   • Obtenha uma instância da MergeSynchronizationAgent classe a partir da SynchronizationAgent propriedade e chame o Synchronize método. Este método inicia o Merge Agent de forma síncrona, e o controlo mantém-se com a tarefa do agente em execução. Durante a execução síncrona, pode gerir o evento Status enquanto o agente está em execução.

Exemplos (RMO)

Este exemplo sincroniza uma subscrição push com uma publicação transacional, onde o agente é iniciado de forma assíncrona usando o job do agente.

// Define the server, publication, and database names.
string subscriberName = subscriberInstance;
string publisherName = publisherInstance;
string publicationName = "AdvWorksProductTran";
string subscriptionDbName = "AdventureWorks2022Replica";
string publicationDbName = "AdventureWorks2022";

/// Create a connection to the Publisher.
ServerConnection conn = new ServerConnection(publisherName);

TransSubscription subscription;

try
{
    // Connect to the Publisher.
    conn.Connect();

    // Instantiate the push subscription.
    subscription = new TransSubscription();
    subscription.ConnectionContext = conn;
    subscription.DatabaseName = publicationDbName;
    subscription.PublicationName = publicationName;
    subscription.SubscriptionDBName = subscriptionDbName;
    subscription.SubscriberName = subscriberName;

    // If the push subscription and the job exists, start the agent job.
    if (subscription.LoadProperties() && subscription.AgentJobId != null)
    {
        // Start the Distribution Agent asynchronously.
        subscription.SynchronizeWithJob();
    }
    else
    {
        // Do something here if the subscription does not exist.
        throw new ApplicationException(String.Format(
            "A subscription to '{0}' does not exists on {1}",
            publicationName, subscriberName));
    }
}
catch (Exception ex)
{
    // Implement appropriate error handling here.
    throw new ApplicationException("The subscription could not be synchronized.", ex);
}
finally
{
    conn.Disconnect();
}

' Define the server, publication, and database names.
Dim subscriberName As String = subscriberInstance
Dim publisherName As String = publisherInstance
Dim publicationName As String = "AdvWorksProductTran"
Dim subscriptionDbName As String = "AdventureWorks2022Replica"
Dim publicationDbName As String = "AdventureWorks2022"

' Create a connection to the Publisher.
Dim conn As ServerConnection = New ServerConnection(publisherName)

Dim subscription As TransSubscription

Try
    ' Connect to the Publisher.
    conn.Connect()

    ' Instantiate the push subscription.
    subscription = New TransSubscription()
    subscription.ConnectionContext = conn
    subscription.DatabaseName = publicationDbName
    subscription.PublicationName = publicationName
    subscription.SubscriptionDBName = subscriptionDbName
    subscription.SubscriberName = subscriberName

    ' If the push subscription and the job exists, start the agent job.
    If subscription.LoadProperties() And Not subscription.AgentJobId Is Nothing Then
        ' Start the Distribution Agent asynchronously.
        subscription.SynchronizeWithJob()
    Else
        ' Do something here if the subscription does not exist.
        Throw New ApplicationException(String.Format( _
         "A subscription to '{0}' does not exists on {1}", _
         publicationName, subscriberName))
    End If
Catch ex As Exception
    ' Implement appropriate error handling here.
    Throw New ApplicationException("The subscription could not be synchronized.", ex)
Finally
    conn.Disconnect()
End Try

Este exemplo sincroniza uma subscrição push com uma publicação transacional, onde o agente é iniciado de forma síncrona.

// Define the server, publication, and database names.
string subscriberName = subscriberInstance;
string publisherName = publisherInstance;
string publicationName = "AdvWorksProductTran";
string subscriptionDbName = "AdventureWorks2022Replica";
string publicationDbName = "AdventureWorks2022";

// Create a connection to the Publisher.
ServerConnection conn = new ServerConnection(publisherName);

TransSubscription subscription;

try
{
    // Connect to the Publisher.
    conn.Connect();

    // Define the push subscription.
    subscription = new TransSubscription();
    subscription.ConnectionContext = conn;
    subscription.DatabaseName = publicationDbName;
    subscription.PublicationName = publicationName;
    subscription.SubscriptionDBName = subscriptionDbName;
    subscription.SubscriberName = subscriberName;

    // If the push subscription exists, start the synchronization.
    if (subscription.LoadProperties())
    {
        // Check that we have enough metadata to start the agent.
        if (subscription.SubscriberSecurity != null)
        {
            // Synchronously start the Distribution Agent for the subscription.
            subscription.SynchronizationAgent.Synchronize();
        }
        else
        {
            throw new ApplicationException("There is insufficent metadata to " +
                "synchronize the subscription. Recreate the subscription with " +
                "the agent job or supply the required agent properties at run time.");
        }
    }
    else
    {
        // Do something here if the push subscription does not exist.
        throw new ApplicationException(String.Format(
            "The subscription to '{0}' does not exist on {1}",
            publicationName, subscriberName));
    }
}
catch (Exception ex)
{
    // Implement appropriate error handling here.
    throw new ApplicationException("The subscription could not be synchronized.", ex);
}
finally
{
    conn.Disconnect();
}

' Define the server, publication, and database names.
Dim subscriberName As String = subscriberInstance
Dim publisherName As String = publisherInstance
Dim publicationName As String = "AdvWorksProductTran"
Dim subscriptionDbName As String = "AdventureWorks2022Replica"
Dim publicationDbName As String = "AdventureWorks2022"

' Create a connection to the Publisher.
Dim conn As ServerConnection = New ServerConnection(publisherName)

Dim subscription As TransSubscription

Try
    ' Connect to the Publisher.
    conn.Connect()

    ' Define the push subscription.
    subscription = New TransSubscription()
    subscription.ConnectionContext = conn
    subscription.DatabaseName = publicationDbName
    subscription.PublicationName = publicationName
    subscription.SubscriptionDBName = subscriptionDbName
    subscription.SubscriberName = subscriberName

    ' If the push subscription exists, start the synchronization.
    If subscription.LoadProperties() Then
        ' Check that we have enough metadata to start the agent.
        If Not subscription.SubscriberSecurity Is Nothing Then

            ' Synchronously start the Distribution Agent for the subscription.
            subscription.SynchronizationAgent.Synchronize()
        Else
            Throw New ApplicationException("There is insufficent metadata to " + _
             "synchronize the subscription. Recreate the subscription with " + _
             "the agent job or supply the required agent properties at run time.")
        End If
    Else
        ' Do something here if the push subscription does not exist.
        Throw New ApplicationException(String.Format( _
         "The subscription to '{0}' does not exist on {1}", _
         publicationName, subscriberName))
    End If
Catch ex As Exception
    ' Implement appropriate error handling here.
    Throw New ApplicationException("The subscription could not be synchronized.", ex)
Finally
    conn.Disconnect()
End Try

Este exemplo sincroniza uma subscrição push com uma publicação de fusão, onde o agente é iniciado de forma assíncrona usando o job do agente.

// Define the server, publication, and database names.
string subscriberName = subscriberInstance;
string publisherName = publisherInstance;
string publicationName = "AdvWorksSalesOrdersMerge";
string subscriptionDbName = "AdventureWorks2022Replica";
string publicationDbName = "AdventureWorks2022";

// Create a connection to the Publisher.
ServerConnection conn = new ServerConnection(publisherName);

MergeSubscription subscription;

try
{
    // Connect to the Publisher.
    conn.Connect();

    // Define push subscription.
    subscription = new MergeSubscription();
    subscription.ConnectionContext = conn;
    subscription.DatabaseName = publicationDbName;
    subscription.PublicationName = publicationName;
    subscription.SubscriptionDBName = subscriptionDbName;
    subscription.SubscriberName = subscriberName;

    // If the push subscription and the job exists, start the agent job.
    if (subscription.LoadProperties() && subscription.AgentJobId != null)
    {
        // Start the Merge Agent asynchronously.
        subscription.SynchronizeWithJob();
    }
    else
    {
        // Do something here if the subscription does not exist.
        throw new ApplicationException(String.Format(
            "A subscription to '{0}' does not exists on {1}",
            publicationName, subscriberName));
    }
}
catch (Exception ex)
{
    // Implement appropriate error handling here.
    throw new ApplicationException("The subscription could not be synchronized.", ex);
}
finally
{
    conn.Disconnect();
}

' Define the server, publication, and database names.
Dim subscriberName As String = subscriberInstance
Dim publisherName As String = publisherInstance
Dim publicationName As String = "AdvWorksSalesOrdersMerge"
Dim subscriptionDbName As String = "AdventureWorks2022Replica"
Dim publicationDbName As String = "AdventureWorks2022"

' Create a connection to the Publisher.
Dim conn As ServerConnection = New ServerConnection(publisherName)

Dim subscription As MergeSubscription

Try
    ' Connect to the Publisher.
    conn.Connect()

    ' Define push subscription.
    subscription = New MergeSubscription()
    subscription.ConnectionContext = conn
    subscription.DatabaseName = publicationDbName
    subscription.PublicationName = publicationName
    subscription.SubscriptionDBName = subscriptionDbName
    subscription.SubscriberName = subscriberName

    ' If the push subscription and the job exists, start the agent job.
    If subscription.LoadProperties() And Not subscription.AgentJobId Is Nothing Then
        ' Start the Merge Agent asynchronously.
        subscription.SynchronizeWithJob()
    Else
        ' Do something here if the subscription does not exist.
        Throw New ApplicationException(String.Format( _
            "A subscription to '{0}' does not exists on {1}", _
            publicationName, subscriberName))
    End If
Catch ex As Exception
    ' Implement appropriate error handling here.
    Throw New ApplicationException("The subscription could not be synchronized.", ex)
Finally
    conn.Disconnect()
End Try

Este exemplo sincroniza uma subscrição push com uma publicação de fusão, onde o agente é iniciado de forma síncrona.

// Define the server, publication, and database names.
string subscriberName = subscriberInstance;
string publisherName = publisherInstance;
string publicationName = "AdvWorksSalesOrdersMerge";
string subscriptionDbName = "AdventureWorks2022Replica";
string publicationDbName = "AdventureWorks2022";

// Create a connection to the Publisher.
ServerConnection conn = new ServerConnection(publisherName);

MergeSubscription subscription;

try
{
    // Connect to the Publisher
    conn.Connect();

    // Define the subscription.
    subscription = new MergeSubscription();
    subscription.ConnectionContext = conn;
    subscription.DatabaseName = publicationDbName;
    subscription.PublicationName = publicationName;
    subscription.SubscriptionDBName = subscriptionDbName;
    subscription.SubscriberName = subscriberName;

    // If the push subscription exists, start the synchronization.
    if (subscription.LoadProperties())
    {
        // Check that we have enough metadata to start the agent.
        if (subscription.SubscriberSecurity != null)
        {
            // Synchronously start the Merge Agent for the subscription.
            subscription.SynchronizationAgent.Synchronize();
        }
        else
        {
            throw new ApplicationException("There is insufficent metadata to " +
                "synchronize the subscription. Recreate the subscription with " +
                "the agent job or supply the required agent properties at run time.");
        }
    }
    else
    {
        // Do something here if the push subscription does not exist.
        throw new ApplicationException(String.Format(
            "The subscription to '{0}' does not exist on {1}",
            publicationName, subscriberName));
    }
}
catch (Exception ex)
{
    // Implement appropriate error handling here.
    throw new ApplicationException("The subscription could not be synchronized.", ex);
}
finally
{
    conn.Disconnect();
}

' Define the server, publication, and database names.
Dim subscriberName As String = subscriberInstance
Dim publisherName As String = publisherInstance
Dim publicationName As String = "AdvWorksSalesOrdersMerge"
Dim subscriptionDbName As String = "AdventureWorks2022Replica"
Dim publicationDbName As String = "AdventureWorks2022"

' Create a connection to the Publisher.
Dim conn As ServerConnection = New ServerConnection(publisherName)

Dim subscription As MergeSubscription

Try
    ' Connect to the Publisher
    conn.Connect()

    ' Define the subscription.
    subscription = New MergeSubscription()
    subscription.ConnectionContext = conn
    subscription.DatabaseName = publicationDbName
    subscription.PublicationName = publicationName
    subscription.SubscriptionDBName = subscriptionDbName
    subscription.SubscriberName = subscriberName

    ' If the push subscription exists, start the synchronization.
    If subscription.LoadProperties() Then
        ' Check that we have enough metadata to start the agent.
        If Not subscription.SubscriberSecurity Is Nothing Then
            ' Synchronously start the Merge Agent for the subscription.
            ' Log agent messages to an output file.
            subscription.SynchronizationAgent.Output = "mergeagent.log"
            subscription.SynchronizationAgent.OutputVerboseLevel = 2
            subscription.SynchronizationAgent.Synchronize()
        Else
            Throw New ApplicationException("There is insufficent metadata to " + _
             "synchronize the subscription. Recreate the subscription with " + _
             "the agent job or supply the required agent properties at run time.")
        End If
    Else
        ' Do something here if the push subscription does not exist.
        Throw New ApplicationException(String.Format( _
         "The subscription to '{0}' does not exist on {1}", _
         publicationName, subscriberName))
    End If
Catch ex As Exception
    ' Implement appropriate error handling here.
    Throw New ApplicationException("The subscription could not be synchronized.", ex)
Finally
    conn.Disconnect()
End Try

Conteúdo relacionado

• Conceitos de objetos de gerenciamento de replicação
• Sincronizar Dados
• Práticas recomendadas de segurança de replicação