Configurer une instance de cluster de basculement SQL Server utilisant des disques persistants en mode écriture simultanée

Les instances de cluster de basculement (FCI) Always On de Microsoft SQL Server vous permettent d'exécuter une seule instance SQL Server sur plusieurs nœuds de cluster de basculement Windows Server (WSFC). À tout moment, l'un des nœuds du cluster héberge activement l'instance SQL. En cas de défaillance, WSFC transfère automatiquement la propriété des ressources de l'instance à un autre nœud.

Les instances FCI SQL Server nécessitent que les données soient stockées sur un espace de stockage partagé pour pouvoir être accessibles sur tous les nœuds WSFC. Ce guide explique comment déployer une instance de cluster de basculement SQL Server 2022 et utiliser des disques persistants en mode écriture simultanée en tant qu'espace de stockage partagé.

Dans un environnement sur site, vous pouvez autoriser WSFC à émettre des annonces ARP en cas de basculement afin d'avertir l'équipement réseau d'une modification d'adresse IP. Toutefois, Google Cloud ne tient pas compte des annonces ARP. Vous devez donc mettre en œuvre l'une des deux options suivantes :

Équilibreur de charge interne (voir Exécuter un clustering de basculement Windows Server)

Architecture

Nom du réseau distribué (DNN) (consultez Configurer un DNN pour l'instance de cluster de basculement).

Architecture

Dans cet article, nous partons du principe que vous avez déjà déployé Active Directory sur Google Cloud et que vous possédez des connaissances de base sur SQL Server, Active Directory et Compute Engine.

Objectifs

Déployer un serveur WSFC comprenant deux instances de VM SQL Server et une troisième instance de VM faisant office de témoin de partage de fichiers
Déployer une instance FCI SQL Server sur le WSFC.
Configurer un équilibreur de charge ou un nom de réseau distribué (DNN) pour acheminer le trafic vers votre groupe de disponibilité avec SQL Server.
Vérifier que le cluster fonctionne en simulant un basculement

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

Compute Engine
Cloud Load Balancing (non nécessaire avec une configuration DNN)

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Avant de commencer

Pour suivre ce guide, vous aurez besoin des éléments suivants :

Un domaine Active Directory existant comportant au moins un contrôleur de domaine. Vous pouvez créer un domaine Active Directory à l'aide du service Microsoft AD géré. Vous pouvez également déployer un environnement Active Directory personnalisé sur Compute Engine et configurer une zone de transfert DNS privée qui transmet les requêtes DNS aux contrôleurs de domaine.
Un utilisateur Active Directory autorisé à rattacher des ordinateurs au domaine et à se connecter à l'aide du protocole RDP. Si vous utilisez le service Microsoft AD géré, vous pouvez vous servir de l'utilisateur setupadmin.
Un projet Google Cloud et un VPC avec une connectivité aux contrôleurs de domaine Active Directory.
Un sous-réseau à utiliser avec les instances de machine virtuelle Exchange.

Assurez-vous d'avoir consulté les restrictions actuelles concernant les disques persistants en mode écriture simultanée, puis sélectionnez une zone dans laquelle ces disques sont disponibles.

Pour suivre ce guide, vous avez également besoin d'un projet Google Cloud :

Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Accéder au sélecteur de projet

Vérifiez que la facturation est activée pour votre projet Google Cloud.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Accéder au sélecteur de projet

Vérifiez que la facturation est activée pour votre projet Google Cloud.

Une fois que vous avez terminé ce tutoriel, évitez de continuer à payer des frais en supprimant les ressources que vous avez créées. Consultez la section Effectuer un nettoyage pour en savoir plus.

Préparer le projet et le réseau

Pour préparer votre projet Google Cloud et votre VPC pour le déploiement de SQL Server FCI, procédez comme suit :

Dans Google Cloud Console, ouvrez Cloud Shell en cliquant sur le bouton Activer Cloud Shell .

Accédez à Google Cloud Console.
Initialisez les variables suivantes :
```
VPC_NAME=VPC_NAME
SUBNET_NAME=SUBNET_NAME
```
Où :
- VPC_NAME : nom de votre VPC
- SUBNET_NAME : nom de votre sous-réseau
Définissez votre ID de projet par défaut :
```
gcloud config set project PROJECT_ID
```
Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.
Définissez votre zone par défaut :
```
gcloud config set compute/zone ZONE
```
Remplacez ZONE par l'ID de la zone dans laquelle vous souhaitez effectuer le déploiement.

Créer des règles de pare-feu

Autorisez la communication entre les nœuds WSFC pour permettre aux clients de se connecter à SQL Server, et créez plusieurs règles de pare-feu pour permettre à l'équilibreur de charge d'effectuer des vérifications d'état. Pour simplifier la création de ces règles de pare-feu, utilisez des tags réseau :

Les deux nœuds WSFC sont annotés avec le tag wsfc-node.
Tous les serveurs (y compris le témoin) sont annotés avec le tag wsfc.

Créez des règles de pare-feu qui utilisent ces tags réseau :

Revenez à la session Cloud Shell que vous avez précédemment ouverte.

Créez des règles de pare-feu pour les nœuds WSFC :

SUBNET_CIDR=$(gcloud compute networks subnets describe $SUBNET_NAME --format=value\('ipCidrRange'\))

gcloud compute firewall-rules create allow-all-between-wsfc-nodes \
  --direction=INGRESS \
  --action=allow \
  --rules=tcp,udp,icmp \
  --enable-logging \
  --source-tags=wsfc \
  --target-tags=wsfc \
  --network=$VPC_NAME \
  --priority 10000

gcloud compute firewall-rules create allow-sql-to-wsfc-nodes \
  --direction=INGRESS \
  --action=allow \
  --rules=tcp:1433 \
  --enable-logging \
  --source-ranges=$SUBNET_CIDR \
  --target-tags=wsfc-node \
  --network=$VPC_NAME \
  --priority 10000

Créez une règle de pare-feu qui autorise les vérifications d'état à partir des plages d'adresses IP des vérificateurs Google Cloud (non requise avec une configuration DNN)

gcloud compute firewall-rules create allow-health-check-to-wsfc-nodes \
  --direction=INGRESS \
  --action=allow \
  --rules=tcp \
  --source-ranges=130.211.0.0/22,35.191.0.0/16 \
  --target-tags=wsfc-node \
  --network=$VPC_NAME \
  --priority 10000

Créer des instances de VM

Vous allez maintenant déployer deux instances de VM pour le cluster de basculement. À tout moment, une seule de ces VM sert de nœud FCI actif, tandis que l'autre sert de nœud de basculement. Les deux instances de VM doivent :

se trouver dans la même zone afin qu'elles puissent accéder aux mêmes disques persistants ;
avoir installé un clustering de basculement Windows Server et SQL Server ;
avoir activé la compatibilité WSFC de Compute Engine.

Vous utilisez une image payante SQL Server sur laquelle SQL Server 2022 est préinstallé.

Pour obtenir un nombre de votes majoritaire et atteindre un quorum pour le scénario de basculement, vous déployez une troisième VM faisant office de témoin de partage de fichiers.

Revenez à la session Cloud Shell que vous avez précédemment ouverte.
Créez une stratégie d'emplacement par répartition qui répartit les nœuds WSFC sur l'infrastructure sous-jacente du centre de données afin qu'ils ne partagent pas le même hôte ou système d'alimentation :
```
ZONE=$(gcloud config get-value compute/zone)
gcloud compute resource-policies create group-placement spread-placement \
  --availability-domain-count 2 \
  --region ${ZONE::-2}
```

Créez un script de spécialisation pour les nœuds WSFC. Le script installe la fonctionnalité Windows nécessaire et crée des règles de pare-feu pour WSFC et SQL Server :

cat << "EOF" > specialize-node.ps1

$ErrorActionPreference = "stop"

# Install required Windows features
Install-WindowsFeature Failover-Clustering -IncludeManagementTools
Install-WindowsFeature RSAT-AD-PowerShell

# Open firewall for WSFC
netsh advfirewall firewall add rule name="Allow SQL Server health check" dir=in action=allow protocol=TCP localport=59997

# Open firewall for SQL Server
netsh advfirewall firewall add rule name="Allow SQL Server" dir=in action=allow protocol=TCP localport=1433

EOF

Créez les instances de VM et activez l'agent de clustering de basculement Windows Server sur les nœuds WSFC en définissant la clé de métadonnées enable-wsfc sur true :

MACHINE_TYPE=n2-standard-8

gcloud compute instances create node-1 \
  --resource-policies spread-placement \
  --machine-type $MACHINE_TYPE \
  --subnet $SUBNET_NAME \
  --image-family sql-ent-2022-win-2022 \
  --image-project windows-sql-cloud \
  --tags wsfc,wsfc-node \
  --boot-disk-size 50 \
  --boot-disk-type pd-ssd \
  --boot-disk-device-name "node-1" \
  --metadata enable-wsfc=true \
  --metadata-from-file=sysprep-specialize-script-ps1=specialize-node.ps1

gcloud compute instances create node-2 \
  --resource-policies spread-placement \
  --machine-type $MACHINE_TYPE \
  --subnet $SUBNET_NAME \
  --image-family sql-ent-2022-win-2022 \
  --image-project windows-sql-cloud \
  --tags wsfc,wsfc-node \
  --boot-disk-size 50 \
  --boot-disk-type pd-ssd \
  --boot-disk-device-name "node-2" \
  --metadata enable-wsfc=true \
  --metadata-from-file=sysprep-specialize-script-ps1=specialize-node.ps1

gcloud compute instances create "witness" \
  --machine-type n2-standard-2 \
  --subnet $SUBNET_NAME \
  --image-family=windows-2022 \
  --image-project=windows-cloud \
  --tags wsfc \
  --boot-disk-size 50 \
  --boot-disk-type pd-ssd \
  --metadata sysprep-specialize-script-ps1="add-windowsfeature FS-FileServer"

Pour rattacher les trois instances de VM à Active Directory, procédez comme suit pour chacune d'entre elles :
1. Surveillez le processus d'initialisation de la VM en consultant la sortie de son port série :
```
gcloud compute instances tail-serial-port-output NAME
```
  Remplacez NAME par le nom de l'instance de VM.
  
  Attendez environ trois minutes avant que la sortie Instance setup finished s'affiche, puis appuyez sur Ctrl+C. À ce stade, l'instance de VM est prête à être utilisée.
2. Créez un nom d'utilisateur et un mot de passe pour l'instance de VM.
3. Connectez-vous à la VM à l'aide du Bureau à distance en vous servant du nom d'utilisateur et du mot de passe créés à l'étape précédente.
4. Effectuez un clic droit sur le bouton Start (Démarrer) (ou appuyez sur Win+X) et cliquez sur Windows PowerShell (Admin).
5. Confirmez l'invite d'élévation en cliquant sur Yes (Oui).
6. Rattachez l'ordinateur au domaine Active Directory, puis redémarrez-le :
```
Add-Computer -Domain DOMAIN -Restart
```
  Remplacez DOMAIN par le nom DNS du domaine Active Directory.
  
  Attendez environ une minute la fin du redémarrage.

Créez des disques persistants en mode écriture simultanée

Vous allez maintenant créer trois disques persistants en mode écriture simultanée et les associer aux deux nœuds WSFC.

Revenez à la session Cloud Shell que vous avez précédemment ouverte.

Créez trois disques persistants partagés :

PD_SIZE=50

gcloud beta compute disks create datadisk-1 \
  --size $PD_SIZE \
  --type pd-ssd \
  --multi-writer \
  --zone $(gcloud config get-value compute/zone)
gcloud beta compute disks create datadisk-2 \
  --size $PD_SIZE \
  --type pd-ssd \
  --multi-writer \
  --zone $(gcloud config get-value compute/zone)
gcloud beta compute disks create datadisk-3 \
  --size $PD_SIZE \
  --type pd-ssd \
  --multi-writer \
  --zone $(gcloud config get-value compute/zone)

Associez les disques à node-1 :

gcloud compute instances attach-disk node-1 --disk datadisk-1
gcloud compute instances attach-disk node-1 --disk datadisk-2
gcloud compute instances attach-disk node-1 --disk datadisk-3

Associez les disques à node-2 :

gcloud compute instances attach-disk node-2 --disk datadisk-1
gcloud compute instances attach-disk node-2 --disk datadisk-2
gcloud compute instances attach-disk node-2 --disk datadisk-3

Réserver des adresses IP de cluster

Vous réservez maintenant deux adresses IP statiques dans votre VPC. Une adresse IP est utilisée comme adresse IP du cluster WSFC, l'autre est utilisée par l'équilibreur de charge interne.

Réservez une adresse IP statique pour l'équilibreur de charge interne et enregistrez l'adresse dans une nouvelle variable d'environnement nommée LOADBALANCER_ADDRESS :

gcloud compute addresses create wsfc \
  --region $(gcloud config get-value compute/zone | rev | cut -c 3- | rev) \
  --subnet $SUBNET_NAME

LOADBALANCER_ADDRESS=$(gcloud compute addresses describe wsfc \
  --region $(gcloud config get-value compute/zone | rev | cut -c 3- | rev) \
  --format=value\(address\)) && \
echo "Load Balancer IP: $LOADBALANCER_ADDRESS"

Notez l'adresse IP, car vous en aurez besoin plus tard.

Réservez une autre adresse IP statique que vous utilisez comme adresse IP de cluster : (non nécessaire avec une configuration de DNN)

gcloud compute addresses create wsfc-cluster \
  --subnet $SUBNET_NAME \
  --region $(gcloud config get-value compute/zone | rev | cut -c 3- | rev) && \
CLUSTER_ADDRESS=$(gcloud compute addresses describe wsfc-cluster \
  --region $(gcloud config get-value compute/zone | rev | cut -c 3- | rev) \
  --format=value\(address\)) && \
echo "Cluster IP: $CLUSTER_ADDRESS"

Notez l'adresse IP, car vous en aurez besoin plus tard.

Votre projet et votre VPC sont maintenant prêts pour le déploiement de WSFC et de SQL Server.

Créer un partage de fichiers témoin

Pour préparer witness à servir de témoin de partage de fichiers, créez un partage de fichiers et accordez à vous-même et aux deux nœuds WSFC l'autorisation d'accéder à ce partage :

Connectez-vous à witness à l'aide du Bureau à distance. Connectez-vous avec le compte utilisateur de votre domaine.
Effectuez un clic droit sur le bouton Start (Démarrer) (ou appuyez sur Win+X) et cliquez sur Windows PowerShell (Admin).
Confirmez l'invite d'élévation en cliquant sur Yes (Oui).

Créez le dossier témoin et partagez-le :

New-Item "C:\QWitness" –type directory

icacls C:\QWitness\ /grant 'node-1$:(OI)(CI)(M)'
icacls C:\QWitness\ /grant 'node-2$:(OI)(CI)(M)'

New-SmbShare `
  -Name QWitness `
  -Path "C:\QWitness" `
  -Description "SQL File Share Witness" `
  -FullAccess  $env:username,node-1$,node-2$

Déployer le cluster de basculement

Vous allez maintenant utiliser les instances de VM pour déployer WSFC et SQL Server.

Déployer WSFC

Vous êtes maintenant prêt à créer le cluster de basculement.

Connectez-vous à node-1 à l'aide du Bureau à distance. Connectez-vous avec le compte utilisateur de votre domaine.
Effectuez un clic droit sur le bouton Start (Démarrer) (ou appuyez sur Win+X) et cliquez sur Windows PowerShell (Admin).
Confirmez l'invite d'élévation en cliquant sur Yes (Oui).

Créez un cluster :

Pour la configuration de l'équilibreur de charge

New-Cluster `
  -Name sql-cluster `
  -Node node-1,node-2 `
  -NoStorage `
  -StaticAddress CLUSTER_ADDRESS

Remplacez CLUSTER_ADDRESS par l'adresse IP du cluster que vous avez créée précédemment.

Pour la configuration de DNN

New-Cluster `
  -Name sql-cluster `
  -Node node-1,node-2 `
  -NoStorage `
  -ManagementPointNetworkType Distributed

Revenez à la session PowerShell sur witness et accordez à l'objet ordinateur virtuel du cluster l'autorisation d'accéder au partage de fichiers :

icacls C:\QWitness\ /grant 'sql-cluster$:(OI)(CI)(M)'
Grant-SmbShareAccess `
  -Name QWitness `
  -AccountName 'sql-cluster$' `
  -AccessRight Full `
  -Force

Revenez à la session PowerShell sur node-1 et configurez le cluster pour utiliser le partage de fichiers sur witness en tant que quorum de cluster :
```
Set-ClusterQuorum -FileShareWitness \\witness\QWitness
```

Vérifiez que le cluster a bien été créé :

Test-Cluster

Vous pouvez voir des avertissements pouvant être ignorés en toute sécurité :

WARNING: System Configuration - Validate All Drivers Signed: The test reported some warnings..
WARNING: Network - Validate Network Communication: The test reported some warnings..
WARNING:
Test Result:
HadUnselectedTests, ClusterConditionallyApproved
Testing has completed for the tests you selected. You should review the warnings in the Report.  A cluster solution is
supported by Microsoft only if you run all cluster validation tests, and all tests succeed (with or without warnings).

Vous pouvez également lancer le composant logiciel enfichable MMC du gestionnaire de cluster de basculement pour vérifier l'état du cluster en exécutant cluadmin.msc.

Si vous utilisez le service AD géré, ajoutez le compte d'ordinateur utilisé par WSFC au groupe Cloud Service Domain Join Accounts pour pouvoir joindre des ordinateurs au domaine :
```
Add-ADGroupMember `
  -Identity "Cloud Service Domain Join Accounts" `
  -Members sql-cluster$
```

Créer un pool de stockage

Vous allez maintenant créer un pool de stockage qui combine les trois disques persistants que vous avez créés précédemment et utiliser ce pool pour créer un volume partagé de cluster :

Revenez à la session PowerShell sur node-1.

Créez un pool de stockage utilisant les trois disques persistants :

$NodeName = [System.Net.Dns]::GetHostName()

$ClusterDisks = Get-PhysicalDisk -CanPool $True |
  Where-Object { ($_ |
    Get-PhysicalDiskStorageNodeView |
    Select-Object -Property StorageNodeObjectId) -like ('*' + $NodeName + '*') }

$Pool = New-StoragePool `
  -StorageSubsystemFriendlyName 'Clustered*' `
  -FriendlyName FciPool `
  -PhysicalDisks $ClusterDisks `
  -ResiliencySettingNameDefault Simple `
  -Verbose

Dans le pool de stockage, créez un volume utilisant les versions de volume partagé du cluster (reFS) et 64 Ko de l'espace du cluster :
```
$Pool | New-Volume `
  -FriendlyName FciVolume `
  -FileSystem CSVFS_ReFS `
  -Size 100GB `
  -AllocationUnitSize 65536
```
Le volume s'affiche automatiquement sur node-2, car les disques persistants sous-jacents sont associés aux deux instances de VM.
Ouvrez le composant logiciel enfichable MMC Gestionnaire du cluster de basculement:
```
cluadmin.msc
```
Dans le volet de gauche, accédez à Gestionnaire du cluster de basculement > sql-cluster > Stockage > Disques.
Effectuez un clic droit sur Disque virtuel de cluster (FciVolume), puis sélectionnez Supprimer des volumes partagés de cluster.
Sélectionnez Disque virtuel de cluster (FciVolume).
Dans l'onglet Volumes en bas de la page, effectuez un clic droit sur le volume, puis sélectionnez Modifier la lettre de lecteur.
Sélectionnez la lettre du lecteur D, puis cliquez sur OK.

Tester le basculement du pool de stockage

Si vous le souhaitez, vous pouvez maintenant vérifier si le basculement du pool de stockage fonctionne correctement:

Connectez-vous à node-2 à l'aide du Bureau à distance. Connectez-vous avec le compte utilisateur de votre domaine.
Effectuez un clic droit sur le bouton Démarrer (ou appuyez sur Win+X) et sélectionnez Exécuter.
Saisissez cluadmin.msc et sélectionnez OK.
Dans le volet de gauche, accédez à Gestionnaire du cluster de basculement > sql-cluster > Stockage > Pools.

Vous devriez voir un pool nommé Cluster Pool 1 avec le nœud propriétaire défini sur node-1.
Revenez à Cloud Shell et réinitialisez la VM node-1 pour simuler un basculement :
```
gcloud compute instances reset node-1
```
Revenez au gestionnaire de cluster de basculement sur node-2.
Observez l'état du pool de stockage en appuyant à plusieurs reprises sur F5 pour actualiser la vue.

Après environ 30 secondes, le nœud propriétaire devrait basculer automatiquement sur node-2.

Supprimer l'installation SQL Server par défaut

Vous allez maintenant supprimer l'installation SQL Server par défaut des deux nœuds et la remplacer par une nouvelle configuration FCI.

Pour chacun des deux nœuds WSFC, node-1 et node-2, procédez comme suit :

Effectuez un clic droit sur le bouton Start (Démarrer) (ou appuyez sur Win+X) et cliquez sur Windows PowerShell (Admin).
Confirmez l'invite d'élévation en cliquant sur Yes (Oui).

Supprimez l'instance SQL Server par défaut.

C:\sql_server_install\Setup.exe /Action=Uninstall /FEATURES=SQL,AS,IS,RS /INSTANCENAME=MSSQLSERVER /Q

Supprimez le pilote Microsoft OLE :

Get-Package -Name "Microsoft OLE*" | Uninstall-Package -Force

Supprimez le pilote Microsoft ODBC :

Get-Package -Name "Microsoft ODBC*" | Uninstall-Package -Force

Redémarrez l'ordinateur :
```
Restart-Computer
```
Attendez environ une minute la fin du redémarrage.

Installer SQL Server FCI

Avant d'installer la nouvelle configuration FCI, vérifiez que node-1 est le nœud actif dans le cluster :

Reconnectez-vous à node-1 en utilisant le bureau à distance, puis connectez-vous à l'aide de votre utilisateur de domaine.
Effectuez un clic droit sur le bouton Démarrer (ou appuyez sur Win+X) et sélectionnez Exécuter.
Saisissez cluadmin.msc et sélectionnez OK.
Dans le volet de gauche, accédez à Gestionnaire du cluster de basculement > sql-cluster.

Vérifiez que le serveur hôte actuel est défini sur node-1.

Si le serveur hôte actuel est défini sur node-2, effectuez un clic droit sur sql-cluster dans le volet de gauche, puis sélectionnez Autres actions > Déplacer les ressources principales du cluster > Sélectionner un nœud > node-1, puis cliquez sur OK.
Dans le volet de gauche, accédez à Gestionnaire du cluster de basculement > sql-cluster > Stockage > Pools.

Vérifiez que le nœud propriétaire du pool de cluster 1 est défini sur node-1.

Si le nœud propriétaire est défini sur node-2, effectuez un clic droit sur le pool, sélectionnez Déplacer > Sélectionner un nœud > node-1, puis cliquez sur OK.

Vous allez maintenant créer une installation de cluster de basculement SQL Server sur node-1 :

Effectuez un clic droit sur le bouton Start (Démarrer) (ou appuyez sur Win+X) et cliquez sur Windows PowerShell (Admin).
Confirmez l'invite d'élévation en cliquant sur Yes (Oui).

Créez un compte utilisateur de domaine pour SQL Server et l'agent SQL, puis attribuez un mot de passe :

$Credential = Get-Credential -UserName sql_server -Message 'Enter password'
New-ADUser `
  -Name "sql_server" `
  -Description "SQL Agent and SQL Admin account." `
  -AccountPassword $Credential.Password `
  -Enabled $true -PasswordNeverExpires $true

Démarrez la configuration de SQL Server :
```
& c:\sql_server_install\setup.exe
```
Dans le menu de gauche, sélectionnez Installation.
Sélectionnez Installation d'un nouveau cluster de basculement SQL Server.
Sur la page Édition, cochez la case Je possède une licence SQL Server uniquement, puis sélectionnez Suivant.
Sur la page Conditions d'utilisation de la licence, lisez les conditions et, si vous les acceptez, sélectionnez Suivant.
Sur la page Microsoft Update, sélectionnez Next (Suivant) pour lancer l'installation.
Sur la page Installer les règles de cluster de basculement, un avertissement de type Avertissement de vérification du cluster MSCS et un pare-feu Windows s'affichent. Vous pouvez ignorer ces avertissements et sélectionner Suivant.
Sur la page Sélection des fonctionnalités, sélectionnez Services du moteur de base de données, puis Suivant.
Sur la page Configuration de l'instance, saisissez sql comme nom de réseau, puis sélectionnez Suivant.
Sur la page Groupe de ressources de cluster, conservez les valeurs par défaut et sélectionnez Suivant.
Sur la page Sélection du disque du cluster, sélectionnez Disque virtuel de cluster (FciVolume), puis Suivant.
Sur la page Configuration du réseau de cluster, configurez les paramètres suivants, puis sélectionnez Suivant :
- DHCP: vide
- Adresse IP : saisissez l'adresse IP de l'équilibreur de charge interne.
Sur la page Configuration du serveur, configurez les paramètres suivants pour l'agent SQL Server et le moteur de base de données SQL Server:
- Nom du compte : DOMAIN\sql_server, où DOMAIN est le nom NetBIOS de votre domaine Active Directory.
- Mot de passe : saisissez le mot de passe que vous avez créé précédemment.
Sélectionnez l'onglet Classement, puis choisissez le classement que vous souhaitez utiliser. Cliquez ensuite sur Suivant.
Sur la page Configuration du moteur de base de données, sélectionnez Ajouter l'utilisateur actuel pour désigner l'utilisateur actuel comme administrateur SQL Server. Sélectionnez ensuite Suivant.
Sur la page Prêt à l'installation, vérifiez les paramètres, puis sélectionnez Installer.
Une fois l'installation terminée, sélectionnez Fermer.

Ajoutez maintenant node-2 au cluster de basculement SQL Server :

Connectez-vous à node-2 en utilisant le bureau à distance, puis connectez-vous à l'aide de votre utilisateur de domaine.
Effectuez un clic droit sur le bouton Start (Démarrer) (ou appuyez sur Win+X) et cliquez sur Windows PowerShell (Admin).
Confirmez l'invite d'élévation en cliquant sur Yes (Oui).
Démarrez la configuration de SQL Server :
```
& c:\sql_server_install\setup.exe
```
Dans le menu de gauche, sélectionnez Installation.
Sélectionnez Ajouter un nœud à un cluster de basculement SQL Server.
Suivez les instructions de l'assistant d'installation et acceptez les paramètres par défaut jusqu'à atteindre la page Comptes de service.
Sur la page Comptes de service, saisissez le mot de passe que vous avez créé précédemment pour l'agent SQL Server et le moteur de base de données SQL Server. Sélectionnez ensuite Suivant.
Sur la page Prêt à l'installation, vérifiez les paramètres, puis sélectionnez Installer.
Une fois l'installation terminée, sélectionnez Fermer.

Configurer les vérifications d'état

Enfin, configurez le cluster pour exposer un point de terminaison de vérification d'état pouvant être utilisé par un équilibreur de charge interne :

Revenez à la session PowerShell sur node-2.
Initialisez une variable avec l'adresse IP de l'équilibreur de charge.
```
$LoadBalancerIP = 'IP_ADDRESS'
```
Remplacez IP_ADDRESS par l'adresse IP de l'adresse wsfc que vous avez réservée précédemment.

Configurez le cluster de basculement pour qu'il réponde au service de vérification d'état :

$SqlGroup = Get-ClusterGroup |
  Where-Object {$_.Name.StartsWith("SQL Server")}
$SqlIpAddress = Get-ClusterResource |
  Where-Object {$_.Name.StartsWith("SQL IP Address")}

$SqlIpAddress | Set-ClusterParameter -Multiple @{
 'Address'=$LoadBalancerIP;
 'ProbePort'= 59997;
 'SubnetMask'='255.255.255.255';
 'Network'= (Get-ClusterNetwork).Name;
 'EnableDhcp'=0; }

Redémarrez la ressource de cluster :

$SqlIpAddress | Stop-ClusterResource
$SqlIpAddress | Start-ClusterResource

Redémarrez le groupe de clusters :

$SqlGroup | Stop-ClusterGroup
$SqlGroup | Start-ClusterGroup

Créer un équilibreur de charge interne

Afin de fournir un point de terminaison unique aux clients SQL Server, vous allez maintenant déployer un équilibreur de charge interne qui utilise une vérification d'état garantissant que le trafic est dirigé vers le nœud actif de WSFC.

Revenez à la session Cloud Shell que vous avez précédemment ouverte.

Créez un groupe d'instances non géré, puis ajoutez-y les deux nœuds :

gcloud compute instance-groups unmanaged create wsfc-group
gcloud compute instance-groups unmanaged add-instances wsfc-group --instances node-1,node-2

Créez une vérification d'état que l'équilibreur de charge peut utiliser pour déterminer quel est le nœud actif.
```
gcloud compute health-checks create tcp wsfc-healthcheck \
  --check-interval="2s" \
  --healthy-threshold=1 \
  --unhealthy-threshold=2 \
  --port=59997 \
  --timeout="1s"
```
La vérification de l'état sonde le port 59997, qui est le port que vous avez précédemment configuré en tant que ProbePort pour l'adresse IP du cluster WSFC.

Créez un service de backend et ajoutez le groupe d'instances :

gcloud compute backend-services create wsfc-backend \
  --load-balancing-scheme internal \
  --region $(gcloud config get-value compute/zone | rev | cut -c 3- | rev) \
  --health-checks wsfc-healthcheck \
  --protocol tcp
gcloud compute backend-services add-backend wsfc-backend \
  --instance-group wsfc-group \
  --instance-group-zone $(gcloud config get-value compute/zone) \
  --region $(gcloud config get-value compute/zone | rev | cut -c 3- | rev)

Créez l'équilibreur de charge interne :

gcloud compute forwarding-rules create wsfc-sql \
  --load-balancing-scheme internal \
  --address $LOADBALANCER_ADDRESS \
  --ports 1433 \
  --network $VPC_NAME \
  --subnet $SUBNET_NAME \
  --region $(gcloud config get-value compute/zone | rev | cut -c 3- | rev) \
  --backend-service wsfc-backend

Configurer une ressource DNN et un nom DNS DNN

À l'instar de l'équilibreur de charge interne, la ressource DNN sert de passerelle unique pour les clients SQL Server. Lors des basculements, le cluster achemine le trafic vers le nœud FCI SQL Server actif. Les clients se connectent à l'instance FCI SQL Server avec le nom DNS.

Revenez à la session PowerShell sur node-1.

Exécutez le script pour créer une ressource DNN

  $DNNResourceName='fci-dnn'
  $DNN_DNSName='fcidnn'

  # create the DNN resource
  Add-ClusterResource -Name $DNNResourceName -ResourceType 'Distributed Network Name' -Group 'SQL Server (MSSQLSERVER)'

  # set the DNS name of the DNN resource
  Get-ClusterResource -Name $DNNResourceName | Set-ClusterParameter -Name DnsName -Value $DNN_DNSName

  # start the DNN resource
  Start-ClusterResource -Name $DNNResourceName

Redémarrez node-1 et node-2.

Tester le cluster de basculement

Vous avez terminé l'installation du cluster de basculement, mais vous devez encore vérifier si le cluster fonctionne correctement.

Préparer un client

Créez une instance de VM que vous pouvez utiliser pour vous connecter au cluster de basculement :

Revenez à la session Cloud Shell que vous avez précédemment ouverte.

Créez une instance de VM.

gcloud compute instances create sqlclient \
  --machine-type n2-standard-2 \
  --subnet $SUBNET_NAME \
  --image-family sql-ent-2022-win-2022 \
  --image-project windows-sql-cloud \
  --boot-disk-size 50 \
  --boot-disk-type pd-ssd

Surveillez le processus d'initialisation de la VM en consultant la sortie de son port série :
```
gcloud compute instances tail-serial-port-output sqlclient
```
Attendez environ trois minutes jusqu'à ce que la configuration de l'instance de sortie soit terminée, puis appuyez sur Ctrl+C. À ce stade, l'instance de VM est prête à être utilisée.
Créez un nom d'utilisateur et un mot de passe pour l'instance de VM.
Connectez-vous à la VM à l'aide du Bureau à distance en vous servant du nom d'utilisateur et du mot de passe créés à l'étape précédente.
Effectuez un clic droit sur le bouton Start (Démarrer) (ou appuyez sur Win+X) et cliquez sur Windows PowerShell (Admin).
Confirmez l'invite d'élévation en cliquant sur Yes (Oui).
Rattachez l'ordinateur au domaine Active Directory :
```
Add-Computer -Domain DOMAIN
```
Remplacez DOMAIN par le nom DNS du domaine Active Directory.
Redémarrez l'ordinateur :
```
Restart-Computer
```
Attendez environ une minute la fin du redémarrage.

Exécuter le test

Utilisez la VM sqlclient pour vérifier que vous pouvez vous connecter au cluster de basculement et vérifier que le basculement fonctionne correctement :

Connectez-vous à sqlclient en utilisant le bureau à distance, puis connectez-vous à l'aide de votre utilisateur de domaine.
Effectuez un clic droit sur le bouton Start (Démarrer) (ou appuyez sur Win+X) et cliquez sur Windows PowerShell.

Connectez-vous au cluster SQL Server en utilisant son nom de réseau sql et interrogez la table dm_os_cluster_nodes :

& "$env:ProgramFiles\Microsoft SQL Server\Client SDK\ODBC\170\Tools\Binn\SQLCMD.EXE" `
   -S SQL_SERVER_NAME -E -Q "SELECT * FROM sys.dm_os_cluster_nodes"

Remplacez SQL_SERVER_NAME par sql pour la configuration de l'équilibreur de charge ou fcidnn pour la configuration DNN.

Le résultat doit se présenter comme suit :

NodeName                       status      status_description is_current_owner
------------------------------ ----------- ------------------ ----------------
NODE-1                                   0 up                                1
NODE-2                                   0 up                                0

(2 rows affected)

Notez que node-1 est le propriétaire actuel de la ressource de cluster de basculement SQL Server.

Revenez à Cloud Shell et désactivez la VM node-1 pour tester le scénario de basculement.
```
gcloud compute instances stop node-1
```

Répétez la requête :

& "$env:ProgramFiles\Microsoft SQL Server\Client SDK\ODBC\170\Tools\Binn\SQLCMD.EXE" `
   -S SQL_SERVER_NAME -E -Q "SELECT * FROM sys.dm_os_cluster_nodes"

Remplacez SQL_SERVER_NAME par sql pour la configuration de l'équilibreur de charge ou fcidnn pour la configuration DNN.

Vous devez à présent obtenir le résultat suivant :

NodeName                       status      status_description is_current_owner
------------------------------ ----------- ------------------ ----------------
NODE-1                                   1 down                              0
NODE-2                                   0 up                                1

(2 rows affected)

Malgré la désactivation de node-1, la requête aboutit et indique que node-2 est désormais le propriétaire du cluster de basculement.

Nettoyer

Une fois le tutoriel terminé, vous pouvez procéder au nettoyage des ressources que vous avez créées afin qu'elles ne soient plus comptabilisées dans votre quota et qu'elles ne vous soient plus facturées. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour 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.

Étape suivante

Apprenez-en plus sur les disques persistants en mode écriture simultanée.
Découvrez comment configurer une instance de cluster de basculement SQL Server utilisant les espaces de stockage direct.