Dela via

Konfigurera Always On-tillgänglighetsgruppen på en virtuell Azure-dator med PowerShell

  • Artikel

Innan du börjar bör du tänka på att du nu kan slutföra den här uppgiften i Azure Resource Manager-modellen. Vi rekommenderar Azure Resource Manager-modellen för nya distributioner. Se SQL Server Always On-tillgänglighetsgrupper på virtuella Azure-datorer.

Viktigt

Vi rekommenderar att de flesta nya distributioner använder Resource Manager modellen. Azure har två olika distributionsmodeller för att skapa och arbeta med resurser: Resource Manager och klassisk. Den här artikeln beskriver den klassiska distributionsmodellen.

Virtuella Azure-datorer (VM) kan hjälpa databasadministratörer att sänka kostnaden för ett system med SQL Server tillgänglighet. I den här självstudien får du lära dig hur du implementerar en tillgänglighetsgrupp med hjälp SQL Server en Always On-miljö från start till slut i en Azure-miljö. I slutet av självstudien består SQL Server Always On-lösningen i Azure av följande element:

  • Ett virtuellt nätverk som innehåller flera undernät, inklusive en frontend och ett backend-undernät.
  • En domänkontrollant med en Active Directory-domän.
  • Två SQL Server virtuella datorer som distribueras till backend-undernätet och är ansluten till Active Directory-domänen.
  • Ett kluster med tre noder Windows redundanskluster med kvorummodellen Nodmajoritet.
  • En tillgänglighetsgrupp med två repliker för synkront genomförande av en tillgänglighetsdatabas.

Det här scenariot är ett bra alternativ för enkelhetens skull i Azure, inte för dess kostnadseffektivitet eller andra faktorer. Du kan till exempel minimera antalet virtuella datorer för en tillgänglighetsgrupp med två repliker för att spara på beräkningstimmar i Azure genom att använda domänkontrollanten som kvorumfilresursvittne i ett redundanskluster med två noder. Den här metoden minskar antalet virtuella datorer med ett från konfigurationen ovan.

Den här självstudien är avsedd att visa dig de steg som krävs för att konfigurera den beskrivna lösningen ovan, utan att ta fram detaljerad information om varje steg. I stället för att tillhandahålla GUI-konfigurationsstegen använder den därför PowerShell-skript för att ta dig snabbt igenom varje steg. Den här självstudien förutsätter följande:

  • Du har redan ett Azure-konto med prenumerationen på den virtuella datorn.
  • Du har installerat Azure PowerShell cmdlets.
  • Du har redan en gedigen förståelse för Always On-tillgänglighetsgrupper för lokala lösningar. Mer information finns i Always On-tillgänglighetsgrupper (SQL Server).

Anslut till din Azure-prenumeration och skapa det virtuella nätverket

  1. I ett PowerShell-fönster på den lokala datorn importerar du Azure-modulen, laddar ned filen med publiceringsinställningar till datorn och ansluter PowerShell-sessionen till din Azure-prenumeration genom att importera de nedladdade publiceringsinställningarna.

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

    Kommandot Get-AzurePublishSettingsFile genererar automatiskt ett hanteringscertifikat med Azure och laddar ned det till din dator. En webbläsare öppnas automatiskt och du uppmanas att ange autentiseringsuppgifterna Microsoft-konto din Azure-prenumeration. Den nedladdade .publishsettings-filen innehåller all information som du behöver för att hantera din Azure-prenumeration. När du har sparat filen i en lokal katalog importerar du den med kommandot Import-AzurePublishSettingsFile .

    Anteckning

    Filen .publishsettings innehåller dina autentiseringsuppgifter (okodade) som används för att administrera dina Azure-prenumerationer och -tjänster. Den bästa säkerhetpraxisen för den här filen är att lagra den tillfälligt utanför dina källkataloger (till exempel i mappen Libraries\Documents) och sedan ta bort den när importen har slutförts. En obehörig användare som får åtkomst till filen .publishsettings kan redigera, skapa och ta bort dina Azure-tjänster.

  2. Definiera en serie variabler som du använder för att skapa din IT-molninfrastruktur.

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

    Var uppmärksam på följande för att se till att dina kommandon lyckas senare:

    • Variabler $storageAccountName och $dcServiceName måste vara unika eftersom de används för att identifiera ditt molnlagringskonto respektive molnservern på Internet.
    • De namn som du anger för $affinityGroupNameoch $virtualNetworkName konfigureras i konfigurationsdokumentet för virtuellt nätverk som du kommer att använda senare.
    • $sqlImageName anger det uppdaterade namnet på vm-avbildningen som innehåller SQL Server 2012 Service Pack 1 Enterprise Edition.
    • För enkelhetens skull är Contoso!000 samma lösenord som används i hela självstudien.

  3. Skapa en tillhörighetsgrupp.

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

  4. Skapa ett virtuellt nätverk genom att importera en konfigurationsfil.

    Set-AzureVNetConfig `
    -ConfigurationPath $networkConfigPath

    Konfigurationsfilen innehåller följande XML-dokument. I korthet anger den ett virtuellt nätverk med namnet ContosoNET i tillhörighetsgruppen ContosoAG. Det har adressutrymmet 10.10.0.0/16 och har två undernät, 10.10.1.0/24 respektive 10.10.2.0/24, som är undernätet framifrån respektive bakåt. Klientundernätet är den plats där du kan placera klientprogram, till exempel Microsoft SharePoint. Det undernät som är tillbaka är där du placerar de SQL Server virtuella datorerna. Om du ändrar $affinityGroupNameoch $virtualNetworkName tidigare måste du också ändra motsvarande namn nedan.

    <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. Skapa ett lagringskonto som är associerat med tillhörighetsgruppen som du skapade och ange det som det aktuella lagringskontot i din prenumeration.

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

  6. Skapa domänkontrollantservern i den nya molntjänsten och tillgänglighetsuppsättningen.

    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

    Dessa piped-kommandon gör följande:

    • New-AzureVMConfig skapar en VM-konfiguration .
    • Add-AzureProvisioningConfig ger konfigurationsparametrarna för en fristående Windows server.
    • Add-AzureDataDisk lägger till den datadisk som du ska använda för att lagra Active Directory-data, med cachelagringsalternativet inställt på Ingen.
    • New-AzureVM skapar en ny molntjänst och den nya virtuella Azure-datorn i den nya molntjänsten.

  7. Vänta tills den nya virtuella datorn har etablerats helt och ladda ned fjärrskrivbordsfilen till din arbetskatalog. Eftersom det tar lång tid att etablera den nya virtuella Azure-datorn fortsätter while loopen att avssöka den nya virtuella datorn tills den är redo att användas.

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

Domänkontrollantservern har nu etablerats. Därefter konfigurerar du Active Directory-domänen på den här domänkontrollantservern. Lämna PowerShell-fönstret öppet på den lokala datorn. Du kommer att använda den igen senare för att skapa de två SQL Server virtuella datorerna.

Konfigurera domänkontrollanten

  1. Anslut till domänkontrollantservern genom att starta fjärrskrivbordsfilen. Använd datoradministratörens användarnamn AzureAdmin och lösenordet Contoso!000, som du angav när du skapade den nya virtuella datorn.

  2. Öppna ett PowerShell-fönster i administratörsläge.

  3. Kör följandeDCPROMO.EXEför att konfigurera corp.contoso.com domän, med datakatalogerna på enhet 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"

    När kommandot har avslutats startas den virtuella datorn om automatiskt.

  4. Anslut till domänkontrollantservern igen genom att starta fjärrskrivbordsfilen. Den här gången loggar du in som CORP\Administratör.

  5. Öppna ett PowerShell-fönster i administratörsläge och importera Active Directory PowerShell-modulen med hjälp av följande kommando:

    Import-Module ActiveDirectory

  6. Kör följande kommandon för att lägga till tre användare i domänen.

    $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 används för att konfigurera allt relaterat SQL Server instanser av tjänsten, redundansklustret och tillgänglighetsgruppen. CORP\SQLSvc1 och CORP\SQLSvc2 används som SQL Server för de två SQL Server virtuella datorerna.

  7. Kör sedan följande kommandon för att ge CORP\Install behörighet att skapa datorobjekt i domänen.

    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

    Det GUID som anges ovan är GUID för datorobjekttypen. CORP \Install-kontot behöver behörigheten Läsa alla egenskaper och Skapa datorobjekt för att skapa Active Direct-objekt för redundansklustret. Behörigheten Läsa alla egenskaper har redan getts till CORP\Install som standard, så du behöver inte uttryckligen bevilja den. Mer information om behörigheter som behövs för att skapa redundansklustret finns i Stegvis guide för redundanskluster: Konfigurera konton i Active Directory.

    Nu när du har konfigurerat Active Directory och användarobjekten ska du skapa två virtuella SQL Server datorer och ansluta dem till den här domänen.

Skapa virtuella SQL Server datorer

  1. Fortsätt att använda PowerShell-fönstret som är öppet på den lokala datorn. Definiera följande ytterligare variabler:

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

    IP-adressen 10.10.0.4 tilldelas vanligtvis till den första virtuella datorn som du skapar i undernätet 10.10.0.0/16 i det virtuella Azure-nätverket. Du bör kontrollera att det här är adressen till domänkontrollantservern genom att köra IPCONFIG.

  2. Kör följande piped-kommandon för att skapa den första virtuella datorn i redundansklustret med namnet 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

    Observera följande om kommandot ovan:

    • New-AzureVMConfig skapar en VM-konfiguration med önskat namn på tillgänglighetsuppsättningen. De efterföljande virtuella datorerna skapas med samma namn på tillgänglighetsuppsättningen så att de är ansluten till samma tillgänglighetsuppsättning.
    • Add-AzureProvisioningConfig ansluter den virtuella datorn till den Active Directory-domän som du skapade.
    • Set-AzureSubnet placerar den virtuella datorn i det bakre undernätet.
    • New-AzureVM skapar en ny molntjänst och den nya virtuella Azure-datorn i den nya molntjänsten. Parametern DnsSettings anger att DNS-servern för servrarna i den nya molntjänsten har IP-adressen 10.10.0.4. Det här är IP-adressen för domänkontrollantservern. Den här parametern krävs för att de nya virtuella datorerna i molntjänsten ska kunna ansluta till Active Directory-domänen. Utan den här parametern måste du manuellt ange IPv4-inställningarna på den virtuella datorn för att använda domänkontrollantservern som primär DNS-server när den virtuella datorn har etablerats och sedan ansluta den virtuella datorn till Active Directory-domänen.

  3. Kör följande piped-kommandon för att skapa SQL Server virtuella datorer med namnet ContosoSQL1och 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

    Observera följande när det gäller kommandona ovan:

    • New-AzureVMConfig använder samma namn på tillgänglighetsuppsättningen som domänkontrollantservern och använder avbildningen SQL Server 2012 Service Pack 1 Enterprise Edition i galleriet för virtuella datorer. Den ställer även in operativsystemdisken på skrivskyddade cachelagringar (ingen cachelagring av skrivningar). Vi rekommenderar att du migrerar databasfilerna till en separat datadisk som du kopplar till den virtuella datorn och konfigurerar den utan cachelagring för läsning eller skrivning. Det näst bästa är dock att ta bort cachelagring av skrivningar på operativsystemdisken eftersom du inte kan ta bort cachelagring av läsningar på operativsystemdisken.
    • Add-AzureProvisioningConfig ansluter den virtuella datorn till den Active Directory-domän som du skapade.
    • Set-AzureSubnet placerar den virtuella datorn i det bakre undernätet.
    • Add-AzureEndpoint lägger till åtkomstslutpunkter så att klientprogram kan komma åt dessa SQL Server-tjänstinstanser på Internet. Olika portar ges till ContosoSQL1 och ContosoSQL2.
    • New-AzureVM skapar den nya SQL Server virtuella datorn i samma molntjänst som ContosoQuorum. Du måste placera de virtuella datorerna i samma molntjänst om du vill att de ska finnas i samma tillgänglighetsuppsättning.

  4. Vänta tills varje virtuell dator har etablerats fullständigt och att varje virtuell dator laddar ned sin fjärrskrivbordsfil till din arbetskatalog. Loopen for går igenom de tre nya virtuella datorerna och kör kommandona inom klammerparenteserna på den översta nivån för var och en av dem.

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

    De SQL Server virtuella datorerna etableras och körs nu, men de installeras med SQL Server med standardalternativ.

Initiera de virtuella datorerna i redundansklustret

I det här avsnittet behöver du ändra de tre servrar som du ska använda i redundansklustret och SQL Server installation. Specifikt:

  • Alla servrar: Du måste installera funktionen Redundanskluster .

  • Alla servrar: Du måste lägga till CORP\Install som datoradministratör.

  • Endast ContosoSQL1 och ContosoSQL2: Du måste lägga till CORP\Install som en sysadmin-roll i standarddatabasen.

  • Endast ContosoSQL1 och ContosoSQL2: Du måste lägga till NT AUTHORITY\System som en inloggning med följande behörigheter:

    • Ändra en tillgänglighetsgrupp
    • Anslut SQL
    • Visa servertillstånd

  • Endast ContosoSQL1 och ContosoSQL2: TCP-protokollet är redan aktiverat på den SQL Server virtuella datorn. Du måste dock fortfarande öppna brandväggen för fjärråtkomst till SQL Server.

Nu är du redo att börja. Från och med ContosoQuorum följer du stegen nedan:

  1. Anslut till ContosoQuorum genom att starta fjärrskrivbordsfilerna. Använd datoradministratörens användarnamn AzureAdmin och lösenordet Contoso!000, som du angav när du skapade de virtuella datorerna.

  2. Kontrollera att datorerna har anslutits till corp.contoso.com.

  3. Vänta tills SQL Server har kört de automatiserade initieringsuppgifterna innan du fortsätter.

  4. Öppna ett PowerShell-fönster i administratörsläge.

  5. Installera funktionen Windows redundanskluster.

    Import-Module ServerManager
Add-WindowsFeature Failover-Clustering

  6. Lägg till CORP\Install som lokal administratör.

    net localgroup administrators "CORP\Install" /Add

  7. Logga ut från ContosoQuorum. Nu är du klar med den här servern.

    logoff.exe

Initiera sedan ContosoSQL1 ochContosoSQL2. Följ stegen nedan, som är identiska för båda SQL Server virtuella datorerna.

  1. Anslut till de två SQL Server virtuella datorerna genom att starta fjärrskrivbordsfilerna. Använd datoradministratörens användarnamn AzureAdmin och lösenordet Contoso!000, som du angav när du skapade de virtuella datorerna.

  2. Kontrollera att datorerna har anslutits till corp.contoso.com.

  3. Vänta tills SQL Server har kört de automatiserade initieringsuppgifterna innan du fortsätter.

  4. Öppna ett PowerShell-fönster i administratörsläge.

  5. Installera funktionen Windows redundanskluster.

    Import-Module ServerManager
Add-WindowsFeature Failover-Clustering

  6. Lägg till CORP\Install som lokal administratör.

    net localgroup administrators "CORP\Install" /Add

  7. Importera SQL Server PowerShell-providern.

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

  8. Lägg till CORP\Install som sysadmin-roll för SQL Server instansen.

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

  9. Lägg till NT AUTHORITY\System som en inloggning med de tre behörigheter som beskrivs ovan.

    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. Öppna brandväggen för fjärråtkomst av 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. Logga ut från båda virtuella datorerna.

     logoff.exe

Slutligen är du redo att konfigurera tillgänglighetsgruppen. Du kommer att använda SQL Server PowerShell-providern för att utföra allt arbete på ContosoSQL1.

Konfigurera tillgänglighetsgruppen

  1. Anslut till ContosoSQL1 igen genom att starta fjärrskrivbordsfilerna. I stället för att logga in med datorkontot loggar du in med hjälp av CORP\Install.

  2. Öppna ett PowerShell-fönster i administratörsläge.

  3. Definiera följande variabler:

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

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

  5. Ändra SQL Server för ContosoSQL1 till 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. Ändra SQL Server för ContosoSQL2 till 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. Ladda CreateAzureFailoverCluster.ps1 från Skapa redundanskluster för Always On-tillgänglighetsgrupper på virtuella Azure-datorer till den lokala arbetskatalogen. Du använder det här skriptet för att skapa ett funktionellt redundanskluster. Viktig information om hur Windows redundanskluster interagerar med Azure-nätverket finns i Hög tillgänglighet och haveriberedskap för SQL Server i Azure Virtual Machines.

  8. Ändra till arbetskatalogen och skapa redundansklustret med det nedladdade skriptet.

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

  9. Aktivera Always On-tillgänglighetsgrupper för standardinstanserna SQL Server ContosoSQL1 och 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. Skapa en säkerhetskopieringskatalog och bevilja behörigheter för SQL Server-tjänstkonton. Du använder den här katalogen för att förbereda tillgänglighetsdatabasen på den sekundära repliken.

    $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. Skapa en databas på ContosoSQL1 med namnet MyDB1, ta både en fullständig säkerhetskopia och en loggsäkerhetskopia och återställ dem på ContosoSQL2 med alternativet MED 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. Skapa slutpunkterna för tillgänglighetsgruppen på SQL Server virtuella datorerna och ange rätt behörigheter för slutpunkterna.

    $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. Skapa tillgänglighetsreplikerna.

    $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. Skapa slutligen tillgänglighetsgruppen och anslut den sekundära repliken till tillgänglighetsgruppen.

    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

Nästa steg

Nu har du implementerat SQL Server Always On genom att skapa en tillgänglighetsgrupp i Azure. Information om hur du konfigurerar en lyssnare för den här tillgänglighetsgruppen finns i Konfigurera en ILB-lyssnare för Always On-tillgänglighetsgrupper i Azure.

Mer information om hur du använder SQL Server azure finns i SQL Server på virtuella Azure-datorer.