VENTAS: 1-800-867-1389

Tutorial: Trasvase de registros para la recuperación ante desastres en entornos informáticos híbridos

Actualizado: abril de 2014

Este tutorial muestra cómo implementar el trasvase de registros de SQL Server en un entorno informático híbrido. Al final del tutorial, la solución SQL Server AlwaysOn constará de los elementos siguientes:

  • Una red virtual que contiene varias subredes, incluida una subred back-end y front-end

  • Un controlador de dominio y un equipo con SQL Server que se ejecuta detrás de un dispositivo VPN en la red local

  • Una conexión VPN de sitio a sitio entre el dispositivo VPN de Azure y el dispositivo VPN local

  • Una VM de SQL Server implementada en la subred back-end en Azure y unida al dominio de AD local

  • El equipo local con SQL Server configurado como servidor de base de datos principal

  • La VM de SQL Server en Azure configurada como servidor de base de datos secundario

Este tutorial incluye instrucciones sobre cómo configurar la solución integral, incluida la configuración de una red privada ficticia (10.0.0.0/24) y un dominio de Active Directory ficticio (corp.contoso.com) local. Si desea usar la red local existente y Active Directory, omita las secciones pertinentes y vaya a Create VPN Connection to Azure and SQL Server VM in Azure. Sin embargo, no se garantiza que los pasos posteriores funcionen con las especificaciones personalizadas de la configuración local existente.

Este tutorial está concebido para mostrarle los pasos necesarios para configurar la solución descrita anteriormente sin profundizar en los detalles de cada paso. Por tanto, en lugar de mostrar los pasos de configuración de la GUI, utiliza el script de PowerShell para llevarle rápidamente a través de cada paso. Se supone lo siguiente:

  1. Instalar Windows Server 2008 R2 en un equipo local que se utilizará como el controlador de dominio y el servidor DHCP.

  2. Conecte el equipo a Internet e instale todas las actualizaciones.

  3. Desconecte el equipo de Internet y conéctelo a la misma subred que el dispositivo VPN.

  4. Abra una ventana de Windows PowerShell en modo de administrador.

  5. Defina las variables siguientes de PowerShell que usará para configurar este equipo:

    $dcName = "DC1"
    $dcIP = "10.0.0.1"
    $subnetMask = "255.255.255.0"
    $gatewayIP = "10.0.0.2"
    $password = "Contoso!000"
    
    
  6. Configure la dirección IP del controlador de dominio en el equipo como 10.0.0.1, con la máscara de subred 255.255.255.0 y la dirección IP de puerta de enlace 10.0.0.2.

    netsh interface ip set address name="Local Area Connection" static $dcIP $subnetMask $gatewayIP 1
    
  7. Cambie el nombre del equipo a DC1.

    netdom renamecomputer $ENV:COMPUTERNAME /newname:$dcName /usero:Administrator /passwordo:$password /force /reboot
    
  8. Una vez que el equipo se reinicie, inicie sesión de nuevo y defina las variables siguientes de PowerShell que utilizará para configurar este equipo como controlador de dominio:

    $domainSuffix = "corp.contoso.com"
    $domainNetBIOS = "CORP"
    $password = "Contoso!000"
    
    
  9. Ejecute DCPROMO.EXE para crear un dominio de Active Directory denominado corp.contoso.com en un nuevo bosque de dominios.

    dcpromo.exe `
        /unattend `
        /ReplicaOrNewDomain:Domain `
        /NewDomain:Forest `
        /NewDomainDNSName:$domainSuffix `
        /ForestLevel:4 `
        /DomainNetbiosName:$domainNetBIOS `
        /DomainLevel:4 `
        /InstallDNS:Yes `
        /ConfirmGc:Yes `
        /CreateDNSDelegation:No `
        /SafeModeAdminPassword:"$password" 
    

    Una vez que se reinicie el equipo, se convierte en el controlador de dominio del dominio corp.contoso.com recién creado.

  10. Inicie sesión en el controlador de dominio como CORP\administrator con la contraseñaContoso!000. Esta es la misma contraseña que utilizará para el resto del tutorial.

  11. Abra una ventana de Windows PowerShell en modo de administrador.

  12. Define las variables siguientes de PowerShell para ayudarle a configurar el dominio.

    $dcName = "DC1"
    $dcIP = "10.0.0.1"
    $gatewayIP = "10.0.0.2"
    $scopeIP = "10.0.0.0"
    $scopeName = "Corpnet"
    $scopeStart = "10.0.0.100"
    $scopeEnd = "10.0.0.150"
    $domainSuffix = "corp.contoso.com"
    $pwd = ConvertTo-SecureString "Contoso!000" -AsPlainText -Force
    
  13. Importe el módulo de PowerShell de Active Directory y cree varios usuarios.

    Import-Module ActiveDirectory
    
    New-ADUser -Name 'Install' -AccountPassword $pwd -PasswordNeverExpires $true -ChangePasswordAtLogon $false -Enabled $true
    New-ADUser -Name 'SQLAgent1' -AccountPassword $pwd -PasswordNeverExpires $true -ChangePasswordAtLogon $false -Enabled $true
    New-ADUser -Name 'SQLAgent2' -AccountPassword $pwd -PasswordNeverExpires $true -ChangePasswordAtLogon $false -Enabled $true
    

    CORP\SQLAgent1 y CORP\SQLAgent2 se usan como cuentas de servicio para los servicios del Agente SQL Server que se ejecutan en los dos servidores de instancia de SQL Server.

  14. Configure el servicio DHCP con un nuevo ámbito de la subred privada. La dirección IP de la puerta de enlace se establece en 10.0.0.2. El dispositivo VPN local se configurará para usarla.

    Import-Module ServerManager
    Add-WindowsFeature DHCP
    Set-Service dhcpserver -StartupType automatic
    Start-service dhcpserver
    netsh dhcp server add scope $scopeIP 255.255.255.0 $scopeName $scopeName
    netsh dhcp server scope $scopeIP set state 0
    netsh dhcp server scope $scopeIP add iprange $scopeStart $scopeEnd
    netsh dhcp server scope $scopeIP set optionvalue 003 IPADDRESS $gatewayIP
    netsh dhcp server scope $scopeIP set optionvalue 006 IPADDRESS $dcIP
    netsh dhcp server scope $scopeIP set optionvalue 015 STRING $domainSuffix
    netsh dhcp server scope $scopeIP set state 1
    netsh dhcp add server $dcName.$domainSuffix $dcIP 
    

Ahora tiene una red TCP/IP funcional que se ejecuta en la subred privada con un dominio de Active Directory funcional. Ya está preparado para configurar el sistema local de SQL Server.

  1. Instale Windows Server 2008 R2 en un equipo local adicional que usará para la instancia local de SQL Server.

  2. Conecte el equipo a Internet e instale todas las actualizaciones.

  3. Desconecte el equipo de Internet y conéctelo a la misma subred que el dispositivo VPN.

  4. Abra una ventana de Windows PowerShell en modo de administrador.

  5. Una los equipos al dominio CORP, que creó previamente. Si utiliza la red y el dominio local existentes, una los equipos al dominio respectivo de su organización. Cambie la variable $computerName a SQLOnPrem para los respectivos equipos.

    $domain = "CORP"
    $domainAdmin = "CORP\Administrator"
    $password = "Contoso!000"
    
    $computerName = SQLOnPrem
    netdom join $env:COMPUTERNAME /domain:$domain /userd:$domainAdmin /passwordd:$password 
    netdom renamecomputer $env:COMPUTERNAME /newname:$computerName /userd:$domainAdmin /passwordd:$password /force /reboot
    

    Los equipos se reinician automáticamente después de que se ejecutan estos comandos.

  6. Una vez que los equipos terminen de reiniciarse, inicie sesión como administrador local de nuevo y abra una ventana de Windows PowerShell en modo de administrador.

  7. Establezca la variable para el directorio de instalación e instale SQL Server 2012 en SQLOnPrem.

    $installDir = "<Directory of SQL Server Setup.exe>"
    $agtsvcacct = "CORP\SQLAgent1"
    $sqlAdmin = "CORP\Install"
    $password = "Contoso!000"
    
    cd $installDir
    .\Setup.exe `
        /q `
        /ACTION=Install `
        /FEATURES=SQL,SSMS `
        /INSTANCENAME=MSSQLSERVER `
        /AGTSVCACCOUNT="$agtsvcacct" `
        /AGTSVCPASSWORD="$password" `
        /SQLSYSADMINACCOUNTS="$sqlAdmin" `
        /IACCEPTSQLSERVERLICENSETERMS
    
    
  8. Abra el firewall para el acceso remoto de SQL Server.

    netsh advfirewall firewall add rule `
        name='SQL Server (TCP-In)' `
        program='C:\Program Files\Microsoft SQL Server\MSSQL11.MSSQLSERVER\MSSQL\Binn\sqlservr.exe' `
        dir=in `
        action=allow `
        protocol=TCP
    
    
  9. Habilite el protocolo TCP en la instancia predeterminada y reinicie el servicio SQL Server.

    [reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo")
    [reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.SqlWmiManagement")
    $wmi = new-object ("Microsoft.SqlServer.Management.Smo.Wmi.ManagedComputer") $env:COMPUTERNAME
    $wmi.ServerInstances['MSSQLSERVER'].ServerProtocols['Tcp'].IsEnabled = "True"
    $wmi.ServerInstances['MSSQLSERVER'].ServerProtocols['Tcp'].Alter()
    $svc = Get-Service -Name 'MSSQLSERVER'
    $timeout = New-Object System.TimeSpan -ArgumentList 0, 0, 30
    $svc.Stop(); 
    $svc.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Stopped,$timeout)
    $svc.Start(); 
    $svc.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Stopped,$timeout) 
    
  10. Agregue CORP\install como administrador local. Usará este usuario para configurar el clúster WSFC y el grupo de disponibilidad.

    net localgroup administrators "$sqlAdmin" /Add
    
  11. Cierre sesión en ambos equipos.

    Logoff.exe
    

Ha terminado con la configuración de SQL Server y de la subred privada local. Después, configurará la conexión VPN entre la subred privada local y una red de Azure, y también creará un máquina virtual de SQL Server unida al dominio en Azure.

  1. En una ventana de PowerShell en un equipo conectado a Internet, importe el módulo de Azure, descargue un archivo de configuración de publicación en el equipo y conecte la sesión de PowerShell a la suscripción de Azure importando la configuración de publicación descargada.

    Import-Module `
        "C:\Program Files (x86)\Microsoft SDKs\Azure\PowerShell\Azure\Azure.psd1"
    Get-AzurePublishSettingsFile
    Import-AzurePublishSettingsFile <publishsettingsfilepath> 
    

    El comando Get-AzurePublishgSettingsFile genera automáticamente un certificado de administración con las descargas de Azure en el equipo. Se abrirá un explorador automáticamente y se le solicitará que escriba las credenciales de la cuenta de Microsoft para su suscripción de Azure. El archivo descargado .publishsettings contiene toda la información que necesita para administrar la suscripción de Azure. Cuando guarde este archivo en un directorio local, impórtelo mediante el comando Import-AzurePublishSettingsFile.

    securityNota de seguridad
    El archivo publishsettings contiene las credenciales (sin codificar) que se usan para administrar sus servicios y suscripciones de Azure. Por seguridad, se recomienda almacenar este archivo temporalmente fuera de los directorios de origen (por ejemplo, en la carpeta Bibliotecas\Documentos) y eliminarlo una vez completada la importación. Un usuario malintencionado que tenga acceso al archivo publishsettings puede editar, crear y eliminar sus servicios de Azure.

  2. Defina una serie de variables que usará para crear la infraestructura de TI en la nube.

    $workingDir = "C:\workingDirectory\"
    $location = "West US"
    $affinityGroupName = "ContosoAG"
    $affinityGroupDescription = "Contoso SQL HADR Affinity Group"
    $affinityGroupLabel = "IaaS BI Affinity Group"
    $virtualNetworkName = "ContosoNET" 
    $localNetworkName = "ContosoNETLocal"
    $networkConfigPath = $workingDir + "NetworkConfig.xml"
    $storageAccountName = "<uniquestorageaccountname>"
    $storageAccountLabel = "Contoso SQL HADR Storage Account"
    $storageAccountContainer = "https://$storageAccountName.blob.core.windows.net/vhds/"
    $sqlImageName = (Get-AzureVMImage | where {$_.Label -like "SQL Server 2012 SP1 Enterprise*"} | sort PublishedDate -Descending)[0].ImageName
    $serviceName = "<uniqueservicename>"
    $sqlServerName = "SQLInCloud"
    $vmAdminUser = "AzureAdmin" 
    $vmAdminPassword = "Contoso!000"
    $dnsSettings = New-AzureDns -Name "LocalDC" -IPAddress "10.0.0.1"
    $domainName= "corp"
    $domainSuffix = "corp.contoso.com"
    $subnetName = "CloudBack"
    $domainUser = "Administrator"
    $dataDiskSize = 100
    

    Preste atención a lo siguiente para asegurarse de que los comandos se ejecutarán correctamente después:

    • Las variables $storageAccountName y $serviceName deben ser únicas porque se usan para identificar la cuenta de almacenamiento en la nube y el servidor en la nube, respectivamente, en Internet.

    • Los nombres especificados para las variables $affinityGroupName, $virtualNetworkName y $localNetworkName se configuran en el documento de configuración de red virtual que utilizará más adelante.

    • $sqlImageName especifica el nuevo nombre de la imagen de VM que contiene SQL Server 2012 Service Pack 1 Enterprise Edition.

    • Para simplificar, Contoso!000 es la contraseña que se usa en todo en el tutorial.

  3. Cree un grupo de afinidad.

    New-AzureAffinityGroup `
        -Name $affinityGroupName `
        -Location $location `
        -Description $affinityGroupDescription `
        -Label $affinityGroupLabel
    
  4. Cree una red virtual importando un archivo de configuración denominado NetworkConfig.xml..

    Set-AzureVNetConfig `
        -ConfigurationPath $networkConfigPath
    

    El archivo de configuración contiene el siguiente documento XML. En resumen, especifica una red virtual denominada ContosoNET en el grupo de afinidad denominado ContosoAG y tiene el espacio de direcciones 10.10.0.0/16. La subred CloudBack o 10.1.1.0/24 es donde colocará la VM de SQL Server. Azure usa la subred GatewaySubnet o 10.1.254.0/24 para colocar un dispositivo (VPN) virtual. No se puede cambiar el nombre de subred GatewaySubnet. Si cambia las variables $affinityGroupName, $virtualNetworkName y $localNetworkName anteriores, debe cambiar también los nombres que corresponden siguientes. Además, el documento configura la dirección IP del servidor DNS local, 10.0.0.1, y hace referencia a este servidor DNS en el elemento DnsServersRef.

    <NetworkConfiguration xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.microsoft.com/ServiceHosting/2011/07/NetworkConfiguration">
      <VirtualNetworkConfiguration>
        <Dns>
          <DnsServers>
            <DnsServer name="LocalDC" IPAddress="10.0.0.1" />
          </DnsServers>
        </Dns>
        <LocalNetworkSites>
          <LocalNetworkSite name="ContosoNETLocal">
            <AddressSpace>
              <AddressPrefix>10.0.0.0/24</AddressPrefix>
            </AddressSpace>
            <VPNGatewayAddress>24.12.228.169</VPNGatewayAddress>
          </LocalNetworkSite>
        </LocalNetworkSites>
        <VirtualNetworkSites>
          <VirtualNetworkSite name="ContosoNET" AffinityGroup="ContosoAG">
            <AddressSpace>
              <AddressPrefix>10.1.0.0/16</AddressPrefix>
            </AddressSpace>
            <Subnets>
              <Subnet name="CloudBack">
                <AddressPrefix>10.1.1.0/24</AddressPrefix>
              </Subnet>
              <Subnet name="GatewaySubnet">
                <AddressPrefix>10.1.254.0/24</AddressPrefix>
              </Subnet>
            </Subnets>
            <DnsServersRef>
              <DnsServerRef name="LocalDC" />
            </DnsServersRef>
            <Gateway profile="Small">
              <ConnectionsToLocalNetwork>
                <LocalNetworkSiteRef name="ContosoNETLocal" />
              </ConnectionsToLocalNetwork>
            </Gateway>
          </VirtualNetworkSite>
        </VirtualNetworkSites>
      </VirtualNetworkConfiguration>
    </NetworkConfiguration>
    
  5. Cree la puerta de enlace de la red virtual y espere a que la puerta de enlace termine el aprovisionamiento.

    New-AzureVNetGateway -VNetName $virtualNetworkName
    
    $gateway = Get-AzureVNetGateway -VNetName $virtualNetworkName
    While ($gateway.State -ne "Provisioned")
    {
        write-host "Waiting...Current State = " $gateway.Status
        Start-Sleep -Seconds 15
        $gateway = Get-AzureVNetGateway -VNetName $virtualNetworkName
    }
    
    "IP Address   : " + $gateway.VIPAddress
    "Preshared Key: " + (Get-AzureVNetGatewayKey -VNetName $virtualNetworkName -LocalNetworkSiteName $localNetworkName).Value
    
    

    La puerta de enlace de red virtual tarda algún tiempo en aprovisionarse. Una vez que se aprovisiona, la dirección IP pública de la puerta de enlace y la clave compartida previamente se muestran en la ventana de PowerShell.

  6. Configure el dispositivo VPN local utilizando la dirección IP pública de la puerta de enlace de red virtual y la clave compartida previamente. Para utilizar el script de configuración específico del dispositivo VPN, vea Acerca de los dispositivos VPN de red virtual.

    Al final de este paso, la conexión VPN debería estar conectada completamente. Para obtener más información, vea Establecer una conexión VPN de sitio a sitio.

  7. Continuando con la ventana de PowerShell en el equipo conectado a Internet, cree una cuenta de almacenamiento asociada al grupo de afinidad que ha creado.

    New-AzureStorageAccount `
        -StorageAccountName $storageAccountName `
        -Label $storageAccountLabel `
        -AffinityGroup $affinityGroupName
    Set-AzureSubscription `
        -SubscriptionName (Get-AzureSubscription).SubscriptionName `
        -CurrentStorageAccount $storageAccountName
    
  8. Cree la VM de SQL Server en un nuevo servicio en la nube.

    New-AzureVMConfig `
        -Name $sqlServerName `
        -InstanceSize Large `
        -ImageName $sqlImageName `
        -MediaLocation "$storageAccountContainer$sqlServerName.vhd" `
        -HostCaching "ReadOnly" `
        -DiskLabel "OS" | 
        Add-AzureProvisioningConfig `
            -WindowsDomain `
            -AdminUserName $vmAdminUser `
            -Password $vmAdminPassword `
            -DisableAutomaticUpdates `
            -Domain $domainName `
            -JoinDomain $domainSuffix `
            -DomainUserName $domainUser `
            -DomainPassword $vmAdminPassword |
            Set-AzureSubnet `
                -SubnetNames $subnetName |
                Add-AzureEndpoint `
                    -Name "SQL" `
                    -Protocol "tcp" `
                    -PublicPort 1 `
                    -LocalPort 1433 | 
                    New-AzureVM `
                        -ServiceName $serviceName `
                        -AffinityGroup $affinityGroupName `
                        -VNetName $virtualNetworkName `
                        -DnsSettings $dnsSettings
    

    Esta serie de comandos canalizados hacen lo siguiente:

    • New-AzureVMConfig crea una configuración de VM con la imagen de SQL Server 2012 Service Pack 1 Enterprise Edition en la galería de la máquina virtual. También establece el disco del sistema operativo en solo Caching de lectura (sin Caching de escritura). Se recomienda migrar los archivos de base de datos a un disco de datos independiente que exponga a la VM y configurarlo sin Caching de lectura o escritura. Sin embargo, dado que ambos servidores de bases de datos locales usan la unidad C: para los archivos de base de datos, renunciará a mover los archivos de la base de datos. De esta manera, la VM de Azure puede ser idéntica a los servidores locales de configuración cuando todos se unan a un clúster WSFC posteriormente.

    • Add-AzureProvisioningConfig combina la VM en el dominio de Active Directory local que creó.

    • Add-AzureEndpoint agrega extremos de acceso de modo que las aplicaciones cliente puedan tener acceso a la instancia del servicio SQL Server en Internet.

    • New-AzureVM crea un nuevo servicio en la nube y una nueva VM de Windows en el nuevo servicio en la nube.

  9. Espere a que la nueva VM esté completamente aprovisionada y descargue el archivo de escritorio remoto en el directorio de trabajo. El bucle de tiempo while sigue sondeando la nueva VM de Azure hasta que está lista para usarse.

    $VMStatus = Get-AzureVM -ServiceName $serviceName -Name $sqlServerName
    
    While ($VMStatus.Status -ne "ReadyRole")
    {
        write-host "Waiting...Current Status = " $VMStatus.InstanceStatus
        Start-Sleep -Seconds 15
        $VMStatus = Get-AzureVM -ServiceName $serviceName -Name $sqlServerName
    } 
    Get-AzureRemoteDesktopFile `
        -ServiceName $serviceName `
        -Name $sqlServerName `
        -LocalPath "$workingDir$sqlServerName.rdp"
    

A continuación, se conectará a la nueva VM de SQL Server, SQLInCloud, y la inicializará.

En esta sección, debe modificar la instalación predeterminada de SQL Server en la nueva VM de SQL Server que creó para prepararla para unirse al grupo de disponibilidad. Concretamente:

  • La VM se instala con todos los servicios de SQL Server (por ejemplo, motor de base de datos, SSIS, SSAS, SSRS, etc.). Necesita deshabilitar todos los servicios de SQL que no necesite, como la instancia predeterminada de MSSQLSERVER y el demonio de búsqueda de texto completo.

  • Necesita cambiar el Agente SQL Server de la cuenta de servicio a CORP\SQLAgent2.

  • El protocolo TCP ya está habilitado en la VM de SQL Server. Sin embargo, todavía necesita abrir el firewall para el acceso remoto de SQL Server.

  1. Conéctese a SQLInCloud iniciando los archivos de escritorio remoto. Use el nombre de usuario AzureAdmin y la contraseña Contoso!000 del administrador del equipo, que especificó al crear las VM.

  2. Compruebe que los equipos se han unido correctamente a corp.contoso.com.

  3. Espere a que instalación de SQL Server termine de ejecutar las tareas automatizadas de inicialización antes de continuar.

  4. Abra una ventana de PowerShell en modo de administrador.

  5. Defina las variables siguientes.

    $desirableServices = @("SqlServer","SqlAgent","9")
    $svcaccount = "CORP\SQLAgent2"
    $password = "Contoso!000"
    

    Para la variable $desirableServices, SqlServer es el tipo del servicio del motor de base de datos, SqlAgent es el tipo de servicio del Agente SQL Server y 9 es el tipo de servicio del demonio de búsqueda de texto completo.

  6. Importe el proveedor de PowerShell de SQL Server.

    Set-ExecutionPolicy -Execution RemoteSigned -Force
    Import-Module -Name "sqlps" -DisableNameChecking
    
  7. Detenga todos los servicios de SQL que no desee (SSIS, SSAS, SSRS, etc.) y establezca su modo de inicio en Disabled.

    $wmi = new-object ("Microsoft.SqlServer.Management.Smo.Wmi.ManagedComputer") $env:COMPUTERNAME
    $wmi.services | where {$desirableServices -notcontains $_.Type} | foreach{$_.StartMode = "Disabled"; $_.Alter(); $_.Stop();}
    
  8. Cambie la cuenta de servicio del Agente SQL Server para la instancia predeterminada a CORP\SQLAgent2.

    $wmi.services | where {$_.Type -eq 'SqlAgent'} | foreach{$_.SetServiceAccount($svcaccount,$password)}
    $svc = Get-Service -Name 'SQLSERVERAGENT'
    $timeout = New-Object System.TimeSpan -ArgumentList 0, 0, 30
    $svc.Stop(); 
    $svc.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Stopped,$timeout)
    # Start the SQL Server service and wait for the service to be fully started
    $svc.Start(); 
    $svc.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Running,$timeout)
    
  9. Abra el firewall para el acceso remoto de SQL Server.

    netsh advfirewall firewall add rule name='SQL Server (TCP-In)' program='C:\Program Files\Microsoft SQL Server\MSSQL11.MSSQLSERVER\MSSQL\Binn\sqlservr.exe' dir=in action=allow protocol=TCP
    

Finalmente, ya puede configurar el trasvase de registros.

  1. Conéctese a SQLOnPrem de nuevo iniciando los archivos de escritorio remoto. Para iniciar sesión, use la cuenta de administrador integrada.

  2. Abra una ventana de PowerShell en modo de administrador. Si no ha cerrado sesión previamente de SQLOnPrem, debe cerrar la ventana existente de PowerShell y abrir una nueva en modo de administrador para asegurarse de que las rutas de acceso de SQL Server se carguen en las variables de entorno de PowerShell.

  3. Cree el recurso compartido de red que usará para los trabajos de trasvase de registros.

    $backup = "C:\LocalBackup"
    $acct1 = "CORP\SQLAgent1"
    $acct2 = "CORP\SQLAgent2"
    
    New-Item $backup -ItemType directory
    net share backup=$backup "/grant:$acct1,FULL" "/grant:$acct2,FULL"
    icacls.exe "$backup" /grant:r ("$acct1" + ":(OI)(CI)F") ("$acct2" + ":(OI)(CI)F")
    
  4. Ejecute el script Transact-SQL siguiente para configurar el trasvase de registros en SQLOnPrem. Este script se genera desde la interfaz de usuario de SQL Server Management Studio (SSMS) usando las variables siguientes:

    1. Base de datos: MyDB1

    2. Directorio de copia de seguridad: C:\LocalBackup

    3. Ruta de acceso del recurso compartido de copia de seguridad: \\SQLOnPrem\backup

    4. Servidor secundario: SQLInCloud

    5. Directorio de destino para las copias de seguridad de registros (en SQLInCloud): C:\LocalBackup

    Ejecutará la segunda parte del script generado por SSMS en SQLInCloud más adelante.

    SQLCMD -S SQLOnPrem
    
    DECLARE @LS_BackupJobIdAS uniqueidentifier 
    DECLARE @LS_PrimaryIdAS uniqueidentifier 
    DECLARE @SP_Add_RetCodeAs int 
    
    
    EXEC @SP_Add_RetCode = master.dbo.sp_add_log_shipping_primary_database 
    @database = N'MyDB1' 
    ,@backup_directory = N'C:\LocalBackup' 
    ,@backup_share = N'\\SQLOnPrem\backup' 
    ,@backup_job_name = N'LSBackup_MyDB1' 
    ,@backup_retention_period = 4320
    ,@backup_compression = 2
    ,@backup_threshold = 60 
    ,@threshold_alert_enabled = 1
    ,@history_retention_period = 5760 
    ,@backup_job_id = @LS_BackupJobId OUTPUT 
    ,@primary_id = @LS_PrimaryId OUTPUT 
    ,@overwrite = 1 
    
    
    IF (@@ERROR = 0 AND @SP_Add_RetCode = 0) 
    BEGIN 
    
    DECLARE @LS_BackUpScheduleUIDAs uniqueidentifier 
    DECLARE @LS_BackUpScheduleIDAS int 
    
    
    EXEC msdb.dbo.sp_add_schedule 
    @schedule_name =N'LSBackupSchedule_SQL11' 
    ,@enabled = 1 
    ,@freq_type = 4 
    ,@freq_interval = 1 
    ,@freq_subday_type = 4 
    ,@freq_subday_interval = 15 
    ,@freq_recurrence_factor = 0 
    ,@active_start_date = 20121127 
    ,@active_end_date = 99991231 
    ,@active_start_time = 0 
    ,@active_end_time = 235900 
    ,@schedule_uid = @LS_BackUpScheduleUID OUTPUT 
    ,@schedule_id = @LS_BackUpScheduleID OUTPUT 
    
    EXEC msdb.dbo.sp_attach_schedule 
    @job_id = @LS_BackupJobId 
    ,@schedule_id = @LS_BackUpScheduleID  
    
    EXEC msdb.dbo.sp_update_job 
    @job_id = @LS_BackupJobId 
    ,@enabled = 1 
    
    
    END 
    
    
    EXEC master.dbo.sp_add_log_shipping_alert_job 
    
    EXEC master.dbo.sp_add_log_shipping_primary_secondary 
    @primary_database = N'MyDB1' 
    ,@secondary_server = N'SQLInCloud' 
    ,@secondary_database = N'MyDB1' 
    ,@overwrite = 1 
    
    Exit
    
  5. Conéctese a SQLInCloud de nuevo iniciando los archivos de escritorio remoto. Para iniciar sesión, use la cuenta de administrador integrada.

  6. Abra una ventana de PowerShell en modo de administrador.

  7. Cree el directorio local que usará para los trabajos de copia y restauración de trasvase de registros.

    $backup = "C:\LocalBackup"
    $acct2 = "CORP\SQLAgent2"
    
    New-Item $backup -ItemType directory
    icacls.exe "$backup" /grant:r ("$acct2" + ":(OI)(CI)F")
    
  8. Ejecute el script Transact-SQL siguiente para configurar el trasvase de registros en SQLInCloud. Esta es la segunda parte del script generado por SSMS.

    SQLCMD -S SQLInCloud
    
    DECLARE @LS_Secondary__CopyJobIdAS uniqueidentifier 
    DECLARE @LS_Secondary__RestoreJobIdAS uniqueidentifier 
    DECLARE @LS_Secondary__SecondaryIdAS uniqueidentifier 
    DECLARE @LS_Add_RetCodeAs int 
    
    
    EXEC @LS_Add_RetCode = master.dbo.sp_add_log_shipping_secondary_primary 
    @primary_server = N'SQLOnPrem' 
    ,@primary_database = N'MyDB1' 
    ,@backup_source_directory = N'\\SQLOnPrem\backup' 
    ,@backup_destination_directory = N'C:\LocalBackup' 
    ,@copy_job_name = N'LSCopy_SQLOnPrem_MyDB1' 
    ,@restore_job_name = N'LSRestore_SQLOnPrem_MyDB1' 
    ,@file_retention_period = 4320 
    ,@overwrite = 1 
    ,@copy_job_id = @LS_Secondary__CopyJobId OUTPUT 
    ,@restore_job_id = @LS_Secondary__RestoreJobId OUTPUT 
    ,@secondary_id = @LS_Secondary__SecondaryId OUTPUT 
    
    IF (@@ERROR = 0 AND @LS_Add_RetCode = 0) 
    BEGIN 
    
    DECLARE @LS_SecondaryCopyJobScheduleUIDAs uniqueidentifier 
    DECLARE @LS_SecondaryCopyJobScheduleIDAS int 
    
    
    EXEC msdb.dbo.sp_add_schedule 
    @schedule_name =N'DefaultCopyJobSchedule' 
    ,@enabled = 1 
    ,@freq_type = 4 
    ,@freq_interval = 1 
    ,@freq_subday_type = 4 
    ,@freq_subday_interval = 15 
    ,@freq_recurrence_factor = 0 
    ,@active_start_date = 20121127 
    ,@active_end_date = 99991231 
    ,@active_start_time = 0 
    ,@active_end_time = 235900 
    ,@schedule_uid = @LS_SecondaryCopyJobScheduleUID OUTPUT 
    ,@schedule_id = @LS_SecondaryCopyJobScheduleID OUTPUT 
    
    EXEC msdb.dbo.sp_attach_schedule 
    @job_id = @LS_Secondary__CopyJobId 
    ,@schedule_id = @LS_SecondaryCopyJobScheduleID  
    
    DECLARE @LS_SecondaryRestoreJobScheduleUIDAs uniqueidentifier 
    DECLARE @LS_SecondaryRestoreJobScheduleIDAS int 
    
    
    EXEC msdb.dbo.sp_add_schedule 
    @schedule_name =N'DefaultRestoreJobSchedule' 
    ,@enabled = 1 
    ,@freq_type = 4 
    ,@freq_interval = 1 
    ,@freq_subday_type = 4 
    ,@freq_subday_interval = 15 
    ,@freq_recurrence_factor = 0 
    ,@active_start_date = 20121127 
    ,@active_end_date = 99991231 
    ,@active_start_time = 0 
    ,@active_end_time = 235900 
    ,@schedule_uid = @LS_SecondaryRestoreJobScheduleUID OUTPUT 
    ,@schedule_id = @LS_SecondaryRestoreJobScheduleID OUTPUT 
    
    EXEC msdb.dbo.sp_attach_schedule 
    @job_id = @LS_Secondary__RestoreJobId 
    ,@schedule_id = @LS_SecondaryRestoreJobScheduleID  
    
    
    END 
    
    
    DECLARE @LS_Add_RetCode2As int 
    
    
    IF (@@ERROR = 0 AND @LS_Add_RetCode = 0) 
    BEGIN 
    
    EXEC @LS_Add_RetCode2 = master.dbo.sp_add_log_shipping_secondary_database 
    @secondary_database = N'MyDB1' 
    ,@primary_server = N'SQLOnPrem' 
    ,@primary_database = N'MyDB1' 
    ,@restore_delay = 0 
    ,@restore_mode = 0 
    ,@disconnect_users= 0 
    ,@restore_threshold = 45   
    ,@threshold_alert_enabled = 1 
    ,@history_retention_period= 5760 
    ,@overwrite = 1 
    
    END 
    
    
    IF (@@error = 0 AND @LS_Add_RetCode = 0) 
    BEGIN 
    
    EXEC msdb.dbo.sp_update_job 
    @job_id = @LS_Secondary__CopyJobId 
    ,@enabled = 1 
    
    EXEC msdb.dbo.sp_update_job 
    @job_id = @LS_Secondary__RestoreJobId 
    ,@enabled = 1 
    
    END 
    
    Exit
    

Enhorabuena. Ha implementado correctamente el trasvase de registros en un entorno informático híbrido, donde el servidor de base de datos principal se ejecuta de forma local y el servidor de base de datos secundario se ejecuta en Azure. Puede supervisar los trabajos de trasvase de registros del Agente SQL Server para asegurarse de que los registros se crean correctamente en SQLOnPrem, y se copian y restauran correctamente en SQLInCloud.

¿Te ha resultado útil?
(Caracteres restantes: 1500)
Gracias por sus comentarios
Mostrar:
© 2014 Microsoft