Compartir a través de

Configuración del grupo de disponibilidad AlwaysOn en una máquina virtual de Azure con PowerShell

  • Artículo

Antes de empezar, tenga en cuenta que ahora puede completar esta tarea en el modelo de Azure Resource Manager. Se recomienda el modelo de Azure Resource Manager para nuevas implementaciones. Consulte Grupos de disponibilidad AlwaysOn de SQL Server en máquinas virtuales de Azure.

Importante

Se recomienda que la mayoría de las implementaciones nuevas usen el modelo de Resource Manager. Azure tiene dos modelos de implementación diferentes para crear recursos y trabajar con ellos: Resource Manager y el clásico. Este artículo trata del modelo de implementación clásico.

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

  • Una red virtual que contiene varias subredes, incluido un front-end y una subred de back-end.
  • Un controlador de dominio con un dominio de Active Directory.
  • Dos máquinas virtuales de SQL Server que se implementan en la subred back-end y se unen al dominio de Active Directory.
  • Un clúster de conmutación por error de Windows de tres nodos con el modelo de quórum Mayoría de Nodos.
  • Un grupo de disponibilidad con dos réplicas de confirmación sincrónica de una base de datos de disponibilidad.

Este escenario es una buena opción para su simplicidad en Azure, no para su rentabilidad u otros factores. Por ejemplo, puede minimizar el número de máquinas virtuales en un grupo de disponibilidad de dos réplicas para ahorrar en horas de proceso en Azure, utilizando el controlador de dominio como testigo del recurso compartido de archivos de quórum en un clúster de conmutación por error de dos nodos. Este método reduce el recuento de máquinas virtuales por uno de la configuración anterior.

Este tutorial está pensado para mostrar los pasos necesarios para configurar la solución descrita anteriormente, sin elaborar los detalles de cada paso. Por lo tanto, en lugar de proporcionar los pasos de configuración de la GUI, utiliza scripting de PowerShell para guiarlo rápidamente a través de cada paso. En este tutorial se da por hecho lo siguiente:

Conexión a la suscripción de Azure y creación de la red virtual

  1. En una ventana de PowerShell en el equipo local, importe el módulo de Azure, descargue el archivo de configuración de publicación en la máquina y conecte la sesión de PowerShell a su suscripción de Azure mediante la importación de 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-AzurePublishSettingsFile genera automáticamente un certificado de administración con Azure y lo descarga en la máquina. Se abre automáticamente un explorador y se le pedirá que escriba las credenciales de la cuenta Microsoft para la suscripción de Azure. El archivo .publishsettings descargado contiene toda la información que necesita para administrar la suscripción de Azure. Después de guardar este archivo en un directorio local, impórtelo mediante el comando Import-AzurePublishSettingsFile .

    Nota:

    El archivo .publishsettings contiene las credenciales (sin codificar) que se usan para administrar las suscripciones y servicios de Azure. El procedimiento recomendado de seguridad para este archivo es almacenarlo temporalmente fuera de los directorios de origen (por ejemplo, en la carpeta Bibliotecas\Documentos) y, a continuación, eliminarlo una vez finalizada la importación. Un usuario malintencionado que obtenga acceso al archivo .publishsettings puede editar, crear y eliminar los 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 realizarán correctamente más adelante:

    • 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 que especifique para las variables $affinityGroupName y $virtualNetworkName se configuran en el documento de configuración de red virtual que usará más adelante.
    • $sqlImageName especifica el nombre actualizado de la imagen de máquina virtual que contiene SQL Server 2012 Service Pack 1 Enterprise Edition.
    • Para simplificar, Contoso!000 es la misma contraseña que se usa en todo 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. Tiene el espacio de direcciones 10.10.0.0/16 y tiene dos subredes, 10.10.1.0/24 y 10.10.2.0/24, que son la subred frontal y la subred back, respectivamente. La subred frontal es donde puede colocar aplicaciones cliente como Microsoft SharePoint. La subred de back-end es donde se colocarán las máquinas virtuales de SQL Server. Si anteriormente ha cambiado las variables $affinityGroupName y $virtualNetworkName, también debe cambiar los nombres correspondientes más abajo.

    <NetworkConfiguration xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="https://www.w3.org/2001/XMLSchema" xmlns="https://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>
```xml

  5. Cree una cuenta de almacenamiento asociada al grupo de afinidad que creó y establézcala como la cuenta de almacenamiento actual de la suscripción.

    New-AzureStorageAccount `
    -StorageAccountName $storageAccountName `
    -Label $storageAccountLabel `
    -AffinityGroup $affinityGroupName
Set-AzureSubscription `
    -SubscriptionName (Get-AzureSubscription).SubscriptionName `
    -CurrentStorageAccount $storageAccountName

  6. Cree el servidor controlador de dominio en el nuevo servicio en la nube y el 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

    Estos comandos canalizados hacen lo siguiente:

    • New-AzureVMConfig crea una configuración de máquina virtual.
    • Add-AzureProvisioningConfig proporciona los parámetros de configuración de un servidor windows independiente.
    • Add-AzureDataDisk agrega el disco de datos que usará para almacenar datos de Active Directory, con la opción de almacenamiento en caché establecida en Ninguno.
    • New-AzureVM crea un nuevo servicio en la nube y crea la nueva máquina virtual de Azure en el nuevo servicio en la nube.

  7. Espere a que se aprovisione completamente la nueva máquina virtual y descargue el archivo de Escritorio remoto en el directorio de trabajo. Dado que la nueva máquina virtual de Azure tarda mucho tiempo en aprovisionarse, el while bucle continúa sondeando la nueva máquina virtual hasta que esté lista para su uso.

    $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 del controlador de dominio ahora está aprovisionado correctamente. A continuación, configurará el dominio de Active Directory en este servidor de controlador de dominio. Deje abierta la ventana de PowerShell en el equipo local. Lo usará de nuevo más tarde para crear las dos máquinas virtuales de SQL Server.

Configuración del controlador de dominio

  1. Conéctese al servidor del controlador de dominio iniciando el archivo de escritorio remoto. Use el nombre de usuario del administrador de la máquina AzureAdmin y la contraseña Contoso!000, que especificó al crear la nueva máquina virtual.

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

  3. Ejecute el siguiente comando DCPROMO.EXE para configurar el dominio de 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 finalizado el comando, la máquina virtual se reinicia automáticamente.

  4. Vuelva a conectarse al servidor del controlador de dominio iniciando el archivo de Escritorio remoto. Esta vez, inicie sesión como CORP\Administrator.

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

    Import-Module ActiveDirectory

  6. Ejecute los siguientes comandos 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 usa para configurar todo lo relacionado con las instancias de servicio de SQL Server, el clúster de conmutación por error y el grupo de disponibilidad. CORP\SQLSvc1 y CORP\SQLSvc2 se usan como cuentas de servicio de SQL Server para las dos máquinas virtuales de SQL Server.

  7. A continuación, ejecute los siguientes comandos para conceder 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 de equipo. La cuenta CORP\Install necesita el permiso Leer todas las propiedades y crear objetos de equipo para crear los objetos Active Direct para el clúster de conmutación por error. El permiso Leer todas las propiedades ya se concede a CORP\Install de forma predeterminada, por lo que no es necesario concederlo explícitamente. Para obtener más información sobre los permisos necesarios para crear el clúster de conmutación por error, consulte Guía paso a paso del clúster de conmutación por error: Configuración de cuentas en Active Directory.

    Ahora que ha terminado de configurar Active Directory y los objetos de usuario, creará dos máquinas virtuales con SQL Server y las unirá a este dominio.

Creación de las máquinas virtuales de SQL Server

  1. Siga usando 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 máquina virtual que se crea en la subred 10.10.0.0/16 de la red virtual de Azure. Debe comprobar que esta es la dirección del servidor del controlador de dominio ejecutando IPCONFIG.

  2. Ejecute los siguientes comandos pipeados para crear la primera máquina virtual en el clúster de conmutación por error, 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 máquina virtual con el nombre del conjunto de disponibilidad deseado. Las máquinas virtuales posteriores se crearán con el mismo nombre del conjunto de disponibilidad para que se unan al mismo conjunto de disponibilidad.
    • Add-AzureProvisioningConfig une la máquina virtual al dominio de Active Directory que creó.
    • Set-AzureSubnet coloca la máquina virtual en la subred de respaldo.
    • New-AzureVM crea un nuevo servicio en la nube y crea la nueva máquina virtual de Azure 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. Esta es la dirección IP del servidor del controlador de dominio. Este parámetro es necesario para permitir que las nuevas máquinas virtuales del servicio en la nube se unan correctamente al dominio de Active Directory. Sin este parámetro, debe establecer manualmente la configuración de IPv4 en la máquina virtual para usar el servidor de controlador de dominio como servidor DNS principal después de aprovisionar la máquina virtual y, a continuación, unir la máquina virtual al dominio de Active Directory.

  3. Ejecute los siguientes comandos canalados para crear las máquinas virtuales de SQL Server, 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 del conjunto de disponibilidad que el servidor de controlador de dominio 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 a solo caché de lectura (sin caché de escritura). Se recomienda migrar los archivos de base de datos a un disco de datos independiente que se conecte a la máquina virtual y configurarlo sin almacenamiento en caché de lectura o escritura. Sin embargo, la mejor alternativa es quitar el almacenamiento en caché de escritura en el disco del sistema operativo ya que no se puede quitar el almacenamiento en caché de lectura en el disco del sistema operativo.
    • Add-AzureProvisioningConfig une la máquina virtual al dominio de Active Directory que creó.
    • Set-AzureSubnet coloca la máquina virtual en la subred trasera.
    • Add-AzureEndpoint agrega puntos de conexión de acceso para que las aplicaciones cliente puedan acceder a estas instancias de servicios de SQL Server en Internet. Se proporcionan puertos diferentes a ContosoSQL1 y ContosoSQL2.
    • New-AzureVM crea la nueva máquina virtual con SQL Server en el mismo servicio en la nube que ContosoQuorum. Debe colocar las máquinas virtuales en el mismo servicio en la nube si quiere que estén en el mismo conjunto de disponibilidad.

  4. Espere a que cada máquina virtual esté completamente aprovisionada y a que cada una descargue su archivo de escritorio remoto en su directorio de trabajo. El for bucle recorre las tres máquinas virtuales nuevas y ejecuta los comandos dentro de los corchetes de nivel superior para cada una de ellas.

    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 máquinas virtuales de SQL Server ahora se aprovisionan y ejecutan, pero se instalan con SQL Server con opciones predeterminadas.

Inicializa las máquinas virtuales del clúster de conmutación por error

En esta sección, debe modificar los tres servidores que usará en el clúster de conmutación por error y la instalación de SQL Server. Específicamente:

  • Todos los servidores: necesita instalar la característica Clúster de conmutación por error.

  • Todos los servidores: debe agregar CORP\Install como administrador de la máquina.

  • Solo ContosoSQL1 y ContosoSQL2: debe agregar CORP\Install como rol sysadmin en la base de datos predeterminada.

  • Solo ContosoSQL1 y ContosoSQL2: Necesita agregar NT AUTHORITY\System como usuario con los siguientes permisos:

    • Modificación de cualquier grupo de disponibilidad
    • Conectar a SQL
    • Ver estado del servidor

  • Solo ContosoSQL1 y ContosoSQL2: el protocolo TCP ya está habilitado en la máquina virtual con SQL Server. Sin embargo, todavía debe abrir el firewall para el acceso remoto de SQL Server.

Ya está listo para empezar. A partir de ContosoQuorum, siga estos pasos:

  1. Conéctese a ContosoQuorum iniciando los archivos de Escritorio remoto. Use el nombre de usuario del administrador de la máquina AzureAdmin y la contraseña Contoso!000, que especificó al crear las máquinas virtuales.

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

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

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

  5. Instale la característica de Clúster de conmutación por error de Windows.

    Import-Module ServerManager
Add-WindowsFeature Failover-Clustering

  6. Agregue CORP\Install como administrador local.

    net localgroup administrators "CORP\Install" /Add

  7. Cerrar 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 ambas máquinas virtuales con SQL Server.

  1. Conéctese a las dos máquinas virtuales de SQL Server iniciando los archivos de escritorio remoto. Use el nombre de usuario del administrador de la máquina AzureAdmin y la contraseña Contoso!000, que especificó al crear las máquinas virtuales.

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

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

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

  5. Instale la función Clusters de conmutación por error de Windows.

    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 SQL Server PowerShell.

    Set-ExecutionPolicy -Execution RemoteSigned -Force
Import-Module -Name "sqlps" -DisableNameChecking

  8. Agregue CORP\Install como rol sysadmin para la instancia predeterminada de SQL Server.

    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 la sesión de ambas máquinas virtuales.

     logoff.exe

Por último, está listo para configurar el grupo de disponibilidad. Usará el proveedor de SQL Server PowerShell para realizar todo el trabajo en ContosoSQL1.

Configuración del grupo de disponibilidad

  1. Vuelva a conectarse a ContosoSQL1 iniciando los archivos de Escritorio remoto. En lugar de iniciar sesión con la cuenta del equipo, inicie sesión con CORP\Install.

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

  3. Defina las siguientes variables:

    $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 de SQL Server PowerShell.

    Set-ExecutionPolicy RemoteSigned -Force
Import-Module "sqlps" -DisableNameChecking

  5. Cambie la cuenta de servicio de SQL Server de 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 de 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 de Crear un clúster de conmutación por error para Always On Availability Groups en la máquina virtual de Azure en el directorio de trabajo local. Utilizarás este script para ayudarte a crear un clúster de conmutación por error funcional. Para obtener información importante sobre cómo interactúan los clústeres de conmutación por error de Windows con la red de Azure, consulte Alta disponibilidad y recuperación ante desastres para SQL Server en Azure Virtual Machines.

  8. Cambie a su directorio de trabajo y cree el clúster de conmutación por error 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 predeterminadas de SQL Server 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 para las cuentas de servicio de SQL Server. Usará este directorio para preparar la base de datos de disponibilidad en la réplica 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 una copia de seguridad completa y una copia de seguridad de registros y restáurela 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 puntos de conexión del grupo de disponibilidad en las máquinas virtuales de SQL Server y establezca los permisos adecuados en los puntos de conexión.

    $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. Por último, cree el grupo de disponibilidad y una la réplica secundaria al grupo de disponibilidad.

    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

Pasos siguientes

Ahora ha implementado correctamente SQL Server AlwaysOn mediante la creación de un grupo de disponibilidad en Azure. Para configurar un agente de escucha para este grupo de disponibilidad, consulte Configuración de un agente de escucha de ILB para grupos de disponibilidad AlwaysOn en Azure.

Para obtener otra información sobre el uso de SQL Server en Azure, consulte SQL Server en máquinas virtuales de Azure.