Configurazione di gruppi di disponibilità AlwaysOn di SQL Server con commit sincrono


I gruppi di disponibilità AlwaysOn di Microsoft SQL Server (AG) consentono di replicare i database su più istanze SQL Server Enterprise.

Analogamente alle istanze cluster di failover di SQL Server, i gruppi di disponibilità AlwaysOn utilizzano il clustering di failover di Windows Server (WSFC) per implementare l'alta disponibilità. Tuttavia, le due funzionalità differiscono in molti modi, tra cui:

Gruppi di disponibilità AlwaysOn Istanze cluster di failover
Ambito del failover Gruppo di database Istanza
Archiviazione Non condiviso Condiviso

Per un confronto più dettagliato, vedi Confronto di istanze dei cluster di failover e gruppi di disponibilità.

I gruppi di disponibilità AlwaysOn supportano diverse modalità di disponibilità. Questo tutorial mostra come eseguire il deployment dei gruppi di disponibilità AlwaysOn in modalità di commit sincrona per implementare l'alta disponibilità per uno o più database.

La configurazione creerà tre istanze VM. Due istanze VM, node-1 e node-2, fungono da nodi WSFC ed eseguono SQL Server. 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.

Utilizzando un gruppo di disponibilità AlwaysOn di SQL Server, un database di esempio bookshelf viene replicato in modo sincrono tra le due istanze SQL Server.

In un ambiente on-premise, puoi consentire a WSFC di eseguire annunci ARP in caso di failover per notificare all'apparecchiatura di rete la modifica dell'indirizzo IP. Google Cloud, tuttavia, ignora gli annunci ARP. Di conseguenza, devi implementare una delle due opzioni seguenti:

Architettura

Architettura

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

Obiettivi

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, ti occorrono:

Per completare la guida, devi anche avere un progetto Google Cloud:

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

    Go to project selector

  5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Al termine di questo tutorial, potrai evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.

Preparazione del progetto e della rete

Per preparare il progetto Google Cloud e il VPC per il deployment dei gruppi di disponibilità AlwaysOn di SQL Server, segui questi passaggi:

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

    Vai alla console Google Cloud

  2. Inizializza le seguenti variabili:

    VPC_NAME=VPC_NAME
    SUBNET_NAME=SUBNET_NAME
    

    Dove:

    • VPC_NAME: nome del tuo VPC
    • SUBNET_NAME: nome della subnet
  3. Imposta l'ID progetto predefinito:

    gcloud config set project PROJECT_ID
    

    Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

  4. Imposta la tua 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, consentire la comunicazione tra i nodi WSFC e per consentire al bilanciatore del carico di eseguire i 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 quello witness) sono annotati con il tag wsfc.

Crea regole firewall che utilizzino questi tag di rete:

  1. Torna alla sessione di Cloud Shell esistente.
  2. Crea le 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
    
  3. Crea una regola firewall che consenta i controlli di integrità dagli intervalli IP dei probe di Google Cloud.

<pre class="devsite-click-to-copy">
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
</pre>

crea istanze VM

Ora esegui il deployment di due istanze VM per il cluster di failover. In qualsiasi momento, una di queste VM ospita la replica principale del database SQL Server mentre l'altro nodo ospita la replica secondaria. Le due istanze VM devono:

  • trovarsi nella stessa regione, in modo che sia possibile accedervi da un bilanciatore del carico di rete passthrough interno (non applicabile per DNN).
  • con WSFC e SQL Server installati.
  • Avere il supporto per WSFC di Compute Engine abilitato.

Utilizzi un'immagine SQL Server premium in cui SQL Server 2022 è preinstallato.

Per dare il voto alla pari e raggiungere il quorum per lo scenario di failover, esegui il deployment di una terza VM che funga da testimone della condivisione file.

  1. Torna alla sessione di Cloud Shell esistente.
  2. Crea uno script di specializzazione per i nodi WSFC. Lo script installa la funzionalità Windows necessaria e crea 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
    
    # Open firewall for SQL Server replication
    netsh advfirewall firewall add rule name="Allow SQL Server replication" dir=in action=allow protocol=TCP localport=5022
    
    # Format data disk
    Get-Disk |
     Where partitionstyle -eq 'RAW' |
     Initialize-Disk -PartitionStyle MBR -PassThru |
     New-Partition -AssignDriveLetter -UseMaximumSize |
     Format-Volume -FileSystem NTFS -NewFileSystemLabel 'Data' -Confirm:$false
    
    # Create data and log folders for SQL Server
    md d:\Data
    md d:\Logs
    EOF
    
  3. Creare le istanze VM. Sulle due VM che fungono da nodi WSFC, collega un disco dati aggiuntivo e abilita il clustering di failover di Windows Server impostando la chiave di metadati enable-wsfc su true:

    REGION=$(gcloud config get-value compute/region)
    PD_SIZE=200
    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-2022-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,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-2022-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,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"
    
  4. Per unire le 3 istanze VM ad Active Directory, segui questi passaggi per ognuna:

    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 circa 3 minuti finché non viene visualizzato l'output Instance setup finished, quindi 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 pulsante destro del mouse sul pulsante Start (o premi Win+X) e fai clic su Windows PowerShell (amministratore).

    5. Conferma la richiesta di elevazione facendo clic su .

    6. Unisci il computer al tuo dominio Active Directory e riavvia:

      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 indirizzi IP del cluster

Ora prenoti due indirizzi IP statici nel tuo VPC. Un indirizzo IP viene utilizzato come indirizzo IP del cluster WSFC, l'altro viene utilizzato dal bilanciatore del carico interno.

  1. Prenota un 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, che ti servirà in un secondo momento.

  2. Prenota un altro 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, che ti servirà in un secondo momento.

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

Deployment del cluster di failover

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

Preparazione di SQL Server

Crea un nuovo account utente in Active Directory per SQL Server:

  1. Connettiti a node-1 utilizzando Remote Desktop. Accedi con il tuo account utente di dominio.
  2. Fai clic con il pulsante destro del mouse sul pulsante Start (o premi Win+X) e fai clic su Windows PowerShell (amministratore).
  3. Conferma la richiesta di elevazione facendo clic su .
  4. Crea un account utente di dominio per SQL Server e l'agente SQL e assegna una password:

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

Per configurare SQL Server, esegui questi passaggi sia su node-1 che su node-2:

  1. Fai clic con il pulsante destro del mouse sul pulsante Start (o premi Win+X) e fai clic su Windows PowerShell (amministratore).

    Rinomina l'istanza SQL Server in modo che il suo nome corrisponda al nome host:

    $OLD_NAME = Invoke-Sqlcmd -Query "
      select @@SERVERNAME;
      GO" | ConvertTo-Csv | SELECT -Skip 2
    $OLD_NAME = $OLD_NAME.Replace('"', '')
    Invoke-Sqlcmd -Query "
      sp_dropserver '$OLD_NAME';
      GO
      sp_addserver '$env:computername', local;
      GO"
    Restart-Service -Name MSSQLSERVER
    
  2. Apri SQL Server Configuration Manager.

  3. Nel riquadro di navigazione, seleziona SQL Server Services (Servizi SQL Server)

  4. Nell'elenco dei servizi, fai clic con il tasto destro del mouse su SQL Server (MSSQLSERVER) e seleziona Proprietà.

  5. In Accedi come, modifica l'account:

    • Nome account: DOMAIN\sql_server dove DOMAIN è il nome NetBIOS del tuo dominio Active Directory.
    • Password: inserisci la password scelta in precedenza.
  6. Fai clic su Ok.

  7. Quando ti viene richiesto di riavviare SQL Server, seleziona .

SQL Server ora viene eseguito in un account utente di dominio.

Creazione di condivisioni file

Crea due condivisioni file su witness in modo che l'istanza VM possa archiviare i backup di SQL Server e agire da testimone della condivisione file:

  1. Connettiti a witness utilizzando Remote Desktop. Accedi con il tuo account utente di dominio.
  2. Fai clic con il pulsante destro del mouse sul pulsante Start (o premi Win+X) e fai clic su Windows PowerShell (amministratore).
  3. Conferma la richiesta di elevazione facendo clic su .
  4. Crea una condivisione file di test e concedi a te e ai due nodi WSFC l'accesso alla condivisione file:

    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$
    
  5. Crea un'altra condivisione file per archiviare i backup e concedi a SQL Server l'accesso completo:

    New-Item "C:\Backup" –type directory
    New-SmbShare `
      -Name Backup `
      -Path "C:\Backup" `
      -Description "SQL Backup" `
      -FullAccess  $env:USERDOMAIN\sql_server
    

Esegui il deployment di WSFC

Ora è tutto pronto per creare il cluster di failover:

  1. Torna alla sessione Remote Desktop su node-1.
  2. Fai clic con il pulsante destro del mouse sul pulsante Start (o premi Win+X) e fai clic su Windows PowerShell (amministratore).
  3. Conferma la richiesta di elevazione facendo clic su .
  4. Crea un nuovo cluster:

    • Per la configurazione del bilanciatore del carico
    New-Cluster `
      -Name sql-cluster `
      -Node node-1,node-2 `
      -NoStorage `
      -StaticAddress CLUSTER_ADDRESS
    

    Sostituisci CLUSTER_ADDRESS con l'indirizzo IP del cluster che hai creato in precedenza.

    • Per la configurazione DNN
    New-Cluster `
      -Name sql-cluster `
      -Node node-1,node-2 `
      -NoStorage `
      -ManagementPointNetworkType Distributed
    
  5. Torna alla sessione PowerShell il giorno witness e concedi all'oggetto computer virtuale del cluster l'autorizzazione per accedere alla condivisione file:

    icacls C:\QWitness\ /grant 'sql-cluster$:(OI)(CI)(M)'
    Grant-SmbShareAccess `
      -Name QWitness `
      -AccountName 'sql-cluster$' `
      -AccessRight Full `
      -Force
    
  6. Torna alla sessione PowerShell il giorno node-1 e configura il cluster in modo che utilizzi la condivisione file su witness come quorum di cluster:

    Set-ClusterQuorum -FileShareWitness \\witness\QWitness
    
  7. Verifica che il cluster sia stato creato correttamente:

    Test-Cluster
    

    Potresti visualizzare alcuni avvisi che puoi tranquillamente ignorare:

    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 snapshot MMC di Gestione cluster di failover per esaminare l'integrità del cluster eseguendo cluadmin.msc.

  8. Se utilizzi Managed AD, aggiungi l'account computer utilizzato da WSFC al gruppo Cloud Service Domain Join Accounts (Account di join al dominio Cloud Service) in modo che possa aggiungere i computer al dominio:

    Add-ADGroupMember `
      -Identity "Cloud Service Domain Join Accounts" `
      -Members sql-cluster$
    
  9. Abilita i gruppi di disponibilità AlwaysOn su entrambi i nodi:

    Enable-SqlAlwaysOn -ServerInstance node-1 -Force
    Enable-SqlAlwaysOn -ServerInstance node-2 -Force
    

Creazione di un gruppo di disponibilità

Ora crei un database di esempio bookshelf, lo includi in un nuovo gruppo di disponibilità denominato bookshelf-ag e configuri l'alta disponibilità.

Creazione di un database

Creare un nuovo database. Ai fini di questo tutorial, il database non deve contenere dati.

  1. Torna alla sessione Remote Desktop su node-1.
  2. Apri SQL Server Management Studio.
  3. Nella finestra di dialogo Connetti al server, verifica che il nome del server sia impostato su NODE-1 e seleziona Connetti.
  4. Nel menu, seleziona File > Nuovo > Query con connessione corrente.
  5. Incolla il seguente script SQL nell'editor:

    -- Create a sample database
    CREATE DATABASE bookshelf ON PRIMARY (
      NAME = 'bookshelf',
      FILENAME='d:\Data\bookshelf.mdf',
      SIZE = 256MB,
      MAXSIZE = UNLIMITED,
      FILEGROWTH = 256MB)
    LOG ON (
      NAME = 'bookshelf_log',
      FILENAME='d:\Logs\bookshelf.ldf',
      SIZE = 256MB,
      MAXSIZE = UNLIMITED,
      FILEGROWTH = 256MB)
    GO
    
    USE [bookshelf]
    SET ANSI_NULLS ON
    SET QUOTED_IDENTIFIER ON
    GO
    
    -- Create sample table
    CREATE TABLE [dbo].[Books] (
      [Id] [bigint] IDENTITY(1,1) NOT NULL,
      [Title] [nvarchar](max) NOT NULL,
      [Author] [nvarchar](max) NULL,
      [PublishedDate] [datetime] NULL,
      [ImageUrl] [nvarchar](max) NULL,
      [Description] [nvarchar](max) NULL,
      [CreatedById] [nvarchar](max) NULL,
      CONSTRAINT [PK_dbo.Books] PRIMARY KEY CLUSTERED ([Id] ASC) WITH (
        PAD_INDEX = OFF,
        STATISTICS_NORECOMPUTE = OFF,
        IGNORE_DUP_KEY = OFF,
        ALLOW_ROW_LOCKS = ON,
        ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
    ) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
    GO
    
    -- Create a backup
    EXEC dbo.sp_changedbowner @loginame = 'sa', @map = false;
      ALTER DATABASE [bookshelf] SET RECOVERY FULL;
      GO
      BACKUP DATABASE bookshelf to disk = '\\witness\Backup\bookshelf.bak' WITH INIT
    GO
    

    Lo script crea un nuovo database con una singola tabella ed esegue un backup iniziale in witness.

  6. Seleziona Esegui per eseguire lo script SQL.

Configurazione dell'alta disponibilità

  1. Nella finestra Esplora oggetti, fai clic con il tasto destro del mouse su Sempre alta disponibilità e seleziona Procedura guidata nuovo gruppo di disponibilità.
  2. Nella pagina Specifica opzioni, imposta il nome del gruppo di disponibilità su bookshelf-ag, quindi seleziona Avanti.
  3. Nella pagina Seleziona database, seleziona il database bookshelf, quindi seleziona Avanti.
  4. Nella pagina Specifica le repliche, seleziona la scheda Repliche:

    1. Seleziona Aggiungi replica.
    2. Nella finestra di dialogo Connetti al server, inserisci il nome del server node-2 e seleziona Connetti.

      L'elenco delle repliche di disponibilità ora contiene le istanze SQL Server, node-1 e node-2.

    3. Imposta la Modalità disponibilità su Commit sincrono per entrambe le istanze.

    4. Imposta Failover automatico su Abilitato per entrambe le istanze.

    5. Seleziona la scheda Listener **

      1. Seleziona Crea un listener del gruppo di disponibilità
      2. Inserisci le seguenti impostazioni:

        • Nome DNS del listener: bookshelf
        • Porta: 1433
        • Modalità di rete: IP statico
      3. Seleziona Aggiungi e inserisci l'indirizzo IP del bilanciatore del carico che hai creato in precedenza. Quindi, seleziona OK.

    6. Seleziona Avanti.

  5. Nella pagina Seleziona sincronizzazione dati, scegli Seeding automatico.

  6. Nella pagina Convalida, verifica che tutti i controlli siano andati a buon fine.

  7. Nella pagina Riepilogo, seleziona Fine.

  8. Nella pagina Risultati, seleziona Chiudi.

Configura i controlli di integrità

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

  1. Torna alla sessione PowerShell il giorno node-1.
  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.

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

    $SqlIpAddress = Get-ClusterResource |
      Where-Object {$_.ResourceType -eq "IP Address"} |
      Where-Object {$_.Name.StartsWith("bookshelf")}
    
    $SqlIpAddress | Set-ClusterParameter -Multiple @{
     'Address'= $LoadBalancerIP;
     'ProbePort'= 59997;
     'SubnetMask'='255.255.255.255';
     'Network'= (Get-ClusterNetwork).Name;
     'EnableDhcp'=0; }
    
  4. Riavvia la risorsa del cluster:

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

Crea un bilanciatore del carico interno

Per fornire un singolo endpoint per i client SQL Server, ora esegui il deployment di un bilanciatore del carico interno. Il bilanciatore del carico utilizza un controllo di integrità per garantire che il traffico sia diretto al nodo attivo di WSFC.

  1. Torna alla sessione di Cloud Shell esistente.
  2. Crea due gruppi di istanze non gestite, uno per zona, e aggiungi i due nodi ai gruppi:

    REGION=$(gcloud config get-value compute/region)
    
    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
    
  3. Crea un controllo di integrità utilizzabile dal bilanciatore del carico per determinare quale è 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à verifica la porta 59997, ovvero la porta precedentemente configurata come ProbePort per il listener del gruppo di disponibilità.

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

Ora puoi connetterti al listener del gruppo di disponibilità di SQL Server utilizzando il bilanciatore del carico interno e il nome DNS bookshelf.

Per creare più gruppi di disponibilità in un singolo cluster di failover, devi utilizzare un bilanciatore del carico separato con il proprio controllo di integrità per gruppo di disponibilità. Ciò significa che per ogni gruppo di disponibilità, hai bisogno di:

  1. Un indirizzo IP interno riservato (uno per ogni gruppo di disponibilità) da utilizzare per il listener e il bilanciatore del carico interno.

  2. Un bilanciatore del carico separato (uno per ogni gruppo di disponibilità) con il proprio indirizzo IP prenotato nel passaggio precedente.

  3. Una porta del probe separata (59997, 59998 e così via per ogni gruppo di disponibilità) e una regola firewall per consentire il traffico su queste porte del probe.

  4. Una regola separata per il controllo di integrità per ogni gruppo di disponibilità che utilizza le rispettive porte del probe.

Configurare un listener DNN per un gruppo di disponibilità

Analogamente alla configurazione del bilanciamento del carico interno, il listener DNN funge da singolo endpoint per i client SQL Server.

  1. Torna alla sessione PowerShell il giorno node-1.
  2. Esegui lo script seguente per creare un listener DNN.

      $Ag='bookshelf-ag'
      $Port='DNN_PORT'
      $Dns='DNN_NAME'
    
      # create the DNN resource with the port as the resource name
      Add-ClusterResource -Name $Port -ResourceType "Distributed Network Name" -Group $Ag
    
      # set the DNS name of the DNN resource
      Get-ClusterResource -Name $Port | Set-ClusterParameter -Name DnsName -Value $Dns
    
      # start the DNN resource
      Start-ClusterResource -Name $Port
    
      # add the Dependency from availability group resource to the DNN resource
      Set-ClusterResourceDependency -Resource $Ag -Dependency "[$Port]"
    
      #bounce the AG resource
      Stop-ClusterResource -Name $Ag
      Start-ClusterResource -Name $Ag
    

    Sostituisci DNN_PORT con la porta listener DNN. La porta del listener DNN deve essere configurata con una porta univoca. Per ulteriori informazioni, vedi Considerazioni sulle porte.

    Sostituisci DNN_NAME con il nome del listener DNN.

  3. Crea regole firewall per la porta del listener DNN sia su node-1 che su node-2.

      netsh advfirewall firewall add rule name="Allow DNN listener" dir=in action=allow protocol=TCP localport=DNN_PORT
    

Test del failover in corso...

Ora puoi verificare se il failover funziona come previsto:

  1. Torna alla sessione PowerShell il giorno witness.
  2. Esegui questo script:

    while ($True){
      $Conn = New-Object System.Data.SqlClient.SqlConnection
      $Conn.ConnectionString = "Server=LISTENER;Integrated Security=true;Initial Catalog=master"
      $Conn.Open()
    
      $Cmd = New-Object System.Data.SqlClient.SqlCommand
      $Cmd.Connection = $Conn
      $Cmd.CommandText = "SELECT @@SERVERNAME"
    
      $Adapter = New-Object System.Data.SqlClient.SqlDataAdapter $Cmd
      $Data = New-Object System.Data.DataSet
      $Adapter.Fill($Data) | Out-Null
      $Data.Tables[0] + (Get-Date -Format "MM/dd/yyyy HH:mm:ss")
    
      Start-Sleep -Seconds 2
    }
    

    Sostituisci LISTENER con il nome DNS del listener o il listener DNN e la porta del gruppo di disponibilità.

    Ogni 2 secondi, lo script si connette a SQL Server utilizzando il listener del gruppo di disponibilità o il listener DNN, e esegue una query sul nome del server.

    Lascia in esecuzione lo script.

  3. Torna alla sessione Desktop remoto su node-1 per attivare un failover:

    1. In SQL Server Management Studio, vai a AlwaysOn Alta disponibilità > Gruppi di disponibilità > bookmen-ag (primario) e fai clic con il tasto destro del mouse sul nodo.
    2. Seleziona Failover.
    3. Nella pagina Seleziona nuova replica principale, verifica che node-2 sia selezionato come nuova replica principale e che la colonna Idoneità per il failover indichi No data loss. Quindi, seleziona Avanti.
    4. Nella pagina Connetti alla replica, seleziona Connetti.
    5. Nella finestra di dialogo Connetti al server, verifica che il nome del server sia node-2 e fai clic su Connetti.
    6. Seleziona Avanti, quindi Fine.
    7. Nella pagina Risultati, verifica che il failover sia riuscito.
  4. Torna alla sessione PowerShell il giorno witness.

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

  6. Interrompi lo script premendo Ctrl+C.

Esegui la pulizia

Dopo aver completato il tutorial, puoi eseguire la pulizia delle risorse che hai creato in modo che smettano di utilizzare la quota e generino addebiti. Le sezioni seguenti descrivono come eliminare o disattivare queste risorse.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è quello di eliminare il progetto che hai creato per il tutorial.

Per eliminare il progetto:

  1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi