Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Configurer une instance de cluster de basculement SQL Server sur Linux avec un disque à écriture simultanée

Pour assurer la haute disponibilité de SQL Server dans deux zones distinctes de Compute Engine, vous pouvez déployer une instance de cluster de basculement (FCI) SQL Server sur Linux qui utilise des disques à écriture simultanée. Contrairement aux architectures sans partage traditionnelles, cette configuration vous permet d'associer simultanément des nœuds dans différentes zones au même disque. Ce guide explique comment déployer un FCI SQL Server à disponibilité élevée sur Linux dans Compute Engine en utilisant la réplication synchrone à faible latence de Google Cloud Hyperdisk.

Cette conception garantit que SQL Server reste disponible même en cas de panne de zone, ce qui est peu probable. La combinaison de Pacemaker pour l'orchestration de clusters et de la résilience multizone de Compute Engine fournit une solution robuste et hautes performances pour les charges de travail de bases de données critiques qui nécessitent la simplicité du stockage partagé.

Avantages de l'implémentation de la haute disponibilité avec des disques multi-écrivains

L'utilisation d'une FCI SQL Server avec des disques à écriture simultanée au lieu de groupes de disponibilité Always On (AG) sur Linux supprime la complexité de la gestion de plusieurs copies de données et la surcharge de synchronisation que les configurations AG entraînent.

Une architecture de volumes partagés est également plus efficace en termes de stockage que les architectures de groupes de disponibilité qui utilisent des répliques de données complètes sur chaque nœud. Les volumes partagés peuvent également réduire les coûts de disque dans les scénarios de mise en miroir.

Points clés de cette architecture

Redondance zonale : protection des données en cas de défaillance d'un nœud ou de panne zonale (ce qui est rare).
Gestion simplifiée : réduit la complexité de la gestion de plusieurs copies de données par rapport aux groupes de disponibilité Always On.
Efficacité du stockage : utilise un seul volume partagé pour les données et les journaux, optimisé grâce à la fonctionnalité multi-écrivain.
Orchestration Linux native : utilise des extensions à haute disponibilité (HAE) conformes aux normes du secteur pour un basculement fluide.

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. Google Cloud, en revanche, ignore les annonces ARP. Par conséquent, vous devez implémenter un équilibreur de charge interne (consultez la section Exécuter un clustering de basculement Windows Server).

Architecture

Dans cet article, nous partons du principe que vous possédez des connaissances de base sur SQL Server, Active Directory et Compute Engine.

Objectifs

Ce tutoriel vous explique comment effectuer les tâches suivantes, en vue d'atteindre votre objectif :

Créez un déploiement SQL Server sur Linux.
Créez, associez et configurez un disque à écriture simultanée.
Configurer le cluster Pacemaker.
Configurez l'équilibreur de charge.
Effectuez un test de basculement.

Coûts

Ce tutoriel fait appel à des composants payants de Google Cloud, y compris ceux-ci :

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

Avant de commencer

Pour ce tutoriel, vous avez besoin d'un projet Google Cloud . Vous pouvez en créer un ou sélectionner un projet existant :
1. Dans la console Google Cloud , sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud .
  Rôles requis pour sélectionner ou créer un projet
  - Sélectionnez un projet : la sélection d'un projet ne nécessite pas de rôle IAM spécifique. Vous pouvez sélectionner n'importe quel projet pour lequel un rôle vous a été attribué.
  - Créer un projet : pour créer un projet, vous devez disposer du rôle Créateur de projet (roles/resourcemanager.projectCreator), qui contient l'autorisation resourcemanager.projects.create. Découvrez comment attribuer des rôles.
  Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.
  
  Accéder au sélecteur de projet
2. Vérifiez que la facturation est activée pour votre projet Google Cloud .
3. Dans la console Google Cloud , activez Cloud Shell.
  
  Activer Cloud Shell

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éder à la console Google Cloud
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 les nœuds du cluster

Déployez deux VM en tant que nœuds de cluster et une troisième en tant que client dédié pour valider la connectivité et les performances de basculement.

Initialisez les variables suivantes qui seront utilisées pour les commandes restantes.

BOOT_DISK_SIZE=50
BOOT_IOPS=10000
BOOT_THROUGHPUT=400
DATA_IOPS=10000
DATA_THROUGHPUT=400
DATA_DISK_SIZE=200
REGION=$(gcloud config get-value compute/region)
ZONE1=$REGION-a
ZONE2=$REGION-b
SUBNET=SUBNET_NAME
MACHINE_TYPE=c3-standard-8
VPC_NAME=VPC_NAME

Créez deux disques régionaux : un pour les données et un autre pour le journal. Pour permettre aux deux instances d'accéder aux disques, activez le mode écriture simultanée pour les deux disques avec l'indicateur --access-mode=READ_WRITE_MANY.

gcloud compute disks create sqlfci-mw-data-disk \
--size=$DATA_DISK_SIZE \
--type=hyperdisk-balanced-high-availability \
--region=$REGION \
--replica-zones=$ZONE1,$ZONE2 \
--provisioned-iops=$DATA_IOPS \
--provisioned-throughput=$DATA_THROUGHPUT \
--access-mode=READ_WRITE_MANY

gcloud compute disks create sqlfci-mw-log-disk \
--size=$DATA_DISK_SIZE \
--type=hyperdisk-balanced-high-availability \
--region=$REGION \
--replica-zones=$ZONE1,$ZONE2 \
--provisioned-iops=$DATA_IOPS \
--provisioned-throughput=$DATA_THROUGHPUT \
--access-mode=READ_WRITE_MANY

Créez les VM Linux et associez-leur les disques en écriture simultanée que vous avez créés.

gcloud compute instances create node-1 \
--boot-disk-size=$BOOT_DISK_SIZE \
--boot-disk-type=hyperdisk-balanced \
--boot-disk-provisioned-iops=$BOOT_IOPS \
--boot-disk-provisioned-throughput=$BOOT_THROUGHPUT \
--zone $ZONE1 \
--machine-type $MACHINE_TYPE \
--subnet $SUBNET \
--image-family ubuntu-2204-lts \
--image-project ubuntu-os-cloud \
--disk="name=sqlfci-mw-data-disk,scope=regional,mode=rw" \
--disk="name=sqlfci-mw-log-disk,scope=regional,mode=rw" \
--scopes=compute-rw,trace,service-control,service-management,pubsub,monitoring-write,logging-write,storage-rw \
--tags=sqlfci

gcloud compute instances create node-2 \
--boot-disk-size=$BOOT_DISK_SIZE \
--boot-disk-type=hyperdisk-balanced \
--boot-disk-provisioned-iops=$BOOT_IOPS \
--boot-disk-provisioned-throughput=$BOOT_THROUGHPUT \
--zone $ZONE2 \
--machine-type $MACHINE_TYPE \
--subnet $SUBNET \
--image-family ubuntu-2204-lts \
--image-project ubuntu-os-cloud \
--disk="name=sqlfci-mw-data-disk,scope=regional,mode=rw" \
--disk="name=sqlfci-mw-log-disk,scope=regional,mode=rw" \
--scopes=compute-rw,trace,service-control,service-management,pubsub,monitoring-write,logging-write,storage-rw \
--tags=sqlfci

Créez la VM cliente Windows, cl-node, que vous utiliserez pour tester la connexion.

gcloud compute instances create cl-node \
--boot-disk-size=100 \
--boot-disk-type=hyperdisk-balanced \
--machine-type $MACHINE_TYPE \
--image-family windows-2025 \
--image-project windows-cloud \
--zone $ZONE1 \
--subnet $SUBNET \
--scopes=compute-rw,trace,service-control,service-management,pubsub,monitoring-write,logging-write,storage-rw

Créer un équilibreur de charge interne

Réservez une adresse IP pour le cluster et l'équilibreur de charge.

gcloud compute addresses create sqlfci-lb-ipaddress \
--region=$REGION \
--subnet=$SUBNET \
--purpose="SHARED_LOADBALANCER_VIP"
CLUSTER_ADDRESS=$(gcloud compute addresses describe sqlfci-lb-ipaddress \
--region $REGION \
--format=value\(address\)) && \
echo "Cluster IP address: $CLUSTER_ADDRESS"

Créez une vérification de l'état pour le cluster.

gcloud compute health-checks create tcp sqlfci-healthcheck \
--port="60008" \
--region=$REGION \
--check-interval=3 \
--timeout=2 \
--unhealthy-threshold=2 \
--healthy-threshold=5

Pour autoriser une connexion au port de vérification de l'état, créez une règle de pare-feu.

gcloud compute firewall-rules create "allow-sqlfci-healthcheck-60008" \
--allow "tcp:60008" \
--target-tags sqlfci \
--network $VPC_NAME \
--source-ranges="35.191.0.0/16,130.211.0.0/22" \
--priority="1000"

Pour en savoir plus, consultez la section Règles de pare-feu pour les vérifications d'état.

Créez des groupes d'instances pour les nœuds du cluster.

gcloud compute instance-groups unmanaged create sqlfci-1-uig \
--zone=$ZONE1
gcloud compute instance-groups unmanaged add-instances sqlfci-1-uig \
--zone=$ZONE1 \
--instances=node-1

gcloud compute instance-groups unmanaged create sqlfci-2-uig \
--zone=$ZONE2
gcloud compute instance-groups unmanaged add-instances sqlfci-2-uig \
--zone=$ZONE2 \
--instances=node-2

Créez le service de backend de l'équilibreur de charge.

gcloud compute backend-services create sqlfci-backend-services \
--region=$REGION \
--load-balancing-scheme="INTERNAL" \
--protocol="TCP" \
--health-checks=sqlfci-healthcheck \
--health-checks-region=$REGION

gcloud compute backend-services add-backend sqlfci-backend-services \
--region=$REGION \
--instance-group=sqlfci-1-uig \
--instance-group-zone=$ZONE1

gcloud compute backend-services add-backend sqlfci-backend-services \
--region=$REGION \
--instance-group=sqlfci-2-uig \
--instance-group-zone=$ZONE2

Créez la règle de transfert de l'équilibreur de charge.

gcloud compute forwarding-rules create "sqlfci-forwarding-rule" \
--load-balancing-scheme=INTERNAL \
--network=$VPC_NAME \
--subnet=$SUBNET \
--region=$REGION \
--address=$CLUSTER_ADDRESS \
--ip-protocol="TCP" \
--ports="ALL" \
--backend-service=sqlfci-backend-services \
--backend-service-region=$REGION

Créez un bucket Cloud Storage pour transférer des fichiers des nœuds de cluster principal vers les nœuds de cluster secondaire.
```
gcloud storage buckets create gs://BUCKET_NAME \
--location=$REGION \
--public-access-prevention
```
Remplacez BUCKET_NAME par le nom du bucket à créer.

Pour en savoir plus, consultez Créer des buckets.

Installer les logiciels nécessaires

Téléchargez, installez et configurez le moteur SQL Server et la gestion du cluster sur les deux VM Linux, node-1 et node-2, qui participeront au cluster de basculement.

Connectez-vous à chacune de vos VM à l'aide de SSH. Pour en savoir plus, consultez Se connecter à des VM Linux et Bonnes pratiques pour contrôler l'accès au réseau via SSH.
Mettez à jour hosts file sur node-1 et node-2.

Remarque : Pour une utilisation en production, la résolution de domaine doit être gérée par un serveur DNS (Domain Name System) dédié.
1. Ouvrez hosts file pour le modifier.
```
sudo vi /etc/hosts
```
2. Recherchez l'adresse IP interne de chaque VM Linux et ajoutez les entrées d'hôte en bas du fichier.
  
  Accéder à Compute Engine
```
NODE1_INTERNAL_IP node-1
NODE2_INTERNAL_IP node-2
```
  Remplacez NODE1_INTERNAL_IP et NODE2_INTERNAL_IP par l'adresse IP interne de chaque VM Linux.

Vérifiez la communication entre vos VM. Toutes les VM participant au groupe de disponibilité Always On doivent pouvoir communiquer avec d'autres VM : Revenez à chaque VM Linux, exécutez les commandes à partir de chaque VM et vérifiez que toutes les VM peuvent communiquer entre elles.

ping -c 4 node-1
ping -c 4 node-2

La sortie se présente comme suit :

PING node-1 (10.128.0.37) 56(84) bytes of data.
64 bytes from node-1 (10.128.0.37): icmp_seq=1 ttl=128 time=1.91 ms
64 bytes from node-1 (10.128.0.37): icmp_seq=2 ttl=128 time=0.234 ms
64 bytes from node-1 (10.128.0.37): icmp_seq=3 ttl=128 time=0.249 ms
64 bytes from node-1 (10.128.0.37): icmp_seq=4 ttl=128 time=0.263 ms

Installez SQL Server 2025.

Ajoutez le dépôt SQL Server au système.

curl https://packages.microsoft.com/keys/microsoft.asc | sudo tee /etc/apt/trusted.gpg.d/microsoft.asc
curl -fsSL https://packages.microsoft.com/config/ubuntu/22.04/mssql-server-2025.list | sudo tee /etc/apt/sources.list.d/mssql-server-2025.list
sudo apt-get update

Installez SQL Server.
```
sudo apt-get install -y mssql-server
```

Installez les outils pour les développeurs SQL Server. Téléchargez et installez les outils SQL Server sur les deux VM Linux qui participeront au cluster de basculement.

curl https://packages.microsoft.com/config/ubuntu/22.04/prod.list | sudo tee /etc/apt/sources.list.d/mssql-release.list
sudo apt-get update

sudo ACCEPT_EULA=Y apt-get install -y mssql-tools18 unixodbc-dev

Installez Pacemaker. Pacemaker est un logiciel de gestion des ressources à haute disponibilité Open Source, utilisé avec le moteur de cluster Corosync. Dans cette section, vous allez installer Pacemaker sur les deux VM du cluster.
1. Installez Pacemaker sur node-1 et node-2.
```
sudo apt-get install -y pacemaker pcs fence-agents resource-agents pacemaker-cli-utils crmsh
```
2. Installez l'agent de ressources SQL Server pour Pacemaker.
```
sudo apt-get install -y mssql-server-ha
```
Si un pare-feu est activé sur vos VM, ouvrez-le pour SQL Server.
1. Vérifiez si Uncomplicated Firewall est installé et activé en exécutant la commande suivante.
```
sudo ufw status
```
2. Si l'état est "active" (actif), exécutez les commandes suivantes pour ouvrir les ports. Si le service de pare-feu n'est pas en cours d'exécution, vous pouvez ignorer cette étape.
```
sudo ufw allow 1433
sudo ufw allow 5022
sudo ufw reload
```
  Remarque : Si vous utilisez d'autres ports pour SQL Server ou pour votre point de terminaison de groupe de disponibilité, modifiez les règles de pare-feu en conséquence.

Configurer le nœud de base de données principal

Dans cette section, vous allez initialiser les deux disques en écriture simultanée et configurer chaque disque avec des groupes de volumes et des groupes logiques.

Configurez le LVM.

Configurez les paramètres LVM.

Sauvegardez la configuration existante.

sudo cp /etc/lvm/lvm.conf /etc/lvm/lvm.conf.bak

Mettre à jour la source de l'ID système :

sudo sed -i 's/^\(\s*system_id_source\s*=\s*\)"none"/\1"uname"/' /etc/lvm/lvm.conf

Vérifiez que la modification a bien été effectuée.

grep 'system_id_source *= *"uname"' /etc/lvm/lvm.conf

Configurez les groupes de volumes et les volumes logiques LVM.

sudo pvcreate /dev/nvme0n2 /dev/nvme0n3
sudo pvs
sudo vgcreate vgdata /dev/nvme0n2
sudo lvcreate -l 100%FREE -n lvdata vgdata
sudo vgcreate vglogtmp /dev/nvme0n3
sudo lvcreate -l 70%FREE  -n lvlog vglogtmp
sudo lvcreate -l 100%FREE -n lvtmp vglogtmp
sudo vgs -o+systemid

Formatez les volumes avec le système de fichiers xfs et une taille de bloc de 64 Ko.

sudo mkfs.xfs -d su=64k,sw=1 -L data /dev/vgdata/lvdata -f
sudo mkfs.xfs -d su=64k,sw=1 -L dblog /dev/vglogtmp/lvlog -f
sudo mkfs.xfs -d su=64k,sw=1 -L tmp /dev/vglogtmp/lvtmp -f

Vérifiez que les volumes ont été créés.
```
sudo lvs
```

Installer et formater les disques

Configurez les points de montage pour les disques partagés et accordez l'accès à l'utilisateur mssql.

Créez des points de montage pour les nouveaux volumes.

sudo mkdir /mssql
sudo mkdir -p /mssql/db_data
sudo mkdir -p /mssql/db_log
sudo mkdir -p /mssql/db_temp

Montez les volumes LVM sur des points de montage.

sudo mount /dev/vgdata/lvdata /mssql/db_data
sudo mount /dev/vglogtmp/lvlog /mssql/db_log
sudo mount /dev/vglogtmp/lvtmp /mssql/db_temp

Définissez l'utilisateur mssql comme propriétaire des points de montage.

sudo chown mssql:mssql /mssql/db_data
sudo chown mssql:mssql /mssql/db_log
sudo chown mssql:mssql /mssql/db_temp

Configurer SQL Server :
1. Définissez les variables en déplaçant la base de données maître vers le stockage partagé, puis exécutez l'outil mssql-conf.
```
sudo MSSQL_MASTER_DATA_FILE="/mssql/db_data/master.mdf" MSSQL_MASTER_LOG_FILE="/mssql/db_data/mastlog.ldf" /opt/mssql/bin/mssql-conf setup
```
2. Choisissez l'édition Developer pour l'édition SQL Server et acceptez le contrat de licence.
  
  L'édition pour développeur inclut toutes les fonctionnalités pour les entreprises, mais vous ne pouvez l'utiliser que pour les environnements hors production. Pour en savoir plus, consultez les pages Éditions SQL Server et Licences Microsoft.
  
  Remarque : Une licence SQL Server est requise pour chaque instance de VM. Si vous exécutez des serveurs d'applications Microsoft, la mobilité des licences via Software Assurance vous aide à effectuer la transition vers Google Cloud. Pour en savoir plus, consultez Utiliser License Mobility avec les applications serveur Microsoft. Si vous n'apportez pas votre propre licence et que vous devez en acheter une via Google (PAYG), suivez la procédure décrite dans la section Ajouter une licence SQL Server à un disque de démarrage pour vous assurer d'acheter une licence pour chaque instance de VM.
3. Spécifiez un mot de passe pour le compte SA.
4. Vérifiez que le service mssql-server est en cours d'exécution.
```
systemctl status mssql-server --no-pager
```

Configurer SQL Server et Pacemaker

Créez un utilisateur SQL Server pour Pacemaker. Remplacez SA_PASSWORD par le mot de passe du compte SA sur SQL Server et PA_PASSWORD par le mot de passe qui sera utilisé pour le compte pacemaker.

QUERY="
CREATE LOGIN [pacemaker] with PASSWORD= N'PA_PASSWORD';
ALTER SERVER ROLE [sysadmin] ADD MEMBER [pacemaker];
GO"

/opt/mssql-tools18/bin/sqlcmd -No -S localhost -U sa -P 'SA_PASSWORD' -Q "$QUERY"

Ajoutez les identifiants de connexion et le mot de passe Pacemaker au dossier des secrets SQL Server.

{
  echo 'pacemaker'
  echo PA_PASSWORD'
} | sudo tee /var/opt/mssql/secrets/passwd > /dev/null
sudo chown root:root /var/opt/mssql/secrets/passwd
sudo chmod 400 /var/opt/mssql/secrets/passwd

Mettez à jour la configuration SQL Server pour utiliser les nouveaux emplacements de données, de journaux et temporaires. Vous allez également définir les paramètres recommandés de SQL Server.

sudo /opt/mssql/bin/mssql-conf set filelocation.defaultdatadir /mssql/db_data
sudo /opt/mssql/bin/mssql-conf set filelocation.defaultlogdir /mssql/db_log
sudo /opt/mssql/bin/mssql-conf set filelocation.defaultdumpdir /mssql/db_log
sudo /opt/mssql/bin/mssql-conf traceflag 9944 3979 on
sudo /opt/mssql/bin/mssql-conf set control.alternatewritethrough 0
sudo /opt/mssql/bin/mssql-conf set control.writethrough 1

Déplacer TempDB vers un disque partagé

Obtenez la liste des fichiers TempDB et utilisez-les pour créer une requête Alter. Cette requête sera utilisée à l'étape suivante pour définir le nouvel emplacement des fichiers TempDB.

QUERY="
SET NOCOUNT ON;
SELECT 'ALTER DATABASE tempdb MODIFY FILE (NAME = [' + f.name + '],' + ' FILENAME = ''/mssql/db_temp/' + f.name + CASE WHEN f.type = 1 THEN '.ldf' ELSE '.mdf' END + ''');' FROM sys.master_files f WHERE f.database_id = DB_ID(N'tempdb');"

/opt/mssql-tools18/bin/sqlcmd -No -S localhost -U sa -P 'SA_PASSWORD' -Q "$QUERY"

Capturez le résultat de la commande précédente. Vous utiliserez la sortie pour former la prochaine commande à exécuter.

QUERY="QUERY_OUTPUT"

Exemple de requête utilisant la sortie :

QUERY="
ALTER DATABASE tempdb MODIFY FILE (NAME = [tempdev], FILENAME = '/mssql/db_temp/tempdev.mdf');
ALTER DATABASE tempdb MODIFY FILE (NAME = [templog], FILENAME = '/mssql/db_temp/templog.ldf');
ALTER DATABASE tempdb MODIFY FILE (NAME = [tempdev2], FILENAME = '/mssql/db_temp/tempdev2.mdf');
ALTER DATABASE tempdb MODIFY FILE (NAME = [tempdev3], FILENAME = '/mssql/db_temp/tempdev3.mdf');"

Exécutez la commande SQL générée pour déplacer les fichiers TempDB.

/opt/mssql-tools18/bin/sqlcmd -No -S localhost -U sa -P 'SA_PASSWORD' -Q "$QUERY"

Redémarrez le service SQL Server pour que les modifications prennent effet.
```
sudo systemctl restart mssql-server.service
```
Vérifiez que les fichiers TempDB ont été créés.
```
ls -l /mssql/db_temp/
```
Vérifiez que le service SQL Server est en cours d'exécution.
```
systemctl status mssql-server --no-pager
```

Configurer HAProxy

Définissez un nouveau mot de passe pour hacluster.

Remarque : Définissez le même mot de passe sur les trois nœuds. Vous en aurez besoin pour configurer le cluster.
```
sudo passwd hacluster
```
Pour terminer la configuration et vérifier si votre équilibreur de charge réseau est correctement configuré, installez et configurez HAProxy tcp listener sur les deux nœuds du cluster :
1. Installez HAProxy.
```
sudo apt-get install haproxy
```
2. Saisissez Y pour terminer l'installation.
3. Modifiez le fichier haproxy.cfg.
```
sudo vi /etc/haproxy/haproxy.cfg
```
4. Dans la section defaults du fichier haproxy.cfg file, remplacez le mode par tcp.
5. Ajoutez la section suivante à la fin du fichier haproxy.cfg.
```
#---------------------------------------------------------------
# Set up health check listener for SQL Server Availability Group
#---------------------------------------------------------------
listen healthcheck
bind *:60008
```

Démarrez le service HAProxy.

sudo systemctl start haproxy.service
sudo systemctl status haproxy.service

Arrêtez et désactivez le service HAProxy.

sudo systemctl stop haproxy.service
sudo systemctl disable haproxy.service

Importez le fichier de clé machine dans Cloud Storage à l'aide de la commande suivante.
```
sudo gcloud storage cp /var/opt/mssql/secrets/machine-key gs://BUCKET_NAME/
```
Remplacez BUCKET_NAME par le nom du bucket.
Arrêtez et désactivez le service SQL Server. À partir de ce moment, le service sera contrôlé par le cluster.
```
sudo systemctl stop mssql-server.service
sudo systemctl disable mssql-server.service
```

Désinstallez l'espace de stockage partagé.

sudo umount /mssql/db_data
sudo umount /mssql/db_log
sudo umount /mssql/db_temp

Nettoyez la configuration de cluster par défaut existante.
```
sudo pcs cluster destroy
```

Configurer le nœud secondaire

Créez des points de montage pour les volumes LVM. Vous n'avez pas besoin de formater le disque, car il est partagé avec node-1. Vous avez déjà formaté le disque et configuré les volumes LVM lorsque vous avez configuré node-1.
```
sudo mkdir /mssql
sudo mkdir -p /mssql/db_data
sudo mkdir -p /mssql/db_log
sudo mkdir -p /mssql/db_temp

sudo chown mssql:mssql /mssql/db_data
sudo chown mssql:mssql /mssql/db_log
sudo chown mssql:mssql /mssql/db_temp
```
Configurez SQL Server.
1. Pour déplacer la base de données principale vers le disque de données partagé, définissez les variables suivantes, puis exécutez l'outil mssql-conf pour appliquer les modifications.
```
sudo MSSQL_MASTER_DATA_FILE="/mssql/db_data/master.mdf" MSSQL_MASTER_LOG_FILE="/mssql/db_data/mastlog.ldf" /opt/mssql/bin/mssql-conf setup
```
2. Choisissez l'édition Developer pour l'édition SQL Server et acceptez le contrat de licence.
  
  L'édition pour développeur inclut toutes les fonctionnalités pour les entreprises, mais vous ne pouvez l'utiliser que pour les environnements hors production. Pour en savoir plus, consultez les pages Éditions SQL Server et Licences Microsoft.
  
  Remarque : Vous avez besoin d'une licence SQL Server pour chaque instance. Si vous exécutez des serveurs d'applications Microsoft, la mobilité des licences via Software Assurance vous aide à effectuer la transition vers Google Cloud. Pour en savoir plus, consultez Utiliser License Mobility avec les applications serveur Microsoft. Si vous n'apportez pas votre propre licence et que vous devez en acheter une via Google (PAYG), suivez la procédure décrite dans la section Ajouter une licence SQL Server à un disque de démarrage pour vous assurer d'acheter une licence pour chaque instance de VM.
3. Spécifiez un mot de passe pour le compte SA.
4. Vérifiez que le service mssql-server est en cours d'exécution.
```
systemctl status mssql-server --no-pager
```

Créez un utilisateur SQL Server pour le cluster Pacemaker. Remplacez SA_PASSWORD par le mot de passe du compte SA sur SQL Server et PA_PASSWORD par le mot de passe qui sera utilisé pour le compte pacemaker.

QUERY="
CREATE LOGIN [pacemaker] with PASSWORD= N'PA_PASSWORD';
ALTER SERVER ROLE [sysadmin] ADD MEMBER [pacemaker];
GO"

/opt/mssql-tools18/bin/sqlcmd -No -S localhost -U sa -P 'SA_PASSWORD' -Q "$QUERY"

Ajoutez les identifiants de connexion et le mot de passe Pacemaker au dossier des secrets SQL Server.

{
  echo 'pacemaker'
  echo 'PA_PASSWORD'
} | sudo tee /var/opt/mssql/secrets/passwd > /dev/null
sudo chown root:root /var/opt/mssql/secrets/passwd
sudo chmod 400 /var/opt/mssql/secrets/passwd

Mettez à jour la configuration de SQL Server pour utiliser les nouveaux emplacements de données, de journaux et temporaires. Vous définirez également les paramètres SQL Server recommandés.

sudo /opt/mssql/bin/mssql-conf set filelocation.defaultdatadir /mssql/db_data
sudo /opt/mssql/bin/mssql-conf set filelocation.defaultlogdir /mssql/db_log
sudo /opt/mssql/bin/mssql-conf set filelocation.defaultdumpdir /mssql/db_log
sudo /opt/mssql/bin/mssql-conf traceflag 9944 3979 on
sudo /opt/mssql/bin/mssql-conf set control.alternatewritethrough 0
sudo /opt/mssql/bin/mssql-conf set control.writethrough 1

Déplacez TempDB vers le disque de données partagé.

Obtenez la liste des fichiers TempDB et utilisez-les pour créer la requête Alter.

QUERY="
SET NOCOUNT ON;
SELECT 'ALTER DATABASE tempdb MODIFY FILE (NAME = [' + f.name + '],' + ' FILENAME = ''/mssql/db_temp/' + f.name + CASE WHEN f.type = 1 THEN '.ldf' ELSE '.mdf' END + ''');' FROM sys.master_files f WHERE f.database_id = DB_ID(N'tempdb');"

/opt/mssql-tools18/bin/sqlcmd -No -S localhost -U sa -P 'SA_PASSWORD' -Q "$QUERY"

Capturez le résultat de la commande précédente. Vous utiliserez la sortie pour former la prochaine commande à exécuter.

QUERY="QUERY_OUTPUT"

Exemple de requête utilisant la sortie :

QUERY="
ALTER DATABASE tempdb MODIFY FILE (NAME = [tempdev], FILENAME = '/mssql/db_temp/tempdev.mdf');
ALTER DATABASE tempdb MODIFY FILE (NAME = [templog], FILENAME = '/mssql/db_temp/templog.ldf');
ALTER DATABASE tempdb MODIFY FILE (NAME = [tempdev2], FILENAME = '/mssql/db_temp/tempdev2.mdf');
ALTER DATABASE tempdb MODIFY FILE (NAME = [tempdev3], FILENAME = '/mssql/db_temp/tempdev3.mdf');"

Pour déplacer les fichiers TempDB, exécutez la commande SQL générée.

/opt/mssql-tools18/bin/sqlcmd -No -S localhost -U sa -P 'SA_PASSWORD' -Q "$QUERY"

Pour que les modifications prennent effet, redémarrez le service SQL Server.
```
sudo systemctl restart mssql-server.service
```
Vérifiez que le service SQL Server est en cours d'exécution.
```
sudo systemctl status mssql-server --no-pager
```
Vérifiez que les fichiers TempDB ont été créés.
```
ls -l /mssql/db_temp/
```

Arrêtez et désactivez temporairement le service SQL Server.

sudo systemctl stop mssql-server.service
sudo systemctl disable mssql-server.service

Pour vous assurer que les deux nœuds utilisent la même clé pour SQL Server, téléchargez le fichier de clé de la machine depuis node-1.

sudo rm /var/opt/mssql/secrets/machine-key
sudo gcloud storage cp gs://BUCKET_NAME/machine-key /var/opt/mssql/secrets/machine-key
sudo chown mssql:mssql /var/opt/mssql/secrets/machine-key
sudo chmod 0600  /var/opt/mssql/secrets/machine-key

Configurez les paramètres LVM.

Sauvegardez la configuration existante.

sudo cp /etc/lvm/lvm.conf /etc/lvm/lvm.conf.bak

Mettez à jour la source de l'ID système.

sudo sed -i 's/^\(\s*system_id_source\s*=\s*\)"none"/\1"uname"/' /etc/lvm/lvm.conf

Vérifiez la modification en exécutant la commande suivante :

cat /etc/lvm/lvm.conf | grep uname

La sortie se présente comme suit :

#     Set the system ID from the hostname (uname) of the system.
system_id_source = "uname"

Vérifiez que la modification a bien été effectuée.

grep 'system_id_source *= *"uname"' /etc/lvm/lvm.conf

Définissez un nouveau mot de passe pour hacluster.

Remarque : Définissez le même mot de passe sur les deux nœuds. Vous en aurez besoin lors de la configuration du cluster.
```
sudo passwd hacluster
```
Pour terminer la configuration et vérifier si votre équilibreur de charge réseau est correctement configuré, installez et configurez HAProxy tcp listener sur les deux nœuds du cluster.
1. Installez HAProxy.
```
sudo apt-get install haproxy
```
2. Choisissez Y pour terminer l'installation.
3. Modifiez le fichier haproxy.cfg.
```
sudo vi /etc/haproxy/haproxy.cfg
```
4. Dans la section defaults du fichier haproxy.cfg file, remplacez le mode par tcp.
5. Ajoutez la section suivante à la fin du fichier haproxy.cfg.
```
#---------------------------------------------------------------
# Set up health check listener for SQL Server Availability Group
#---------------------------------------------------------------
listen healthcheck
bind *:60008
```
6. Démarrez le service HAProxy.
```
sudo systemctl start haproxy.service
sudo systemctl status haproxy.service
```

Arrêtez et désactivez le service HAProxy.

sudo systemctl stop haproxy.service
sudo systemctl disable haproxy.service

Nettoyez la configuration de cluster par défaut existante.
```
sudo pcs cluster destroy
```

Terminer la configuration du cluster

Revenez à node-1 pour poursuivre la configuration du cluster.

Authentifiez-vous en tant qu'utilisateur hacluster.

sudo pcs host auth node-1 node-2 -u hacluster -p "HA_PASSWORD"

Créez un cluster appelé ubuntu_fci.

sudo pcs cluster setup ubuntu_fci node-1 addr="NODE1_INTERNAL_IP" node-2 addr="NODE2_INTERNAL_IP" --start --enable

Définissez la stratégie de non-quorum pour un cluster à deux nœuds.
```
sudo pcs property set no-quorum-policy="ignore"
```

Créez une ressource de cluster d'adresse IP virtuelle.

sudo pcs resource create pcs-cluster-vip ocf:heartbeat:IPaddr2 ip="CLUSTER_ADDRESS" cidr_netmask=32 nic=ens3 op monitor interval=30s

Remplacez CLUSTER_ADDRESS par l'adresse IP réservée précédemment.

Créez des objets de ressources de cluster pour tous les volumes partagés.

sudo pcs resource create vgdata ocf:heartbeat:LVM-activate vgname=vgdata vg_access_mode=system_id activation_mode=exclusive
sudo pcs resource create vglogtmp ocf:heartbeat:LVM-activate vgname=vglogtmp vg_access_mode=system_id activation_mode=exclusive
sudo pcs resource create data_dir ocf:heartbeat:Filesystem device="/dev/mapper/vgdata-lvdata" directory="/mssql/db_data" fstype="xfs"
sudo pcs resource create log_dir ocf:heartbeat:Filesystem device="/dev/mapper/vglogtmp-lvlog" directory="/mssql/db_log" fstype="xfs"
sudo pcs resource create tmp_dir ocf:heartbeat:Filesystem device="/dev/mapper/vglogtmp-lvtmp" directory="/mssql/db_temp" fstype="xfs"

Créez un groupe de ressources et ajoutez-y tous les objets créés.

sudo pcs resource group add sql_group pcs-cluster-vip vgdata vglogtmp data_dir log_dir tmp_dir

Créez la ressource de cluster pour le service Microsoft SQL Server et ajoutez-la au groupe de ressources existant.
```
sudo pcs resource create sql_fci ocf:mssql:fci  op stop timeout=60s --group sql_group
```

Créez une ressource de cluster pour HAProxy et ajoutez-la au même groupe.

sudo pcs resource create pcs-healthcheck systemd:haproxy.service op monitor interval=20s timeout=30s --group sql_group

Créez une contrainte de cluster qui contrôle la séquence de démarrage des ressources.

sudo pcs constraint order set  pcs-cluster-vip vgdata vglogtmp data_dir log_dir tmp_dir sql_fci pcs-healthcheck

Configurer un cloisonnement STONITH

STONITH est une stratégie de cloisonnement permettant de préserver l'intégrité des nœuds dans un cluster à haute disponibilité. Le service STONITH fonctionne au niveau du nœud et protège le cluster des nœuds qui ne répondent pas ou dont l'état est inconnu. Nous vous recommandons le dispositif de clôture fence_gce spécialisé pour Compute Engine sur Google Cloud.

Configurer des appareils de cloisonnement

Vérifiez si l'agent de cloisonnement fence_gce pour Compute Engine est installé sur node-1.
```
sudo pcs stonith list | grep fence_gce
```
Pour en savoir plus, consultez :
- Agent de cloisonnement pour Google Compute Engine
- Pour afficher les paramètres associés à l'agent, exécutez la commande suivante :
```
sudo pcs stonith describe fence_gce
```

Configurez les ressources de cloisonnement du cluster.

sudo pcs stonith create node-1-fence fence_gce \
plug=node-1 \
zone=ZONE1 \
project=PROJECT_ID \
pcmk_reboot_timeout=300 pcmk_monitor_retries=4 pcmk_delay_max=30 \
op monitor interval="300s" timeout="120s" \
op start interval="0" timeout="60s"

sudo pcs stonith create node-2-fence fence_gce \
plug=node-2 \
zone=ZONE2 \
project=PROJECT_ID \
pcmk_reboot_timeout=300 pcmk_monitor_retries=4 pcmk_delay_max=30 \
op monitor interval="300s" timeout="120s" \
op start interval="0" timeout="60s"

Remplacez ZONE1 et ZONE2 par la zone dans laquelle les VM Linux sont déployées, et remplacez PROJECT_ID par l'ID de votre projet.

Vous pouvez tester l'état des agents de mise en quarantaine en exécutant la commande status.
```
sudo fence_gce -o status -n node-1 --zone=ZONE1
sudo fence_gce -o status -n node-2 --zone=ZONE2
```
La sortie se présente comme suit :
```
Status: ON
```

Remplacez ZONE1 et ZONE2 par la zone dans laquelle les VM Linux sont déployées.

Créez des contraintes d'emplacement pour vos appareils de cloisonnement afin de vous assurer qu'ils ne s'exécutent que sur les instances prévues.
```
sudo pcs constraint location node-1-fence avoids node-1
sudo pcs constraint location node-2-fence avoids node-2
```
Activez le cloisonnement dans votre cluster pacemaker et définissez le délai avant cloisonnement du cluster.
```
sudo pcs -f stonith_cfg property set stonith-enabled=true
sudo pcs property set stonith-timeout="300s"
```
Nettoyez le processus de démarrage du cluster.
```
sudo pcs resource cleanup
```

Vérifiez l'état du cluster.

sudo crm status

La sortie se présente comme suit :

  Cluster Summary:
    * Stack: corosync
    * Current DC: node-1 (version 2.1.2-ada5c3b36e2) - partition with quorum
    * Last updated: Tue Jun  2 21:36:47 2026
    * Last change:  Mon Apr 27 12:31:58 2026 by root via crm_resource on node-1
    * 2 nodes configured
    * 10 resource instances configured

  Node List:
    * Online: [ node-1 node-2 ]

  Full List of Resources:
    * Resource Group: sql_group:
      * pcs-cluster-vip   (ocf:heartbeat:IPaddr2):         Started node-2
      * vgdata    (ocf:heartbeat:LVM-activate):    Started node-2
      * vglogtmp  (ocf:heartbeat:LVM-activate):    Started node-2
      * data_dir  (ocf:heartbeat:Filesystem):      Started node-2
      * log_dir   (ocf:heartbeat:Filesystem):      Started node-2
      * tmp_dir   (ocf:heartbeat:Filesystem):      Started node-2
      * sql_fci   (ocf:mssql:fci):                 Started node-2
      * pcs-healthcheck   (systemd:haproxy.service):       Started node-2
    * node-1-fence       (stonith:fence_gce):     Started node-2
    * node2-fence        (stonith:fence_gce):     Started node-1

Tester les appareils de cloisonnement

Une fois les appareils de cloisonnement configurés, nous vous recommandons de les tester en suivant la procédure ci-dessous.

Arrêtez le cloisonnement sur node-2.

Connectez-vous à node-1 et exécutez la commande suivante pour tester l'appareil de cloisonnement associé à node-2 à partir de votre cluster.
```
fence_gce -o off -n node-2 --zone=ZONE2
```
La sortie se présente comme suit :
```
Success: Powered OFF
```
Vérifiez l'état du cluster.
```
sudo crm status
```
La sortie se présente comme suit :

    Cluster Summary:
      * Stack: corosync
      * Current DC: node-1 (version 2.1.2-ada5c3b36e2) - partition with quorum
      * Last updated: Tue Jun  2 21:52:00 2026
      * Last change:  Mon Apr 27 12:31:58 2026 by root via crm_resource on node-1
      * 2 nodes configured
      * 10 resource instances configured

    Node List:
      * Online: [ node-1 ]
      * OFFLINE: [ node-2 ]

    Full List of Resources:
      * Resource Group: sql_group:
        * pcs-cluster-vip   (ocf:heartbeat:IPaddr2): Started node-1
        * vgdata    (ocf:heartbeat:LVM-activate):    Started node-1
        * vglogtmp  (ocf:heartbeat:LVM-activate):    Started node-1
        * data_dir  (ocf:heartbeat:Filesystem):      Started node-1
        * log_dir   (ocf:heartbeat:Filesystem):      Started node-1
        * tmp_dir   (ocf:heartbeat:Filesystem):      Started node-1
        * sql_fci   (ocf:mssql:fci):                 Started node-1
        * pcs-healthcheck   (systemd:haproxy.service):       Started node-1
      * node-1-fence       (stonith:fence_gce):     Stopped
      * node-2-fence        (stonith:fence_gce):     Started node-1

Vous verrez également que node-2 est désactivé dans Compute Engine.

Accéder à Compute Engine

Redémarrez le cloisonnement sur node-2.
1. Revenez à node-1 et redémarrez à nouveau l'instance en exécutant la commande suivante.
```
fence_gce -o on -n node-2 --zone=ZONE2
```
  La sortie se présente comme suit :
```
Success: Powered ON
```
2. Vérifiez l'état du cluster dans Pacemaker et Compute Engine. Au bout de quelques instants, vous verrez que node-2 est de nouveau en ligne.
```
 $ sudo crm status
```

Tester le basculement

Vous êtes maintenant prêt à tester si le basculement fonctionne comme prévu.

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.
Connectez-vous à la VM Windows sur cl-node via le Bureau à distance.
Ouvrez une session PowerShell.

Connectez-vous au serveur en exécutant le script suivant. Toutes les cinq secondes, le script se connecte à SQL Server à l'aide de l'écouteur du groupe de disponibilité et interroge le nom du serveur.

while ($True){
  try {
    $Conn = New-Object System.Data.SqlClient.SqlConnection
    $Conn.ConnectionString = "Server=CLUSTER_ADDRESS;User ID=sa;Password=SA_PASSWORD;Initial Catalog=master"
    $Conn.Open()

    $Cmd =  $Conn.CreateCommand()
    $Cmd.CommandText = "SELECT SERVERPROPERTY('ComputerNamePhysicalNetBIOS')"

    $Result = $Cmd.ExecuteReader()
    if ($Result.Read()) {
      $currentNode = $Result.GetString(0)
      Write-Host "Current Node: $currentNode at $(Get-Date)"
    }

    $Conn.Close()
    Start-Sleep -Seconds 5
  }
  catch {
      Write-Host "SQL Connection Failed at $(Get-Date). Retrying..."
      Start-Sleep -Seconds 15 # Wait before retrying
  }
}

Remplacez CLUSTER_ADDRESS par l'adresse IP de l'écouteur et SA_PASSWORD par le mot de passe du compte SA sur SQL Server.

La sortie se présente comme suit :

  Current Node: node-1 at 06/09/2026 20:24:35
  Current Node: node-1 at 06/09/2026 20:24:40
  Current Node: node-1 at 06/09/2026 20:24:45
  Current Node: node-1 at 06/09/2026 20:24:50
  Current Node: node-1 at 06/09/2026 20:24:55

Laissez le script s'exécuter.

Déclenchez un basculement vers node-2 : à partir de node-1, revenez au terminal SSH et exécutez la commande suivante.
```
sudo pcs resource move sql_group node-2
```

Revenez à la session PowerShell sur cl-node.

Observez la sortie du script en cours d'exécution et notez que le nom du serveur passe de node-1 à node-2 suite au basculement.

La sortie se présente comme suit :

  Current Node: node-1 at 06/09/2026 20:28:51
  Current Node: node-1 at 06/09/2026 20:28:56
  SQL Connection Failed at 06/09/2026 20:29:16. Retrying...
  Current Node: node-2 at 06/09/2026 20:29:31
  Current Node: node-2 at 06/09/2026 20:29:36

Initiez un retour à l'état antérieur vers node-1. Depuis la ligne de commande du nœud 1, exécutez la commande suivante.
```
sudo pcs resource move sql_group node-1
```
Revenez à PowerShell sur cl-node. Arrêtez le script en appuyant sur Ctrl+C.

Effectuer un nettoyage

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

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.

Configurer une instance de cluster de basculement SQL Server sur Linux avec un disque à écriture simultanée Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avantages de l'implémentation de la haute disponibilité avec des disques multi-écrivains

Points clés de cette architecture

Objectifs

Coûts

Avant de commencer

Préparer le projet et le réseau

Créer les nœuds du cluster

Créer un équilibreur de charge interne

Installer les logiciels nécessaires

Configurer le nœud de base de données principal

Configurez le LVM.

Installer et formater les disques

Configurer SQL Server et Pacemaker

Déplacer TempDB vers un disque partagé

Configurer HAProxy

Configurer le nœud secondaire

Terminer la configuration du cluster

Configurer un cloisonnement STONITH

Configurer des appareils de cloisonnement

Tester les appareils de cloisonnement

Tester le basculement

Effectuer un nettoyage

Supprimer le projet

Étapes suivantes

Configurer une instance de cluster de basculement SQL Server sur Linux avec un disque à écriture simultanée