Freigeben über

Konfigurieren der AlwaysOn-Verfügbarkeitsgruppe auf einem virtuellen Azure-Computer mit PowerShell

Bevor Sie beginnen, sollten Sie berücksichtigen, dass Sie diese Aufgabe jetzt im Azure-Ressourcen-Manager-Modell ausführen können. Wir empfehlen das Azure Resource Manager-Modell für neue Bereitstellungen. Siehe SQL Server AlwaysOn-Verfügbarkeitsgruppen auf virtuellen Azure-Computern.

Von großer Bedeutung

Wir empfehlen, dass bei den meisten neuen Bereitstellungen das Resource Manager-Modell verwendet wird. Azure verfügt über zwei verschiedene Bereitstellungsmodelle für das Erstellen und Verwenden von Ressourcen: das Resource Manager-Modell und das klassische Bereitstellungsmodell. Dieser Artikel befasst sich mit der Verwendung des klassischen Bereitstellungsmodells.

Virtuelle Azure-Computer (VMs) können Datenbankadministratoren dabei helfen, die Kosten eines SQL Server-Systems mit hoher Verfügbarkeit zu senken. In diesem Lernprogramm erfahren Sie, wie Sie eine Verfügbarkeitsgruppe mithilfe von SQL Server Always On end-to-End in einer Azure-Umgebung implementieren. Am Ende des Lernprogramms besteht Ihre SQL Server Always On-Lösung in Azure aus den folgenden Elementen:

  • Ein virtuelles Netzwerk, das mehrere Subnetze enthält, einschließlich eines Front-End- und eines Back-End-Subnetzes.
  • Ein Domänencontroller mit einer Active Directory-Domäne.
  • Zwei SQL Server-VMs, die im Back-End-Subnetz bereitgestellt und der Active Directory-Domäne beigetreten sind.
  • Ein Drei-Knoten-Windows-Failovercluster mit dem Knotenmehrheits-Quorummodell.
  • Eine Verfügbarkeitsgruppe mit zwei synchronen Commit-Replikaten einer Verfügbarkeitsdatenbank.

Dieses Szenario ist eine gute Wahl für seine Einfachheit in Azure, nicht für seine Kosteneffizienz oder andere Faktoren. Sie können beispielsweise die Anzahl der virtuellen Maschinen für eine Verfügbarkeitsgruppe mit zwei Replikaten minimieren, um Rechenstunden in Azure zu sparen, indem Sie den Domänencontroller als Quorum-Dateifreigabe-Zeuge in einem Zwei-Knoten-Failover-Cluster verwenden. Diese Methode reduziert die Anzahl der virtuellen Computer um eine von der obigen Konfiguration.

Dieses Lernprogramm soll Ihnen die Schritte zeigen, die zum Einrichten der oben beschriebenen Lösung erforderlich sind, ohne die Details der einzelnen Schritte zu erarbeiten. Anstatt daher die GUI-Konfigurationsschritte bereitzustellen, wird powerShell-Skripting verwendet, um Sie schnell durch jeden Schritt zu führen. In diesem Lernprogramm wird folgendes vorausgesetzt:

Herstellen einer Verbindung mit Ihrem Azure-Abonnement und Erstellen des virtuellen Netzwerks

  1. Importieren Sie in einem PowerShell-Fenster auf Ihrem lokalen Computer das Azure-Modul, laden Sie die Veröffentlichungseinstellungsdatei auf Ihren Computer herunter, und verbinden Sie Ihre PowerShell-Sitzung mit Ihrem Azure-Abonnement, indem Sie die heruntergeladenen Veröffentlichungseinstellungen importieren.

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

    Der Befehl "Get-AzurePublishSettingsFile " generiert automatisch ein Verwaltungszertifikat mit Azure und lädt es auf Ihren Computer herunter. Ein Browser wird automatisch geöffnet, und Sie werden aufgefordert, die Anmeldeinformationen des Microsoft-Kontos für Ihr Azure-Abonnement einzugeben. Die heruntergeladene PUBLISHSETTINGS-Datei enthält alle Informationen, die Sie zum Verwalten Ihres Azure-Abonnements benötigen. Nachdem Sie diese Datei in einem lokalen Verzeichnis gespeichert haben, importieren Sie sie mithilfe des Befehls "Import-AzurePublishSettingsFile ".

    Hinweis

    Die Publishsettings-Datei enthält Ihre Anmeldeinformationen (nicht codiert), die zum Verwalten Ihrer Azure-Abonnements und -Dienste verwendet werden. Die bewährte Methode für die Sicherheit für diese Datei besteht darin, sie vorübergehend außerhalb Der Quellverzeichnisse (z. B. im Ordner "Bibliotheken\Dokumente") zu speichern und nach Abschluss des Imports zu löschen. Ein böswilliger Benutzer, der Zugriff auf die Publishsettings-Datei erhält, kann Ihre Azure-Dienste bearbeiten, erstellen und löschen.

  2. Definieren Sie eine Reihe von Variablen, die Sie zum Erstellen Ihrer Cloud-IT-Infrastruktur verwenden.

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

    Achten Sie auf Folgendes, um sicherzustellen, dass Ihre Befehle später erfolgreich sind:

    • Variablen $storageAccountName und $dcServiceName müssen eindeutig sein, da sie verwendet werden, um Ihr Cloudspeicherkonto bzw. Cloudserver im Internet zu identifizieren.
    • Die Namen, die Sie für Variablen $affinityGroupName und $virtualNetworkName angeben, werden im Dokument für die virtuelle Netzwerkkonfiguration konfiguriert, das Sie später verwenden werden.
    • $sqlImageName gibt den aktualisierten Namen des VM-Images an, das SQL Server 2012 Service Pack 1 Enterprise Edition enthält.
    • Aus Gründen der Einfachheit ist Contoso!000 dasselbe Kennwort, das im gesamten Lernprogramm verwendet wird.

  3. Erstellen Sie eine Affinitätsgruppe.

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

  4. Erstellen Sie ein virtuelles Netzwerk, indem Sie eine Konfigurationsdatei importieren.

    Set-AzureVNetConfig `
    -ConfigurationPath $networkConfigPath

    Die Konfigurationsdatei enthält das folgende XML-Dokument. Kurz gesagt, es gibt ein virtuelles Netzwerk namens ContosoNET in der Affinitätsgruppe namens ContosoAG an. Sie verfügt über den Adressraum 10.10.0.0/16 und verfügt über zwei Subnetze, 10.10.1.0/24 und 10.10.2.0/24, die das Front-Subnetz bzw. das Back-Subnetz sind. Das Front-Subnetz ist der Ort, an dem Sie Clientanwendungen wie Microsoft SharePoint platzieren können. Das Back-Subnetz ist der Ort, an dem Sie die SQL Server-VMs platzieren. Wenn Sie die $affinityGroupName und $virtualNetworkName Variablen früher ändern, müssen Sie auch die entsprechenden Namen unten ändern.

    <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. Erstellen Sie ein Speicherkonto, das der von Ihnen erstellten Affinitätsgruppe zugeordnet ist, und legen Sie es als das aktuelle Speicherkonto in Ihrem Abonnement fest.

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

  6. Erstellen Sie den Domänencontrollerserver im neuen Clouddienst und verfügbarkeitssatz.

    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

    Diese Weitergeleiteten Befehle führen die folgenden Aktionen aus:

    • New-AzureVMConfig erstellt eine VM-Konfiguration .
    • Add-AzureProvisioningConfig gibt die Konfigurationsparameter eines eigenständigen Windows-Servers an.
    • Add-AzureDataDisk fügt den Datenträger hinzu, den Sie zum Speichern von Active Directory-Daten verwenden, wobei die Zwischenspeicherungsoption auf "Keine" festgelegt ist.
    • New-AzureVM erstellt einen neuen Clouddienst und erstellt die neue Azure-VM im neuen Clouddienst.

  7. Warten Sie, bis die neue VM vollständig bereitgestellt wird, und laden Sie die Remotedesktopdatei in Ihr Arbeitsverzeichnis herunter. Da die neue Azure-VM eine lange Zeit für die Bereitstellung benötigt, fragt die while Schleife die neue VM weiterhin ab, bis sie einsatzbereit ist.

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

Der Domänencontrollerserver wurde jetzt erfolgreich bereitgestellt. Als Nächstes konfigurieren Sie die Active Directory-Domäne auf diesem Domänencontrollerserver. Lassen Sie das PowerShell-Fenster auf Ihrem lokalen Computer geöffnet. Sie verwenden es später erneut, um die beiden SQL Server-VMs zu erstellen.

Konfigurieren des Domänencontrollers

  1. Stellen Sie eine Verbindung mit dem Domänencontrollerserver her, indem Sie die Remotedesktopdatei starten. Verwenden Sie den Benutzernamen "AzureAdmin" und das Kennwort "Contoso!000", den Sie beim Erstellen der neuen VM angegeben haben.

  2. Öffnen Sie ein PowerShell-Fenster im Administratormodus.

  3. Führen Sie den folgenden DCPROMO.EXE Befehl aus, um die corp.contoso.com Domäne mit den Datenverzeichnissen auf Laufwerk M einzurichten.

    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"

    Nach Abschluss des Befehls wird der virtuelle Computer automatisch neu gestartet.

  4. Stellen Sie erneut eine Verbindung mit dem Domänencontrollerserver her, indem Sie die Remotedesktopdatei starten. Melden Sie sich dieses Mal als CORP\Administrator an.

  5. Öffnen Sie ein PowerShell-Fenster im Administratormodus, und importieren Sie das Active Directory PowerShell-Modul mithilfe des folgenden Befehls:

    Import-Module ActiveDirectory

  6. Führen Sie die folgenden Befehle aus, um der Domäne drei Benutzer hinzuzufügen.

    $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 wird verwendet, um alles im Zusammenhang mit den SQL Server-Dienstinstanzen, dem Failovercluster und der Verfügbarkeitsgruppe zu konfigurieren. CORP\SQLSvc1 und CORP\SQLSvc2 werden als SQL Server-Dienstkonten für die beiden SQL Server-VMs verwendet.

  7. Führen Sie als Nächstes die folgenden Befehle aus, um CORP\Install die Berechtigungen zur Erstellung von Computerobjekten in der Domäne zu erteilen.

    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

    Die oben angegebene GUID ist die GUID für den Computerobjekttyp. Das Corp\Install-Konto benötigt die Berechtigung " Alle Eigenschaften lesen " und " Computerobjekte erstellen ", um die Active Direct-Objekte für den Failovercluster zu erstellen. Die Berechtigung " Alle eigenschaften lesen " ist standardmäßig bereits für CORP\Install angegeben, sodass Sie sie nicht explizit erteilen müssen. Weitere Informationen zu Berechtigungen, die zum Erstellen des Failoverclusters erforderlich sind, finden Sie in der schrittweisen Anleitung zum Konfigurieren von Konten in Active Directory.

    Nachdem Sie die Konfiguration von Active Directory und den Benutzerobjekten abgeschlossen haben, erstellen Sie zwei SQL Server-VMs und verbinden sie mit dieser Domäne.

Erstellen der SQL Server-VMs

  1. Verwenden Sie weiterhin das PowerShell-Fenster, das auf Ihrem lokalen Computer geöffnet ist. Definieren Sie die folgenden zusätzlichen Variablen:

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

    Die IP-Adresse 10.10.0.4 wird in der Regel der ersten VM zugewiesen, die Sie im Subnetz 10.10.0.0/16 Ihres virtuellen Azure-Netzwerks erstellen. Überprüfen Sie, ob dies die Adresse Ihres Domänencontrollerservers ist, indem Sie IPCONFIG ausführen.

  2. Führen Sie die folgenden weitergeleiteten Befehle aus, um den ersten virtuellen Computer im Failovercluster namens ContosoQuorum zu erstellen:

    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

    Beachten Sie Folgendes in Bezug auf den obigen Befehl:

    • New-AzureVMConfig erstellt eine VM-Konfiguration mit dem gewünschten Verfügbarkeitssatznamen. Die nachfolgenden virtuellen Computer werden mit demselben Verfügbarkeitssatznamen erstellt, sodass sie mit demselben Verfügbarkeitssatz verknüpft sind.
    • Add-AzureProvisioningConfig verknüpft den virtuellen Computer mit der von Ihnen erstellten Active Directory-Domäne.
    • Set-AzureSubnet platziert den virtuellen Computer im Hintergrundsubnetz.
    • New-AzureVM erstellt einen neuen Clouddienst und erstellt die neue Azure-VM im neuen Clouddienst. Der Parameter DnsSettings gibt an, dass der DNS-Server für die Server im neuen Clouddienst die IP-Adresse 10.10.0.4 aufweist. Dies ist die IP-Adresse des Domänencontrollerservers. Dieser Parameter ist erforderlich, um die neuen VMs im Clouddienst zu aktivieren, um erfolgreich der Active Directory-Domäne beizutreten. Ohne diesen Parameter müssen Sie die IPv4-Einstellungen in Ihrer VM manuell festlegen, um den Domänencontrollerserver nach der Bereitstellung des virtuellen Computers als primären DNS-Server zu verwenden und dann der VM zur Active Directory-Domäne beizutreten.

  3. Führen Sie die folgenden weitergeleiteten Befehle aus, um die SQL Server-VMs mit dem Namen ContosoSQL1 und ContosoSQL2 zu erstellen.

    # 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

    Beachten Sie Folgendes in Bezug auf die oben aufgeführten Befehle:

    • New-AzureVMConfig verwendet denselben Verfügbarkeitssatznamen wie der Domänencontrollerserver und verwendet das SQL Server 2012 Service Pack 1 Enterprise Edition-Image im Katalog des virtuellen Computers. Außerdem wird die Festplatte des Betriebssystems auf reines Lese-Caching (kein Schreib-Caching) festgelegt. Es wird empfohlen, die Datenbankdateien auf einen separaten Datenträger zu migrieren, den Sie an die VM anfügen, und es ohne Lese- oder Schreibzwischenspeicherung zu konfigurieren. Das nächste Beste ist jedoch, die Schreibzwischenspeicherung auf dem Betriebssystemdatenträger zu entfernen, da Sie keine Lesezwischenspeicherung auf dem Betriebssystemdatenträger entfernen können.
    • Add-AzureProvisioningConfig verknüpft den virtuellen Computer mit der von Ihnen erstellten Active Directory-Domäne.
    • Set-AzureSubnet platziert den virtuellen Computer im Hintergrundsubnetz.
    • Add-AzureEndpoint fügt Zugriffsendpunkte hinzu, damit Clientanwendungen auf diese SQL Server-Diensteinstanzen im Internet zugreifen können. Unterschiedliche Ports werden ContosoSQL1 und ContosoSQL2 zugewiesen.
    • New-AzureVM erstellt die neue SQL Server-VM im selben Clouddienst wie ContosoQuorum. Sie müssen die virtuellen Computer im selben Clouddienst platzieren, wenn sie sich in demselben Verfügbarkeitssatz befinden sollen.

  4. Warten Sie, bis jeder virtuelle Computer vollständig bereitgestellt wird, und warten Sie, bis jeder virtuelle Computer seine Remotedesktopdatei in Ihr Arbeitsverzeichnis herunterladen kann. Die for Schleife durchläuft die drei neuen virtuellen Maschinen und führt die Befehle in den geschweiften Klammern der obersten Ebene für jede von ihnen aus.

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

    Die SQL Server-VMs werden jetzt bereitgestellt und ausgeführt, aber sie werden mit SQL Server mit Standardoptionen installiert.

Initialisieren Sie die VMs des Failoverclusters

In diesem Abschnitt müssen Sie die drei Server ändern, die Sie im Failovercluster und in der SQL Server-Installation verwenden. Dies gilt insbesondere in folgenden Fällen:

  • Alle Server: Sie müssen das Failover-Clustering-Feature installieren.

  • Alle Server: Sie müssen CORP\Install als Computeradministrator hinzufügen.

  • Nur ContosoSQL1 und ContosoSQL2: Sie müssen CORP \Install als Sysadmin-Rolle in der Standarddatenbank hinzufügen.

  • Nur ContosoSQL1 und ContosoSQL2: Sie müssen NT AUTHORITY\System als Anmeldung mit den folgenden Berechtigungen hinzufügen:

    • Ändern einer Beliebigen Verfügbarkeitsgruppe
    • SQL verbinden
    • Serverstatus anzeigen

  • Nur ContosoSQL1 und ContosoSQL2: Das TCP-Protokoll ist bereits auf der SQL Server-VM aktiviert. Sie müssen die Firewall jedoch weiterhin für den Remotezugriff von SQL Server öffnen.

Jetzt können Sie beginnen. Führen Sie ab ContosoQuorum die folgenden Schritte aus:

  1. Stellen Sie eine Verbindung mit ContosoQuorum her, indem Sie die Remotedesktopdateien starten. Verwenden Sie den Benutzernamen "AzureAdmin " und das Kennwort "Contoso!000", den Sie beim Erstellen der virtuellen Computer angegeben haben.

  2. Stellen Sie sicher, dass die Computer erfolgreich mit corp.contoso.com verbunden wurden.

  3. Warten Sie, bis die SQL Server-Installation die Ausführung der automatisierten Initialisierungsaufgaben abgeschlossen hat, bevor Sie fortfahren.

  4. Öffnen Sie ein PowerShell-Fenster im Administratormodus.

  5. Installieren Sie die Windows-Failoverclustering-Funktion.

    Import-Module ServerManager
Add-WindowsFeature Failover-Clustering

  6. Fügen Sie CORP\Install als lokaler Administrator hinzu.

    net localgroup administrators "CORP\Install" /Add

  7. Melden Sie sich bei ContosoQuorum ab. Sie sind jetzt mit diesem Server fertig.

    logoff.exe

Initialisieren Sie als Nächstes ContosoSQL1 und ContosoSQL2. Führen Sie die folgenden Schritte aus, die für beide SQL Server-VMs identisch sind.

  1. Stellen Sie eine Verbindung mit den beiden SQL Server-VMs her, indem Sie die Remotedesktopdateien starten. Verwenden Sie den Benutzernamen "AzureAdmin " und das Kennwort "Contoso!000", den Sie beim Erstellen der virtuellen Computer angegeben haben.

  2. Stellen Sie sicher, dass die Computer erfolgreich mit corp.contoso.com verbunden wurden.

  3. Warten Sie, bis die SQL Server-Installation die Ausführung der automatisierten Initialisierungsaufgaben abgeschlossen hat, bevor Sie fortfahren.

  4. Öffnen Sie ein PowerShell-Fenster im Administratormodus.

  5. Installieren Sie das Windows-Feature für Failover-Clustering.

    Import-Module ServerManager
Add-WindowsFeature Failover-Clustering

  6. Fügen Sie CORP\Install als lokaler Administrator hinzu.

    net localgroup administrators "CORP\Install" /Add

  7. Importieren Sie den SQL Server PowerShell-Anbieter.

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

  8. Fügen Sie CORP\Install als sysadmin-Rolle für die Standardmäßige SQL Server-Instanz hinzu.

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

  9. Fügen Sie NT AUTHORITY\System als Anmeldung mit den oben beschriebenen drei Berechtigungen hinzu.

    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. Öffnen Sie die Firewall für den Remotezugriff von 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. Melden Sie sich bei beiden virtuellen Computern ab.

     logoff.exe

Schließlich können Sie die Verfügbarkeitsgruppe konfigurieren. Sie verwenden den SQL Server PowerShell-Anbieter, um alle Arbeiten an ContosoSQL1 auszuführen.

Konfigurieren der Verfügbarkeitsgruppe

  1. Stellen Sie erneut eine Verbindung mit ContosoSQL1 her, indem Sie die Remotedesktopdateien starten. Statt sich mit dem Computerkonto anzumelden, melden Sie sich mit CORP\Install an.

  2. Öffnen Sie ein PowerShell-Fenster im Administratormodus.

  3. Definieren Sie die folgenden Variablen:

    $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. Importieren Sie den SQL Server PowerShell-Anbieter.

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

  5. Ändern Sie das SQL Server-Dienstkonto für ContosoSQL1 in 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. Ändern Sie das SQL Server-Dienstkonto für ContosoSQL2 in 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. Laden Sie CreateAzureFailoverCluster.ps1 aus Erstellen Failovercluster für Always On-Verfügbarkeitsgruppen in Azure VM in das lokale Arbeitsverzeichnis herunter. Sie nutzen dieses Skript, um einen funktionsfähigen Failover-Cluster zu erstellen. Wichtige Informationen zur Interaktion von Windows-Failoverclustering mit dem Azure-Netzwerk finden Sie unter Hohe Verfügbarkeit und Notfallwiederherstellung für SQL Server auf virtuellen Azure-Computern.

  8. Wechseln Sie zu Ihrem Arbeitsverzeichnis, und erstellen Sie den Failovercluster mit dem heruntergeladenen Skript.

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

  9. Aktivieren Sie AlwaysOn-Verfügbarkeitsgruppen für die standardmäßigen SQL Server-Instanzen in ContosoSQL1 und 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. Erstellen Sie ein Sicherungsverzeichnis, und erteilen Sie Berechtigungen für die SQL Server-Dienstkonten. Sie verwenden dieses Verzeichnis, um die Verfügbarkeitsdatenbank für das sekundäre Replikat vorzubereiten.

    $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. Erstellen Sie eine Datenbank auf ContosoSQL1 namens MyDB1, übernehmen Sie sowohl eine vollständige Sicherung als auch eine Protokollsicherung, und stellen Sie sie auf ContosoSQL2 mit der OPTION WITH NORECOVERY wieder her.

    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. Erstellen Sie die Verfügbarkeitsgruppenendpunkte auf den SQL Server-VMs, und legen Sie die richtigen Berechtigungen für die Endpunkte fest.

    $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. Erstellen Sie die Verfügbarkeitsreplikate.

    $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. Erstellen Sie schließlich die Verfügbarkeitsgruppe, und verbinden Sie das sekundäre Replikat mit der Verfügbarkeitsgruppe.

    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ächste Schritte

Sie haben sql Server Always On jetzt erfolgreich implementiert, indem Sie eine Verfügbarkeitsgruppe in Azure erstellen. Informationen zum Konfigurieren eines Listeners für diese Verfügbarkeitsgruppe finden Sie unter Konfigurieren eines ILB-Listeners für AlwaysOn-Verfügbarkeitsgruppen in Azure.

Weitere Informationen zur Verwendung von SQL Server in Azure finden Sie unter SQL Server auf virtuellen Azure-Computern.

  • Last updated on