Déployer un groupe de disponibilité Always On Microsoft SQL Server 2016 à plusieurs sous-réseaux sur Compute Engine

Ce tutoriel constitue la deuxième partie d'une série destinée à vous aider à déployer un environnement Windows à disponibilité élevée sur Google Cloud avec Microsoft Active Directory, SQL Server 2016 et Internet Information Services (IIS). Dans ce tutoriel, vous allez configurer deux instances SQL Server dans différentes zones de la même région, puis les configurer en tant que groupes de disponibilité Always On Microsoft SQL Server à plusieurs sous-réseaux.

La série comprend les tutoriels suivants :

Chaque tutoriel s'appuie sur l'infrastructure que vous avez créée dans le précédent.

Objectifs

  • Créer deux sous-réseaux de réseau couvrant deux zones.
  • Déployer une machine virtuelle (VM) Microsoft SQL Server 2016 dans chaque zone.
  • Configurer chaque instance SQL Server pour qu'elles rejoignent votre domaine Active Directory.
  • Créer un cluster de basculement Windows Server.
  • Créer et configurer un exemple de base de données bookshelf SQL Server.
  • Configurer le groupe de disponibilité Always On Microsoft SQL Server.

Coûts

Dans ce tutoriel, vous continuez à utiliser les ressources Google Cloud que vous avez configurées dans les tutoriels précédents. Vous allez utiliser les composants facturables suivants :

Le simulateur de coût estime le coût de cet environnement à environ 98 $ par jour, comprenant les licences SQL Server 2016 Enterprise et l'environnement Active Directory à deux serveurs.

Avant de commencer

La configuration que vous utilisez dans ce tutoriel nécessite l'accès à un contrôleur de domaine Windows et à un domaine Active Directory opérationnel. Si vous ne disposez pas encore de cet environnement, suivez la procédure décrite dans les tutoriels suivants :

Initialiser des variables communes

Vous devez définir plusieurs variables d'environnement qui contrôlent où les éléments de l'infrastructure sont déployés.

  1. À l'aide d'un éditeur de texte, créez un script définissant les variables d'environnement suivantes pour qu'elles indiquent votre ID de projet, ainsi que la région et les zones que vous souhaitez utiliser.

    Les variables définissent la région sur us-east1. Si vous avez utilisé une région différente dans le tutoriel précédent, modifiez-la dans ce script pour qu'elle corresponde à celle que vous avez utilisée auparavant.

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

    Remplacez your-project-id par l'ID du projet Cloud que vous utilisez.

  2. Ouvrez Cloud Shell.

    Ouvrir Cloud Shell

  3. Copiez le script dans la fenêtre Cloud Shell et exécutez-le.

  4. Définissez la région et l'ID du projet par défaut afin de ne pas avoir à spécifier ces valeurs dans chacune des commandes suivantes :

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

Créer l'infrastructure réseau

Une fois que vous avez défini les variables d'infrastructure, créez les sous-réseaux de réseau que SQL Server utilisera.

  1. Ajoutez des sous-réseaux au réseau cloud privé virtuel (VPC) existant :

    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. Créez une règle de pare-feu interne pour autoriser le trafic entre les sous-réseaux private-ad* que vous avez créés précédemment et les nouveaux sous-réseaux 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
    

Créer des instances SQL Server

Créez ensuite deux VM SQL Server 2016 Enterprise Edition à l'aide d'images Compute Engine préconfigurées avec les propriétés suivantes :

  • Noms : bookshelf-sql1 et bookshelf-sql2
  • Taille du disque de démarrage : 200GB
  • Type de machine : n1-highmem-4

Si vous avez l'intention d'utiliser cet environnement au-delà de ce tutoriel, et que vous avez besoin de ressources de calcul supplémentaires, vous pourrez toujours personnaliser plus tard le type de machine de ces instances. Vous avez également la possibilité d'ajouter des disques et de redimensionner les disques persistants existants.

Dans ce tutoriel, vous utilisez l'image publique SQL Server sur Windows Server pour vos VM, ce qui signifie que l'utilisation de SQL Server vous sera facturée. Vous pouvez également déployer vos licences SQL Server existantes sur Compute Engine à l'aide de Licence Mobility via Software Assurance, et les appliquer aux images publiques de Windows Server après avoir installé SQL Server.

  1. Créez une instance Compute Engine de Windows Server 2016 avec 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. Créez la deuxième instance :

    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
    

Configurer l'instance bookshelf-sql2

Configurez ensuite l'instance bookshelf-sql2. Vous devez commencer par la deuxième instance, car des opérations supplémentaires sont nécessaires pour définir la base de données sur bookshelf-sql1. Par ailleurs, le fait de commencer par la configuration de bookshelf-sql2 nécessite moins de sessions du protocole RDP (Remote Desktop Protocol).

  1. Créez un mot de passe pour l'instance Windows bookshelf-sql2 :

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

    Le nom d'utilisateur est le nom d'utilisateur de votre compte Google. Prenez note du nom d'utilisateur et du mot de passe pour une utilisation future.

  2. Utilisez RDP pour vous connecter à l'instance SQL Server à l'aide des identifiants que vous avez créés précédemment.

  3. Dans l'instance, ouvrez un terminal PowerShell en tant qu'administrateur. (Cliquez sur Démarrer, saisissez PowerShell, puis appuyez sur Control+Shift+Enter).

  4. Définissez ces 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. Configurez le serveur DNS principal :

    netsh interface ip set dns Ethernet static $DNS1
  6. Configurez le serveur DNS secondaire :

    netsh interface ip add dns Ethernet $DNS2 index=2
  7. Définissez l'adresse IP et la passerelle par défaut :

    netsh interface ip set address name=Ethernet static $LocalStaticIp 255.255.255.0 $DefaultGateway 1
  8. Ajoutez la VM au domaine Windows :

    Add-Computer -DomainName $DomainName `
        -Credential (Get-Credential "example-gcp\Administrator")
    
  9. Lorsque vous êtes invité à fournir un mot de passe pour le compte administrateur (Administrator), utilisez les identifiants d'administrateur que vous avez définis lors de l'installation d'une forêt Active Directory dans le tutoriel précédent. Pour le nom d'utilisateur, ajoutez le nom de domaine en tant que préfixe, comme dans EXAMPLE-GCP\Administrator.

  10. Ouvrez les ports de pare-feu Windows pour le groupe de 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. Installez la fonctionnalité de clustering de basculement :

    Install-WindowsFeature Failover-Clustering -IncludeManagementTools
  12. Redémarrez l'instance :

    Restart-Computer
  13. Utilisez RDP pour vous connecter à l'instance SQL Server à l'aide des identifiants du compte EXAMPLE-GCP\Administrator.

  14. Ouvrez une fenêtre de la console PowerShell en tant qu'administrateur.

  15. Dans la fenêtre de la console PowerShell, créez les dossiers pour vos données et fichiers journaux SQL Server :

    New-Item -ItemType directory -Path C:\SQLData
    New-Item -ItemType directory -Path C:\SQLLog
    
  16. Créez un dossier pour les sauvegardes de la base de données et partagez-le :

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

Configurer l'instance bookshelf-sql1

Configurez ensuite l'instance bookshelf-sql1.

  1. Dans Cloud Shell, créez un mot de passe pour l'instance Windows bookshelf-sql1 :

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

    Le nom d'utilisateur est le nom d'utilisateur de votre compte Google. Prenez note du nom d'utilisateur et du mot de passe pour une utilisation future.

  2. Utilisez RDP pour vous connecter à l'instance SQL Server à l'aide des identifiants que vous avez créés pour l'instance bookshelf-sql1.

  3. Ouvrez une fenêtre de la console PowerShell en tant qu'administrateur.

  4. Dans la fenêtre de la console PowerShell, définissez les variables suivantes :

    $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. Configurez le serveur DNS principal :

    netsh interface ip set dns Ethernet static $DNS1
  6. Configurez le serveur DNS secondaire :

    netsh interface ip add dns Ethernet $DNS2 index=2
  7. Définissez l'adresse IP et la passerelle par défaut :

    netsh interface ip set address name=Ethernet static $LocalStaticIp 255.255.255.0 $DefaultGateway 1
  8. Ajoutez la VM au domaine :

    Add-Computer -DomainName $DomainName `
        -Credential (Get-Credential "example-gcp\Administrator")
    
  9. Lorsque vous êtes invité à fournir un mot de passe pour le compte administrateur, utilisez les identifiants d'administrateur que vous avez définis lors de l'installation d'une forêt Active Directory dans le tutoriel précédent. Pour le nom d'utilisateur, ajoutez le nom de domaine en tant que préfixe, comme dans EXAMPLE-GCP\Administrator.

  10. Ajoutez des règles de pare-feu 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. Installez la fonctionnalité de clustering de basculement :

    Install-WindowsFeature Failover-Clustering -IncludeManagementTools
  12. Redémarrez l'instance :

    Restart-Computer

Configurer le cluster de basculement Windows Server

  1. Utilisez le protocole RDP pour vous connecter à l'instance bookshelf-sql1. Lorsque vous êtes invité à fournir un mot de passe pour le compte administrateur, utilisez les identifiants d'administrateur que vous avez définis lors de l'installation d'une forêt Active Directory dans le tutoriel précédent. Pour le nom d'utilisateur, ajoutez le nom de domaine en tant que préfixe, comme dans EXAMPLE-GCP\Administrator.

  2. Ouvrez une fenêtre de la console PowerShell en tant qu'administrateur.

  3. Dans la fenêtre de la console PowerShell, définissez les variables suivantes :

    $node1 = "bookshelf-sql1"
    $node2 = "bookshelf-sql2"
    
  4. Définissez le nom du cluster :

    $nameWSFC = "bookshelf-dbclus"
  5. Définissez les adresses IP pour les clusters et les écouteurs de cluster :

    $ipWSFC1 = "10.3.0.4"
    $ipWSFC2 = "10.4.0.4"
    $ipWSListener1 = "10.3.0.5"
    $ipWSListener2 = "10.4.0.5"
    
  6. Assurez-vous que l'instance SQL Server bookshelf-sql1 est prête à rejoindre le cluster. Exécutez le script suivant, qui lance une tentative de connexion à l'instance 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. Assurez-vous que l'instance SQL Server bookshelf-sql2 est prête à rejoindre le 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. Créez le cluster :

    New-Cluster -Name $nameWSFC -Node $node1, $node2 -NoStorage `
        -StaticAddress $ipWSFC1, $ipWSFC2
    
  9. Activez la fonctionnalité "Always On" pour les deux nœuds :

    Enable-SqlAlwaysOn -ServerInstance $node1 -Force
    Enable-SqlAlwaysOn -ServerInstance $node2 -Force
    
  10. Créez des dossiers pour les données de base de données et les fichiers journaux :

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

Configurer la base de données

Ce tutoriel utilise l'exemple de base de données bookshelf que vous avez créé pour vérifier que votre configuration fonctionne correctement.

  1. Dans la fenêtre de la console PowerShell sur laquelle vous travaillez, exécutez l'instruction SQL suivante pour créer la base de données 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. Exécutez l'instruction SQL suivante pour créer la table 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. Définissez ces variables :

    $Domain = "example-gcp.com"
    $ADControllerFQDN = "ad-dc1.$Domain"
    $ServiceAccountName = "sql.service"
    $ServiceAccountPrincipalName = "$ServiceAccountName@$Domain"
    
  4. Activez l'applet de commande RSAT-AD-PowerShell à l'aide de la commande PowerShell suivante :

    Add-WindowsFeature RSAT-AD-PowerShell

    Vous avez besoin des outils d'administration de serveur distant pour créer un compte de service à partir de la machine virtuelle.

  5. Ajoutez un compte de service de base de données nommé sql.service au sein du domaine :

    New-ADUser -Name $ServiceAccountName `
        -Server $ADControllerFQDN `
        -SamAccountName $ServiceAccountName `
        -UserPrincipalName $ServiceAccountPrincipalName `
        -AccountPassword (Read-Host -AsSecureString "AccountPassword") `
        -PassThru | Enable-ADAccount
    
  6. Lorsque vous êtes invité à renseigner le mot de passe du compte sql.service, utilisez un mot de passe sécurisé, et stockez-le en lieu sûr pour une utilisation ultérieure.

  7. Exécutez l'instruction SQL suivante pour ajouter le compte EXAMPLE-GCP\sql.service en tant qu'administrateur de base de données :

    $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
    

Configurer le groupe de disponibilité SQL Server

  1. Toujours dans l'instance dans laquelle vous travaillez, définissez les variables suivantes :

    $Database="bookshelf"
    $BackupFolder="SQLBackup"
    $SharedLocation="\\$node2\$BackupFolder"
    $ListenerName="sql-listener"
    $AGName="MainAG"
    $PrimaryServer = "$node1.$Domain\MSSQLSERVER"
    $SecondaryServer = "$node2.$Domain\MSSQLSERVER"
    
  2. Sauvegardez la base de données sur le serveur principal :

    Backup-SqlDatabase `
        -Database $Database -Initialize `
        -BackupFile "$SharedLocation\$Database.bak" `
        -ServerInstance $node1
    
  3. Restaurez la base de données sur le serveur secondaire :

    Restore-SqlDatabase `
        -Database $Database `
        -BackupFile "$SharedLocation\$Database.bak" `
        -ServerInstance $node2 `
        -NORECOVERY
    
  4. Sauvegardez le journal de la base de données sur le serveur principal :

    Backup-SqlDatabase `
        -Database $Database -Initialize `
        -BackupFile "$SharedLocation\$Database.log" `
        -ServerInstance $node1 `
        -BackupAction Log
    
  5. Restaurez le journal de la base de données sur le serveur secondaire :

    Restore-SqlDatabase `
        -Database $Database `
        -BackupFile "$SharedLocation\$Database.log" `
        -ServerInstance $node2 `
        -RestoreAction Log `
        -NORECOVERY
    
  6. Créez et démarrez les points de terminaison :

    $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
    

    Le résultat est le suivant :

    AlwaysonEndpoint1       STARTED            5022 - for node1
    AlwaysonEndpoint2       STARTED            5022 - for node2
    
  7. Vérifiez la configuration en exécutant les commandes suivantes dans 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
    

    Si la configuration est correcte, un résultat de ce type s'affiche :

    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. Définissez les URL du point de terminaison :

    $EndpointUrlSQLServer1="TCP://" + $node1 + "." + $Domain + ":5022"
    $EndpointUrlSQLServer2="TCP://" + $node2 + "." + $Domain + ":5022"
    
  9. Créez une représentation en mémoire des instances dupliquées :

    $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. Créez le groupe de disponibilité :

    New-SqlAvailabilityGroup -Name $AGName `
        -AvailabilityReplica @($PrimaryReplica, $SecondaryReplica) `
        -Path "SQLSERVER:\SQL\$node1.$Domain\Default" `
        -Database $Database
    
  11. Intégrez l'instance secondaire au groupe de disponibilité :

    Join-SqlAvailabilityGroup -Path "SQLSERVER:\SQL\$node2\Default" -Name $AGName
  12. Intégrez la base de données secondaire au groupe de disponibilité :

    Add-SqlAvailabilityDatabase `
        -Path "SQLSERVER:\SQL\$node2\Default\AvailabilityGroups\$AGName" `
        -Database $Database
    
  13. Créez l'écouteur :

    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. Supprimez le dossier partagé, qui n'est plus nécessaire :

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

Nettoyer

Si vous souhaitez passer au tutoriel suivant de cette série (Déployer des serveurs Web IIS à équilibrage de charge), conservez les ressources que vous avez créées dans le cadre de ce tutoriel. Si vous n'envisagez pas d'utiliser l'environnement que vous venez de créer, nettoyez les ressources créées sur Google Cloud pour éviter qu'elles ne vous soient facturées par la suite. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Supprimer le projet

  • Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  • Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  • Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.
  • Supprimer des instances

    Si vous ne souhaitez pas supprimer entièrement le projet, vous pouvez supprimer les ressources spécifiques que vous avez créées.

    Pour supprimer une instance Compute Engine, procédez comme suit :

    1. Dans Cloud Console, accédez à la page "Instances de VM".

      Accéder à la page "Instances de VM"

    2. Sélectionnez les instances à supprimer.

    3. En haut de la page, cliquez sur Supprimer pour supprimer les instances.

    Supprimer des réseaux VPC

    Pour supprimer les réseaux VPC, les sous-réseaux et les règles de pare-feu, procédez comme suit :

    1. Dans Cloud Console, accédez à la page "Réseaux VPC".

      Accéder à la page Réseaux VPC

    2. Sélectionnez le réseau VPC que vous avez créé.

    3. En haut de la page, cliquez sur Supprimer pour supprimer le réseau.

    Étape suivante