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

Artikel
2017-03-17

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 AlwaysOn-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 klassiska. Den här artikeln beskriver den klassiska distributionsmodellen.

Virtuella Azure-datorer kan hjälpa databasadministratörer att sänka kostnaden för ett SQL Server-system med hög tillgänglighet. Den här självstudien visar hur du skapar en tillgänglighetsgrupp med hjälp av SQL Server Always On genom hela processen i en Azure-miljö. I slutet av självstudien består din SQL Server AlwaysOn-lösning i Azure av följande element:

Ett virtuellt nätverk som innehåller flera undernät, inklusive en klientdel och ett serverdelsundernät.
En domänkontrollant med en Active Directory-domän.
Två virtuella SQL Server-datorer som distribueras till serverdelsundernätet och som är anslutna till Active Directory-domänen.
Ett Windows-redundanskluster med tre noder med node majority quorum-modellen.
En tillgänglighetsgrupp med två synkrona commit-repliker av en tillgänglighetsdatabas.

Det här scenariot är ett bra val 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 kvorumfilvittne i ett failoverkluster med två noder. Den här metoden minskar antalet virtuella datorer med en från ovanstående konfiguration.

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

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

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

I ett PowerShell-fönster på den lokala datorn importerar du Azure-modulen, laddar ned filen för 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 datorn. En webbläsare öppnas automatiskt och du uppmanas att ange autentiseringsuppgifterna för Microsoft-kontot för 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 hjälp av kommandot Import-AzurePublishSettingsFile.

Anmärkning

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

Definiera en serie variabler som du kommer att använda för att skapa din moln-IT-infrastruktur.

$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 molnserver på Internet.
De namn som du anger för variabler $affinityGroupName och $virtualNetworkName konfigureras i konfigurationsdokumentet för virtuella nätverk som du ska använda senare.
$sqlImageName anger det uppdaterade namnet på den virtuella datoravbildningen som innehåller SQL Server 2012 Service Pack 1 Enterprise Edition.
För enkelhetens skull är Contoso!000 samma lösenord som används under hela handledningen.

Skapa en tillhörighetsgrupp.

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

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

Set-AzureVNetConfig `
    -ConfigurationPath $networkConfigPath

Konfigurationsfilen innehåller följande XML-dokument. I korthet anger det ett virtuellt nätverk med namnet ContosoNET i tillhörighetsgruppen som heter ContosoAG. Den har adressutrymmet 10.10.0.0/16 och har två undernät, 10.10.1.0/24 och 10.10.2.0/24, som är det främre undernätet respektive det bakre undernätet. I det främre undernätet kan du placera klientprogram som Microsoft SharePoint. I det bakre undernätet ska du placera de virtuella SQL Server-datorerna. Om du ändrar variablerna $affinityGroupName och $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

Skapa ett lagringskonto som är associerat med den tillhörighetsgrupp 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

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 skapar den nya virtuella Azure-datorn i den nya molntjänsten.

Vänta tills den nya VM är fullt provisionerad och ladda ned fjärrskrivbordsfilen till arbetskatalogen. Eftersom den nya virtuella Azure-datorn tar lång tid att etablera fortsätter while-loopen att avsöka den nya virtuella datorn tills den är klar för användning.

$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 är nu framgångsrikt installerad. Därefter konfigurerar du Active Directory-domänen på den här domänkontrollantservern. Låt PowerShell-fönstret vara öppet på den lokala datorn. Du använder den igen senare för att skapa de två virtuella SQL Server-datorerna.

Konfigurera domänkontrollanten

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.
Öppna ett PowerShell-fönster i administratörsläge.

Kör följande DCPROMO.EXE kommando för att konfigurera corp.contoso.com domänen 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 slutförts startas den virtuella datorn om automatiskt.

Anslut till domänkontrollantservern igen genom att starta fjärrskrivbordsfilen. Den här gången loggar du in som CORP\Administrator.
Ö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
```

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 som rör SQL Server-tjänstinstanserna, redundansklustret och tillgänglighetsgruppen. CORP\SQLSvc1 och CORP\SQLSvc2 används som SQL Server-tjänstkonton för de två virtuella SQL Server-datorerna.

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
```
Den GUID som anges ovan är GUID för objektet av typen dator. Kontot CORP\Install behöver Läs alla egenskaper och Skapa datorobjekt behörighet för att skapa Active Directory-objekt för redundansklustret. Behörigheten Läs alla egenskaper har redan tilldelats CORP\Install som standard, så du behöver inte uttryckligen bevilja den. Mer information om behörigheter som krä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 skapar du två virtuella SQL Server-datorer och ansluter dem till den här domänen.

Skapa de virtuella SQL Server-datorerna

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 10.10.0.0/16 undernät för ditt virtuella Azure-nätverk. Du bör kontrollera att det här är adressen till domänkontrollantservern genom att köra IPCONFIG-.
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 angående 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 anslutna 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 skapar 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 behö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.

Kör följande piped-kommandon för att skapa de virtuella SQL Server-datorerna med namnet ContosoSQL1 och 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 om kommandona ovan:

New-AzureVMConfig använder samma tillgänglighetsuppsättningsnamn som domänkontrollantservern och använder SQL Server 2012 Service Pack 1 Enterprise Edition-avbildningen i galleriet för virtuella datorer. Den ställer också in operativsystemets disk på endast läscache (ingen skrivcache). Vi rekommenderar att du migrerar databasfilerna till en separat datadisk som du kopplar till den virtuella datorn och konfigurerar dem utan cachelagring av läsning eller skrivning. Det näst bästa är dock att ta bort skrivcachelagring på operativsystemdisken eftersom du inte kan ta bort läscachelagring 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 virtuella SQL Server-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.

Vänta tills varje virtuell dator är helt etablerad och att varje virtuell dator laddar ned sin fjärrskrivbordsfil till arbetskatalogen. Den for-loopen växlar genom de tre nya virtuella datorerna och kör kommandona inom de översta klammerparenteserna 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 virtuella SQL Server-datorerna etableras och körs nu, men de installeras med SQL Server med standardalternativ.

Initiera de virtuella datorerna för redundanskluster

I det här avsnittet måste du ändra de tre servrar som du ska använda i redundansklustret och SQL Server-installationen. Specifikt:

Alla servrar: Du måste installera funktionen redundansklustring.
Alla servrar: Du måste lägga till CORP\Install som administratör för maskinen .
Endast ContosoSQL1 och ContosoSQL2: Du behöver lägga till CORP\Install som en sysadmin roll i standarddatabasen.
Endast ContosoSQL1 och ContosoSQL2: Du behöver lägga till NT AUTHORITY\System som inloggning med följande behörigheter:
- Ändra valfri tillgänglighetsgrupp
- Anslut SQL
- Visa status för servern
Endast ContosoSQL1 och ContosoSQL2: protokollet TCP är redan aktiverat på den virtuella SQL Server-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 ContosoQuorumföljer du stegen nedan:

Anslut till ContosoQuorum genom att starta fjärrskrivbordsfilerna. Använd datoradministratörens användarnamn AzureAdmin och lösenord Contoso!000, som du angav när du skapade de virtuella datorerna.
Kontrollera att datorerna har anslutits framgångsrikt till corp.contoso.com.
Vänta tills SQL Server-installationen är klar med att köra de automatiserade initieringsuppgifterna innan du fortsätter.
Öppna ett PowerShell-fönster i administratörsläge.

Installera Windows-failover-klusterfunktionen.

Import-Module ServerManager
Add-WindowsFeature Failover-Clustering

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

net localgroup administrators "CORP\Install" /Add

Logga ut från ContosoQuorum. Du är klar med den här servern nu.
```
logoff.exe
```

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

Anslut till de två virtuella SQL Server-datorerna genom att starta fjärrskrivbordsfilerna. Använd datoradministratörens användarnamn AzureAdmin och lösenord Contoso!000, som du angav när du skapade de virtuella datorerna.
Kontrollera att datorerna framgångsrikt har anslutits till corp.contoso.com.
Vänta tills SQL Server-installationen är klar med att köra de automatiserade initieringsuppgifterna innan du fortsätter.
Öppna ett PowerShell-fönster i administratörsläge.

Installera funktionen Windows-failoverkluster.

Import-Module ServerManager
Add-WindowsFeature Failover-Clustering

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

net localgroup administrators "CORP\Install" /Add

Importera SQL Server PowerShell-providern.

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

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

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

Lägg till NT AUTHORITY\System som 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 "."

Öppna brandväggen för fjärråtkomst till 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

Logga ut från båda de virtuella datorerna.
```
 logoff.exe
```

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

Konfigurera tillgänglighetsgruppen

Anslut till ContosoSQL1 igen genom att starta fjärrskrivbordsfilerna. I stället för att logga in med hjälp av datorkontot loggar du in med hjälp av CORP\Install.
Öppna ett PowerShell-fönster i administratörsläge.

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"

Importera SQL Server PowerShell-providern.

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

Ändra SQL Server-tjänstkontot 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)

Ändra SQL Server-tjänstkontot 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)

Ladda ned CreateAzureFailoverCluster.ps1 från Skapa redundanskluster för AlwaysOn-tillgänglighetsgrupper på virtuella Azure-datorer till den lokala arbetskatalogen. Du använder det här skriptet för att skapa ett funktionellt redundanskluster. För viktig information om hur Windows-failoverklustring interagerar med Azure-nätverket, se Hög tillgänglighet och katastrofåterställning för SQL Server i Azure Virtual Machines.

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

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

Aktivera AlwaysOn-tillgänglighetsgrupper för SQL Server-standardinstanserna på 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)

Skapa en säkerhetskopieringskatalog och bevilja behörigheter för SQL Server-tjänstkontona. 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")

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

Skapa slutpunkterna för tillgänglighetsgruppen på de virtuella SQL Server-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

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

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 AlwaysOn-tillgänglighetsgrupper i Azure.

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

Dela via