Configurazione di un'istanza del cluster di failover SQL Server su Linux con un disco multi-writer

Prepara il progetto e la rete

Per preparare il progetto Cloud de Confiance e il VPC per il deployment della FCI di SQL Server, segui questi passaggi:

1. Nella console Cloud de Confiance , apri Cloud Shell facendo clic sul pulsante Attiva Cloud Shell .

   Vai alla console Cloud de Confiance

2. Imposta l'ID progetto predefinito:

   gcloud config set project PROJECT_ID
   

   Sostituisci PROJECT_ID con l'ID del tuo progetto Cloud de Confiance .

3. Imposta la regione predefinita:

   gcloud config set compute/region REGION
   

   Sostituisci REGION con l'ID della regione in cui vuoi eseguire il deployment.

Crea i nodi del cluster

Esegui il deployment di due VM come nodi del cluster e di una terza come client dedicato per convalidare la connettività e le prestazioni di failover.

1. Inizializza le seguenti variabili che verranno utilizzate per i comandi rimanenti.

   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. Crea due dischi a livello di regione, uno per i dati e l'altro per il log. Per consentire a entrambe le istanze di accedere ai dischi, attiva la modalità multi-writer per entrambi i dischi con il flag --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. Crea le VM Linux e collega i dischi multi-writer che hai creato.

   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. Crea la VM client Windows, cl-node, che utilizzerai per testare la connessione.

   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
   

Crea il bilanciatore del carico interno

1. Prenota un indirizzo IP per il cluster e il bilanciatore del carico.

   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. Crea un controllo di integrità per il 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. Per consentire una connessione alla porta del controllo di integrità, crea una regola firewall.

   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"
   

   Per saperne di più, consulta Regole firewall per i controlli di integrità.

4. Crea gruppi di istanze per i nodi del 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. Crea il servizio di backend del bilanciatore del carico.

   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. Crea la regola di forwarding del bilanciatore del carico.

   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. Crea un bucket Cloud Storage per trasferire i file dal nodo primario del cluster ai nodi secondari.

   gcloud storage buckets create gs://BUCKET_NAME \
   --location=$REGION \
   --public-access-prevention
   

   Sostituisci BUCKET_NAME con il nome del bucket da creare.

   Per saperne di più, consulta Crea bucket.

Installare il software necessario

Scarica, installa e configura il motore SQL Server e la gestione del cluster sulle due VM Linux, node-1 e node-2, che faranno parte del cluster di failover.

1. Connettiti a ciascuna delle tue VM tramite SSH. Per saperne di più, consulta Connessione alle VM Linux e Best practice per il controllo dell'accesso alla rete SSH.

2. Aggiorna hosts file su node-1 e node-2.

   1. Apri il file hosts file per modificarlo.

      sudo vi /etc/hosts
      

   2. Trova l'indirizzo IP interno di ogni VM Linux e aggiungi le voci host alla fine del file.

      Vai a Compute Engine

      NODE1_INTERNAL_IP node-1
      NODE2_INTERNAL_IP node-2
      

      Sostituisci NODE1_INTERNAL_IP e NODE2_INTERNAL_IP con l'indirizzo IP interno di ciascuna VM Linux.

3. Controlla la comunicazione tra le VM. Tutte le VM che fanno parte del gruppo di disponibilità Always On devono essere in grado di comunicare con altre VM: torna a ogni VM Linux, esegui i comandi da ogni VM e verifica che tutte le VM possano comunicare tra loro.

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

   L'output visualizzato è simile al seguente:

   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. Installa SQL Server 2025.

   1. Aggiungi il repository SQL Server al sistema.

      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. Installa SQL Server.

      sudo apt-get install -y mssql-server
      

   3. Installa gli strumenti per sviluppatori di SQL Server. Scarica e installa gli strumenti SQL Server sulle due VM Linux che faranno parte del cluster di failover.

      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. Installa Pacemaker. Pacemaker è un software di gestione delle risorse ad alta affidabilità open source, utilizzato con il motore di cluster Corosync. In questa sezione installerai Pacemaker su entrambe le VM del cluster.

   1. Installa Pacemaker su node-1 e node-2.

      sudo apt-get install -y pacemaker pcs fence-agents resource-agents pacemaker-cli-utils crmsh
      

   2. Installa l'agente di risorse SQL Server per Pacemaker.

      sudo apt-get install -y mssql-server-ha
      

6. Se hai attivato un firewall sulle VM, apri il firewall per SQL Server.

   1. Controlla se Uncomplicated Firewall è installato e abilitato eseguendo questo comando.

      sudo ufw status
      

   2. Se lo stato è attivo, esegui questi comandi per aprire le porte. Se il servizio firewall non è in esecuzione, puoi ignorare questo passaggio.

      sudo ufw allow 1433
      sudo ufw allow 5022
      sudo ufw reload
      

Configura il nodo del database primario

In questa sezione, inizializzerai i due dischi multi-writer e configurerai ciascun disco con gruppi di volumi e gruppi logici.

Configura LVM.

Configura le impostazioni di LVM.

1. Esegui il backup della configurazione esistente.

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

2. Aggiorna origine ID sistema:

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

3. Verifica che la modifica sia stata apportata correttamente.

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

4. Configura i gruppi di volumi LVM e i volumi logici.

   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. Formatta i volumi con il file system xfs con una dimensione del blocco di 64 KB.

   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. Verifica che i volumi siano stati creati.

   sudo lvs
   

Monta e formatta i dischi

Configura i punti di montaggio per i dischi condivisi e concedi l'accesso all'utente mssql.

1. Crea punti di montaggio per i nuovi volumi.

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

2. Monta i volumi LVM sui punti di montaggio.

   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. Imposta l'utente mssql come proprietario dei punti di montaggio.

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

4. Configura SQL Server:

   1. Imposta le variabili spostando il database principale nella memoria condivisa e esegui lo strumento 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. Scegli la versione Developer come versione di SQL Server e accetta il contratto di licenza.

      La versione Developer include tutte le funzionalità per le aziende, ma puoi utilizzarla solo per ambienti non di produzione. Sono disponibili maggiori informazioni sulle versioni di SQL Server e sulle licenze Microsoft.

   3. Specifica una password per l'account SA.

   4. Verifica che il servizio mssql-server sia in esecuzione.

      systemctl status mssql-server --no-pager
      

Configura SQL Server e Pacemaker

1. Crea l'utente SQL Server per Pacemaker. Sostituisci SA_PASSWORD con la password dell'account SA su SQL Server e PA_PASSWORD con la password che verrà utilizzata per l'account 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. Aggiungi le credenziali di accesso di Pacemaker alla cartella dei secret di 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. Aggiorna la configurazione di SQL Server in modo che utilizzi le nuove posizioni di dati, log e temp. Verranno inoltre impostate le impostazioni consigliate di 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
   

Spostare TempDB sul disco condiviso

1. Recupera l'elenco dei file TempDB e utilizzali per creare la query Alter. Questa query verrà utilizzata nel passaggio successivo per impostare la nuova posizione dei file 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. Acquisisci l'output del comando precedente. Utilizzerai l'output per formare il comando successivo da eseguire.

   QUERY="QUERY_OUTPUT"
   

   Query di esempio che utilizza l'output:

   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. Esegui il comando SQL generato per spostare i file TempDB.

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

4. Riavvia il servizio SQL Server per applicare le modifiche.

   sudo systemctl restart mssql-server.service
   

5. Verifica che i file TempDB siano stati creati.

   ls -l /mssql/db_temp/
   

6. Verifica che il servizio SQL Server sia in esecuzione.

   systemctl status mssql-server --no-pager
   

Configura HAProxy

1. Imposta una nuova password per hacluster.

   sudo passwd hacluster
   

2. Per completare la configurazione e verificare se il bilanciatore del carico di rete è configurato correttamente, installa e configura HAProxy tcp listener su entrambi i nodi del cluster:

   1. Installa HAProxy.

      sudo apt-get install haproxy
      

   2. Digita Y per completare l'installazione.

   3. Modifica il file haproxy.cfg.

      sudo vi /etc/haproxy/haproxy.cfg
      

   4. Nella sezione defaults di haproxy.cfg file, imposta la modalità su tcp.

   5. Aggiungi la seguente sezione alla fine del file haproxy.cfg.

      #---------------------------------------------------------------
      # Set up health check listener for SQL Server Availability Group
      #---------------------------------------------------------------
      listen healthcheck
      bind *:60008
      

3. Avvia il servizio HAProxy.

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

4. Arresta e disabilita il servizio HAProxy.

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

5. Carica il file della chiave della macchina su Cloud Storage utilizzando il seguente comando.

   sudo gcloud storage cp /var/opt/mssql/secrets/machine-key gs://BUCKET_NAME/
   

   Sostituisci BUCKET_NAME con il nome del bucket creato.

6. Arresta e disattiva il servizio SQL Server. Il servizio da questo punto in poi sarà controllato dal cluster.

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

7. Smonta l'archivio condiviso.

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

8. Esegui la pulizia della configurazione del cluster predefinita esistente.

   sudo pcs cluster destroy
   

Configura il nodo secondario

1. Crea punti di montaggio per i volumi LVM. Non devi formattare il disco perché è condiviso con node-1. Hai già formattato il disco e configurato i volumi LVM durante la configurazione di 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. Configura SQL Server.

   1. Per spostare il database principale sul disco dati condiviso, imposta le seguenti variabili e poi esegui lo strumento mssql-conf per applicare le modifiche.

      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. Scegli la versione Developer come versione di SQL Server e accetta il contratto di licenza.

      La versione Developer include tutte le funzionalità per le aziende, ma puoi utilizzarla solo per ambienti non di produzione. Sono disponibili maggiori informazioni sulle versioni di SQL Server e sulle licenze Microsoft.

   3. Specifica una password per l'account SA.

   4. Verifica che il servizio mssql-server sia in esecuzione.

      systemctl status mssql-server --no-pager
      

3. Crea l'utente SQL Server per il cluster Pacemaker. Sostituisci SA_PASSWORD con la password dell'account SA su SQL Server e PA_PASSWORD con la password che verrà utilizzata per l'account 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. Aggiungi le credenziali di accesso di Pacemaker alla cartella dei secret di 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. Aggiorna la configurazione di SQL Server in modo che utilizzi le nuove posizioni di dati, log e temp. Imposterai anche le impostazioni consigliate di 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
   

6. Sposta TempDB sul disco dati condiviso.

   1. Recupera l'elenco dei file TempDB e utilizzali per creare la query 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. Acquisisci l'output del comando precedente. Utilizzerai l'output per formare il comando successivo da eseguire.

      QUERY="QUERY_OUTPUT"
      

      Query di esempio che utilizza l'output:

      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. Per spostare i file TempDB, esegui il comando SQL generato.

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

   4. Per applicare le modifiche, riavvia il servizio SQL Server.

      sudo systemctl restart mssql-server.service
      

   5. Verifica che il servizio SQL Server sia in esecuzione.

      sudo systemctl status mssql-server --no-pager
      

   6. Verifica che siano stati creati i file TempDB.

      ls -l /mssql/db_temp/
      

7. Arresta e disattiva temporaneamente il servizio SQL Server.

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

8. Per assicurarti che entrambi i nodi utilizzino la stessa chiave per SQL Server, scarica il file della chiave del computer da 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. Configura le impostazioni di LVM.

   1. Esegui il backup della configurazione esistente.

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

   2. Aggiorna l'origine dell'ID sistema.

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

      Verifica la modifica eseguendo:

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

      L'output visualizzato è simile al seguente:

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

   3. Verifica che la modifica sia stata apportata correttamente.

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

10. Imposta una nuova password per hacluster.

    sudo passwd hacluster
    

11. Per completare la configurazione e verificare se il bilanciatore del carico di rete è configurato correttamente, installa e configura HAProxy tcp listener su entrambi i nodi del cluster.

    1. Installa HAProxy.

       sudo apt-get install haproxy
       

    2. Scegli Y per completare l'installazione.

    3. Modifica il file haproxy.cfg.

       sudo vi /etc/haproxy/haproxy.cfg
       

    4. Nella sezione dei valori predefiniti di haproxy.cfg file, imposta la modalità su tcp.

    5. Aggiungi la seguente sezione alla fine del file haproxy.cfg.

       #---------------------------------------------------------------
       # Set up health check listener for SQL Server Availability Group
       #---------------------------------------------------------------
       listen healthcheck
       bind *:60008
       

    6. Avvia il servizio HAProxy.

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

12. Arresta e disabilita il servizio HAProxy.

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

13. Pulisci la configurazione del cluster predefinita esistente.

    sudo pcs cluster destroy
    

Completa la configurazione del cluster

Torna a node-1 per continuare la configurazione del cluster.

1. Autenticati come utente hacluster.

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

2. Crea un cluster denominato ubuntu_fci.

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

3. Imposta no-quorum-policy per il cluster a due nodi.

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

4. Crea la risorsa cluster indirizzo IP virtuale.

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

   Sostituisci CLUSTER_ADDRESS con l'indirizzo IP prenotato in precedenza.

5. Crea oggetti risorsa cluster per tutti i volumi condivisi.

   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. Crea un gruppo di risorse e aggiungi tutti gli oggetti creati al nuovo gruppo.

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

7. Crea la risorsa cluster per il servizio Microsoft SQL Server e aggiungila al gruppo di risorse esistente.

   sudo pcs resource create sql_fci ocf:mssql:fci  op stop timeout=60s --group sql_group
   

8. Crea la risorsa cluster per HAProxy e aggiungila allo stesso gruppo.

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

9. Crea un vincolo del cluster che controlli la sequenza di avvio delle risorse.

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

Configura un isolamento STONITH

STONITH è una strategia di isolamento per mantenere l'integrità dei nodi in un cluster ad alta affidabilità. Il servizio STONITH funziona a livello di nodo e protegge il cluster dai nodi che non rispondono o sono in uno stato sconosciuto. Ti consigliamo il dispositivo di isolamento fence_gce specializzato per Compute Engine su Cloud de Confiance by S3NS.

Configura i dispositivi di isolamento

1. Controlla se l'agente di isolamento fence_gce per Compute Engine è installato su node-1.

   sudo pcs stonith list | grep fence_gce
   

   Per saperne di più, vedi:

   • Agente di isolamento per Google Compute Engine.

   • Per visualizzare i parametri associati all'agente, esegui questo comando:

     sudo pcs stonith describe fence_gce
     

2. Configura le risorse di isolamento del 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"
   

   Sostituisci ZONE1 e ZONE2 con la zona in cui hai eseguito il deployment delle VM Linux e PROJECT_ID con l'ID progetto.

3. Puoi verificare lo stato degli agenti di isolamento eseguendo il comando status.

   sudo fence_gce -o status -n node-1 --zone=ZONE1
   sudo fence_gce -o status -n node-2 --zone=ZONE2
   

   L'output visualizzato è simile al seguente:

   Status: ON
   

Sostituisci ZONE1 e ZONE2 con la zona in cui hai eseguito il deployment delle VM Linux.

1. Crea vincoli di località per i dispositivi di isolamento per assicurarti che vengano eseguiti solo sulle istanze previste.

   sudo pcs constraint location node-1-fence avoids node-1
   sudo pcs constraint location node-2-fence avoids node-2
   

2. Attiva l'isolamento nel cluster pacemaker e imposta il timeout di isolamento del cluster.

   sudo pcs -f stonith_cfg property set stonith-enabled=true
   sudo pcs property set stonith-timeout="300s"
   

3. Pulisci la procedura di avvio del cluster.

   sudo pcs resource cleanup
   

4. Controlla lo stato del cluster.

   sudo crm status
   

   L'output visualizzato è simile al seguente:

     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
   

Testa i dispositivi di isolamento

Dopo aver configurato i dispositivi di isolamento, ti consigliamo di testarli seguendo i passaggi riportati di seguito.

1. Arresta l'isolamento su node-2.

   1. Connettiti a node-1 ed esegui questo comando per testare il dispositivo di isolamento associato a node-2 dal cluster.

      fence_gce -o off -n node-2 --zone=ZONE2
      

      L'output visualizzato è simile al seguente:

      Success: Powered OFF
      

   2. Controlla lo stato del cluster.

      sudo crm status
      

      L'output visualizzato è simile al seguente:

       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. Vedrai anche che node-2 è disattivato in Compute Engine.

      Vai a Compute Engine

2. Riavvia l'isolamento su node-2.

   1. Torna a node-1 e riavvia di nuovo l'istanza eseguendo questo comando.

      fence_gce -o on -n node-2 --zone=ZONE2
      

      L'output visualizzato è simile al seguente:

      Success: Powered ON
      

   2. Controlla lo stato del cluster in Pacemaker e Compute Engine. Dopo poco tempo, vedrai che node-2 è di nuovo online.

       $ sudo crm status
      

Testa il failover

Ora puoi verificare se il failover funziona come previsto.

1. Crea un nome utente e una password per l'istanza VM
2. Connettiti alla VM utilizzando Remote Desktop e accedi con il nome utente e la password creati nel passaggio precedente.
3. Connettiti alla VM Windows su cl-node tramite Remote Desktop.
4. Apri una sessione di PowerShell.

5. Connettiti al server eseguendo il seguente script. Ogni 5 secondi, lo script si connette a SQL Server utilizzando il listener del gruppo di disponibilità ed esegue una query sul nome del server.

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

   Sostituisci CLUSTER_ADDRESS con l'indirizzo IP del listener e SA_PASSWORD con la password dell'account SA su SQL Server.

   L'output visualizzato è simile al seguente:

     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
   

   Lascia in esecuzione lo script.

6. Attiva un failover su node-2: da node-1, torna al terminale SSH ed esegui questo comando.

   sudo pcs resource move sql_group node-2
   

7. Torna alla sessione PowerShell su cl-node.

   1. Osserva l'output dello script in esecuzione e nota che il nome del server cambia da node-1 a node-2 a seguito del failover.

   L'output visualizzato è simile al seguente:

     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. Avvia un failback su node-1. Dalla riga di comando in node-1, esegui il comando seguente

   sudo pcs resource move sql_group node-1
   

9. Torna a PowerShell su cl-node. Per interrompere lo script, premi Ctrl+C.