Configura grupos de disponibilidad AlwaysOn de SQL Server con confirmación síncrona

Los grupos de disponibilidad AlwaysOn (AG) de Microsoft SQL Server te permiten replicar bases de datos en varias instancias de SQL Server Enterprise.

Al igual que las instancias de clústeres de conmutación por error de SQL Server, los grupos de disponibilidad AlwaysOn usan clústeres de conmutación por error de Windows Server (WSFC) para implementar la alta disponibilidad. Sin embargo, hay varias diferencias entre las dos funciones:

Grupos de disponibilidad AlwaysOn Instancias de clústeres de conmutación por error
Alcance de la conmutación por error Grupo de bases de datos Instancia
Almacenamiento No compartido Compartido

Para obtener una comparación más detallada, consulta Comparación de instancias de clústeres de conmutación por error y grupos de disponibilidad.

Los grupos de disponibilidad siempre activados admiten varios modos de disponibilidad. En este instructivo, se muestra cómo puedes implementar grupos de disponibilidad AlwaysOn en modo de confirmación síncrona para implementar una alta disponibilidad de una o más bases de datos:

Arquitectura

Dos instancias de VM, node-1 y node-2, funcionan como nodos de WSFC y ejecutan SQL Server. Una tercera instancia de VM, witness, se usa para lograr un quórum en una situación de conmutación por error. Las tres instancias de VM se distribuyen en tres zonas y comparten una subred común.

Si usas grupo de disponibilidad Always On de SQL Server, una base de datos de ejemplo, bookshelf, se replica de forma síncrona en las dos instancias de SQL Server. Los clientes se comunican con SQL Server a través de un balanceador de cargas de TCP interno que está configurado para enrutar el tráfico al nodo que en el momento aloja la réplica de la base de datos principal.

En el artículo, se supone que ya implementaste Active Directory en Google Cloud y que tienes conocimientos básicos de SQL Server, Active Directory y Compute Engine.

Objetivos

  • Implementa un WSFC que incluya dos instancias de VM de SQL Server y una tercera instancia de VM que actúe como testigo de archivos compartidos.
  • Implementa un SQL Server.
  • Crea un grupo de disponibilidad con confirmación síncrona.
  • Verifica que la configuración esté en funcionamiento mediante la simulación de una conmutación por error.

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto.

Antes de comenzar

Para completar esta guía, necesitas lo siguiente:

  • Un dominio de Active Directory con al menos un controlador de dominio. Puedes crear un dominio de Active Directory mediante Microsoft AD administrado. También puedes implementar un entorno personalizado de Active Directory en Compute Engine y configurar una zona de reenvío de DNS privado que reenvíe las consultas de DNS a los controladores de tu dominio.
  • Un usuario de Active Directory que tenga permiso para unir computadoras al dominio y pueda acceder mediante RDP. Si usas Microsoft AD administrado, puedes usar el usuario setupadmin.
  • Un proyecto de Google Cloud y una VPC con conectividad a los controladores de dominio de Active Directory.
  • Una subred para usar en las instancias de VM de WSFC.

Para completar la guía, también necesitas un proyecto de GCP:

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

Cuando finalices este instructivo, puedes borrar los recursos creados para evitar que se te siga facturando. Para obtener más información, consulta Realiza una limpieza.

Prepara el proyecto y la red

Haz lo siguiente a fin de preparar tu proyecto de Google Cloud y la VPC para la implementación de grupos de disponibilidad AlwaysOn de SQL Server:

  1. En Google Cloud Console, haz clic en el botón Activar Cloud ShellActiva Cloud Shell. para abrir Cloud Shell.

    Ir a Google Cloud Console.

  2. Inicializa las siguientes variables:

    VPC_NAME=VPC_NAME
    SUBNET_NAME=SUBNET_NAME
    

    Aquí:

    • VPC_NAME: Es el nombre de tu VPC.
    • SUBNET_NAME: Es el nombre de tu subred.
  3. Establece tu ID del proyecto predeterminado:

    gcloud config set project PROJECT_ID
    

    Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

  4. Configura la región predeterminada:

    gcloud config set compute/region REGION
    

    Reemplaza REGION por el ID de la región en la que deseas realizar la implementación.

Crea reglas de firewall

Para permitir que los clientes se conecten a SQL Server, permitir la comunicación entre los nodos de WSFC y habilitar que el balanceador de cargas realice verificaciones de estado, debes crear varias reglas de firewall. Para simplificar la creación de estas reglas de firewall, debes usar las etiquetas de red:

  • Los 2 nodos del WSFC tienen anotaciones con la etiqueta wsfc-node.
  • Todos los servidores (incluido el testigo) están anotados con la etiqueta wsfc.

Crea reglas de firewall que usen estas etiquetas de red:

  1. Regresa a tu sesión actual de Cloud Shell.
  2. Crea reglas de firewall para los nodos del 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 regla de firewall que permita las verificaciones de estado de los rangos de IP de los sistemas de sondeo de Google Cloud:

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

Cree instancias de VM

Ahora implementará dos instancias de VM para el clúster de conmutación por error. En cualquier momento, una de estas VM aloja la réplica principal de la base de datos de SQL Server, mientras que el otro nodo aloja la réplica secundaria. Las dos instancias de VM deben cumplir estos requisitos:

  • deben encontrarse en la misma región para que un balanceador de cargas TCP interno pueda acceder a ellas
  • deben tener instalados clústeres de conmutación por error de Windows Server y SQL Server
  • deben tener habilitada la compatibilidad con WSFC de Compute Engine

Usa una imagen premium de SQL Server que tenga SQL Server 2019 preinstalado.

A fin de proporcionar un voto de desempate y lograr un quórum para la situación de conmutación por error, implementa una tercera VM que sirva como testigo de archivos compartidos.

  1. Regresa a tu sesión actual de Cloud Shell.
  2. Crea una secuencia de comandos de specialize para los nodos de WSFC. La secuencia de comandos instala la función necesaria de Windows y crea reglas de firewall para WSFC y 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. Crea las instancias de VM. En las dos VM que funcionan como nodos WSFC, conecta un disco de datos adicional y habilita el agrupamiento en clústeres de conmutación por error de Windows Server mediante la configuración de la clave de metadatos enable-wsfc en 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-2019-win-2019 \
      --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-2019-win-2019 \
      --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-2019 \
      --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. A fin de unir las 3 instancias de VM a Active Directory, haz lo siguiente para cada una de las 3 instancias de VM:

    1. Supervisa el proceso de inicialización de la VM cuando ves su salida de puerto en serie:

      gcloud compute instances tail-serial-port-output NAME
      

      Reemplaza NAME con el nombre de la instancia de VM.

      Espera unos 3 minutos hasta que veas el resultado Instance setup finished y presiona Ctrl+C. En este punto, la instancia de VM está lista para usarse.

    2. Crea un nombre de usuario y una contraseña para la instancia de VM.

    3. Conéctate a la VM mediante el escritorio remoto y accede con el nombre de usuario y la contraseña que creaste en el paso anterior.

    4. Haz clic derecho en el botón Iniciar (o presiona Windows+X) y, luego, haz clic en Windows PowerShell (Admin).

    5. Para confirmar el símbolo de elevación, haz clic en .

    6. Une la computadora a tu dominio de Active Directory y reiníciala:

      Add-Computer -Domain DOMAIN -Restart
      

      Reemplaza DOMAIN por el nombre de DNS de tu dominio de Active Directory.

      Espera aproximadamente 1 minuto para que se complete el reinicio.

Reserva direcciones IP del clúster

Ahora debes reservar dos direcciones IP estáticas en tu VPC. Una dirección IP se usa como la dirección IP del clúster de WSFC; la otra la usa el balanceador de cargas interno.

  1. Reserva una IP estática para el balanceador de cargas interno y captura la dirección en una variable de entorno nueva llamada 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"
    

    Anota la dirección IP, ya que la necesitarás más adelante.

  2. Reserva otra dirección IP estática que uses como IP del clúster:

    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"
    

    Anota la dirección IP, ya que la necesitarás más adelante.

Tu proyecto y VPC están listos para la implementación del WSFC y SQL Server.

Implementa el clúster de conmutación por error

Ahora usa las instancias de VM para implementar un WSFC y SQL Server.

Prepara SQL Server

Crea una cuenta de usuario nueva en Active Directory para SQL Server:

  1. Conéctate a node-1 mediante el escritorio remoto. Accede con tu cuenta de usuario de dominio.
  2. Haz clic derecho en el botón Iniciar (o presiona Windows+X) y, luego, haz clic en Windows PowerShell (Admin).
  3. Para confirmar el símbolo de elevación, haz clic en .
  4. Crea una cuenta de usuario de dominio para SQL Server y el agente de SQL, y asigna una contraseña:

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

Para configurar SQL Server, realiza los siguientes pasos en node-1 y node-2:

  1. Haz clic derecho en el botón Iniciar (o presiona Windows+X) y, luego, haz clic en Windows PowerShell (Admin).

    Cambia el nombre de la instancia de SQL Server para que su nombre coincida con el nombre de host:

    Invoke-Sqlcmd -Query "
      sp_dropserver 'INST-INSTALL-SQ';
      GO
      sp_addserver '$env:computername', local;
      GO"
    Restart-Service -Name MSSQLSERVER
    
  2. Abre el Administrador de configuración de SQL Server.

  3. En el panel de navegación, selecciona SQL Server Services.

  4. En la lista de servicios, haz clic con el botón derecho en SQL Server (MSSQLSERVER) y selecciona Propiedades.

  5. En Acceder como, cambia la cuenta:

    • Nombre de la cuenta: DOMAIN\sql_server, en el que DOMAIN es el nombre de NetBIOS de tu dominio de Active Directory.
    • Contraseña: Ingresa la contraseña que elegiste antes.
  6. Haga clic en OK.

  7. Cuando se te solicite reiniciar SQL Server, selecciona .

SQL Server ahora se ejecuta con una cuenta de usuario de dominio.

Crea archivos compartidos

Crea dos archivos compartidos en witness para que la instancia de VM pueda almacenar copias de seguridad de SQL Server y actuar como un testigo de archivos compartidos:

  1. Conéctate a witness mediante el escritorio remoto. Accede con tu cuenta de usuario de dominio.
  2. Haz clic derecho en el botón Iniciar (o presiona Windows+X) y, luego, haz clic en Windows PowerShell (Admin).
  3. Para confirmar el símbolo de elevación, haz clic en .
  4. Crea un archivo compartido de testigo y otórgate a ti mismo y a los dos nodos de WSFC acceso al archivo compartido:

    New-Item "C:\QWitness" –type directory
    New-SmbShare `
      -Name QWitness `
      -Path "C:\QWitness" `
      -Description "SQL File Share Witness" `
      -FullAccess $env:username,node-1$,node-2$
    
  5. Crea otro archivo compartido para almacenar copias de seguridad y otorgar a SQL Server acceso completo:

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

Implementa WSFC

Ya estás listo para crear el clúster de conmutación por error.

  1. Regresa a la sesión de escritorio remoto en node-1.
  2. Haz clic derecho en el botón Iniciar (o presiona Windows+X) y, luego, haz clic en Windows PowerShell (Admin).
  3. Para confirmar el símbolo de elevación, haz clic en .
  4. Crea un clúster nuevo:

    New-Cluster `
      -Name sql-cluster `
      -Node node-1,node-2 `
      -NoStorage `
      -StaticAddress CLUSTER_ADDRESS
    

    Reemplaza CLUSTER_ADDRESS por la dirección IP del clúster que creaste antes.

  5. Configura el clúster para usar el archivo compartido en witness como un quórum de clúster:

    Set-ClusterQuorum -FileShareWitness \\witness\QWitness
    
  6. Verifica que el clúster se haya creado de forma correcta:

    Test-Cluster
    

    Es posible que veas algunas advertencias que pueden ignorarse de forma segura:

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

    También puedes iniciar el complemento de MMC del administrador de clústeres de conmutación por error para revisar el estado del clúster si ejecutas cluadmin.msc.

  7. Si usas AD administrado, agrega la cuenta de computadora que usa WSFC al grupo de cuentas de unión de dominio del servicio en la nube para que pueda unir computadoras al dominio:

    Add-ADGroupMember `
      -Identity "Cloud Service Domain Join Accounts" `
      -Members sql-cluster$
    
  8. Habilita los grupos de disponibilidad AlwaysOn en ambos nodos:

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

Crea un grupo de disponibilidad

Ahora debes crear una base de datos bookshelf de muestra, incluirla en un nuevo grupo de disponibilidad llamado bookshelf-ag y configurar la alta disponibilidad.

Crea una base de datos

Crea una base de datos nueva. Para los fines de este instructivo, la base de datos no necesita contener ningún dato.

  1. Regresa a la sesión de escritorio remoto en node-1.
  2. Abre SQL Server Management Studio.
  3. En el cuadro de diálogo Conectar al servidor, verifica que el nombre del servidor esté configurado como NODE-1 y selecciona Conectar.
  4. En el menú, selecciona Archivo > Nuevo > Consulta con conexión actual.
  5. Pega la siguiente secuencia de comandos SQL en el 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
    

    La secuencia de comandos crea una base de datos nueva con una sola tabla y realiza una copia de seguridad inicial en witness.

  6. Selecciona Ejecutar para ejecutar la secuencia de comandos SQL.

Configura la alta disponibilidad

  1. En la ventana Explorador de objetos, haz clic con el botón derecho en Alta disponibilidad de Always On y, luego, selecciona Nuevo asistente de grupo de disponibilidad.
  2. En la página Especificar opciones, configura el nombre del grupo de disponibilidad en bookshelf-ag y, luego, selecciona Siguiente.
  3. En la página Seleccionar bases de datos, selecciona la base de datos bookshelf y, luego, Siguiente.
  4. En la página Especificar réplicas, selecciona la pestaña Réplicas:

    1. Selecciona Agregar réplica.
    2. En el cuadro de diálogo Conectar al servidor, ingresa el nombre del servidor node-2 y selecciona Conectar.

      La lista de réplicas de disponibilidad ahora contiene instancias de SQL Server, node-1 y node-2.

    3. Configura el modo de disponibilidad como Confirmación síncrona para ambas instancias.

    4. Configura Conmutación por error automática como Habilitada para ambas instancias.

    5. Selecciona la pestaña Listener.

      1. Selecciona Crear un objeto de escucha del grupo de disponibilidad.
      2. Ingresa las opciones de configuración siguientes:

        • Nombre de DNS del objeto de escucha: bookshelf
        • Puerto: 1433
        • Modo de red: Static IP.
      3. Selecciona Agregar y, luego, ingresa la dirección IP del balanceador de cargas que creaste antes. Luego, selecciona Aceptar.

    6. Selecciona Siguiente.

  5. En la página Seleccionar sincronización de datos, selecciona Propagación automática.

  6. En la página Validación, verifica que todas las verificaciones se realicen con éxito.

  7. En la página Resumen, selecciona Finalizar.

  8. En la página Resultados, selecciona Cerrar.

Configura las verificaciones de estado

Como paso final, configura el clúster para exponer un extremo de verificación de estado que pueda usar un balanceador de cargas interno:

  1. Regresa a la sesión de PowerShell en node-1.
  2. Inicializa una variable con la dirección IP del balanceador de cargas.

    $LoadBalancerIP = 'IP_ADDRESS'
    

    Reemplaza IP_ADDRESS por la dirección IP de la dirección wsfc que reservaste antes.

  3. Configura el clúster de conmutación por error para responder al servicio de verificación de estado:

    $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. Ejecuta el siguiente comando para reiniciar el recurso del clúster:

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

Crea un balanceador de cargas interno

A fin de proporcionar un único extremo para los clientes de SQL Server, ahora debes implementar un balanceador de cargas interno. El balanceador de cargas usa una verificación de estado que garantiza que el tráfico se dirija al nodo activo del WSFC.

  1. Regresa a tu sesión actual de Cloud Shell.
  2. Crea dos grupos de instancias no administrados, uno por zona, y agrega los dos nodos:

    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 una verificación de estado que el balanceador de cargas pueda usar para determinar cuál es el nodo activo.

    gcloud compute health-checks create tcp wsfc-healthcheck \
      --check-interval="2s" \
      --healthy-threshold=1 \
      --unhealthy-threshold=2 \
      --port=59997 \
      --timeout="1s"
    

    La verificación de estado sondea el puerto 59997, que es el puerto que configuraste antes como ProbePort para el objeto de escucha del grupo de disponibilidad.

  4. Crea un servicio de backend y agrega los dos grupos de instancias:

    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 el balanceador de cargas 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
    

Ahora puedes conectarte al objeto de escucha del grupo de disponibilidad de SQL Server mediante el balanceador de cargas interno y el nombre de DNS bookshelf.

Prueba de conmutación por error

Ahora estás listo para probar si la conmutación por error funciona como se esperaba:

  1. Regresa a la sesión de PowerShell en witness.
  2. Ejecute la siguiente secuencia de comandos:

    while ($True){
      $Conn = New-Object System.Data.SqlClient.SqlConnection
      $Conn.ConnectionString = "Server=bookshelf;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
    }
    

    Cada 2 segundos, la secuencia de comandos se conecta a SQL Server mediante el objeto de escucha del grupo de disponibilidad y consulta el nombre del servidor.

    Deja la secuencia de comandos en ejecución.

  3. Regresa a la sesión del escritorio remoto en node-1 para activar una conmutación por error:

    1. En SQL Server Management Studio, navega a AlwaysOn High Availability > Availability Groups > bookshelf-ag (Primary) y haz clic con el botón derecho en el nodo.
    2. Selecciona Conmutación por error.
    3. En la página Selecciona una réplica principal nueva, verifica quenode-2 se selecciona como una réplica principal nueva y que la columna Preparación para la conmutación por error indique No data loss. Luego, selecciona Siguiente.
    4. En la página Conectar a la réplica, selecciona Conectar.
    5. En el diálogo Conectar al servidor, verifica que el nombre del servidor sea node-2 y haz clic en Conectar.
    6. Selecciona Siguiente y, luego, Listo.
    7. En la página Resultados, verifica que la conmutación por error se haya realizado correctamente.
  4. Regresa a la sesión de PowerShell en witness.

  5. Observa el resultado de la secuencia de comandos en ejecución y observa que el nombre del servidor cambia de node-1 a node-2 como resultado de la conmutación por error.

  6. Para detener la secuencia de comandos, presiona Ctrl+C.

Limpia

Una vez que completes el instructivo, puedes limpiar los recursos que creaste para que dejen de usar la cuota y generar cargos. En las siguientes secciones, se describe cómo borrar o desactivar estos recursos.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, sigue estos pasos:

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

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?