Cette page a été traduite par l'API Cloud Translation.

Configurer une instance de cluster de basculement SQL Server utilisant les espaces de stockage direct

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 2019 utilisant des espaces de stockage direct (S2D) pour le stockage partagé. Les espaces de stockage S2D fournissent un réseau SAN virtuel basé sur un logiciel pouvant utiliser des disques de données de VM Compute Engine pour stocker une base de données SQL.

Le schéma suivant illustre le déploiement :

Architecture

En mettant en œuvre une architecture hyperconvergée, les instances de VM node-1 et node-2 servent à la fois de nœuds WSFC et d'hébergement pour le stockage partagé. Une troisième instance de VM, witness, permet d'atteindre un quorum dans un scénario de basculement. Les trois instances de VM sont réparties dans trois zones et partagent un sous-réseau commun.

Les clients communiquent avec l'instance SQL Server via un équilibreur de charge TCP interne. Cet équilibreur de charge utilise une vérification d'état personnalisée pour déterminer quel nœud WSFC héberge actuellement l'instance SQL et achemine le trafic vers cette instance.

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.
Vérifier que le cluster fonctionne en simulant un basculement

Coûts

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

Utilisez le Simulateur de coût pour générer une estimation des coûts en fonction de votre utilisation prévue.

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.

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

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

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 la console Google Cloud, ouvrez Cloud Shell en cliquant sur le bouton Activer Cloud Shell .

Accédez à la console Google Cloud.
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 région par défaut :
```
gcloud config set compute/region REGION
```
Remplacez REGION par l'ID de la région 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 :

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 répondre aux exigences suivantes :

Elles sont situées dans la même région afin qu'elles soient accessibles par un équilibreur de charge TCP interne.
Leur agent invité est configuré pour utiliser le mode WSFC. Dans ce mode, l'agent invité ignore les adresses IP des équilibreurs de charge internes lors de la configuration de l'interface de réseau local. Ce comportement est nécessaire pour éviter les conflits d'adresses IP lors des événements de basculement WSFC.

Vous utilisez une image payante SQL Server sur laquelle SQL Server 2019 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 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. Sur les deux VM qui servent de nœuds S2D et WSFC, associez des disques de données supplémentaires et activez le mode WSFC en définissant la clé de métadonnées enable-wsfc sur true :

REGION=$(gcloud config get-value compute/region)
PD_SIZE=50
MACHINE_TYPE=n2-standard-8

gcloud compute instances create node-1 \
  --zone $REGION-a \
  --machine-type $MACHINE_TYPE \
  --subnet $SUBNET_NAME \
  --image-family sql-ent-2019-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" \
  --create-disk=name=node-1-datadisk-1,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --create-disk=name=node-1-datadisk-2,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --create-disk=name=node-1-datadisk-3,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --create-disk=name=node-1-datadisk-4,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --metadata enable-wsfc=true \
  --metadata-from-file=sysprep-specialize-script-ps1=specialize-node.ps1

gcloud compute instances create node-2 \
  --zone $REGION-b \
  --machine-type $MACHINE_TYPE \
  --subnet $SUBNET_NAME \
  --image-family sql-ent-2019-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" \
  --create-disk=name=node-2-datadisk-1,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --create-disk=name=node-2-datadisk-2,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --create-disk=name=node-2-datadisk-3,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --create-disk=name=node-2-datadisk-4,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --metadata enable-wsfc=true \
  --metadata-from-file=sysprep-specialize-script-ps1=specialize-node.ps1

gcloud compute instances create "witness" \
  --zone $REGION-c \
  --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 quelques minutes jusqu'à ce 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.

Réserver des adresses IP de cluster

Vous réservez maintenant deux adresses IP statiques dans votre réseau VPC. Les deux adresses ont des usages différents :

Adresse IP de l'équilibreur de charge : cette adresse IP est utilisée par les clients pour se connecter à SQL Server.
Adresse IP du cluster : cette adresse IP est utilisée uniquement en interne par WSFC.

Pour réserver les adresses IP statiques, procédez comme suit :

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 \
  --subnet $SUBNET_NAME \
  --region $(gcloud config get-value compute/region)

LOADBALANCER_ADDRESS=$(gcloud compute addresses describe wsfc \
  --region $(gcloud config get-value compute/region) \
  --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 :

gcloud compute addresses create wsfc-cluster \
  --subnet $SUBNET_NAME \
  --region $(gcloud config get-value compute/region) && \
CLUSTER_ADDRESS=$(gcloud compute addresses describe wsfc-cluster \
    --region $(gcloud config get-value compute/region) \
    --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 :
```
New-Cluster `
  -Name windows-fci `
  -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.

La commande crée un compte d'ordinateur windows-fci dans votre domaine Active Directory.

Revenez à la session PowerShell sur witness et accordez au compte d'ordinateur l'autorisation windows-fci pour accéder au partage de fichiers :

icacls C:\QWitness\ /grant 'windows-fci$:(OI)(CI)(M)'
Grant-SmbShareAccess `
  -Name QWitness `
  -AccountName 'windows-fci$' `
  -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:
```
Install-WindowsFeature RSAT-ADDS
Add-ADGroupMember `
  -Identity "Cloud Service Domain Join Accounts" `
  -Members windows-fci$
```

Activer les espaces de stockage direct

Vous allez maintenant activer S2D et créer un volume partagé de cluster qui combine les trois disques persistants que vous avez créés précédemment :

Revenez à la session PowerShell sur node-1.
Activez S2D :
```
Enable-ClusterStorageSpacesDirect
```
Si vous souhaitez optimiser les performances du disque, vous pouvez également ajouter des disques SSD locaux via une interface SCSI à vos nœuds S2D, en plus des disques persistants SSD standards. Les disques SSD locaux peuvent servir de couche de mise en cache S2D. Faites en sorte que le nombre de disques de capacité (disques persistants SSD, dans ce cas) soit un multiple du nombre de disques SSD locaux. Exécutez à la place la commande suivante pour activer S2D avec la mise en cache :
```
Enable-ClusterStorageSpacesDirect -CacheDeviceModel "EphemeralDisk"
```
Acceptez la valeur par défaut lorsque vous êtes invité à la confirmer. Vous pouvez voir des avertissements pouvant être ignorés en toute sécurité :
```
WARNING: 2021/04/08-13:12:26.159 Node node-1: No disks found to be used for cache
WARNING: 2021/04/08-13:12:26.159 Node node-2: No disks found to be used for cache
```
Vous pouvez également définir le cache en mémoire CSV (Cluster Shared Volume, volume partagé de cluster) sur 2 048 Mo pour un meilleur débit en lecture :
```
(Get-Cluster).BlockCacheSize = 2048
```

Créez un volume qui utilise les versions de volume partagé du cluster de ReFS et 64 Ko de l'espace du cluster :

New-Volume `
  -StoragePoolFriendlyName S2D* `
  -FriendlyName FciVolume `
  -FileSystem CSVFS_ReFS `
  -UseMaximumSize `
  -AllocationUnitSize 65536

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 > windows-fci > 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 --zone $REGION-a
```
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 > windows-fci.

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, faites un clic droit sur windows-fci dans le volet de gauche, puis sélectionnez Autres actions > Déplacer les ressources principales du cluster > Choisir nœud > node-1, puis cliquez sur OK.
Dans le volet de gauche, accédez à Gestionnaire du cluster de basculement > windows-fci > 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 :

Active Directory

$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

Managed Microsoft AD

$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 `
  -Path "OU=Cloud,DOMAIN"

Remplacez DOMAIN par le nom distinctif de votre domaine, par exemple DC=example,DC=org.

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 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 Clé de produit, conservez les valeurs par défaut et 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 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 pour le nom du réseau et l'instance nommée, 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, activez Disque virtuel de cluster (FciVolume) et désactivez tous les autres disques. Cliquez sur 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.

Votre domaine Active Directory contient désormais un compte d'ordinateur sql qui représente l'instance SQL Server, ainsi qu'une entrée DNS correspondante qui pointe vers l'adresse IP de l'équilibreur de charge interne.

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 deux groupes d'instances non gérés (un par zone), puis ajoutez les deux nœuds aux groupes :

gcloud compute instance-groups unmanaged create wsfc-group-1 --zone $REGION-a
gcloud compute instance-groups unmanaged add-instances wsfc-group-1 --zone $REGION-a \
  --instances node-1

gcloud compute instance-groups unmanaged create wsfc-group-2 --zone $REGION-b
gcloud compute instance-groups unmanaged add-instances wsfc-group-2 --zone $REGION-b \
  --instances 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 d'état teste le port 59997, qui est le port que vous avez précédemment configuré en tant que ProbePort pour la ressource d'adresse IP SQL Server.

Créez un service de backend et ajoutez les deux groupes d'instances :

gcloud compute backend-services create wsfc-backend \
  --load-balancing-scheme internal \
  --region $(gcloud config get-value compute/region) \
  --health-checks wsfc-healthcheck \
  --protocol tcp

gcloud compute backend-services add-backend wsfc-backend \
  --instance-group wsfc-group-1 \
  --instance-group-zone $REGION-a \
  --region $REGION

gcloud compute backend-services add-backend wsfc-backend \
  --instance-group wsfc-group-2 \
  --instance-group-zone $REGION-b \
  --region $REGION

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 $REGION \
  --backend-service wsfc-backend

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 \
  --zone $REGION-a \
  --machine-type n2-standard-2 \
  --subnet $SUBNET_NAME \
  --image-family sql-ent-2019-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 quelques minutes jusqu'à ce 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.
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 à l'aide du protocole TCP/IP et du nom DNS sql, puis interrogez la table dm_os_cluster_nodes :

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

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 --zone $REGION-a
```

Répétez la requête :

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

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.

Limites

Les espaces de stockage direct S2D ne sont compatibles qu'avec Windows Server 2016 et les versions ultérieures.
Avec S2D, chaque disque ne contient qu'une vue partielle des données. Par conséquent, effectuer un instantané d'un disque persistant ne sera pas suffisant pour assurer la sauvegarde de vos données. Utilisez plutôt une sauvegarde en SQL natif.

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 entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez é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.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Étape suivante

Découvrez comment configurer une instance de cluster de basculement SQL Server utilisant des disques persistants en mode écriture simultanée.