Exportar (0) Imprimir
Expandir Tudo

Tutorial: grupos de disponibilidade AlwaysOn no Azure (PowerShell)

Atualizado: outubro de 2013

noteObservação
Para o tutorial baseado em GUI do mesmo cenário, consulte Teste de Laboratório: Criar um grupo de disponibilidade AlwaysOn no Azure de ponta a ponta.

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

  • Uma rede virtual que contém várias sub-redes, incluindo uma sub-rede front-end e back-end

  • Um controlador de domínio com um domínio do Active Directory (AD)

  • Duas VMs do SQL Server implantadas na sub-rede back-end e unidas ao domínio do AD

  • Um cluster WSFC de 3 nós com o modelo de quorum Maioria de Nós

  • Um grupo de disponibilidade com duas réplicas de confirmação síncrona de um banco de dados de disponibilidade

Este cenário foi escolhido por sua simplicidade, não por ser econômico, nem por outros fatores no Azure. Por exemplo, você pode minimizar o número de VMs para um grupo de disponibilidade de duas réplicas para economizar horas de computação no Azure usando o controlador de domínio como a testemunha de compartilhamento de arquivo de quorum em um cluster WSFC de 2 nós. Esse método reduz a contagem de VMs em uma da configuração acima.

Este tutorial tem o objetivo de mostrar as etapas necessárias para configurar a solução descrita acima sem elaborar os detalhes de cada etapa. Consequentemente, em vez de mostrar as etapas de configuração de GUI, ele usa o script do PowerShell para orientá-lo rapidamente a cada etapa. Ele presume o seguinte:

  1. Em uma janela do PowerShell no computador local, importe o módulo do Azure, baixe um arquivo de configurações de publicação no seu computador e conecte a 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-AzurePublishgSettingsFile gera automaticamente um certificado de gerenciamento que o Azure baixa para o seu computador. Um navegador será aberto automaticamente e você receberá uma solicitação para inserir as credenciais de conta da Microsoft para sua assinatura do Azure. O arquivo.publishsettings baixado contém todas as informações de que você precisa para gerenciar sua assinatura do Azure. Depois de salvar o arquivo em um diretório local, importe-o usando o comando Import-AzurePublishSettingsFile.

    securitySegurança Observação
    O arquivo publishsettings contém as suas credenciais (sem codificação) que são usadas para administrar suas assinaturas e serviços do Azure. A prática recomendada de segurança para esse arquivo é armazená-lo temporariamente fora dos diretórios de origem (por exemplo, na pasta Bibliotecas\Documentos) e, depois, excluí-lo quando a importação for concluída. 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 no seguinte para garantir que os comandos tenham êxito depois:

    • As variáveis $storageAccountName e $dcServiceName devem ser exclusivas porque são usadas para identificar a conta de armazenamento na nuvem e o servidor de nuvem, respectivamente, na Internet.

    • Os nomes especificados para as variáveis $affinityGroupName e $virtualNetworkName são configurados no documento de configuração de rede virtual que você usará mais tarde.

    • $sqlImageName especifica o nome atualizado da imagem de VM que contém o SQL Server 2012 Service Pack 1 Enterprise Edition.

    • Para simplificar, Contoso!000 é a mesma senha usada durante todo o tutorial.

  3. Crie um grupo de afinidade.

    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. Resumidamente, ele especifica uma rede virtual chamada ContosoNET no grupo de afinidade denominado ContosoAG e tem o espaço de endereço 10.10.0.0/16 e duas sub-redes, 10.10.1.0/24 e 10.10.2.0/24, que são a sub-rede anterior e posterior, respectivamente. A sub-rede anterior é o local em que você pode colocar aplicativos cliente, como o Microsoft SharePoint, e a sub-rede posterior é o local onde você colocará as VMs do SQL Server. Se alterar as variáveis $affinityGroupName e $virtualNetworkName antes, você também deverá modificar os nomes correspondentes abaixo.

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

    New-AzureStorageAccount `
        -StorageAccountName $storageAccountName `
        -Label $storageAccountLabel `
        -AffinityGroup $affinityGroupName 
    Set-AzureSubscription `
        -SubscriptionName (Get-AzureSubscription).SubscriptionName `
        -CurrentStorageAccount $storageAccountName
    
  6. Crie o servidor DC 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
    

    Essa série de comandos conectados faz 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 Directory, com a opção de cache definida como None.

    • New-AzureVM cria um novo serviço em nuvem e cria o novo Azure VM no novo serviço em nuvem.

  7. Aguarde até que a nova VM seja totalmente provisionada e baixe o arquivo da área de trabalho remota no seu diretório de trabalho. Como o provisionamento do novo Azure VM é demorado, o loop while continua sondando a nova VM até que esteja pronto 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" 
    

Agora, o servidor DC foi provisionado com êxito. Em seguida, você configurará o domínio do Active Directory nesse servidor DC. Deixe a janela do PowerShell aberta no computador local. Você a usará novamente depois para criar duas VMs do SQL Server.

  1. Conecte-se ao servidor DC iniciando o arquivo da área de trabalho remota. 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 comando DCPROMO.EXE a seguir 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"
    

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

  4. Conecte-se ao servidor DC novamente, iniciando o arquivo da área de trabalho remota. Dessa vez, faça logon como CORP\Administrator.

  5. Abra uma janela do PowerShell no modo de administrador e importe o módulo 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 todos os itens relacionados às instâncias de serviço do SQL Server, o cluster WSFC e o 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 atribuir a 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 do tipo de objeto do computador. A conta de CORP\Install precisa das permissões Read All Properties e Create Computer Objects) para criar os objetos do Active Direct para o cluster WSFC. A permissão Read All Properties já foi atribuída a CORP\Install por padrão, portanto, você não precisa concedê-la explicitamente. Para obter mais informações sobre as permissões necessárias para criar o cluster WSFC, consulte Guia passo a passo do cluster de failover: configurando contas no Active Directory.

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

  1. Continue usando 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 na sub-rede 10.10.0.0/16 da rede virtual do Azure. Você deverá verificar se esse é o endereço do servidor DC executando IPCONFIG.

  2. Execute os seguintes comandos conectados para criar a primeira VM no cluster WSFC, chamada 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 unir 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 Posterior.

    • New-AzureVM cria um novo serviço em nuvem e cria o novo Azure VM no novo serviço em 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, que é o endereço IP do servidor DC. Esse parâmetro é necessário para permitir que as novas VMs no serviço de nuvem ingressem com êxito no domínio do Active Directory. Sem esse parâmetro, você deverá definir manualmente as configurações IPv4 na sua VM para usar o servidor DC como o servidor DNS primário depois que a VM for provisionada e depois unir a VM ao domínio do Active Directory.

  3. Execute comandos conectados a seguir para criar VMs do SQL Server, denominadas 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 DC e usa a imagem do SQL Server 2012 Service Pack 1 Enterprise Edition na galeria de máquinas virtuais. Também define o disco do sistema operacional para cache somente leitura (sem cache de gravação). É recomendável que você migre os arquivos de banco de dados para um disco de dados separados que conecta à VM e configura sem cache de leitura ou gravação. No entanto, a melhor maneira é remover o cache de gravação no disco do sistema operacional, pois 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 Posterior.

    • Add-AzureEndpoint adiciona pontos de extremidade de acesso de modo que os aplicativos cliente possam acessar essas instâncias de serviços SQL Server na Internet. Portas diferentes são atribuídas a ContosoSQL1 e ContosoSQL2.

    • cria uma novaNew-AzureVM cria a nova VM do SQL Server no mesmo serviço de nuvem que ContosoQuorum. Você deverá colocar as VMs no mesmo serviço de nuvem se quiser que elas estejam no mesmo conjunto de disponibilidade.

  4. Aguarde até que cada nova VM seja totalmente provisionada e baixe o arquivo da área de trabalho remota no seu diretório de trabalho. O loop for percorre as três novas VMs e executa os comandos nas chaves 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"
    }
    

Agora, as VMs do SQL Server estão provisionadas e em execução, mas são instalados com o SQL Server com opções padrão.

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

  • (Todos os servidores) Você precisa instalar o recurso de Failover Clustering.

  • (Todos os servidores) Você precisa adicionar CORP\Install como administrador do computador.

  • (ContosoSQL1 e ContosoSQL2 somente) Você precisa adicionar CORP\Install como uma função sysadmin no banco de dados padrão.

  • (ContosoSQL1 e ContosoSQL2 somente) Você precisa adicionar NT AUTHORITY\System como um logon com as seguintes permissões:

    • Alterar qualquer grupo de disponibilidade

    • Conectar SQL

    • Exibir estado do servidor

  • (ContosoSQL1 e ContosoSQL2 somente) O protocolo TCP já está habilitado na VM do SQL Server. No entanto, ainda será necessário 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 a ContosoQuorum iniciando os arquivos da área de trabalho remota. Use o nome de usuário do administrador do computador AzureAdmin e a senha Contoso!000, que você especificou ao criar as máquinas virtuais.

  2. Verifique se os computadores foram unidos com êxito em corp.contoso.com.

  3. Aguarde a instalação do SQL Server concluir a execução das tarefas automatizadas de inicialização antes de continuar.

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

  5. Instale o recurso de Clustering 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. Faça logoff de ContosoQuorum. Você terminou com esse servidor agora.

    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 da área de trabalho remota. Use o nome de usuário do administrador do computador AzureAdmin e a senha Contoso!000, que você especificou ao criar as máquinas virtuais.

  2. Verifique se os computadores foram unidos com êxito em corp.contoso.com.

  3. Aguarde a instalação do SQL Server concluir a execução das tarefas automatizadas de inicialização antes de continuar.

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

  5. Instale o recurso de Clustering 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 à instância padrão do SQL Server.

    net localgroup administrators "CORP\Install" /Add
    Invoke-SqlCmd -Query "EXEC sp_addsrvrolemember 'CORP\Install', 'sysadmin'" -ServerInstance "."
    
  9. Adicionar NT AUTHORITY\System como um logon 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. Faça logoff de ambas as VMs.

    logoff.exe
    

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

  1. Conecte-se a ContosoSQL1 novamente iniciando os arquivos da área de trabalho remota. Em vez de fazer logon usando a conta do computador, faça logon usando CORP\Install.

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

  3. Defina as variáveis a seguir:

    $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 de 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 de 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 Criar o cluster WSFC para grupos de disponibilidade AlwaysOn na VM do Azure para o diretório de trabalho local. Você usará esse script para ajudar a criar um cluster WSFC funcional. Para obter informações importantes sobre como o WSFC interage com a rede do Azure, consulte Alta disponibilidade e recuperação de desastres para o SQL Server em máquinas virtuais do Azure.

  8. Altere para o diretório de trabalho e crie o cluster WSFC com o script baixado.

    Set-ExecutionPolicy Unrestricted -Force
    .\CreateAzureFailoverCluster.ps1 -ClusterName "$clusterName" -ClusterNode "$server1","$server2","$serverQuorum"
    
  9. Habilite Grupos de Disponibilidade AlwaysOn 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 em 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 apropriadas 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. Finalmente, 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
    

Você acabou de implementar com êxito o SQL Server AlwaysOn criando um grupo de disponibilidade no Azure. Para configurar um ouvinte para esse grupo de disponibilidade, consulte Tutorial: Listener Configuration for AlwaysOn Availability Groups in Azure.

Mostrar:
© 2014 Microsoft