Compartir a través de


Creación de una publicación

Se aplica a: SQL Server Azure SQL Managed Instance

En este artículo se describe cómo crear una publicación en SQL Server mediante SQL Server Management Studio, Transact-SQL o Replication Management Objects (RMO).

Limitaciones y restricciones

  • Los nombres de publicaciones y artículos no pueden contener ninguno de los siguientes caracteres: %, *, [, ], |, :, ", ?, ', \, /, < ni >. Si los objetos de la base de datos incluyen cualquiera de estos caracteres y quiere replicarlos, debe especificar un nombre de artículo diferente del nombre del objeto en el cuadro de diálogo Propiedades del artículo: <Artículo>, que está disponible en la página Artículos del asistente.

Seguridad

Cuando sea posible, pida a los usuarios que proporcionen credenciales de seguridad en tiempo de ejecución. Si debe almacenar credenciales, use los servicios criptográficos proporcionados por Microsoft Windows .NET Framework.

Uso de SQL Server Management Studio

Cree publicaciones y defina artículos con el Asistente para nueva publicación. Después de crear una publicación, vea y modifique las propiedades de la publicación en el cuadro de diálogo Propiedades de la publicación: <Publicación>. Para obtener información sobre cómo crear una publicación de una base de datos de Oracle, vea Crear una publicación a partir de una base de datos de Oracle.

Crear publicaciones y definir artículos

  1. Conéctese al publicador en Microsoft SQL Server Management Studio y, a continuación, expanda el nodo del servidor.

  2. Expanda la carpeta Replicación y, a continuación, haga clic con el botón secundario en la carpeta Publicaciones locales .

  3. Seleccione Nueva publicación.

  4. Siga las indicaciones de las páginas del Asistente para nueva publicación para:

    • Especificar un distribuidor si la distribución no se ha configurado en el servidor. Para obtener más información sobre cómo configurar la distribución, vea Configurar la publicación y la distribución.

      Si en la página Distribuidor especifica que el servidor del publicador actúe como su propio distribuidor (un distribuidor local) y el servidor no está configurado como tal, el Asistente para nueva publicación configurará el servidor. Especifique una carpeta de instantáneas predeterminada para el distribuidor en la página Carpeta de instantáneas . La carpeta de instantáneas es simplemente un directorio designado como recurso compartido; los agentes que leen y escriben en esta carpeta deben tener permisos de acceso suficientes a ella. Para obtener más información sobre cómo proteger la carpeta adecuadamente, vea Proteger la carpeta de instantáneas.

      Si especifica que otro servidor actúe como distribuidor, deberá escribir una contraseña en la página Contraseña administrativa para las conexiones que se realicen desde el publicador al distribuidor. Esta contraseña debe coincidir con la especificada cuando se habilitó el publicador en el distribuidor remoto.

      Para más información, consulte Configure Distribution.

    • Elegir una base de datos de publicación.

    • Seleccionar un tipo de publicación. Para obtener más información, vea Tipos de replicación.

    • Especificar los datos y los objetos de base de datos que se van a publicar; de forma opcional, filtrar columnas de artículos de tablas y establecer las propiedades de los artículos.

    • De forma opcional, filtrar filas de artículos de tablas. Para obtener más información, vea Filtrar datos publicados.

    • Establecer la programación del Agente de instantáneas.

    • Especificar las credenciales con las que los siguientes agentes de replicación se ejecutan y efectúan conexiones:

      • Agente de instantáneas para todas las publicaciones.

      • Agente de registro del LOG para todas las publicaciones transaccionales.

      • Agente de lectura de cola para las publicaciones transaccionales que permiten suscripciones de actualización.

        Para obtener más información, consulte Replication Agent Security Model y Replication Security Best Practices.

    • De forma opcional, incluir la publicación. Para más información, consulte Scripting Replication.

    • Especificar un nombre para la publicación.

Uso de Transact-SQL

Las publicaciones pueden crearse mediante programación con procedimientos almacenados de replicación. Los procedimientos almacenados que se usen dependerán del tipo de publicación creado.

Crear una publicación transaccional o de instantáneas

  1. En el publicador de la base de datos de publicación, ejecute sp_replicationdboption (Transact-SQL) para habilitar la publicación de la base de datos actual con la replicación transaccional o de instantáneas.

  2. En el caso de una publicación transaccional, determine si existe un trabajo de Agente de registro del LOG para la base de datos de publicación. (Este paso no es necesario para las publicaciones de instantáneas).

    • Si existe un trabajo de Agente de registro del LOG para la base de datos de publicación, continúe en el paso 3.

    • Si no está seguro de si existe un trabajo del Agente de registro del LOG para una base de datos publicada, ejecute sp_helplogreader_agent (Transact-SQL) en el publicador de la base de datos de publicación.

    • Si el conjunto de resultados está vacío, cree un trabajo de Agente de registro del LOG. En el publicador, ejecute sp_addlogreader_agent (Transact-SQL). Especifique las credenciales de Microsoft Windows con las que se ejecuta el agente para @job_name y @password. Si el agente va a usar la autenticación de SQL Server al conectarse al publicador, también debe especificar un valor de 0 para @publisher_security_mode y la información de inicio de sesión de SQL server para @publisher_login y @publisher_password. Continúe en el paso 3.

  3. En el publicador, ejecute sp_addpublication (Transact-SQL). Especifique un nombre de publicación para @publication y, en el caso del parámetro @repl_freq, especifique un valor de snapshot para una publicación de instantáneas o un valor de continuous para una publicación transaccional. Especifique cualquier otra opción de publicación. Esto define la publicación.

    Nota:

    Los nombres de publicación no pueden incluir los caracteres siguientes:

    %, *, [, ], |, :, ", ?, \, /, < o >.

  4. En el publicador, ejecute sp_addpublication_snapshot (Transact-SQL). Especifique el nombre de publicación usado en el paso 3 para @publication y las credenciales de Windows con las que se ejecuta el Agente de instantáneas para @snapshot_job_name y @password. Si el agente va a usar la autenticación de SQL Server al conectarse al publicador, también debe especificar un valor de 0 para @publisher_security_mode y la información de inicio de sesión de SQL server para @publisher_login y publisher_password. Esto crea un trabajo de Agente de instantáneas para la publicación.

    Importante

    Al configurar un publicador con un distribuidor remoto, los valores suministrados para todos los parámetros, incluidos job_login y job_password, se envían al distribuidor como texto sin formato. Antes de ejecutar este procedimiento almacenado, se recomienda cifrar la conexión entre el publicador y su distribuidor remoto. Para obtener más información, vea Habilitar conexiones cifradas en el motor de base de datos (Administrador de configuración de SQL Server).

  5. Agregue artículos a la publicación. Para más información, consulte Define an Article.

  6. Inicie el trabajo del Agente de instantáneas para generar la instantánea inicial de esta publicación. Para más información, consulte Crear y aplicar la instantánea inicial.

Crear una publicación de combinación

  1. En el publicador, ejecute sp_replicationdboption (Transact-SQL) para habilitar la publicación de la base de datos actual con la replicación de mezcla.

  2. En el publicador de la base de datos de publicación, ejecute sp_addmergepublication (Transact-SQL). Especifique un nombre de publicación para @publication y cualquier otra opción de publicación. Esto define la publicación.

    Nota:

    Los nombres de publicación no pueden incluir los caracteres siguientes:

    %, *, [, ], |, :, ", ?, \, /, < o >.

  3. En el publicador, ejecute sp_addpublication_snapshot (Transact-SQL). Especifique el nombre de publicación usado en el paso 2 para @publication y las credenciales de Windows con las que se ejecuta el Agente de instantáneas para @snapshot_job_name y @password. Si el agente va a usar la autenticación de SQL Server al conectarse al publicador, también debe especificar un valor de 0 para @publisher_security_mode y la información de inicio de sesión de SQL server para @publisher_login y @publisher_password. Esto crea un trabajo de Agente de instantáneas para la publicación.

    Importante

    Al configurar un publicador con un distribuidor remoto, los valores suministrados para todos los parámetros, incluidos job_login y job_password, se envían al distribuidor como texto sin formato. Antes de ejecutar este procedimiento almacenado, se recomienda cifrar la conexión entre el publicador y su distribuidor remoto. Para obtener más información, vea Habilitar conexiones cifradas en el motor de base de datos (Administrador de configuración de SQL Server).

  4. Agregue artículos a la publicación. Para más información, consulte Define an Article.

  5. Inicie el trabajo del Agente de instantáneas para generar la instantánea inicial de esta publicación. Para más información, consulte Crear y aplicar la instantánea inicial.

Ejemplo (Transact-SQL)

Este ejemplo crea una publicación transaccional. Las variables de scripting se usan para pasar las credenciales de Windows necesarias para crear los trabajos del Agente de instantáneas y del Agente de registro del LOG.

-- To avoid storing the login and password in the script file, the values 
-- are passed into SQLCMD as scripting variables. For information about 
-- how to use scripting variables on the command line and in SQL Server
-- Management Studio, see the "Executing Replication Scripts" section in
-- the topic "Programming Replication Using System Stored Procedures".

DECLARE @publicationDB AS sysname;
DECLARE @publication AS sysname;
DECLARE @login AS sysname;
DECLARE @password AS sysname;
SET @publicationDB = N'AdventureWorks'; 
SET @publication = N'AdvWorksProductTran'; 
-- Windows account used to run the Log Reader and Snapshot Agents.
SET @login = $(Login); 
-- This should be passed at runtime.
SET @password = $(Password); 

-- Enable transactional or snapshot replication on the publication database.
EXEC sp_replicationdboption 
    @dbname=@publicationDB, 
    @optname=N'publish',
    @value = N'true';

-- Execute sp_addlogreader_agent to create the agent job. 
EXEC sp_addlogreader_agent 
    @job_login = @login, 
    @job_password = @password,
    -- Explicitly specify the use of Windows Integrated Authentication (default) 
    -- when connecting to the Publisher.
    @publisher_security_mode = 1;

-- Create a new transactional publication with the required properties. 
EXEC sp_addpublication 
    @publication = @publication, 
    @status = N'active',
    @allow_push = N'true',
    @allow_pull = N'true',
    @independent_agent = N'true';

-- Create a new snapshot job for the publication, using a default schedule.
EXEC sp_addpublication_snapshot 
    @publication = @publication, 
    @job_login = @login, 
    @job_password = @password,
    -- Explicitly specify the use of Windows Integrated Authentication (default) 
    -- when connecting to the Publisher.
    @publisher_security_mode = 1;
GO

Este ejemplo crea una publicación de combinación. Las variables de scripting se usan para pasar las credenciales de Windows necesarias para crear el trabajo del Agente de instantáneas.

-- To avoid storing the login and password in the script file, the value 
-- is passed into SQLCMD as a scripting variable. For information about 
-- how to use scripting variables on the command line and in SQL Server
-- Management Studio, see the "Executing Replication Scripts" section in
-- the topic "Programming Replication Using System Stored Procedures".

--Declarations for adding a merge publication
DECLARE @publicationDB AS sysname;
DECLARE @publication AS sysname;
DECLARE @login AS sysname;
DECLARE @password AS sysname;
SET @publicationDB = N'AdventureWorks2022'; 
SET @publication = N'AdvWorksSalesOrdersMerge'; 
SET @login = $(Login);
SET @password = $(Password);

-- Enable merge replication on the publication database, using defaults.
USE master
EXEC sp_replicationdboption 
  @dbname=@publicationDB, 
  @optname=N'merge publish',
  @value = N'true' 

-- Create a new merge publication, explicitly setting the defaults. 
USE [AdventureWorks2022]
EXEC sp_addmergepublication 
-- These parameters are optional.
  @publication = @publication,
  -- optional parameters 
  @description = N'Merge publication of AdventureWorks2022.',
  @publication_compatibility_level  = N'120RTM';

-- Create a new snapshot job for the publication.
EXEC sp_addpublication_snapshot 
  @publication = @publication, 
  @job_login = @login, 
  @job_password = @password;
GO

Usar Replication Management Objects (RMO)

Puede crear publicaciones mediante programación utilizando Replication Management Objects (RMO). Las clases RMO que usa para crear una publicación dependen del tipo de publicación que crea.

Crear una publicación transaccional o de instantáneas

  1. Cree una conexión al publicador mediante la clase ServerConnection .

  2. Cree una instancia de la clase ReplicationDatabase para la base de datos de publicación, establezca la propiedad ConnectionContext en la instancia de ServerConnection del paso 1 y llame al método LoadProperties . Si LoadProperties devuelve false, compruebe que la base de datos existe.

  3. Si la propiedad EnabledTransPublishing es false, establézcala en true.

  4. Para una publicación transaccional, compruebe el valor de la propiedad LogReaderAgentExists . Si esta propiedad es true, un trabajo del Agente de registro del LOG ya existe para esta base de datos. Si esta propiedad es false, haga lo siguiente:

  5. Cree una instancia de la clase TransPublication y establezca las propiedades siguientes para este objeto:

  6. Llame al método Create para crear la publicación.

    Importante

    Cuando se configura un Publicador con un Distribuidor remoto, los valores suministrados para todas las propiedades, incluidos SnapshotGenerationAgentProcessSecurity, se envían al Distribuidor como texto simple. Debe cifrar la conexión entre el publicador y su distribuidor remoto antes de llamar al método Create . Para obtener más información, vea Habilitar conexiones cifradas en el motor de base de datos (Administrador de configuración de SQL Server).

  7. Llame al método CreateSnapshotAgent para crear el trabajo del Agente de instantáneas para la publicación.

Crear una publicación de combinación

  1. Cree una conexión al publicador mediante la clase ServerConnection .

  2. Cree una instancia de la clase ReplicationDatabase para la base de datos de publicación, establezca la propiedad ConnectionContext en la instancia de ServerConnection del paso 1 y llame al método LoadProperties . Si LoadProperties devuelve false, compruebe que la base de datos existe.

  3. Si la propiedad EnabledMergePublishing es false, establézcala en true y llame a CommitPropertyChanges.

  4. Cree una instancia de la clase MergePublication y establezca las propiedades siguientes para este objeto:

  5. Llame al método Create para crear la publicación.

    Importante

    Cuando se configura un Publicador con un Distribuidor remoto, los valores suministrados para todas las propiedades, incluidos SnapshotGenerationAgentProcessSecurity, se envían al Distribuidor como texto simple. Debe cifrar la conexión entre el publicador y su distribuidor remoto antes de llamar al método Create . Para obtener más información, vea Habilitar conexiones cifradas en el motor de base de datos (Administrador de configuración de SQL Server).

  6. Llame al método CreateSnapshotAgent para crear el trabajo del Agente de instantáneas para la publicación.

Ejemplos (RMO)

Este ejemplo habilita la base de datos de AdventureWorks para la publicación transaccional, define un trabajo del Agente de registro del LOG y crea la publicación de AdvWorksProductTran. Se debe definir un artículo para esta publicación. Las credenciales de cuenta de Windows que se necesitan para crear el trabajo del Agente de registro del LOG y el trabajo del Agente de instantáneas se pasan en tiempo de ejecución. Para obtener información sobre cómo usar RMO para definir artículos de instantáneas y de transacciones, vea Define an Article.

// Set the Publisher, publication database, and publication names.
string publicationName = "AdvWorksProductTran";
string publicationDbName = "AdventureWorks2022";
string publisherName = publisherInstance;

ReplicationDatabase publicationDb;
TransPublication publication;

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


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

    // Enable the AdventureWorks2022 database for transactional publishing.
    publicationDb = new ReplicationDatabase(publicationDbName, conn);

    // If the database exists and is not already enabled, 
    // enable it for transactional publishing.
    if (publicationDb.LoadProperties())
    {
        if (!publicationDb.EnabledTransPublishing)
        {
            publicationDb.EnabledTransPublishing = true;
        }

        // If the Log Reader Agent does not exist, create it.
        if (!publicationDb.LogReaderAgentExists)
        {
            // Specify the Windows account under which the agent job runs.
            // This account will be used for the local connection to the 
            // Distributor and all agent connections that use Windows Authentication.
            publicationDb.LogReaderAgentProcessSecurity.Login = winLogin;
            publicationDb.LogReaderAgentProcessSecurity.Password = winPassword;

            // Explicitly set authentication mode for the Publisher connection
            // to the default value of Windows Authentication.
            publicationDb.LogReaderAgentPublisherSecurity.WindowsAuthentication = true;

            // Create the Log Reader Agent job.
            publicationDb.CreateLogReaderAgent();
        }
    }
    else
    {
        throw new ApplicationException(String.Format(
            "The {0} database does not exist at {1}.",
            publicationDb, publisherName));
    }

    // Set the required properties for the transactional publication.
    publication = new TransPublication();
    publication.ConnectionContext = conn;
    publication.Name = publicationName;
    publication.DatabaseName = publicationDbName;

    // Specify a transactional publication (the default).
    publication.Type = PublicationType.Transactional;

    // Activate the publication so that we can add subscriptions.
    publication.Status = State.Active;

    // Enable push and pull subscriptions and independent Distribition Agents.
    publication.Attributes |= PublicationAttributes.AllowPull;
    publication.Attributes |= PublicationAttributes.AllowPush;
    publication.Attributes |= PublicationAttributes.IndependentAgent;

    // Specify the Windows account under which the Snapshot Agent job runs.
    // This account will be used for the local connection to the 
    // Distributor and all agent connections that use Windows Authentication.
    publication.SnapshotGenerationAgentProcessSecurity.Login = winLogin;
    publication.SnapshotGenerationAgentProcessSecurity.Password = winPassword;

    // Explicitly set the security mode for the Publisher connection
    // Windows Authentication (the default).
    publication.SnapshotGenerationAgentPublisherSecurity.WindowsAuthentication = true;

    if (!publication.IsExistingObject)
    {
        // Create the transactional publication.
        publication.Create();

        // Create a Snapshot Agent job for the publication.
        publication.CreateSnapshotAgent();
    }
    else
    {
        throw new ApplicationException(String.Format(
            "The {0} publication already exists.", publicationName));
    }
}

catch (Exception ex)
{
    // Implement custom application error handling here.
    throw new ApplicationException(String.Format(
        "The publication {0} could not be created.", publicationName), ex);
}
finally
{
    conn.Disconnect();
}
' Set the Publisher, publication database, and publication names.
Dim publicationName As String = "AdvWorksProductTran"
Dim publicationDbName As String = "AdventureWorks2022"
Dim publisherName As String = publisherInstance

Dim publicationDb As ReplicationDatabase
Dim publication As TransPublication

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

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

    ' Enable the AdventureWorks2022 database for transactional publishing.
    publicationDb = New ReplicationDatabase(publicationDbName, conn)

    ' If the database exists and is not already enabled, 
    ' enable it for transactional publishing.
    If publicationDb.LoadProperties() Then
        If Not publicationDb.EnabledTransPublishing Then
            publicationDb.EnabledTransPublishing = True
        End If

        ' If the Log Reader Agent does not exist, create it.
        If Not publicationDb.LogReaderAgentExists Then
            ' Specify the Windows account under which the agent job runs.
            ' This account will be used for the local connection to the 
            ' Distributor and all agent connections that use Windows Authentication.
            publicationDb.LogReaderAgentProcessSecurity.Login = winLogin
            publicationDb.LogReaderAgentProcessSecurity.Password = winPassword

            ' Explicitly set authentication mode for the Publisher connection
            ' to the default value of Windows Authentication.
            publicationDb.LogReaderAgentPublisherSecurity.WindowsAuthentication = True

            ' Create the Log Reader Agent job.
            publicationDb.CreateLogReaderAgent()
        End If
    Else
        Throw New ApplicationException(String.Format( _
         "The {0} database does not exist at {1}.", _
         publicationDb, publisherName))
    End If

    ' Set the required properties for the transactional publication.
    publication = New TransPublication()
    publication.ConnectionContext = conn
    publication.Name = publicationName
    publication.DatabaseName = publicationDbName

    ' Specify a transactional publication (the default).
    publication.Type = PublicationType.Transactional

    'Enable push and pull subscriptions and independent Distribition Agents.
    publication.Attributes = _
    publication.Attributes Or PublicationAttributes.AllowPull
    publication.Attributes = _
    publication.Attributes Or PublicationAttributes.AllowPush
    publication.Attributes = _
    publication.Attributes Or PublicationAttributes.IndependentAgent

    ' Activate the publication so that we can add subscriptions.
    publication.Status = State.Active

    ' Specify the Windows account under which the Snapshot Agent job runs.
    ' This account will be used for the local connection to the 
    ' Distributor and all agent connections that use Windows Authentication.
    publication.SnapshotGenerationAgentProcessSecurity.Login = winLogin
    publication.SnapshotGenerationAgentProcessSecurity.Password = winPassword

    ' Explicitly set the security mode for the Publisher connection
    ' Windows Authentication (the default).
    publication.SnapshotGenerationAgentPublisherSecurity.WindowsAuthentication = True

    If Not publication.IsExistingObject Then
        ' Create the transactional publication.
        publication.Create()

        ' Create a Snapshot Agent job for the publication.
        publication.CreateSnapshotAgent()
    Else
        Throw New ApplicationException(String.Format( _
            "The {0} publication already exists.", publicationName))
    End If
Catch ex As Exception
    ' Implement custom application error handling here.
    Throw New ApplicationException(String.Format( _
        "The publication {0} could not be created.", publicationName), ex)
Finally
    conn.Disconnect()
End Try

Este ejemplo habilita la base de datos de AdventureWorks para la publicación de combinación y crea la publicación de AdvWorksSalesOrdersMerge. Todavía se deben definir artículos para esta publicación. Las credenciales de cuenta de Windows que se necesitan para crear el trabajo del Agente de registro del LOG se pasan en tiempo de ejecución. Para obtener información sobre cómo usar RMO para definir artículos de mezcla, vea Define an Article.

// Set the Publisher, publication database, and publication names.
string publisherName = publisherInstance;
string publicationName = "AdvWorksSalesOrdersMerge";
string publicationDbName = "AdventureWorks2022";

ReplicationDatabase publicationDb;
MergePublication publication;

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

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

    // Enable the database for merge publication.				
    publicationDb = new ReplicationDatabase(publicationDbName, conn);
    if (publicationDb.LoadProperties())
    {
        if (!publicationDb.EnabledMergePublishing)
        {
            publicationDb.EnabledMergePublishing = true;
        }
    }
    else
    {
        // Do something here if the database does not exist. 
        throw new ApplicationException(String.Format(
            "The {0} database does not exist on {1}.",
            publicationDb, publisherName));
    }

    // Set the required properties for the merge publication.
    publication = new MergePublication();
    publication.ConnectionContext = conn;
    publication.Name = publicationName;
    publication.DatabaseName = publicationDbName;

    // Enable precomputed partitions.
    publication.PartitionGroupsOption = PartitionGroupsOption.True;

    // Specify the Windows account under which the Snapshot Agent job runs.
    // This account will be used for the local connection to the 
    // Distributor and all agent connections that use Windows Authentication.
    publication.SnapshotGenerationAgentProcessSecurity.Login = winLogin;
    publication.SnapshotGenerationAgentProcessSecurity.Password = winPassword;

    // Explicitly set the security mode for the Publisher connection
    // Windows Authentication (the default).
    publication.SnapshotGenerationAgentPublisherSecurity.WindowsAuthentication = true;

    // Enable Subscribers to request snapshot generation and filtering.
    publication.Attributes |= PublicationAttributes.AllowSubscriberInitiatedSnapshot;
    publication.Attributes |= PublicationAttributes.DynamicFilters;

    // Enable pull and push subscriptions.
    publication.Attributes |= PublicationAttributes.AllowPull;
    publication.Attributes |= PublicationAttributes.AllowPush;

    if (!publication.IsExistingObject)
    {
        // Create the merge publication.
        publication.Create();
        
        // Create a Snapshot Agent job for the publication.
        publication.CreateSnapshotAgent();
    }
    else
    {
        throw new ApplicationException(String.Format(
            "The {0} publication already exists.", publicationName));
    }
}

catch (Exception ex)
{
    // Implement custom application error handling here.
    throw new ApplicationException(String.Format(
        "The publication {0} could not be created.", publicationName), ex);
}
finally
{
    conn.Disconnect();
}
' Set the Publisher, publication database, and publication names.
Dim publisherName As String = publisherInstance
Dim publicationName As String = "AdvWorksSalesOrdersMerge"
Dim publicationDbName As String = "AdventureWorks2022"

Dim publicationDb As ReplicationDatabase
Dim publication As MergePublication

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

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

    ' Enable the database for merge publication.				
    publicationDb = New ReplicationDatabase(publicationDbName, conn)
    If publicationDb.LoadProperties() Then
        If Not publicationDb.EnabledMergePublishing Then
            publicationDb.EnabledMergePublishing = True
        End If
    Else
        ' Do something here if the database does not exist. 
        Throw New ApplicationException(String.Format( _
         "The {0} database does not exist on {1}.", _
         publicationDb, publisherName))
    End If

    ' Set the required properties for the merge publication.
    publication = New MergePublication()
    publication.ConnectionContext = conn
    publication.Name = publicationName
    publication.DatabaseName = publicationDbName

    ' Enable precomputed partitions.
    publication.PartitionGroupsOption = PartitionGroupsOption.True

    ' Specify the Windows account under which the Snapshot Agent job runs.
    ' This account will be used for the local connection to the 
    ' Distributor and all agent connections that use Windows Authentication.
    publication.SnapshotGenerationAgentProcessSecurity.Login = winLogin
    publication.SnapshotGenerationAgentProcessSecurity.Password = winPassword

    ' Explicitly set the security mode for the Publisher connection
    ' Windows Authentication (the default).
    publication.SnapshotGenerationAgentPublisherSecurity.WindowsAuthentication = True

    ' Enable Subscribers to request snapshot generation and filtering.
    publication.Attributes = publication.Attributes Or _
        PublicationAttributes.AllowSubscriberInitiatedSnapshot
    publication.Attributes = publication.Attributes Or _
        PublicationAttributes.DynamicFilters

    ' Enable pull and push subscriptions
    publication.Attributes = publication.Attributes Or _
        PublicationAttributes.AllowPull
    publication.Attributes = publication.Attributes Or _
        PublicationAttributes.AllowPush

    If Not publication.IsExistingObject Then
        ' Create the merge publication.
        publication.Create()

        ' Create a Snapshot Agent job for the publication.
        publication.CreateSnapshotAgent()
    Else
        Throw New ApplicationException(String.Format( _
            "The {0} publication already exists.", publicationName))
    End If
Catch ex As Exception
    ' Implement custom application error handling here.
    Throw New ApplicationException(String.Format( _
        "The publication {0} could not be created.", publicationName), ex)
Finally
    conn.Disconnect()
End Try

Consulte también