TOC

SaltStack-Infrastruktur: Salt-Status für MySQL-Datenbankserver erstellen

Einführung

SaltStack oder Salt ist ein leistungsstarkes Remote-Ausführungs- und Konfigurationsverwaltungssystem, mit dem die Infrastruktur auf einfache Weise strukturiert und wiederholbar verwaltet werden kann. In dieser Serie werden wir eine Methode zum Verwalten Ihrer Entwicklungs-, Staging- und Produktionsumgebungen anhand einer Salt-Bereitstellung demonstrieren. Wir werden das Salt-Status-System verwenden, um wiederholbare Aktionen zu schreiben und anzuwenden. Auf diese Weise können wir jede unserer Umgebungen zerstören, in der Gewissheit, dass wir sie zu einem späteren Zeitpunkt problemlos in identischem Zustand wieder online stellen können.

In der last guide in dieser Reihe haben wir HAProxy als Load Balancer in eingerichtet vor unseren Webservern. In diesem Handbuch werden wir uns darauf konzentrieren, Zustände zu erstellen, mit denen unsere MySQL-Datenbankserver in jeder unserer Umgebungen installiert und verwaltet werden. Dieser Artikel behandelt die grundlegende Installation und Einrichtung von MySQL. In einem zukünftigen Handbuch werden wir uns mit der komplexeren Aufgabe des Einrichtens der Replikation befassen.

Holen Sie sich MySQL Prompt-Informationen mit debconf-utils

Das Erstellen unserer MySQL-Status ist etwas komplizierter als in unseren vorherigen Beispielen mit Nginx und MySQL. Im Gegensatz zu den beiden anderen Installationsschritten müssen bei der MySQL-Installation in der Regel mehrere Eingabeaufforderungen beantwortet werden, um das MySQL-Root-Passwort festzulegen.

Bevor wir mit unserer Statusdatei beginnen, sollten wir eine Testinstallation von MySQL auf einem unserer Minions durchführen. Wir können dann das Paket + debconf-utils + verwenden, um Informationen zu den Eingabeaufforderungen zu erhalten, die wir ausfüllen müssen.

Wenn Ihre Staging-Umgebung noch nicht verfügbar ist, können Sie die zuvor erstellte Staging-Umgebungszuordnungsdatei verwenden, um die Umgebung hochzufahren:

sudo salt-cloud -P -m /etc/salt/cloud.maps.d/stage-environment.map

Sobald Ihre Datenbankserver verfügbar sind, wählen Sie einen Ihrer Datenbankserver aus, um MySQL zu installieren, damit wir die relevanten Informationen aus der Installation abrufen können:

sudo salt stage-db1 pkg.install mysql-server

Um die + debconf + - Datenbanken einfach nach den erforderlichen Eingabeaufforderungsinformationen abzufragen, sollten wir auch das + debconf-utils + - Paket auf dem Datenbank-Minion installieren:

sudo salt stage-db1 pkg.install debconf-utils

Die + debconf + - Funktionalität in Salt ist verfügbar, sobald dieses Paket installiert ist. Wir können die Ausführungsmodulfunktion "+ debconf.get_selections " verwenden, um alle Eingabeaufforderungsinformationen vom Datenbank-Minion abzurufen. Wir sollten dies in " less +" umleiten, da dies alle Informationen aus den auf diesem Host installierten Paketen zurückgibt:

sudo salt stage-db1 debconf.get_selections | less

Suchen Sie in der Ausgabe nach dem Abschnitt, in dem es um MySQL geht. Es sollte ungefähr so ​​aussehen:

Output. . .

mysql-server-5.5:
   |_


   |_


   |_
     - mysql-server-5.5/really_downgrade
     - boolean
     - false
   |_
     - mysql-server-5.5/start_on_boot
     - boolean
     - true

. . .

Die ersten beiden Einträge enthalten die Feldnamen, die wir benötigen (+ mysql-server / root_password + und + mysql-server / root_password_again +). Die zweite Zeile dieser Einträge gibt den Feldtyp an, den wir in unserer Statusdatei angeben müssen.

Nachdem Sie diese Informationen aus der Ausgabe von "+ debconf " kopiert haben, sollten wir auch die Datei " /etc/mysql/my.cnf +" abrufen. Wir werden das später brauchen, wenn wir unsere MySQL-Zustände konfigurieren:

sudo salt stage-db1 cp.push /etc/mysql/my.cnf

Nachdem wir die + / etc / mysql / my.cnf -Datei zurück in den Salt-Master verschoben haben, können wir die Ressource löschen, damit wir später in der Anleitung einen sauberen Slate zum Testen haben:

sudo salt-cloud -d stage-db1

Nachdem der Server gelöscht wurde, können Sie ihn im Hintergrund neu erstellen, indem Sie Folgendes eingeben. Das "+ sm +" in diesem Fall ist der Name unseres Salt-Masterservers, der über die entsprechenden Cloud-Anmeldeinformationen verfügt:

sudo salt --async  cloud.profile stage-db stage-db1

Während der Wiederherstellung Ihres Datenbankservers können wir mit der Erstellung der MySQL-Statusdatei beginnen.

Erstellen Sie die Haupt-MySQL-Statusdatei

Zunächst erstellen wir ein Verzeichnis für unseren MySQL-Status im Verzeichnis "+ / srv / salt +":

sudo mkdir -p /srv/salt/mysql

In diesem Verzeichnis können wir eine "+ init.sls +" - Datei erstellen und öffnen, um unsere primäre MySQL-Statusdatei zu speichern:

sudo nano /srv/salt/mysql/init.sls

Wir müssen sicherstellen, dass das Paket "+ debconf-utils " auf dem Minion installiert ist, um die von uns benötigten Werte einfach einstellen zu können. Wir können dies mit dem Zustandsmodul " package.installed" tun:

/srv/salt/mysql/init.sls

debconf-utils:
 pkg.installed

Nachdem das Paket "+ debconf-utils " installiert wurde, können wir die Antworten auf die Eingabeaufforderungen mit dem Zustandsmodul " debconf.set " voreinstellen. Wir werden das Attribut " name " verwenden, um den Paketnamen anzugeben, für den wir Eingabeaufforderungen festlegen möchten. Anschließend erstellen wir eine " data +" - Struktur, die das Informationsverzeichnis enthält, mit dem die Eingabeaufforderungen ausgefüllt werden können.

Die + data + - Struktur verwendet im Wesentlichen die Informationen zu Eingabeaufforderungen, die wir von unserer Test-MySQL-Installation abgefragt haben. Wir kennen die Feldnamen und die Datentypen, die für diese Felder verwendet werden sollen. Um das eigentliche Passwort festzulegen, werden wir mit der Ausführungsmodulfunktion + pillar.get + aus dem Salt-Pillar-System ziehen.

Wir werden das Passwort etwas später im Säulensystem einrichten. Auf diese Weise können wir Ihre Kennwortdaten von unserer Konfiguration trennen.

Note

/srv/salt/mysql/init.sls

debconf-utils:
 pkg.installed

mysql_setup:
 debconf.set:
   - name: mysql-server
   - data:
       'mysql-server/root_password': {'type': 'password', 'value': '{{ salt['pillar.get']('mysql:root_pw', '') }}' }
       'mysql-server/root_password_again': {'type': 'password', 'value': '{{ salt['pillar.get']('mysql:root_pw', '') }}' }
   - require:
     - pkg: debconf-utils

Um tatsächlich mit MySQL interagieren zu können, müssen die entsprechenden Python-Bibliotheken auf den Datenbankservern verfügbar sein. Wir können das Paket + python-mysqldb installieren, um sicherzustellen, dass wir Zugriff auf die MySQL-Funktionen von Salt haben. Danach können wir die eigentliche MySQL-Server-Software sicher installieren. Wir werden "+ require " verwenden, um sicherzustellen, dass die Bibliotheken " debconf +" und "Python" verfügbar sind.

Nach der Installation können wir einen Dienststatus hinzufügen, um sicherzustellen, dass der Dienst ausgeführt wird. Dadurch wird nach Änderungen im MySQL-Serverpaket gesucht. Es überwacht auch die grundlegende MySQL-Konfigurationsdatei und lädt den Dienst neu, wenn Änderungen festgestellt werden:

/srv/salt/mysql/init.sls

debconf-utils:
 pkg.installed

mysql_setup:
 debconf.set:
   - name: mysql-server
   - data:
       'mysql-server/root_password': {'type': 'password', 'value': '{{ salt['pillar.get']('mysql:root_pw', '') }}' }
       'mysql-server/root_password_again': {'type': 'password', 'value': '{{ salt['pillar.get']('mysql:root_pw', '') }}' }
   - require:
     - pkg: debconf-utils

Es gibt einige Dateien, die wir mit MySQL verwalten müssen. Die naheliegendste Datei, die wir verwalten müssen, ist die oben erwähnte Datei "+ /etc/mysql/my.cnf". Wir müssen einige Änderungen basierend auf variablen Informationen vornehmen, daher muss diese Datei eine Jinja-Vorlage sein.

Die anderen Dateien, die wir verwalten müssen, haben mit der Verwaltung von MySQL-Systemen durch Salt zu tun. Um Datenbanken verwalten zu können, muss der Salt Minion über Informationen zum Herstellen einer Verbindung zum RDBMS verfügen. Zuerst können wir eine einfache Datei im Verzeichnis + / etc / salt / minion.d + erstellen. Dies listet einfach die Datei auf, in der unsere Verbindungsdetails zu finden sind. Die Datei mit den Datenbankverbindungsdetails ist die andere Datei, die wir verwalten müssen. Die Datenbankverbindungsdatei muss eine Vorlage sein:

/srv/salt/mysql/init.sls

. . .

mysql:
 service.running:
   - watch:
     - pkg: mysql-server
     - file: /etc/mysql/my.cnf

Zuletzt müssen wir den Zustand "+ service.restart " einfügen, der den " salt-minion " - Prozess selbst neu lädt. Dies ist notwendig, damit unser Diener die Datei " / etc / salt / minion.d / mysql.conf " abholt. Wir möchten nur, dass das ` salt-minion ` neu gestartet wird, wenn Änderungen an der ` / etc / salt / minion.d / mysql.conf ` Datei selbst vorgenommen werden. Wir können ein " watch +" - Requisit verwenden, um dies zu erreichen:

/srv/salt/mysql/init.sls

. . .

/etc/mysql/salt.cnf:
 file.managed:
   - source: salt://mysql/files/etc/mysql/salt.cnf.jinja
   - template: jinja
   - user: root
   - group: root
   - mode: 640
   - require:
     - service: mysql

Wenn Sie mit dem Hinzufügen der obigen Details fertig sind, speichern und schließen Sie die Datei.

Erstellen Sie die Säulen für MySQL

In unserem MySQL-Status haben wir die Ausführungsmodulfunktion + pillar.get + verwendet, um das MySQL-Root-Passwort mit einem Wert aus dem Pillar-System zu füllen. Wir müssen diese Säule so einrichten, dass der Staat die erforderlichen Daten abrufen kann, um die Datenbankanmeldeinformationen zu erstellen.

Das Pillar-System eignet sich perfekt für diese Art von Anwendungsfällen, da Sie bestimmten Hosts Daten zuweisen können. Nicht übereinstimmende Hosts haben keinen Zugriff auf die vertraulichen Daten. Bisher benötigt unser Staat nur das root-Passwort. Wir haben die Position innerhalb des Säulensystems mit "+ mysql: root_pw +" angegeben. Wir werden nun den Schlüssel einrichten.

Erstellen einer Top-Datei für das Säulensystem

Bevor wir die benötigten MySQL-Pillar-Dateien erstellen, müssen wir eine Pillar-Top-Datei erstellen. Die oberste Datei wird verwendet, um Salt Minions mit Säulendaten abzugleichen. Salt Minions können nicht auf Säulendaten zugreifen, die in der obersten Datei nicht übereinstimmen.

Das Verzeichnis "+ / srv / pillar " sollte während der Installationsanleitung erstellt worden sein. Wir können eine " top.sls +" - Datei in diesem Verzeichnis erstellen, um zu beginnen:

cd /srv/pillar
sudo nano top.sls

Im Inneren müssen wir die "+ base" -Umgebung angeben (wir verwenden aufgrund der Komplexität und einiger undokumentierter Verhaltensweisen nicht die Salt-Konzeption von Umgebungen in dieser Reihe). Alle unsere Server arbeiten in der "+ base +" - Umgebung und verwenden Körner für die Umweltkennzeichnung. Wir werden zusammengesetzte Übereinstimmungen verwenden, um Knoten abzugleichen. Wir werden die Serverrolle und die Serverumgebung abgleichen, um zu bestimmen, welche Säulen jedem Host zugewiesen werden sollen.

Die Säulen verwenden die Punktnotation, um Dateien innerhalb eines Verzeichnisses zu kennzeichnen. Zum Beispiel ist die Wurzel des Säulensystems "+ / srv / pillar ". Um die " mysql.sls" -Säule im "+ dev " -Verzeichnis zuzuweisen, verwenden wir " dev.mysql".

Die Aufgabe, die wir für diesen Leitfaden benötigen, sieht folgendermaßen aus:

/srv/pillar/top.sls

base:
 'G@env:dev and G@role:dbserver':
   - match: compound
   - dev.mysql

 'G@env:stage and G@role:dbserver':
   - match: compound
   - stage.mysql

 'G@env:prod and G@role:dbserver':
   - match: compound
   - prod.mysql

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Schaffung der umweltspezifischen Säulen

Oben haben wir den Servern je nach Rolle und Umgebung Säulen zugewiesen. Auf diese Weise können wir verschiedene Verbindungs- und Anmeldeinformationen für verschiedene Umgebungen angeben.

Erstellen Sie zunächst die Verzeichnisse, auf die in der Pillar-Top-Datei verwiesen wird:

sudo mkdir /srv/pillar/{prod,stage,dev}

Als nächstes sollten wir eine "+ mysql.sql" -Datei in jedem dieser Verzeichnisse erstellen. Wir können mit der Datei + / srv / salt / stage / mysql.sls + beginnen, da wir derzeit die Staging-Umgebung zum Testen verwenden:

sudo nano /srv/pillar/stage/mysql.sls

Die von uns erstellte Statusdatei möchte das MySQL-Root-Passwort mit dem Schlüssel + mysql: root_pw + aus dem Pillar-System holen. Dies ist eigentlich ein verschachtelter Schlüssel, was bedeutet, dass "+ root_pw " ein Kind des Schlüssels " mysql +" ist. In diesem Sinne können wir ein Passwort für unseren MySQL-Root-Benutzer auswählen und es in der Datei wie folgt festlegen:

/srv/pillar/stage/mysql.sls

mysql:
 root_pw:

Wählen Sie das Passwort, das Sie verwenden möchten. Wenn Sie fertig sind, speichern und schließen Sie die Datei. Das ist alles was wir jetzt brauchen.

Erstellen Sie eine ähnliche Datei in Ihrer Entwicklungssäule:

sudo nano /srv/pillar/dev/mysql.sls

/srv/pillar/dev/mysql.sls

mysql:
 root_pw:

Machen Sie dasselbe für Ihre Produktionsumgebungssäule:

sudo nano /srv/pillar/prod/mysql.sls

/srv/pillar/prod/mysql.sls

mysql:
 root_pw:

Wählen Sie für jede dieser Umgebungen unterschiedliche Kennwörter.

Wir werden später auf diese Säulen zurückkommen, da wir mehr Daten benötigen, die nicht in der Konfiguration selbst enthalten sind. Speichern und schließen Sie vorerst alle geöffneten Dateien.

Erstellen Sie die Vorlage /etc/mysql/my.cnf.jinja

Wir haben unsere grundlegende MySQL-Statusdatei früher erstellt, aber nie die verwalteten Dateien für die Installation.

Als wir die Testinstallation von "+ mysql-server " auf unserem " stage-db1 " -Server durchgeführt haben, haben wir die " / etc / mysql / my.cnf" -Datei zurück auf den Master verschoben. Das sollte noch in unserem Salt Master Cache verfügbar sein. Wir können die gesamte Verzeichnisstruktur, die zu dieser Cache-Datei führt, in unser Verzeichnis + / srv / salt / mysql + kopieren, indem wir Folgendes eingeben:

sudo cp -r /var/cache/salt/master/minions/stage-db1/files /srv/salt/mysql

Wechseln Sie in das Verzeichnis, das die kopierte "+ mycnf +" - Datei im MySQL-Statusverzeichnis enthält:

cd /srv/salt/mysql/files/etc/mysql

Kopieren Sie die derzeit vorhandene Datei in das Suffix "+ .orig +", damit wir bei Bedarf die Änderungen rückgängig machen können:

sudo cp my.cnf my.cnf.orig

Als nächstes benennen Sie die Datei + my.cnf + um, um ein + .jinja + Suffix zu erhalten. Dies zeigt uns auf einen Blick, dass es sich bei dieser Datei um eine Vorlage handelt und nicht um eine Datei, die ohne Rendern auf einem Host abgelegt werden kann:

sudo mv my.cnf my.cnf.jinja

Öffnen Sie die Jinja-Vorlagendatei, um mit den erforderlichen Änderungen zu beginnen:

sudo nano my.cnf.jinja

Alle Änderungen, die wir jetzt vornehmen möchten, haben mit dem Zulassen von Remote-MySQL-Verbindungen zu tun. Gegenwärtig ist MySQL an die lokale Loopback-Schnittstelle gebunden. Wir möchten dies so einstellen, dass die private Netzwerkadresse des Knotens abgehört wird.

Suchen Sie dazu die Zeile + bind-address im Abschnitt` + [mysqld] + `. Wir werden die "+ network.interface_ip " - Ausführungsmodulfunktion verwenden, um die der " eth1 +" - Schnittstelle des Minions zugewiesene Adresse zu erhalten.

/srv/salt/mysql/files/etc/mysql/my.cnf.jinja

. . .

[mysqld]

. . .

bind-address            =

Die andere Ergänzung, die wir vornehmen müssen, besteht darin, die DNS-Namensauflösung für unsere Server zu deaktivieren. Durch Hinzufügen der Option "+ überspringen-Name-Auflösen +" schlägt MySQL nicht fehl, wenn es einen Namen nicht vervollständigen und die Namensauflösung umkehren kann:

/srv/salt/mysql/files/etc/mysql/my.cnf.jinja

. . .

[mysqld]

. . .

bind-address            = {{ salt['network.interface_ip']('eth1') }}

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Erstellen Sie die Datei /etc/salt/minion.d/mysql.conf

Als nächstes müssen wir die verwaltete Datei erstellen, die zum Ändern der Konfiguration des Minions verwendet wird, mit Kenntnissen darüber, wie eine Verbindung zur MySQL-Datenbank hergestellt wird. Anstatt die Konfiguration in der Datei "+ / etc / salt / minion " selbst zu belassen, wird eine neue Datei in das Verzeichnis " / etc / salt / minion.d +" gestellt, in der angegeben wird, wo sich die Verbindungsinformationen befinden.

Erstellen Sie zunächst die erforderliche Verzeichnisstruktur im Verzeichnis "+ / srv / salt / mysql / files":

sudo mkdir -p /srv/salt/mysql/files/etc/salt/minion.d

In diesem Verzeichnis können wir eine Datei mit dem Namen "+ mysql.conf +" erstellen:

sudo nano /srv/salt/mysql/files/etc/salt/minion.d/mysql.conf

Im Inneren müssen wir nur eine Option festlegen: den Speicherort der Verbindungsinformationsdatei. In unserem Fall setzen wir dies auf eine Datei unter + / etc / mysql / salt.cnf +:

/srv/salt/mysql/files/etc/salt/minion.d/mysql.conf

mysql.default_file: '/etc/mysql/salt.cnf'

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Erstellen Sie die Vorlagendatei /etc/mysql/salt.cnf

Jetzt müssen wir die Datei erstellen, auf die sich unsere Minion-Konfiguration bezieht. Dies ist eine Vorlagendatei, da wir einige der Verbindungsdetails aus dem Säulensystem abrufen müssen. Wir werden diese Datei im Verzeichnis + / srv / salt / mysql / files / etc / mysql ablegen:

sudo nano /srv/salt/mysql/files/etc/mysql/salt.cnf.jinja

Im Inneren müssen wir einen Abschnitt "+ [client] " öffnen, um die Art der Informationen anzugeben, die wir definieren. Unterhalb dieses Headers können wir festlegen, dass der Client mit dem MySQL-Root-Benutzer an einem Unix-Socket unter ` / var / run / mysqld / mysqld.sock +` eine Verbindung zum lokalen Computer herstellt. Dies sind alles Standardwerte für MySQL:

/srv/salt/mysql/files/etc/mysql/salt.cnf.jinja

[client]
host                = localhost
user                = root
socket              = /var/run/mysqld/mysqld.sock

Das einzige, was wir jetzt hinzufügen müssen, ist das Passwort. Wir werden dies wieder direkt aus dem Pillar-System ziehen, so wie wir es im Abschnitt "+ debconf +" unserer MySQL-Statusdatei getan haben. Es wird ungefähr so ​​aussehen:

/srv/salt/mysql/files/etc/mysql/salt.cnf.jinja

[client]
host                = localhost
user                = root
socket              = /var/run/mysqld/mysqld.sock

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Testinstallation und Sanity Check

Nachdem wir den grundlegenden Installationsstatus und die unterstützenden Dateien konfiguriert haben, sollten wir unser Setup schnell testen, um sicherzustellen, dass es ordnungsgemäß funktioniert.

Wir beginnen mit unserem typischen Testprozess. Verwenden Sie das Ausführungsmodul + state.show_sls +, um sicherzustellen, dass es Ihre Statusdatei rendern kann:

sudo salt stage-db1 state.show_sls mysql

Durchsuchen Sie die Ausgabe, um sicherzustellen, dass Salt keine Probleme beim Parsen Ihrer Datei + / srv / salt / mysql / init.sls + hat.

Führen Sie als Nächstes einen Probelauf der Statusanwendung durch, indem Sie "+ test = True " am Ende der Ausführungsmodulfunktion " state.apply +" hinzufügen:

sudo salt stage-db1 state.apply mysql test=True

  • Dieser Befehl wird voraussichtlich fehlschlagen *. Da einige der Statusfunktionen in unserer Datei erst nach der Installation bestimmter Pakete verfügbar sind, wird ein Fehler während des Testlaufs erwartet. Während des eigentlichen Laufs wird durch die Statusreihenfolge sichergestellt, dass die vorausgesetzten Pakete installiert werden, bevor die Status aufgerufen werden, die sie verwenden.

Alle Kommentare für die fehlgeschlagenen Zustände sollten anzeigen, dass "ein oder mehrere erforderliche Zustände fehlgeschlagen sind", mit Ausnahme des Zustands "+ mysql_setup ", der fehlschlagen sollte, weil " debconf.set +" nicht verfügbar ist (dies ist nur ein weiterer vorausgesetzter Fehler) ). Verwenden Sie die Ausgabe hier, um sicherzustellen, dass keine anderen Fehler ohne Bezug auftauchen.

Nach dem Ausführen des Tests können wir den Status anwenden, indem wir Folgendes eingeben:

sudo salt stage-db1 state.apply mysql

Dies sollte zu einer erfolgreichen Statusausführung führen.

Wir müssen testen, ob Salt eine Verbindung zur MySQL-Datenbank herstellen und diese abfragen kann. Stellen Sie sicher, dass Sie die Standarddatenbanken auflisten können, indem Sie Folgendes eingeben:

sudo salt stage-db1 mysql.db_list

Sie sollten eine Auflistung erhalten, die ungefähr so ​​aussieht:

Outputstage-db1:
   - information_schema
   - mysql
   - performance_schema

Dies zeigt an, dass Salt eine Verbindung zur MySQL-Instanz unter Verwendung der in der Datei + / etc / mysql / salt.cnf + angegebenen Informationen herstellen konnte.

Nachdem wir überprüft haben, dass unser Basis-MySQL-Status korrekt funktioniert, können wir den "+ stage-db1 +" - Server löschen:

sudo salt-cloud -d stage-db1

Erstellen Sie den Server im Hintergrund neu, damit Sie ihn später erneut testen können. Wieder ist "+ sm +" der Name unseres Salt-Masterservers in dieser Instanz:

sudo salt --async  cloud.profile stage-db stage-db1

Jetzt ist unser grundlegendes MySQL-Setup abgeschlossen.

Fazit

Sie sollten nun einen Status haben, der MySQL auf Ihren Dienern installiert. Dadurch wird auch der Prozess "+ salt-minion +" auf jedem dieser Server ausgelöst, sodass Salt eine Verbindung zu den beteiligten Datenbanken herstellen und diese verwalten kann.

Während unsere aktuellen Versionen MySQL installieren und unsere Minions so konfigurieren, dass sie die Datenbanksysteme steuern, sind unsere Datenbanken derzeit völlig getrennt. In einem zukünftigen Handbuch werden wir uns mit der Replikation von MySQL-Datenbanken befassen, damit unsere Daten in jeder unserer Datenbanken in jeder Umgebung konsistent sind.

Related