TOC

Verwendung von ProxySQL als Load Balancer für MySQL unter Ubuntu 16.04

Einführung

ProxySQL ist ein Open-Source-MySQL-Proxyserver, dh er dient als Vermittler zwischen einem MySQL-Server und den Anwendungen, die auf seine Datenbanken zugreifen. ProxySQL kann die Leistung verbessern, indem der Datenverkehr auf mehrere Datenbankserver verteilt wird, und die Verfügbarkeit verbessern, indem bei Ausfall eines oder mehrerer Datenbankserver automatisch ein Failover in einen Standby-Modus durchgeführt wird.

In diesem Handbuch richten Sie ProxySQL alsload balancer für mehrere MySQL-Server mit automatischem Failover ein. In diesem Lernprogramm wird beispielsweise ein mehrfach replizierter Primärcluster mit drei MySQL-Servern verwendet. Sie können jedoch einen ähnlichen Ansatz auch für andere Clusterkonfigurationen verwenden.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

[[Schritt-1 -—- Installation von ProxySQL]] == Schritt 1 - Installation von ProxySQL

Die Entwickler von ProxySQL bieten offizielle Ubuntu-Pakete für alle ProxySQL-Versionen auftheir GitHub releases page an. Daher laden wir die neueste Paketversion von dort herunter und installieren sie.

Das neueste Paket finden Sie auf denrelease list. Die Namenskonvention lautetproxysql_version-distribution.deb, wobeiversion eine Zeichenfolge wie1.4.4 für Version 1.4.4 unddistribution eine Zeichenfolge wieubuntu16_amd64 für 64-Bit ist Ubuntu 16.04.

Laden Sie das neueste offizielle Paket, das zum Zeitpunkt des Schreibens 1.4.4 ist, in das Verzeichnis/tmpherunter. 

cd /tmp
curl -OL https://github.com/sysown/proxysql/releases/download/v1.4.4/proxysql_1.4.4-ubuntu16_amd64.deb

Installieren Sie das Paket mitdpkg, das fürmanage .deb software packages verwendet wird. Das-i-Flag zeigt an, dass wir von der angegebenen Datei installieren möchten. 

sudo dpkg -i proxysql_*

Ab diesem Zeitpunkt benötigen Sie die Datei.debnicht mehr, sodass Sie sie entfernen können. 

rm proxysql_*

Als Nächstes benötigen wir eine MySQL-Client-Anwendung, um eine Verbindung zur ProxySQL-Instanz herzustellen. Dies liegt daran, dass ProxySQL intern eine MySQL-kompatible Schnittstelle für Verwaltungsaufgaben verwendet. Wir verwenden das Befehlszeilentoolmysql, das Teil des Paketsmysql-clientist, das in den Ubuntu-Repositorys verfügbar ist.

Aktualisieren Sie Ihr Paket-Repository, um sicherzustellen, dass Sie die neueste vorgebündelte Version erhalten, und installieren Sie dann das Paketmysql-client. 

sudo apt-get update
sudo apt-get install mysql-client

Sie haben jetzt alle Voraussetzungen, um ProxySQL auszuführen, aber der Dienst wird nach der Installation nicht automatisch gestartet. Starten Sie ihn daher jetzt manuell. 

sudo systemctl start proxysql

ProxySQL sollte nun mit der Standardkonfiguration ausgeführt werden. Sie können dies mitsystemctl überprüfen. 

systemctl status proxysql

Die Ausgabe sieht ungefähr so ​​aus: 

Output● proxysql.service - LSB: High Performance Advanced Proxy for MySQL
   Loaded: loaded (/etc/init.d/proxysql; bad; vendor preset: enabled)
   Active: active (running) since Thu 2017-12-21 19:19:20 UTC; 5s ago
     Docs: man:systemd-sysv-generator(8)
  Process: 12350 ExecStart=/etc/init.d/proxysql start (code=exited, status=0/SUCCESS)
    Tasks: 23
   Memory: 30.9M
      CPU: 86ms
   CGroup: /system.slice/proxysql.service
           ├─12355 proxysql -c /etc/proxysql.cnf -D /var/lib/proxysql
           └─12356 proxysql -c /etc/proxysql.cnf -D /var/lib/proxysql

Die Zeileactive (running)bedeutet, dass ProxySQL installiert ist und ausgeführt wird.

Als Nächstes erhöhen wir die Sicherheit, indem wir das Kennwort festlegen, das für den Zugriff auf die Verwaltungsoberfläche von ProxySQL verwendet wird.

[[Schritt-2 - Festlegen des Proxy-SQL-Administratorkennworts]] == Schritt 2 - Festlegen des ProxySQL-Administratorkennworts

Wenn Sie zum ersten Mal eine neue ProxySQL-Installation starten, wird eine vom Paket bereitgestellte Konfigurationsdatei verwendet, um die Standardwerte für alle Konfigurationsvariablen zu initialisieren. Nach dieser Initialisierung speichert ProxySQL seine Konfiguration in einer Datenbank, die Sie über die Befehlszeile verwalten und ändern können.

Um das Administratorkennwort in ProxySQL festzulegen, stellen wir eine Verbindung zu dieser Konfigurationsdatenbank her und aktualisieren die entsprechenden Variablen.

Greifen Sie zunächst auf die Administrationsoberfläche zu. Sie werden aufgefordert, ein Kennwort einzugeben, das bei einer Standardinstallationadmin lautet. 

mysql -u admin -p -h 127.0.0.1 -P 6032 --prompt='ProxySQLAdmin> '

  • -u gibt den Benutzer an, als den wir eine Verbindung herstellen möchten. Hier istadmin der Standardbenutzer für Verwaltungsaufgaben wie das Ändern von Konfigurationseinstellungen.

  • -h 127.0.0.1 weistmysql an, eine Verbindung zur lokalen ProxySQL-Instanz herzustellen. Wir müssen dies explizit definieren, da ProxySQL die Socket-Datei, diemysql standardmäßig annimmt, nicht abhört.

  • -P gibt den Port an, zu dem eine Verbindung hergestellt werden soll. Die Administrationsoberfläche von ProxySQL überwacht6032.

  • --prompt ist ein optionales Flag, das die Standardaufforderung ändert, die normalerweisemysql> ist. Hier ändern wir es inProxySQLAdmin>, um zu verdeutlichen, dass wir mit der ProxySQL-Verwaltungsoberfläche verbunden sind. Dies ist hilfreich, um später Verwirrung zu vermeiden, wenn wir uns auch mit den MySQL-Schnittstellen auf den replizierten Datenbankservern verbinden.

Sobald Sie eine Verbindung hergestellt haben, wird die Eingabeaufforderung vonProxySQLAdmin>angezeigt: 

ProxySQL administration console promptWelcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.5.30 (ProxySQL Admin Module)

Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

ProxySQLAdmin>

Ändern Sie das Kennwort des Administratorkontos, indem Sie die Konfigurationsvariableadmin-admin_credentialsin der Datenbankglobal_variablesaktualisieren (UPDATE). Denken Sie daran,password im folgenden Befehl in ein sicheres Passwort Ihrer Wahl zu ändern. 

UPDATE global_variables SET variable_value='admin:password' WHERE variable_name='admin-admin_credentials';
OutputQuery OK, 1 row affected (0.00 sec)

Diese Änderung wird aufgrund der Funktionsweise des ProxySQL-Konfigurationssystems nicht sofort wirksam. Es besteht aus drei separaten Ebenen:

  • memory, das geändert wird, wenn Änderungen über die Befehlszeilenschnittstelle vorgenommen werden.

  • runtime, das von ProxySQL als effektive Konfiguration verwendet wird.

  • disk, mit dem eine Konfiguration über Neustarts hinweg beibehalten wird.

Im Moment ist die von Ihnen vorgenommene Änderung inmemory. Um die Änderung in Kraft zu setzen, müssen Sie die Einstellungen vonmemoryin den Bereich vonruntimekopieren und dann indisk speichern, damit sie bestehen bleiben. 

LOAD ADMIN VARIABLES TO RUNTIME;
SAVE ADMIN VARIABLES TO DISK;

DieseADMIN-Befehle verarbeiten nur Variablen, die sich auf die administrative Befehlszeilenschnittstelle beziehen. ProxySQL stellt ähnliche Befehle wieMYSQL zur Verfügung, um andere Teile seiner Konfiguration zu verarbeiten. Wir werden diese später in diesem Lernprogramm verwenden.

Nachdem ProxySQL installiert ist und mit einem neuen Administratorkennwort ausgeführt wird, richten wir die drei MySQL-Knoten ein, damit ProxySQL sie überwachen kann. Lassen Sie die ProxySQL-Schnittstelle jedoch geöffnet, da wir sie später verwenden werden.

[[Schritt-3 - Konfigurieren der Überwachung in MySQL]] == Schritt 3 - Konfigurieren der Überwachung in MySQL

ProxySQL muss mit den MySQL-Knoten kommunizieren, um deren Zustand beurteilen zu können. Dazu muss es in der Lage sein, mit einem dedizierten Benutzer eine Verbindung zu jedem Server herzustellen.

Hier konfigurieren wir den erforderlichen Benutzer auf den MySQL-Knoten und installieren zusätzliche SQL-Funktionen, mit denen ProxySQL den Gruppenreplikationsstatus abfragen kann.

Da die MySQL-Gruppenreplikation bereits ausgeführt wird, müssen die folgenden Schritte nur füra single member of the group ausgeführt werden.

Melden Sie sich in einem zweiten Terminal bei einem Server mit einem der MySQL-Knoten an. 

ssh sammy@your_mysql_server_ip_1

Laden Sie die SQL-Datei mit einigen erforderlichen Funktionen herunter, damit die ProxySQL-Gruppenreplikationsunterstützung funktioniert. 

curl -OL https://gist.github.com/lefred/77ddbde301c72535381ae7af9f968322/raw/5e40b03333a3c148b78aa348fd2cd5b5dbb36e4d/addition_to_sys.sql

[.Hinweis]##

Note: Diese Datei wird von ProxySQL-Autoren bereitgestellt, jedoch ad-hoc: Es handelt sich umgist in einem persönlichen GitHub-Repository. Dies bedeutet, dass sie möglicherweise verschoben oder veraltet ist. In Zukunft kann es als versionierte Datei im offiziellen ProxySQL-Repository hinzugefügt werden.

Weitere Informationen zum Kontext und Inhalt dieser Datei finden Sie im Blogbeitrag des Autors zunative ProxySQL support for MySQL group replication.

Sie können den Inhalt der Datei mitless addition_to_sys.sql anzeigen.

Wenn Sie fertig sind, führen Sie die Befehle in der Datei aus. Sie werden zur Eingabe des MySQL-Administratorkennworts aufgefordert. 

mysql -u root -p < addition_to_sys.sql

Wenn der Befehl erfolgreich ausgeführt wird, wird keine Ausgabe erzeugt. In diesem Fall stellen nun alle MySQL-Knoten die erforderlichen Funktionen zur Verfügung, damit ProxySQL den Gruppenreplikationsstatus erkennt.

Als nächstes müssen wir einen dedizierten Benutzer erstellen, der von ProxySQL zur Überwachung des Zustands der Instanzen verwendet wird.

Öffnen Sie die interaktive MySQL-Eingabeaufforderung, in der Sie erneut zur Eingabe desroot-Kennworts aufgefordert werden. 

mysql -u root -p

Erstellen Sie dann den dedizierten Benutzer, den wir hiermonitor genannt haben. Stellen Sie sicher, dass Sie ein sicheres Kennwort verwenden. 

CREATE USER 'monitor'@'%' IDENTIFIED BY 'monitorpassword';

Gewähren Sie dem Benutzermonitordie Benutzerrechte zum Abfragen des Zustands des MySQL-Servers. 

GRANT SELECT on sys.* to 'monitor'@'%';

Wenden Sie abschließend die Änderungen an. 

FLUSH PRIVILEGES;

Aufgrund der Gruppenreplikation wird der Benutzer nach dem Hinzufügen zur Integritätsüberwachung zu einem MySQL-Knoten auf allen drei Knoten vollständig konfiguriert.

Als Nächstes müssen wir ProxySQL mit den Informationen für diesen Benutzer aktualisieren, damit er auf die MySQL-Knoten zugreifen kann.

[[Schritt-4 - Konfigurieren der Überwachung in ProxysQL]] == Schritt 4 - Konfigurieren der Überwachung in ProxySQL

Um ProxySQL für die Verwendung des neuen Benutzerkontos bei der Überwachung von Knoten zu konfigurieren, wirdUPDATEdie entsprechende Konfigurationsvariable sein. Dies ist sehr ähnlich der Art und Weise, wie wir das Administratorkennwort aus Schritt 2 festgelegt haben.

Aktualisieren Sie in der ProxySQL-Administrationsoberfläche die Variablemysql-monitor_usernameauf den Benutzernamen des neuen Kontos. 

UPDATE global_variables SET variable_value='monitor' WHERE variable_name='mysql-monitor_username';

Wie zuvor wird die Konfiguration nicht automatisch angewendet. Migrieren Sie sie daher inruntime und speichern Sie sie indisk. Beachten Sie diesmal, dass wirMYSQL anstelle vonADMIN verwenden, um diese Variablen zu aktualisieren, da wir MySQL-Konfigurationsvariablen ändern. 

LOAD MYSQL VARIABLES TO RUNTIME;
SAVE MYSQL VARIABLES TO DISK;

Das Überwachungskonto ist auf allen Seiten konfiguriert, und der nächste Schritt besteht darin, ProxySQL die Knoten selbst mitzuteilen.

[[Schritt 5 - Hinzufügen von MySQL-Knoten zum Proxy-SQL-Server-Pool]] == Schritt 5 - Hinzufügen von MySQL-Knoten zum ProxySQL-Server-Pool

Um ProxySQL auf unsere drei MySQL-Knoten aufmerksam zu machen, müssen wir ProxySQL mitteilen, wie sie auf diehost groupsverteilt werden sollen, die als Knotensätze bezeichnet werden. Jede Wirtsgruppe wird durch eine positive Zahl wie1 oder2 identifiziert. Hostgruppen können bei Verwendung des ProxySQL-Abfrageroutings verschiedene SQL-Abfragen an verschiedene Sätze von Hosts weiterleiten.

In statischen Replikationskonfigurationen können Hostgruppen beliebig festgelegt werden. Die Gruppenreplikationsunterstützung von ProxySQL unterteilt jedoch automatisch alle Knoten in einer Replikationsgruppe in vier logische Zustände:

  • writers sind MySQL-Knoten, die Abfragen akzeptieren können, die Daten ändern. ProxySQL stellt sicher, dass alle primären Knoten bis zur maximal definierten Anzahl in dieser Gruppe verwaltet werden.

  • backup writers, die auch MySQL-Knoten sind, die Abfragen akzeptieren können, die Daten ändern. Diese Knoten werden jedoch nicht als Schreiber bezeichnet. Primärknoten, die die festgelegte Anzahl von verwalteten Schreibern überschreiten, werden in dieser Gruppe aufbewahrt und zu Schreibern befördert, wenn einer der Schreibern ausfällt.

  • readers sind MySQL-Knoten, die keine Abfragen akzeptieren können, die Daten ändern, und als schreibgeschützte Knoten verwendet werden sollten. ProxySQL legt hier nur Slave-Knoten ab.

  • offline, dies gilt für Knoten, die sich aufgrund von Problemen wie mangelnder Konnektivität oder langsamem Datenverkehr schlecht verhalten.

Jeder dieser vier Zustände hat entsprechende Hostgruppen, aber die numerischen Gruppenkennungen werden nicht automatisch zugewiesen.

Wenn wir alles zusammenfassen, müssen wir ProxySQL mitteilen, welche Bezeichner es für jeden Status verwenden soll. Hier verwenden wir1 für dieoffline-Hostgruppe,2 für diewriter-Hostgruppe,3 für diereader-Hostgruppe und 4 für die Hostgruppebackup writer.

Um diese Bezeichner festzulegen, erstellen Sie eine neue Zeile mit diesen Variablen und Werten in der Konfigurationstabelle vonmysql_group_replication_hostgroups. 

INSERT INTO mysql_group_replication_hostgroups (writer_hostgroup, backup_writer_hostgroup, reader_hostgroup, offline_hostgroup, active, max_writers, writer_is_also_reader, max_transactions_behind) VALUES (2, 4, 3, 1, 1, 3, 1, 100);

Dies sind die zusätzlichen Variablen, die in dieser Zeile festgelegt sind, und die jeweiligen Funktionen:

  • active auf1 gesetzt, ermöglicht die Überwachung dieser Hostgruppen durch ProxySQL.

  • max_writers definiert, wie viele Knoten als Schreiber fungieren können. Wir haben hier3 verwendet, weil in einer Multi-Primär-Konfiguration alle Knoten gleich behandelt werden können. Daher haben wir hier3 (die Gesamtzahl der Knoten) verwendet.

  • writer_is_also_reader auf1 gesetzt weist ProxySQL an, Autoren auch als Leser zu behandeln.

  • max_transactions_behind legt die maximale Anzahl verzögerter Transaktionen fest, bevor ein Knoten alsoffline klassifiziert wird.

[.Hinweis]##

Note: Da in unserem Beispiel eine Multi-Primär-Topologie verwendet wird, in der alle Knoten in die Datenbank schreiben können, werden alle SQL-Abfragen auf die Hostgruppe vonwriterverteilt. In anderen Topologien kann die Aufteilung zwischenwriter (primären) Knoten undreader (sekundären) Knoten schreibgeschützte Abfragen an andere Knoten / Hostgruppen als Schreibabfragen weiterleiten. ProxySQL tut dies nicht automatisch, aber Sie könnenset up query routing using rules.

Nachdem ProxySQL nun weiß, wie Knoten auf Hostgruppen verteilt werden, können wir unsere MySQL-Server zum Pool hinzufügen. Dazu müssen wirINSERT die IP-Adresse und die anfängliche Hostgruppe jedes Servers in die Tabellemysql_servers aufnehmen, die die Liste der Server enthält, mit denen ProxySQL interagieren kann.

Fügen Sie jeden der drei MySQL-Server hinzu und achten Sie darauf, die Beispiel-IP-Adressen in den folgenden Befehlen zu ersetzen. 

INSERT INTO mysql_servers(hostgroup_id, hostname, port) VALUES (2, '203.0.113.1', 3306);
INSERT INTO mysql_servers(hostgroup_id, hostname, port) VALUES (2, '203.0.113.2', 3306);
INSERT INTO mysql_servers(hostgroup_id, hostname, port) VALUES (2, '203.0.113.3', 3306);

Hier setzt der Wert2 alle diese Knoten zunächst als Writer, und3306 legt den Standard-MySQL-Port fest.

Migrieren Sie diese Änderungen wie zuvor inruntime und speichern Sie sie indisk, um die Änderungen zu übernehmen. 

LOAD MYSQL SERVERS TO RUNTIME;
SAVE MYSQL SERVERS TO DISK;

ProxySQL sollte jetzt unsere Knoten wie angegeben auf die Hostgruppen verteilen. Überprüfen Sie dies, indem Sie eine AbfrageSELECTfür die Tabelleruntim330e_mysql_serversausführen, die den aktuellen Status der von ProxySQL verwendeten Server anzeigt. 

SELECT hostgroup_id, hostname, status FROM runtime_mysql_servers;
Output+--------------+-------------+--------+
| hostgroup_id | hostname    | status |
+--------------+-------------+--------+
| 2            | 203.0.113.1 | ONLINE |
| 2            | 203.0.113.2 | ONLINE |
| 2            | 203.0.113.3 | ONLINE |
| 3            | 203.0.113.1 | ONLINE |
| 3            | 203.0.113.2 | ONLINE |
| 3            | 203.0.113.3 | ONLINE |
+--------------+-------------+--------+
6 rows in set (0.01 sec)

In der Ergebnistabelle wird jeder Server zweimal aufgeführt: jeweils einmal für die Hostgruppen-IDs2 und3, was darauf hinweist, dass alle drei Knoten sowohl Schreiber als auch Leser sind. Alle Knoten sind mitONLINE markiert, was bedeutet, dass sie zur Verwendung bereit sind.

Bevor wir sie jedoch verwenden können, müssen wir Benutzeranmeldeinformationen konfigurieren, um auf die MySQL-Datenbanken auf jedem Knoten zuzugreifen.

[[Schritt 6 - Erstellen der MySQL-Benutzer]] == Schritt 6 - Erstellen der MySQL-Benutzer

ProxySQL fungiert als Load Balancer. Endbenutzer stellen eine Verbindung zu ProxySQL her, und ProxySQL leitet die Verbindung der Reihe nach an den ausgewählten MySQL-Knoten weiter. Um eine Verbindung zu einem einzelnen Knoten herzustellen, verwendet ProxySQL die Anmeldeinformationen, mit denen auf ihn zugegriffen wurde.

Um den Zugriff auf die Datenbanken auf den Replikationsknoten zu ermöglichen, müssen wir ein Benutzerkonto mit den gleichen Anmeldeinformationen wie ProxySQL erstellen und diesem Benutzer die erforderlichen Berechtigungen erteilen.

Wie in Schritt 3 dürfen die folgenden Schritte nur füra single member of the group ausgeführt werden. Sie können ein beliebiges Mitglied auswählen.

Erstellen Sie einen neuen Benutzer mit dem Namenplaygrounduser, der mit dem Kennwortplaygroundpassword gekennzeichnet ist. 

CREATE USER 'playgrounduser'@'%' IDENTIFIED BY 'playgroundpassword';

Geben Sie ihm die Berechtigung, vonthe original group replication tutorial vollständig auf die Testdatenbank vonplaygroundzuzugreifen. 

GRANT ALL PRIVILEGES on playground.* to 'playgrounduser'@'%';

Übernehmen Sie dann die Änderungen und schließen Sie die Eingabeaufforderung. 

FLUSH PRIVILEGES;
EXIT;

Sie können überprüfen, ob der Benutzer ordnungsgemäß erstellt wurde, indem Sie versuchen, die Datenbank mit den neu konfigurierten Anmeldeinformationen direkt auf dem Knoten zu öffnen.

Öffnen Sie die MySQL-Oberfläche erneut mit dem neuen Benutzer, und Sie werden zur Eingabe des Kennworts aufgefordert. 

mysql -u playgrounduser -p

Wenn Sie angemeldet sind, führen Sie eine Testabfrage in derplayground-Datenbank aus. 

SHOW TABLES FROM playground;
Output+----------------------+
| Tables_in_playground |
+----------------------+
| equipment            |
+----------------------+
1 row in set (0.00 sec)

Die sichtbare Liste der Tabellen in der Datenbank mit der Tabelleequipment, die im ursprünglichen Replikations-Lernprogramm erstellt wurde, bestätigt, dass der Benutzer auf den Knoten korrekt erstellt wurde.

Sie können jetzt die Verbindung zur MySQL-Oberfläche trennen, das Terminal mit der Verbindung zum Server jedoch geöffnet lassen. Wir werden es verwenden, um Tests im letzten Schritt durchzuführen. 

EXIT;

Jetzt müssen wir den entsprechenden Benutzer auf dem ProxySQL-Server erstellen.

[[Schritt-7 -—- Erstellen des Proxy-SQL-Benutzers]] == Schritt 7 - Erstellen des ProxySQL-Benutzers

Der letzte Konfigurationsschritt besteht darin, Verbindungen zu ProxySQL mit dem Benutzerplaygrounduserzuzulassen und diese Verbindungen an die Knoten weiterzuleiten.

Dazu müssen wir Konfigurationsvariablen in der Tabellemysql_usersfestlegen, die Informationen zu Benutzeranmeldeinformationen enthält. Fügen Sie in der ProxySQL-Schnittstelle den Benutzernamen, das Kennwort und die Standardhostgruppe zur Konfigurationsdatenbank hinzu (2 für die Hostgruppewriter). 

INSERT INTO mysql_users(username, password, default_hostgroup) VALUES ('playgrounduser', 'playgroundpassword', 2);

Migrieren Sie die Konfiguration inruntime und speichern Sie sie indisk, um die neue Konfiguration zu übernehmen. 

LOAD MYSQL USERS TO RUNTIME;
SAVE MYSQL USERS TO DISK;

Öffnen Sie ein anderes Terminalfenster und SSH für den ProxySQL-Server, um zu überprüfen, ob mit diesen Anmeldeinformationen eine Verbindung zu den Datenbankknoten hergestellt werden kann. Die Administrationsaufforderung wird später noch benötigt, schließen Sie sie also noch nicht. 

ssh sammy@your_proxysql_server_ip

ProxySQL überwacht Port6033 auf eingehende Clientverbindungen. Versuchen Sie daher, mitplaygrounduser und Port6033 eine Verbindung zur realen Datenbank (nicht zur Verwaltungsschnittstelle) herzustellen. Sie werden aufgefordert, das Kennwort einzugeben, das in unserem Beispielplaygroundpassword war. 

mysql -u playgrounduser -p -h 127.0.0.1 -P 6033 --prompt='ProxySQLClient> '

Hier setzen wir die Eingabeaufforderung aufProxySQLClient>, damit wir sie von der Eingabeaufforderung der Verwaltungsschnittstelle unterscheiden können. Wir werden beides verwenden, wenn wir die endgültige Konfiguration testen.

Die Eingabeaufforderung sollte sich öffnen, was bedeutet, dass die Anmeldeinformationen von ProxySQL selbst akzeptiert wurden. 

ProxySQL client promptWelcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 31
Server version: 5.5.30 (ProxySQL)

Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

ProxySQLClient>

Führen Sie eine einfache Anweisung aus, um zu überprüfen, ob ProxySQL eine Verbindung zu einem der Knoten herstellen wird. Dieser Befehl fragt die Datenbank nach dem Hostnamen des Servers ab, auf dem er ausgeführt wird, und gibt den Server-Hostnamen als einzige Ausgabe zurück. 

SELECT @@hostname;

Gemäß unserer Konfiguration sollte diese Abfrage von ProxySQL an einen unserer drei Knoten geleitet werden, die der Hostgruppewriterzugewiesen sind. Die Ausgabe sollte wie folgt aussehen, wobeimember1 der Hostname eines der MySQL-Knoten ist. 

Output+------------+
| @@hostname |
+------------+
| member1    |
+------------+
1 row in set (0.00 sec)

Damit ist die Konfiguration abgeschlossen, sodass ProxySQL Verbindungen zwischen den drei MySQL-Knoten ausgleichen kann.

Im letzten Schritt stellen wir sicher, dass ProxySQL Lese- und Schreibanweisungen für die Datenbank ausführen kann und Abfragen auch dann verarbeitet, wenn einige Knoten ausfallen.

[[Schritt 8 - Überprüfung der Proxy-SQL-Konfiguration]] == Schritt 8 - Überprüfung der ProxySQL-Konfiguration

Wir wissen, dass die Konnektivität zwischen ProxySQL und den MySQL-Knoten funktioniert. Die letzten Tests stellen daher sicher, dass die Datenbankberechtigungen sowohl Lese- als auch Schreibanweisungen von ProxySQL zulassen und dass diese Anweisungen ausgeführt werden, wenn einige der Knoten in ausgeführt werden Die Gruppe scheitert.

Führen Sie eineSELECT-Anweisung in der ProxySQL-Client-Eingabeaufforderung aus, um zu überprüfen, ob wir die Daten aus derplayground-Datenbank lesen können. 

SELECT * FROM playground.equipment;

Die Ausgabe sollte der folgenden ähneln und die drei Elemente enthalten, die im Lernprogramm zur Gruppenreplikation erstellt wurden. Dies bedeutet, dass wir erfolgreich Daten aus der MySQL-Datenbank über ProxySQL lesen. 

Output+----+--------+-------+--------+
| id | type   | quant | color  |
+----+--------+-------+--------+
|  3 | slide  |     2 | blue   |
| 10 | swing  |    10 | yellow |
| 17 | seesaw |     3 | green  |
+----+--------+-------+--------+
3 rows in set (0.00 sec)

Versuchen Sie als nächstes zu schreiben, indem Sie einige neue Daten in die Tabelle einfügen, die 5 rote Bohrer darstellen. 

INSERT INTO playground.equipment (type, quant, color) VALUES ("drill", 5, "red");

Führen Sie dann den vorherigen BefehlSELECT erneut aus, um zu überprüfen, ob die Daten eingefügt wurden. 

SELECT * FROM playground.equipment;

Die neue Drill-Zeile in der Ausgabe bedeutet, dass wir erfolgreich Daten über ProxySQL in die MySQL-Datenbank geschrieben haben. 

Output+----+--------+-------+--------+
| id | type   | quant | color  |
+----+--------+-------+--------+
|  3 | slide  |     2 | blue   |
| 10 | swing  |    10 | yellow |
| 17 | seesaw |     3 | green  |
| 24 | drill  |     5 | red    |
+----+--------+-------+--------+
4 rows in set (0.00 sec)

Wir wissen, dass ProxySQL die Datenbank jetzt voll nutzen kann, aber was passiert, wenn ein Server ausfällt?

Beenden Sie über die Befehlszeile eines der MySQL-Server den MySQL-Prozess, um einen Fehler zu simulieren. 

systemctl stop mysql

Versuchen Sie nach dem Stoppen der Datenbank erneut, Daten aus der Tabelleequipmentan der ProxySQL-Client-Eingabeaufforderung abzufragen. 

SELECT * FROM playground.equipment;

Die Ausgabe sollte sich nicht ändern. Sie sollten weiterhin die Ausrüstungsliste wie zuvor sehen. Dies bedeutet, dass ProxySQL festgestellt hat, dass einer der Knoten ausgefallen ist und auf einen anderen Knoten gewechselt ist, um die Anweisung auszuführen.

Wir können dies überprüfen, indem wir die Tabelleruntime_mysql_serversan der ProxySQL-Verwaltungsaufforderung abfragen, wie in Schritt 5. 

SELECT hostgroup_id, hostname, status FROM runtime_mysql_servers;

Die Ausgabe sieht folgendermaßen aus: 

Output+--------------+-------------+---------+
| hostgroup_id | hostname    | status  |
+--------------+-------------+---------+
| 1            | 203.0.113.1 | SHUNNED |
| 2            | 203.0.113.2 | ONLINE  |
| 2            | 203.0.113.3 | ONLINE  |
| 3            | 203.0.113.2 | ONLINE  |
| 3            | 203.0.113.3 | ONLINE  |
+--------------+-------------+---------+
6 rows in set (0.01 sec)

Der Knoten, den wir gestoppt haben, ist jetztshunned, was bedeutet, dass er vorübergehend als unzugänglich angesehen wird, sodass der gesamte Datenverkehr auf die beiden verbleibenden Online-Knoten verteilt wird.

ProxySQL überwacht ständig den Status dieses Knotens und bringt ihn entweder aufonline zurück, wenn er sich normal verhält, oder markiert ihn alsoffline, wenn er den in Schritt 4 festgelegten Zeitlimitschwellenwert überschreitet.

Testen wir diese Überwachung. Wechseln Sie zurück zum MySQL-Server und bringen Sie den Knoten wieder in Betrieb. 

systemctl start mysql

Warten Sie einen Moment und fragen Sie dann die Tabelleruntime_mysql_serverserneut an der ProxySQL-Verwaltungsaufforderung ab. 

SELECT hostgroup_id, hostname, status FROM runtime_mysql_servers;

ProxySQL stellt schnell fest, dass der Knoten wieder verfügbar ist, und markiert ihn als online: 

Output+--------------+-------------+--------+
| hostgroup_id | hostname    | status |
+--------------+-------------+--------+
| 2            | 203.0.113.1 | ONLINE |
| 2            | 203.0.113.2 | ONLINE |
| 2            | 203.0.113.3 | ONLINE |
| 3            | 203.0.113.1 | ONLINE |
| 3            | 203.0.113.2 | ONLINE |
| 3            | 203.0.113.3 | ONLINE |
+--------------+-------------+--------+
6 rows in set (0.01 sec)

Sie können diesen Test mit einem anderen Knoten (oder zwei von ihnen) wiederholen, um festzustellen, ob mindestens ein Knoten aktiv ist und ob Sie Ihre Datenbank sowohl für den schreibgeschützten als auch für den schreibgeschützten Zugriff frei verwenden können.

Fazit

In diesem Lernprogramm haben Sie ProxySQL so konfiguriert, dass SQL-Abfragen auf mehrere schreibfähige MySQL-Knoten in einer Replikationstopologie mit mehreren Primärgruppen verteilt werden. Diese Art der Konfiguration kann die Leistung bei starker Datenbanknutzung erhöhen, indem die Last auf mehrere Server verteilt wird. Es kann auch eine Failover-Funktion bereitstellen, falls einer der Datenbankserver offline geschaltet wird.

Wir haben hier jedoch nur eine Knotentopologie als Beispiel behandelt. ProxySQL bietet auch für viele andere MySQL-Topologien zuverlässiges Query-Caching, Routing und Leistungsanalyse. Sie können mehr über die Funktionen von ProxySQL und darüber erfahren, wie Sie verschiedene Datenbankverwaltungsprobleme mit ihnen auf denofficial ProxySQL blog undProxySQL wiki lösen können.

Related