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:

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.

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

  2. Apri Cloud Shell:

    Apri Cloud Shell

  3. Copia lo script nella finestra di Cloud Shell ed eseguilo.

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

  1. 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
    
  2. 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
    

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.

  1. 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
    
  2. 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).

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

  2. Utilizza RDP per connetterti all'istanza SQL Server utilizzando le credenziali create in precedenza.

  3. Nell'istanza, apri un terminale PowerShell come Amministratore. Fai clic su Start, digita PowerShell e premi Control+Shift+Enter.

  4. 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"
    
  5. Configura il server DNS principale:

    netsh interface ip set dns Ethernet static $DNS1
  6. Configura il server DNS secondario:

    netsh interface ip add dns Ethernet $DNS2 index=2
  7. Imposta l'indirizzo IP e il gateway predefinito:

    netsh interface ip set address name=Ethernet static $LocalStaticIp 255.255.255.0 $DefaultGateway 1
  8. Aggiungi la VM al dominio Windows:

    Add-Computer -DomainName $DomainName `
        -Credential (Get-Credential "example-gcp\Administrator")
    
  9. 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.

  10. 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
    
  11. Installa la funzionalità di clustering di failover:

    Install-WindowsFeature Failover-Clustering -IncludeManagementTools
  12. Riavvia l'istanza:

    Restart-Computer
  13. Utilizza RDP per la connessione all'istanza SQL Server utilizzando le credenziali per l'account EXAMPLE-GCP\Administrator.

  14. Apri una finestra della console di PowerShell come amministratore.

  15. 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
    
  16. 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.

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

  2. Utilizza RDP per connetterti all'istanza SQL Server utilizzando le credenziali create per l'istanza bookshelf-sql1.

  3. Apri una finestra della console di PowerShell come amministratore.

  4. 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"
    
  5. Configura il server DNS principale:

    netsh interface ip set dns Ethernet static $DNS1
  6. Configura il server DNS secondario:

    netsh interface ip add dns Ethernet $DNS2 index=2
  7. Imposta l'indirizzo IP e il gateway predefinito:

    netsh interface ip set address name=Ethernet static $LocalStaticIp 255.255.255.0 $DefaultGateway 1
  8. Aggiungi la VM al dominio:

    Add-Computer -DomainName $DomainName `
        -Credential (Get-Credential "example-gcp\Administrator")
    
  9. 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.

  10. 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
    
  11. Installa la funzionalità di clustering di failover:

    Install-WindowsFeature Failover-Clustering -IncludeManagementTools
  12. Riavvia l'istanza:

    Restart-Computer

Configura il cluster di failover di Windows Server

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

  2. Apri una finestra della console di PowerShell come amministratore.

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

    $node1 = "bookshelf-sql1"
    $node2 = "bookshelf-sql2"
    
  4. Imposta il nome del cluster:

    $nameWSFC = "bookshelf-dbclus"
  5. 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"
    
  6. 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?"
    }
    
  7. 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?"
    }
    
  8. Crea il nuovo cluster:

    New-Cluster -Name $nameWSFC -Node $node1, $node2 -NoStorage `
        -StaticAddress $ipWSFC1, $ipWSFC2
    
  9. Abilita la funzionalità dei gruppi di disponibilità sempre attivi su entrambi i nodi:

    Enable-SqlAlwaysOn -ServerInstance $node1 -Force
    Enable-SqlAlwaysOn -ServerInstance $node2 -Force
    
  10. 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.

  1. 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
    
  2. 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
    
  3. Imposta le variabili seguenti:

    $Domain = "example-gcp.com"
    $ADControllerFQDN = "ad-dc1.$Domain"
    $ServiceAccountName = "sql.service"
    $ServiceAccountPrincipalName = "$ServiceAccountName@$Domain"
    
  4. 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.

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

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

  1. 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"
    
  2. Esegui il backup del database sul server principale:

    Backup-SqlDatabase `
        -Database $Database -Initialize `
        -BackupFile "$SharedLocation\$Database.bak" `
        -ServerInstance $node1
    
  3. Ripristina il database sul server secondario:

    Restore-SqlDatabase `
        -Database $Database `
        -BackupFile "$SharedLocation\$Database.bak" `
        -ServerInstance $node2 `
        -NORECOVERY
    
  4. Esegui il backup del log del database sul server principale:

    Backup-SqlDatabase `
        -Database $Database -Initialize `
        -BackupFile "$SharedLocation\$Database.log" `
        -ServerInstance $node1 `
        -BackupAction Log
    
  5. Ripristina il log del database sul server secondario:

    Restore-SqlDatabase `
        -Database $Database `
        -BackupFile "$SharedLocation\$Database.log" `
        -ServerInstance $node2 `
        -RestoreAction Log `
        -NORECOVERY
    
  6. 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
    
  7. 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
    
  8. Imposta gli URL endpoint:

    $EndpointUrlSQLServer1="TCP://" + $node1 + "." + $Domain + ":5022"
    $EndpointUrlSQLServer2="TCP://" + $node2 + "." + $Domain + ":5022"
    
  9. 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
    
  10. Crea il gruppo di disponibilità:

    New-SqlAvailabilityGroup -Name $AGName `
        -AvailabilityReplica @($PrimaryReplica, $SecondaryReplica) `
        -Path "SQLSERVER:\SQL\$node1.$Domain\Default" `
        -Database $Database
    
  11. Unisci l'istanza secondaria al gruppo di disponibilità:

    Join-SqlAvailabilityGroup -Path "SQLSERVER:\SQL\$node2\Default" -Name $AGName
  12. Unisci il database secondario al gruppo di disponibilità:

    Add-SqlAvailabilityDatabase `
        -Path "SQLSERVER:\SQL\$node2\Default\AvailabilityGroups\$AGName" `
        -Database $Database
    
  13. 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
    
  14. 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

  • 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.
  • 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:

    1. Nella console Google Cloud, vai alla pagina Istanze VM.

      Vai alla pagina Istanze VM

    2. Seleziona le istanze che vuoi eliminare.

    3. 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:

    1. Nella console Google Cloud, vai alla pagina Reti VPC.

      Vai alla pagina Reti VPC

    2. Seleziona la rete VPC che hai creato.

    3. Nella parte superiore della pagina, fai clic su Elimina per eliminare la rete.

    Passaggi successivi