Wie kann ich eine Datenbank unter Git stellen (Versionskontrolle)?

Ich mache eine Web-App und muss einen Zweig für einige wichtige Änderungen erstellen. Diese Änderungen erfordern Änderungen am Datenbankschema. Daher möchte ich auch die gesamte Datenbank unter Git stellen.

Wie mache ich das? Gibt es einen bestimmten Ordner, den ich unter einem Git-Repository aufbewahren kann? Woher weiß ich welche? Wie kann ich sicher sein, dass ich den richtigen Ordner ablege?

Ich muss sicher sein, da diese Änderungen nicht abwärtskompatibel sind. Ich kann es mir nicht leisten, es zu vermasseln.

Die Datenbank in meinem Fall ist PostgreSQL

Bearbeiten:

Jemand schlug vor, Backups zu erstellen und die Backup-Datei anstelle der Datenbank der Versionskontrolle zu unterziehen. Um ehrlich zu sein, finde ich das wirklich schwer zu schlucken.

Es muss einen besseren Weg geben.

Aktualisieren:

OK, es gibt keinen besseren Weg, aber ich bin immer noch nicht ganz überzeugt, also werde ich die Frage ein wenig ändern:

Ich möchte die gesamte Datenbank unter Versionskontrolle stellen. Welches Datenbankmodul kann ich verwenden, um die eigentliche Datenbank unter Versionskontrolle zu stellen, anstatt ihren Speicherauszug?

Wäre SQLite git-freundlich?

Da dies nur die Entwicklungsumgebung ist, kann ich die gewünschte Datenbank auswählen.

Edit2:

Was ich wirklich möchte, ist nicht, meine Entwicklungshistorie zu verfolgen, sondern in der Lage zu sein, von meinem Zweig "Neue radikale Änderungen" zum "aktuellen stabilen Zweig" zu wechseln und beispielsweise einige Fehler / Probleme usw. mit dem aktuellen zu beheben stabiler Zweig. Wenn ich also einen Zweig wechsle, wird die Datenbank automatisch mit dem Zweig kompatibel, in dem ich mich gerade befinde. Die tatsächlichen Daten sind mir eigentlich egal.

Nehmen Sie einen Datenbank-Dump und kontrollieren Sie stattdessen die Version. Auf diese Weise ist es eine flache Textdatei.

Persönlich schlage ich vor, dass Sie sowohl einen Daten-Dump als auch einen Schema-Dump behalten. Auf diese Weise wird mit diff ziemlich einfach zu erkennen, was sich im Schema von Revision zu Revision geändert hat.

Wenn Sie große Änderungen vornehmen, sollten Sie über eine sekundäre Datenbank verfügen, in der Sie die neuen Schemaänderungen vornehmen und die alte nicht berühren, da Sie, wie Sie sagten, eine Verzweigung vornehmen.

Überprüfen Sie die Refactoring-Datenbanken ( http://databaserefactoring.com/). ) finden Sie eine Reihe guter Techniken, um Ihre Datenbank zusammen mit Codeänderungen zu verwalten.

Es genügt zu sagen, dass Sie die falschen Fragen stellen. Anstatt Ihre Datenbank in Git zu versetzen, sollten Sie Ihre Änderungen in kleine überprüfbare Schritte zerlegen, damit Sie Schemaänderungen problemlos migrieren / zurücksetzen können.

Wenn Sie eine vollständige Wiederherstellbarkeit wünschen, sollten Sie in Betracht ziehen, Ihre Postgres-WAL-Protokolle zu archivieren und die PITR (Zeitpunktwiederherstellung) zu verwenden, um Transaktionen in bestimmten bekannten guten Zuständen wiederzugeben / weiterzuleiten.

Ich fange an, über eine wirklich einfache Lösung nachzudenken, weiß nicht, warum ich vorher nicht daran gedacht habe !!

• Duplizieren Sie die Datenbank (sowohl das Schema als auch die Daten).
• Ändern Sie in der Verzweigung für die neuen Hauptänderungen einfach die Projektkonfiguration, um die neue doppelte Datenbank zu verwenden.

Auf diese Weise kann ich Zweige wechseln, ohne mich um Änderungen des Datenbankschemas kümmern zu müssen.

BEARBEITEN:

Mit Duplizieren meine ich, eine andere Datenbank mit einem anderen Namen (wie my_db_2) zu erstellen ; keinen Dump machen oder so.

Verwenden Sie so etwas wie LiquiBase, damit Sie die Revisionskontrolle Ihrer Liquibase-Dateien behalten können. Sie können Änderungen nur für die Produktion kennzeichnen und lb Ihre Datenbank entweder für die Produktion oder die Entwicklung (oder für ein beliebiges Schema) auf dem neuesten Stand halten.

Angesichts eines ähnlichen Bedarfs und hier ist, was meine Forschung über Datenbank-Versionskontrollsysteme ergab:

1. Sqitch - Open Source auf Perl-Basis; Verfügbar für alle wichtigen Datenbanken, einschließlich PostgreSQL https://github.com/sqitchers/sqitch
2. Mahout - nur für PostgreSQL; Versionskontrolle des Open Source-Datenbankschemas. https://github.com/cbbrowne/mahout
3. Liquibase - eine weitere Open Source DB Versionskontrolle sw. kostenlose Version von Datical.http://www.liquibase.org/index.html
4. Datical - kommerzielle Version von Liquibase - https://www.datical.com/
5. Flyway von BoxFuse - kommerziell sw. https://flywaydb.org/
6. Ein weiteres Open Source-Projekt https://gitlab.com/depesz/Versioning Author bietet hier einen Leitfaden: https://www.depesz.com/2010/08/22/versioning/
7. Red Gate Change Automation - nur für SQL Server. https://www.red-gate.com/products/sql-development/sql-change-automation/

Es gibt ein großartiges Projekt namens Migrations under Doctrine, das nur für diesen Zweck entwickelt wurde.

Es ist immer noch im Alpha-Zustand und für PHP gebaut.

http://docs.doctrine-project.org/projects/doctrine-migrations/en/latest/index.html

Ich bin auf diese Frage gestoßen, da ich ein ähnliches Problem habe, bei dem etwas, das sich einer DB-basierten Verzeichnisstruktur annähert, 'Dateien' speichert und ich Git brauche, um es zu verwalten. Es wird mithilfe der Replikation über eine Cloud verteilt, daher erfolgt der Zugriffspunkt über MySQL.

Der Kern der obigen Antworten scheint ebenfalls eine alternative Lösung für das gestellte Problem vorzuschlagen, bei der es darum geht, mit Git etwas in einer Datenbank zu verwalten. Daher werde ich versuchen, diese Frage zu beantworten.

Git ist ein System, das im Wesentlichen eine Datenbank mit Deltas (Unterschieden) speichert, die wieder zusammengesetzt werden können, um einen Kontext zu reproduzieren. Die normale Verwendung von git setzt voraus, dass der Kontext ein Dateisystem ist und diese Deltas in diesem Dateisystem unterschiedlich sind, aber eigentlich ist alles git eine hierarchische Datenbank von Deltas (hierarchisch, da in den meisten Fällen jedes Delta ein Commit mit mindestens 1 ist Eltern, in einem Baum angeordnet).

Solange Sie ein Delta erzeugen können, kann Git es theoretisch speichern. Das Problem ist normalerweise, dass Git erwartet, dass der Kontext, in dem Delta generiert wird, ein Dateisystem ist. Wenn Sie einen Punkt in der Git-Hierarchie auschecken, erwartet es, dass ein Dateisystem generiert wird.

Wenn Sie Änderungen in einer Datenbank verwalten möchten, haben Sie zwei diskrete Probleme, die ich separat behandeln würde (wenn ich Sie wäre). Das erste ist das Schema, das zweite sind Daten (obwohl Sie in Ihrer Frage angeben, dass Daten nichts sind, worüber Sie sich Sorgen machen). Ein Problem, das ich in der Vergangenheit hatte, war eine Dev- und Prod-Datenbank, in der Dev inkrementelle Änderungen am Schema vornehmen konnte. Diese Änderungen mussten in CVS dokumentiert und für das Leben freigegeben werden, zusammen mit Ergänzungen zu einer von mehreren "statischen" Datenbanken. Tabellen. Dazu haben wir eine dritte Datenbank namens Cruise eingerichtet, die nur die statischen Daten enthielt. Zu jedem Zeitpunkt konnte das Schema von Dev und Cruise verglichen werden, und wir hatten ein Skript, um den Unterschied dieser beiden Dateien zu nehmen und eine SQL-Datei mit ALTER-Anweisungen zu erstellen, um sie anzuwenden. Ebenso alle neuen Daten, könnte in eine SQL-Datei mit INSERT-Befehlen destilliert werden. Solange Felder und Tabellen nur hinzugefügt und nie gelöscht werden, kann der Prozess das Generieren der SQL-Anweisungen zum Anwenden des Deltas automatisieren.

Der Mechanismus, durch den Git Deltas erzeugt, ist diffund der Mechanismus, durch den es 1 oder mehrere Deltas mit einer Datei kombiniert, wird aufgerufen merge. Wenn Sie eine Methode zum Unterscheiden und Zusammenführen aus einem anderen Kontext finden können, sollte git funktionieren, aber wie bereits erläutert, bevorzugen Sie möglicherweise ein Tool, das dies für Sie erledigt. Mein erster Gedanke zur Lösung dieses Problems ist https://git-scm.com/book/en/v2/Customizing-Git-Git-Configuration#External-Merge-and-Diff-Tools, in dem detailliert beschrieben wird, wie das interne Diff und die internen Git ersetzt werden Werkzeug zusammenführen. Ich werde diese Antwort aktualisieren, wenn ich eine bessere Lösung für das Problem finde, aber in meinem Fall erwarte ich, dass ich nur Datenänderungen verwalten muss, sofern sich ein DB-basierter Dateispeicher ändern kann, also meine Lösung ist möglicherweise nicht genau das, was Sie brauchen.

Schauen Sie sich RedGate SQL Source Control an.

http://www.red-gate.com/products/sql-development/sql-source-control/

Dieses Tool ist ein SQL Server Management Studio-Snap-In, mit dem Sie Ihre Datenbank mit Git unter Quellcodeverwaltung platzieren können.

Es ist ein bisschen teuer bei 495 US-Dollar pro Benutzer, aber es gibt eine kostenlose 28-Tage-Testversion.

HINWEIS Ich bin in keiner Weise mit RedGate verbunden.

Ich möchte etwas Ähnliches machen und meine Datenbankänderungen zu meinem Versionskontrollsystem hinzufügen.

Ich werde den Ideen in diesem Beitrag von Vladimir Khorikov "Best Practices für die Datenbankversionierung" folgen . Zusammenfassend werde ich

• Speichern Sie sowohl das Schema als auch die Referenzdaten in einem Versionsverwaltungssystem.
• Für jede Änderung erstellen wir ein separates SQL-Skript mit den Änderungen

Falls es hilft!

• Irmin
• Flur.ee
• Crux DB

Ich habe eine Weile nach der gleichen Funktion für Postgres (oder SQL-Datenbanken im Allgemeinen) gesucht, aber ich fand keine Tools, die geeignet (einfach und intuitiv) genug sind. Dies ist wahrscheinlich auf die binäre Art der Speicherung von Daten zurückzuführen. Klonio klingt ideal, sieht aber tot aus. Noms DB sieht interessant ( und lebendig ) aus. Schauen Sie sich auch Irmin an (OCaml-basiert mit Git-Eigenschaften).

Obwohl dies die Frage nicht beantwortet, da es mit Postgres funktionieren würde, schauen Sie sich Flur.ee an Datenbank. Es verfügt über eine "Zeitreise" -Funktion, mit der Sie die Daten zu einem beliebigen Zeitpunkt abfragen können. Ich vermute, es sollte in der Lage sein, mit einem "Verzweigungs" -Modell zu arbeiten.

Diese Datenbank wurde kürzlich für Blockchain-Zwecke entwickelt. Aufgrund der Art der Blockchains müssen die Daten in Schritten aufgezeichnet werden, genau so funktioniert Git. Sie streben eine Open-Source-Veröffentlichung im zweiten Quartal 2019 an .

Da jede Fluree-Datenbank eine Blockchain ist, speichert sie den gesamten Verlauf jeder durchgeführten Transaktion. Dies ist Teil dessen, wie eine Blockchain sicherstellt, dass Informationen unveränderlich und sicher sind .

Update : Überprüfen Sie auch die Crux-Datenbank , die über die Zeitdimension von Einfügungen abfragen kann, die Sie als "Versionen" sehen können. Crux scheint eine Open-Source-Implementierung des hoch bewerteten Datomic zu sein.

Crux ist eine bitemporale Datenbank, in der Transaktionszeit und gültige Zeitverläufe gespeichert werden. Während eine [uni] zeitliche Datenbank die Abfrage von "Zeitreisen" durch die Transaktionssequenz von Datenbankzuständen vom Zeitpunkt der Datenbankerstellung bis zu ihrem aktuellen Status ermöglicht, bietet Crux auch Abfragen von "Zeitreisen" für eine diskrete gültige Zeitachse ohne unnötige Entwurfskomplexität oder Auswirkungen auf die Leistung. Dies bedeutet, dass ein Crux-Benutzer die Datenbank unabhängig von der Reihenfolge, in der die Informationen eingehen, mit vergangenen und zukünftigen Informationen füllen und Korrekturen an früheren Aufzeichnungen vornehmen kann, um ein sich ständig verbesserndes zeitliches Modell einer bestimmten Domäne zu erstellen.

Sie können es nicht ohne Atomizität tun, und Sie können Atomizität nicht erhalten, ohne entweder pg_dump oder ein Snapshotting-Dateisystem zu verwenden.

Meine Postgres-Instanz befindet sich auf zfs, was ich gelegentlich als Schnappschuss mache. Es ist ungefähr sofort und konsistent.

Was Sie im Geiste wollen, ist vielleicht so etwas wie Post Facto , das Versionen einer Datenbank in einer Datenbank speichert. Überprüfen Sie diese Präsentation .

Das Projekt ist anscheinend nie wirklich irgendwohin gegangen, daher wird es Ihnen wahrscheinlich nicht sofort helfen, aber es ist ein interessantes Konzept. Ich befürchte, dass es sehr schwierig sein würde, dies richtig zu machen, da sogar Version 1 alle Details richtig machen müsste, damit die Leute ihrer Arbeit vertrauen.

Ich habe ein Tool für SQLite veröffentlicht, das genau das tut, wonach Sie fragen. Es verwendet einen benutzerdefinierten Diff-Treiber, der das SQLite-Projekttool 'sqldiff' nutzt, UUIDs als Primärschlüssel und lässt die SQLite-Zeilen-ID weg. Es ist immer noch in Alpha, daher ist Feedback willkommen.

Postgres und MySQL sind schwieriger, da die Binärdaten in mehreren Dateien gespeichert sind und möglicherweise nicht einmal gültig sind, wenn Sie einen Snapshot erstellen konnten.

https://github.com/cannadayr/git-sqlite

Ich denke, X-Istence ist auf dem richtigen Weg, aber Sie können noch einige Verbesserungen an dieser Strategie vornehmen. Erste Benutzung:

$pg_dump --schema ... 

um die Tabellen, Sequenzen usw. zu sichern und diese Datei unter Versionskontrolle zu stellen. Sie werden dies verwenden, um die Kompatibilitätsänderungen zwischen Ihren Zweigen zu trennen.

Führen Sie als Nächstes einen Datendump für den Satz von Tabellen durch, die die Konfiguration enthalten, die für den Betrieb Ihrer Anwendung erforderlich ist (sollte wahrscheinlich Benutzerdaten usw. überspringen), z. B. Formularvorgaben und andere Daten, die nicht vom Benutzer geändert werden können. Sie können dies selektiv tun, indem Sie Folgendes verwenden:

$pg_dump --table=.. <or> --exclude-table=..

Dies ist eine gute Idee, da das Repo sehr klobig werden kann, wenn Ihre Datenbank bei einem vollständigen Datendump 100+ MB erreicht. Eine bessere Idee ist es, einen minimaleren Datensatz zu sichern, den Sie zum Testen Ihrer App benötigen. Wenn Ihre Standarddaten jedoch sehr groß sind, kann dies dennoch zu Problemen führen.

Wenn Sie unbedingt vollständige Sicherungen im Repo platzieren müssen, sollten Sie dies in einem Zweig außerhalb Ihres Quellbaums tun. Ein externes Backup-System mit einem Verweis auf die passende SVN-Version ist hierfür jedoch wahrscheinlich am besten geeignet.

Außerdem empfehle ich, für Revisionszwecke (zumindest für das Schema) Textformat-Dumps über Binärdateien zu verwenden, da diese leichter zu unterscheiden sind. Sie können diese jederzeit komprimieren, um vor dem Einchecken Platz zu sparen.

Schauen Sie sich zum Schluss die Postgres-Backup-Dokumentation an, falls Sie dies noch nicht getan haben. Die Art und Weise, wie Sie die Sicherung der Datenbank anstelle eines Speicherauszugs kommentieren, lässt mich fragen, ob Sie an dateisystembasierte Sicherungen denken (siehe Abschnitt 23.2 für Einschränkungen).

Diese Frage ist ziemlich beantwortet, aber ich möchte die Antwort von X-Istence und Dana the Sane mit einem kleinen Vorschlag ergänzen.

Wenn Sie beispielsweise täglich eine Revisionskontrolle mit einem gewissen Grad an Granularität benötigen, können Sie den Textauszug sowohl der Tabellen als auch des Schemas mit einem Tool wie rdiff-backup koppeln inkrementelle Sicherungen durchführt. Der Vorteil ist, dass Sie anstelle von Snapshots von täglichen Backups einfach die Unterschiede zum vorherigen Tag speichern.

Damit haben Sie beide den Vorteil der Revisionskontrolle und verschwenden nicht zu viel Platz.

In jedem Fall ist die Verwendung von git direkt für große Flatfiles, die sich sehr häufig ändern, keine gute Lösung. Wenn Ihre Datenbank zu groß wird, treten bei git einige Probleme bei der Verwaltung der Dateien auf.

Folgendes versuche ich in meinen Projekten zu tun:

• separate Daten und Schema sowie Standarddaten.

Die Datenbankkonfiguration wird in einer Konfigurationsdatei gespeichert, die nicht der Versionskontrolle unterliegt (.gitignore).

Die Datenbankvorgabe (zum Einrichten neuer Projekte) ist eine einfache SQL-Datei unter Versionskontrolle.

Erstellen Sie für das Datenbankschema einen Datenbankschema-Dump unter der Versionskontrolle.

Am häufigsten werden Aktualisierungsskripte verwendet, die SQL-Anweisungen enthalten (ALTER Table .. oder UPDATE). Sie müssen auch einen Platz in Ihrer Datenbank haben, an dem Sie die aktuelle Version Ihres Schemas speichern.

Schauen Sie sich andere große Open-Source-Datenbankprojekte an (piwik oder Ihr bevorzugtes CMS-System), die alle Updateskripte verwenden (1.sql, 2.sql, 3.sh, 4.php.5.sql).

Dies ist jedoch eine sehr zeitintensive Aufgabe. Sie müssen die Aktualisierungsskripte erstellen und testen. Außerdem müssen Sie ein gemeinsames Aktualisierungsskript ausführen, das die Version vergleicht und alle erforderlichen Aktualisierungsskripts ausführt.

Theoretisch (und das ist es, wonach ich suche) könnten Sie das Datenbankschema nach jeder Änderung (manuell, Conjob, Git-Hooks (möglicherweise vor dem Festschreiben)) sichern (und nur in einigen ganz besonderen Fällen Aktualisierungsskripte erstellen).

Danach in Ihrem allgemeinen Aktualisierungsskript (führen Sie die normalen Aktualisierungsskripte für die Sonderfälle aus) und vergleichen Sie dann die Schemas (den Speicherauszug und die aktuelle Datenbank) und generieren Sie dann automatisch die erforderlichen ALTER-Anweisungen. Es gibt einige Tools, die dies bereits können, aber noch kein gutes gefunden haben.

Ich würde neXtep für die Versionskontrolle der Datenbank empfehlen. Es verfügt über eine gute Dokumentation und Foren, in denen die Installation und die aufgetretenen Fehler erläutert werden. Ich habe es für postgreSQL 9.1 und 9.3 getestet. Ich konnte es für 9.1 zum Laufen bringen, aber für 9.3 scheint es nicht zu funktionieren.

Was ich in meinen persönlichen Projekten mache, ist, dass ich meine gesamte Datenbank in Dropbox speichere und dann auf MAMP, WAMP-Workflow zeige, um sie direkt von dort aus zu verwenden. Auf diese Weise ist die Datenbank immer auf dem neuesten Stand, wo immer ich etwas entwickeln muss. Aber das ist nur für Entwickler! Live-Sites verwenden dafür natürlich einen eigenen Server! :) :)

Das Speichern jeder Ebene von Datenbankänderungen unter Git-Versionskontrolle ist wie das Verschieben Ihrer gesamten Datenbank bei jedem Commit und das Wiederherstellen Ihrer gesamten Datenbank bei jedem Pull. Wenn Ihre Datenbank so anfällig für wichtige Änderungen ist und Sie es sich nicht leisten können, diese zu verlieren, können Sie einfach Ihre Hooks pre_commit und post_merge aktualisieren . Ich habe das gleiche mit einem meiner Projekte gemacht und die Anweisungen finden Sie hier .

So mach ich es:

Da Sie die freie Wahl über den DB-Typ haben, verwenden Sie eine dateibasierte DB wie z. B. Firebird.

Erstellen Sie eine Vorlagen-Datenbank mit dem Schema, das zu Ihrem tatsächlichen Zweig passt, und speichern Sie es in Ihrem Repository.

Wenn Sie Ihre Anwendung programmgesteuert ausführen, erstellen Sie eine Kopie Ihrer Vorlagen-DB, speichern Sie sie an einem anderen Ort und arbeiten Sie einfach mit dieser Kopie.

Auf diese Weise können Sie Ihr DB-Schema ohne die Daten der Versionskontrolle unterziehen. Und wenn Sie Ihr Schema ändern, müssen Sie nur die Vorlagen-DB ändern

Früher haben wir eine soziale Website mit einer Standard-LAMP-Konfiguration betrieben. Wir hatten einen Live-Server, einen Testserver und einen Entwicklungsserver sowie die lokalen Entwicklermaschinen. Alle wurden mit GIT verwaltet.

Auf jedem Computer hatten wir die PHP-Dateien, aber auch den MySQL-Dienst und einen Ordner mit Bildern, die Benutzer hochladen würden. Der Live-Server hatte ungefähr 100.000 (!) Wiederkehrende Benutzer, der Speicherauszug war ungefähr 2 GB (!), Der Image-Ordner war ungefähr 50 GB (!). Als ich ging, erreichte unser Server das Limit seiner CPU, seines RAM und vor allem das Limit der gleichzeitigen Netzverbindung (wir haben sogar unsere eigene Version des Netzwerkkartentreibers kompiliert, um den Server 'lol' maximal zu nutzen). Wir konnten ( noch sollten Sie nicht mit Ihrer Website annehmen ) nicht 2 GB Daten und 50 GB Bilder in GIT speichern.

Um all dies unter GIT einfach zu verwalten, würden wir die Binärordner (die Ordner mit den Bildern) ignorieren, indem wir diese Ordnerpfade in .gitignore einfügen. Wir hatten auch einen Ordner namens SQL außerhalb des Apache-Dokumentwurzelpfads. In diesem SQL-Ordner würden wir unsere SQL-Dateien von den Entwicklern in inkrementellen Nummerierungen (001.florianm.sql, 001.johns.sql, 002.florianm.sql usw.) ablegen. Diese SQL-Dateien wurden ebenfalls von GIT verwaltet. Die erste SQL-Datei würde tatsächlich einen großen Satz von DB-Schemata enthalten. Wir fügen keine Benutzerdaten in GIT hinzu (z. B. die Datensätze der Benutzertabelle oder der Kommentartabelle), aber Daten wie Konfigurationen oder Topologie oder andere ortsspezifische Daten wurden in den SQL-Dateien (und damit von GIT) verwaltet. Meistens bestimmen die Entwickler (die den Code am besten kennen), was von GIT in Bezug auf SQL-Schema und -Daten verwaltet wird und was nicht.

Bei einer Veröffentlichung meldet sich der Administrator beim Entwickler-Server an, führt den Live-Zweig mit allen Entwicklern und benötigten Zweigen auf dem Entwickler-Computer zu einem Update-Zweig zusammen und überträgt ihn an den Testserver. Auf dem Testserver prüft er, ob der Aktualisierungsprozess für den Live-Server noch gültig ist, und verweist in schneller Folge den gesamten Datenverkehr in Apache auf eine Platzhalter-Site, erstellt einen DB-Speicherauszug und verweist das Arbeitsverzeichnis von "live" auf "update" ', führt alle neuen SQL-Dateien in MySQL aus und leitet den Datenverkehr zurück an die richtige Site. Wenn alle Beteiligten nach Überprüfung des Testservers einverstanden waren, hat der Administrator vom Testserver zum Live-Server dasselbe getan. Anschließend führt er den Live-Zweig auf dem Produktionsserver mit dem Master-Zweig auf allen Servern zusammen und basiert alle Live-Zweige neu.

Wenn es Probleme auf dem Testserver gab, z. Die Zusammenführungen hatten zu viele Konflikte, dann wurde der Code zurückgesetzt (der Arbeitszweig wurde wieder auf "live" gesetzt) ​​und die SQL-Dateien wurden nie ausgeführt. In dem Moment, in dem die SQL-Dateien ausgeführt wurden, wurde dies zu diesem Zeitpunkt als nicht umkehrbare Aktion angesehen. Wenn die SQL-Dateien nicht ordnungsgemäß funktionierten, wurde die Datenbank mithilfe des Speicherauszugs wiederhergestellt (und die Entwickler gaben an, schlecht getestete SQL-Dateien bereitzustellen).

Heute verwalten wir sowohl einen SQL-Up- als auch einen SQL-Down-Ordner mit entsprechenden Dateinamen, in denen die Entwickler testen müssen, ob beide aktualisierten SQL-Dateien gleichermaßen heruntergestuft werden können. Dies könnte letztendlich mit einem Bash-Skript ausgeführt werden, aber es ist eine gute Idee, wenn menschliche Augen den Upgrade-Prozess weiterhin überwachen.

Es ist nicht großartig, aber überschaubar. Ich hoffe, dies gibt einen Einblick in eine reale, praktische Website mit relativ hoher Verfügbarkeit. Sei es ein bisschen veraltet, aber immer noch gefolgt.

Verwenden Sie ein Tool wie iBatis Migrations ( Handbuch , kurzes Tutorial-Video ), mit dem Sie die Änderungen versionieren können Sie an einer Datenbank während des gesamten Lebenszyklus eines Projekts vornehmen, und nicht die Datenbank selbst versionieren können.

Auf diese Weise können Sie einzelne Änderungen selektiv auf verschiedene Umgebungen anwenden, ein Änderungsprotokoll darüber führen, welche Änderungen sich in welchen Umgebungen befinden, Skripts zum Anwenden der Änderungen A bis N, Rollback-Änderungen usw. erstellen.

Ich möchte die gesamte Datenbank unter Versionskontrolle stellen. Welches Datenbankmodul kann ich verwenden, um die eigentliche Datenbank unter Versionskontrolle zu stellen, anstatt ihren Speicherauszug?

Dies ist nicht datenbankmodulabhängig. Von Microsoft SQL Server gibt es viele Versionskontrollprogramme. Ich glaube nicht, dass das Problem mit git gelöst werden kann. Sie müssen ein pgsql-spezifisches Schema-Versionskontrollsystem verwenden. Ich weiß nicht, ob so etwas existiert oder nicht ...

Update 26. August 2019:

Netlify CMS macht es mit GitHub. Eine Beispielimplementierung finden Sie hier mit allen Informationen darüber, wie sie Netlify-cms-backend-github implementiert haben