Compartilhar via

Configurar o grupo de disponibilidade AlwaysOn em uma VM do Azure com o PowerShell

  • Artigo

Antes de começar, considere que agora você pode concluir essa tarefa no modelo do Azure Resource Manager. Recomendamos o modelo do Azure Resource Manager para novas implantações. Consulte grupos de disponibilidade Always On do SQL Server em máquinas virtuais do Azure.

Importante

Recomendamos que a maioria das novas implantações use o modelo do Resource Manager. O Azure tem dois modelos de implantação diferentes para criar e trabalhar com recursos: Resource Manager e clássico. Este artigo aborda o uso do modelo de implantação clássica.

As VMs (máquinas virtuais) do Azure podem ajudar os administradores de banco de dados a reduzir o custo de um sistema SQL Server de alta disponibilidade. Este tutorial mostra como implementar um grupo de disponibilidade usando o SQL Server Always On de ponta a ponta dentro de um ambiente do Azure. No final do tutorial, sua solução Always On do SQL Server no Azure consistirá nos seguintes elementos:

  • Uma rede virtual que contém várias sub-redes, incluindo um front-end e uma sub-rede de back-end.
  • Um controlador de domínio com um domínio do Active Directory.
  • Duas VMs do SQL Server implantadas na sub-rede de back-end e ingressadas no domínio do Active Directory.
  • Um cluster de failover do Windows de três nós com o modelo de quorum de maioria de nós.
  • Um grupo de disponibilidade com duas réplicas de confirmação síncrona de um banco de dados de disponibilidade.

Esse cenário é uma boa opção para sua simplicidade no Azure, não por seu custo-benefício ou outros fatores. Por exemplo, você pode minimizar o número de VMs em um grupo de disponibilidade com duas réplicas para economizar em horas de computação no Azure, usando o controlador de domínio como testemunha de compartilhamento de arquivo de quórum em um cluster de failover de dois nós. Esse método reduz em um o número de máquinas virtuais da configuração acima.

Este tutorial destina-se a mostrar as etapas necessárias para configurar a solução descrita acima, sem elaborar os detalhes de cada etapa. Portanto, em vez de fornecer as etapas de configuração de GUI, ele usa o script do PowerShell para levá-lo rapidamente em cada etapa. Este tutorial pressupõe o seguinte:

  • Você já tem uma conta do Azure com a assinatura da máquina virtual.
  • Você instalou os cmdlets do Azure PowerShell .
  • Você já tem uma compreensão sólida dos grupos de disponibilidade Always On para soluções locais. Para obter mais informações, consulte grupos de disponibilidade Always On (SQL Server).

Conecte-se à sua assinatura do Azure e crie a rede virtual

  1. Em uma janela do PowerShell em seu computador local, importe o módulo do Azure, baixe o arquivo de configurações de publicação para seu computador e conecte sua sessão do PowerShell à sua assinatura do Azure importando as configurações de publicação baixadas.

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

    O comando Get-AzurePublishSettingsFile gera automaticamente um certificado de gerenciamento com o Azure e o baixa em seu computador. Um navegador é aberto automaticamente e você é solicitado a inserir as credenciais de conta da Microsoft para sua assinatura do Azure. O arquivo .publishsettings baixado contém todas as informações necessárias para gerenciar sua assinatura do Azure. Depois de salvar esse arquivo em um diretório local, importe-o usando o comando Import-AzurePublishSettingsFile.

    Observação

    O arquivo .publishsettings contém suas credenciais (não codificadas) que são usadas para administrar suas assinaturas e serviços do Azure. A melhor prática de segurança para esse arquivo é armazená-lo temporariamente fora dos diretórios de origem (por exemplo, na pasta Bibliotecas\Documentos) e excluí-lo após a conclusão da importação. Um usuário mal-intencionado que obtém acesso ao arquivo .publishsettings pode editar, criar e excluir seus serviços do Azure.

  2. Defina uma série de variáveis que você usará para criar sua infraestrutura de TI na nuvem.

    $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 atenção ao seguinte para garantir que seus comandos sejam bem-sucedidos mais tarde:

    • As variáveis $storageAccountName e $dcServiceName devem ser exclusivas porque são usadas para identificar sua conta de armazenamento em nuvem e o servidor de nuvem, respectivamente, na Internet.
    • Os nomes que você especificar para variáveis $affinityGroupName e $virtualNetworkName são configurados no documento de configuração de rede virtual que você usará posteriormente.
    • $sqlImageName especifica o nome atualizado da imagem da VM que contém o SQL Server 2012 Service Pack 1 Enterprise Edition.
    • Para simplificar, Contoso!000 é a mesma senha usada em todo o tutorial.

  3. Crie um grupo de afinidades.

    New-AzureAffinityGroup `
    -Name $affinityGroupName `
    -Location $location `
    -Description $affinityGroupDescription `
    -Label $affinityGroupLabel

  4. Crie uma rede virtual importando um arquivo de configuração.

    Set-AzureVNetConfig `
    -ConfigurationPath $networkConfigPath

    O arquivo de configuração contém o documento XML a seguir. Resumindo, ela especifica uma rede virtual chamada ContosoNET no grupo de afinidades chamado ContosoAG. Ele tem o espaço de endereço 10.10.0.0/16 e tem duas sub-redes, 10.10.1.0/24 e 10.10.2.0/24, que são a sub-rede frontal e a sub-rede traseira, respectivamente. A sub-rede frontal é onde você pode colocar aplicativos cliente, como o Microsoft SharePoint. A sub-rede traseira é onde você colocará as VMs do SQL Server. Se você alterar as variáveis $affinityGroupName e $virtualNetworkName anteriormente, também deverá alterar os nomes correspondentes abaixo.

    <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. Crie uma conta de armazenamento associada ao grupo de afinidade que você criou e defina-a como a conta de armazenamento atual em sua assinatura.

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

  6. Crie o servidor do controlador de domínio no novo serviço de nuvem e conjunto de disponibilidade.

    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

    Esses comandos fazem o seguinte:

    • New-AzureVMConfig cria uma configuração de VM.
    • Add-AzureProvisioningConfig fornece os parâmetros de configuração de um servidor Windows autônomo.
    • Add-AzureDataDisk adiciona o disco de dados que você usará para armazenar dados do Active Directory, com a opção de cache definida como None.
    • New-AzureVM cria um novo serviço de nuvem e cria a nova VM do Azure no novo serviço de nuvem.

  7. Aguarde até que a nova VM seja totalmente provisionada e baixe o arquivo de área de trabalho remota no diretório de trabalho. Como a nova VM do Azure leva muito tempo para ser provisionada, o loop while continua pesquisando a nova VM até que ela esteja pronta para 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"

O servidor do controlador de domínio agora é provisionado com êxito. Em seguida, você configurará o domínio do Active Directory neste servidor do controlador de domínio. Deixe a janela do PowerShell aberta no computador local. Você o usará novamente mais tarde para criar as duas VMs do SQL Server.

Configurar o controlador de domínio

  1. Conecte-se ao servidor do controlador de domínio iniciando o arquivo de desktop remoto. Use o nome de usuário do administrador do computador AzureAdmin e a senha Contoso!000, que você especificou ao criar a nova VM.

  2. Abra uma janela do PowerShell no modo de administrador.

  3. Execute o seguinte comando DCPROMO.EXE para configurar o domínio corp.contoso.com, com os diretórios de dados na unidade 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"

    Depois que o comando for concluído, a VM será reiniciada automaticamente.

  4. Conecte-se ao servidor do controlador de domínio novamente iniciando o arquivo de área de trabalho remota. Desta vez, entre como CORP\Administrator.

  5. Abra uma janela do PowerShell no modo de administrador e importe o módulo do PowerShell do Active Directory usando o seguinte comando:

    Import-Module ActiveDirectory

  6. Execute os comandos a seguir para adicionar três usuários ao domínio.

    $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 é usado para configurar tudo relacionado às instâncias de serviço do SQL Server, ao cluster de failover e ao grupo de disponibilidade. CORP\SQLSvc1 e CORP\SQLSvc2 são usados como contas de serviço do SQL Server para as duas VMs do SQL Server.

  7. Em seguida, execute os comandos a seguir para fornecer CORP\Install as permissões para criar objetos de computador no domínio.

    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

    O GUID especificado acima é o GUID para o tipo de objeto do computador. A conta CORP\Install precisa das permissões Ler Todas as Propriedades e Criar Objetos de Computador para criar os objetos Active Directory para o cluster de failover. A permissão Ler Todas as Propriedades já é fornecida a CORP\Install por padrão, portanto, você não precisa concedê-la explicitamente. Para obter mais informações sobre permissões necessárias para criar o cluster de failover, consulte Guia passo a passo do cluster de failover: configurando contas no Active Directory.

    Agora que você terminou de configurar o Active Directory e os objetos de usuário, criará duas VMs do SQL Server e as unirá a esse domínio.

Criar as VMs do SQL Server

  1. Continue a usar a janela do PowerShell que está aberta no computador local. Defina as seguintes variáveis adicionais:

    $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"

    O endereço IP 10.10.0.4 normalmente é atribuído à primeira VM que você cria no sub-rede 10.10.0.0/16 da rede virtual do Azure. Você deve verificar se esse é o endereço do servidor do controlador de domínio executando IPCONFIG.

  2. Execute os seguintes comandos em pipeline para criar a primeira VM no cluster de failover, denominado 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

    Observe o seguinte em relação ao comando acima:

    • New-AzureVMConfig cria uma configuração de VM com o nome do conjunto de disponibilidade desejado. As VMs subsequentes serão criadas com o mesmo nome do conjunto de disponibilidade para que sejam unidas ao mesmo conjunto de disponibilidade.
    • Add-AzureProvisioningConfig une a VM ao domínio do Active Directory que você criou.
    • Set-AzureSubnet coloca a VM na sub-rede traseira.
    • New-AzureVM cria um novo serviço de nuvem e cria a nova VM do Azure no novo serviço de nuvem. O parâmetro DnsSettings especifica que o servidor DNS para os servidores no novo serviço de nuvem tem o endereço IP 10.10.0.4. Esse é o endereço IP do servidor do controlador de domínio. Esse parâmetro é necessário para habilitar as novas VMs no serviço de nuvem a ingressar no domínio do Active Directory com êxito. Sem esse parâmetro, você deve definir manualmente as configurações IPv4 em sua VM para usar o servidor do controlador de domínio como o servidor DNS primário após o provisionamento da VM e, em seguida, ingressar a VM no domínio do Active Directory.

  3. Execute os seguintes comandos encanados para criar as VMs do SQL Server, chamadas ContosoSQL1 e 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

    Observe o seguinte em relação aos comandos acima:

    • New-AzureVMConfig usa o mesmo nome do conjunto de disponibilidade que o servidor do controlador de domínio e usa a imagem do SQL Server 2012 Service Pack 1 Enterprise Edition na galeria de máquinas virtuais. Ele também define o disco do sistema operacional como somente cache de leitura (sem cache de gravação). Recomendamos migrar os arquivos de banco de dados para um disco de dados separado anexado à VM e configurá-lo sem cache de leitura ou gravação. No entanto, a próxima melhor coisa é remover o cache de gravação no disco do sistema operacional porque você não pode remover o cache de leitura no disco do sistema operacional.
    • Add-AzureProvisioningConfig une a VM ao domínio do Active Directory que você criou.
    • Set-AzureSubnet coloca a VM na sub-rede traseira.
    • Add-AzureEndpoint adiciona endpoints de acesso para que os aplicativos cliente possam acessar essas instâncias dos serviços do SQL Server na Internet. Portas diferentes são fornecidas para ContosoSQL1 e ContosoSQL2.
    • New-AzureVM cria a nova VM do SQL Server no mesmo serviço de nuvem que ContosoQuorum. Você deve colocar as VMs no mesmo serviço de nuvem se quiser que elas estejam no mesmo conjunto de disponibilidade.

  4. Aguarde até que cada VM seja totalmente provisionada e que cada VM baixe seu arquivo de área de trabalho remota para o diretório de trabalho. O loop for percorre as três novas VMs e executa os comandos dentro dos colchetes de nível superior para cada uma delas.

    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"
}

    As VMs do SQL Server agora estão provisionadas e em execução, mas estão instaladas com o SQL Server com opções padrão.

Inicializar as VMs do cluster de failover

Nesta seção, você precisa modificar os três servidores que usará no cluster de failover e na instalação do SQL Server. Especificamente:

  • Todos os servidores: você precisa instalar o recurso Clusters de Failover.

  • Todos os servidores: você precisa adicionar CORP\Install como administrador da máquina .

  • Somente ContosoSQL1 e ContosoSQL2: você precisa adicionar CORP\Install como uma função sysadmin no banco de dados padrão.

  • Somente ContosoSQL1 e ContosoSQL2: você precisa adicionar NT AUTHORITY\System como uma entrada com as seguintes permissões:

    • Alterar qualquer grupo de disponibilidade
    • Conectar SQL
    • Exibir o estado do servidor

  • Somente ContosoSQL1 e ContosoSQL2: o protocolo TCP já está habilitado na VM do SQL Server. No entanto, você ainda precisa abrir o firewall para acesso remoto do SQL Server.

Agora, você está pronto para começar. Começando com ContosoQuorum, siga as etapas abaixo:

  1. Conecte-se ao ContosoQuorum iniciando os arquivos de área de trabalho remota. Use o nome de usuário do administrador do computador do AzureAdmin e senha Contoso!000, que você especificou ao criar as VMs.

  2. Verifique se os computadores foram adicionados com êxito no corp.contoso.com.

  3. Aguarde até que a instalação do SQL Server conclua a execução das tarefas de inicialização automatizadas antes de continuar.

  4. Abra uma janela do PowerShell no modo de administrador.

  5. Instale a função de cluster de failover do Windows.

    Import-Module ServerManager
Add-WindowsFeature Failover-Clustering

  6. Adicione CORP\Install como administrador local.

    net localgroup administrators "CORP\Install" /Add

  7. Saia da ContosoQuorum. Você terminou agora com esse servidor.

    logoff.exe

Em seguida, inicialize contosoSQL1 e contosoSQL2. Siga as etapas abaixo, que são idênticas para ambas as VMs do SQL Server.

  1. Conecte-se às duas VMs do SQL Server iniciando os arquivos de área de trabalho remota. Use o nome de usuário do administrador do computador do AzureAdmin e senha Contoso!000, que você especificou ao criar as VMs.

  2. Verifique se os computadores foram vinculados com êxito no corp.contoso.com.

  3. Aguarde até que a instalação do SQL Server conclua a execução das tarefas de inicialização automatizadas antes de continuar.

  4. Abra uma janela do PowerShell no modo de administrador.

  5. Instale o recurso de cluster de failover do Windows.

    Import-Module ServerManager
Add-WindowsFeature Failover-Clustering

  6. Adicione CORP\Install como administrador local.

    net localgroup administrators "CORP\Install" /Add

  7. Importe o provedor do SQL Server PowerShell.

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

  8. Adicione CORP\Install como a função sysadmin para a instância padrão do SQL Server.

    net localgroup administrators "CORP\Install" /Add
Invoke-SqlCmd -Query "EXEC sp_addsrvrolemember 'CORP\Install', 'sysadmin'" -ServerInstance "."

  9. Adicione NT AUTHORITY\System como um login com as três permissões descritas acima.

    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 o firewall para acesso remoto do 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. Saia de ambas as VMs.

     logoff.exe

Por fim, você está pronto para configurar o grupo de disponibilidade. Você usará o Provedor do SQL Server PowerShell para executar todo o trabalho em ContosoSQL1.

Configurar o grupo de disponibilidade

  1. Conecte-se ao ContosoSQL1 novamente abrindo os arquivos de área de trabalho remota. Em vez de entrar usando a conta do computador, entre usando CORP\Install.

  2. Abra uma janela do PowerShell no modo de administrador.

  3. Defina as seguintes variáveis:

    $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 o provedor do SQL Server PowerShell.

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

  5. Altere a conta de serviço do SQL Server para ContosoSQL1 para 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. Altere a conta de serviço do SQL Server para ContosoSQL2 para 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. Baixe ,CreateAzureFailoverCluster.ps1, de para Criar Cluster de Failover para Grupos de Disponibilidade Always On na VM do Azure no diretório de trabalho local. Você usará esse script para ajudá-lo a criar um cluster de failover funcional. Para obter informações importantes sobre como o Cluster de Failover do Windows interage com a rede do Azure, consulte Alta disponibilidade e recuperação de desastre para SQL Server em Máquinas Virtuais do Azure.

  8. Mude para o diretório de trabalho e crie o cluster de failover com o script baixado.

    Set-ExecutionPolicy Unrestricted -Force
.\CreateAzureFailoverCluster.ps1 -ClusterName "$clusterName" -ClusterNode "$server1","$server2","$serverQuorum"

  9. Habilite grupos de disponibilidade Always On para as instâncias padrão do SQL Server em contosoSQL1 e 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. Crie um diretório de backup e conceda permissões para as contas de serviço do SQL Server. Você usará esse diretório para preparar o banco de dados de disponibilidade na réplica secundária.

    $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. Crie um banco de dados no ContosoSQL1 chamado MyDB1, faça um backup completo e um backup de log, e restaure-os em ContosoSQL2 com a opção 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. Crie os pontos de extremidade do grupo de disponibilidade nas VMs do SQL Server e defina as permissões adequadas nos pontos de extremidade.

    $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. Crie as réplicas de disponibilidade.

    $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 fim, crie o grupo de disponibilidade e ingresse a réplica secundária no grupo de disponibilidade.

    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

Próximas etapas

Agora você implementou com êxito o SQL Server Always On criando um grupo de disponibilidade no Azure. Para configurar um ouvinte para esse grupo de disponibilidade, consulte Configurar um ouvinte ILB para grupos de disponibilidade Always On no Azure.

Para obter outras informações sobre como usar o SQL Server no Azure, consulte SQL Server em máquinas virtuais do Azure.