Skapa och konfigurera en tillgänglighetsgrupp för SQL Server i Linux

Gäller för:SQL Server i Linux

Den här självstudien visar hur du skapar och konfigurerar en tillgänglighetsgrupp (AG) för SQL Server i Linux. Till skillnad från SQL Server 2016 (13.x) och tidigare versioner på Windows kan du aktivera en AG (tillgänglighetsgrupp) med eller utan att skapa det underliggande Pacemaker-klustret först. Integrering med klustret sker vid behov senare.

Handledningen innehåller följande uppgifter:

Aktivera tillgänglighetsgrupper.
Skapa slutpunkter och certifikat för tillgänglighetsgrupper.
Använd SQL Server Management Studio (SSMS) eller Transact-SQL för att skapa en tillgänglighetsgrupp.
Skapa SQL Server-inloggning och behörigheter för Pacemaker.
Skapa resurser för tillgänglighetsgrupp i ett Pacemaker-kluster (endast extern typ).

Förutsättningar

Distribuera pacemakerklustret med hög tillgänglighet enligt beskrivningen i Distribuera ett Pacemaker-kluster för SQL Server på Linux.

Aktivera funktionen tillgänglighetsgrupper

Till skillnad från i Windows kan du inte använda PowerShell eller SQL Server Configuration Manager för att aktivera tillgänglighetsgrupper (AG). I Linux kan du aktivera funktionen tillgänglighetsgrupper på två sätt: använd verktyget mssql-conf eller redigera mssql.conf filen manuellt.

Viktig

Du måste aktivera ag-funktionen för repliker med endast konfiguration, även på SQL Server Express.

Använda verktyget mssql-conf

Kör följande kommando i en prompt:

sudo /opt/mssql/bin/mssql-conf set hadr.hadrenabled 1

Redigera filen mssql.conf

Du kan också ändra mssql.conf filen under mappen /var/opt/mssql . Lägg till följande rader:

[hadr]

hadr.hadrenabled = 1

Starta om SQL Server

När du har aktiverat tillgänglighetsgrupper måste du starta om SQL Server. Använd följande kommando:

sudo systemctl restart mssql-server

Skapa tillgänglighetsgruppens slutpunkter och certifikat

En tillgänglighetsgrupp använder TCP-slutpunkter för kommunikation. Under Linux stöds slutpunkter för en AG endast om certifikat används för autentisering. Du måste återställa certifikatet från en instans till alla andra instanser som deltar som repliker i samma tillgänglighetsgrupp. Certifikatprocessen krävs även för en replika som endast är för konfiguration.

Du kan bara skapa slutpunkter och återställa certifikat med hjälp av Transact-SQL. Du kan också använda icke-SQL Server-genererade certifikat. Du behöver också en process för att hantera och ersätta eventuella certifikat som upphör att gälla.

Viktig

Om du planerar att använda SQL Server Management Studio-guiden för att skapa disponibilitetsgruppen måste du fortfarande skapa och återställa certifikaten med hjälp av Transact-SQL i Linux.

Fullständig syntax för de alternativ som är tillgängliga för de olika kommandona (inklusive säkerhet) finns i:

Not

Även om du skapar en tillgänglighetsgrupp använder slutpunkttypen FOR DATABASE_MIRRORING, eftersom vissa underliggande aspekter en gång delades med den numera föråldrade funktionen.

Det här exemplet skapar certifikat för en konfiguration med tre noder. Instansnamnen är LinAGN1, LinAGN2och LinAGN3.

Kör följande skript på LinAGN1 för att skapa huvudnyckeln, certifikatet och slutpunkten och säkerhetskopiera certifikatet. I det här exemplet används den typiska TCP-porten 5022 för slutpunkten.

CREATE MASTER KEY ENCRYPTION BY PASSWORD = '<master-key-password>';
GO

CREATE CERTIFICATE LinAGN1_Cert
WITH SUBJECT = 'LinAGN1 AG Certificate';
GO

BACKUP CERTIFICATE LinAGN1_Cert
TO FILE = '/var/opt/mssql/data/LinAGN1_Cert.cer';
GO

CREATE ENDPOINT AGEP
STATE = STARTED
AS TCP
(
    LISTENER_PORT = 5022,
    LISTENER_IP = ALL
)
FOR DATABASE_MIRRORING
(
    AUTHENTICATION = CERTIFICATE LinAGN1_Cert,
    ROLE = ALL
);
GO

Gör samma sak på LinAGN2:

CREATE MASTER KEY ENCRYPTION BY PASSWORD = '<master-key-password>';
GO

CREATE CERTIFICATE LinAGN2_Cert
WITH SUBJECT = 'LinAGN2 AG Certificate';
GO

BACKUP CERTIFICATE LinAGN2_Cert
TO FILE = '/var/opt/mssql/data/LinAGN2_Cert.cer';
GO

CREATE ENDPOINT AGEP
STATE = STARTED
AS TCP
(
    LISTENER_PORT = 5022,
    LISTENER_IP = ALL
)
FOR DATABASE_MIRRORING
(
    AUTHENTICATION = CERTIFICATE LinAGN2_Cert,
    ROLE = ALL
);
GO

Utför slutligen samma sekvens på LinAGN3:

CREATE MASTER KEY ENCRYPTION BY PASSWORD = '<master-key-password>';
GO

CREATE CERTIFICATE LinAGN3_Cert
WITH SUBJECT = 'LinAGN3 AG Certificate';
GO

BACKUP CERTIFICATE LinAGN3_Cert
TO FILE = '/var/opt/mssql/data/LinAGN3_Cert.cer';
GO

CREATE ENDPOINT AGEP
STATE = STARTED
AS TCP
(
    LISTENER_PORT = 5022,
    LISTENER_IP = ALL
)
FOR DATABASE_MIRRORING
(
    AUTHENTICATION = CERTIFICATE LinAGN3_Cert,
    ROLE = ALL
);
GO

Med hjälp av scp eller något annat verktyg kopierar du säkerhetskopiorna av certifikatet till varje nod som ska ingå i tillgänglighetsgruppen.

I det här exemplet:
- Kopiera LinAGN1_Cert.cer till LinAGN2 och LinAGN3.
- Kopiera LinAGN2_Cert.cer till LinAGN1 och LinAGN3.
- Kopiera LinAGN3_Cert.cer till LinAGN1 och LinAGN2.
Ändra ägarskap och gruppen som är associerad med de kopierade certifikatfilerna till mssql.
```
sudo chown mssql:mssql <CertFileName>
```
Skapa inloggningar på instansnivå och användare som är associerade med LinAGN2 och LinAGN3 på LinAGN1.
```
CREATE LOGIN LinAGN2_Login
WITH PASSWORD = '<password>';

CREATE USER LinAGN2_User
FOR LOGIN LinAGN2_Login;
GO

CREATE LOGIN LinAGN3_Login
WITH PASSWORD = '<password>';

CREATE USER LinAGN3_User
FOR LOGIN LinAGN3_Login;
GO
```
Försiktighet

Lösenordet bör följa SQL Server-standardprincipen för lösenord. Lösenordet måste som standard vara minst åtta tecken långt och innehålla tecken från tre av följande fyra uppsättningar: versaler, gemener, bas-10 siffror och symboler. Lösenord kan vara upp till 128 tecken långa. Använd lösenord som är så långa och komplexa som möjligt.

Återställ LinAGN2_Cert och LinAGN3_Cert på LinAGN1. Att ha de andra replikernas certifikat är en viktig aspekt av AGs kommunikation och säkerhet.

CREATE CERTIFICATE LinAGN2_Cert
    AUTHORIZATION LinAGN2_User
    FROM FILE = '/var/opt/mssql/data/LinAGN2_Cert.cer';
GO

CREATE CERTIFICATE LinAGN3_Cert
    AUTHORIZATION LinAGN3_User
    FROM FILE = '/var/opt/mssql/data/LinAGN3_Cert.cer';
GO

Bevilja inloggningarna som är associerade med LinAGN2 och LinAGN3 behörighet att ansluta till slutpunkten på LinAGN1.
```
GRANT CONNECT ON ENDPOINT::AGEP TO LinAGN2_Login;
GRANT CONNECT ON ENDPOINT::AGEP TO LinAGN3_Login;
```

Skapa inloggningar på instansnivå och användare som är associerade med LinAGN1 och LinAGN3 på LinAGN2.

CREATE LOGIN LinAGN1_Login
WITH PASSWORD = '<password>';

CREATE USER LinAGN1_User
FOR LOGIN LinAGN1_Login;
GO

CREATE LOGIN LinAGN3_Login
WITH PASSWORD = '<password>';

CREATE USER LinAGN3_User
FOR LOGIN LinAGN3_Login;
GO

Återställ LinAGN1_Cert och LinAGN3_Cert på LinAGN2.

CREATE CERTIFICATE LinAGN1_Cert
    AUTHORIZATION LinAGN1_User
    FROM FILE = '/var/opt/mssql/data/LinAGN1_Cert.cer';
GO

CREATE CERTIFICATE LinAGN3_Cert
    AUTHORIZATION LinAGN3_User
    FROM FILE = '/var/opt/mssql/data/LinAGN3_Cert.cer';
GO

Bevilja inloggningarna som är associerade med LinAGN1 och LinAGN3 behörighet att ansluta till slutpunkten på LinAGN2.
```
GRANT CONNECT ON ENDPOINT::AGEP TO LinAGN1_Login;
GRANT CONNECT ON ENDPOINT::AGEP TO LinAGN3_Login;
GO
```

Skapa inloggningar på instansnivå och användare som är associerade med LinAGN1 och LinAGN2 på LinAGN3.

CREATE LOGIN LinAGN1_Login
WITH PASSWORD = '<password>';

CREATE USER LinAGN1_User
FOR LOGIN LinAGN1_Login;
GO

CREATE LOGIN LinAGN2_Login
WITH PASSWORD = '<password>';

CREATE USER LinAGN2_User
FOR LOGIN LinAGN2_Login;
GO

Återställ LinAGN1_Cert och LinAGN2_Cert på LinAGN3.

CREATE CERTIFICATE LinAGN1_Cert
    AUTHORIZATION LinAGN1_User
    FROM FILE = '/var/opt/mssql/data/LinAGN1_Cert.cer';
GO

CREATE CERTIFICATE LinAGN2_Cert
    AUTHORIZATION LinAGN2_User
    FROM FILE = '/var/opt/mssql/data/LinAGN2_Cert.cer';
GO

Bevilja inloggningarna som är associerade med LinAG1 och LinAGN2 behörighet att ansluta till slutpunkten på LinAGN3.
```
GRANT CONNECT ON ENDPOINT::AGEP TO LinAGN1_Login;
GRANT CONNECT ON ENDPOINT::AGEP TO LinAGN2_Login;
GO
```

Skapa tillgänglighetsgruppen

Det här avsnittet visar hur du använder SQL Server Management Studio (SSMS) eller Transact-SQL för att skapa tillgänglighetsgruppen för SQL Server.

Använda SQL Server Management Studio

Det här avsnittet visar hur du skapar en tillgänglighetsgrupp med en klustertyp av extern med hjälp av SSMS med guiden Ny tillgänglighetsgrupp.

I SSMS utökar du Always On High Availability, högerklickar på Tillgänglighetsgrupperoch väljer Ny Tillgänglighetsgruppsguiden.
I dialogrutan Introduktion väljer du Nästa.
I dialogrutan Ange alternativ för tillgänglighetsgrupp anger du ett namn för tillgänglighetsgruppen och väljer en klustertyp av EXTERNAL eller NONE i listrutan. Använd EXTERNAL när du distribuerar Pacemaker. Används NONE för specialiserade scenarier, till exempel utskalning av läsning. Det är valfritt att välja alternativet för hälsoidentifiering på databasnivå. Mer information om det här alternativet finns i alternativet för hälsoidentifiering på databasnivå för tillgänglighetsgrupp. Välj Nästa.
I dialogrutan Välj databaser väljer du de databaser som ska delta i tillgänglighetsgruppen. Varje databas måste ha en fullständig säkerhetskopia innan du kan lägga till den i en tillgänglighetsgrupp. Välj Nästa.
I dialogrutan Ange repliker väljer du Lägg till replik.
I dialogrutan Anslut till server anger du namnet på Den Linux-instans av SQL Server som ska vara den sekundära repliken och autentiseringsuppgifterna för att ansluta. Välj Anslut.
Upprepa de föregående två stegen för den instans som ska innehålla enbart en konfigurationsreplik eller en annan sekundär replik.
Alla tre instanserna visas i dialogrutan Ange repliker. Om du använder en klustertyp av Extern för den sekundära repliken som kommer att vara en sann sekundär, kontrollera att tillgänglighetsläget matchar det för den primära repliken och att redundansläget är inställt på Externt. För konfigurationsrepliken väljer du ett tillgänglighetsläge för endast konfiguration.

I följande exempel visas en AG med två repliker, den externa klustertypen och en replik som endast är konfiguration.

I följande exempel visas en tillgänglighetsgrupp med två repliker, utan klustertyp, och endast en konfigurationsreplik.
Om du vill ändra inställningarna för säkerhetskopiering väljer du fliken Inställningar för säkerhetskopiering. Mer information om säkerhetskopieringsinställningar med AG:er finns i Konfigurera säkerhetskopior på sekundära repliker i en AlwaysOn-tillgänglighetsgrupp.
Om du använder läsbara sekundärer eller skapar en tillgänglighetsgrupp med klustertypen Ingen för lässkala kan du skapa en lyssnare genom att välja fliken Lyssnare. Du kan också lägga till en lyssnare senare. Om du vill skapa en lyssnare väljer du alternativet Skapa en tillgänglighetsgruppslyssnare och anger ett namn, en TCP/IP-port och om du vill använda en statisk eller automatiskt tilldelad DHCP IP-adress. För en tillgänglighetsgrupp med klustertypen None ska IP-adressen vara statisk och ställas in på den primära IP-adressen.
Om du skapar en lyssnare för scenarier som kan läsas tillåter SSMS skapandet av en skrivskyddad routning i guiden. Du kan också lägga till den senare via SSMS eller Transact-SQL. Så här lägger du till skrivskyddad routning nu:
1. Välj fliken Read-Only Routning.
2. Ange URL:erna för de skrivskyddade replikerna. Dessa URL:er liknar slutpunkterna, förutom att de använder porten för instansen, inte slutpunkten.
3. Välj varje URL och välj de läsbara replikerna längst ned. Håll ned SKIFT eller select-drag om du vill välja flera val.
Välj Nästa.
Välj hur de sekundära replikerna initieras. Standardvärdet är att använda automatisk seeding, som kräver samma sökväg på alla servrar som deltar i tillgänglighetsgruppen. Du kan också låta guiden göra en säkerhetskopia, kopiera och återställa (det andra alternativet); ha det anslutet om du manuellt har säkerhetskopierat, kopierat och återställt databasen på replikerna (tredje alternativet); eller lägg till databasen senare (sista alternativet). Precis som med certifikat, om du manuellt gör säkerhetskopior och kopierar dem, anger du behörigheter för säkerhetskopieringsfilerna på de andra replikerna. Välj Nästa.
Om inte allt kommer tillbaka som lyckat i valideringsdialogrutan, undersök vad som har gått fel. Vissa varningar är acceptabla och inte dödliga, till exempel om du inte skapar en lyssnare. Välj Nästa.
I dialogrutan Sammanfattning väljer du Slutför. Processen för att skapa tillgänglighetsgruppen börjar nu.
När AG-skapandet är klart väljer du Stäng i resultaten. Nu kan du se AG på replikerna i de dynamiska hanteringsvyerna och under mappen Always On High Availability i SSMS.

Använd Transact-SQL

Det här avsnittet visar exempel på hur du skapar en AG (tillgänglighetsgrupp) med hjälp av Transact-SQL. Du kan konfigurera lyssnaren och routning för skrivskyddad läsning efter att ha skapat tillgänglighetsgruppen (AG). Du kan ändra tillgänglighetsgruppen med hjälp av ALTER AVAILABILITY GROUP, men du kan inte ändra klustertypen i SQL Server 2017 (14.x). Om du inte menade att skapa en tillgänglighetsgrupp med klustertypen Extern måste du ta bort den och återskapa den med klustertypen Ingen. Mer information och andra alternativ finns i följande länkar:

Exempel A: Två repliker med enbart en konfigurationsreplik (extern klustertyp)

Det här exemplet visar hur du skapar en AG med två repliker som använder en replik som bara har konfiguration.

Kör följande instruktion på den nod som ska fungera som den primära repliken och som innehåller den fullständiga läs-/skrivkopia av databaserna. I det här exemplet används automatisk seeding.

CREATE AVAILABILITY GROUP [<AGName>]
WITH (CLUSTER_TYPE = EXTERNAL)
FOR DATABASE <DBName>
REPLICA ON
N'LinAGN1' WITH (
   ENDPOINT_URL = N' TCP://LinAGN1.FullyQualified.Name:5022',
   FAILOVER_MODE = EXTERNAL,
   AVAILABILITY_MODE = SYNCHRONOUS_COMMIT
),
N'LinAGN2' WITH (
   ENDPOINT_URL = N'TCP://LinAGN2.FullyQualified.Name:5022',
   FAILOVER_MODE = EXTERNAL,
   AVAILABILITY_MODE = SYNCHRONOUS_COMMIT,
   SEEDING_MODE = AUTOMATIC
),
N'LinAGN3' WITH (
   ENDPOINT_URL = N'TCP://LinAGN3.FullyQualified.Name:5022',
   AVAILABILITY_MODE = CONFIGURATION_ONLY
);
GO

I ett frågefönster som är anslutet till den andra repliken kör du följande instruktion för att ansluta repliken till tillgänglighetsgruppen och initiera seedingprocessen från den primära till den sekundära repliken.
```
ALTER AVAILABILITY GROUP [<AGName>]
JOIN WITH (CLUSTER_TYPE = EXTERNAL);
GO

ALTER AVAILABILITY GROUP [<AGName>]
GRANT CREATE ANY DATABASE;
GO
```
I ett frågefönster som är anslutet till konfigurationsreplikan endast kör du följande instruktion för att ansluta den till AG.
```
ALTER AVAILABILITY GROUP [<AGName>]
JOIN WITH (CLUSTER_TYPE = EXTERNAL);
GO
```

Exempel B: Tre repliker med skrivskyddad routning (extern klustertyp)

Det här exemplet visar tre fullständiga repliker och hur du kan konfigurera skrivskyddad routning som en del av det första skapandet av tillgänglighetsgruppen.

Kör följande instruktion på den nod som ska fungera som den primära replikan och som har en fullständig läs- och skrivbar kopia av databaserna. I det här exemplet används automatisk seeding.

CREATE AVAILABILITY GROUP [<AGName>] WITH (CLUSTER_TYPE = EXTERNAL)
FOR DATABASE < DBName > REPLICA ON
    N'LinAGN1' WITH (
        ENDPOINT_URL = N'TCP://LinAGN1.FullyQualified.Name:5022',
        FAILOVER_MODE = EXTERNAL,
        AVAILABILITY_MODE = SYNCHRONOUS_COMMIT,
        PRIMARY_ROLE(ALLOW_CONNECTIONS = READ_WRITE, READ_ONLY_ROUTING_LIST = (
            (
                'LinAGN2.FullyQualified.Name',
                'LinAGN3.FullyQualified.Name'
                )
            )),
        SECONDARY_ROLE(ALLOW_CONNECTIONS = ALL, READ_ONLY_ROUTING_URL = N'TCP://LinAGN1.FullyQualified.Name:1433')
    ),
    N'LinAGN2' WITH (
        ENDPOINT_URL = N'TCP://LinAGN2.FullyQualified.Name:5022',
        FAILOVER_MODE = EXTERNAL,
        SEEDING_MODE = AUTOMATIC,
        AVAILABILITY_MODE = SYNCHRONOUS_COMMIT,
        PRIMARY_ROLE(ALLOW_CONNECTIONS = READ_WRITE, READ_ONLY_ROUTING_LIST = (
            (
                'LinAGN1.FullyQualified.Name',
                'LinAGN3.FullyQualified.Name'
                )
            )),
        SECONDARY_ROLE(ALLOW_CONNECTIONS = ALL, READ_ONLY_ROUTING_URL = N'TCP://LinAGN2.FullyQualified.Name:1433')
    ),
    N'LinAGN3' WITH (
        ENDPOINT_URL = N'TCP://LinAGN3.FullyQualified.Name:5022',
        FAILOVER_MODE = EXTERNAL,
        SEEDING_MODE = AUTOMATIC,
        AVAILABILITY_MODE = SYNCHRONOUS_COMMIT,
        PRIMARY_ROLE(ALLOW_CONNECTIONS = READ_WRITE, READ_ONLY_ROUTING_LIST = (
            (
                'LinAGN1.FullyQualified.Name',
                'LinAGN2.FullyQualified.Name'
                )
            )),
        SECONDARY_ROLE(ALLOW_CONNECTIONS = ALL, READ_ONLY_ROUTING_URL = N'TCP://LinAGN3.FullyQualified.Name:1433')
    )
    LISTENER '<ListenerName>' (
        WITH IP = ('<IPAddress>', '<SubnetMask>'), Port = 1433
    );
GO

Några saker att notera om den här konfigurationen:

AGName är namnet på tillgänglighetsgruppen.
DBName är namnet på databasen som du använder med tillgänglighetsgruppen. Det kan också vara en lista med namn avgränsade med kommatecken.
ListenerName är ett namn som skiljer sig från någon av de underliggande servrarna eller noderna. Den är registrerad i DNS tillsammans med IPAddress.
IPAddress är en IP-adress som är associerad med ListenerName. Det är också unikt och inte detsamma som någon av servrarna eller noderna. Applikationer och slutanvändare använder antingen ListenerName eller IPAddress för att ansluta till AG.
- SubnetMask är nätmasken för IPAddress. I SQL Server 2019 (15.x) och tidigare versioner är 255.255.255.255det här värdet . I SQL Server 2022 (16.x) och senare versioner är 0.0.0.0det här värdet .

I ett frågefönster som är anslutet till den andra repliken kör du följande uttalande för att ansluta repliken till AG och initiera seedingprocessen från den primära till den sekundära repliken.
```
ALTER AVAILABILITY GROUP [<AGName>]
JOIN WITH (CLUSTER_TYPE = EXTERNAL);
GO

ALTER AVAILABILITY GROUP [<AGName>]
GRANT CREATE ANY DATABASE;
GO
```
Upprepa steg 2 för den tredje repliken.

Exempel C: Två repliker med skrivskyddad routing (utan klustertyp)

Det här exemplet visar skapandet av en konfiguration med två repliker med en klustertyp av Ingen. Använd den här konfigurationen för lässkalningsscenariot där ingen redundans förväntas. Det här steget skapar lyssnaren som faktiskt är den primära repliken och den skrivskyddade routningen med hjälp av resursallokeringsfunktionen.

Kör följande instruktion på den nod som ska fungera som den primära repliken och som innehåller den kompletta läs-/skrivkopian av databaserna. I det här exemplet används automatisk seeding.

CREATE AVAILABILITY GROUP [<AGName>]
WITH (CLUSTER_TYPE = NONE)
FOR DATABASE <DBName> REPLICA ON
    N'LinAGN1' WITH (
        ENDPOINT_URL = N'TCP://LinAGN1.FullyQualified.Name: <PortOfEndpoint>',
        FAILOVER_MODE = MANUAL,
        AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT,
        PRIMARY_ROLE(
            ALLOW_CONNECTIONS = READ_WRITE,
            READ_ONLY_ROUTING_LIST = (('LinAGN1.FullyQualified.Name'.'LinAGN2.FullyQualified.Name'))
        ),
        SECONDARY_ROLE(
            ALLOW_CONNECTIONS = ALL,
            READ_ONLY_ROUTING_URL = N'TCP://LinAGN1.FullyQualified.Name:<PortOfInstance>'
        )
    ),
    N'LinAGN2' WITH (
        ENDPOINT_URL = N'TCP://LinAGN2.FullyQualified.Name:<PortOfEndpoint>',
        FAILOVER_MODE = MANUAL,
        SEEDING_MODE = AUTOMATIC,
        AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT,
        PRIMARY_ROLE(ALLOW_CONNECTIONS = READ_WRITE, READ_ONLY_ROUTING_LIST = (
                 ('LinAGN1.FullyQualified.Name',
                    'LinAGN2.FullyQualified.Name')
                 )),
        SECONDARY_ROLE(ALLOW_CONNECTIONS = ALL, READ_ONLY_ROUTING_URL = N'TCP://LinAGN2.FullyQualified.Name:<PortOfInstance>')
    ),
    LISTENER '<ListenerName>' (WITH IP = (
             '<PrimaryReplicaIPAddress>',
             '<SubnetMask>'),
            Port = <PortOfListener>
    );
GO

I det här exemplet:

AGName är namnet på tillgänglighetsgruppen.
DBName är namnet på databasen som du använder med tillgänglighetsgruppen. Det kan också vara en lista med namn avgränsade med kommatecken.
PortOfEndpoint är det portnummer som används av slutpunkten som du skapar.
- PortOfInstance är portnumret som används av instansen av SQL Server.
ListenerName är ett namn som skiljer sig från någon av de underliggande replikerna men som inte används i praktiken.
PrimaryReplicaIPAddress är IP-adressen för den primära repliken.
- SubnetMask är nätmasken för IPAddress. I SQL Server 2019 (15.x) och tidigare versioner är 255.255.255.255det här värdet . I SQL Server 2022 (16.x) och senare versioner är 0.0.0.0det här värdet .

Anslut den sekundära repliken till tillgänglighetsgruppen och starta automatisk sådd.

ALTER AVAILABILITY GROUP [<AGName>]
JOIN WITH (CLUSTER_TYPE = NONE);
GO

ALTER AVAILABILITY GROUP [<AGName>]
GRANT CREATE ANY DATABASE;
GO

Ett pacemakerkluster med hög tillgänglighet som använder SQL Server i Linux behöver åtkomst till SQL Server-instansen och behörigheter för själva tillgänglighetsgruppen. De här stegen skapar inloggningen och de associerade behörigheterna, tillsammans med en fil som talar om för Pacemaker hur man loggar in på SQL Server.

Kör följande skript i ett frågefönster som är anslutet till den första repliken:

CREATE LOGIN PMLogin WITH PASSWORD ='<password>';
GO

GRANT VIEW SERVER STATE TO PMLogin;
GO

GRANT ALTER, CONTROL, VIEW DEFINITION
ON AVAILABILITY GROUP::<AGThatWasCreated> TO PMLogin;
GO

På nod 1 anger du kommandot:
```
sudo emacs /var/opt/mssql/secrets/passwd
```
Det här kommandot öppnar Emacs-redigeraren.
Ange följande två rader i redigeraren:
```
PMLogin

<password>
```
Håll ned Ctrl och tryck sedan på Xoch sedan Cför att avsluta och spara filen.

Kör:

sudo chmod 400 /var/opt/mssql/secrets/passwd

för att låsa filen.

Upprepa steg 1–5 på de andra servrarna som fungerar som repliker.

Skapa resurser för tillgänglighetsgrupp i Pacemaker-klustret (endast externt)

När du har skapat en tillgänglighetsgrupp i SQL Server måste du skapa motsvarande resurser i Pacemaker när du anger en klustertyp för Extern. Två resurser är associerade med en tillgänglighetsgrupp: själva tillgänglighetsgruppen och en IP-adress. Det är valfritt att konfigurera IP-adressresursen om du inte använder lyssnarfunktionen, men det rekommenderas.

Den AG-resurs som du skapar är en typ av resurs som kallas klon. Tillgänglighetsgruppens resurs har kopior på varje nod och en kontrollerande resurs som kallas huvudresursen. Huvudservern är associerad med servern som är värd för den primära repliken. De andra resurserna är värdar för sekundära repliker (vanliga eller endast konfigurationsbaserade) och kan uppgraderas till primär replik vid en failover.

Red Hat Enterprise Linux (RHEL) och Ubuntu
SUSE Linux Enterprise Server (SLES)

Skapa ag-resursen med följande syntax:
```
sudo pcs resource create <NameForAGResource> ocf:mssql:ag ag_name=<AGName> meta failure-timeout=30s promotable notify=true
```
I det här exemplet NameForAGResource är det unika namn som du ger den här klusterresursen för tillgänglighetsgruppen och AGName är namnet på den tillgänglighetsgrupp som du skapade.
Skapa IP-adressresursen för applikationsgatewayen som du associerar med lyssnarens funktionalitet.
```
sudo pcs resource create <NameForIPResource> ocf:heartbeat:IPaddr2 ip=<IPAddress> cidr_netmask=<Netmask>
```
I det här exemplet NameForIPResource är det unika namnet på IP-resursen och IPAddress är den statiska IP-adress som du tilldelar resursen.
För att säkerställa att IP-adressen och tillgänglighetsgruppens resurs körs på samma nod konfigurerar du en samlokaliseringsbegränsning.
```
sudo pcs constraint colocation add <NameForIPResource> with promoted <NameForAGResource>-clone INFINITY
```
I det här exemplet NameForIPResource är namnet på IP-resursen och NameForAGResource namnet på tillgänglighetsgruppens resurs.
Skapa en beställningsbegränsning för att säkerställa att AG-resursen är uppe och fungerar före IP-adressen. Även om samlokaliseringsbegränsningen innebär en ordningsbegränsning framtvingar det här steget den.
```
sudo pcs constraint order promote <NameForAGResource>-clone then start <NameForIPResource>
```
I det här exemplet NameForIPResource är namnet på IP-resursen och NameForAGResource namnet på tillgänglighetsgruppens resurs.

Not

Från och med SQL Server 2025 (17.x) stöds inte SUSE Linux Enterprise Server (SLES).

Skapa ag-resursen med följande syntax:

primitive <NameForAGResource> \
ocf:mssql:ag \
params ag_name="<AGName>" \
meta failure-timeout=60s \
op start timeout=60s \
op stop timeout=60s \
op promote timeout=60s \
op demote timeout=10s \
op monitor timeout=60s interval=10s \
op monitor timeout=60s interval=11s role="Promoted" \
op notify timeout=60s
clone ms-ag_cluster <NameForAGResource> \
meta promoted-max="1" promoted-node-max="1" clone-max="3" \
    promotable="true" clone-node-max="1" notify="true" \
commit

I det här exemplet NameForAGResource är det unika namn som du ger den här klusterresursen för tillgänglighetsgruppen och AGName är namnet på den tillgänglighetsgrupp som du skapade.

Skapa IP-adressresursen för applikationsgatewayen som du associerar med lyssnarfunktionen.
```
crm configure \
primitive <NameForIPResource> \
   ocf:heartbeat:IPaddr2 \
   params ip=<IPAddress> \
      cidr_netmask=<Netmask>
```
I det här exemplet NameForIPResource är det unika namnet på IP-resursen och IPAddress är den statiska IP-adress som du tilldelar resursen. På SLES måste du också ange nätmasken. Till exempel har 255.255.255.0 värdet 24 för Netmask.
För att säkerställa att IP-adressen och tillgänglighetsgruppens resurs körs på samma nod konfigurerar du en samlokaliseringsbegränsning.
```
crm configure <NameForConstraint> inf: \
<NameForIPResource> <NameForAGResource>:Promoted
commit
```
I det här exemplet NameForIPResource är namnet på IP-resursen, NameForAGResource är namnet på resursen för tillgänglighetsgruppen och NameForConstraint är namnet på villkoret.
Skapa en beställningsbegränsning för att säkerställa att AG-resursen är uppe och fungerar före IP-adressen. Även om samlokaliseringsbegränsningen innebär en ordningsbegränsning framtvingar det här steget den.
```
crm configure \
order <NameForConstraint> Mandatory: <NameForAGResource>:promote <NameForIPResource>:start
commit
```
I det här exemplet NameForIPResource är namnet på IP-resursen, NameForAGResource är namnet på resursen för tillgänglighetsgruppen och NameForConstraint är namnet på villkoret.

Nästa steg

I den här självstudien har du lärt dig hur du skapar och konfigurerar en tillgänglighetsgrupp för SQL Server i Linux. Du har lärt dig att:

Aktivera tillgänglighetsgrupper.
Skapa AG-slutpunkter och certifikat.
Använd SQL Server Management Studio (SSMS) eller Transact-SQL för att skapa en tillgänglighetsgrupp (AG).
Skapa SQL Server-inloggning och behörigheter för Pacemaker.
Skapa AG-resurser i ett Pacemaker-kluster.

De flesta administrationsuppgifter för AG, inklusive uppgraderingar och failover, finns i:

AlwaysOn-redundans för tillgänglighetsgrupp i Linux

Feedback

Var den här sidan hjälpsam?

Last updated on 2026-01-05