Déployer un groupe de disponibilité Always On Microsoft SQL Server 2016 à plusieurs sous-réseaux sur Compute Engine

Ce tutoriel constitue la deuxième partie d'une série destinée à vous aider à déployer un environnement Windows à disponibilité élevée sur Google Cloud avec Microsoft Active Directory, SQL Server 2016 et Internet Information Services (IIS). Dans ce tutoriel, vous allez configurer deux instances SQL Server dans différentes zones de la même région, puis les configurer en tant que groupes de disponibilité Always On Microsoft SQL Server à plusieurs sous-réseaux.

La série comprend les tutoriels suivants :

Déployer un environnement Microsoft Active Directory tolérant aux pannes
Déployer plusieurs sous-réseaux SQL Server (ce document)
Déployer des serveurs Web IIS à équilibrage de charge.

Chaque tutoriel s'appuie sur l'infrastructure que vous avez créée dans le précédent.

Objectifs

Créer deux sous-réseaux de réseau couvrant deux zones.
Déployer une machine virtuelle (VM) Microsoft SQL Server 2016 dans chaque zone.
Configurer chaque instance SQL Server pour qu'elles rejoignent votre domaine Active Directory.
Créer un cluster de basculement Windows Server.
Créer et configurer un exemple de base de données bookshelf SQL Server.
Configurer le groupe de disponibilité Always On Microsoft SQL Server.

Coûts

Dans ce tutoriel, vous continuez à utiliser les ressources Google Cloud que vous avez configurées dans les tutoriels précédents. Vous allez utiliser les composants facturables suivants :

Le simulateur de coût estime le coût de cet environnement à environ 98 $ par jour, comprenant les licences SQL Server 2016 Enterprise et l'environnement Active Directory à deux serveurs.

Avant de commencer

La configuration que vous utilisez dans ce tutoriel nécessite l'accès à un contrôleur de domaine Windows et à un domaine Active Directory opérationnel. Si vous ne disposez pas encore de cet environnement, suivez la procédure décrite dans les tutoriels suivants :

Initialiser des variables communes

Vous devez définir plusieurs variables d'environnement qui contrôlent où les éléments de l'infrastructure sont déployés.

À l'aide d'un éditeur de texte, créez un script définissant les variables d'environnement suivantes pour qu'elles indiquent votre ID de projet, ainsi que la région et les zones que vous souhaitez utiliser.

Les variables définissent la région sur us-east1. Si vous avez utilisé une région différente dans le tutoriel précédent, modifiez-la dans ce script pour qu'elle corresponde à celle que vous avez utilisée auparavant.
```
region=us-east1
zone_1=${region}-b
zone_2=${region}-c
vpc_name=webappnet
project_id=your-project-id
```
Remplacez your-project-id par l'ID du projet Google Cloud que vous utilisez.
Ouvrez Cloud Shell.

Ouvrir Cloud Shell
Copiez le script dans la fenêtre Cloud Shell et exécutez-le.
Définissez la région et l'ID du projet par défaut afin de ne pas avoir à spécifier ces valeurs dans chacune des commandes suivantes :
```
gcloud config set compute/region ${region}
gcloud config set project ${project_id}
```

Créer l'infrastructure réseau

Une fois que vous avez défini les variables d'infrastructure, créez les sous-réseaux de réseau que SQL Server utilisera.

Ajoutez des sous-réseaux au réseau cloud privé virtuel (VPC) existant :

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

Créez une règle de pare-feu interne pour autoriser le trafic entre les sous-réseaux private-ad* que vous avez créés précédemment et les nouveaux sous-réseaux private-sql* :
```
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
```
Remarque : Dans un environnement de production, il est recommandé de sécuriser tous les ports que vos systèmes n'utilisent pas activement. Il est également recommandé de sécuriser l'accès à vos machines à l'aide d'un hôte bastion.

Créer des instances SQL Server

Créez ensuite deux VM SQL Server 2016 Enterprise Edition à l'aide d'images Compute Engine préconfigurées avec les propriétés suivantes :

Noms : bookshelf-sql1 et bookshelf-sql2
Taille du disque de démarrage : 200GB
Type de machine : n1-highmem-4

Si vous avez l'intention d'utiliser cet environnement au-delà de ce tutoriel, et que vous avez besoin de ressources de calcul supplémentaires, vous pourrez toujours personnaliser plus tard le type de machine de ces instances. Vous avez également la possibilité d'ajouter des disques et de redimensionner les disques persistants existants.

Dans ce tutoriel, vous utilisez l'image publique SQL Server sur Windows Server pour vos VM, ce qui signifie que l'utilisation de SQL Server vous sera facturée. Vous pouvez également déployer vos licences SQL Server existantes sur Compute Engine à l'aide de Licence Mobility via Software Assurance, et les appliquer aux images publiques de Windows Server après avoir installé SQL Server.

Créez une instance Compute Engine de Windows Server 2016 avec 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

Créez la deuxième instance :

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

Configurer l'instance bookshelf-sql2

Configurez ensuite l'instance bookshelf-sql2. Vous devez commencer par la deuxième instance, car des opérations supplémentaires sont nécessaires pour définir la base de données sur bookshelf-sql1. Par ailleurs, le fait de commencer par la configuration de bookshelf-sql2 nécessite moins de sessions du protocole RDP (Remote Desktop Protocol).

Créez un mot de passe pour l'instance Windows bookshelf-sql2 :
```
gcloud compute reset-windows-password bookshelf-sql2 \
    --zone ${zone_2} --quiet
```
Le nom d'utilisateur est le nom d'utilisateur de votre compte Google. Prenez note du nom d'utilisateur et du mot de passe pour une utilisation future.
Remarque
: Si l'instance n'est pas prête à accepter la requête, vous verrez s'afficher le message d'erreur ci-dessous.
```
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.
```
Si ce message s'affiche, tentez de réexécuter la commande dans quelques minutes.
Utilisez RDP pour vous connecter à l'instance SQL Server à l'aide des identifiants que vous avez créés précédemment.
Dans l'instance, ouvrez un terminal PowerShell en tant qu'administrateur. (Cliquez sur Démarrer, saisissez PowerShell, puis appuyez sur Control+Shift+Enter).

Définissez ces variables :

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

Configurez le serveur DNS principal :

netsh interface ip set dns Ethernet static $DNS1

Configurez le serveur DNS secondaire :

netsh interface ip add dns Ethernet $DNS2 index=2

Définissez l'adresse IP et la passerelle par défaut :
```
netsh interface ip set address name=Ethernet static $LocalStaticIp 255.255.255.0 $DefaultGateway 1
```
Remarque : RDP peut perdre la connectivité pendant quelques secondes ou vous obliger à vous reconnecter.

Ajoutez la VM au domaine Windows :

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

Lorsque vous êtes invité à fournir un mot de passe pour le compte administrateur (Administrator), utilisez les identifiants d'administrateur que vous avez définis lors de l'installation d'une forêt Active Directory dans le tutoriel précédent. Pour le nom d'utilisateur, ajoutez le nom de domaine en tant que préfixe, comme dans EXAMPLE-GCP\Administrator.

Ouvrez les ports de pare-feu Windows pour le groupe de disponibilité SQL Server :

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

Installez la fonctionnalité de clustering de basculement :

Install-WindowsFeature Failover-Clustering -IncludeManagementTools

Redémarrez l'instance :
```
Restart-Computer
```
Utilisez RDP pour vous connecter à l'instance SQL Server à l'aide des identifiants du compte EXAMPLE-GCP\Administrator.
Ouvrez une fenêtre de la console PowerShell en tant qu'administrateur.
Dans la fenêtre de la console PowerShell, créez les dossiers pour vos données et fichiers journaux SQL Server :
```
New-Item -ItemType directory -Path C:\SQLData
New-Item -ItemType directory -Path C:\SQLLog
```
Remarque : En production, il est recommandé de créer un disque séparé pour vos fichiers SQL Server. Si vous procédez ainsi, modifiez les commandes précédentes pour qu'elles correspondent au disque et au chemin d'accès que vous utilisez.

Créez un dossier pour les sauvegardes de la base de données et partagez-le :

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

Configurer l'instance bookshelf-sql1

Configurez ensuite l'instance bookshelf-sql1.

Dans Cloud Shell, créez un mot de passe pour l'instance Windows bookshelf-sql1 :
```
gcloud compute reset-windows-password bookshelf-sql1 --zone ${zone_1}  --quiet
```
Le nom d'utilisateur est le nom d'utilisateur de votre compte Google. Prenez note du nom d'utilisateur et du mot de passe pour une utilisation future.
Utilisez RDP pour vous connecter à l'instance SQL Server à l'aide des identifiants que vous avez créés pour l'instance bookshelf-sql1.
Ouvrez une fenêtre de la console PowerShell en tant qu'administrateur.

Dans la fenêtre de la console PowerShell, définissez les variables suivantes :

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

Configurez le serveur DNS principal :

netsh interface ip set dns Ethernet static $DNS1

Configurez le serveur DNS secondaire :

netsh interface ip add dns Ethernet $DNS2 index=2

Définissez l'adresse IP et la passerelle par défaut :
```
netsh interface ip set address name=Ethernet static $LocalStaticIp 255.255.255.0 $DefaultGateway 1
```
Remarque : Le protocole RDP peut perdre la connectivité pendant quelques secondes.

Ajoutez la VM au domaine :

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

Lorsque vous êtes invité à fournir un mot de passe pour le compte administrateur, utilisez les identifiants d'administrateur que vous avez définis lors de l'installation d'une forêt Active Directory dans le tutoriel précédent. Pour le nom d'utilisateur, ajoutez le nom de domaine en tant que préfixe, comme dans EXAMPLE-GCP\Administrator.

Ajoutez des règles de pare-feu Windows :

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

Installez la fonctionnalité de clustering de basculement :

Install-WindowsFeature Failover-Clustering -IncludeManagementTools

Redémarrez l'instance :
```
Restart-Computer
```

Configurer le cluster de basculement Windows Server

Utilisez le protocole RDP pour vous connecter à l'instance bookshelf-sql1. Lorsque vous êtes invité à fournir un mot de passe pour le compte administrateur, utilisez les identifiants d'administrateur que vous avez définis lors de l'installation d'une forêt Active Directory dans le tutoriel précédent. Pour le nom d'utilisateur, ajoutez le nom de domaine en tant que préfixe, comme dans EXAMPLE-GCP\Administrator.
Ouvrez une fenêtre de la console PowerShell en tant qu'administrateur.
Dans la fenêtre de la console PowerShell, définissez les variables suivantes :
```
$node1 = "bookshelf-sql1"
$node2 = "bookshelf-sql2"
```
Définissez le nom du cluster :
```
$nameWSFC = "bookshelf-dbclus"
```

Définissez les adresses IP pour les clusters et les écouteurs de cluster :

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

Assurez-vous que l'instance SQL Server bookshelf-sql1 est prête à rejoindre le cluster. Exécutez le script suivant, qui lance une tentative de connexion à l'instance SQL Server :

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

Assurez-vous que l'instance SQL Server bookshelf-sql2 est prête à rejoindre le cluster :

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

Créez le cluster :

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

Activez la fonctionnalité "Always On" pour les deux nœuds :

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

Créez des dossiers pour les données de base de données et les fichiers journaux :

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

Configurer la base de données

Ce tutoriel utilise l'exemple de base de données bookshelf que vous avez créé pour vérifier que votre configuration fonctionne correctement.

Dans la fenêtre de la console PowerShell sur laquelle vous travaillez, exécutez l'instruction SQL suivante pour créer la base de données bookshelf :

$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

Exécutez l'instruction SQL suivante pour créer la table Books :

$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

Définissez ces variables :

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

Activez l'applet de commande RSAT-AD-PowerShell à l'aide de la commande PowerShell suivante :
```
Add-WindowsFeature RSAT-AD-PowerShell
```
Vous avez besoin des outils d'administration de serveur distant pour créer un compte de service à partir de la machine virtuelle.

Ajoutez un compte de service de base de données nommé sql.service au sein du domaine :

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

Lorsque vous êtes invité à renseigner le mot de passe du compte sql.service, utilisez un mot de passe sécurisé, et stockez-le en lieu sûr pour une utilisation ultérieure.

Exécutez l'instruction SQL suivante pour ajouter le compte EXAMPLE-GCP\sql.service en tant qu'administrateur de base de données :

$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

Configurer le groupe de disponibilité SQL Server

Toujours dans l'instance dans laquelle vous travaillez, définissez les variables suivantes :

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

Sauvegardez la base de données sur le serveur principal :

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

Restaurez la base de données sur le serveur secondaire :

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

Sauvegardez le journal de la base de données sur le serveur principal :

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

Restaurez le journal de la base de données sur le serveur secondaire :

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

Créez et démarrez les points de terminaison :

$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

Le résultat est le suivant :

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

Vérifiez la configuration en exécutant les commandes suivantes dans PowerShell :

$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

Si la configuration est correcte, un résultat de ce type s'affiche :

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

Définissez les URL du point de terminaison :

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

Créez une représentation en mémoire des instances dupliquées :

$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

Créez le groupe de disponibilité :

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

Intégrez l'instance secondaire au groupe de disponibilité :

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

Intégrez la base de données secondaire au groupe de disponibilité :

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

Créez l'écouteur :

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

Supprimez le dossier partagé, qui n'est plus nécessaire :

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

Nettoyer

Si vous souhaitez passer au tutoriel suivant de cette série (Déployer des serveurs Web IIS à équilibrage de charge), conservez les ressources que vous avez créées dans le cadre de ce tutoriel. Si vous n'envisagez pas d'utiliser l'environnement que vous venez de créer, nettoyez les ressources créées sur Google Cloud pour éviter qu'elles ne vous soient facturées par la suite. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Supprimer le projet

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Dans la console Google Cloud, accédez à la page Gérer les ressources.

Accéder à la page Gérer les ressources

Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.

Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer des instances

Si vous ne souhaitez pas supprimer entièrement le projet, vous pouvez supprimer les ressources spécifiques que vous avez créées.

Pour supprimer une instance Compute Engine, procédez comme suit :

Dans Google Cloud Console, accédez à la page "Instances de VM".

Accéder à la page "Instances de VM"
Sélectionnez les instances à supprimer.
En haut de la page, cliquez sur Supprimer pour supprimer les instances.

Supprimer des réseaux VPC

Pour supprimer les réseaux VPC, les sous-réseaux et les règles de pare-feu, procédez comme suit :

Dans la console Google Cloud, accédez à la page "Réseaux VPC".

Accéder à la page Réseaux VPC
Sélectionnez le réseau VPC que vous avez créé.
En haut de la page, cliquez sur Supprimer pour supprimer le réseau.

Étape suivante

Passez aux tutoriels suivants de cette série :
- Déployer des serveurs Web IIS à équilibrage de charge.
Obtenez plus d'informations sur SQL Server sur Google Cloud :
Consultez les bonnes pratiques relatives à la conception de charges de travail évolutives et à disponibilité élevée.
Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.