Exportar (0) Imprimir
Expandir todo

Tutorial: Grupos de disponibilidad de AlwaysOn en Azure (PowerShell)

Actualizado: octubre de 2013

noteNota
Para seguir el tutorial basado en GUI del mismo escenario, vea Práctica: Crear el grupo de disponibilidad AlwaysOn en Azure de extremo a extremo .

Las máquinas virtuales (VM) de Azure pueden ayudar a los administradores de bases de datos a reducir el costo de un sistema de alta disponibilidad de SQL Server. Este tutorial muestra cómo implementar un grupo de disponibilidad mediante SQL Server AlwaysOn integral dentro de un entorno de Azure. Al final del tutorial, la solución SQL Server AlwaysOn en Azure constará de los elementos siguientes:

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

  • Un controlador de dominio con un dominio de Active Directory (AD)

  • Dos VM de SQL Server implementadas en la subred back-end y unidas al dominio de AD

  • Un clúster WSFC de tres nodos con el modelo de cuórum Mayoría de nodo

  • Un grupo de disponibilidad con dos réplicas de confirmación sincrónica de una base de datos de disponibilidad

Este escenario se elige por simplicidad, no por rentabilizar los costes o por otros factores de Azure. Por ejemplo, puede minimizar el número de VM para el grupo de disponibilidad de dos réplicas para ahorrar horas de cálculo en Azure con el controlador de dominio como testigo de recurso compartido de archivos de cuórum en un clúster WSFC de dos nodos. Este método reduce el recuento de VM en uno respecto a la configuración anterior.

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. En una ventana de PowerShell del equipo local, 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.

    $location = "West US"
    $affinityGroupName = "ContosoAG"
    $affinityGroupDescription = "Contoso SQL HADR Affinity Group"
    $affinityGroupLabel = "IaaS BI Affinity Group"
    $networkConfigPath = "C:\scripts\Network.netcfg"
    $virtualNetworkName = "ContosoNET"
    $storageAccountName = "<uniquestorageaccountname>"
    $storageAccountLabel = "Contoso SQL HADR Storage Account"
    $storageAccountContainer = "https://" + $storageAccountName + ".blob.core.windows.net/vhds/"
    $winImageName = (Get-AzureVMImage | where {$_.Label -like "Windows Server 2008 R2 SP1*"} | sort PublishedDate -Descending)[0].ImageName
    $sqlImageName = (Get-AzureVMImage | where {$_.Label -like "SQL Server 2012 SP1 Enterprise*"} | sort PublishedDate -Descending)[0].ImageName
    $dcServerName = "ContosoDC"
    $dcServiceName = "<uniqueservicename>" 
    $availabilitySetName = "SQLHADR"
    $vmAdminUser = "AzureAdmin" 
    $vmAdminPassword = "Contoso!000" 
    $workingDir = "c:\scripts\" 
    

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

    • Las variables $storageAccountName y $dcServiceName 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 y $virtualNetworkName 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.

    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 y dos subredes, 10.10.1.0/24 y 10.10.2.0/24, que son la subred front-end y back-end, respectivamente. La subred front-end es donde puede poner aplicaciones cliente como Microsoft SharePoint y la subred back-end es donde pondrá las VM de SQL Server. Si cambia las variables $affinityGroupName y $virtualNetworkName anteriores, debe cambiar también los nombres correspondientes a continuación.

    <NetworkConfiguration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.microsoft.com/ServiceHosting/2011/07/NetworkConfiguration">
      <VirtualNetworkConfiguration>
        <Dns />
        <VirtualNetworkSites>
          <VirtualNetworkSite name="ContosoNET" AffinityGroup="ContosoAG">
            <AddressSpace>
              <AddressPrefix>10.10.0.0/16</AddressPrefix>
            </AddressSpace>
            <Subnets>
              <Subnet name="Front">
                <AddressPrefix>10.10.1.0/24</AddressPrefix>
              </Subnet>
              <Subnet name="Back">
                <AddressPrefix>10.10.2.0/24</AddressPrefix>
              </Subnet>
            </Subnets>
          </VirtualNetworkSite>
        </VirtualNetworkSites>
      </VirtualNetworkConfiguration>
    </NetworkConfiguration>
    
  5. Cree una cuenta de almacenamiento asociada al grupo de afinidad que creó y establézcalo como cuenta de almacenamiento actual en la suscripción.

    New-AzureStorageAccount `
        -StorageAccountName $storageAccountName `
        -Label $storageAccountLabel `
        -AffinityGroup $affinityGroupName 
    Set-AzureSubscription `
        -SubscriptionName (Get-AzureSubscription).SubscriptionName `
        -CurrentStorageAccount $storageAccountName
    
  6. Cree el servidor DC en el nuevo servicio en la nube y conjunto de disponibilidad.

    New-AzureVMConfig `
        -Name $dcServerName `
        -InstanceSize Medium `
        -ImageName $winImageName `
        -MediaLocation "$storageAccountContainer$dcServerName.vhd" `
        -DiskLabel "OS" | 
        Add-AzureProvisioningConfig `
            -Windows `
            -DisableAutomaticUpdates `
            -AdminUserName $vmAdminUser `
            -Password $vmAdminPassword |
            New-AzureVM `
                -ServiceName $dcServiceName `
                –AffinityGroup $affinityGroupName `
                -VNetName $virtualNetworkName
    

    Esta serie de comandos canalizados hacen lo siguiente:

    • New-AzureVMConfig crea una configuración de VM.

    • Add-AzureProvisioningConfig proporciona los parámetros de configuración de un servidor independiente de Windows.

    • Add-AzureDataDisk agrega el disco de datos que utilizará para almacenar los datos de Active Directory, con la opción de Caching establecida en None.

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

  7. Espere a que la nueva VM esté completamente aprovisionada y descargue el archivo de escritorio remoto en el directorio de trabajo. Dado que la nueva VM de Azure tarda mucho en aprovisionarse, el bucle while continúa sondeando la nueva VM hasta que esté lista para usarse.

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

El servidor DC ya está aprovisionado correctamente. Después, configurará el dominio de Active Directory en este servidor DC. Deje la ventana de PowerShell abierta en el equipo local. Se utilizará de nuevo posteriormente para crear dos VM de SQL Server.

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

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

  3. Ejecute el siguiente comando para DCPROMO.EXE para configurar el dominio corp.contoso.com con los directorios de datos en la unidad M.

    dcpromo.exe `
        /unattend `
        /ReplicaOrNewDomain:Domain `
        /NewDomain:Forest `
        /NewDomainDNSName:corp.contoso.com `
        /ForestLevel:4 `
        /DomainNetbiosName:CORP `
        /DomainLevel:4 `
        /InstallDNS:Yes `
        /ConfirmGc:Yes `
        /CreateDNSDelegation:No `
        /DatabasePath:"C:\Windows\NTDS" `
        /LogPath:"C:\Windows\NTDS" `
        /SYSVOLPath:"C:\Windows\SYSVOL" `
        /SafeModeAdminPassword:"Contoso!000"
    

    Una vez completado el comando, se reinicia la VM automáticamente.

  4. Conéctese al servidor DC de nuevo iniciando el archivo de escritorio remoto. Esta vez, inicie sesión como CORP\Administrator.

  5. Abra una ventana de PowerShell en modo administrador e importe el módulo de PowerShell de Active Directory mediante el comando siguiente:

    Import-Module ActiveDirectory
    
  6. Ejecute los comandos siguientes para agregar tres usuarios al dominio.

    $pwd = ConvertTo-SecureString "Contoso!000" -AsPlainText -Force
    New-ADUser `
        -Name 'Install' `
        -AccountPassword  $pwd `
        -PasswordNeverExpires $true `
        -ChangePasswordAtLogon $false `
        -Enabled $true
    New-ADUser `
        -Name 'SQLSvc1' `
        -AccountPassword  $pwd `
        -PasswordNeverExpires $true `
        -ChangePasswordAtLogon $false `
        -Enabled $true
    New-ADUser `
        -Name 'SQLSvc2' `
        -AccountPassword  $pwd `
        -PasswordNeverExpires $true `
        -ChangePasswordAtLogon $false `
        -Enabled $true
    

    CORP\Install se utiliza para configurar todo lo relacionado con las instancias de servicio de SQL Server, el clúster de WSFC y la disponibilidad de grupo. CORP\SQLSvc1 y CORP\SQLSvc2 se usan como cuentas de servicio de SQL Server para las dos VM de SQL Server.

  7. A continuación, ejecute los comandos siguientes para proporcionar a CORP\Install los permisos para crear objetos de equipo en el dominio.

    Cd ad:
    $sid = new-object System.Security.Principal.SecurityIdentifier (Get-ADUser "Install").SID
    $guid = new-object Guid bf967a86-0de6-11d0-a285-00aa003049e2
    $ace1 = new-object System.DirectoryServices.ActiveDirectoryAccessRule $sid,"CreateChild","Allow",$guid,"All"
    $corp = Get-ADObject -Identity "DC=corp,DC=contoso,DC=com"
    $acl = Get-Acl $corp
    $acl.AddAccessRule($ace1)
    Set-Acl -Path "DC=corp,DC=contoso,DC=com" -AclObject $acl 
    

    El GUID especificado anteriormente es el GUID para el tipo de objeto del equipo. La cuenta CORP\Install necesita los permisos Read All Properties y Create Computer Objects para crear objetos de Active Directory para el clúster WSFC. El permiso Read All Properties ya se le ha asignado a CORP\Install de forma predeterminada, por lo que no es necesario concederlo explícitamente. Para obtener más información acerca de los permisos necesarios para crear el clúster WSFC, vea Guía paso a paso de clúster de conmutación por error: Configurar cuentas en Active Directory.

Ahora que ha terminado de configurar Active Directory y los objetos de usuario, creará dos VM de SQL Server y los unirá a este dominio.

  1. Siga utilizando la ventana de PowerShell que está abierta en el equipo local. Defina las siguientes variables adicionales:

    $domainName= "corp"
    $FQDN = "corp.contoso.com"
    $subnetName = "Back"
    $sqlServiceName = "<uniqueservicename>"
    $quorumServerName = "ContosoQuorum"
    $sql1ServerName = "ContosoSQL1"
    $sql2ServerName = "ContosoSQL2"
    $availabilitySetName = "SQLHADR"
    $dataDiskSize = 100
    $dnsSettings = New-AzureDns -Name "ContosoBackDNS" -IPAddress "10.10.0.4"
    

    La dirección IP 10.10.0.4 normalmente se asigna a la primera VM que se crea en la subred de 10.10.0.0/16 de la red virtual de Azure. Debe comprobar que esta es la dirección del servidor DC ejecutando IPCONFIG.

  2. Ejecute los siguientes comandos canalizados para crear la primera VM del clúster de WSFC, denominada ContosoQuorum:

    New-AzureVMConfig `
        -Name $quorumServerName `
        -InstanceSize Medium `
        -ImageName $winImageName `
        -MediaLocation "$storageAccountContainer$quorumServerName.vhd" `
        -AvailabilitySetName $availabilitySetName `
        -DiskLabel "OS" | 
        Add-AzureProvisioningConfig `
            -WindowsDomain `
            -AdminUserName $vmAdminUser `
            -Password $vmAdminPassword `
            -DisableAutomaticUpdates `
            -Domain $domainName `
            -JoinDomain $FQDN `
            -DomainUserName $vmAdminUser `
            -DomainPassword $vmAdminPassword |
            Set-AzureSubnet `
                -SubnetNames $subnetName |
                New-AzureVM `
                    -ServiceName $sqlServiceName `
                    –AffinityGroup $affinityGroupName `
                    -VNetName $virtualNetworkName `
                    -DnsSettings $dnsSettings
    

    Tenga en cuenta lo siguiente con respecto al comando anterior:

    • New-AzureVMConfig crea una configuración de VM con el nombre de conjunto de disponibilidad deseado. Las VM siguientes se crean con el mismo nombre de conjunto de disponibilidad determinado para combinarlos en el mismo conjunto de disponibilidad.

    • Add-AzureProvisioningConfig une la VM al dominio de Active Directory local que creó.

    • Set-AzureSubnet coloca la VM en la subred back-end.

    • New-AzureVM crea un nuevo servicio en la nube y una nueva VM de Windows en el nuevo servicio en la nube. El parámetro DnsSettings especifica que el servidor DNS para los servidores del nuevo servicio en la nube tiene la dirección IP 10.10.0.4, que es la dirección IP del servidor DC. Este parámetro es necesario para que las nuevas VM en el servicio en la nube se unan al dominio de Active Directory correctamente. Sin este parámetro, debe establecer manualmente los valores IPv4 en la VM para que utilice el servidor DC como servidor DNS principal después de aprovisionar la VM y, a continuación, unir la VM al dominio de Active Directory.

  3. Ejecute los comandos canalizados siguientes para crear las VM de SQL Server VM, denominadas ContosoSQL1 y ContosoSQL2.

    # Create ContosoSQL1...
    New-AzureVMConfig `
        -Name $sql1ServerName `
        -InstanceSize Large `
        -ImageName $sqlImageName `
        -MediaLocation "$storageAccountContainer$sql1ServerName.vhd" `
        -AvailabilitySetName $availabilitySetName `
        -HostCaching "ReadOnly" `
        -DiskLabel "OS" | 
        Add-AzureProvisioningConfig `
            -WindowsDomain `
            -AdminUserName $vmAdminUser `
            -Password $vmAdminPassword `
            -DisableAutomaticUpdates `
            -Domain $domainName `
            -JoinDomain $FQDN `
            -DomainUserName $vmAdminUser `
            -DomainPassword $vmAdminPassword |
            Set-AzureSubnet `
                -SubnetNames $subnetName |
                Add-AzureEndpoint `
                    -Name "SQL" `
                    -Protocol "tcp" `
                    -PublicPort 1 `
                    -LocalPort 1433 | 
                    New-AzureVM `
                        -ServiceName $sqlServiceName
    
    # Create ContosoSQL2...
    New-AzureVMConfig `
        -Name $sql2ServerName `
        -InstanceSize Large `
        -ImageName $sqlImageName `
        -MediaLocation "$storageAccountContainer$sql2ServerName.vhd" `
        -AvailabilitySetName $availabilitySetName `
        -HostCaching "ReadOnly" `
        -DiskLabel "OS" | 
        Add-AzureProvisioningConfig `
            -WindowsDomain `
            -AdminUserName $vmAdminUser `
            -Password $vmAdminPassword `
            -DisableAutomaticUpdates `
            -Domain $domainName `
            -JoinDomain $FQDN `
            -DomainUserName $vmAdminUser `
            -DomainPassword $vmAdminPassword |
            Set-AzureSubnet `
                -SubnetNames $subnetName |
                Add-AzureEndpoint `
                    -Name "SQL" `
                    -Protocol "tcp" `
                    -PublicPort 2 `
                    -LocalPort 1433 | 
                    New-AzureVM `
                        -ServiceName $sqlServiceName
    

    Tenga en cuenta lo siguiente con respecto a los comandos anteriores:

    • New-AzureVMConfig usa el mismo nombre de conjunto de disponibilidad que el servidor DC y usa la imagen de SQL Server 2012 Service Pack 1 Enterprise Edition en la galería de máquinas virtuales. 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, lo mejor es quitar el servicio Caching de escritura en el disco del sistema operativo, ya que no puede quitar el servicio Caching de lectura en el disco del sistema operativo.

    • Add-AzureProvisioningConfig une la VM al dominio de Active Directory local que creó.

    • Set-AzureSubnet coloca la VM en la subred back-end.

    • Add-AzureEndpoint agrega los extremos de acceso de modo que las aplicaciones cliente puedan tener acceso a estas instancias de servicio de SQL Server en Internet. Se proporcionan puertos diferentes a ContosoSQL1 y a ContosoSQL2.

    • New-AzureVM crea la nueva VM de SQL Server en el mismo servicio en la nube que ContosoQuorum. Debe poner las VM en el mismo servicio en la nube si desea que estén en el mismo conjunto de disponibilidad.

  4. Espere a que cada VM esté completamente aprovisionada y descargue su archivo de escritorio remoto en el directorio de trabajo. El bucle for recorre las tres nuevas VM y ejecuta los comandos dentro de los paréntesis de nivel superior para cada uno de ellos.

    Foreach ($VM in $VMs = Get-AzureVM -ServiceName $sqlServiceName)
    {
        write-host "Waiting for " $VM.Name "..."
    
        # Loop until the VM status is "ReadyRole"
        While ($VM.InstanceStatus -ne "ReadyRole")
        {
            write-host "  Current Status = " $VM.InstanceStatus
            Start-Sleep -Seconds 15
            $VM = Get-AzureVM -ServiceName $VM.ServiceName -Name $VM.InstanceName
        }
    
        write-host "  Current Status = " $VM.InstanceStatus
    
        # Download remote desktop file
        Get-AzureRemoteDesktopFile -ServiceName $VM.ServiceName -Name $VM.InstanceName -LocalPath "$workingDir$($VM.InstanceName).rdp"
    }
    

Las VM de SQL Server están aprovisionadas y en ejecución, pero se instalan con SQL Server con opciones predeterminadas.

En esta sección, debe modificar los tres servidores que utilizará en el clúster de WSFC y la instalación de SQL Server. Concretamente:

  • (Todos los servidores) Necesita instalar la característica Failover Clustering.

  • (Todos los servidores) Necesita agregar CORP\Install como administrador del equipo.

  • (ContosoSQL1 y ContosoSQL2 únicamente) Tiene que agregar CORP\Install como un rol de sysadmin en la base de datos predeterminada.

  • (ContosoSQL1 y ContosoSQL2 solamente) Necesita agregar NT AUTHORITY\System como inicio de sesión con los permisos siguientes:

    • Modificar cualquier grupo de disponibilidad

    • Conectar SQL

    • Ver estado del servidor

  • (ContosoSQL1 y ContosoSQL2 únicamente) El protocolo TCP ya está habilitado en el VM de SQL Server. Sin embargo, todavía necesita abrir el firewall para el acceso remoto de SQL Server.

Ahora ya puede iniciar. A partir de ContosoQuorum, siga los pasos siguientes:

  1. Conéctese a ContosoQuorum 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. Instale la característica de Windows Clúster de conmutación por error.

    Import-Module ServerManager
    Add-WindowsFeature Failover-Clustering 
    
  6. Agregue CORP\Install como administrador local.

    net localgroup administrators "CORP\Install" /Add
    
  7. Cierre sesión en ContosoQuorum. Ya ha terminado con este servidor.

    logoff.exe 
    

A continuación, inicialice ContosoSQL1 y ContosoSQL2. Siga los pasos siguientes, que son idénticos para ambos VM de SQL Server.

  1. Conéctese a las dos VM de SQL Server 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. Instale la característica de Windows Clúster de conmutación por error.

    Import-Module ServerManager
    Add-WindowsFeature Failover-Clustering 
    
  6. Agregue CORP\Install como administrador local.

    net localgroup administrators "CORP\Install" /Add
    
  7. Importe el proveedor de PowerShell de SQL Server.

    Set-ExecutionPolicy -Execution RemoteSigned -Force
    Import-Module -Name "sqlps" -DisableNameChecking
    
  8. Agregue CORP\Install como el rol sysadmin para la instancia de SQL Server predeterminada.

    net localgroup administrators "CORP\Install" /Add
    Invoke-SqlCmd -Query "EXEC sp_addsrvrolemember 'CORP\Install', 'sysadmin'" -ServerInstance "."
    
  9. Agregue NT AUTHORITY\System como inicio de sesión con los tres permisos descritos anteriormente.

    Invoke-SqlCmd -Query "CREATE LOGIN [NT AUTHORITY\SYSTEM] FROM WINDOWS" -ServerInstance "."
    Invoke-SqlCmd -Query "GRANT ALTER ANY AVAILABILITY GROUP TO [NT AUTHORITY\SYSTEM] AS SA" -ServerInstance "." 
    Invoke-SqlCmd -Query "GRANT CONNECT SQL TO [NT AUTHORITY\SYSTEM] AS SA" -ServerInstance "."
    Invoke-SqlCmd -Query "GRANT VIEW SERVER STATE TO [NT AUTHORITY\SYSTEM] AS SA" -ServerInstance "."
    
  10. 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
    
  11. Cierre sesión en ambas VM.

    logoff.exe
    

Finalmente, está en disposición de configurar el grupo de disponibilidad. Utilizará el proveedor de PowerShell de SQL Server para realizar todo el trabajo en ContosoSQL1.

  1. Conéctese a ContosoSQL1 de nuevo iniciando los archivos de escritorio remoto. En lugar de registrarse mediante la cuenta de equipo, inicie sesión con CORP\Install.

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

  3. Defina las variables siguientes:

    $server1 = "ContosoSQL1"
    $server2 = "ContosoSQL2"
    $serverQuorum = "ContosoQuorum"
    $acct1 = "CORP\SQLSvc1"
    $acct2 = "CORP\SQLSvc2"
    $password = "Contoso!000"
    $clusterName = "Cluster1"
    $timeout = New-Object System.TimeSpan -ArgumentList 0, 0, 30
    $db = "MyDB1"
    $backupShare = "\\$server1\backup"
    $quorumShare = "\\$server1\quorum"
    $ag = "AG1" 
    
  4. Importe el proveedor PowerShell de SQL Server.

    Set-ExecutionPolicy RemoteSigned -Force
    Import-Module "sqlps" -DisableNameChecking
    
  5. Cambie la cuenta de servicio de SQL Server para ContosoSQL1 a CORP\SQLSvc1.

    $wmi1 = new-object ("Microsoft.SqlServer.Management.Smo.Wmi.ManagedComputer") $server1
    $wmi1.services | where {$_.Type -eq 'SqlServer'} | foreach{$_.SetServiceAccount($acct1,$password)}
    $svc1 = Get-Service -ComputerName $server1 -Name 'MSSQLSERVER'
    $svc1.Stop()
    $svc1.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Stopped,$timeout)
    $svc1.Start(); 
    $svc1.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Running,$timeout)
    
  6. Cambie la cuenta de servicio de SQL Server para ContosoSQL2 a CORP\SQLSvc2.

    $wmi2 = new-object ("Microsoft.SqlServer.Management.Smo.Wmi.ManagedComputer") $server2
    $wmi2.services | where {$_.Type -eq 'SqlServer'} | foreach{$_.SetServiceAccount($acct2,$password)}
    $svc2 = Get-Service -ComputerName $server2 -Name 'MSSQLSERVER'
    $svc2.Stop()
    $svc2.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Stopped,$timeout)
    $svc2.Start(); 
    $svc2.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Running,$timeout)
    
  7. Descargue CreateAzureFailoverCluster.ps1 desde Crear el clúster WSFC para grupos de disponibilidad AlwaysOn en la VM de Azure al directorio de trabajo local. Utilizará este script para ayudarle a crear un clúster funcional de WSFC. Para obtener información importante sobre cómo WSFC interactúa con la red de Azure, vea Alta disponibilidad y recuperación ante desastres para SQL Server en máquinas virtuales de Azure.

  8. Cambie al directorio de trabajo y cree el clúster WSFC con el script descargado.

    Set-ExecutionPolicy Unrestricted -Force
    .\CreateAzureFailoverCluster.ps1 -ClusterName "$clusterName" -ClusterNode "$server1","$server2","$serverQuorum"
    
  9. Habilite los grupos de disponibilidad AlwaysOn para las instancias de SQL Server predeterminadas en ContosoSQL1 y ContosoSQL2.

    Enable-SqlAlwaysOn `
        -Path SQLSERVER:\SQL\$server1\Default `
        -Force
    Enable-SqlAlwaysOn `
        -Path SQLSERVER:\SQL\$server2\Default `
        -NoServiceRestart
    $svc2.Stop()
    $svc2.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Stopped,$timeout)
    $svc2.Start(); 
    $svc2.WaitForStatus([System.ServiceProcess.ServiceControllerStatus]::Running,$timeout)
    
  10. Cree un directorio de copia de seguridad y conceda permisos a las cuentas de servicio de SQL Server. Utilizará este directorio para preparar la base de datos de disponibilidad en la replicación secundaria.

    $backup = "C:\backup"
    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") 
    
  11. Cree una base de datos en ContosoSQL1 denominada MyDB1, realice tanto una copia de seguridad completa como una copia de seguridad de registros y restáurelas en ContosoSQL2 con la opción WITH NORECOVERY.

    Invoke-SqlCmd -Query "CREATE database $db"
    Backup-SqlDatabase -Database $db -BackupFile "$backupShare\db.bak" -ServerInstance $server1
    Backup-SqlDatabase -Database $db -BackupFile "$backupShare\db.log" -ServerInstance $server1 -BackupAction Log
    Restore-SqlDatabase -Database $db -BackupFile "$backupShare\db.bak" -ServerInstance $server2 -NoRecovery
    Restore-SqlDatabase -Database $db -BackupFile "$backupShare\db.log" -ServerInstance $server2 -RestoreAction Log -NoRecovery 
    
  12. Cree los extremos del grupo de disponibilidad en las VM de SQL Server y establezca los permisos apropiados en los extremos.

    $endpoint = 
        New-SqlHadrEndpoint MyMirroringEndpoint `
        -Port 5022 `
        -Path "SQLSERVER:\SQL\$server1\Default"
    Set-SqlHadrEndpoint `
        -InputObject $endpoint `
        -State "Started"
    $endpoint = 
        New-SqlHadrEndpoint MyMirroringEndpoint `
        -Port 5022 `
        -Path "SQLSERVER:\SQL\$server2\Default"
    Set-SqlHadrEndpoint `
        -InputObject $endpoint `
        -State "Started"
    
    Invoke-SqlCmd -Query "CREATE LOGIN [$acct2] FROM WINDOWS" -ServerInstance $server1
    Invoke-SqlCmd -Query "GRANT CONNECT ON ENDPOINT::[MyMirroringEndpoint] TO [$acct2]" -ServerInstance $server1
    Invoke-SqlCmd -Query "CREATE LOGIN [$acct1] FROM WINDOWS" -ServerInstance $server2
    Invoke-SqlCmd -Query "GRANT CONNECT ON ENDPOINT::[MyMirroringEndpoint] TO [$acct1]" -ServerInstance $server2 
    
  13. Cree las réplicas de disponibilidad.

    $primaryReplica = 
        New-SqlAvailabilityReplica `
        -Name $server1 `
        -EndpointURL "TCP://$server1.corp.contoso.com:5022" `
        -AvailabilityMode "SynchronousCommit" `
        -FailoverMode "Automatic" `
        -Version 11 `
        -AsTemplate
    $secondaryReplica = 
        New-SqlAvailabilityReplica `
        -Name $server2 `
        -EndpointURL "TCP://$server2.corp.contoso.com:5022" `
        -AvailabilityMode "SynchronousCommit" `
        -FailoverMode "Automatic" `
        -Version 11 `
        -AsTemplate 
    
  14. Finalmente, cree el grupo de disponibilidad y una las réplicas secundarias al mismo.

    New-SqlAvailabilityGroup `
        -Name $ag `
        -Path "SQLSERVER:\SQL\$server1\Default" `
        -AvailabilityReplica @($primaryReplica,$secondaryReplica) `
        -Database $db
    Join-SqlAvailabilityGroup `
        -Path "SQLSERVER:\SQL\$server2\Default" `
        -Name $ag
    Add-SqlAvailabilityDatabase `
        -Path "SQLSERVER:\SQL\$server2\Default\AvailabilityGroups\$ag" `
        -Database $db
    

Ha implementado correctamente SQL Server AlwaysOn creando un grupo de disponibilidad de Azure. Para configurar un agente de escucha del grupo de disponibilidad, vea Tutorial: Listener Configuration for AlwaysOn Availability Groups in Azure.

Mostrar:
© 2014 Microsoft