Konfigurera en distribuerad AlwaysOn-tillgänglighetsgrupp

Om du vill skapa din distribuerade tillgänglighetsgrupp med automatisk seeding använder du följande Transact-SQL kod:

CREATE AVAILABILITY GROUP [distributedAG]
   WITH (DISTRIBUTED)
   AVAILABILITY GROUP ON
      'ag1' WITH
      (
         LISTENER_URL = 'tcp://ag1-listener.contoso.com:5022',
         AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT,
         FAILOVER_MODE = MANUAL,
         SEEDING_MODE = AUTOMATIC
      ),
      'ag2' WITH
      (
         LISTENER_URL = 'tcp://ag2-listener.contoso.com:5022',
         AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT,
         FAILOVER_MODE = MANUAL,
         SEEDING_MODE = AUTOMATIC
      );
GO

Om du vill skapa din distribuerade tillgänglighetsgrupp med manuell seeding använder du följande Transact-SQL kod:

CREATE AVAILABILITY GROUP [distributedAG]
   WITH (DISTRIBUTED)
   AVAILABILITY GROUP ON
      'ag1' WITH
      (
         LISTENER_URL = 'tcp://ag1-listener.contoso.com:5022',
         AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT,
         FAILOVER_MODE = MANUAL,
         SEEDING_MODE = MANUAL
      ),
      'ag2' WITH
      (
         LISTENER_URL = 'tcp://ag2-listener.contoso.com:5022',
         AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT,
         FAILOVER_MODE = MANUAL,
         SEEDING_MODE = MANUAL
      );
GO

Om du vill ansluta till din distribuerade tillgänglighetsgrupp med automatisk seeding använder du följande Transact-SQL kod:

ALTER AVAILABILITY GROUP [distributedAG]
   JOIN
   AVAILABILITY GROUP ON
      'ag1' WITH
      (
         LISTENER_URL = 'tcp://ag1-listener.contoso.com:5022',
         AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT,
         FAILOVER_MODE = MANUAL,
         SEEDING_MODE = AUTOMATIC
      ),
      'ag2' WITH
      (
         LISTENER_URL = 'tcp://ag2-listener.contoso.com:5022',
         AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT,
         FAILOVER_MODE = MANUAL,
         SEEDING_MODE = AUTOMATIC
      );
GO

Om du vill ansluta till din distribuerade tillgänglighetsgrupp med manuell seeding använder du följande Transact-SQL kod:

ALTER AVAILABILITY GROUP [distributedAG]
   JOIN
   AVAILABILITY GROUP ON
      'ag1' WITH
      (
         LISTENER_URL = 'tcp://ag1-listener.contoso.com:5022',
         AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT,
         FAILOVER_MODE = MANUAL,
         SEEDING_MODE = MANUAL
      ),
      'ag2' WITH
      (
         LISTENER_URL = 'tcp://ag2-listener.contoso.com:5022',
         AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT,
         FAILOVER_MODE = MANUAL,
         SEEDING_MODE = MANUAL
      );
GO

Om manuell seeding används för att skapa databasen på vidarebefordraren utför du en fullständig säkerhetskopia och en säkerhetskopia av transaktionsloggen från den globala primära databasen och återställer dem till vidarebefordraren med norecovery-alternativet. Till exempel:

Så säkerhetskopierar du den globala primära servern:

BACKUP DATABASE [db1]
    TO DISK = '<full backup location>'
    WITH FORMAT;

BACKUP LOG [db1]
    TO DISK = '<log backup location>'
    WITH FORMAT;

Så här återställer du till vidarebefordraren:

RESTORE DATABASE [db1] FROM DISK = '<full backup location>'
    WITH NORECOVERY;

RESTORE LOG [db1] FROM DISK = '<log backup location>'
    WITH NORECOVERY;

Därefter kör du följande på vidarebefordraren:

ALTER DATABASE [db1]
    SET HADR AVAILABILITY GROUP = [distributedAG];

På SQL Server 2022 (16.x) och senare kan du konfigurera REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT inställningen för en distribuerad tillgänglighetsgrupp, som är utformad för att garantera ingen dataförlust när en distribuerad tillgänglighetsgrupp redundansväxlar. Om den här inställningen har konfigurerats, följ stegen i det här avsnittet för att växla över din distribuerade tillgänglighetsgrupp. Om du inte vill använda REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT-inställningen, följer du anvisningarna för att växla över en distribuerad tillgänglighetsgrupp i SQL Server 2019 och tidigare.

Steg för att säkerställa att inga data går förlorade

För att säkerställa att inga data går förlorade måste du först konfigurera den distribuerade tillgänglighetsgruppen så att den inte stöder dataförlust genom att följa dessa steg:

1. För att förbereda för redundans kontrollerar du att den globala primära och vidarebefordraren är i SYNCHRONOUS_COMMIT läge. Annars ställer du in dem på SYNCHRONOUS_COMMIT via ÄNDRA TILLGÄNGLIGHETSGRUPP.
2. Ange den distribuerade tillgänglighetsgruppen till synkron överföring både för den globala primärservern och vidarebefordraren.
3. Vänta tills den distribuerade tillgänglighetsgruppen har synkroniserats.
4. I den globala primära inställningen anger du inställningen för distribuerad tillgänglighetsgrupp REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT till 1 med hjälp av ÄNDRA TILLGÄNGLIGHETSGRUPP.
5. Kontrollera att alla repliker i de lokala AG:erna och den distribuerade tillgänglighetsgruppen är felfria och att den distribuerade tillgänglighetsgruppen är SYNKRONISERAd.
6. På den globala primära repliken anger du rollen distribuerad tillgänglighetsgrupp till SECONDARY, vilket gör den distribuerade tillgänglighetsgruppen otillgänglig.
7. På vidarebefordraren (den avsedda nya primära) redundansväxlar du den distribuerade tillgänglighetsgruppen med hjälp av ALTER AVAILABILITY GROUP med FORCE_FAILOVER_ALLOW_DATA_LOSS.
8. På den nya sekundära (den tidigare globala primära repliken) anger du den distribuerade tillgänglighetsgruppen REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT till 0.
9. Valfritt: Om tillgänglighetsgrupperna är över ett geografiskt avstånd som orsakar svarstid ändrar du tillgänglighetsläget till ASYNCHRONOUS_COMMIT. Detta återställer ändringen från det första steget om det behövs.

T-SQL-exempel

Det här avsnittet innehåller stegen i en detaljerad instruktion för att växla över den distribuerade tillgänglighetsgruppen med namnet distributedAG med hjälp av Transact-SQL. Exempelmiljön har totalt 4 noder för den distribuerade tillgänglighetsgruppen. Den globala primära N1- och N2-värdtillgänglighetsgruppen ag1 medan vidarebefordraren N3 och N4-värdtillgänglighetsgruppen ag2. Den distribuerade tillgänglighetsgruppen distributedAG skickar ändringar från ag1 till ag2.

1. Fråga för att verifiera SYNCHRONOUS_COMMIT om primärenheterna för de lokala tillgänglighetsgrupper som utgör den distribuerade tillgänglighetsgruppen. Kör följande T-SQL direkt på vidarebefordraren och den globala primärservern:

   SELECT DISTINCT ag.name AS [Availability Group],
                   ar.replica_server_name AS [Replica],
                   ar.availability_mode_desc AS [Availability Mode]
   FROM sys.availability_replicas AS ar
        INNER JOIN
        sys.availability_groups AS ag
        ON ar.group_id = ag.group_id
        INNER JOIN
        sys.dm_hadr_database_replica_states AS rs
        ON ar.group_id = rs.group_id
           AND ar.replica_id = rs.replica_id
   WHERE ag.name IN ('ag1', 'ag2')
         AND rs.is_primary_replica = 1
   ORDER BY [Availability Group];
   --if needed, to set a given replica to SYNCHRONOUS for node N1, default instance. If named, change from N1 to something like N1\SQL22
   
   ALTER AVAILABILITY GROUP [testag] MODIFY REPLICA ON N'N1\SQL22' WITH (AVAILABILITY_MODE = SYNCHRONOUS_COMMIT);
   

2. Ställ in den distribuerade tillgänglighetsgruppen på synkron commit genom att köra följande kod på både den globala primärnoden och vidarebefordraren.

    -- sets the distributed availability group to synchronous commit
    ALTER AVAILABILITY GROUP [distributedAG] MODIFY AVAILABILITY GROUP ON
    'ag1' WITH (AVAILABILITY_MODE = SYNCHRONOUS_COMMIT),
    'ag2' WITH (AVAILABILITY_MODE = SYNCHRONOUS_COMMIT);
   

   Anmärkning

   I en distribuerad tillgänglighetsgrupp beror synkroniseringsstatusen mellan de två tillgänglighetsgrupperna på tillgänglighetsläget för båda replikerna. För synkront förbindelseläge måste både den aktuella primära tillgänglighetsgruppen och den aktuella sekundära tillgänglighetsgruppen ha SYNCHRONOUS_COMMIT tillgänglighetsläge. Därför måste du köra det här skriptet på både den globala primära repliken och vidarebefordraren.

3. Vänta tills statusen för den distribuerade tillgänglighetsgruppen ändras till SYNCHRONIZED. Kör följande fråga på den globala primären:

   -- Run this query on the Global Primary
   
   -- Check the results to see if synchronization_state_desc is SYNCHRONIZED
   SELECT ag.name,
          drs.database_id AS [Availability Group],
          db_name(drs.database_id) AS database_name,
          drs.synchronization_state_desc,
          drs.last_hardened_lsn
   FROM sys.dm_hadr_database_replica_states AS drs
        INNER JOIN
        sys.availability_groups AS ag
        ON drs.group_id = ag.group_id
   WHERE ag.name = 'distributedAG'
   ORDER BY [Availability Group];
   

   Fortsätt när tillgänglighetsgruppen synchronization_state_desc är SYNCHRONIZED.

4. För SQL Server 2022 (16.x) och senare, ställ REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT till 1 på den globala primärservern med hjälp av följande T-SQL-kommando:

   ALTER AVAILABILITY GROUP distributedAG SET (REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT = 1);
   

5. Kontrollera att dina tillgänglighetsgrupper är felfria på alla repliker genom att fråga den globala primära och vidarebefordraren:

   SELECT ag.name AS [AG Name],
          db_name(drs.database_id) AS database_name,
          ar.replica_server_name AS [replica],
          drs.synchronization_state_desc,
          drs.last_hardened_lsn
   FROM sys.dm_hadr_database_replica_states AS drs
        INNER JOIN
        sys.availability_groups AS ag
        ON drs.group_id = ag.group_id
        INNER JOIN
        sys.availability_replicas AS ar
        ON drs.replica_id = ar.replica_id
           AND drs.replica_id = ar.replica_id
   WHERE ag.name IN ('ag1', 'ag2', 'distributedAG');
   

6. På den globala primära, ange rollen för den distribuerade tillgänglighetsgruppen till SECONDARY. Nu är den distribuerade tillgänglighetsgruppen inte tillgänglig. När det här steget är klart kan du inte gå tillbaka förrän resten av stegen har utförts.

   ALTER AVAILABILITY GROUP distributedAG SET (ROLE = SECONDARY);
   

7. Växla över från den globala primära servern genom att köra följande kommando på den vidarebefordrande servern för att överföra tillgänglighetsgrupperna och återaktivera den distribuerade tillgänglighetsgruppen online.

   -- Run the following command on the forwarder, the SQL Server instance that hosts the primary replica of the secondary availability group.
   ALTER AVAILABILITY GROUP distributedAG FORCE_FAILOVER_ALLOW_DATA_LOSS;
   

   Efter det här steget:

   • De globala primära övergångarna från N1 till N3.
   • Vidarebefordraren övergår från N3 till N1.
   • Den distribuerade tillgänglighetsgruppen är tillgänglig.

8. På den nya vidarebefordraren (tidigare global primär, N1) avmarkerar du egenskapen REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT distribuerad tillgänglighetsgrupp genom att ange den till 0:

   ALTER AVAILABILITY GROUP distributedAG SET (REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT = 0);
   

9. VALFRITT: Om tillgänglighetsgrupperna befinner sig över ett geografiskt avstånd som orsakar svarstid bör du överväga att ändra tillgänglighetsläget tillbaka till ASYNCHRONOUS_COMMITpå både den globala primära och vidarebefordraren. Detta återställer ändringen som gjordes i det första steget, om det behövs.

    -- If applicable: sets the distributed availability group to asynchronous commit:
    ALTER AVAILABILITY GROUP distributedAG MODIFY AVAILABILITY GROUP ON
    'ag1' WITH (AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT),
    'ag2' WITH (AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT);
   

Anvisningarna i det här avsnittet gäller om REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT inte har angetts för den distribuerade tillgänglighetsgruppen, till exempel versioner före SQL Server 2022 (16.x) eftersom de inte stöder den för distribuerade tillgänglighetsgrupper.

Steg för att säkerställa att inga data går förlorade

Följ dessa steg för att säkerställa att inga data går förlorade:

1. Stoppa alla transaktioner som körs på den globala primära tillgänglighetsgruppens databaser.
2. Kontrollera att den globala primär- och vidarebefordraren är i SYNCHRONOUS_COMMIT läge. Annars ställer du in dem på SYNCHRONOUS_COMMIT via ÄNDRA TILLGÄNGLIGHETSGRUPP.
3. Ställ in den distribuerade tillgänglighetsgruppen till synkron commit på den globala primären och vidarebefordraren.
4. Vänta tills den distribuerade tillgänglighetsgruppen har synkroniserats och har samma last_hardened_lsn per databas. Vänta tills last_hardened_lsn för databasen matchar mellan repliker.
5. På den globala primära repliken anger du rollen distribuerad tillgänglighetsgrupp till SECONDARY, vilket gör den distribuerade tillgänglighetsgruppen otillgänglig.
6. Testa redundansberedskapen genom att kontrollera att last_hardened_lsn värden är desamma på den globala primära och vidarebefordraren. ** Om de inte matchar måste du återgå till det globala primära systemet och starta processen om från det första steget.
7. Växla över den primära tillgänglighetsgruppen med ALTER AVAILABILITY GROUP med FORCE_FAILOVER_ALLOW_DATA_LOSS.
8. Valfritt: Om tillgänglighetsgrupperna är över ett geografiskt avstånd som orsakar svarstid ändrar du tillgänglighetsläget tillbaka till ASYNCHRONOUS_COMMIT.

T-SQL-exempel

Det här avsnittet innehåller stegen i en detaljerad instruktion för att växla över den distribuerade tillgänglighetsgruppen med namnet distributedAG med hjälp av Transact-SQL. Exempelmiljön har totalt 4 noder för den distribuerade tillgänglighetsgruppen. Den globala primära N1- och N2-värdtillgänglighetsgruppen ag1 medan vidarebefordraren N3 och N4-värdtillgänglighetsgruppen ag2. Den distribuerade tillgänglighetsgruppen distributedAG skickar ändringar från ag1 till ag2.

1. För att säkerställa att inga data går förlorade stoppar du alla transaktioner på de globala primära databaserna (dvs. databaser för den primära tillgänglighetsgruppen).

2. Fråga för att verifiera SYNCHRONOUS_COMMIT om primärenheterna i de lokala tillgänglighetsgrupper som utgör den distribuerade tillgänglighetsgruppen. Kör direkt på vidarebefordraren och den globala primärservern.

   SELECT ag.name AS [Availability Group],
          ar.replica_server_name AS [Replica],
          ar.availability_mode_desc AS [Availability Mode]
   FROM sys.availability_replicas AS ar
        INNER JOIN
        sys.availability_groups AS ag
        ON ar.group_id = ag.group_id
        INNER JOIN
        sys.dm_hadr_database_replica_states AS rs
        ON ar.group_id = rs.group_id
           AND ar.replica_id = rs.replica_id
   WHERE ag.name IN ('ag1', 'ag2')
         AND rs.is_primary_replica = 1
   ORDER BY [Availability Group];
   

3. Ställ in den distribuerade tillgänglighetsgruppen på synkron commit genom att köra följande kod på både den globala primärnoden och vidarebefordraren.

    -- sets the distributed availability group to synchronous commit
    ALTER AVAILABILITY GROUP [distributedAG]
    MODIFY AVAILABILITY GROUP ON
    'ag1' WITH (AVAILABILITY_MODE = SYNCHRONOUS_COMMIT),
    'ag2' WITH (AVAILABILITY_MODE = SYNCHRONOUS_COMMIT);
   
    -- query to verify the commit state of the distributed availability group
    SELECT
     ag.name,
     ag.is_distributed,
     ar.replica_server_name [Local AG Names],
     ar.availability_mode_desc,
     ars.connected_state_desc,
     ars.role_desc,
     ars.operational_state_desc,
     ars.synchronization_health_desc
    FROM sys.availability_groups ag
    INNER JOIN sys.availability_replicas ar ON ag.group_id=ar.group_id
    LEFT JOIN sys.dm_hadr_availability_replica_states ars on ars.replica_id=ar.replica_id and ag.group_id = ars.group_id
    WHERE ag.is_distributed=1;
   

   Anmärkning

   I en distribuerad tillgänglighetsgrupp beror synkroniseringsstatusen mellan de två tillgänglighetsgrupperna på tillgänglighetsläget för båda replikerna. För synkront incheckningsläge måste både den aktuella primära tillgänglighetsgruppen och den aktuella sekundära tillgänglighetsgruppen ha SYNCHRONOUS_COMMIT tillgänglighetsläge. Därför måste du köra det här skriptet på både den globala primära repliken och vidarebefordraren.

4. Vänta tills statusen för den distribuerade tillgänglighetsgruppen ändras till SYNCHRONIZED och alla repliker har samma last_hardened_lsn (per databas). Kör följande fråga på både den globala primära, som är den primära repliken för den primära tillgänglighetsgruppen, och vidarebefordraren för att kontrollera synchronization_state_desc och last_hardened_lsn:

   -- Run this query on the global primary and the forwarder
   
   -- Check the results to see if synchronization_state_desc is SYNCHRONIZED, and the last_hardened_lsn is the same per database on both the global primary and forwarder
   
   -- If not, rerun the query on both side every 5 seconds until it is the case
   
   --
   SELECT ag.name AS [AG Name],
          ar.replica_server_name AS [replica],
          db_name(drs.database_id) AS database_name,
          drs.synchronization_state_desc,
          drs.last_hardened_lsn
   FROM sys.availability_groups AS ag
        INNER JOIN
        sys.availability_replicas AS ar
        ON ag.group_id = ar.group_id
        INNER JOIN
        sys.dm_hadr_database_replica_states AS drs
        ON drs.replica_id = ar.replica_id
           AND ag.group_id = drs.group_id
   WHERE ag.name IN ('ag1', 'ag2');
   

   Fortsätt efter att tillgänglighetsgruppen synchronization_state_desc är SYNCHRONIZED, och last_hardened_lsn är samma för varje databas på både den globala primären och vidarebefordraren. Om synchronization_state_desc inte är samma eller SYNCHRONIZED inte är detsamma, kör du kommandot var femte sekund tills det ändras. För att förhindra dataförlust fortsätter du inte förrän synchronization_state_desc = SYNCHRONIZED och last_hardened_lsn är samma per databas.

5. Ställ in rollen för den distribuerade tillgänglighetsgruppen till SECONDARY:

   ALTER AVAILABILITY GROUP distributedAG SET (ROLE = SECONDARY);
   

   Nu är den distribuerade tillgänglighetsgruppen inte tillgänglig.

6. Testa redundansberedskapen. Kör SELECT-frågan igen för att kontrollera last_hardened_lsn (per databas) på både den globala primära och vidarebefordraren. Kontrollera att last_hardened_lsn matchar för alla databaser mellan global primär och vidarebefordrare.

7. Beroende på resultatet från föregående steg varierar nästa steg.

   • Om last_hardened_lsns matchar från SELECT-frågan, växlar du från den primära tillgänglighetsgruppen till den sekundära tillgänglighetsgruppen. Kör kommandot ALTER AVAILABILITY GROUP på vidarebefordraren, DEN SQL Server som är värd för den primära repliken av den sekundära tillgänglighetsgruppen.

   • Om last_hardened_lsnsinte matchar från SELECT-frågan efter en tid, återställ den distribuerade tillgänglighetsgruppen till den ursprungliga vidarebefordraren (N1) genom att köra failover-kommandot mot det globala primära objektet. Starta sedan processen igen från det första steget.

   -- If the last_hardened_lsns match, you can run the failover query below against the forwarder
   
   -- If the last_hardened_lsns do not match after some time, you can run the failover query against the original global primary
   ALTER AVAILABILITY GROUP distributedAG FORCE_FAILOVER_ALLOW_DATA_LOSS;
   

   Efter det här steget är den distribuerade tillgänglighetsgruppen tillgänglig.

8. VALFRITT: Efter en lyckad redundansväxling, om tillgänglighetsgrupperna är på ett geografiskt avstånd som medför latens, kan du överväga att ändra tillgänglighetsläget tillbaka till ASYNCHRONOUS_COMMIT för att återgå till det tidigare läget.

    -- If applicable: sets the distributed availability group to asynchronous commit:
    ALTER AVAILABILITY GROUP distributedAG MODIFY AVAILABILITY GROUP ON
    'ag1' WITH (AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT),
    'ag2' WITH (AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT);
   

När du har slutfört de här stegen växlar den distribuerade tillgänglighetsgruppen över utan att förlora någon data.