Implementa un grupo de disponibilidad Always On de SQL Server 2016 de varias subredes en Compute Engine

Este instructivo es la segunda parte de una serie que te ayuda a implementar un entorno de Windows de alta disponibilidad en Google Cloud con Microsoft Active Directory, SQL Server 2016 y servicios de información de Internet (IIS). En este instructivo, crearás dos instancias de SQL Server en diferentes zonas de la misma región y las configurarás como un grupo de disponibilidad Always On de SQL Server con varias subredes.

La serie consta de estos instructivos:

Cada instructivo continúa con la infraestructura que creaste en el anterior.

Objetivos

  • Crear dos subredes que abarquen dos zonas.
  • Implementar una máquina virtual (VM) de Microsoft SQL Server 2016 en cada zona.
  • Configurar cada instancia de SQL Server para unirlas a tu dominio de Active Directory.
  • Crear un clúster de conmutación por error en Windows Server
  • Crear y configurar una base de datos bookshelf de muestra de SQL Server
  • Configurar el grupo de disponibilidad Always On de SQL Server

Costos

En este instructivo, seguirás usando los recursos de Google Cloud que configuraste en instructivos anteriores. Usarás los siguientes componentes facturables:

La estimación de costos de la calculadora de precios para este entorno es de aproximadamente $98 por día; este precio incluye las licencias de SQL Server 2016 Enterprise y el entorno de dos servidores de Active Directory.

Antes de comenzar

Para la configuración que usarás en este instructivo, se requiere que tengas acceso a un controlador de dominio de Windows y a un dominio de Active Directory en funcionamiento. Si aún no tienes este entorno, completa los pasos de los siguientes instructivos:

Cómo inicializar variables comunes

Debes definir varias variables del entorno para controlar en qué lugar se implementan los elementos de la infraestructura.

  1. En un editor de texto, crea una secuencia de comandos con las siguientes variables de entorno para especificar el ID del proyecto, junto con la región y las zonas que quieres usar.

    Las variables establecen la región como us-east1. Si en el instructivo anterior usaste otra región, cambia la región de esta secuencia de comandos para que coincida con la anterior.

    region=us-east1
    zone_1=${region}-b
    zone_2=${region}-c
    vpc_name=webappnet
    project_id=your-project-id
    

    Reemplaza your-project-id por el ID del proyecto de Cloud que usas.

  2. Abre Cloud Shell:

    Abrir Cloud Shell

  3. Copia la secuencia de comandos en tu ventana de Cloud Shell y ejecútala.

  4. Configura la región predeterminada y el ID del proyecto para que no tengas que especificar estos valores en cada comando posterior:

    gcloud config set compute/region ${region}
    gcloud config set project ${project_id}
    

Crea la infraestructura de red

Luego de definir las variables de la infraestructura, creas las subredes que utiliza SQL Server.

  1. Agrega subredes nuevas a tu red de nube privada virtual (VPC) existente:

    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 regla de firewall interna para permitir el tráfico entre las subredes private-ad* que creaste antes y las subredes private-sql* nuevas:

    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
    

Cómo crear instancias de SQL Server

A continuación, crearás dos VM de SQL Server 2016 Enterprise a través de las imágenes preconfiguradas de Compute Engine, con las siguientes propiedades:

  • Nombres: bookshelf-sql1 y bookshelf-sql2
  • Tamaño de disco de arranque: 200GB
  • Tipo de máquina: n1-highmem-4

Si quieres utilizar este entorno con fines distintos a los de este instructivo y necesitas recursos informáticos adicionales, puedes personalizar el tipo de máquina para estas instancias más adelante. También puedes agregar discos y cambiar el tamaño del disco persistente.

En este instructivo, se utiliza SQL Server en la imagen pública de Windows Server para tus VM, lo que significa que se te facturará por el uso de SQL Server. También puedes implementar tus licencias existentes de SQL Server en Compute Engine a través de la movilidad de licencias con Software Assurance y aplicar esas licencias luego de instalar SQL Server en cualquiera de las imágenes públicas de Windows Server.

  1. Crea una instancia de Compute Engine de Windows Server 2016 a través de 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 segunda instancia:

    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 la instancia bookshelf-sql2

A continuación, configura la instancia bookshelf-sql2. Comenzarás con la segunda instancia porque se requiere trabajo adicional para configurar la base de datos en bookshelf-sql1, mientras que configurar bookshelf-sql2 primero requiere menos sesiones de protocolo de escritorio remoto (RDP).

  1. Crea una contraseña para la instancia bookshelf-sql2 de Windows:

    gcloud compute reset-windows-password bookshelf-sql2 \
        --zone ${zone_2} --quiet
    

    El nombre de usuario es el mismo que el de tu Cuenta de Google. Toma nota del nombre de usuario y contraseña para utilizarlos más adelante.

  2. Usa RDP para conectarte a la instancia de SQL Server mediante las credenciales que creaste anteriormente.

  3. En la instancia, abre la terminal de PowerShell como Administrador (haz clic en Inicio, escribe PowerShell y, luego, presiona Control+Shift+Enter).

  4. Configura las siguientes variables:

    $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 el servidor DNS principal:

    netsh interface ip set dns Ethernet static $DNS1
  6. Configura el servidor DNS secundario:

    netsh interface ip add dns Ethernet $DNS2 index=2
  7. Configura la dirección IP y la puerta de enlace predeterminada:

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

    Add-Computer -DomainName $DomainName `
        -Credential (Get-Credential "example-gcp\Administrator")
    
  9. Cuando se te solicite que proporciones una contraseña para la cuenta de Administrator, usa las credenciales de administrador que definiste cuando instalaste un bosque de Active Directory en el instructivo anterior. Para el nombre de usuario, agrega el nombre de dominio como un prefijo, como en EXAMPLE-GCP\Administrator.

  10. Abre puertos de firewall de Windows para el grupo de disponibilidad de 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. Instala la característica de clúster de conmutación por error:

    Install-WindowsFeature Failover-Clustering -IncludeManagementTools
  12. Reinicia la instancia:

    Restart-Computer
  13. Usa el RDP para conectarte a la instancia de SQL Server mediante las credenciales de la cuenta EXAMPLE-GCP\Administrator.

  14. Abre una ventana de consola de PowerShell como Administrador.

  15. En la ventana de consola de PowerShell, crea las carpetas para tus datos y archivos de registro de SQL Server:

    New-Item -ItemType directory -Path C:\SQLData
    New-Item -ItemType directory -Path C:\SQLLog
    
  16. Crea una carpeta nueva para las copias de seguridad de la base de datos y compártela:

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

Configura la instancia bookshelf-sql1

A continuación, configura la instancia bookshelf-sql1.

  1. En Cloud Shell, crea una contraseña para la instancia bookshelf-sql1 de Windows:

    gcloud compute reset-windows-password bookshelf-sql1 --zone ${zone_1}  --quiet

    El nombre de usuario es el mismo que el de tu Cuenta de Google. Toma nota del nombre de usuario y la contraseña para usarlos más adelante.

  2. Usa el RDP a fin de conectarte a la instancia de SQL Server mediante las credenciales que creaste para la instancia bookshelf-sql1.

  3. Abre una ventana de consola de PowerShell como Administrador.

  4. En la ventana de la consola de PowerShell, configura las siguientes variables:

    $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 el servidor DNS principal:

    netsh interface ip set dns Ethernet static $DNS1
  6. Configura el servidor DNS secundario:

    netsh interface ip add dns Ethernet $DNS2 index=2
  7. Configura la dirección IP y la puerta de enlace predeterminada:

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

    Add-Computer -DomainName $DomainName `
        -Credential (Get-Credential "example-gcp\Administrator")
    
  9. Cuando se te solicite que ingreses una contraseña para la cuenta de Administrador, utiliza las credenciales de Administrador que definiste cuando instalaste el bosque de Active Directory en el instructivo anterior. Para el nombre de usuario, agrega el nombre de dominio como un prefijo, como en EXAMPLE-GCP\Administrator.

  10. Agrega reglas del firewall de 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. Instala la característica de clúster de conmutación por error:

    Install-WindowsFeature Failover-Clustering -IncludeManagementTools
  12. Reinicia la instancia:

    Restart-Computer

Configura el clúster de conmutación por error de Windows Server

  1. Usa el RDP para conectarte a la instancia bookshelf-sql1. Cuando se te solicite que ingreses una contraseña para la cuenta de administrador, usa las credenciales de administrador que definiste cuando instalaste el bosque de Active Directory en el instructivo anterior. Para el nombre de usuario, agrega el nombre de dominio como un prefijo, como en EXAMPLE-GCP\Administrator.

  2. Abre una ventana de consola de PowerShell como Administrador.

  3. En la ventana de la consola de PowerShell, configura las siguientes variables:

    $node1 = "bookshelf-sql1"
    $node2 = "bookshelf-sql2"
    
  4. Configura el nombre del clúster:

    $nameWSFC = "bookshelf-dbclus"
  5. Establece las direcciones IP para los clústeres y sus objetos de escucha:

    $ipWSFC1 = "10.3.0.4"
    $ipWSFC2 = "10.4.0.4"
    $ipWSListener1 = "10.3.0.5"
    $ipWSListener2 = "10.4.0.5"
    
  6. Asegúrate de que la instancia bookshelf-sql1 de SQL Server esté lista para unirse al clúster. Ejecuta la siguiente secuencia de comandos para intentar establecer la conexión con la instancia de 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. Asegúrate de que la instancia de bookshelf-sql2 SQL Server esté lista para unirse al clúster:

    $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 un clúster nuevo:

    New-Cluster -Name $nameWSFC -Node $node1, $node2 -NoStorage `
        -StaticAddress $ipWSFC1, $ipWSFC2
    
  9. Habilita la característica de grupos de disponibilidad Always On en ambos nodos:

    Enable-SqlAlwaysOn -ServerInstance $node1 -Force
    Enable-SqlAlwaysOn -ServerInstance $node2 -Force
    
  10. Crea carpetas para los datos y los archivos de registro de la base de datos:

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

Configura la base de datos

En este instructivo, se usa la base de datos bookshelf de ejemplo, que creas para probar que tu configuración funciona de forma correcta.

  1. En la ventana de la consola de PowerShell en la que trabajas, ejecuta la siguiente instrucción de SQL para crear la base de datos 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. Ejecuta la siguiente instrucción de SQL para crear la tabla 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. Configura las siguientes variables:

    $Domain = "example-gcp.com"
    $ADControllerFQDN = "ad-dc1.$Domain"
    $ServiceAccountName = "sql.service"
    $ServiceAccountPrincipalName = "$ServiceAccountName@$Domain"
    
  4. Activa RSAT-AD-PowerShell cmdlet mediante el siguiente comando de PowerShell:

    Add-WindowsFeature RSAT-AD-PowerShell

    Necesitarás las Herramientas de administración remota del servidor para crear una cuenta de servicio desde la VM.

  5. Agrega una cuenta de servicio de base de datos llamada sql.service dentro del dominio:

    New-ADUser -Name $ServiceAccountName `
        -Server $ADControllerFQDN `
        -SamAccountName $ServiceAccountName `
        -UserPrincipalName $ServiceAccountPrincipalName `
        -AccountPassword (Read-Host -AsSecureString "AccountPassword") `
        -PassThru | Enable-ADAccount
    
  6. Cuando se te solicite que ingreses la contraseña de la cuenta sql.service, usa una contraseña segura y almacénala en una ubicación segura para usarla más adelante.

  7. Ejecuta la siguiente instrucción de SQL para agregar la cuenta EXAMPLE-GCP\sql.service como administrador de la base de datos:

    $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 el grupo de disponibilidad de SQL Server

  1. En la instancia en la que estuviste trabajando, configura las siguientes variables:

    $Database="bookshelf"
    $BackupFolder="SQLBackup"
    $SharedLocation="\\$node2\$BackupFolder"
    $ListenerName="sql-listener"
    $AGName="MainAG"
    $PrimaryServer = "$node1.$Domain\MSSQLSERVER"
    $SecondaryServer = "$node2.$Domain\MSSQLSERVER"
    
  2. Crea una copia de seguridad de tu base de datos en el servidor principal:

    Backup-SqlDatabase `
        -Database $Database -Initialize `
        -BackupFile "$SharedLocation\$Database.bak" `
        -ServerInstance $node1
    
  3. Restablece la base de datos en el servidor secundario:

    Restore-SqlDatabase `
        -Database $Database `
        -BackupFile "$SharedLocation\$Database.bak" `
        -ServerInstance $node2 `
        -NORECOVERY
    
  4. Crea una copia de seguridad del registro de la base de datos en el servidor principal:

    Backup-SqlDatabase `
        -Database $Database -Initialize `
        -BackupFile "$SharedLocation\$Database.log" `
        -ServerInstance $node1 `
        -BackupAction Log
    
  5. Restablece el registro de la base de datos en el servidor secundario:

    Restore-SqlDatabase `
        -Database $Database `
        -BackupFile "$SharedLocation\$Database.log" `
        -ServerInstance $node2 `
        -RestoreAction Log `
        -NORECOVERY
    
  6. Crea y, luego, inicia los extremos:

    $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
    

    El resultado es el siguiente:

    AlwaysonEndpoint1       STARTED            5022 - for node1
    AlwaysonEndpoint2       STARTED            5022 - for node2
    
  7. Ejecuta los siguientes comandos de PowerShell para verificar la configuración:

    $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
    

    Si la configuración es correcta, verás un resultado como el siguiente:

    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. Configura la URL del extremo:

    $EndpointUrlSQLServer1="TCP://" + $node1 + "." + $Domain + ":5022"
    $EndpointUrlSQLServer2="TCP://" + $node2 + "." + $Domain + ":5022"
    
  9. Crea una representación de las réplicas en la memoria:

    $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 el grupo de disponibilidad:

    New-SqlAvailabilityGroup -Name $AGName `
        -AvailabilityReplica @($PrimaryReplica, $SecondaryReplica) `
        -Path "SQLSERVER:\SQL\$node1.$Domain\Default" `
        -Database $Database
    
  11. Une la instancia secundaria al grupo de disponibilidad:

    Join-SqlAvailabilityGroup -Path "SQLSERVER:\SQL\$node2\Default" -Name $AGName
  12. Une la base de datos secundaria al grupo de disponibilidad:

    Add-SqlAvailabilityDatabase `
        -Path "SQLSERVER:\SQL\$node2\Default\AvailabilityGroups\$AGName" `
        -Database $Database
    
  13. Crea el objeto de escucha:

    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. Quita la carpeta compartida, que ya no se necesita:

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

Realiza una limpieza

Si deseas continuar con el siguiente instructivo de esta serie (Implementa servidores web IIS con balanceo de cargas), conserva los recursos que creaste en este instructivo. Sin embargo, si no pretendes usar el entorno que creaste en este instructivo, realiza una limpieza de los recursos que creaste en Google Cloud para que no se te facture por ellos. En las siguientes secciones, se describe cómo borrarlos o desactivarlos.

Borra el proyecto

  • En Cloud Console, ve a la página Administrar recursos.

    Ir a la página Administrar recursos

  • En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar .
  • En el cuadro de diálogo, escribe el ID del proyecto y haz clic en Cerrar para borrar el proyecto.
  • Borra instancias

    Si no quieres borrar tu proyecto por completo, puedes borrar los recursos específicos que hayas creado.

    Para borrar una instancia de Compute Engine:

    1. En Cloud Console, ve a la página Instancias de VM.

      Ir a la página Instancias de VM

    2. Selecciona las instancias que quieres borrar.

    3. En la parte superior de la página, haz clic en Borrar para borrar las instancias.

    Cómo borrar redes de VPC

    Si deseas borrar la red de VPC, las subredes y las reglas de firewall, haz lo siguiente:

    1. En Cloud Console, ve a la página Redes de VPC.

      Ir a la página Redes de VPC

    2. Selecciona la red de VPC que creaste.

    3. En la parte superior de la página, haz clic en Borrar para borrar la red.

    ¿Qué sigue?