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

Préparer le projet et le réseau

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

1. Dans la console Cloud de Confiance , ouvrez Cloud Shell en cliquant sur le bouton Activer Cloud Shell .

   Accéder à la console Cloud de Confiance

2. Définissez votre ID de projet par défaut :

   gcloud config set project PROJECT_ID
   

   Remplacez PROJECT_ID par l'ID de votre projet Cloud de Confiance .

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

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

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

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

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

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

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

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

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

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

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

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

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

2. Mettez à jour hosts file sur node-1 et node-2.

   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.

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

4. Installez SQL Server 2025.

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

   2. Installez SQL Server.

      sudo apt-get install -y mssql-server
      

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

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

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

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.

1. Sauvegardez la configuration existante.

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

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

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

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

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

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

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

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

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

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

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

   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

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

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

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

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

2. 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');"
   

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

4. Redémarrez le service SQL Server pour que les modifications prennent effet.

   sudo systemctl restart mssql-server.service
   

5. Vérifiez que les fichiers TempDB ont été créés.

   ls -l /mssql/db_temp/
   

6. Vérifiez que le service SQL Server est en cours d'exécution.

   systemctl status mssql-server --no-pager
   

Configurer HAProxy

1. Définissez un nouveau mot de passe pour hacluster.

   sudo passwd hacluster
   

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

3. Démarrez le service HAProxy.

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

4. Arrêtez et désactivez le service HAProxy.

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

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

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

7. Désinstallez l'espace de stockage partagé.

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

8. Nettoyez la configuration de cluster par défaut existante.

   sudo pcs cluster destroy
   

Configurer le nœud secondaire

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

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

   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
      

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

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

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

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

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

   2. 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');"
      

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

   4. Pour que les modifications prennent effet, redémarrez le service SQL Server.

      sudo systemctl restart mssql-server.service
      

   5. Vérifiez que le service SQL Server est en cours d'exécution.

      sudo systemctl status mssql-server --no-pager
      

   6. Vérifiez que les fichiers TempDB ont été créés.

      ls -l /mssql/db_temp/
      

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

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

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

9. Configurez les paramètres LVM.

   1. Sauvegardez la configuration existante.

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

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

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

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

10. Définissez un nouveau mot de passe pour hacluster.

    sudo passwd hacluster
    

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

12. Arrêtez et désactivez le service HAProxy.

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

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

1. Authentifiez-vous en tant qu'utilisateur hacluster.

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

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

3. Définissez la stratégie de non-quorum pour un cluster à deux nœuds.

   sudo pcs property set no-quorum-policy="ignore"
   

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

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

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

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

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

9. 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 Cloud de Confiance by S3NS.

Configurer des appareils de cloisonnement

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

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

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

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

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"
   

3. Nettoyez le processus de démarrage du cluster.

   sudo pcs resource cleanup
   

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

1. Arrêtez le cloisonnement sur node-2.

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

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

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

      Accéder à Compute Engine

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

1. Créez un nom d'utilisateur et un mot de passe pour l'instance de VM.
2. 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.
3. Connectez-vous à la VM Windows sur cl-node via le Bureau à distance.
4. Ouvrez une session PowerShell.

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

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

7. Revenez à la session PowerShell sur cl-node.

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

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

9. Revenez à PowerShell sur cl-node. Arrêtez le script en appuyant sur Ctrl+C.