Questa pagina è stata tradotta dall'API Cloud Translation.

Configurazione di un'istanza del cluster di failover SQL Server che utilizza Storage Spaces Direct

Le istanze del cluster di failover Always On (FCI) di Microsoft SQL Server consentono di eseguire una singola istanza SQL Server su più nodi del cluster di failover di Windows Server (WSFC). In qualsiasi momento, uno dei nodi del cluster ospita attivamente l'istanza SQL. In caso di errore, WSFC trasferisce automaticamente la proprietà delle risorse dell'istanza a un altro nodo.

La FCI di SQL Server richiede che i dati si trovino in uno spazio di archiviazione condiviso in modo che sia possibile accedervi da tutti i nodi WSFC. Questa guida descrive come eseguire il deployment di un'istanza del cluster di failover SQL Server 2019 che utilizza Spazi di archiviazione diretta (S2D) per lo spazio di archiviazione condiviso. S2D fornisce una SAN virtuale basata su software che può utilizzare i dischi di dati delle VM Compute Engine per archiviare il database SQL.

Il seguente diagramma illustra il deployment:

Architettura

Implementando un'architettura iperconvergente, le istanze VM node-1 e node-2 fungono da nodi WSFC e ospitano anche lo spazio di archiviazione condiviso. Una terza istanza VM, witness, viene utilizzata per raggiungere il quorum in uno scenario di failover. Le tre istanze VM sono distribuite su tre zone e condividono una subnet comune.

I client comunicano con l'istanza SQL Server tramite un bilanciatore del carico TCP interno. Questo bilanciatore del carico utilizza un controllo di integrità personalizzato per determinare quale nodo WSFC ospita attualmente l'istanza SQL e instrada il traffico a questa istanza.

L'articolo presuppone che tu abbia già eseguito il deployment di Active Directory su Google Cloud e che tu abbia conoscenze di base di SQL Server, Active Directory e Compute Engine.

Obiettivi

Eseguire il deployment di un WSFC composto da due istanze VM SQL Server e una terza istanza VM che funge da controllo di condivisione file.
Eseguire il deployment di un FCI di SQL Server sul WSFC.
Verificare il funzionamento del cluster simulando un 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 completare questa guida, devi disporre di quanto segue:

Un dominio Active Directory con almeno un domain controller. Puoi creare un dominio Active Directory utilizzando Microsoft Active Directory gestito. In alternativa, puoi eseguire il deployment di un ambiente Active Directory personalizzato su Compute Engine e configurare una zona di inoltro con DNS privato che inoltra le query DNS ai tuoi domain controller.
Un utente Active Directory che dispone dell'autorizzazione per unire computer al dominio e può accedere utilizzando RDP. Se usi Microsoft Active Directory gestito, puoi utilizzare l'utente setupadmin.
Un progetto Google Cloud e un VPC con connettività ai domain controller Active Directory.
Una subnet da utilizzare per le istanze VM WSFC.

Per completare la guida, hai bisogno anche di un progetto Google Cloud :

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

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

Go to project selector

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

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

Go to project selector

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

Al termine di questo tutorial, puoi evitare l'addebito di ulteriori costi eliminando le risorse create. Per ulteriori informazioni, consulta Pulizia.

Preparazione del progetto e della 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
Inizializza le seguenti variabili:
```
VPC_NAME=VPC_NAME
SUBNET_NAME=SUBNET_NAME
```
Dove:
- VPC_NAME: il nome del tuo VPC
- SUBNET_NAME: il nome della tua subnet
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 regole firewall

Per consentire ai client di connettersi a SQL Server, ai nodi di comunicare tra loro e al bilanciatore del carico di eseguire controlli di integrità, devi creare diverse regole firewall. Per semplificare la creazione di queste regole firewall, utilizza i tag di rete:

I due nodi WSFC sono annotati con il tag wsfc-node.
Tutti i server (incluso il server di controllo) sono annotati con il tag wsfc.

Crea regole firewall che utilizzano questi tag di rete:

Torna alla sessione di Cloud Shell esistente.

Crea regole firewall per i nodi WSFC:

SUBNET_CIDR=$(gcloud compute networks subnets describe $SUBNET_NAME --format=value\('ipCidrRange'\))

gcloud compute firewall-rules create allow-all-between-wsfc-nodes \
  --direction=INGRESS \
  --action=allow \
  --rules=tcp,udp,icmp \
  --enable-logging \
  --source-tags=wsfc \
  --target-tags=wsfc \
  --network=$VPC_NAME \
  --priority 10000

gcloud compute firewall-rules create allow-sql-to-wsfc-nodes \
  --direction=INGRESS \
  --action=allow \
  --rules=tcp:1433 \
  --enable-logging \
  --source-ranges=$SUBNET_CIDR \
  --target-tags=wsfc-node \
  --network=$VPC_NAME \
  --priority 10000

Crea una regola firewall che consenta i controlli di integrità dagli intervalli IP dei prober di Google Cloud:

gcloud compute firewall-rules create allow-health-check-to-wsfc-nodes \
  --direction=INGRESS \
  --action=allow \
  --rules=tcp \
  --source-ranges=130.211.0.0/22,35.191.0.0/16 \
  --target-tags=wsfc-node \
  --network=$VPC_NAME \
  --priority 10000

Crea istanze VM

Ora esegui il deployment di due istanze VM per il cluster di failover. In qualsiasi momento, solo una di queste VM funge da nodo FCI attivo, mentre l'altro nodo funge da nodo di failover. Le due istanze VM devono soddisfare i seguenti requisiti:

Si trovano nella stessa regione per consentire l'accesso di un bilanciatore del carico TCP interno.
L'agente guest è configurato per utilizzare la modalità WSFC. In questa modalità, l'agente guest ignora gli indirizzi IP dei bilanciatori del carico interni durante la configurazione dell'interfaccia di rete locale. Questo comportamento è necessario per evitare conflitti di indirizzi IP durante gli eventi di failover WSFC.

Utilizzi un'immagine premium SQL Server con SQL Server 2019 preinstallato.

Per fornire un voto decisivo e raggiungere il quorum per lo scenario di failover, esegui il deployment di una terza istanza VM che funge da controllo di condivisione file.

Torna alla sessione di Cloud Shell esistente.

Crea uno script di specializzazione per i nodi WSFC. Lo script installa la funzionalità Windows necessaria e crea le regole firewall per WSFC e SQL Server:

cat << "EOF" > specialize-node.ps1

$ErrorActionPreference = "stop"

# Install required Windows features
Install-WindowsFeature Failover-Clustering -IncludeManagementTools
Install-WindowsFeature RSAT-AD-PowerShell

# Open firewall for WSFC
netsh advfirewall firewall add rule name="Allow SQL Server health check" dir=in action=allow protocol=TCP localport=59997

# Open firewall for SQL Server
netsh advfirewall firewall add rule name="Allow SQL Server" dir=in action=allow protocol=TCP localport=1433

EOF

Crea le istanze VM. Sulle due VM che fungono da nodi S2D e WSFC, collega dischi dati aggiuntivi e attiva la modalità WSFC impostando la chiave dei metadati enable-wsfc su true:

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

gcloud compute instances create node-1 \
  --zone $REGION-a \
  --machine-type $MACHINE_TYPE \
  --subnet $SUBNET_NAME \
  --image-family sql-ent-2019-win-2022 \
  --image-project windows-sql-cloud \
  --tags wsfc,wsfc-node \
  --boot-disk-size 50 \
  --boot-disk-type pd-ssd \
  --boot-disk-device-name "node-1" \
  --create-disk=name=node-1-datadisk-1,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --create-disk=name=node-1-datadisk-2,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --create-disk=name=node-1-datadisk-3,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --create-disk=name=node-1-datadisk-4,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --metadata enable-wsfc=true \
  --metadata-from-file=sysprep-specialize-script-ps1=specialize-node.ps1

gcloud compute instances create node-2 \
  --zone $REGION-b \
  --machine-type $MACHINE_TYPE \
  --subnet $SUBNET_NAME \
  --image-family sql-ent-2019-win-2022 \
  --image-project windows-sql-cloud \
  --tags wsfc,wsfc-node \
  --boot-disk-size 50 \
  --boot-disk-type pd-ssd \
  --boot-disk-device-name "node-2" \
  --create-disk=name=node-2-datadisk-1,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --create-disk=name=node-2-datadisk-2,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --create-disk=name=node-2-datadisk-3,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --create-disk=name=node-2-datadisk-4,size=$PD_SIZE,type=pd-ssd,auto-delete=no \
  --metadata enable-wsfc=true \
  --metadata-from-file=sysprep-specialize-script-ps1=specialize-node.ps1

gcloud compute instances create "witness" \
  --zone $REGION-c \
  --machine-type n2-standard-2 \
  --subnet $SUBNET_NAME \
  --image-family=windows-2022 \
  --image-project=windows-cloud \
  --tags wsfc \
  --boot-disk-size 50 \
  --boot-disk-type pd-ssd \
  --metadata sysprep-specialize-script-ps1="add-windowsfeature FS-FileServer"

Per unire le tre istanze VM ad Active Directory, segui questi passaggi per ciascuna delle tre istanze VM:
1. Monitora il processo di inizializzazione della VM visualizzando l'output della porta seriale:
```
gcloud compute instances tail-serial-port-output NAME
```
  Sostituisci NAME con il nome dell'istanza VM.
  
  Attendi qualche minuto finché non vedi l'output Instance setup finished, poi premi Ctrl+C. A questo punto, l'istanza VM è pronta per essere utilizzata.
2. Crea un nome utente e una password per l'istanza VM.
3. Connettiti alla VM utilizzando Remote Desktop e accedi con il nome utente e la password creati nel passaggio precedente.
4. Fai clic con il tasto destro del mouse sul pulsante Start (o premi Win+X) e poi su Windows PowerShell (Amministratore).
5. Conferma la richiesta di elevazione facendo clic su Sì.
6. Unisci il computer al dominio Active Directory ed esegui il riavvio:
```
Add-Computer -Domain DOMAIN -Restart
```
  Sostituisci DOMAIN con il nome DNS del tuo dominio Active Directory.
  
  Attendi circa 1 minuto per il completamento del riavvio.

Prenota gli indirizzi IP del cluster

Ora devi prenotare due indirizzi IP statici nella tua rete VPC. I due indirizzi hanno scopi diversi:

IP del bilanciatore del carico: questo indirizzo IP viene utilizzato dai client per connettersi a SQL Server.
IP cluster: questo indirizzo IP viene utilizzato solo internamente da WSFC.

Per prenotare gli indirizzi IP statici, segui questi passaggi:

Prenota un IP statico per il bilanciatore del carico interno e acquisisci l'indirizzo in una nuova variabile di ambiente denominata LOADBALANCER_ADDRESS:

gcloud compute addresses create wsfc \
  --subnet $SUBNET_NAME \
  --region $(gcloud config get-value compute/region)

LOADBALANCER_ADDRESS=$(gcloud compute addresses describe wsfc \
  --region $(gcloud config get-value compute/region) \
  --format=value\(address\)) && \
echo "Load Balancer IP: $LOADBALANCER_ADDRESS"

Prendi nota dell'indirizzo IP, ti servirà più avanti.

Prenota un altro indirizzo IP statico da utilizzare come IP del cluster:

gcloud compute addresses create wsfc-cluster \
  --subnet $SUBNET_NAME \
  --region $(gcloud config get-value compute/region) && \
CLUSTER_ADDRESS=$(gcloud compute addresses describe wsfc-cluster \
    --region $(gcloud config get-value compute/region) \
    --format=value\(address\)) && \
echo "Cluster IP: $CLUSTER_ADDRESS"

Prendi nota dell'indirizzo IP, ti servirà più avanti.

Il progetto e il VPC sono ora pronti per il deployment di WSFC e SQL Server.

Crea un controllo di condivisione file

Per preparare witness a fungere da controllo di condivisione file, crea una condivisione file e concedi a te e ai due nodi WSFC l'accesso alla condivisione file:

Connettiti a witness utilizzando Remote Desktop. Accedi con il tuo account utente di dominio.
Fai clic con il tasto destro del mouse sul pulsante Start (o premi Win+X) e poi su Windows PowerShell (Amministratore).
Conferma la richiesta di elevazione facendo clic su Sì.

Crea la cartella di controllo e condividila:

New-Item "C:\QWitness" -Type directory

icacls C:\QWitness\ /grant 'node-1$:(OI)(CI)(M)'
icacls C:\QWitness\ /grant 'node-2$:(OI)(CI)(M)'

New-SmbShare `
  -Name QWitness `
  -Path "C:\QWitness" `
  -Description "SQL File Share Witness" `
  -FullAccess  $env:username,node-1$,node-2$

Deployment del cluster di failover

Ora puoi utilizzare le istanze VM per eseguire il deployment di un WSFC e di SQL Server.

Esegui il deployment di WSFC

Ora puoi creare il cluster di failover:

Connettiti a node-1 utilizzando Remote Desktop. Accedi con il tuo account utente di dominio.
Fai clic con il tasto destro del mouse sul pulsante Start (o premi Win+X) e poi su Windows PowerShell (Amministratore).
Conferma la richiesta di elevazione facendo clic su Sì.
Crea un nuovo cluster:
```
New-Cluster `
  -Name windows-fci `
  -Node node-1,node-2 `
  -NoStorage `
  -StaticAddress CLUSTER_ADDRESS
```
Sostituisci CLUSTER_ADDRESS con l'indirizzo IP del cluster che hai creato in precedenza.

Il comando crea un account computer windows-fci nel tuo dominio Active Directory.

Torna alla sessione PowerShell su witness e concedi all'account computer windows-fci l'autorizzazione per accedere alla condivisione file:

icacls C:\QWitness\ /grant 'windows-fci$:(OI)(CI)(M)'
Grant-SmbShareAccess `
  -Name QWitness `
  -AccountName 'windows-fci$' `
  -AccessRight Full `
  -Force

Torna alla sessione PowerShell su node-1 e configura il cluster per utilizzare la condivisione file su witness come quorum del cluster:
```
Set-ClusterQuorum -FileShareWitness \\witness\QWitness
```

Verifica che il cluster sia stato creato correttamente:

Test-Cluster

Potresti visualizzare alcuni avvisi che possono essere ignorati:

WARNING: System Configuration - Validate All Drivers Signed: The test reported some warnings..
WARNING: Network - Validate Network Communication: The test reported some warnings..
WARNING:
Test Result:
HadUnselectedTests, ClusterConditionallyApproved
Testing has completed for the tests you selected. You should review the warnings in the Report.  A cluster solution is
supported by Microsoft only if you run all cluster validation tests, and all tests succeed (with or without warnings).

Puoi anche avviare lo snap-in Gestione cluster di failover di MMC per esaminare l'integrità del cluster eseguendo cluadmin.msc.

Se utilizzi Active Directory gestito, aggiungi l'account del computer utilizzato da WSFC al gruppo Cloud Service Domain Join Accounts in modo che possa unire i computer al dominio:
```
Install-WindowsFeature RSAT-ADDS
Add-ADGroupMember `
  -Identity "Cloud Service Domain Join Accounts" `
  -Members windows-fci$
```

Abilitazione di Spazi di archiviazione diretta

Ora abilita S2D e crea un volume condiviso del cluster che combina i tre dischi permanenti che hai creato in precedenza:

Torna alla sessione PowerShell su node-1.
Attiva S2D:
```
Enable-ClusterStorageSpacesDirect
```
Se vuoi prestazioni migliori del disco, puoi aggiungere SSD locali SCSI ai nodi S2D oltre ai dischi permanenti SSD standard. Gli SSD locali possono fungere da livello di memorizzazione nella cache S2D. Imposta il numero di unità di capacità (nel nostro caso, dischi permanenti SSD) come multiplo del numero di SSD locali. Esegui invece questo comando per abilitare S2D con la memorizzazione nella cache:
```
Enable-ClusterStorageSpacesDirect -CacheDeviceModel "EphemeralDisk"
```
Accetta il valore predefinito quando ti viene chiesto di confermare. Potresti visualizzare alcuni avvisi che possono essere ignorati:
```
WARNING: 2021/04/08-13:12:26.159 Node node-1: No disks found to be used for cache
WARNING: 2021/04/08-13:12:26.159 Node node-2: No disks found to be used for cache
```
(Facoltativo) Imposta la cache in memoria del volume condiviso del cluster (CSV) su 2048 MB per un migliore throughput di lettura:
```
(Get-Cluster).BlockCacheSize = 2048
```

Crea un nuovo volume che utilizzi le versioni del volume condiviso del cluster di ReFS e una dimensione del cluster di 64 KB:

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

Test del failover del pool di archiviazione

Facoltativamente, ora puoi verificare se il failover del pool di archiviazione funziona correttamente:

Connettiti a node-2 utilizzando Remote Desktop. Accedi con il tuo account utente di dominio.
Fai clic con il tasto destro del mouse sul pulsante Start (o premi Win+X) e seleziona Esegui.
Inserisci cluadmin.msc e seleziona Ok.
Nel riquadro della finestra a sinistra, vai a Gestione cluster di failover > windows-fci > Archiviazione > Pool.

Dovresti vedere un pool denominato Cluster Pool 1 con nodo Proprietario impostato su node-1.
Torna a Cloud Shell e reimposta la VM node-1 per simulare un failover:
```
gcloud compute instances reset node-1 --zone $REGION-a
```
Torna a Gestione cluster di failover su node-2.
Controlla lo stato del pool di archiviazione premendo ripetutamente F5 per aggiornare la visualizzazione.

Dopo circa 30 secondi, il nodo proprietario dovrebbe passare automaticamente a node-2.

Rimuovi l'installazione predefinita di SQL Server

Ora rimuovi l'installazione predefinita di SQL Server dai due nodi e sostituiscila con una nuova configurazione FCI.

Per ciascuno dei due nodi WSFC, node-1 e node-2, esegui questi passaggi:

Fai clic con il tasto destro del mouse sul pulsante Start (o premi Win+X) e poi su Windows PowerShell (Amministratore).
Conferma la richiesta di elevazione facendo clic su Sì.

Rimuovi l'istanza SQL Server predefinita:

C:\sql_server_install\Setup.exe /Action=Uninstall /FEATURES=SQL,AS,IS,RS /INSTANCENAME=MSSQLSERVER /Q

Rimuovi il driver Microsoft OLE:

Get-Package -Name "Microsoft OLE*" | Uninstall-Package -Force

Rimuovi il driver Microsoft ODBC:

Get-Package -Name "Microsoft ODBC*" | Uninstall-Package -Force

Riavvia il computer:
```
Restart-Computer
```
Attendi circa 1 minuto per il completamento del riavvio.

Installa la FCI di SQL Server

Prima di installare la nuova configurazione FCI, verifica che node-1 sia il nodo attivo nel cluster:

Riconnettiti a node-1 utilizzando Remote Desktop e accedi con il tuo utente di dominio.
Fai clic con il tasto destro del mouse sul pulsante Start (o premi Win+X) e seleziona Esegui.
Inserisci cluadmin.msc e seleziona Ok.
Nel riquadro della finestra a sinistra, vai a Gestione cluster di failover > windows-fci.

Verifica che il server host attuale sia impostato su node-1.

Se il server host attuale è impostato su node-2, fai clic con il tasto destro del mouse su windows-fci nel riquadro della finestra a sinistra e seleziona Altre azioni > Sposta risorse principali cluster > Seleziona nodo… > node-1 e fai clic su Ok.
Nel riquadro della finestra a sinistra, vai a Gestione cluster di failover > windows-fci > Archiviazione > Pool.

Verifica che il nodo proprietario di Cluster Pool 1 sia impostato su node-1.

Se il nodo proprietario è impostato su node-2, fai clic con il tasto destro del mouse sul pool, seleziona Sposta > Seleziona nodo > node-1 e fai clic su Ok.

Ora crea una nuova installazione del cluster di failover SQL Server su node-1:

Fai clic con il tasto destro del mouse sul pulsante Start (o premi Win+X) e poi su Windows PowerShell (Amministratore).
Conferma la richiesta di elevazione facendo clic su Sì.

Crea un account utente di dominio per SQL Server e l'agente SQL e assegna una password:

Active Directory

$Credential = Get-Credential -UserName sql_server -Message 'Enter password'
New-ADUser `
  -Name "sql_server" `
  -Description "SQL Agent and SQL Admin account." `
  -AccountPassword $Credential.Password `
  -Enabled $true -PasswordNeverExpires $true

Microsoft Active Directory gestito

$Credential = Get-Credential -UserName sql_server -Message 'Enter password'
New-ADUser `
  -Name "sql_server" `
  -Description "SQL Agent and SQL Admin account." `
  -AccountPassword $Credential.Password `
  -Enabled $true -PasswordNeverExpires $true `
  -Path "OU=Cloud,DOMAIN"

Sostituisci DOMAIN con il nome distinto del tuo dominio, ad esempio DC=example,DC=org.

Avvia la configurazione di SQL Server:
```
& c:\sql_server_install\setup.exe
```
Nel menu a sinistra, seleziona Installazione.
Seleziona Installazione nuovo cluster di failover di SQL Server.
Nella pagina Microsoft Update seleziona Avanti per avviare l'installazione.
Nella pagina Installa regole del cluster di failover, viene visualizzato un avviso Avvisi di verifica del cluster MSCS e Windows Firewall. Puoi ignorare questi avvisi e selezionare Avanti.
Nella pagina Product Key, mantieni le impostazioni predefinite e seleziona Avanti.
Nella pagina Condizioni di licenza rivedi i termini e, se li accetti, seleziona Avanti.
Nella pagina Selezione delle funzionalità, seleziona Servizi del motore di database e quindi Avanti.
Nella pagina Configurazione istanza, inserisci sql per il nome di rete e l'istanza denominata, quindi seleziona Avanti.
Nella pagina Gruppo di risorse cluster, mantieni le impostazioni predefinite e seleziona Avanti.
Nella pagina Selezione disco del cluster, attiva Disco virtuale del cluster (FciVolume) e disattiva tutti gli altri dischi. Seleziona Avanti.
Nella pagina Configurazione rete cluster, configura le seguenti impostazioni, quindi seleziona Avanti:
- DHCP: vuoto
- Indirizzo IP: inserisci l'indirizzo IP del bilanciatore del carico interno.
Nella pagina Configurazione server, configura le seguenti impostazioni sia per SQL Server Agent che per Motore di database di SQL Server:
- Nome account: DOMAIN\sql_server, dove DOMAIN è il nome NetBIOS del tuo dominio Active Directory
- Password: inserisci la password che hai creato in precedenza
Seleziona la scheda Regole di confronto scegli e le regole di confronto che vuoi utilizzare. Quindi, fai clic su Avanti.
Nella pagina Configurazione motore di database, seleziona Aggiungi utente corrente per designare l'utente corrente come amministratore di SQL Server. Poi seleziona Avanti.
Nella pagina Inizio installazione, rivedi le impostazioni e poi seleziona Installa.
Al termine dell'installazione, seleziona Chiudi.

Il tuo dominio Active Directory ora contiene un account computer sql che rappresenta l'istanza SQL Server e una voce DNS corrispondente che rimanda all'indirizzo IP del bilanciamento del carico interno.

Ora aggiungi node-2 al cluster di failover SQL Server:

Connettiti a node-2 utilizzando Remote Desktop e accedi con il tuo utente di dominio.
Fai clic con il tasto destro del mouse sul pulsante Start (o premi Win+X) e poi su Windows PowerShell (Amministratore).
Conferma la richiesta di elevazione facendo clic su Sì.
Avvia la configurazione di SQL Server:
```
& c:\sql_server_install\setup.exe
```
Nel menu a sinistra, seleziona Installazione.
Seleziona Aggiungi nodo a cluster di failover di SQL Server.
Segui le istruzioni dell'installazione guidata e accetta le impostazioni predefinite fino a raggiungere la pagina Account di servizio.
Nella pagina Account di servizio, inserisci la password creata in precedenza sia per SQL Server Agent sia per Motore di database di SQL Server. Poi seleziona Avanti.
Nella pagina Inizio installazione, rivedi le impostazioni e poi seleziona Installa.
Al termine dell'installazione, seleziona Chiudi.

Configura i controlli di integrità

Come passaggio finale, configura il cluster in modo da esporre un endpoint di controllo di integrità che possa essere utilizzato da un bilanciatore del carico interno:

Torna alla sessione PowerShell su node-2
Inizializza una variabile con l'indirizzo IP del bilanciatore del carico.
```
$LoadBalancerIP = 'IP_ADDRESS'
```
Sostituisci IP_ADDRESS con l'indirizzo IP dell'indirizzo wsfc che hai prenotato in precedenza.

Configura il cluster di failover in modo che risponda al servizio di controllo di integrità:

$SqlGroup = Get-ClusterGroup |
  Where-Object {$_.Name.StartsWith("SQL Server")}
$SqlIpAddress = Get-ClusterResource |
  Where-Object {$_.Name.StartsWith("SQL IP Address")}

$SqlIpAddress | Set-ClusterParameter -Multiple @{
 'Address'=$LoadBalancerIP;
 'ProbePort'= 59997;
 'SubnetMask'='255.255.255.255';
 'Network'= (Get-ClusterNetwork).Name;
 'EnableDhcp'=0; }

Riavvia la risorsa del cluster:

$SqlIpAddress | Stop-ClusterResource
$SqlIpAddress | Start-ClusterResource

Riavvia il gruppo del cluster:

$SqlGroup | Stop-ClusterGroup
$SqlGroup | Start-ClusterGroup

Crea un bilanciatore del carico interno

Per fornire un singolo endpoint per i client SQL Server, ora devi eseguire il deployment di un bilanciatore del carico interno. Il bilanciatore del carico utilizza un controllo di integrità che garantisce che il traffico venga indirizzato al nodo attivo del WSFC.

Torna alla sessione di Cloud Shell esistente.

Crea due gruppi di istanze non gestite, uno per zona, e aggiungi i due nodi ai gruppi:

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

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

Crea un controllo di integrità utilizzabile dal bilanciatore del carico per determinare quale sia il nodo attivo.
```
gcloud compute health-checks create tcp wsfc-healthcheck \
  --check-interval="2s" \
  --healthy-threshold=1 \
  --unhealthy-threshold=2 \
  --port=59997 \
  --timeout="1s"
```
Il controllo di integrità utilizza la porta 59997, ovvero la porta configurata in precedenza come ProbePort per la risorsa indirizzo IP di SQL Server.

Crea un servizio di backend e aggiungi i due gruppi di istanze:

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

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

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

Crea il bilanciatore del carico interno:

gcloud compute forwarding-rules create wsfc-sql \
  --load-balancing-scheme internal \
  --address $LOADBALANCER_ADDRESS \
  --ports 1433 \
  --network $VPC_NAME \
  --subnet $SUBNET_NAME \
  --region $REGION \
  --backend-service wsfc-backend

Test del cluster di failover

Hai completato l'installazione del cluster di failover, ma devi ancora testare se il cluster funziona correttamente.

Prepara un client

Crea una nuova istanza VM che puoi utilizzare per connetterti al cluster di failover:

Torna alla sessione di Cloud Shell esistente.

Crea una nuova istanza VM:

gcloud compute instances create sqlclient \
  --zone $REGION-a \
  --machine-type n2-standard-2 \
  --subnet $SUBNET_NAME \
  --image-family sql-ent-2019-win-2022 \
  --image-project windows-sql-cloud \
  --boot-disk-size 50 \
  --boot-disk-type pd-ssd

Monitora il processo di inizializzazione della VM visualizzando l'output della porta seriale:
```
gcloud compute instances tail-serial-port-output sqlclient
```
Attendi qualche minuto finché non vedi l'output Instance setup finished, poi premi Ctrl+C. A questo punto, l'istanza VM è pronta per essere utilizzata.
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.
Fai clic con il tasto destro del mouse sul pulsante Start (o premi Win+X) e poi su Windows PowerShell (Amministratore).
Conferma la richiesta di elevazione facendo clic su Sì.
Unisci il computer al dominio Active Directory:
```
Add-Computer -Domain DOMAIN
```
Sostituisci DOMAIN con il nome DNS del tuo dominio Active Directory.
Riavvia il computer:
```
Restart-Computer
```
Attendi circa 1 minuto per il completamento del riavvio.

Esegui il test

Utilizza la VM sqlclient per verificare la connessione al cluster di failover e per testare che il failover funzioni correttamente:

Connettiti a sqlclient utilizzando Remote Desktop e accedi con il tuo utente di dominio.
Fai clic con il tasto destro del mouse sul pulsante Start (o premi Win+X) e poi su Windows PowerShell.

Connettiti al cluster SQL Server utilizzando TCP/IP e il nome DNS sql ed esegui una query sulla tabella dm_os_cluster_nodes:

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

L'output dovrebbe essere simile al seguente:

NodeName                       status      status_description is_current_owner
------------------------------ ----------- ------------------ ----------------
NODE-1                                   0 up                                1
NODE-2                                   0 up                                0

(2 rows affected)

Nota che node-1 è il proprietario attuale della risorsa del cluster di failover SQL Server.

Torna a Cloud Shell e arresta la VM node-1 per testare lo scenario di failover.
```
gcloud compute instances stop node-1 --zone $REGION-a
```

Ripeti la query:

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

L'output ora dovrebbe essere simile al seguente:

NodeName                       status      status_description is_current_owner
------------------------------ ----------- ------------------ ----------------
NODE-1                                   1 down                              0
NODE-2                                   0 up                                1

(2 rows affected)

Nota come, nonostante la perdita di node-1, la query va a buon fine e mostra che node-2 è ora il proprietario attuale del cluster di failover.

Limitazioni

S2D è supportato solo per Windows Server 2016 e versioni successive.
Con S2D, ogni disco contiene solo una visualizzazione parziale dei dati complessivi. Pertanto, l'acquisizione di uno snapshot di un disco permanente non sarà sufficiente per eseguire il backup dei dati. Utilizza invece il backup SQL nativo.

Esegui la pulizia

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

Eliminazione del progetto

Il modo più semplice per eliminare la fatturazione è quello di 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, quando lo elimini, elimini 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.

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

Passaggi successivi

Scopri come configurare un'istanza del cluster di failover SQL Server che utilizza dischi permanenti in modalità multi-writer.

Configurazione di un'istanza del cluster di failover SQL Server che utilizza Storage Spaces Direct Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Preparazione del progetto e della rete

Crea regole firewall

Crea istanze VM

Prenota gli indirizzi IP del cluster

Crea un controllo di condivisione file

Deployment del cluster di failover

Esegui il deployment di WSFC

Abilitazione di Spazi di archiviazione diretta

Test del failover del pool di archiviazione

Rimuovi l'installazione predefinita di SQL Server

Installa la FCI di SQL Server

Active Directory

Microsoft Active Directory gestito

Configura i controlli di integrità

Crea un bilanciatore del carico interno

Test del cluster di failover

Prepara un client

Esegui il test

Limitazioni

Esegui la pulizia

Eliminazione del progetto

Passaggi successivi

Configurazione di un'istanza del cluster di failover SQL Server che utilizza Storage Spaces Direct