Deployment di un gruppo di disponibilità sempre attiva SQL Server 2016 su più subnet su Compute Engine

Questo tutorial è la seconda parte di una serie che ti aiuta a eseguire il deployment di un ambiente Windows ad alta disponibilità su Google Cloud con Microsoft Active Directory, SQL Server 2016 e Internet Information Services (IIS). In questo tutorial, configuri due istanze SQL Server in zone diverse della stessa regione e le configuri come gruppo di disponibilità SQL Server sempre attivo con più subnet.

La serie è costituita da questi tutorial:

Deployment di un ambiente Microsoft Active Directory a tolleranza di errore
Deployment di un server SQL con più subnet (questo documento)
Deployment dei server web IIS con bilanciamento del carico

Ogni tutorial si basa sull'infrastruttura che hai creato nella precedente.

Obiettivi

Crea due subnet di rete su due zone.
Eseguire il deployment di una macchina virtuale (VM) Microsoft SQL Server 2016 in ciascuna zona.
Configura ogni istanza SQL Server in modo che entri nel dominio Active Directory.
Creare un cluster di failover di Windows Server.
Crea e configura un database di esempio SQL Server bookshelf.
Configurare il gruppo di disponibilità SQL Server Always On.

Costi

In questo tutorial, continuerà a utilizzare le risorse Google Cloud configurate nei tutorial precedenti. Utilizzi i seguenti componenti fatturabili:

Il Calcolatore prezzi stima il costo di questo ambiente a circa 98 $al giorno, incluse le licenze SQL Server 2016 Enterprise e l'ambiente Active Directory a due server.

Prima di iniziare

La configurazione utilizzata in questo tutorial richiede l'accesso a un controller di dominio Windows e un dominio Active Directory funzionante. Se non disponi già di questo ambiente, completa i passaggi dei seguenti tutorial:

Inizializzazione delle variabili comuni

Devi definire diverse variabili di ambiente che controllano il deployment degli elementi dell'infrastruttura.

Utilizzando un editor di testo, crea uno script che imposti le seguenti variabili di ambiente per specificare il tuo ID progetto, insieme alla regione e alle zone che vuoi utilizzare.

Le variabili impostano la regione su us-east1. Se hai utilizzato un'area geografica diversa nel tutorial precedente, modifica l'area geografica in questo script in modo che corrisponda a quella utilizzata in precedenza.
```
region=us-east1
zone_1=${region}-b
zone_2=${region}-c
vpc_name=webappnet
project_id=your-project-id
```
Sostituisci your-project-id con l'ID del progetto Google Cloud che stai utilizzando.
Apri Cloud Shell:

Apri Cloud Shell
Copia lo script nella finestra di Cloud Shell ed eseguilo.
Imposta la regione e l'ID progetto predefiniti in modo da non dover specificare questi valori in ogni comando successivo:
```
gcloud config set compute/region ${region}
gcloud config set project ${project_id}
```

Creazione dell'infrastruttura di rete

Dopo aver definito le variabili di infrastruttura, puoi creare le subnet di rete utilizzate da SQL Server.

Aggiungi nuove subnet alla rete VPC (Virtual Private Cloud) esistente:

gcloud compute networks subnets create private-sql-1 \
    --network ${vpc_name} \
    --range 10.3.0.0/24

gcloud compute networks subnets create private-sql-2 \
    --network ${vpc_name} \
    --range 10.4.0.0/24

Crea una regola firewall interna per consentire il traffico tra le subnet private-ad* che hai creato in precedenza e le nuove subnet private-sql*:
```
gcloud compute firewall-rules create allow-internal-ports-private-sql \
    --network ${vpc_name} \
    --allow tcp:0-65535,udp:0-65535,icmp \
    --source-ranges 10.4.0.0/24,10.3.0.0/24,10.2.0.0/24,10.1.0.0/24
```
Nota: in un ambiente di produzione, è una best practice proteggere tutte le porte che i tuoi sistemi non utilizzano attivamente. È anche una best practice proteggere l'accesso alle macchine tramite un host di base.

Creazione di istanze SQL Server

Quindi, crea due VM di SQL Server 2016 Enterprise utilizzando immagini preconfigurate di Compute Engine con le seguenti proprietà:

Nomi: bookshelf-sql1 e bookshelf-sql2
Dimensione disco di avvio: 200GB
Tipo di macchina: n1-highmem-4

Se intendi utilizzare questo ambiente oltre questo tutorial e hai bisogno di risorse di calcolo aggiuntive, puoi personalizzare il tipo di macchina per queste istanze in un secondo momento. Puoi anche aggiungere dischi e ridimensionare i dischi permanenti esistenti.

In questo tutorial utilizzerai l'immagine pubblica di SQL Server su Windows Server per le tue VM, il che significa che ti verrà addebitato l'utilizzo di SQL Server. Puoi anche eseguire il deployment delle tue licenze SQL Server esistenti in Compute Engine utilizzando la mobilità delle licenze tramite Software Assurance e applicare queste licenze dopo aver installato SQL Server su una qualsiasi delle immagini pubbliche di Windows Server.

Crea un'istanza di Compute Engine di Windows Server 2016 con SQL Server 2016 Enterprise:

gcloud compute instances create bookshelf-sql1 \
    --machine-type n1-highmem-4 \
    --boot-disk-type pd-ssd \
    --boot-disk-size 200GB \
    --image-project windows-sql-cloud \
    --image-family sql-ent-2016-win-2016 \
    --zone ${zone_1} \
    --network-interface=network=${vpc_name},subnet=private-sql-1,private-network-ip=10.3.0.2,aliases=10.3.0.4/31

Crea la seconda istanza:

gcloud compute instances create bookshelf-sql2 \
    --machine-type n1-highmem-4 \
    --boot-disk-type pd-ssd \
    --boot-disk-size 200GB \
    --image-project windows-sql-cloud \
    --image-family sql-ent-2016-win-2016 \
    --zone ${zone_2} \
    --network-interface=network=${vpc_name},subnet=private-sql-2,private-network-ip=10.4.0.2,aliases=10.4.0.4/31

Configura l'istanza Bookshelf-sql2

Ora configuri l'istanza bookshelf-sql2. Inizia con la seconda istanza perché è necessario un lavoro aggiuntivo per configurare il database su bookshelf-sql1 e la configurazione di bookshelf-sql2 richiede prima un minor numero di sessioni RDP (Remote Desktop Protocol).

Crea una password per l'istanza Windows bookshelf-sql2:
```
gcloud compute reset-windows-password bookshelf-sql2 \
    --zone ${zone_2} --quiet
```
Il nome utente è il nome utente del tuo Account Google. Prendi nota di nome utente e password per un uso futuro.
Nota:
se l'istanza non è pronta ad accettare la richiesta, verrà visualizzato il seguente messaggio di errore.
```
ERROR: (gcloud.compute.reset-windows-password)
The instance may not be ready for use. This can occur if the instance was
recently created or if the instance is not running Windows. Please wait a
few minutes and try again.
```
Se vedi questo messaggio, riprova il comando tra qualche minuto.
Utilizza RDP per connetterti all'istanza SQL Server utilizzando le credenziali create in precedenza.
Nell'istanza, apri un terminale PowerShell come Amministratore. Fai clic su Start, digita PowerShell e premi Control+Shift+Enter.

Imposta le variabili seguenti:

$DomainName = "example-gcp.com"
$DNS1 = "10.1.0.100"
$DNS2 = "10.2.0.100"
$LocalStaticIp = "10.4.0.2"
$DefaultGateway = "10.4.0.1"

Configura il server DNS principale:

netsh interface ip set dns Ethernet static $DNS1

Configura il server DNS secondario:

netsh interface ip add dns Ethernet $DNS2 index=2

Imposta l'indirizzo IP e il gateway predefinito:
```
netsh interface ip set address name=Ethernet static $LocalStaticIp 255.255.255.0 $DefaultGateway 1
```
Nota: RDP potrebbe perdere la connettività per alcuni secondi e richiedere anche una nuova connessione.

Aggiungi la VM al dominio Windows:

Add-Computer -DomainName $DomainName `
    -Credential (Get-Credential "example-gcp\Administrator")

Quando ti viene chiesto di fornire una password per l'account Administrator, utilizza le credenziali di amministratore definite quando hai installato una foresta di Active Directory nel tutorial precedente. Come nome utente, aggiungi il nome di dominio come prefisso, ad esempio EXAMPLE-GCP\Administrator.

Apri le porte del firewall di Windows per il gruppo di disponibilità SQL Server:

netsh advfirewall firewall add rule name="5022 for Avail Groups" dir=in action=allow protocol=TCP localport=5022
netsh advfirewall firewall add rule name="1433 for SQL Server" dir=in action=allow protocol=TCP localport=1433

Installa la funzionalità di clustering di failover:

Install-WindowsFeature Failover-Clustering -IncludeManagementTools

Riavvia l'istanza:
```
Restart-Computer
```
Utilizza RDP per la connessione all'istanza SQL Server utilizzando le credenziali per l'account EXAMPLE-GCP\Administrator.
Apri una finestra della console di PowerShell come amministratore.
Nella finestra della console di PowerShell, crea le cartelle per i file di dati e di log di SQL Server:
```
New-Item -ItemType directory -Path C:\SQLData
New-Item -ItemType directory -Path C:\SQLLog
```
Nota: una best practice in produzione crea un disco separato per i tuoi file SQL Server. In questo caso, modifica i comandi precedenti in modo che corrispondano all'unità e al percorso in uso.

Crea una nuova cartella per i backup del database e condividila:

New-Item -ItemType directory -Path C:\SQLBackup
New-SMBShare -Name SQLBackup -Path C:\SQLBackup -FullAccess "Authenticated Users"

Configura l'istanza Bookshelf-sql1

Ora configuri l'istanza bookshelf-sql1.

In Cloud Shell, crea una password per l'istanza di Windows bookshelf-sql1:
```
gcloud compute reset-windows-password bookshelf-sql1 --zone ${zone_1}  --quiet
```
Il nome utente è il nome utente del tuo Account Google. Prendi nota di nome utente e password per gli utilizzi futuri.
Utilizza RDP per connetterti all'istanza SQL Server utilizzando le credenziali create per l'istanza bookshelf-sql1.
Apri una finestra della console di PowerShell come amministratore.

Nella finestra della console di PowerShell, imposta le seguenti variabili:

$DomainName = "example-gcp.com"
$DNS1 = "10.1.0.100"
$DNS2 = "10.2.0.100"
$LocalStaticIp = "10.3.0.2"
$DefaultGateway = "10.3.0.1"

Configura il server DNS principale:

netsh interface ip set dns Ethernet static $DNS1

Configura il server DNS secondario:

netsh interface ip add dns Ethernet $DNS2 index=2

Imposta l'indirizzo IP e il gateway predefinito:
```
netsh interface ip set address name=Ethernet static $LocalStaticIp 255.255.255.0 $DefaultGateway 1
```
Nota: RDP potrebbe perdere la connettività per alcuni secondi.

Aggiungi la VM al dominio:

Add-Computer -DomainName $DomainName `
    -Credential (Get-Credential "example-gcp\Administrator")

Quando ti viene chiesto di fornire una password per l'account amministratore, utilizza le credenziali amministratore che hai definito durante l'installazione di una foresta di Active Directory nel tutorial precedente. Come nome utente, aggiungi il nome di dominio come prefisso, ad esempio EXAMPLE-GCP\Administrator.

Aggiungi regole firewall di Windows:

netsh advfirewall firewall add rule name="5022 for Avail Groups" dir=in action=allow protocol=TCP localport=5022
netsh advfirewall firewall add rule name="1433 for SQL Server" dir=in action=allow protocol=TCP localport=1433

Installa la funzionalità di clustering di failover:

Install-WindowsFeature Failover-Clustering -IncludeManagementTools

Riavvia l'istanza:
```
Restart-Computer
```

Configura il cluster di failover di Windows Server

Utilizza RDP per la connessione all'istanza bookshelf-sql1. Quando ti viene chiesto di fornire una password per l'account amministratore, utilizza le credenziali di amministratore definite durante l'installazione di una foresta di Active Directory nel tutorial precedente. Come nome utente, aggiungi il nome di dominio come prefisso, ad esempio EXAMPLE-GCP\Administrator.
Apri una finestra della console di PowerShell come amministratore.
Nella finestra della console di PowerShell, imposta le seguenti variabili:
```
$node1 = "bookshelf-sql1"
$node2 = "bookshelf-sql2"
```
Imposta il nome del cluster:
```
$nameWSFC = "bookshelf-dbclus"
```

Imposta gli indirizzi IP per i cluster e i listener di cluster:

$ipWSFC1 = "10.3.0.4"
$ipWSFC2 = "10.4.0.4"
$ipWSListener1 = "10.3.0.5"
$ipWSListener2 = "10.4.0.5"

Assicurati che l'istanza SQL Server bookshelf-sql1 sia pronta per entrare nel cluster. Esegui lo script seguente, che tenta di connettersi all'istanza SQL Server:

$SQLServer1IsReady=$False
For ($i=0; $i -le 30; $i++) {
    $SqlCatalog = "master"
    $SqlConnection = New-Object System.Data.SqlClient.SqlConnection
    $SqlConnection.ConnectionString = "Server = $node1;" + `
         "Database = $SqlCatalog; Integrated Security = True"
    try {
        $SqlConnection.Open()
        Write-Host "Connection to the server $node1 was successful"
        $SQLServer1IsReady=$True
        $SqlConnection.Close()
        break
    }
    catch {
        Write-Host "SQL server $node1 is not ready, waiting for 60s"
        Start-Sleep -s 60 #Wait for 60 seconds
    }
}
if($SQLServer1IsReady -eq $False) {
    Write-Error "$node1 is not responding. Was it deployed correctly?"
}

Assicurati che l'istanza SQL Server bookshelf-sql2 sia pronta per entrare nel cluster:

$SQLServer2IsReady=$False
For ($i=0; $i -le 30; $i++) {
    $SqlCatalog = "master"
    $SqlConnection = New-Object System.Data.SqlClient.SqlConnection
    $SqlConnection.ConnectionString = "Server = $node2;" + `
        "Database = $SqlCatalog; Integrated Security = True"
    try {
        $SqlConnection.Open()
        Write-Host "Connection to the server $node2 was successful"
        $SQLServer2IsReady=$True
        $SqlConnection.Close()
        break
    }
    catch {
        Write-Host "SQL server $node2 is not ready, waiting for 60s"
        Start-Sleep -s 60 #Wait for 60 seconds
    }
}
if($SQLServer2IsReady -eq $False) {
    Write-Error "$node2 is not responding. Was it deployed correctly?"
}

Crea il nuovo cluster:

New-Cluster -Name $nameWSFC -Node $node1, $node2 -NoStorage `
    -StaticAddress $ipWSFC1, $ipWSFC2

Abilita la funzionalità dei gruppi di disponibilità sempre attivi su entrambi i nodi:

Enable-SqlAlwaysOn -ServerInstance $node1 -Force
Enable-SqlAlwaysOn -ServerInstance $node2 -Force

Crea cartelle per i dati del database e i file di log:

New-Item -ItemType directory -Path C:\SQLData
New-Item -ItemType directory -Path C:\SQLLog

Configurare il database

Questo tutorial utilizza il database di esempio bookshelf, creato per verificare che la configurazione funzioni correttamente.

Nella finestra della console di PowerShell in cui hai lavorato, esegui la seguente istruzione SQL per creare il database bookshelf:

$CreateDatabaseSQLScript =  @"
CREATE DATABASE bookshelf ON PRIMARY
    (NAME = 'bookshelf_Data', FILENAME='C:\SQLData\bookshelf_data.mdf', SIZE =
256MB, MAXSIZE = UNLIMITED, FILEGROWTH = 256MB )
    LOG ON (NAME = 'bookshelf_log', FILENAME='C:\SQLLog\bookshelf_log.ldf',
SIZE = 256MB, MAXSIZE = UNLIMITED, FILEGROWTH = 256MB )
GO
USE [bookshelf]
Exec dbo.sp_changedbowner @loginame = 'sa', @map = false;
ALTER DATABASE [bookshelf] SET RECOVERY FULL;
GO
BACKUP DATABASE bookshelf to disk =
'\\bookshelf-sql2\SQLBackup\bookshelf.bak' WITH INIT
GO
"@
Invoke-Sqlcmd -Query $CreateDatabaseSQLScript -ServerInstance $node1

Esegui questa istruzione SQL per creare la tabella Books:

$CreateTableSQLScript =  @"
USE [bookshelf]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
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
"@
Invoke-Sqlcmd -Query $CreateTableSQLScript -ServerInstance $node1

Imposta le variabili seguenti:

$Domain = "example-gcp.com"
$ADControllerFQDN = "ad-dc1.$Domain"
$ServiceAccountName = "sql.service"
$ServiceAccountPrincipalName = "$ServiceAccountName@$Domain"

Attiva il cmdlet RSAT-AD-PowerShell con il seguente comando di PowerShell:
```
Add-WindowsFeature RSAT-AD-PowerShell
```
Per creare un account di servizio dalla VM sono necessari strumenti di amministrazione del server remoto.

Aggiungi un account di servizio di database denominato sql.service all'interno del dominio:

New-ADUser -Name $ServiceAccountName `
    -Server $ADControllerFQDN `
    -SamAccountName $ServiceAccountName `
    -UserPrincipalName $ServiceAccountPrincipalName `
    -AccountPassword (Read-Host -AsSecureString "AccountPassword") `
    -PassThru | Enable-ADAccount

Quando ti viene chiesto di inserire la password per l'account sql.service, utilizza una password efficace e memorizzala in un luogo sicuro per utilizzarla in futuro.

Esegui la seguente istruzione SQL per aggiungere l'account EXAMPLE-GCP\sql.service come amministratore di database:

$AddSQLServiceAccountScript =  @"
USE [master]
GO
    CREATE LOGIN [EXAMPLE-GCP\sql.service] FROM WINDOWS WITH
DEFAULT_DATABASE=[bookshelf], DEFAULT_LANGUAGE=[us_english]
GO
USE [bookshelf]
GO
CREATE USER [EXAMPLE-GCP\sql.service] FOR LOGIN [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_accessadmin] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_backupoperator] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_datareader] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_datawriter] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_ddladmin] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_owner] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
USE [bookshelf]
GO
ALTER ROLE [db_securityadmin] ADD MEMBER [EXAMPLE-GCP\sql.service]
GO
"@
Invoke-Sqlcmd -Query $AddSQLServiceAccountScript -ServerInstance $node1

Configura il gruppo di disponibilità SQL Server

Mentre sei ancora nel caso in cui hai lavorato, imposta le seguenti variabili:

$Database="bookshelf"
$BackupFolder="SQLBackup"
$SharedLocation="\\$node2\$BackupFolder"
$ListenerName="sql-listener"
$AGName="MainAG"
$PrimaryServer = "$node1.$Domain\MSSQLSERVER"
$SecondaryServer = "$node2.$Domain\MSSQLSERVER"

Esegui il backup del database sul server principale:

Backup-SqlDatabase `
    -Database $Database -Initialize `
    -BackupFile "$SharedLocation\$Database.bak" `
    -ServerInstance $node1

Ripristina il database sul server secondario:

Restore-SqlDatabase `
    -Database $Database `
    -BackupFile "$SharedLocation\$Database.bak" `
    -ServerInstance $node2 `
    -NORECOVERY

Esegui il backup del log del database sul server principale:

Backup-SqlDatabase `
    -Database $Database -Initialize `
    -BackupFile "$SharedLocation\$Database.log" `
    -ServerInstance $node1 `
    -BackupAction Log

Ripristina il log del database sul server secondario:

Restore-SqlDatabase `
    -Database $Database `
    -BackupFile "$SharedLocation\$Database.log" `
    -ServerInstance $node2 `
    -RestoreAction Log `
    -NORECOVERY

Crea e quindi avvia gli endpoint:

$endpoint1=New-SqlHADREndpoint -Port 5022 -Owner sa `
    -Encryption Supported -EncryptionAlgorithm Aes `
    -Name AlwaysonEndpoint1 `
    -Path "SQLSERVER:\SQL\$node1.$Domain\Default"
Set-SqlHADREndpoint -InputObject $endpoint1 -State Started
$endpoint2=New-SqlHADREndpoint -Port 5022 -Owner sa `
    -Encryption Supported -EncryptionAlgorithm Aes `
    -Name AlwaysonEndpoint2 `
    -Path "SQLSERVER:\SQL\$node2.$Domain\Default"
Set-SqlHADREndpoint -InputObject $endpoint2 -State Started

L'output è il seguente:

AlwaysonEndpoint1       STARTED            5022 - for node1
AlwaysonEndpoint2       STARTED            5022 - for node2

Verifica la configurazione eseguendo questi comandi in PowerShell:

$node1 = "bookshelf-sql1"
$node2 = "bookshelf-sql2"
Invoke-Sqlcmd -Query "select name, state_desc, port FROM sys.tcp_endpoints" -ServerInstance $node1
Invoke-Sqlcmd -Query "select name, state_desc, port FROM sys.tcp_endpoints" -ServerInstance $node2

Se la configurazione è corretta, visualizzi l'output in questo modo:

name                       state_desc port
----                       ---------- ----
Dedicated Admin Connection STARTED       0
TSQL Default TCP           STARTED       0
AlwaysonEndpoint1          STARTED    5022
Dedicated Admin Connection STARTED       0
TSQL Default TCP           STARTED       0
AlwaysonEndpoint2          STARTED    5022

Imposta gli URL endpoint:

$EndpointUrlSQLServer1="TCP://" + $node1 + "." + $Domain + ":5022"
$EndpointUrlSQLServer2="TCP://" + $node2 + "." + $Domain + ":5022"

Crea una rappresentazione in memoria delle repliche:

$PrimaryReplica = New-SqlAvailabilityReplica -Name $node1 `
    -EndpointUrl $EndpointUrlSQLServer1 `
    -FailoverMode "Automatic" `
    -AvailabilityMode "SynchronousCommit" `
    -AsTemplate -Version 13
$SecondaryReplica = New-SqlAvailabilityReplica -Name $node2 `
    -EndpointUrl $EndpointUrlSQLServer2 `
    -FailoverMode "Automatic" `
    -AvailabilityMode "SynchronousCommit" `
    -AsTemplate -Version 13

Crea il gruppo di disponibilità:

New-SqlAvailabilityGroup -Name $AGName `
    -AvailabilityReplica @($PrimaryReplica, $SecondaryReplica) `
    -Path "SQLSERVER:\SQL\$node1.$Domain\Default" `
    -Database $Database

Unisci l'istanza secondaria al gruppo di disponibilità:

Join-SqlAvailabilityGroup -Path "SQLSERVER:\SQL\$node2\Default" -Name $AGName

Unisci il database secondario al gruppo di disponibilità:

Add-SqlAvailabilityDatabase `
    -Path "SQLSERVER:\SQL\$node2\Default\AvailabilityGroups\$AGName" `
    -Database $Database

Crea il listener:

New-SqlAvailabilityGroupListener -Name $ListenerName `
    -Port 1433 `
    -StaticIp @("$ipWSListener1/255.255.255.0","$ipWSListener2/255.255.255.0") `
    -Path SQLSERVER:\Sql\$node1\Default\AvailabilityGroups\$AGName

Rimuovi la cartella condivisa, che non è più necessaria:

For ($i=0; $i -le 30; $i++) {
    try {
        Remove-Item \\$node2\c$\$BackupFolder -Force -Recurse -ErrorAction Stop
        Write-Host "Shared folder $SharedLocation was removed"
        break
    }
    catch {
        Write-Host "\\$node2\c$\$BackupFolder is in use waiting 1m to retry"
        Start-Sleep -s 60
    }
}

Esegui la pulizia

Se vuoi continuare con il tutorial successivo di questa serie (Deployment di server web IIS con bilanciamento del carico), mantieni le risorse che hai creato in questo tutorial. Tuttavia, se non intendi utilizzare l'ambiente che hai creato in questo tutorial, vai alla pulizia delle risorse che hai creato su Google Cloud e non riceverai addebiti. Le seguenti sezioni descrivono come eliminare o disattivare queste risorse.

Elimina 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à in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro 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 il progetto che vuoi eliminare, quindi fai clic su Elimina.

Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Eliminazione di istanze

Se non vuoi eliminare completamente il progetto, puoi eliminare le risorse specifiche che hai creato.

Per eliminare un'istanza di Compute Engine:

Nella console Google Cloud, vai alla pagina Istanze VM.

Vai alla pagina Istanze VM
Seleziona le istanze che vuoi eliminare.
Nella parte superiore della pagina, fai clic su Elimina per eliminare le istanze.

Eliminazione delle reti VPC

Per eliminare la rete VPC, le subnet e le regole firewall:

Nella console Google Cloud, vai alla pagina Reti VPC.

Vai alla pagina Reti VPC
Seleziona la rete VPC che hai creato.
Nella parte superiore della pagina, fai clic su Elimina per eliminare la rete.

Passaggi successivi

Vai al prossimo tutorial di questa serie:
- Deployment dei server web IIS con bilanciamento del carico
Scopri di più su SQL Server su Google Cloud:
Consulta le best practice per la progettazione di carichi di lavoro scalabili e ad alta disponibilità.
Esplora architetture di riferimento, diagrammi e best practice su Google Cloud. Dai un'occhiata al nostro Centro di architettura cloud.