Immer aktive SQL Server 2016-Verfügbarkeitsgruppe für mehrere Subnetze auf Compute Engine bereitstellen

Diese Anleitung ist der zweite Teil einer Reihe, die Sie bei der Bereitstellung einer hochverfügbaren Windows-Umgebung in Google Cloud mit Microsoft Active Directory, SQL Server 2016 und Internet Information Services (IIS) unterstützt. Mithilfe dieser Anleitung richten Sie zwei SQL Server-Instanzen in verschiedenen Zonen derselben Region ein und konfigurieren sie als immer aktive SQL Server-Verfügbarkeitsgruppe für mehrere Subnetze.

Die Reihe besteht aus folgenden Anleitungen:

Fehlertolerante Microsoft Active Directory-Umgebung bereitstellen
Immer aktive SQL Server-Verfügbarkeitsgruppe für mehrere Subnetze auf Compute Engine bereitstellen (dieses Dokument)
IIS-Webserver mit Load-Balancing bereitstellen

Die einzelnen Anleitungen basieren auf der Infrastruktur, die Sie in der vorigen Anleitung erstellt haben.

Ziele

Zwei Netzwerk-Subnetze erstellen, die sich über zwei Zonen erstrecken.
In jeder Zone eine virtuelle Maschine (VM) für Microsoft SQL Server 2016 bereitstellen.
Jede SQL Server-Instanz so konfigurieren, dass sie Ihrer Active Directory-Domain hinzugefügt wird.
Einen Windows Server-Failover-Cluster erstellen.
bookshelf-Beispieldatenbank für SQL Server erstellen und konfigurieren.
Die immer aktive SQL Server-Verfügbarkeitsgruppe einrichten.

Kosten

In dieser Anleitung verwenden Sie weiterhin Google Cloud-Ressourcen, die Sie in vorherigen Anleitungen konfiguriert haben. Sie verwenden die folgenden kostenpflichtigen Komponenten:

Laut Preisrechner liegen die geschätzten Kosten für diese Umgebung bei ca. 98 $ pro Tag, einschließlich der Lizenzen für SQL Server 2016 Enterprise und der Active Directory-Umgebung mit zwei Servern.

Vorbereitung

Die in dieser Anleitung verwendete Konfiguration erfordert Zugriff auf einen Windows Domain Controller und eine funktionierende Active Directory-Domain. Wenn Sie diese Umgebung noch nicht haben, führen Sie die Schritte in den folgenden Anleitungen aus:

Gemeinsame Variablen initialisieren

Sie müssen verschiedene Variablen definieren, die festlegen, wo Elemente der Infrastruktur bereitgestellt werden.

Erstellen Sie mit einem Texteditor ein Skript, das die folgenden Umgebungsvariablen festlegt, um Ihre Projekt-ID sowie die Region und die Zonen anzugeben, die Sie verwenden möchten.

Die Variablen setzen die Region auf us-east1. Wenn Sie in der vorherigen Anleitung eine andere Region verwendet haben, ändern Sie die Region in diesem Skript entsprechend in die zuvor verwendete um.
```
region=us-east1
zone_1=${region}-b
zone_2=${region}-c
vpc_name=webappnet
project_id=your-project-id
```
Ersetzen Sie your-project-id durch die ID des von Ihnen verwendeten Google Cloud-Projekts.
Öffnen Sie Cloud Shell:

Zu Cloud Shell
Kopieren Sie das Skript in Ihr Cloud Shell-Fenster und führen Sie es aus.
Legen Sie die Standardregion und die Projekt-ID fest, damit Sie diese Werte nicht bei jedem nachfolgenden Befehl angeben müssen:
```
gcloud config set compute/region ${region}
gcloud config set project ${project_id}
```

Netzwerkinfrastruktur erstellen

Nachdem Sie die Infrastrukturvariablen definiert haben, müssen Sie die Netzwerk-Subnetze erstellen, die von SQL Server verwendet werden.

Fügen Sie Ihrem vorhandenen VPC-Netzwerk (Virtual Private Cloud) neue Subnetze hinzu:

gcloud compute networks subnets create private-sql-1 \
    --network ${vpc_name} \
    --range 10.3.0.0/24

gcloud compute networks subnets create private-sql-2 \
    --network ${vpc_name} \
    --range 10.4.0.0/24

Erstellen Sie eine interne Firewallregel, um den Traffic zwischen den zuvor erstellten Subnetzen private-ad* und den neuen Subnetzen private-sql* zu regeln:
```
gcloud compute firewall-rules create allow-internal-ports-private-sql \
    --network ${vpc_name} \
    --allow tcp:0-65535,udp:0-65535,icmp \
    --source-ranges 10.4.0.0/24,10.3.0.0/24,10.2.0.0/24,10.1.0.0/24
```
Hinweis: In Produktionsumgebungen hat es sich bewährt, alle Ports zu sichern, die nicht aktiv von Ihren Systemen verwendet werden. Es ist außerdem Best Practice, den Zugriff auf Ihre Computer über einen Bastion-Host abzusichern.

SQL Server-Instanzen erstellen

Als Nächstes erstellen Sie mithilfe vorkonfigurierter Compute Engine-Images zwei VMs der SQL Server 2016 Enterprise Edition mit den folgenden Properties:

Namen: bookshelf-sql1 und bookshelf-sql2
Größe des Bootlaufwerks: 200GB
Maschinentyp: n1-highmem-4

Wenn Sie diese Umgebung über diese Anleitung hinaus verwenden und zusätzliche Rechenressourcen benötigen, können Sie den Maschinentyp für diese Instanzen später anpassen. Sie können auch Laufwerke hinzufügen und die Größe der vorhandenen nichtflüchtigen Speicher ändern.

Bei dieser Anleitung verwenden Sie das öffentliche Image von SQL Server auf Windows Server für Ihre VMs. Das bedeutet, dass Ihnen die SQL Server-Nutzung in Rechnung gestellt wird. Sie können Ihre vorhandenen SQL Server-Lizenzen auch mithilfe der Lizenzmobilität durch Software Assurance für Compute Engine bereitstellen und diese Lizenzen nach der Installation von SQL Server auf einem der öffentlichen Windows Server-Images anwenden.

Erstellen Sie eine Compute Engine-Instanz von Windows Server 2016 mit SQL Server 2016 Enterprise:

gcloud compute instances create bookshelf-sql1 \
    --machine-type n1-highmem-4 \
    --boot-disk-type pd-ssd \
    --boot-disk-size 200GB \
    --image-project windows-sql-cloud \
    --image-family sql-ent-2016-win-2016 \
    --zone ${zone_1} \
    --network-interface=network=${vpc_name},subnet=private-sql-1,private-network-ip=10.3.0.2,aliases=10.3.0.4/31

Erstellen Sie die zweite Instanz:

gcloud compute instances create bookshelf-sql2 \
    --machine-type n1-highmem-4 \
    --boot-disk-type pd-ssd \
    --boot-disk-size 200GB \
    --image-project windows-sql-cloud \
    --image-family sql-ent-2016-win-2016 \
    --zone ${zone_2} \
    --network-interface=network=${vpc_name},subnet=private-sql-2,private-network-ip=10.4.0.2,aliases=10.4.0.4/31

bookshelf-sql2-Instanz konfigurieren

Als Nächstes konfigurieren Sie die Instanz bookshelf-sql2. Beginnen Sie mit der zweiten Instanz, da zusätzliche Arbeit erforderlich ist, um die Datenbank auf bookshelf-sql1 einzurichten. Außerdem sind weniger RDP-Sitzungen (Remote Desktop Protocol) erforderlich, wenn Sie bookshelf-sql2 zuerst konfigurieren.

Erstellen Sie ein Passwort für die Windows-Instanz bookshelf-sql2:
```
gcloud compute reset-windows-password bookshelf-sql2 \
    --zone ${zone_2} --quiet
```
Der Nutzername ist der Ihres Google-Kontos. Notieren Sie Nutzernamen und Passwort.
Hinweis:
Wenn die Instanz die Anfrage nicht annehmen kann, wird die folgende Fehlermeldung angezeigt.
```
ERROR: (gcloud.compute.reset-windows-password)
The instance may not be ready for use. This can occur if the instance was
recently created or if the instance is not running Windows. Please wait a
few minutes and try again.
```
Wenn diese Meldung angezeigt wird, wiederholen Sie den Befehl nach einigen Minuten.
Verwenden Sie die zuvor erstellten Anmeldedaten, um mit RDP eine Verbindung zur SQL Server-Instanz herzustellen.
Öffnen Sie in der Instanz als Administrator ein PowerShell-Terminal. (Klicken Sie auf Start, geben Sie PowerShell ein und drücken Sie dann die Tastenkombination Control+Shift+Enter.)

Legen Sie die folgenden Variablen fest:

$DomainName = "example-gcp.com"
$DNS1 = "10.1.0.100"
$DNS2 = "10.2.0.100"
$LocalStaticIp = "10.4.0.2"
$DefaultGateway = "10.4.0.1"

Konfigurieren Sie den primären DNS-Server:

netsh interface ip set dns Ethernet static $DNS1

Konfigurieren Sie den sekundären DNS-Server:

netsh interface ip add dns Ethernet $DNS2 index=2

Legen Sie die IP-Adresse und das Standardgateway fest:
```
netsh interface ip set address name=Ethernet static $LocalStaticIp 255.255.255.0 $DefaultGateway 1
```
Hinweis: RDP verliert unter Umständen einige Sekunden lang die Verbindung und muss dann ggf. neu verbunden werden.

Fügen Sie die VM der Windows-Domain hinzu:

Add-Computer -DomainName $DomainName `
    -Credential (Get-Credential "example-gcp\Administrator")

Wenn Sie aufgefordert werden, ein Passwort für das Konto Administrator anzugeben, verwenden Sie die Administratoranmeldedaten, die Sie bei der Installation der Active Directory-Gesamtstruktur in der vorherigen Anleitung definiert haben. Fügen Sie als Benutzernamen den Domainnamen als Präfix wie in EXAMPLE-GCP\Administrator hinzu.

Öffnen Sie Windows-Firewall-Ports für die SQL Server-Verfügbarkeitsgruppe:

netsh advfirewall firewall add rule name="5022 for Avail Groups" dir=in action=allow protocol=TCP localport=5022
netsh advfirewall firewall add rule name="1433 for SQL Server" dir=in action=allow protocol=TCP localport=1433

Installieren Sie die Funktion "Failover-Clustering":

Install-WindowsFeature Failover-Clustering -IncludeManagementTools

Starten Sie die Instanz neu:
```
Restart-Computer
```
Verwenden Sie die für das Konto EXAMPLE-GCP\Administrator erstellten Anmeldedaten, um mit RDP eine Verbindung zur SQL Server-Instanz herzustellen.
Öffnen Sie als Administrator ein PowerShell-Konsolenfenster.
Erstellen Sie im PowerShell-Konsolenfenster die Ordner für Ihre SQL Server-Daten- und -Protokolldateien:
```
New-Item -ItemType directory -Path C:\SQLData
New-Item -ItemType directory -Path C:\SQLLog
```
Hinweis: Es empfiehlt sich, in der Produktionsumgebung ein separates Laufwerk für Ihre SQL Server-Dateien zu erstellen. Ändern Sie in dem Fall die vorhergehenden Befehle, damit sie dem Laufwerk und dem Pfad entsprechen, den Sie verwenden.

Erstellen Sie einen neuen Ordner für Datenbanksicherungen und geben Sie ihn frei:

New-Item -ItemType directory -Path C:\SQLBackup
New-SMBShare -Name SQLBackup -Path C:\SQLBackup -FullAccess "Authenticated Users"

bookshelf-sql1-Instanz konfigurieren

Als Nächstes konfigurieren Sie die Instanz bookshelf-sql1.

Erstellen Sie in der Cloud Shell ein Passwort für die Windows-Instanz bookshelf-sql1:
```
gcloud compute reset-windows-password bookshelf-sql1 --zone ${zone_1}  --quiet
```
Der Nutzername ist der Ihres Google-Kontos. Notieren Sie Nutzernamen und Passwort.
Verwenden Sie die für die Instanz bookshelf-sql1 erstellten Anmeldedaten, um mit RDP eine Verbindung zur SQL Server-Instanz herzustellen.
Öffnen Sie als Administrator ein PowerShell-Konsolenfenster.

Legen Sie im PowerShell-Konsolenfenster die folgenden Variablen fest:

$DomainName = "example-gcp.com"
$DNS1 = "10.1.0.100"
$DNS2 = "10.2.0.100"
$LocalStaticIp = "10.3.0.2"
$DefaultGateway = "10.3.0.1"

Konfigurieren Sie den primären DNS-Server:

netsh interface ip set dns Ethernet static $DNS1

Konfigurieren Sie den sekundären DNS-Server:

netsh interface ip add dns Ethernet $DNS2 index=2

Legen Sie die IP-Adresse und das Standardgateway fest:
```
netsh interface ip set address name=Ethernet static $LocalStaticIp 255.255.255.0 $DefaultGateway 1
```
Hinweis: RDP verliert unter Umständen einige Sekunden lang die Verbindung.

Fügen Sie die VM der Domain hinzu:

Add-Computer -DomainName $DomainName `
    -Credential (Get-Credential "example-gcp\Administrator")

Wenn Sie aufgefordert werden, ein Passwort für das Konto "Administrator" anzugeben, verwenden Sie die Administratoranmeldedaten, die Sie bei der Installation der Active Directory-Gesamtstruktur in der vorherigen Anleitung definiert haben. Fügen Sie als Benutzernamen den Domainnamen als Präfix wie in EXAMPLE-GCP\Administrator hinzu.

Fügen Sie Windows-Firewall-Regeln hinzu:

netsh advfirewall firewall add rule name="5022 for Avail Groups" dir=in action=allow protocol=TCP localport=5022
netsh advfirewall firewall add rule name="1433 for SQL Server" dir=in action=allow protocol=TCP localport=1433

Installieren Sie die Funktion "Failover-Clustering":

Install-WindowsFeature Failover-Clustering -IncludeManagementTools

Starten Sie die Instanz neu:
```
Restart-Computer
```

Windows Server-Failover-Cluster konfigurieren

Stellen Sie eine RDP-Verbindung mit der Instanz bookshelf-sql1 her. Wenn Sie aufgefordert werden, ein Passwort für das Konto "Administrator" anzugeben, verwenden Sie die Administratoranmeldedaten, die Sie bei der Active Directory-Gesamtstrukturinstallation in der vorherigen Anleitung definiert haben. Fügen Sie als Benutzernamen den Domainnamen als Präfix wie in EXAMPLE-GCP\Administrator hinzu.
Öffnen Sie als Administrator ein PowerShell-Konsolenfenster.
Legen Sie im PowerShell-Konsolenfenster die folgenden Variablen fest:
```
$node1 = "bookshelf-sql1"
$node2 = "bookshelf-sql2"
```
Legen Sie den Namen des Clusters fest:
```
$nameWSFC = "bookshelf-dbclus"
```

Legen Sie die IP-Adressen für die Cluster und Cluster-Listener fest:

$ipWSFC1 = "10.3.0.4"
$ipWSFC2 = "10.4.0.4"
$ipWSListener1 = "10.3.0.5"
$ipWSListener2 = "10.4.0.5"

Prüfen Sie, ob die SQL Server-Instanz bookshelf-sql1 für den Anschluss an den Cluster bereit ist. Führen Sie das folgende Skript aus, mit dem eine Verbindung zur SQL Server-Instanz hergestellt werden soll:

$SQLServer1IsReady=$False
For ($i=0; $i -le 30; $i++) {
    $SqlCatalog = "master"
    $SqlConnection = New-Object System.Data.SqlClient.SqlConnection
    $SqlConnection.ConnectionString = "Server = $node1;" + `
         "Database = $SqlCatalog; Integrated Security = True"
    try {
        $SqlConnection.Open()
        Write-Host "Connection to the server $node1 was successful"
        $SQLServer1IsReady=$True
        $SqlConnection.Close()
        break
    }
    catch {
        Write-Host "SQL server $node1 is not ready, waiting for 60s"
        Start-Sleep -s 60 #Wait for 60 seconds
    }
}
if($SQLServer1IsReady -eq $False) {
    Write-Error "$node1 is not responding. Was it deployed correctly?"
}

Prüfen Sie, ob die SQL Server-Instanz bookshelf-sql2 für den Anschluss an den Cluster bereit ist:

$SQLServer2IsReady=$False
For ($i=0; $i -le 30; $i++) {
    $SqlCatalog = "master"
    $SqlConnection = New-Object System.Data.SqlClient.SqlConnection
    $SqlConnection.ConnectionString = "Server = $node2;" + `
        "Database = $SqlCatalog; Integrated Security = True"
    try {
        $SqlConnection.Open()
        Write-Host "Connection to the server $node2 was successful"
        $SQLServer2IsReady=$True
        $SqlConnection.Close()
        break
    }
    catch {
        Write-Host "SQL server $node2 is not ready, waiting for 60s"
        Start-Sleep -s 60 #Wait for 60 seconds
    }
}
if($SQLServer2IsReady -eq $False) {
    Write-Error "$node2 is not responding. Was it deployed correctly?"
}

Erstellen Sie den neuen Cluster:

New-Cluster -Name $nameWSFC -Node $node1, $node2 -NoStorage `
    -StaticAddress $ipWSFC1, $ipWSFC2

Aktivieren Sie auf beiden Knoten die Funktion "Immer aktive SQL Server-Verfügbarkeitsgruppen":

Enable-SqlAlwaysOn -ServerInstance $node1 -Force
Enable-SqlAlwaysOn -ServerInstance $node2 -Force

Erstellen Sie Ordner für die Datenbankdaten und Protokolldateien:

New-Item -ItemType directory -Path C:\SQLData
New-Item -ItemType directory -Path C:\SQLLog

Datenbank einrichten

In dieser Anleitung wird die Beispieldatenbank bookshelf verwendet, die Sie erstellen, um die ordnungsgemäße Funktion Ihrer Konfiguration zu testen.

Führen Sie im PowerShell-Konsolenfenster, in dem Sie gearbeitet haben, die folgende SQL-Anweisung aus, um die Datenbank bookshelf zu erstellen:

$CreateDatabaseSQLScript =  @"
CREATE DATABASE bookshelf ON PRIMARY
    (NAME = 'bookshelf_Data', FILENAME='C:\SQLData\bookshelf_data.mdf', SIZE =
256MB, MAXSIZE = UNLIMITED, FILEGROWTH = 256MB )
    LOG ON (NAME = 'bookshelf_log', FILENAME='C:\SQLLog\bookshelf_log.ldf',
SIZE = 256MB, MAXSIZE = UNLIMITED, FILEGROWTH = 256MB )
GO
USE [bookshelf]
Exec dbo.sp_changedbowner @loginame = 'sa', @map = false;
ALTER DATABASE [bookshelf] SET RECOVERY FULL;
GO
BACKUP DATABASE bookshelf to disk =
'\\bookshelf-sql2\SQLBackup\bookshelf.bak' WITH INIT
GO
"@
Invoke-Sqlcmd -Query $CreateDatabaseSQLScript -ServerInstance $node1

Führen Sie die folgende SQL-Anweisung aus, um die Tabelle Books zu erstellen:

$CreateTableSQLScript =  @"
USE [bookshelf]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Books] (
            [Id] [bigint] IDENTITY(1,1) NOT NULL,
            [Title] [nvarchar](max) NOT NULL,
            [Author] [nvarchar](max) NULL,
            [PublishedDate] [datetime] NULL,
            [ImageUrl] [nvarchar](max) NULL,
            [Description] [nvarchar](max) NULL,
            [CreatedById] [nvarchar](max) NULL,
CONSTRAINT [PK_dbo.Books] PRIMARY KEY CLUSTERED
    ([Id] ASC) WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF,
IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
"@
Invoke-Sqlcmd -Query $CreateTableSQLScript -ServerInstance $node1

Legen Sie die folgenden Variablen fest:

$Domain = "example-gcp.com"
$ADControllerFQDN = "ad-dc1.$Domain"
$ServiceAccountName = "sql.service"
$ServiceAccountPrincipalName = "$ServiceAccountName@$Domain"

Aktivieren Sie mit dem folgenden PowerShell-Befehl das Cmdlet RSAT-AD-PowerShell:
```
Add-WindowsFeature RSAT-AD-PowerShell
```
Sie benötigen Tools für die Verwaltung des Remoteservers, um ein Dienstkonto von der VM aus zu erstellen.

Fügen Sie innerhalb der Domain ein Datenbankdienstkonto mit dem Namen sql.service hinzu:

New-ADUser -Name $ServiceAccountName `
    -Server $ADControllerFQDN `
    -SamAccountName $ServiceAccountName `
    -UserPrincipalName $ServiceAccountPrincipalName `
    -AccountPassword (Read-Host -AsSecureString "AccountPassword") `
    -PassThru | Enable-ADAccount

Wenn Sie zur Eingabe des Passworts für das Konto sql.service aufgefordert werden, wählen Sie ein starkes Passwort und bewahren Sie es für den späteren Gebrauch an einem sicheren Ort auf.

Führen Sie die folgende SQL-Anweisung aus, um das Konto EXAMPLE-GCP\sql.service als Datenbankadministrator hinzuzufügen:

$AddSQLServiceAccountScript =  @"
USE [master]
GO
    CREATE LOGIN [EXAMPLE-GCP\sql.service] FROM WINDOWS WITH
DEFAULT_DATABASE=[bookshelf], DEFAULT_LANGUAGE=[us_english]
GO
USE [bookshelf]
GO
CREATE USER [EXAMPLE-GCP\sql.service] FOR LOGIN [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_accessadmin] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_backupoperator] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_datareader] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_datawriter] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_ddladmin] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_owner] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_securityadmin] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
"@
Invoke-Sqlcmd -Query $AddSQLServiceAccountScript -ServerInstance $node1

SQL Server-Verfügbarkeitsgruppe einrichten

Legen Sie in der Instanz, in der Sie gearbeitet haben, die folgenden Variablen fest:

$Database="bookshelf"
$BackupFolder="SQLBackup"
$SharedLocation="\\$node2\$BackupFolder"
$ListenerName="sql-listener"
$AGName="MainAG"
$PrimaryServer = "$node1.$Domain\MSSQLSERVER"
$SecondaryServer = "$node2.$Domain\MSSQLSERVER"

Sichern Sie die Datenbank auf dem primären Server:

Backup-SqlDatabase `
    -Database $Database -Initialize `
    -BackupFile "$SharedLocation\$Database.bak" `
    -ServerInstance $node1

Stellen Sie die Datenbank auf dem sekundären Server wieder her:

Restore-SqlDatabase `
    -Database $Database `
    -BackupFile "$SharedLocation\$Database.bak" `
    -ServerInstance $node2 `
    -NORECOVERY

Sichern Sie das Datenbankprotokoll auf dem primären Server:

Backup-SqlDatabase `
    -Database $Database -Initialize `
    -BackupFile "$SharedLocation\$Database.log" `
    -ServerInstance $node1 `
    -BackupAction Log

Stellen Sie das Datenbankprotokoll auf dem sekundären Server wieder her:

Restore-SqlDatabase `
    -Database $Database `
    -BackupFile "$SharedLocation\$Database.log" `
    -ServerInstance $node2 `
    -RestoreAction Log `
    -NORECOVERY

Erstellen und starten Sie die Endpunkte:

$endpoint1=New-SqlHADREndpoint -Port 5022 -Owner sa `
    -Encryption Supported -EncryptionAlgorithm Aes `
    -Name AlwaysonEndpoint1 `
    -Path "SQLSERVER:\SQL\$node1.$Domain\Default"
Set-SqlHADREndpoint -InputObject $endpoint1 -State Started
$endpoint2=New-SqlHADREndpoint -Port 5022 -Owner sa `
    -Encryption Supported -EncryptionAlgorithm Aes `
    -Name AlwaysonEndpoint2 `
    -Path "SQLSERVER:\SQL\$node2.$Domain\Default"
Set-SqlHADREndpoint -InputObject $endpoint2 -State Started

Die Ausgabe sieht so aus:

AlwaysonEndpoint1       STARTED            5022 - for node1
AlwaysonEndpoint2       STARTED            5022 - for node2

Prüfen Sie die Konfiguration. Führen Sie dazu in PowerShell die folgenden Befehle aus:

$node1 = "bookshelf-sql1"
$node2 = "bookshelf-sql2"
Invoke-Sqlcmd -Query "select name, state_desc, port FROM sys.tcp_endpoints" -ServerInstance $node1
Invoke-Sqlcmd -Query "select name, state_desc, port FROM sys.tcp_endpoints" -ServerInstance $node2

Wenn die Konfiguration korrekt ist, sehen Sie die folgende Ausgabe:

name                       state_desc port
----                       ---------- ----
Dedicated Admin Connection STARTED       0
TSQL Default TCP           STARTED       0
AlwaysonEndpoint1          STARTED    5022
Dedicated Admin Connection STARTED       0
TSQL Default TCP           STARTED       0
AlwaysonEndpoint2          STARTED    5022

Legen Sie die Endpunkt-URLs fest:

$EndpointUrlSQLServer1="TCP://" + $node1 + "." + $Domain + ":5022"
$EndpointUrlSQLServer2="TCP://" + $node2 + "." + $Domain + ":5022"

Erstellen Sie eine speicherinterne Darstellung der Replikate:

$PrimaryReplica = New-SqlAvailabilityReplica -Name $node1 `
    -EndpointUrl $EndpointUrlSQLServer1 `
    -FailoverMode "Automatic" `
    -AvailabilityMode "SynchronousCommit" `
    -AsTemplate -Version 13
$SecondaryReplica = New-SqlAvailabilityReplica -Name $node2 `
    -EndpointUrl $EndpointUrlSQLServer2 `
    -FailoverMode "Automatic" `
    -AvailabilityMode "SynchronousCommit" `
    -AsTemplate -Version 13

Erstellen Sie die Verfügbarkeitsgruppe:

New-SqlAvailabilityGroup -Name $AGName `
    -AvailabilityReplica @($PrimaryReplica, $SecondaryReplica) `
    -Path "SQLSERVER:\SQL\$node1.$Domain\Default" `
    -Database $Database

Fügen Sie die sekundäre Instanz der Verfügbarkeitsgruppe hinzu:

Join-SqlAvailabilityGroup -Path "SQLSERVER:\SQL\$node2\Default" -Name $AGName

Fügen Sie die sekundäre Datenbank der Verfügbarkeitsgruppe hinzu:

Add-SqlAvailabilityDatabase `
    -Path "SQLSERVER:\SQL\$node2\Default\AvailabilityGroups\$AGName" `
    -Database $Database

Erstellen Sie den Listener:

New-SqlAvailabilityGroupListener -Name $ListenerName `
    -Port 1433 `
    -StaticIp @("$ipWSListener1/255.255.255.0","$ipWSListener2/255.255.255.0") `
    -Path SQLSERVER:\Sql\$node1\Default\AvailabilityGroups\$AGName

Entfernen Sie den freigegebenen Ordner, der nicht mehr benötigt wird:

For ($i=0; $i -le 30; $i++) {
    try {
        Remove-Item \\$node2\c$\$BackupFolder -Force -Recurse -ErrorAction Stop
        Write-Host "Shared folder $SharedLocation was removed"
        break
    }
    catch {
        Write-Host "\\$node2\c$\$BackupFolder is in use waiting 1m to retry"
        Start-Sleep -s 60
    }
}

Bereinigen

Wenn Sie mit der nächsten Anleitung in dieser Reihe (IIS-Webserver mit Load-Balancing bereitstellen) fortfahren möchten, behalten Sie die in dieser Anleitung erstellten Ressourcen bei. Wenn Sie jedoch nicht die in dieser Anleitung erstellte Umgebung verwenden möchten, bereinigen Sie die in Google Cloud erstellten Ressourcen, damit Ihnen keine Kosten in Rechnung gestellt werden. In den folgenden Abschnitten erfahren Sie, wie Sie diese Ressourcen löschen oder deaktivieren.

Projekt löschen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.

Zur Seite „Ressourcen verwalten“

Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.

Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Instanzen löschen

Wenn Sie Ihr Projekt nicht vollständig löschen möchten, können Sie bestimmte Ressourcen löschen, die Sie erstellt haben.

So löschen Sie eine Compute Engine-Instanz:

Rufen Sie in der Google Cloud Console die Seite „VM-Instanzen“ auf.

Zur Seite „VM-Instanzen"
Wählen Sie die Instanzen aus, die Sie löschen möchten.
Klicken Sie oben auf der Seite auf Löschen, um die Instanzen zu löschen.

VPC-Netzwerke löschen

So löschen Sie VPC-Netzwerk, Subnetze und Firewallregeln:

Rufen Sie in der Google Cloud Console die Seite "VPC-Netzwerke" auf.

Zur VPC-Netzwerkseite
Wählen Sie das von Ihnen erstellte VPC-Netzwerk aus.
Klicken Sie oben auf der Seite auf Löschen, um das Netzwerk zu löschen.

Weitere Informationen

Fahren Sie mit der nächsten Anleitung dieser Reihe fort:
- IIS-Webserver mit Load-Balancing bereitstellen
Weitere Informationen zu SQL Server in Google Cloud:
Best Practices für das Entwerfen skalierbarer und hochverfügbarer Arbeitslasten
Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center