Freigeben über

Lernprogramm: Konfigurieren von Verfügbarkeitsgruppen für SQL Server auf virtuellen Ubuntu-Computern in Azure

In diesem Tutorial lernen Sie, wie Sie:

  • Erstellen von virtuellen Maschinen und Platzieren in einer Verfügbarkeitsgruppe
  • Aktivieren von Hochverfügbarkeit (High Availability, HA)
  • Erstellen eines Pacemaker-Clusters
  • Konfigurieren eines Fencing-Agents durch Erstellen eines STONITH-Geräts
  • Installieren von SQL Server und mssql-tools auf Ubuntu
  • Konfigurieren einer SQL Server-Always On-Verfügbarkeitsgruppe
  • Konfigurieren von Verfügbarkeitsgruppenressourcen im Pacemaker-Cluster
  • Testen von Failover und Fencing-Agent

Hinweis

Dieser Artikel enthält Verweise auf den Begriff Slave, einen Begriff, den Microsoft nicht mehr verwendet. Wenn der Begriff aus der Software entfernt wird, entfernen wir ihn aus diesem Artikel.

In diesem Tutorial wird die Azure CLI verwendet, um Ressourcen in Azure bereitzustellen.

Wenn Sie noch kein Azure-Abonnement haben, erstellen Sie ein kostenloses Konto, bevor Sie beginnen.

Voraussetzungen

  • Für diesen Artikel ist mindestens Version 2.0.30 der Azure CLI erforderlich. Wenn Sie Azure Cloud Shell verwenden, ist die neueste Version bereits installiert.

Erstellen einer Ressourcengruppe

Sollten Sie über mehrere Abonnements verfügen, legen Sie das Abonnement fest, für das Sie diese Ressourcen bereitstellen möchten.

Verwenden Sie den folgenden Befehl, um eine Ressourcengruppe (<resourceGroupName>) in einer Region zu erstellen. Ersetzen Sie <resourceGroupName> durch einen Namen Ihrer Wahl. In diesem Tutorial wird East US 2 verwendet. Weitere Informationen finden Sie in dieser Schnellstartanleitung.

az group create --name <resourceGroupName> --location eastus2

Verfügbarkeitsgruppe erstellen

Im nächsten Schritt wird eine Verfügbarkeitsgruppe erstellt. Führen Sie in Azure Cloud Shell den folgenden Befehl aus, und ersetzen Sie dabei <resourceGroupName> durch den Namen Ihrer Ressourcengruppe. Wählen Sie einen Namen für <availabilitySetName> aus.

az vm availability-set create \
    --resource-group <resourceGroupName> \
    --name <availabilitySetName> \
    --platform-fault-domain-count 2 \
    --platform-update-domain-count 2

Die Ergebnisse des abgeschlossenen Befehls sollten wie folgt aussehen:

{
  "id": "/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.Compute/availabilitySets/<availabilitySetName>",
  "location": "eastus2",
  "name": "<availabilitySetName>",
  "platformFaultDomainCount": 2,
  "platformUpdateDomainCount": 2,
  "proximityPlacementGroup": null,
  "resourceGroup": "<resourceGroupName>",
  "sku": {
    "capacity": null,
    "name": "Aligned",
    "tier": null
  },
  "statuses": null,
  "tags": {},
  "type": "Microsoft.Compute/availabilitySets",
  "virtualMachines": []
}

Erstellen eines virtuellen Netzwerks und des Subnetzes

  1. Erstellen Sie ein benanntes Subnetz mit einem vordefinierten IP-Adressbereich. Ersetzen Sie diese Werte im folgenden Befehl:

    • <resourceGroupName>
    • <vNetName>
    • <subnetName>
    az network vnet create \
    --resource-group <resourceGroupName> \
    --name <vNetName> \
    --address-prefix 10.1.0.0/16 \
    --subnet-name <subnetName> \
    --subnet-prefix 10.1.1.0/24

    Der obige Befehl erstellt ein VNet und ein Subnetz mit einem benutzerdefinierten IP-Adressbereich.

Erstellen von Ubuntu-VMs innerhalb des Verfügbarkeitssatzes

  1. Rufen Sie eine Liste der VM-Images ab, die ein Ubuntu-basiertes Betriebssystem in Azure von Canonical anbieten.

     az vm image list --all --publisher "Canonical"

    In diesem Tutorial wird Ubuntu 20.04 verwendet.

    Von Bedeutung

    Computernamen müssen weniger als 15 Zeichen lang sein, um eine Verfügbarkeitsgruppe einzurichten. Benutzernamen dürfen keine Großbuchstaben enthalten, und Kennwörter müssen zwischen 12 und 72 Zeichen lang sein.

  2. Erstellen Sie drei VMs in der Verfügbarkeitsgruppe. Ersetzen Sie diese Werte im folgenden Befehl:

    • <resourceGroupName>
    • <VM-basename>
    • <availabilitySetName>
    • <VM-Size>: Ein Beispiel wäre etwa „Standard_D16s_v3“.
    • <username>
    • <adminPassword>
    • <vNetName>
    • <subnetName>
    for i in `seq 1 3`; do
    az vm create \
       --resource-group <resourceGroupName> \
       --name <VM-basename>$i \
       --availability-set <availabilitySetName> \
       --size "<VM-Size>" \
       --os-disk-size-gb 128 \
       --image "Canonical:0001-com-ubuntu-server-jammy:20_04-lts-gen2:latest" \
       --admin-username "<username>" \
       --admin-password "<adminPassword>" \
       --authentication-type all \
       --generate-ssh-keys \
       --vnet-name "<vNetName>" \
       --subnet "<subnetName>" \
       --public-ip-sku Standard \
       --public-ip-address ""
    done

Der obige Befehl erstellt die VMs mithilfe des zuvor definierten VNet. Weitere Informationen zu den verschiedenen Konfigurationen finden Sie im Artikel zu „az vm create“.

Der Befehl enthält auch den Parameter --os-disk-size-gb zum Erstellen einer benutzerdefinierten Laufwerkgröße für das Betriebssystem von 128 GB. Wenn Sie diesen Größenwert später erhöhen, erweitern Sie die entsprechenden Ordnervolumes für Ihre Installation, und konfigurieren Sie den Logical Volume Manager (LVM).

Nach Abschluss des Befehls für die einzelnen virtuellen Computer sollten die Ergebnisse in etwa wie folgt aussehen:

{
  "fqdns": "",
  "id": "/subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>/providers/Microsoft.Compute/virtualMachines/ubuntu1",
  "location": "westus",
  "macAddress": "<Some MAC address>",
  "powerState": "VM running",
  "privateIpAddress": "<IP1>",
  "resourceGroup": "<resourceGroupName>",
  "zones": ""
}

Testen der Verbindung mit den erstellten virtuellen Computern

Stellen Sie mithilfe des folgenden Befehls in Azure Cloud Shell eine Verbindung mit jeder VM her. Sollten Sie die IP-Adressen Ihrer VMs nicht finden, lesen Sie diese Schnellstartanleitung zu Azure Cloud Shell.

ssh <username>@<publicIPAddress>

Nach erfolgreicher Verbindungsherstellung sollte die folgende Ausgabe (Linux-Terminal) angezeigt werden:

[<username>@ubuntu1 ~]$

Geben Sie exit ein, um die SSH-Sitzung zu verlassen.

Konfigurieren des kennwortlosen SSH-Zugriffs zwischen Knoten

Der kennwortlose SSH-Zugriff ermöglicht es Ihren VMs, mithilfe öffentlicher SSH-Schlüssel miteinander zu kommunizieren. Sie müssen SSH-Schlüssel auf jedem Knoten konfigurieren und diese Schlüssel auf jeden Knoten kopieren.

Generieren neuer SSH-Schlüssel

Die erforderliche SSH-Schlüsselgröße beträgt 4.096 Bit. Wechseln Sie auf jeder VM zum Ordner /root/.ssh, und führen Sie den folgenden Befehl aus:

ssh-keygen -t rsa -b 4096

In diesem Schritt werden Sie möglicherweise aufgefordert, eine vorhandene SSH-Datei zu überschreiben. Sie müssen dieser Aufforderung zustimmen. Sie müssen keine Passphrase eingeben.

Kopieren der öffentlichen SSH-Schlüssel

Sie müssen den öffentlichen Schlüssel von dem gerade erstellten Knoten mithilfe des Befehls ssh-copy-id auf jede VM kopieren. Wenn Sie das Zielverzeichnis auf der Ziel-VM angeben möchten, können Sie den Parameter -i verwenden.

Im folgenden Befehl kann das Konto <username> das gleiche Konto sein, das Sie beim Erstellen der VM für jeden Knoten konfiguriert haben. Sie können das root Konto auch verwenden, aber diese Option wird in einer Produktionsumgebung nicht empfohlen.

sudo ssh-copy-id <username>@ubuntu1
sudo ssh-copy-id <username>@ubuntu2
sudo ssh-copy-id <username>@ubuntu3

Überprüfen des kennwortlosen Zugriffs von jedem Knoten aus

Um sich zu vergewissern, dass der öffentliche SSH-Schlüssel auf jeden Knoten kopiert wurde, verwenden Sie den Befehl ssh auf dem jedem Knoten. Wenn Sie die Schlüssel ordnungsgemäß kopiert haben, werden Sie nicht zur Eingabe eines Kennworts aufgefordert, und die Verbindung wurde erfolgreich hergestellt.

In diesem Beispiel stellen wir eine Verbindung mit den zweiten und dritten Knoten von der ersten VM (ubuntu1) her. Erneut kann das <username> Konto dasselbe Konto sein, das Sie beim Erstellen der VM für jeden Knoten konfiguriert haben.

ssh <username>@ubuntu2
ssh <username>@ubuntu3

Wiederholen Sie diesen Vorgang auf allen drei Knoten, damit jeder Knoten mit den anderen kommunizieren kann, ohne Kennwörter zu benötigen.

Konfigurieren der Namensauflösung

Sie können die Namensauflösung entweder mithilfe von DNS oder durch manuelles Bearbeiten der Datei etc/hosts auf jedem Knoten konfigurieren.

Weitere Informationen zu DNS und Active Directory finden Sie unter Verknüpfen eines Hosts für SQL Server für Linux mit einer Active Directory-Domäne.

Von Bedeutung

Es empfiehlt sich, im vorherigen Beispiel Ihre private IP-Adresse zu verwenden. Mit der öffentlichen IP-Adresse wäre die Einrichtung in dieser Konfiguration nicht erfolgreich, und Ihre VM wäre über externe Netzwerke zugänglich.

In diesem Beispiel werden die folgenden VMs und ihre zugehörigen IP-Adressen verwendet:

  • ubuntu1: 10.0.0.85
  • ubuntu2: 10.0.0.86
  • ubuntu3: 10.0.0.87

Hohe Verfügbarkeit aktivieren

Verwenden Sie ssh , um eine Verbindung mit den 3 VMs herzustellen, und führen Sie nach der Verbindung die folgenden Befehle aus, um eine hohe Verfügbarkeit zu ermöglichen.

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

Installieren und Konfigurieren des Pacemaker-Clusters

Um mit der Konfiguration des Pacemaker-Clusters zu beginnen, müssen Sie die erforderlichen Pakete und Ressourcen-Agents installieren. Führen Sie die folgenden Befehle auf jedem Ihrer virtuellen Computer aus:

sudo apt-get install -y pacemaker pacemaker-cli-utils crmsh resource-agents fence-agents csync2 python3-azure

Fahren Sie nun mit dem Erstellen des Authentifizierungsschlüssels auf dem primären Server fort:

sudo corosync-keygen

Der Authentifizierungsschlüssel wird am /etc/corosync/authkey Speicherort generiert. Kopieren Sie den Authentifizierungsschlüssel an sekundäre Server an diesem Speicherort: /etc/corosync/authkey

sudo scp /etc/corosync/authkey username@ubuntu2:~
sudo scp /etc/corosync/authkey username@ubuntu3:~

Verschieben Sie den Authentifizierungsschlüssel aus dem Startverzeichnis in /etc/corosync.

sudo mv authkey /etc/corosync/authkey

Fahren Sie mit dem Erstellen des Clusters fort, indem Sie die folgenden Befehle verwenden:

cd /etc/corosync/
sudo vi corosync.conf

Bearbeiten Sie die Corosync-Datei, um Inhalte wie folgt darzustellen:

totem {
    version: 2
    secauth: off
    cluster_name: demo
    transport: udpu
}

nodelist {
    node {
        ring0_addr: 10.0.0.85
        name: ubuntu1
        nodeid: 1
    }
    node {
        ring0_addr: 10.0.0.86
        name: ubuntu2
        nodeid: 2
    }
    node {
        ring0_addr: 10.0.0.87
        name: ubuntu3
        nodeid: 3
    }
}

quorum {
    provider: corosync_votequorum
    two_node: 0
}

qb {
    ipc_type: native
}

logging {
    fileline: on
    to_stderr: on
    to_logfile: yes
    logfile: /var/log/corosync/corosync.log
    to_syslog: no
    debug: off
}

Kopieren Sie die corosync.conf Datei auf andere Knoten in /etc/corosync/corosync.conf:

sudo scp /etc/corosync/corosync.conf username@ubuntu2:~
sudo scp /etc/corosync/corosync.conf username@ubuntu3:~
sudo mv corosync.conf /etc/corosync/

Starten Sie Pacemaker und Corosync neu, und bestätigen Sie den Status:

sudo systemctl restart pacemaker corosync
sudo crm status

Die Ausgabe sieht in etwa wie im folgenden Beispiel aus:

Cluster Summary:
  * Stack: corosync
  * Current DC: ubuntu1 (version 2.0.3-4b1f869f0f) - partition with quorum
  * Last updated: Wed Nov 29 07:01:32 2023
  * Last change:  Sun Nov 26 17:00:26 2023 by hacluster via crmd on ubuntu1
  * 3 nodes configured
  * 0 resource instances configured

Node List:
  * Online: [ ubuntu1 ubuntu2 ubuntu3 ]

Full List of Resources:
  * No resources

Konfigurieren des Fencing-Agents

Konfigurieren Sie das Fencing auf dem Cluster. Das Fencing ist die Isolierung eines fehlgeschlagenen Knotens in einem Cluster. Er startet den fehlgeschlagenen Knoten neu, sodass er herunterfährt, zurückgesetzt und neu gestartet wird und wieder dem Cluster beitritt.

Führen Sie zum Konfigurieren des Fencings die folgenden Aktionen aus:

  1. Registrieren Sie eine neue Anwendung in Microsoft Entra ID und erstellen Sie ein Geheimnis.
  2. Erstellen einer benutzerdefinierten Rolle aus json-Datei in powershell/CLI
  3. Weisen Sie die Rolle und Anwendung den virtuellen Maschinen im Cluster zu
  4. Festlegen der Fencing-Agent-Eigenschaften

Registrieren Sie eine neue Anwendung in Microsoft Entra ID und erstellen Sie ein Geheimnis.

  1. Wechseln Sie zu Microsoft Entra ID im Portal, und notieren Sie sich die Mandanten-ID.
  2. Wählen Sie im linken Menü "App-Registrierungen" und dann " Neue Registrierung" aus.
  3. Geben Sie einen Namen ein, und wählen Sie dann Konten nur in diesem Organisationsverzeichnis aus.
  4. Wählen Sie für den Anwendungstyp"Web" aus, geben Sie http://localhost als Anmelde-URL ein, und wählen Sie dann "Registrieren" aus.
  5. Wählen Sie im linken Menü "Zertifikate und geheime Schlüssel " und dann " Neuer geheimer Clientschlüssel" aus.
  6. Geben Sie eine Beschreibung ein, und wählen Sie einen Ablaufzeitraum aus.
  7. Notieren Sie sich den Wert des geheimen Schlüssels, sie wird als das folgende Kennwort und die geheime ID verwendet, sie wird als der folgende Benutzername verwendet.
  8. Wählen Sie "Übersicht" aus, und notieren Sie sich die Anwendungs-ID. Sie wird als folgende Anmeldung verwendet.

Erstellen Sie eine JSON-Datei namens fence-agent-role.json , und fügen Sie Folgendes hinzu (Hinzufügen Ihrer Abonnement-ID):

{
  "Name": "Linux Fence Agent Role-ap-server-01-fence-agent",
  "Id": null,
  "IsCustom": true,
  "Description": "Allows to power-off and start virtual machines",
  "Actions": [
    "Microsoft.Compute/*/read",
    "Microsoft.Compute/virtualMachines/powerOff/action",
    "Microsoft.Compute/virtualMachines/start/action"
  ],
  "NotActions": [],
  "AssignableScopes": [
    "/subscriptions/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"
  ]
}

Erstellen einer benutzerdefinierten Rolle aus der JSON-Datei in PowerShell/CLI

az role definition create --role-definition fence-agent-role.json

Weisen Sie die Rolle und Anwendung den virtuellen Maschinen im Cluster zu

  1. Wählen Sie für jede der virtuellen Computer im Cluster im Seitmenü die Zugriffssteuerung (IAM) aus.
  2. Wählen Sie " Rollenzuweisung hinzufügen " aus (verwenden Sie die klassische Oberfläche).
  3. Wählen Sie die zuvor erstellte Rolle aus.
  4. Geben Sie in der Liste "Auswählen" den Namen der zuvor erstellten Anwendung ein.

Jetzt können wir die Fencing Agent-Ressource mit vorherigen Werten und Ihrer Abonnement-ID erstellen:

  sudo crm configure primitive fence-vm stonith:fence_azure_arm \
params \
action=reboot \
resourceGroup="resourcegroupname" \
resourceGroup="$resourceGroup" \
username="$secretId" \
login="$applicationId" \
passwd="$password" \
tenantId="$tenantId" \
subscriptionId="$subscriptionId" \
pcmk_reboot_timeout=900 \
power_timeout=60 \
op monitor \
interval=3600 \
timeout=120

Festlegen der Fencing-Agent-Eigenschaften

Führen Sie die folgenden Befehle aus, um die Fencing-Agent-Eigenschaften festzulegen:

sudo crm configure property cluster-recheck-interval=2min
sudo crm configure property start-failure-is-fatal=true
sudo crm configure property stonith-timeout=900
sudo crm configure property concurrent-fencing=true
sudo crm configure property stonith-enabled=true

Und bestätigen Sie den Clusterstatus:

  sudo crm status

Die Ausgabe sieht in etwa wie im folgenden Beispiel aus:

Cluster Summary:
  * Stack: corosync
  * Current DC: ubuntu1 (version 2.0.3-4b1f869f0f) - partition with quorum
  * Last updated: Wed Nov 29 07:01:32 2023
  * Last change:  Sun Nov 26 17:00:26 2023 by root via cibadmin on ubuntu1
  * 3 nodes configured
  * 1 resource instances configured

Node List:
  * Online: [ ubuntu1 ubuntu2 ubuntu3 ]

Full List of Resources:
  * fence-vm     (stonith:fence_azure_arm):                        Started ubuntu1

Installieren von SQL Server und „mssql-tools“

Die folgenden Befehle dienen zum Installieren von SQL Server:

  1. Importieren Sie die öffentlichen GPG-Schlüssel des Repositorys:

    curl https://packages.microsoft.com/keys/microsoft.asc | sudo tee /etc/apt/trusted.gpg.d/microsoft.asc

  2. Registrieren Sie das Ubuntu-Repository:

    sudo add-apt-repository "$(wget -qO- https://packages.microsoft.com/config/ubuntu/20.04/mssql-server-2022.list)"

  3. Führen Sie die folgenden Befehle aus, um SQL Server zu installieren:

    sudo apt-get update
sudo apt-get install -y mssql-server

  4. Nachdem die Paketinstallation abgeschlossen ist, führen Sie mssql-conf setup aus, und befolgen Sie die Anweisungen, um das Systemadministratorkennwort festzulegen und Ihre Edition auszuwählen. Als Erinnerung werden die folgenden Editionen frei lizenziert: Evaluation, Developer und Express.

    sudo /opt/mssql/bin/mssql-conf setup

  5. Nachdem die Konfiguration abgeschlossen ist, überprüfen Sie, ob der Dienst ausgeführt wird:

    systemctl status mssql-server --no-pager

  6. Installieren der SQL Server-Befehlszeilentools

Um eine Datenbank zu erstellen, müssen Sie eine Verbindung mit einem Tool herstellen, das Transact-SQL-Anweisungen auf dem SQL Server-Computer ausführen kann. Die folgenden Schritte installieren die SQL Server-Befehlszeilentools: sqlcmd und bcp.

Führen Sie zum Installieren von mssql-tools18 unter Ubuntu die folgenden Schritte aus.

Hinweis

  • Ubuntu 18.04 wird ab SQL Server 2019 CU 3 unterstützt.
  • Ubuntu 20.04 wird ab SQL Server 2019 CU 10 unterstützt.
  • Ubuntu 22.04 wird ab SQL Server 2022 CU 10 unterstützt.

  1. Geben Sie den Superusermodus ein.

    sudo su

  2. Importieren Sie die GPG-Schlüssel des öffentlichen Repositorys.

    curl https://packages.microsoft.com/keys/microsoft.asc | sudo tee /etc/apt/trusted.gpg.d/microsoft.asc

  3. Registrieren Sie das Microsoft Ubuntu-Repository.

    • Führen Sie für Ubuntu 22.04 den folgenden Befehl aus:

      curl https://packages.microsoft.com/config/ubuntu/22.04/prod.list > /etc/apt/sources.list.d/mssql-release.list

    • Führen Sie für Ubuntu 20.04 den folgenden Befehl aus:

      curl https://packages.microsoft.com/config/ubuntu/20.04/prod.list > /etc/apt/sources.list.d/mssql-release.list

    • Führen Sie für Ubuntu 18.04 den folgenden Befehl aus:

      curl https://packages.microsoft.com/config/ubuntu/18.04/prod.list > /etc/apt/sources.list.d/mssql-release.list

    • Führen Sie für Ubuntu 16.04 den folgenden Befehl aus:

      curl https://packages.microsoft.com/config/ubuntu/16.04/prod.list > /etc/apt/sources.list.d/mssql-release.list

  4. Beenden Sie den Superuser-Modus.

    exit

  5. Aktualisieren Sie die Liste mit Quellen, und führen Sie den Installationsbefehl mit dem unixODBC-Entwicklerpaket aus.

    sudo apt-get update
sudo apt-get install mssql-tools18 unixodbc-dev

    Hinweis

    Führen Sie die folgenden Befehle aus, um mssql-tools auf die neueste Version zu aktualisieren:

    sudo apt-get update  
sudo apt-get install mssql-tools18

  6. Optional: Fügen Sie in einer Bash-Shell /opt/mssql-tools18/bin/ zu Ihrer PATH-Umgebungsvariablen hinzu.

    Um sqlcmd und bcp von der Bash-Shell aus für Anmeldesitzungen zugänglich zu machen, ändern Sie Ihre PATH in der ~/.bash_profile Datei mit dem folgenden Befehl:

    echo 'export PATH="$PATH:/opt/mssql-tools18/bin"' >> ~/.bash_profile

    Um sqlcmd oder bcp von der Bash-Shell aus für interaktive Sitzungen oder Sitzungen ohne Anmeldung zugänglich zu machen, ändern Sie mit dem folgenden Befehl PATH in der ~/.bashrc-Datei:

    echo 'export PATH="$PATH:/opt/mssql-tools18/bin"' >> ~/.bashrc
source ~/.bashrc

Installieren des SQL Server-Hochverfügbarkeits-Agents

Führen Sie den folgenden Befehl auf allen Knoten aus, um das Hochverfügbarkeits-Agent-Paket für SQL Server zu installieren:

sudo apt-get install mssql-server-ha

Konfigurieren einer Verfügbarkeitsgruppe

Führen Sie die folgenden Schritte aus, um eine SQL Server-Always On-Verfügbarkeitsgruppe für Ihre virtuellen Computer zu konfigurieren. Weitere Informationen finden Sie unter Konfigurieren von SQL Server-Always On-Verfügbarkeitsgruppen für Hochverfügbarkeit unter Linux.

Aktivieren von Verfügbarkeitsgruppen und Neustarten von SQL Server

Aktivieren Sie Verfügbarkeitsgruppen auf jedem Knoten, der eine SQL Server-Instanz hostet. Starten Sie den mssql-server-Dienst dann neu. Führen Sie die folgenden Befehle auf jedem Knoten aus:

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

Erstellen eines Zertifikats

Microsoft unterstützt keine Active Directory-Authentifizierung beim Endpunkt der Verfügbarkeitsgruppe. Daher müssen wir für die Verschlüsselung des Endpunkts der Verfügbarkeitsgruppe ein Zertifikat verwenden.

  1. Stellen Sie über SQL Server Management Studio (SSMS) oder sqlcmd eine Verbindung mit allen Knoten her. Führen Sie die folgenden Befehle aus, um eine AlwaysOn_health-Sitzung zu aktivieren und einen Hauptschlüssel zu erstellen:

    Von Bedeutung

    Falls Sie eine Remoteverbindung mit Ihrer SQL Server-Instanz herstellen, muss der Port 1433 in der Firewall geöffnet sein. Außerdem müssen in Ihrer NSG für jeden virtuellen Computer eingehende Verbindungen am Port 1433 zugelassen werden. Weitere Informationen zum Erstellen einer Eingangssicherheitsregel finden Sie unter Erstellen einer Sicherheitsregel.

    • Ersetzen Sie <MasterKeyPassword> durch Ihr eigenes Kennwort.
    ALTER EVENT SESSION AlwaysOn_health ON SERVER
WITH (STARTUP_STATE = ON);
GO

CREATE MASTER KEY ENCRYPTION BY PASSWORD = '<MasterKeyPassword>';
GO

  2. Stellen Sie über SSMS oder sqlcmd eine Verbindung mit dem primären Replikat her. Die folgenden Befehle erstellen auf Ihrem primären SQL Server-Replikat ein Zertifikat unter /var/opt/mssql/data/dbm_certificate.cer und einen privaten Schlüssel unter var/opt/mssql/data/dbm_certificate.pvk:

    • Ersetzen Sie <PrivateKeyPassword> durch Ihr eigenes Kennwort.
    CREATE CERTIFICATE dbm_certificate
    WITH SUBJECT = 'dbm';
GO

BACKUP CERTIFICATE dbm_certificate TO FILE = '/var/opt/mssql/data/dbm_certificate.cer'
WITH PRIVATE KEY (
    FILE = '/var/opt/mssql/data/dbm_certificate.pvk',
    ENCRYPTION BY PASSWORD = '<PrivateKeyPassword>'
);
GO

Beenden Sie die sqlcmd-Sitzung mithilfe des Befehls exit, und kehren Sie zu Ihrer SSH-Sitzung zurück.

Kopieren des Zertifikats auf die sekundären Replikate und Erstellen der Zertifikate auf dem Server

  1. Kopieren Sie die beiden erstellten Dateien auf allen Servern, von denen Verfügbarkeitsreplikate gehostet werden, an den gleichen Speicherort.

    Führen Sie auf dem primären Server den folgenden scp-Befehl aus, um das Zertifikat auf die Zielserver zu kopieren:

    • Ersetzen Sie <username> und sles2 durch den Benutzernamen bzw. den Namen der verwendeten Ziel-VM.
    • Führen Sie diesen Befehl für alle sekundären Replikate aus.

    Hinweis

    Sie müssen nicht sudo -i ausführen, um die Stammumgebung zu erhalten. Sie können den Befehl sudo stattdessen vor jedem Befehl ausführen.

    # The below command allows you to run commands in the root environment
sudo -i

    scp /var/opt/mssql/data/dbm_certificate.* <username>@sles2:/home/<username>

  2. Führen Sie auf dem Zielserver den folgenden Befehl aus:

    • Ersetze <username> durch deinen Benutzernamen.
    • Der Befehl mv verschiebt die Dateien oder das Verzeichnis an einen anderen Ort.
    • Der Befehl chown dient zum Ändern des Besitzers und der Gruppe von Dateien, Verzeichnissen oder Links.
    • Führen Sie diese Befehle für alle sekundären Replikate aus.
    sudo -i
mv /home/<username>/dbm_certificate.* /var/opt/mssql/data/
cd /var/opt/mssql/data
chown mssql:mssql dbm_certificate.*

  3. Mit dem folgenden Transact-SQL-Skript wird ein Zertifikat auf der Grundlage der Sicherung erstellt, die Sie auf dem primären SQL Server-Replikat erstellt haben. Aktualisieren Sie das Skript durch sichere Kennwörter. Das Entschlüsselungskennwort ist das gleiche Kennwort, das Sie im vorherigen Schritt zum Erstellen der PVK-Datei verwendet haben. Um das Zertifikat zu erstellen, führen Sie das folgende Skript unter Verwendung von sqlcmd oder SSMS auf allen sekundären Servern aus:

    CREATE CERTIFICATE dbm_certificate
FROM FILE = '/var/opt/mssql/data/dbm_certificate.cer'
WITH PRIVATE KEY (
    FILE = '/var/opt/mssql/data/dbm_certificate.pvk',
    DECRYPTION BY PASSWORD = '<PrivateKeyPassword>'
);
GO

Erstellen des Datenbankspiegelungs-Endpunkte auf allen Replikaten

Führen Sie das folgende Skript unter Verwendung von sqlcmd oder SSMS in allen SQL Server-Instanzen aus:

CREATE ENDPOINT [Hadr_endpoint]
AS TCP (LISTENER_PORT = 5022)
FOR DATABASE_MIRRORING (
    ROLE = ALL,
    AUTHENTICATION = CERTIFICATE dbm_certificate,
    ENCRYPTION = REQUIRED ALGORITHM AES
);
GO

ALTER ENDPOINT [Hadr_endpoint] STATE = STARTED;
GO

Erstellen der Verfügbarkeitsgruppe

Stellen Sie unter Verwendung von sqlcmd oder SSMS eine Verbindung mit der SQL Server-Instanz her, die das primäre Replikat hostet. Führen Sie den folgenden Befehl aus, um die Verfügbarkeitsgruppe zu erstellen:

  • Ersetzen Sie ag1 durch den Namen der gewünschten Verfügbarkeitsgruppe.
  • Ersetzen Sie die Werte ubuntu1, ubuntu2 und ubuntu3 durch die Namen der SQL Server-Instanzen, von denen die Replikate gehostet werden.
CREATE AVAILABILITY
GROUP [ag1]
WITH (
        DB_FAILOVER = ON,
        CLUSTER_TYPE = EXTERNAL
        )
FOR REPLICA
    ON N'ubuntu1'
WITH (
        ENDPOINT_URL = N'tcp://ubuntu1:5022',
        AVAILABILITY_MODE = SYNCHRONOUS_COMMIT,
        FAILOVER_MODE = EXTERNAL,
        SEEDING_MODE = AUTOMATIC
        ),
    N'ubuntu2'
WITH (
        ENDPOINT_URL = N'tcp://ubuntu2:5022',
        AVAILABILITY_MODE = SYNCHRONOUS_COMMIT,
        FAILOVER_MODE = EXTERNAL,
        SEEDING_MODE = AUTOMATIC
        ),
    N'ubuntu3'
WITH (
        ENDPOINT_URL = N'tcp://ubuntu3:5022',
        AVAILABILITY_MODE = SYNCHRONOUS_COMMIT,
        FAILOVER_MODE = EXTERNAL,
        SEEDING_MODE = AUTOMATIC
        );
GO

ALTER AVAILABILITY GROUP [ag1]
GRANT CREATE ANY DATABASE;
GO

Erstellen einer SQL Server-Anmeldung für Pacemaker

Erstellen Sie in allen SQL Server-Instanzen eine SQL Server-Anmeldung für Pacemaker. Mit dem folgenden Transact-SQL-Skript wird eine Anmeldung erstellt.

  • Ersetzen Sie <password> durch Ihr eigenes komplexes Kennwort.
USE [master];
GO

CREATE LOGIN [pacemakerLogin]
    WITH PASSWORD = N'<password>';
GO

ALTER SERVER ROLE [sysadmin]
    ADD MEMBER [pacemakerLogin];
GO

Speichern Sie in allen SQL Server-Instanzen die für die SQL Server-Anmeldung verwendeten Anmeldeinformationen.

  1. Erstellen Sie die Datei:

    sudo vi /var/opt/mssql/secrets/passwd

  2. Fügen Sie der Datei die folgenden beiden Zeilen hinzu:

    pacemakerLogin
<password>

    Drücken Sie zum Verlassen des vi-Editors ESC, und geben Sie anschließend den Befehl :wq ein, um die Datei zu schreiben und den Editor zu beenden.

  3. Sorgen Sie dafür, dass die Datei nur mit root-Berechtigungen lesbar ist:

    sudo chown root:root /var/opt/mssql/secrets/passwd
sudo chmod 400 /var/opt/mssql/secrets/passwd

Verknüpfen sekundärer Replikate mit der Verfügbarkeitsgruppe

  1. Führen Sie auf Ihren sekundären Replikaten die folgenden Befehle aus, um die Replikate mit der Verfügbarkeitsgruppe zu verknüpfen:

    ALTER AVAILABILITY GROUP [ag1] JOIN WITH (CLUSTER_TYPE = EXTERNAL);
GO

ALTER AVAILABILITY GROUP [ag1] GRANT CREATE ANY DATABASE;
GO

  2. Führen Sie auf dem primären Replikat sowie auf jedem sekundären Replikat das folgende Transact-SQL-Skript aus:

    GRANT ALTER, CONTROL, VIEW DEFINITION
    ON AVAILABILITY GROUP::ag1 TO pacemakerLogin;
GO

GRANT VIEW SERVER STATE TO pacemakerLogin;
GO

  3. Nachdem die sekundären Replikate verknüpft wurden, können Sie sie im SSMS-Objekt-Explorer anzeigen, indem Sie den Knoten Hochverfügbarkeit mit Always On erweitern:

    Im Screenshot werden die primären und sekundären Verfügbarkeitsreplikate gezeigt.

Hinzufügen einer Datenbank zu einer Verfügbarkeitsgruppe

Dieser Abschnitt folgt dem Artikel zum Hinzufügen einer Datenbank zu einer Verfügbarkeitsgruppe.

In diesem Schritt werden die folgenden Transact-SQL-Befehle verwendet. Führen Sie diese Befehle auf dem primären Replikat aus:

CREATE DATABASE [db1]; -- creates a database named db1
GO

ALTER DATABASE [db1] SET RECOVERY FULL; -- set the database in full recovery mode
GO

BACKUP DATABASE [db1] -- backs up the database to disk
    TO DISK = N'/var/opt/mssql/data/db1.bak';
GO

ALTER AVAILABILITY GROUP [ag1] ADD DATABASE [db1]; -- adds the database db1 to the AG
GO

Sicherstellen, dass die Datenbank auf den sekundären Servern erstellt wird

Führen Sie auf jedem sekundären SQL Server-Replikat die folgende Abfrage aus, um zu ermitteln, ob die Datenbank „db1“ erstellt wurde und sich im Zustand „SYNCHRONIZED“ (Synchronisiert) befindet:

SELECT * FROM sys.databases
WHERE name = 'db1';
GO

SELECT DB_NAME(database_id) AS 'database',
       synchronization_state_desc
FROM sys.dm_hadr_database_replica_states;
GO

Wenn synchronization_state_desc für db1 den Zustand „SYNCHRONIZED“ (SYNCHRONISIERT) angibt, wurden die Replikate synchronisiert. Für die sekundären Replikate wird db1 im primären Replikat angezeigt.

Im Pacemaker-Cluster Verfügbarkeitsgruppenressourcen erstellen

Führen Sie die folgenden Befehle aus, um die Verfügbarkeitsgruppenressource in Pacemaker zu erstellen:

sudo crm

configure

primitive ag1_cluster \
ocf:mssql:ag \
params ag_name="ag1" \
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 on-fail=demote interval=11s role="Master" \
op monitor timeout=60s interval=12s role="Slave" \
op notify timeout=60s

ms ms-ag1 ag1_cluster \
meta master-max="1" master-node-max="1" clone-max="3" \
clone-node-max="1" notify="true"

commit

Mit diesem obigen Befehl wird die ag1_cluster Ressource erstellt, d. h. die Verfügbarkeitsgruppenressource. Anschließend erstellt sie die Ressource "ms-ag1" (primäre/sekundäre Ressource in Pacemaker und fügt dann die AG-Ressource hinzu. Dadurch wird sichergestellt, dass die AG-Ressource auf allen drei Knoten im Cluster ausgeführt wird, aber nur einer dieser Knoten primär ist.)

Zeigen Sie die AG-Gruppenressource an und überprüfen Sie den Status des Clusters:

sudo crm resource status ms-ag1
sudo crm status

Die Ausgabe sieht in etwa wie im folgenden Beispiel aus:

resource ms-ag1 is running on: ubuntu1 Master
resource ms-ag1 is running on: ubuntu3
resource ms-ag1 is running on: ubuntu2

Die Ausgabe sieht in etwa wie im folgenden Beispiel aus. Informationen zum Hinzufügen von Kollokations- und Beförderungseinschränkungen finden Sie im Tutorial: Konfigurieren eines Verfügbarkeitsgruppenlisteners auf Linux-VMs.

Cluster Summary:
  * Stack: corosync
  * Current DC: ubuntu1 (version 2.0.3-4b1f869f0f) - partition with quorum
  * Last updated: Wed Nov 29 07:01:32 2023
  * Last change:  Sun Nov 26 17:00:26 2023 by root via cibadmin on ubuntu1
  * 3 nodes configured
  * 4 resource instances configured

Node List:
  * Online: [ ubuntu1 ubuntu2 ubuntu3 ]

Full List of Resources:
  * Clone Set: ms-ag1 [ag1_cluster] (promotable):
  * Masters: [ ubuntu1 ]
  * Slaves : [ ubuntu2 ubuntu3 ]
  * fence-vm     (stonith:fence_azure_arm):                        Started ubuntu1

Führen Sie den folgenden Befehl aus, um eine Gruppenressource zu erstellen, sodass die Kolokations- und Priorisierungseinschränkungen, die auf den Listener und den Load Balancer angewendet werden, nicht einzeln angewendet werden müssen.

sudo crm configure group virtualip-group azure-load-balancer virtualip

Die Ausgabe von crm status wird ähnlich wie das folgende Beispiel aussehen:

Cluster Summary:
  * Stack: corosync
  * Current DC: ubuntu1 (version 2.0.3-4b1f869f0f) - partition with quorum
  * Last updated: Wed Nov 29 07:01:32 2023
  * Last change:  Sun Nov 26 17:00:26 2023 by root via cibadmin on ubuntu1
  * 3 nodes configured
  * 6 resource instances configured

Node List:
  * Online: [ ubuntu1 ubuntu2 ubuntu3 ]

Full List of Resources:
  * Clone Set: ms-ag1 [ag1_cluster] (promotable):
    * Masters: [ ubuntu1 ]
    * Slaves : [ ubuntu2 ubuntu3 ]
  * Resource Group:  virtual ip-group:
    * azure-load-balancer  (ocf  :: heartbeat:azure-lb):           Started ubuntu1
    * virtualip     (ocf :: heartbeat: IPaddr2):                   Started ubuntu1
  * fence-vm     (stonith:fence_azure_arm):                        Started ubuntu1

Nächster Schritt

Tutorial: Konfigurieren von Verfügbarkeitsgruppenlistenern auf virtuellen Linux-Computern

  • Last updated on