Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

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

Per ottenere un'alta affidabilità per SQL Server in due zone distinte di Compute Engine, puoi eseguire il deployment di un'istanza del cluster di failover (FCI) di SQL Server su Linux che utilizza dischi multi-writer. A differenza delle tradizionali architetture shared-nothing, questa configurazione consente di collegare contemporaneamente nodi in zone diverse allo stesso disco. Questa guida descrive come eseguire il deployment di un'istanza del cluster di failover di SQL Server ad alta disponibilità su Linux in Compute Engine utilizzando la replica sincrona a bassa latenza di Google Cloud Hyperdisk.

Questo design garantisce che SQL Server rimanga disponibile anche nell'improbabile eventualità di un'interruzione del servizio a livello di zona. La combinazione di Pacemaker per l'orchestrazione dei cluster con la resilienza tra zone di Compute Engine fornisce una soluzione solida e ad alte prestazioni per i carichi di lavoro di database mission-critical che richiedono la semplicità dell'archiviazione condivisa.

Vantaggi dell'implementazione dell'alta affidabilità con dischi multi-writer

L'utilizzo di un'istanza del cluster di failover SQL Server con dischi multi-writer anziché di gruppi di disponibilità Always On (AG) su Linux elimina la complessità della gestione di più copie di dati e il sovraccarico di sincronizzazione che comportano le configurazioni AG.

Un'architettura del volume condiviso è anche più efficiente in termini di spazio di archiviazione rispetto alle architetture AG che utilizzano repliche complete dei dati su ogni nodo. I volumi condivisi possono anche ridurre i costi del disco negli scenari di mirroring.

Punti salienti di questa architettura

Ridondanza zonale: protezione dei dati nel raro caso di errore dei nodi o interruzione zonale.
Gestione semplificata: riduce la complessità della gestione di più copie di dati rispetto ai gruppi di disponibilità Always On.
Efficienza di archiviazione: utilizza un unico volume condiviso per dati e log, ottimizzato utilizzando la funzionalità multi-writer.
Orchestrazione nativa di Linux: utilizza le estensioni di alta disponibilità (HAE) standard del settore per un failover senza interruzioni.

In un ambiente on-premise, puoi consentire a WSFC di eseguire annunci ARP in caso di failover per comunicare alle apparecchiature di rete una modifica dell'indirizzo IP. Google Cloud, tuttavia, ignora gli annunci ARP. Di conseguenza, devi implementare il bilanciatore del carico interno (consulta Esecuzione del clustering di failover di Windows Server)

Architettura

L'articolo presuppone che tu abbia conoscenze di base di SQL Server, Active Directory e Compute Engine.

Obiettivi

Questo tutorial mostra come completare le seguenti attività per raggiungere il tuo obiettivo:

Crea il deployment di SQL Server su Linux.
Crea, collega e configura il disco multi-writer.
Configura il cluster Pacemaker.
Configura il bilanciatore del carico.
Esegui un test di failover.

Costi

Questo tutorial utilizza componenti fatturabili di Google Cloud, tra cui:

Utilizza il calcolatore prezzi per generare una stima dei costi in base all'utilizzo previsto.

Prima di iniziare

Per questo tutorial, è necessario un progetto Google Cloud . Puoi crearne uno nuovo o selezionarne uno già esistente:
1. Nella console Google Cloud , nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud .
  Ruoli richiesti per selezionare o creare un progetto
  - Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per il quale ti è stato concesso un ruolo.
  - Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.
  Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno già esistente. Una volta completata questa procedura, puoi eliminare il progetto e tutte le relative risorse.
  
  Vai al selettore di progetti
2. Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .
3. Nella console Google Cloud , attiva Cloud Shell.
  
  Attiva Cloud Shell

Prepara il progetto e la rete

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

Nella console Google Cloud , apri Cloud Shell facendo clic sul pulsante Attiva Cloud Shell .

Vai alla console Google Cloud
Imposta l'ID progetto predefinito:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud .
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.

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

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

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

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

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"

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

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

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

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

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

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.

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.
Aggiorna hosts file su node-1 e node-2.

Nota: per l'utilizzo in produzione, la risoluzione del dominio deve essere gestita da un server DNS (Domain Name System) dedicato.
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.

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

Installa SQL Server 2025.

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

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

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

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
```
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
```
  Nota: se utilizzi altre porte per SQL Server o per l'endpoint del gruppo di disponibilità, modifica di conseguenza le regole firewall.

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.

Esegui il backup della configurazione esistente.

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

Aggiorna origine ID sistema:

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

Verifica che la modifica sia stata apportata correttamente.
```
grep 'system_id_source *= *"uname"' /etc/lvm/lvm.conf
```

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

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

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.

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

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

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

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.
  
  Nota: è necessaria una licenza SQL Server per ogni istanza VM. Se utilizzi server di applicazioni Microsoft, la mobilità delle licenze tramite Software Assurance ti aiuta a eseguire la transizione a Google Cloud. Per saperne di più, consulta Utilizzo della mobilità delle licenze con le applicazioni server Microsoft. Se non utilizzi una licenza di tua proprietà e devi acquistarne una tramite Google (PAYG), segui i passaggi descritti in Aggiungi una licenza SQL Server a un disco di avvio per assicurarti di acquistare una licenza per ogni istanza VM.
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

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"

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

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

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"

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

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"

Riavvia il servizio SQL Server per applicare le modifiche.
```
sudo systemctl restart mssql-server.service
```
Verifica che i file TempDB siano stati creati.
```
ls -l /mssql/db_temp/
```
Verifica che il servizio SQL Server sia in esecuzione.
```
systemctl status mssql-server --no-pager
```

Configura HAProxy

Imposta una nuova password per hacluster.

Nota: imposta la stessa password su tutti e tre i nodi. Ti servirà per configurare il cluster.
```
sudo passwd hacluster
```
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
```

Avvia il servizio HAProxy.

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

Arresta e disabilita il servizio HAProxy.

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

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

Smonta l'archivio condiviso.

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

Esegui la pulizia della configurazione del cluster predefinita esistente.
```
sudo pcs cluster destroy
```

Configura il nodo secondario

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

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.
  
  Nota :è necessaria una licenza SQL Server per ogni istanza. Se utilizzi server di applicazioni Microsoft, la mobilità delle licenze tramite Software Assurance ti aiuta a eseguire la transizione a Google Cloud. Per saperne di più, consulta Utilizzo della mobilità delle licenze con le applicazioni server Microsoft. Se non utilizzi una licenza di tua proprietà e devi acquistarne una tramite Google (PAYG), segui i passaggi descritti in Aggiungi una licenza SQL Server a un disco di avvio per assicurarti di acquistare una licenza per ogni istanza VM.
3. Specifica una password per l'account SA.
4. Verifica che il servizio mssql-server sia in esecuzione.
```
systemctl status mssql-server --no-pager
```

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"

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

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

Sposta TempDB sul disco dati condiviso.

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"

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

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"

Per applicare le modifiche, riavvia il servizio SQL Server.
```
sudo systemctl restart mssql-server.service
```
Verifica che il servizio SQL Server sia in esecuzione.
```
sudo systemctl status mssql-server --no-pager
```
Verifica che siano stati creati i file TempDB.
```
ls -l /mssql/db_temp/
```

Arresta e disattiva temporaneamente il servizio SQL Server.

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

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

Configura le impostazioni di LVM.

Esegui il backup della configurazione esistente.

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

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"

Verifica che la modifica sia stata apportata correttamente.
```
grep 'system_id_source *= *"uname"' /etc/lvm/lvm.conf
```

Imposta una nuova password per hacluster.

Nota: imposta la stessa password su entrambi i nodi. Questa password ti servirà durante la configurazione del cluster.
```
sudo passwd hacluster
```
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
```

Arresta e disabilita il servizio HAProxy.

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

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.

Autenticati come utente hacluster.

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

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

Imposta no-quorum-policy per il cluster a due nodi.
```
sudo pcs property set no-quorum-policy="ignore"
```

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.

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"

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

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

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

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

Configura i dispositivi di isolamento

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

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.

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.

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

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"

Pulisci la procedura di avvio del cluster.
```
sudo pcs resource cleanup
```

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.

Arresta l'isolamento su node-2.

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

Vedrai anche che node-2 è disattivato in Compute Engine.

Vai a Compute Engine

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.

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

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.

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

Torna alla sessione PowerShell su cl-node.

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

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
```
Torna a PowerShell su cl-node. Per interrompere lo script, premi Ctrl+C.

Esegui la pulizia

Al termine del tutorial, puoi eliminare le risorse che hai creato in modo che non utilizzino più la quota generando addebiti. Le seguenti sezioni descrivono come eliminare o disattivare queste risorse.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud , vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona quello che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.

Configurazione di un'istanza del cluster di failover SQL Server su Linux con un disco multi-writer Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Vantaggi dell'implementazione dell'alta affidabilità con dischi multi-writer

Punti salienti di questa architettura

Obiettivi

Costi

Prima di iniziare

Prepara il progetto e la rete

Crea i nodi del cluster

Crea il bilanciatore del carico interno

Installare il software necessario

Configura il nodo del database primario

Configura LVM.

Monta e formatta i dischi

Configura SQL Server e Pacemaker

Spostare TempDB sul disco condiviso

Configura HAProxy

Configura il nodo secondario

Completa la configurazione del cluster

Configura un isolamento STONITH

Configura i dispositivi di isolamento

Testa i dispositivi di isolamento

Testa il failover

Esegui la pulizia

Elimina il progetto

Passaggi successivi

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