Tutorial: Konfigurieren von Verfügbarkeitsgruppen für SQL Server auf Ubuntu-VMs in Azure

In diesem Tutorial lernen Sie Folgendes:

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

Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

Voraussetzungen

• Verwenden Sie die Bash-Umgebung in Azure Cloud Shell. Weitere Informationen finden Sie unter Schnellstart für Bash in Azure Cloud Shell.

  

• Wenn Sie CLI-Referenzbefehle lieber lokal ausführen, installieren Sie die Azure CLI. Wenn Sie Windows oder macOS ausführen, sollten Sie die Azure CLI in einem Docker-Container ausführen. Weitere Informationen finden Sie unter Ausführen der Azure CLI in einem Docker-Container.

  • Wenn Sie eine lokale Installation verwenden, melden Sie sich mithilfe des Befehls az login bei der Azure CLI an. Führen Sie die in Ihrem Terminal angezeigten Schritte aus, um den Authentifizierungsprozess abzuschließen. Informationen zu anderen Anmeldeoptionen finden Sie unter Anmelden mit der Azure CLI.

  • Installieren Sie die Azure CLI-Erweiterung beim ersten Einsatz, wenn Sie dazu aufgefordert werden. Weitere Informationen zu Erweiterungen finden Sie unter Verwenden von Erweiterungen mit der Azure CLI.

  • Führen Sie az version aus, um die installierte Version und die abhängigen Bibliotheken zu ermitteln. Führen Sie az upgrade aus, um das Upgrade auf die aktuelle Version durchzuführen.

• Für diesen Artikel ist mindestens Version 2.0.30 der Azure CLI erforderlich. Bei Verwendung von Azure Cloud Shell ist die aktuelle 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 vorab zugewiesenen 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 virtueller Ubuntu-Computer innerhalb der Verfügbarkeitsgruppe

1. Rufen Sie eine Liste der Images virtueller Computer ab, die ein Ubuntu-basiertes Betriebssystem in Azure anbieten.

    az vm image list --all --offer "sql2022-ubuntupro2004"
   

   Die folgenden Ergebnisse sollten angezeigt werden, wenn Sie nach den BYOS-Images suchen:

   [
     {
       "architecture": "x64",
       "offer": "sql2022-ubuntupro2004",
       "publisher": "MicrosoftSQLServer",
       "sku": "enterprise_upro",
       "urn": "MicrosoftSQLServer:sql2022-ubuntupro2004:enterprise_upro:16.0.221108",
       "version": "16.0.221108"
     },
     {
       "architecture": "x64",
       "offer": "sql2022-ubuntupro2004",
       "publisher": "MicrosoftSQLServer",
       "sku": "enterprise_upro",
       "urn": "MicrosoftSQLServer:sql2022-ubuntupro2004:enterprise_upro:16.0.230207",
       "version": "16.0.230207"
     },
     {
       "architecture": "x64",
       "offer": "sql2022-ubuntupro2004",
       "publisher": "MicrosoftSQLServer",
       "sku": "enterprise_upro",
       "urn": "MicrosoftSQLServer:sql2022-ubuntupro2004:enterprise_upro:16.0.230808",
       "version": "16.0.230808"
     },
     {
       "architecture": "x64",
       "offer": "sql2022-ubuntupro2004",
       "publisher": "MicrosoftSQLServer",
       "sku": "sqldev_upro",
       "urn": "MicrosoftSQLServer:sql2022-ubuntupro2004:sqldev_upro:16.0.221108",
       "version": "16.0.221108"
     },
     {
       "architecture": "x64",
       "offer": "sql2022-ubuntupro2004",
       "publisher": "MicrosoftSQLServer",
       "sku": "sqldev_upro",
       "urn": "MicrosoftSQLServer:sql2022-ubuntupro2004:sqldev_upro:16.0.230207",
       "version": "16.0.230207"
     },
     {
       "architecture": "x64",
       "offer": "sql2022-ubuntupro2004",
       "publisher": "MicrosoftSQLServer",
       "sku": "sqldev_upro",
       "urn": "MicrosoftSQLServer:sql2022-ubuntupro2004:sqldev_upro:16.0.230808",
       "version": "16.0.230808"
     },
     {
       "architecture": "x64",
       "offer": "sql2022-ubuntupro2004",
       "publisher": "MicrosoftSQLServer",
       "sku": "standard_upro",
       "urn": "MicrosoftSQLServer:sql2022-ubuntupro2004:standard_upro:16.0.221108",
       "version": "16.0.221108"
     },
     {
       "architecture": "x64",
       "offer": "sql2022-ubuntupro2004",
       "publisher": "MicrosoftSQLServer",
       "sku": "standard_upro",
       "urn": "MicrosoftSQLServer:sql2022-ubuntupro2004:standard_upro:16.0.230207",
       "version": "16.0.230207"
     },
     {
       "architecture": "x64",
       "offer": "sql2022-ubuntupro2004",
       "publisher": "MicrosoftSQLServer",
       "sku": "standard_upro",
       "urn": "MicrosoftSQLServer:sql2022-ubuntupro2004:standard_upro:16.0.230808",
       "version": "16.0.230808"
     },
     {
       "architecture": "x64",
       "offer": "sql2022-ubuntupro2004",
       "publisher": "MicrosoftSQLServer",
       "sku": "web_upro",
       "urn": "MicrosoftSQLServer:sql2022-ubuntupro2004:web_upro:16.0.221108",
       "version": "16.0.221108"
     },
     {
       "architecture": "x64",
       "offer": "sql2022-ubuntupro2004",
       "publisher": "MicrosoftSQLServer",
       "sku": "web_upro",
       "urn": "MicrosoftSQLServer:sql2022-ubuntupro2004:web_upro:16.0.230207",
       "version": "16.0.230207"
     },
     {
       "architecture": "x64",
       "offer": "sql2022-ubuntupro2004",
       "publisher": "MicrosoftSQLServer",
       "sku": "web_upro",
       "urn": "MicrosoftSQLServer:sql2022-ubuntupro2004:web_upro:16.0.230808",
       "version": "16.0.230808"
     }
   ]
   

   In diesem Tutorial wird Ubuntu 20.04 verwendet.

   Wichtig

   Computernamen müssen weniger als 15 Zeichen lang sein, damit eine Verfügbarkeitsgruppe eingerichtet werden kann. 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 auch das Konto root 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 von der ersten VM (ubuntu1) aus eine Verbindung mit dem zweiten und dritten Knoten her. Auch hier kann das Konto <username> das gleiche 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.

Aktivieren der Hochverfügbarkeit

Verwenden Sie ssh, um eine Verbindung mit den 3 VMs herzustellen, und führen Sie nach der Verbindung die folgenden Befehle aus, um Hochverfü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 Speicherort /etc/corosync/authkey 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 nach /etc/corosync.

sudo mv authkey /etc/corosync/authkey

Fahren Sie fort, und erstellen Sie Ihren Cluster mit den folgenden Befehlen:

cd /etc/corosync/
sudo vi corosync.conf

Bearbeiten Sie die Corosync-Dateiso, das Inhalte wie folgt dargestellt werden:

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 etwa folgendermaßen 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 die Umgrenzung auf dem Cluster. Bei einer Umgrenzung handelt es sich um die Isolierung eines fehlgeschlagenen Knotens in einem Cluster. Dabei wird der fehlgeschlagene Knoten neu gestartet, sodass er heruntergefahren, zurückgesetzt und wieder gestartet werden kann und wieder an dem Cluster teilnehmen kann.

Führen Sie zum Konfigurieren der Umgrenzung die folgenden Aktionen aus:

1. Registrieren Sie eine Anwendung in Microsoft Entra ID, und erstellen Sie einen neuen Dienstprinzipal.
2. Erstellen Sie eine benutzerdefinierte Rolle aus der JSON-Datei in powershell/CLI.
3. Weisen Sie die Rolle und Anwendung den virtuellen Computern im Cluster zu.
4. Legen Sie die Eigenschaften des Fencing-Agents fest.

Registrieren Sie eine Anwendung in Microsoft Entra ID, und erstellen Sie einen neuen Dienstprinzipal.

1. Wechseln Sie im Portal zu Microsoft Entra ID, 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 Nur Konten 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 link im Menü Zertifikate  Geheimnisse 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, er wird als das folgende Kennwort verwendet, und die geheime ID 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 Sie eine benutzerdefinierte 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 Computern im Cluster zu.

1. Wählen Sie für jeden virtuellen Computer im Cluster im Seitmenü die Zugriffssteuerung (IAM) aus.
2. Wählen Sie Hinzufügen einer Rollenzuweisung 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 Ressource des Fencing-Agents mit früheren 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

Legen Sie die Eigenschaften des Fencing-Agents fest.

Führen Sie die folgenden Befehle aus, um den Fencing-Agent 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 etwa folgendermaßen 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. Zur Erinnerung: Für die folgenden Editionen sind als kostenlose Lizenzen verfügbar: 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. Mit den folgenden Schritten installieren Sie die SQL Server-Befehlszeilentools: sqlcmd und bcp.

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

1. Wechseln Sie in den Superuser-Modus.

   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 mit dem folgenden Befehl PATH in der -~/.bash_profileDatei:

   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:

   Wichtig

   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:

   • Ersetzen Sie <username> durch Ihren 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:

   

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.

Erstellen von Verfügbarkeitsgruppenressourcen im Pacemaker-Cluster

Führen Sie die folgenden Befehle aus, um die Ressource der Verfügbarkeitsgruppe 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 Ressource der Verfügbarkeitsgruppe. Anschließend wird die Ressource „ms-ag1“ erstellt (primäre/sekundäre Ressource in Pacemaker erstellt, dann wird die Ressource der Verfügbarkeitsgruppe hinzugefügt. Dadurch wird sichergestellt, dass die Ressource der Verfügbarkeitsgruppe auf allen drei Knoten im Cluster ausgeführt wird, aber nur einer dieser Knoten primär ist.)

So zeigen Sie die Ressource der Verfügbarkeitsgruppe an und überprüfen den Status des Clusters:

sudo crm resource status ms-ag1
sudo crm status

Die Ausgabe sieht etwa folgendermaßen 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 Colocation- und Heraufstufungseinschränkungen finden Sie im Tutorial: Konfigurieren eines Verfügbarkeitsgruppenlisteners auf virtuellen Linux-Computern.

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, damit die auf den Listener und den Lastenausgleich angewendeten Einschränkungen für die Colocation und Heraufstufung nicht einzeln angewendet werden müssen.

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

Die Ausgabe von crm status sieht ähnlich dem 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
  * 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