TOC

Bereitstellen von Elixir-Phoenix-Anwendungen mit MySQL unter Ubuntu 16.04

_Der Autor hat Code.org ausgewählt, um eine Spende in Höhe von 300 USD im Rahmen des Programms Write for DOnations zu erhalten. _

Einführung

Im Tutorial https://www.digitalocean.com/community/tutorials/deployment-mit-Destillerie-und-Deliver-on-ubuntu-16-04 automatisierenWie man Elixir Phoenix automatisiert Bereitstellung mit Distillery und edeliver], Sie haben eine Phoenix-Anwendung ohne Datenbank erstellt und auf einem Produktionsserver mit edeliver bereitgestellt. Die meisten realen Anwendungen erfordern eine Datenbank, die einige Änderungen am Bereitstellungsprozess erfordert.

Sie können edeliver verwenden, um Anwendungs- und Datenbankänderungen gleichzeitig auf Ihren Produktionsserver zu übertragen, damit Sie Datenbankänderungen während der Bereitstellung verwalten können.

In diesem Handbuch konfigurieren Sie Ihre vorhandene Phoenix-Anwendung so, dass sie über Phoenix-Ecto und Mariaex eine Verbindung zu einer MySQL-Datenbank herstellt. . Ecto ist ein weit verbreiteter Datenbank-Wrapper für Phoenix-Anwendungen. Mariaex ist ein Datenbanktreiber, der in Ecto integriert ist und mit MySQL- und MariaDB-Datenbanken kommuniziert.

Sie erstellen auch ein einfaches Adressbuch auf Ihrem Entwicklungscomputer, das eine Datenbank verwendet, und verwenden edeliver, um die Änderungen auf Ihrem Produktionsserver bereitzustellen. Benutzer Ihrer Site können Einträge in diesem Adressbuch erstellen, lesen, aktualisieren und löschen.

Voraussetzungen

Um dieses Tutorial abzuschließen, benötigen Sie:

Schritt 1 - Hinzufügen von Mariaex und Ecto zu Ihrer Anwendung

In der Regel stellen Phoenix-Anwendungen keine direkten Verbindungen zu Datenbanken her und führen SQL-Abfragen aus. Stattdessen wird ein Datenbanktreiber verwendet, um eine Verbindung zur gewünschten Datenbank herzustellen, und ein Datenbank-Wrapper wird dann verwendet, um die Datenbank abzufragen.

Ein Datenbanktreiber ist eine Elixir-Anwendung, die sich um die alltäglichen Aufgaben der Verwendung einer Datenbank kümmert, z. B. das Herstellen von Verbindungen, das Schließen von Verbindungen und das Ausführen von Abfragen. Der Datenbank-Wrapper ist eine Schicht über dem Datenbanktreiber, die es Elixir-Programmierern ermöglicht, Datenbankabfragen mit Elixir-Code zu erstellen, und bietet zusätzliche Funktionen wie die Abfragezusammensetzung (Verkettung von Abfragen).

Diese Trennung ermöglicht eine modulare Anwendung. Der Datenbank-Wrapper und damit der Anwendungscode für die Interaktion mit der Datenbank sind unabhängig von der verwendeten Datenbank weitgehend identisch. Durch einfaches Ändern des Datenbanktreibers können Phoenix-Anwendungen eine andere Datenbanksoftware verwenden.

Da Sie beim Erstellen Ihrer Anwendung unter https://www.digitalocean.com/community/tutorials/how-to-automate-elixir-phoenix-deployment-with-destillery-and das Flag "+ - no-ecto +" angegeben haben -edeliver-on-ubuntu-16-04 [vorheriges Tutorial], auf der Anwendung sind weder Ecto noch Mariaex installiert. Sie fügen jetzt Ecto und Mariaex als Abhängigkeiten zu Ihrem Projekt hinzu.

Wechseln Sie zunächst in das Verzeichnis, in dem sich Ihr Phoenix-Projekt befindet.

cd ~/

Öffnen Sie dann die Datei "+ mix.exs +", die die Liste der Abhängigkeiten für Ihre Anwendung enthält.

nano mix.exs

Suchen Sie den folgenden Codeblock:

~ / myproject / mix.exs

 defp deps do
   [
     {:phoenix, "~> 1.3.0"},
     {:phoenix_pubsub, "~> 1.0"},
     {:phoenix_html, "~> 2.10"},
     {:phoenix_live_reload, "~> 1.0", only: :dev},
     {:gettext, "~> 0.11"},
     {:cowboy, "~> 1.0"},
     {:edeliver, "~> 1.4.3"},
     {:distillery, "~> 1.4"}
   ]
 end

Fügen Sie Mariaex und Phoenix-Ecto als Abhängigkeiten hinzu:

~ / myproject / mix.exs

 defp deps do
   [
     {:phoenix, "~> 1.3.0"},
     {:phoenix_pubsub, "~> 1.0"},
     {:phoenix_html, "~> 2.10"},
     {:phoenix_live_reload, "~> 1.0", only: :dev},
     {:gettext, "~> 0.11"},
     {:cowboy, "~> 1.0"},
     {:edeliver, "~> 1.4.3"},
     {:distillery, "~> 1.4"}


   ]
 end

Speichern und schließen Sie + mix.exs +. Führen Sie dann den folgenden Befehl aus, um die Abhängigkeiten herunterzuladen, die Sie gerade zum Projekt hinzugefügt haben.

mix deps.get

Sie sehen diese Ausgabe, wenn Ihre Abhängigkeiten installiert sind:

OutputRunning dependency resolution...
...
* Getting phoenix_ecto (Hex package)
 Checking package (https://repo.hex.pm/tarballs/phoenix_ecto-3.3.0.tar)
 Fetched package
* Getting mariaex (Hex package)
 Checking package (https://repo.hex.pm/tarballs/mariaex-0.8.3.tar)
 Fetched package
...

Die Ausgabe zeigt, dass Mix die Kompatibilität zwischen den Paketen überprüft und die Pakete zusammen mit ihren Abhängigkeiten aus dem Hex-Repository abgerufen hat. Wenn dieser Befehl fehlschlägt, stellen Sie sicher, dass Hex installiert und "+ mix.exs +" korrekt geändert ist.

Mit Ecto und Mariaex können Sie das Ecto-Repository einrichten.

Schritt 2 - Einrichten eines Ecto-Repositorys in Ihrer Anwendung

Phoenix-Anwendungen greifen über einen Datenbank-Wrapper namens Ecto auf die Datenbank zu. Der Datenbank-Wrapper ist in Form eines Elixir-Moduls in Ihrem Projekt implementiert. Sie können dieses Modul jederzeit importieren, wenn Sie mit der Datenbank interagieren und die Funktionen des Moduls verwenden möchten. Die umschlossene Datenbank wird als repository bezeichnet.

Dieses Repository-Modul muss das Makro "+ Ecto.Repo " enthalten, um Zugriff auf die von Ecto definierten Abfragefunktionen zu erhalten. Außerdem muss er den Code enthalten, um die an den Datenbankadapter übergebenen Optionen in einer Funktion mit dem Namen " init +" zu initialisieren.

Wenn Sie beim Erstellen Ihres Phoenix-Projekts nicht das Flag "+ - no-ecto +" verwendet hätten, hätte Phoenix dieses Modul automatisch für Sie generiert. Aber seitdem müssen Sie es selbst erstellen.

Erstellen wir das Modul in einer Datei mit dem Namen "+ repo.ex " im Verzeichnis " lib / +". Erstellen Sie zuerst die Datei:

nano lib//repo.ex

Fügen Sie der Datei den folgenden Code hinzu, um das Repository zu definieren:

~ / myproject / lib / myproject / repo.ex

defmodule .Repo do
 use Ecto.Repo, otp_app: :

 @doc """
 Dynamically loads the repository url from the
 DATABASE_URL environment variable.
 """
 def init(_, opts) do
   {:ok, Keyword.put(opts, :url, System.get_env("DATABASE_URL"))}
 end
end

Standardmäßig definieren Phoenix-Projekte die Funktion "+ init " so, dass Ecto, wenn die Umgebungsvariable " DATABASE_URL +" vorhanden ist, die Konfiguration in der Umgebungsvariablen verwendet, um eine Verbindung zur Datenbank herzustellen, anstatt die Anmeldeinformationen in den Phoenix-Konfigurationsdateien zu verwenden ( wie wir es später in diesem Tutorial tun).

Speichern und schließen Sie "+ repo.ex +".

Phoenix-Projekte verwenden leichte Elixir-Prozesse für Parallelität und Fehlertoleranz. Supervisors verwalten diese Prozesse und starten sie neu, falls sie abstürzen. Supervisoren können auch andere Supervisoren beaufsichtigen, und diese Struktur wird als Überwachungsbaum bezeichnet.

Das soeben hinzugefügte Modul "+ Myproject.Repo +" implementiert einen Supervisor, der Prozesse verwaltet, die eine Verbindung zur Datenbank herstellen. Um diesen Supervisor zu starten, müssen Sie ihn der Supervision-Struktur des Projekts hinzufügen.

Öffnen Sie die Datei "+ application.ex " im Ordner " lib / +".

nano lib//application.ex

Suchen Sie den folgenden Codeblock, der den Überwachungsbaum definiert:

~ / myproject / lib / myproject / application.ex

...
   children = [
     # Start the endpoint when the application starts
     supervisor(.Endpoint, []),
     ...
   ]
...

Sie können sehen, dass der Anwendungsendpunkt "+ MyprojectWeb.Endpoint " als Supervisor gestartet wird. Fügen Sie dieser Liste " Myproject.Repo +" hinzu:

~ / myproject / lib / myproject / myproject.ex

   children = [


     # Start the endpoint when the application starts
     supervisor(MyprojectWeb.Endpoint, []),
     ...
   ]

Wenn Sie diesen Schritt überspringen, erstellt Ecto keine Prozesse für die Interaktion mit der Datenbank und jeder Versuch, mit der Datenbank zu interagieren, führt zum Absturz der Anwendung.

Speichern und schließen Sie "+ application.ex +", bevor Sie fortfahren.

Zuletzt geben Sie das Ecto-Repository in der Anwendungskonfiguration an, damit Sie Mix-Tasks wie "+ ecto.create " und " ecto.migrate +" zum Erstellen und Verwalten Ihrer Datenbank verwenden können.

Öffnen Sie die Konfigurationsdatei unter + config / config.exs +.

nano config/config.exs

Suchen Sie die folgende Zeile am Ende der Datei:

~ / myproject / config / config.exs

import_config "#{Mix.env}.exs"

In dieser Zeile können umgebungsspezifische Konfigurationsdateien wie "+ prod.exs " und " test.exs " die Einstellungen in " config.exs +" bei Bedarf überschreiben. Fügen Sie den folgenden Code * über * dieser Zeile hinzu, um das Ecto-Repository zu konfigurieren:

~ / myproject / config / config.exs

...

config :,
 ecto_repos: [.Repo]
...

Speichern Sie Ihre Änderungen und schließen Sie die Datei.

Nachdem Sie Ecto konfiguriert haben, können Sie der Anwendung Ihre Datenbankanmeldeinformationen hinzufügen.

Schritt 3 - Konfigurieren Ihrer Anwendung mit MySQL-Anmeldeinformationen

Es gibt drei Situationen, in denen Ihre Anwendung eine Verbindung zu einer Datenbank herstellen würde: während der Entwicklung, während des Testens und während der Produktion.

Entsprechend stellt Phoenix drei umgebungsspezifische Konfigurationsdateien zur Verfügung, die Anmeldeinformationen enthalten, die für die Umgebung relevant sind, in der die Anwendung ausgeführt wird. Diese Dateien befinden sich im Verzeichnis "+ config +" im Stammverzeichnis des Projekts. In diesem Schritt ändern Sie diese drei Dateien.

Zuerst konfigurieren wir die Entwicklungsumgebung. Öffne + dev.exs +.

nano config/dev.exs

Fügen Sie die folgenden Zeilen hinzu, um den Datenbankadapter auf "+ Ecto.Adapters.MySQL" zu konfigurieren, da wir MySQL verwenden.

~ / myproject / config / dev.exs

config :, .Repo,
 adapter:

Geben Sie als Nächstes den gewünschten Namen der Datenbank im selben Codeblock an.

~ / myproject / config / dev.exs

config :myproject, Myproject.Repo,
 adapter: Ecto.Adapters.MySQL

Hier definieren wir den Namen der Entwicklungsdatenbank als "+ _dev ". Dies ist eine Namenskonvention, die Phoenix Apps für Datenbanken verwenden. Nach dieser Konvention würde die Produktionsdatenbank " _prod " und die Testdatenbank " _test +" heißen. Sie können stattdessen Ihr eigenes Benennungsschema verwenden.

Geben Sie nun den Hostnamen, den Benutzernamen und das Kennwort für Ihren Entwicklungsdatenbankserver ein.

~ / myproject / config / dev.exs

config :myproject, Myproject.Repo,
 adapter: Ecto.Adapters.MySQL,
 database: "myproject_dev"

Zuletzt stellen Sie die Poolgröße auf eine geeignete Anzahl ein. Die Poolgröße gibt die maximale Anzahl von Verbindungen an, die die Anwendung zur Datenbank herstellen kann. Diese Verbindungen werden über mehrere Anfragen hinweg geteilt. Die optimale Größe hängt von Ihrer Hardware ab, aber Sie können + 10 + zum Starten verwenden.

~ / myproject / config / dev.exs

config :myproject, Myproject.Repo,
 adapter: Ecto.Adapters.MySQL,
 username: "root",
 password: "password",
 database: "myproject_dev",
 hostname: "localhost"

Speichern und schließen Sie + dev.exs +.

Konfigurieren Sie als Nächstes Ihre Testumgebung. Öffnen Sie die Testumgebungskonfigurationsdatei + test.exs +.

nano config/test.exs

In diesem Lernprogramm hosten wir die Testdatenbank neben der Entwicklungsdatenbank auf dem lokalen Datenbankserver. Daher sind die Konfigurationen für die Testdatenbank nahezu identisch.

Anstelle der Poolgröße geben wir jedoch "+ Ecto.Adapters.SQL.Sandbox +" für den Poolwert an. Dadurch werden Tests in einem Sandbox-Modus ausgeführt. Das heißt, alle Transaktionen, die während eines Tests mit der Testdatenbank durchgeführt wurden, werden rückgängig gemacht. Dies bedeutet, dass Komponententests in zufälliger Reihenfolge ausgeführt werden können, da die Datenbank nach jedem Test in den Ausgangszustand zurückgesetzt wird.

Und wir werden "+ myproject_test +" als Datenbanknamen verwenden.

Fügen Sie der Datei + test.exs + die folgende Konfiguration hinzu:

~ / myproject / config / test.exs

config :, .Repo,
 adapter: Ecto.Adapters.MySQL,
 username: "",
 password: "",
 database: "",
 hostname: "",
 pool: Ecto.Adapters.SQL.Sandbox

Speichern und schließen Sie + test.exs +.

Öffnen Sie zum Konfigurieren der Anmeldeinformationen für Ihre Anwendung in der Produktion die geheime Produktionsdatei "+ prod.secret.exs +".

nano config/prod.secret.exs

Fügen Sie diesen Code in die Datei + prod.secret.exs + ein. Beachten Sie, dass wir hier den Benutzernamen * myproject * mit dem Kennwort + password + verwenden. . Dieser Benutzer wird in Kürze mit dem hier angegebenen Kennwort auf dem Produktionsdatenbankserver erstellt. Sie möchten hier ein sichereres Passwort verwenden.

~ / myproject / config / prod.secret.exs

config :, .Repo,
 adapter: Ecto.Adapters.MySQL,
 username: "",
 password: "",
 database: "",
 hostname: "",
 pool_size: 10

Speichern Sie Ihre Änderungen und schließen Sie die Datei.

Diese Datei wird aus Sicherheitsgründen von Git nicht verfolgt, daher müssen Sie sie manuell auf den Server übertragen. Weitere Informationen zu diesem Vorgang finden Sie in Schritt 3 der Voraussetzung https://www.digitalocean.com/community/tutorials/how-to-automate-elixir-phoenix-deployment-with-destillery-and-edeliver-on-ubuntu -16-04 [Tutorial zur Bereitstellung von Phoenix-Anwendungen].

scp ~/myproject/config/prod.secret.exs @:/home//app_config/prod.secret.exs

Rufen Sie dann die Task "+ ecto.create +" Mix auf, um die Entwicklungsdatenbank zu erstellen. Beachten Sie, dass Sie die Testdatenbank nicht erstellen müssen, da Phoenix dies für Sie erledigt, wenn Sie Ihre Tests ausführen.

mix ecto.create

Die folgende Ausgabe zeigt, dass Ecto die Datenbank erfolgreich erstellt hat:

Output...
The database for .Repo has been created

Wenn Sie diese Ausgabe nicht sehen, stellen Sie sicher, dass Ihre Konfigurationsdetails korrekt sind und MySQL ausgeführt wird. Ecto würde sich auch weigern, die Datenbank zu erstellen, wenn Ihre Anwendung aufgrund von Fehlern nicht kompiliert werden kann.

Nachdem Sie das Projekt für die Verbindung mit einer Datenbank eingerichtet und Ecto sogar zum Erstellen einer Datenbank auf dem Entwicklungscomputer verwendet haben, können Sie die Datenbank auf dem Server ändern.

Schritt 4 - Einrichten der Produktionsdatenbank

Mit der Aufgabe "+ ecto.create +` Mix "haben Sie eine leere Datenbank auf Ihrem Entwicklungscomputer erstellt. Jetzt machen Sie dasselbe für Ihren Produktionsserver. Leider gibt es keine Mix-Tasks oder Edeliver-Befehle, um dies zu erreichen. Melden Sie sich daher manuell beim Server an und erstellen Sie mithilfe der MySQL-Konsole eine leere Datenbank mit SQL-Befehlen.

Stellen Sie über SSH eine Verbindung zum Server her.

ssh @

Greifen Sie jetzt auf die MySQL-Konsole zu, indem Sie den Benutzer * root * und das von Ihnen konfigurierte Kennwort verwenden.

mysql -u  -p

Sobald Sie angemeldet sind, erstellen Sie die Produktionsdatenbank:

CREATE DATABASE ;

Die folgende Ausgabe informiert Sie darüber, dass die Datenbank erstellt wurde:

OutputQuery OK, 1 row affected (0.00 sec)

Erstellen Sie als Nächstes einen Benutzer für die App, indem Sie den Benutzernamen * myproject * und das Kennwort verwenden, das Sie im vorherigen Schritt angegeben haben:

CREATE USER ''@'localhost' IDENTIFIED BY '';

Geben Sie dann dem Benutzer * myproject * Zugriff auf die von Ihnen erstellte Datenbank:

GRANT ALL PRIVILEGES ON .* to ''@'localhost';

Wenden Sie abschließend die Berechtigungsänderungen an:

FLUSH PRIVILEGES;

Beenden Sie die MySQL-Konsole, indem Sie "+ exit " eingeben. Beenden Sie die SSH-Verbindung, indem Sie erneut " exit +" eingeben.

Von nun an müssen Sie die Produktionsdatenbank nur noch selten berühren, da Sie fast alle Vorgänge wie das Erstellen und Ändern von Tabellen von Ihrem lokalen Computer aus ausführen.

Wenn die Produktionsdatenbank jetzt bereit ist, können Sie Ihre Anwendung erneut auf dem Server bereitstellen.

Schritt 5 - Bereitstellen des Projekts auf dem Server

In diesem Schritt ersetzen Sie die laufende Anwendung, die keine Verbindung zu einer Datenbank hat, durch Ihre frisch konfigurierte Anwendung und ihr neues Ecto-Repository. Mit diesem Schritt können Sie sicherstellen, dass die Anwendung ordnungsgemäß konfiguriert ist und weiterhin wie erwartet ausgeführt wird.

Öffnen Sie + mix.exs + und erhöhen Sie die Anwendungsversion. Die Versionsnummer erleichtert das Verfolgen von Veröffentlichungen und das Zurücksetzen auf frühere Versionen, falls erforderlich. Es wird auch von edeliver verwendet, um Ihre Anwendung ohne Ausfallzeiten zu aktualisieren.

nano mix.exs

Erhöhen Sie das Versionsfeld auf einen geeigneten Wert.

~ / myproject / mix.exs

 def project do
   [
     app: :myproject,
     version: "",
     elixir: "~> 1.4",
     elixirc_paths: elixirc_paths(Mix.env),
     compilers: [:phoenix, :gettext] ++ Mix.compilers,
     start_permanent: Mix.env == :prod,
     deps: deps()
   ]
 end

Damit edeliver zur Durchführung von Datenbankmigrationen verwendet werden kann, muss edeliver die letzte Anwendung sein, die in Ihrem Projekt gestartet wird. Suchen Sie den folgenden Codeblock:

~ / myproject / mix.exs

 def application do
   [
     mod: {.Application, []},
     extra_applications: [:logger, :runtime_tools]
   ]
 end

Fügen Sie am Ende der Liste "+ extra_applications " " edeliver +" hinzu:

~ / myproject / mix.exs

 def application do
   [
     mod: {.Application, []},
     extra_applications: [:logger, :runtime_tools]
   ]
 end

Speichern und schließen Sie + mix.exs +.

Starten Sie die Anwendung, um sicherzustellen, dass alles funktioniert und keine Kompilierungsfehler auftreten:

mix phx.server

Besuchen Sie http: // localhost: 4000 [http: // localhost: 4000 / address], um sicherzustellen, dass die App weiterhin funktioniert. Wenn es nicht startet oder Kompilierungsfehler auftreten, lesen Sie die Schritte in diesem Lernprogramm und beheben Sie sie, bevor Sie fortfahren.

Wenn alles wie erwartet funktioniert, drücken Sie zweimal auf Ihrem Terminal die Tastenkombination "+ STRG + C +", um den Server anzuhalten.

Übernehmen Sie dann Änderungen mit Git. Sie müssen dies jedes Mal tun, wenn Sie Änderungen an Ihrem Projekt vornehmen, da edeliver Git verwendet, um den Code vom letzten Festschreiben auf den Build-Server zu übertragen und weitere Aktionen auszuführen.

git add .
git commit -m "Configured application with database"

Verwenden Sie schließlich edeliver, um die Anwendung auf dem Produktionsserver zu aktualisieren. Mit dem folgenden Befehl wird die neueste Version Ihres Projekts erstellt und bereitgestellt, bevor die auf dem Produktionscomputer ausgeführte Anwendung ohne Ausfallzeit aktualisiert wird.

mix edeliver upgrade production

Sie sehen die folgende Ausgabe:

OutputEDELIVER MYPROJECT WITH UPGRADE COMMAND

-----> Upgrading to revision 2512398 from branch master
-----> Detecting release versions on production hosts
-----> Deploying upgrades to 1 online hosts
-----> Checking whether installed version 0.0.2 is in release store
-----> Building the upgrade from version 0.0.2
-----> Authorizing hosts
-----> Validating * version 0.0.2 is in local release store
-----> Ensuring hosts are ready to accept git pushes
-----> Pushing new commits with git to: @
-----> Resetting remote hosts to 2512398838c2dcc43de3ccd869779dded4fd5b6b
-----> Cleaning generated files from last build
-----> Checking out 2512398838c2dcc43de3ccd869779dded4fd5b6b
-----> Fetching / Updating dependencies
-----> Compiling sources
-----> Checking version of new release
-----> Uploading archive of release 0.0.2 from local release store
-----> Extracting archive myproject_0.0.2.tar.gz
-----> Removing old releases which were included in upgrade package
-----> Generating release
-----> Removing built release 0.0.2 from remote release directory
-----> Copying release 0.0.3 to local release store
-----> Copying myproject.tar.gz to release store
-----> Upgrading production hosts to version 0.0.3
-----> Authorizing hosts
-----> Uploading archive of release 0.0.3 from local release store
-----> Upgrading release to 0.0.3

UPGRADE DONE!

Obwohl das Upgrade erfolgreich abgeschlossen wurde, können Sie die datenbankbezogenen Edeliver-Tasks erst ausführen, wenn Sie die Anwendung neu starten.

mix edeliver restart production

Sie sehen diese Ausgabe:

OutputEDELIVER  WITH RESTART COMMAND

-----> restarting production servers

production node:

 user    :
 host    :
 path    : /home//app_release
 response: ok

RESTART DONE!

edeliver teilt uns mit, dass der Produktionsserver erfolgreich neu gestartet wurde.

Um sicherzustellen, dass Ihre Anwendung aktualisiert wurde, führen Sie den folgenden Befehl edeliver aus, um die Version der Anwendung abzurufen, die derzeit in der Produktion ausgeführt wird.

mix edeliver version production
OutputEDELIVER MYPROJECT WITH VERSION COMMAND

-----> getting release versions from production servers

production node:

 user    :
 host    :
 path    : /home//app_release
 response:

VERSION DONE!

Die Ausgabe teilt uns mit, dass auf dem Produktionsserver die Anwendungsversion "++" ausgeführt wird.

Sie können Ihre Anwendung auch unter "+ https: // +" aufrufen, um sicherzustellen, dass sie ausgeführt wird. Es sollten keine erkennbaren Änderungen an der Anwendung vorgenommen werden, da wir den Anwendungscode selbst nicht berührt haben.

Wenn das Upgrade erfolgreich ist, die Anwendung jedoch nicht aktualisiert werden kann, stellen Sie sicher, dass Sie Ihren Code festgeschrieben und Ihre Anwendungsversion aktualisiert haben. Wenn der Upgrade-Befehl fehlschlägt, gibt edeliver den Bash-Code, den es auf dem Server ausgeführt hat, als der Fehler auftrat, und die Fehlermeldung selbst aus. Mit diesen Hinweisen können Sie Ihr Problem beheben.

Nachdem Sie Ihrer App Datenbankunterstützung hinzugefügt und sie für die Produktion bereitgestellt haben, können Sie nun einige Funktionen hinzufügen, die MySQL verwenden.

Schritt 6 - Adressbuch erstellen

Erstellen Sie ein einfaches Adressbuch in unserer Anwendung und stellen Sie es für die Produktion bereit, um zu veranschaulichen, wie Sie Datenbankänderungen bereitstellen.

Anstatt den Code für das Adressbuch von Grund auf neu zu schreiben, verwenden wir Phoenix generators, um das Adressbuch zu erstellen. Phoenix-Generatoren sind Dienstprogramme, die Code für eine einfache CRUD-Funktion (Erstellen, Lesen, Aktualisieren, Löschen) generieren. Dies ist ein guter Ausgangspunkt für viele Anwendungsfunktionen, die Sie möglicherweise erstellen möchten.

Das Adressbuch benötigt auch eine Tabelle in der Datenbank, um die Einträge zu speichern. Um diese Tabelle zur Datenbank hinzuzufügen, können Sie eine SQL-Abfrage erstellen und ausführen. Wir verwenden jedoch die Migrationsfunktion von Ecto, um stattdessen die Datenbank zu ändern. Dieser Ansatz hat einige Vorteile. Erstens ist es datenbankunabhängig; Die Befehle sind gleich, unabhängig davon, ob Sie eine PostgreSQL-, MySQL- oder eine andere Datenbank verwenden. Als Nächstes können Sie mithilfe von Migrationsdateien bequem nachverfolgen, wie sich Ihr Datenbankschema im Laufe der Zeit geändert hat. Schließlich können Sie bei Bedarf auch die neuesten Migrationen auf Ihrem Entwicklungscomputer zurücksetzen.

Glücklicherweise müssen Sie keine Migrationsdatei von Grund auf neu schreiben, da Phoenix Generatoren eine für Sie erstellen, sofern nicht anders angegeben.

Um den Generator zu verwenden, geben Sie den Kontext, den Singularnamen der Entität, den Pluralnamen der Entität und alle anderen Felder mit ihren jeweiligen Typen an.

Der * Kontext * ist ein Modul, das Funktionen für verwandte Ressourcen enthält. Wenn Sie beispielsweise vorhaben, eine Liste der Benutzer, die sich auf Ihrer Site angemeldet haben, und ein Sitzungsprotokoll zu führen, wenn sich die Benutzer anmelden, ist es sinnvoll, Benutzer und Sitzungen unter einem einzigen Kontextmodul mit dem Namen "Konto" zu speichern.

Beachten Sie, dass Phoenix gemäß der Konvention den Pluralnamen der Entität als Namen der Datenbanktabelle für diese Ressource annimmt.

Erstellen wir das Adressbuch mit dem Generator. Um das Adressbuch einfach zu halten, enthalten wir nur drei Felder für jeden Datensatz - Name, E-Mail-Adresse und Postleitzahl. Wir bezeichnen jeden Eintrag als "+ Adresse ", mehrere Einträge als " Adressen " und den Kontext, in dem sich das Adressbuch als " Adressbuch +" befinden soll.

Führen Sie diesen Befehl aus, um das Adressbuch zu generieren:

mix phx.gen.html
Output* creating lib/myproject_web/controllers/.ex
...
* creating priv/repo/migrations/_create_address.exs

Add the resource to your browser scope in web/router.ex:

   resources "/",

Remember to update your repository by running migrations:

   $ mix ecto.migrate

Phoenix teilt uns mit, dass die Vorlagendateien, Testdateien, das Modell, der Controller und die Migrationsdatei automatisch generiert wurden. Außerdem werden wir angewiesen, die Ressource der Router-Datei hinzuzufügen und das Repository zu aktualisieren.

Sie könnten den Anweisungen in der Ausgabe folgen, aber auf diese Weise werden Sie das Upgrade des Anwendungscodes und die Datenbankmigration in einer einzigen Version zusammenfassen. Dies kann dazu führen, dass bestimmte Teile der Anwendung in der Produktion vom Zeitpunkt der Bereitstellung der Anwendung auf dem Produktionsserver bis zum Zeitpunkt der Migration der Produktionsdatenbank fehlschlagen. Während dieses Intervalls verweist der Anwendungscode möglicherweise auf nicht vorhandene Tabellen oder Spalten in der Datenbank.

Implementieren Sie die Änderungen in zwei Schritten, um Ausfallzeiten und Fehler zu vermeiden:

  1. Fügen Sie eine Datenbankmigrationsdatei mit den erforderlichen Änderungen an der Datenbank hinzu, ohne den Anwendungscode zu ändern. Erstellen Sie ein Release, aktualisieren Sie den Produktionsserver und migrieren Sie die Produktionsdatenbank.

  2. Nehmen Sie Änderungen am Anwendungscode vor, erstellen Sie dann eine andere Version und stellen Sie sie bereit.

Wenn wir diesen Ansatz nicht wählen, versucht der Code für das Adressbuch, auf die Adresstabelle zu verweisen, die wir noch erstellen müssen, und unsere Anwendung stürzt ab.

Sehen wir uns die Migrationsdatei an, bevor wir die Produktionsdatenbank migrieren. Es befindet sich unter "+ priv / repo / migrations / _create_addresses.exs +", obwohl der Dateiname einen anderen Datumsstempel hat, der davon abhängt, wann Sie ihn erstellt haben. Öffnen Sie die Datei in Ihrem Editor:

nano priv/repo/migrations/*_create_addresses.exs

Die von Phoenix generierte Migrationsdatei ist ein Elixir-Modul mit einer einzigen Funktion namens "+ change +". Wenn Sie die Migration später durchführen, wird diese Funktion aufgerufen.

~ / myproject / priv / repo / migrations / 20180501040548_create_addresses.exs

defmodule Myproject.Repo.Migrations.CreateAddresses do
 use Ecto.Migration

 def change do
   create table(:addresses) do
     add :name, :string
     add :email, :string
     add :zip_code, :integer

     timestamps()
   end

 end
end

In dieser Funktion hat der Phoenix-Generator den Code geschrieben, um die Tabelle "+ Adressen " zusammen mit den von Ihnen angegebenen Feldern zu erstellen. Zusätzlich enthält der Generator die Funktion ` timestamps () `, die zwei weitere Felder für Sie hinzufügt: ` inserted_at ` und ` updated_at +`. Die in diesen Feldern gespeicherten Werte werden automatisch aktualisiert, wenn Sie Daten einfügen oder aktualisieren.

Schließen Sie die Datei, ohne Änderungen vorzunehmen. Der generierte Code ist alles, was Sie brauchen.

Um nur die Migrationsdatei ohne den Anwendungscode bereitzustellen, nutzen wir die Tatsache, dass edeliver Git verwendet, um unser Projekt auf den Build-Server zu übertragen. Insbesondere werden wir die Migrationsdatei nur bereitstellen und festschreiben, während der Rest der generierten Dateien nicht verfolgt wird.

Aber bevor Sie das tun können, erhöhen Sie die Anwendungsversion in + mix.exs +. Edeliver verwendet die Versionsnummer, um sich auf Hot-Upgrades vorzubereiten. Daher müssen Sie die Versionsnummer bei jedem Update erhöhen.

Öffne + mix.exs +.

nano mix.exs

Erhöhen Sie Ihre Anwendungsversion auf einen geeigneten Wert.

~ / myproject / mix.exs

 def project do
   [
     app: :myproject,
     version: "",
     ...

Speichern und schließen Sie die Datei.

Verwenden Sie jetzt Git, um sowohl die Datei "+ mix.exs +" als auch die Migrationsdatei zu inszenieren.

git add mix.exs priv/repo/migrations/*_create_addresses.exs

Übertragen Sie als Nächstes die bereitgestellten Dateien.

git commit -m "Adding addresses table to the database"

Rüsten Sie Ihre Produktionsanwendung mit edeliver auf.

mix edeliver upgrade production

Führen Sie nach Abschluss des Upgrades den folgenden Befehl edeliver aus, um die Produktionsdatenbank zu migrieren.

mix edeliver migrate production

Die Ausgabe zeigt, dass die Migration erfolgreich ausgeführt wurde, und zeigt den Zeitstempel der Migrationsdatei:

OutputEDELIVER  WITH MIGRATE COMMAND

-----> migrateing production servers

production node:

 user    :
 host    :
 path    : /home//app_release
 response: []

MIGRATE DONE!

Die Produktionsdatenbank enthält jetzt eine leere Tabelle mit dem Namen "+ Adressen +".

Das Feld "+ response " würde " [] " anzeigen, wenn keine Migrationen ausgeführt würden. Stellen Sie in diesem Fall sicher, dass Sie Ihren Code mit Git festgeschrieben haben, bevor Sie erneut aktualisieren. Sollte das Problem weiterhin bestehen, starten Sie die Produktionsanwendung neu, indem Sie " mix edeliver restart production +" eingeben, und führen Sie die Datenbankmigrationsaufgabe erneut aus.

Wenn die Tabelle "+ Adressen +" vorhanden ist, können wir die Anweisungen von Phoenix befolgen, als wir das Adressbuch erstellt haben, und eine neue Version erstellen.

Öffnen Sie zuerst die Datei + lib / myproject_web / router.ex +:

nano lib/myproject_web/router.ex

Suchen Sie den folgenden Codeblock:

~ / myproject / lib / myproject_web / router.ex

 scope "/",  do
   pipe_through :browser

   get "/", PageController, :index
 end

Geben Sie die Route für die Ressource "+ Adressen +" ein:

~ / myproject / lib / myproject_web / router.ex

 scope "/",  do
   pipe_through :browser

   get "/", PageController, :index

 end

Speichern und schließen Sie + router.ex +.

Bitten Sie dann Ecto, Änderungen an der lokalen Datenbank vorzunehmen.

mix ecto.migrate

Die Ausgabe zeigt, dass die Funktion in der Migrationsdatei aufgerufen wurde, wodurch die Tabelle "+ Adressen +" erfolgreich erstellt wurde.

Output...
[info] == Running .Repo.Migrations.CreateAddresses.change/0 forward
[info] create table addresses
[info] == Migrated in 0.0s

Starten Sie nun den lokalen Entwicklungsserver, um Ihre neue Funktion zu testen:

mix phx.server

Zeigen Sie mit Ihrem Browser auf http: // localhost: 4000 / address, um die neue Funktion in Aktion zu sehen.

Wenn Sie zufrieden sind, dass die Dinge lokal funktionieren, kehren Sie zu Ihrem Terminal zurück und drücken Sie zweimal STRG + C +, um den Server zu beenden.

Jetzt, da die Dinge funktionieren, können Sie die Änderungen in der Produktion bereitstellen. Öffnen Sie "+ mix.exs +", um die Anwendungsversion zu aktualisieren.

nano mix.exs

Erhöhen Sie das Versionsfeld auf einen geeigneten Wert.

~ / myproject / mix.exs

 def project do
   [
     app: :myproject,
     version: "",
     elixir: "~> 1.4",
     elixirc_paths: elixirc_paths(Mix.env),
     compilers: [:phoenix, :gettext] ++ Mix.compilers,
     start_permanent: Mix.env == :prod,
     deps: deps()
   ]
 end

Speichern und schließen Sie + mix.exs +.

Übernehmen Sie Ihre Änderungen mit Git. Stellen Sie dieses Mal alle Dateien bereit.

git add .
git commit -m "Added application code for address book"

Rüsten Sie die Produktionsanwendung mit edeliver auf.

mix edeliver upgrade production

Wenn das Update abgeschlossen ist, können Sie unter "+ https: /// address +" auf die neue Funktion zugreifen.

Damit haben Sie die Produktionsanwendung und -datenbank erfolgreich aktualisiert.

Fazit

In diesem Artikel haben Sie Ihre Phoenix-Anwendung für die Verwendung einer MySQL-Datenbank konfiguriert und mithilfe von Edeliver- und Ecto-Migrationen Änderungen an der Produktionsdatenbank vorgenommen. Bei dieser Methode müssen Sie die Produktionsdatenbank nicht berühren, und alle Änderungen, die Sie an der Produktionsdatenbank vornehmen möchten, werden über Ecto-Migrationsdateien vorgenommen. Dies erleichtert das Zurücksetzen von Änderungen und das Verfolgen von Änderungen an der Datenbank im Laufe der Zeit.

Weitere Informationen zu Ecto-Migrationen und zum Durchführen komplexer Datenbankmanipulationen finden Sie unter offizielles Ecto-Migrationsdokument.

Related