TOC

Automatisieren der Elixir-Phoenix-Bereitstellung mit Distillery und edeliver unter Ubuntu 16.04

Einführung

Aufbauend auf der Programmiersprache Erlang ist Elixir eine funktionale Programmiersprache, die für ihre Fokussierung auf Entwicklerproduktivität und hohe Benutzerfreundlichkeit bekannt ist gleichzeitige und skalierbare Anwendungen.

Phoenix ist ein auf Elixir basierendes Webframework, mit dem leistungsstarke Webanwendungen erstellt werden können.

In Kombination mit zwei zusätzlichen Tools - Distillery und edeliver - können Sie die Bereitstellung von Phoenix-Projekten aus Ihrer Entwicklung heraus vollständig automatisieren Umgebung zu einem Produktionsserver.

Distillery kompiliert Elixir-Anwendungen in einem einzigen Paket, das Sie an anderer Stelle bereitstellen können. Außerdem werden Pakete generiert, mit denen der Code schnell ausgetauscht werden kann. Dies bedeutet, dass Sie Live-Anwendungen ohne Ausfallzeiten aktualisieren können. All dies kann mit wenig oder gar keiner Konfiguration durchgeführt werden, wodurch sich Distillery von vielen anderen Optionen abhebt.

edeliver automatisiert diesen Erstellungs- und Bereitstellungsprozess, indem sich wiederholende Aufgaben wie das Erstellen der Anwendung, das Übertragen des erstellten Pakets auf den Server, das Migrieren der Datenbank und das Starten / Aktualisieren des Servers erledigt werden. Bei Bedarf können Sie den edeliver auch so konfigurieren, dass auch eine Zwischenbereitstellung möglich ist.

In diesem Lernprogramm installieren Sie Erlang, Elixir und Phoenix 1.3 auf einem lokalen Entwicklungscomputer und auf einem Produktionsserver, vereinfachen die SSH-Kommunikation zwischen den beiden Standorten und erstellen anschließend ein Phoenix-Beispielprojekt zum Erstellen und Verwalten mit edeliver einsetzen. Schließlich sichern Sie den Produktionsserver mit einem Nginx-Reverseproxy und einem SSL-Zertifikat.

Am Ende des Lernprogramms steht Ihnen ein einziger Befehl zur Verfügung, mit dem Sie:

  • Erstellen Sie eine Phoenix-Version, die mit Ihrer Produktionsumgebung kompatibel ist

  • Stellen Sie das Release in Ihrer Produktionsumgebung bereit

  • Starten Sie Ihre Anwendung in einer Produktionsumgebung

  • Tauschen Sie die aktuelle Produktionsversion im laufenden Betrieb aus, indem Sie eine neue Version ohne Ausfallzeiten bereitstellen

Voraussetzungen

Stellen Sie vor dem Start sicher, dass Sie Folgendes haben:

  • Eine Ubuntu-basierte lokale Entwicklungsmaschine. Obwohl die Anweisungen dieses Lernprogramms für einen Ubuntu-basierten lokalen Entwicklungscomputer geschrieben wurden, besteht eine Stärke dieses Bereitstellungsprozesses darin, dass er vollständig unabhängig von der Produktionsumgebung ist. Anweisungen zum Einrichten lokaler Entwicklungscomputer auf anderen Betriebssystemen finden Sie in der offiziellen Elixir-Installationsdokumentation unter https://elixir-lang.org/install.html. Um eine Ubuntu-basierte remote Entwicklungsmaschine einzurichten, folgen Sie this initial server setup tutorial.

  • Ein Nicht-Root-Benutzerkonto mit Sudo-Rechten auf einem Ubuntu 16.04-Produktionsserver mit mindestens 1 GB RAM. Befolgen Sie dazu die ersten vier Schritte unter https://www.digitalocean.com/community/tutorials/initial-server-setup -with-ubuntu-16-04 [dieses Tutorial zur Ersteinrichtung des Servers].

  • Da es unser Ziel ist, den Bereitstellungsprozess zu automatisieren, geben Sie keine SSH-Passphrase ein, wenn Sie Schritt 4 des Setup-Tutorials ausführen. Stellen Sie außerdem sicher, dass Sie in Schritt 7 des Setup-Tutorials den Zugriff auf Port "+ 4000 " mit dem Befehl " sudo ufw allow 4000 +" zulassen. Über diesen Port testen wir Phoenix in diesem Tutorial.

  • Nginx wird auf dem Produktionsserver installiert, indem Sie https://www.digitalocean.com/community/tutorials/how-to-install-nginx-on-ubuntu-16-04 [Anleitung zur Installation von Nginx unter Ubuntu 16.04] befolgen.

  • Ein vollständig registrierter Domainname. In diesem Tutorial wird durchgehend "+ example.com +" verwendet. Sie können einen Domain-Namen unter https://namecheap.com [Namecheap] erwerben, einen kostenlosen unter Freenom erhalten oder den Domain-Registrar Ihrer Wahl verwenden .

  • Die beiden folgenden DNS-Einträge wurden für Ihren Server eingerichtet. Weitere Informationen zum Hinzufügen von Hostnamen finden Sie unter this hostname tutorial.

  • Ein A-Datensatz mit "++", der auf die öffentliche IP-Adresse Ihres Servers verweist.

  • Ein A-Eintrag mit "+ www. +" Verweist auf die öffentliche IP-Adresse Ihres Servers.

  • Nginx wird mit einem SSL-Zertifikat gesichert, indem https://www.digitalocean.com/community/tutorials/how-to-set-up-let-s-encrypt-with-nginx-server-blocks-on-ubuntu-16- 04 [diese Einstellung lassen Sie uns mit Nginx-Server-Blöcken auf Ubuntu 16.04-Tutorial verschlüsseln]. Stellen Sie sicher, dass Sie in Schritt 4 des Nginx-Setup-Tutorials die Option 2 "+ Weiterleiten +" auswählen, da dies automatische Weiterleitungen zu HTTPS auf dem Produktionsserver ermöglicht, den wir in diesem Tutorial erstellen.

Schritt 1 - Elixir und Phoenix auf dem lokalen Entwicklungscomputer installieren

Da Elixir auf der Erlang-VM ausgeführt wird, müssen wir die VM installieren, bevor wir Elixir selbst installieren können. Und da wir sicherstellen möchten, dass wir die neueste stabile Version von Erlang verwenden, installieren wir Erlang aus dem Erlang Solutions-Repository.

Laden Sie zunächst das Erlang Solutions-Repository herunter und fügen Sie es Ihrem lokalen Entwicklungscomputer hinzu.

cd ~
wget https://packages.erlang-solutions.com/erlang-solutions_1.0_all.deb
sudo dpkg -i erlang-solutions_1.0_all.deb

Aktualisieren Sie jetzt Ihre Paketliste und installieren Sie das Paket + esl-erlang +, das sowohl die Erlang-Programmiersprache als auch nützliche Tools, Bibliotheken und Middleware enthält, die zusammen als Erlang / OTP-Plattform bezeichnet werden.

sudo apt-get update
sudo apt-get install esl-erlang

Dann installieren Sie Elixir.

sudo apt-get install elixir

Verwenden Sie als Nächstes Mix - ein mit Elixir gebündeltes Build-Tool zum Erstellen von Elixir-Projekten und zum Verwalten von Abhängigkeiten -, um Elixirs eigenen Paketmanager Hex zu installieren, den Sie später zum Installieren von Phoenix verwenden werden.

Der + local + Teil dieses Befehls weist Mix an, + hex + lokal zu installieren.

mix local.hex

Wenn Sie aufgefordert werden, die Installation zu bestätigen, geben Sie "+ Y +" ein.

OutputAre you sure you want to install "https://repo.hex.pm/installs/1.5.0/hex-0.17.1.ez"? [Yn]
* creating .mix/archives/hex-0.17.1

Installieren Sie nun mit Hex das Phoenix 1.3.0 Mix-Archiv, eine Zip-Datei, die alles enthält, was Sie zum Generieren eines neuen Phoenix-Basisprojekts zum Erstellen benötigen.

mix archive.install https://github.com/phoenixframework/archives/raw/master/phx_new-1.3.0.ez

Wenn Sie erneut aufgefordert werden, die Installation zu bestätigen, geben Sie "+ Y +" ein.

OutputAre you sure you want to install "https://github.com/phoenixframework/archives/raw/master/phx_new-1.3.0.ez"? [Yn]
* creating .mix/archives/phx_new-1.3.0

Wenn Elixir und Phoenix auf der lokalen Entwicklungsmaschine installiert sind, installieren wir die benötigten Teile auf dem Produktionsserver.

Schritt 2 - Elixir und Phoenix auf dem Produktionsserver installieren

Da unser Phoenix-Projekt sowohl auf dem lokalen Entwicklungscomputer als auch auf dem Produktionsserver ausgeführt werden muss, müssen an beiden Stellen dieselben Sprachen und Tools installiert werden.

Verwenden Sie die gleichen Befehle aus dem Link: # step-1-% E2% 80% 94-Installation-Elixier-und-Phoenix-auf-der-lokalen-Entwicklungsmaschine [Schritt 1], laden Sie das Erlang Solutions-Repository herunter und fügen Sie es Ihrem hinzu Produktionsserver.

cd ~
wget https://packages.erlang-solutions.com/erlang-solutions_1.0_all.deb
sudo dpkg -i erlang-solutions_1.0_all.deb

Aktualisieren Sie Ihre Paketliste und installieren Sie das Paket + esl-erlang +.

sudo apt-get update
sudo apt-get install esl-erlang

Installieren Sie Elixir.

sudo apt-get install elixir

Verwenden Sie Mix, um Hex zu installieren.

mix local.hex

Wenn Sie aufgefordert werden, die Installation zu bestätigen, geben Sie "+ Y +" ein.

OutputAre you sure you want to install "https://repo.hex.pm/installs/1.5.0/hex-0.17.1.ez"? [Yn]
* creating .mix/archives/hex-0.17.1

Sowohl die lokale Entwicklungsmaschine als auch der Produktionsserver können jetzt Phoenix ausführen. Erleichtern Sie jedoch die Verbindung von der lokalen Entwicklungsmaschine zum Produktionsserver, indem Sie einen SSH-Host-Alias ​​einrichten.

Schritt 3 - Einrichten eines SSH-Host-Alias

Da unser Ziel ein vollständig automatisierter Bereitstellungsprozess ist, haben wir während der Verknüpfung ein SSH-Schlüsselpaar generiert: #voraussetzungen [Erstinstallation des Produktionsservers], bei dem keine Passphrase abgefragt wird.

Momentan können wir mit dem Befehl + ssh -i ~ / .ssh / @ + eine Verbindung von der lokalen Entwicklungsmaschine zum Produktionsserver herstellen.

Hier verbinden wir uns mit "+ example.com " als Benutzer "* sammy *". Das Flag " -i " weist SSH an, die private Schlüsseldatei unter " ~ / .ssh / private_key_file +" für die Verbindung zu verwenden.

Wir können diesen Befehl - und den Bereitstellungsprozess selbst - noch einfacher gestalten, indem wir einen SSH-Host-Alias ​​einrichten, der automatisch erkennt, welcher private Schlüssel, welcher Benutzer und welche Domäne beim Herstellen einer Verbindung zum Produktionsserver verwendet werden sollen.

Öffnen Sie "+ ~ / .ssh / config +" auf dem lokalen Entwicklungsrechner zum Bearbeiten.

nano ~/.ssh/config

Kopieren Sie die folgenden Zeilen.

~ / .ssh / config

Host
   HostName
   User
   IdentityFile

Die Zeile "+ Host " enthält einen Alias, der diese spezielle Konfiguration identifiziert. Zur besseren Erinnerung verwenden wir unseren Domain-Namen. Die Zeile ` HostName ` teilt SSH mit, mit welchem ​​Host eine Verbindung hergestellt werden soll. Die Zeile " User " informiert SSH darüber, unter welchem ​​Benutzer eine Verbindung hergestellt werden soll, und die Zeile " IdentityFile +" teilt SSH mit, welche private Schlüsseldatei verwendet werden soll.

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

Testen Sie abschließend die Konfiguration, indem Sie eine Verbindung zum Produktionsserver herstellen.

ssh

Sie hätten die Verbindung herstellen können, ohne einen Benutzer, eine private Schlüsseldatei oder eine Domäne anzugeben. Wenn Sie keine Verbindung herstellen konnten, befolgen Sie die Bildschirmmeldungen und führen Sie die vorherigen Schritte erneut aus, um das Problem zu beheben.

Nachdem wir die Verbindung zum Produktionsserver vereinfacht haben, können wir ein Phoenix-Beispielprojekt für die Bereitstellung erstellen.

Schritt 4 - Erstellen eines Testprojekts

Wenn Sie ein neues Phoenix-Projekt erstellen, wird es standardmäßig mit einem PostgreSQL -Datenbankadapter und Brunch, einer JavaScript-basierten Webanwendungserstellung, konfiguriert Werkzeug. Um diese zusätzliche Komplexität zu vermeiden, erstellen wir ein einfaches Phoenix-Projekt mit dem Namen "+ myproject " ohne Datenbankadapter und ohne Brunch, indem wir die Flags " - no-ecto " und " - no-brunch +" übergeben.

Wechseln Sie in Ihr Home-Verzeichnis und erstellen Sie das neue Projekt.

cd ~
mix phx.new --no-ecto --no-brunch

Die Ausgabe enthält die Verzeichnisse und Dateien, die Phoenix als Gerüst für das Projekt "+ myproject +" erstellt hat, eine Aufforderung zur Bestätigung, dass Sie die erforderlichen Abhängigkeiten installieren möchten, und Anweisungen zum Starten des integrierten Phoenix-Servers.

Geben Sie "+ Y +" ein, wenn Sie aufgefordert werden, die Installation zu bestätigen.

Output* creating myproject/config/config.exs
* creating myproject/config/dev.exs
* creating myproject/config/prod.exs
...

Fetch and install dependencies? [Yn]
* running mix deps.get
* running mix deps.compile

We are all set! Go into your application by running:

   $ cd myproject

Start your Phoenix app with:

   $ mix phx.server

You can also run your app inside IEx (Interactive Elixir) as:

   $ iex -S mix phx.server

Nun wollen wir sehen, ob unser Testprojekt funktioniert.

Gehen Sie in das Verzeichnis "+ myproject " und führen Sie den Befehl " mix phx.server +" aus, um das Projekt zu kompilieren und den Server zu starten.

cd ~/myproject
mix phx.server

Die Ausgabe informiert Sie über die Anzahl und den Typ der von Phoenix kompilierten Dateien, gibt Warnungen zu Problemen aus, die auf dem Weg aufgetreten sind, und zeigt Ihnen bei Erfolg an, wo Sie das Projekt erreichen können.

Wenn Sie zum ersten Mal eine Elixir-basierte Anwendung auf Ihrem lokalen Entwicklungscomputer kompilieren, werden Sie aufgefordert, Rebar zu installieren, ein Build- und Abhängigkeitstool für Erlang, auf das Mix angewiesen ist. Geben Sie an der Eingabeaufforderung "+ Y +" ein.

Output==> file_system
Compiling 6 files (.ex)
Generated file_system app
...
Could not find "rebar3", which is needed to build dependency :ranch
I can install a local copy which is just used by Mix
Shall I install rebar3? (if running non-interactively, use "mix local.rebar --force") [Yn]
...
Compiling 11 files (.ex)
Generated myproject app
[info] Running MyprojectWeb.Endpoint with Cowboy using http://0.0.0.0:4000

Zeigen Sie zum Testen des aktuellen Setups mit Ihrem Webbrowser auf http: // localhost: 4000. Sie sollten die standardmäßige Phoenix Framework-Homepage sehen, die Sie bei Phoenix begrüßt. Wenn Sie dies nicht tun, vergewissern Sie sich, dass Ihre Firewall Verbindungen über den Port "+ 4000 +" zulässt, und überprüfen Sie anschließend die Ausgabe Ihres Terminals auf weitere Anweisungen.

Sobald Sie überprüft haben, dass alles funktioniert, drücken Sie zweimal die Tastenkombination "+ STRG + C +", um den Server anzuhalten, damit er für die weitere Konfiguration in Link bereit ist: # step-5-% E2% 80% 94-configuration-the-project-to -verwenden-Sie-Brennerei-und-Edeliver [Schritt 5].

Nachdem Sie ein voll funktionsfähiges, lokales Phoenix-Projekt haben, können Sie es für die Verwendung von Distillery und edeliver konfigurieren.

Schritt 5 - Konfigurieren des Projekts für die Verwendung von Distillery und Edeliver

In Phoenix-Projekten werden Konfigurationsdetails wie der Port, auf dem das Projekt ausgeführt wird, und die Host-URL des Projekts in "+ config / prod.exs +" gespeichert. Bearbeiten Sie daher zunächst diese Datei, um Phoenix mitzuteilen, wie das Projekt in der Produktionsumgebung erreicht werden soll.

Öffnen Sie "+ config / prod.exs +" auf Ihrem lokalen Entwicklungsrechner zum Bearbeiten.

nano ~/myproject/config/prod.exs

Suchen Sie den folgenden Codeblock:

config / prod.exs

...
config :myproject, MyprojectWeb.Endpoint,
 load_from_system_env: true,
 url: [host: "example.com", port: 80],
 cache_static_manifest: "priv/static/cache_manifest.json"
...

Wenn + load_from_system_env + auf + true + gesetzt ist, ruft Phoenix den Port, auf dem das Projekt ausgeführt werden soll, standardmäßig von der Umgebungsvariablen + PORT + ab. Dies wird als HTTP-Port bezeichnet.

Die + url: [host] + und + url: [port] + werden verwendet, um Links innerhalb des Projekts zu generieren. Dieser Unterschied zwischen HTTP und URL ist besonders hilfreich, wenn Sie Proxys einrichten, bei denen der Proxy-Endpunkt an einem anderen Port als im Phoenix-Projekt verfügbar ist.

Der Einfachheit halber wird der HTTP-Port, auf dem "+ myproject +" ausgeführt wird, fest codiert. Dies reduziert die Anzahl der beweglichen Teile, was wiederum die Zuverlässigkeit unseres automatisierten Bereitstellungsprozesses erhöht.

Zusätzlich zu den Standardoptionen, die wir ändern, werden wir auch zwei neue Optionen hinzufügen.

Die Option "+ Server +" weist Distillery an, das Projekt so zu konfigurieren, dass der HTTP-Server beim Start gestartet wird. Dies ist das Ziel eines vollautomatisierten Bereitstellungsprozesses.

Die Option "+ code_reloader +" weist das Projekt an, alle verbundenen Webbrowser zu aktualisieren, wenn sich der Code des Projekts ändert. Dies kann eine sehr hilfreiche Funktion in der Entwicklung sein, ist jedoch nicht für Produktionsumgebungen gedacht. Wir werden sie daher deaktivieren.

Ändern Sie nun die Standardkonfiguration.

config / prod.exs

...
config :myproject, MyprojectWeb.Endpoint,

 url: [host: "", port: 80],
 cache_static_manifest: "priv/static/manifest.json"


...

Speichern und schließen Sie "+ config / prod.exs +", sobald Sie Ihre Änderungen vorgenommen haben.

Als wir das Projekt "+ myproject " im Link "# step-4-% E2% 80% 94-create-a-test-project" [Schritt 4] erstellt haben, hat Phoenix automatisch eine " .gitignore +" - Datei generiert, die wir erstellen werden Need In Link: # Schritt-6-% E2% 80% 94-Konfiguration-Edeliver-und-Destillerie [Schritt 6], wenn wir Codeänderungen mit Edeliver auf den Build-Server übertragen.

Standardmäßig weist diese "+ .gitignore " - Datei Git an, Abhängigkeiten zu ignorieren und Dateien zu erstellen, damit das Repository nicht unnötig groß wird. Außerdem weist diese Datei Git an, " prod.secret.exs " zu ignorieren. Diese Datei befindet sich im Verzeichnis " config +" aller Phoenix-Projekte und enthält sehr vertrauliche Informationen, z. B. Kennwörter der Produktionsdatenbank und Anwendungsgeheimnisse für das Signieren von Token.

Da für das Projekt "+ myproject " " prod.secret.exs +" auf dem Produktionsserver erforderlich ist und wir es mit Git nicht dorthin verschieben können, müssen wir es manuell auf den Server übertragen.

Erstellen Sie in Ihrem Ausgangsverzeichnis auf dem Produktionsserver ein neues Verzeichnis mit dem Namen "+ app_config ". Hier wird ` prod.secret.exs` gespeichert.

cd ~
mkdir app_config

Verwenden Sie nun "+ scp ", um " prod.secret.exs " in das Verzeichnis " app_config +" auf dem Produktionsserver zu kopieren.

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

Überprüfen Sie abschließend, ob die Übertragung stattgefunden hat, indem Sie den Inhalt von "+ app_config +" auf dem Produktionsserver auflisten.

ls ~/app_config

Wenn in der Ausgabe nicht "+ prod.secret.exs +" angezeigt wird, überprüfen Sie das Terminal auf Ihrem lokalen Entwicklungscomputer auf weitere Informationen.

Mit "+ prod.secret.exs " auf dem Produktionsserver können wir Distillery für den Erstellungsprozess und Edeliver für die Bereitstellung installieren, indem wir beide in " mix.exs ", die Hauptkonfigurationsdatei für " myproject +", aufnehmen `Projekt.

Öffnen Sie "+ mix.exs +" auf Ihrem lokalen Entwicklungscomputer.

nano ~/myproject/mix.exs

Suchen Sie nun den folgenden Codeblock:

Abhängigkeiten in 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"}
   ]
 end
 ...

+ deps + ist eine private Funktion, die explizit alle Abhängigkeiten unseres + myproject + Projekts definiert. Dies ist zwar nicht unbedingt erforderlich, hilft jedoch dabei, die Projektkonfiguration zu organisieren.

Fügen Sie der Liste der Abhängigkeiten "+ edeliver " und " distillery +" hinzu.

Abhängigkeiten in 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"}


   ]
 end
 ...

Speichern Sie Ihre Änderungen und schließen Sie + mix.exs +.

Sagen Sie nun "+ mix +", dass die neuen Abhängigkeiten abgerufen werden sollen, damit sie zur Laufzeit verfügbar sind.

cd ~/myproject/
mix deps.get

Die Ausgabe sagt uns, dass "+ edeliver " und " distillery +" erfolgreich zu unserem Projekt hinzugefügt wurden.

OutputResolving Hex dependencies...
Dependency resolution completed:
 ...
* Getting edeliver (Hex package)
 Checking package (https://repo.hex.pm/tarballs/edeliver-1.4.4.tar)
 Fetched package
* Getting distillery (Hex package)
 Checking package (https://repo.hex.pm/tarballs/distillery-1.5.2.tar)
 Fetched package

Starten Sie abschließend den Phoenix-Server auf dem lokalen Entwicklungscomputer neu, um die aktuelle Konfiguration zu testen.

mix phx.server

Zeigen Sie mit Ihrem Browser auf http: // localhost: 4000. Sie sollten dieselbe Standard-Phoenix-Homepage sehen, die Sie im Link gesehen haben: # step-4-% E2% 80% 94-create-a-test-project [Step 4]. Wenn dies nicht der Fall ist, verfolgen Sie die vorherigen Schritte erneut und überprüfen Sie das Terminal Ihres lokalen Entwicklungscomputers auf zusätzliche Informationen.

Wenn Sie fortfahren möchten, drücken Sie zweimal die Tastenkombination "+ STRG + C +", um den Server anzuhalten, damit er im nächsten Schritt für die weitere Konfiguration bereit ist.

Wenn Distillery und edeliver installiert sind, können Sie diese für die Bereitstellung konfigurieren.

Schritt 6 - Edeliver und Distillery konfigurieren

Distillery benötigt eine Build-Konfigurationsdatei, die nicht standardmäßig generiert wird. Wir können jedoch eine Standardkonfiguration erstellen, indem Sie "+ mix release.init +" ausführen.

Wechseln Sie auf Ihrem lokalen Entwicklungsrechner in das Verzeichnis "+ myproject +" und generieren Sie die Konfigurationsdatei.

cd ~/myproject
mix release.init

Die Ausgabe bestätigt, dass die Datei erstellt wurde, und enthält weitere Anweisungen zum Bearbeiten und Erstellen der Version.

OutputAn example config file has been placed in rel/config.exs, review it,
make edits as needed/desired, and then run `mix release` to build the release

edeliver sucht nach Releases im Verzeichnis + rel / +, wenn Hot-Upgrades durchgeführt werden, Distillery legt Releases jedoch standardmäßig im Verzeichnis + _build + ab. Ändern wir also die Standardkonfigurationsdatei von Distillery, + rel / config.exs +, um die Produktionsversionen an der richtigen Stelle zu platzieren.

Öffne + rel / config.exs + in deinem Editor.

nano rel/config.exs

Suchen Sie den folgenden Abschnitt:

rel / config.exs

...
environment :prod do
 set include_erts: true
 set include_src: false
 set cookie: :"f3a1[Q^31~]3~N=|T|T=0NvN;h7OHK!%%c.}$)iP9!X|TS[X@sqG=m`yBYVt4/`:"
end
...

Dieser Block teilt Distillery mit, wie eigenständige Release-Pakete für die Produktion erstellt werden sollen. + include_erts + gibt an, ob das Erlang-Laufzeitsystem gebündelt werden soll. Dies ist hilfreich, wenn auf dem Zielsystem Erlang oder Elixir nicht installiert ist. + include_src + gibt an, ob die Quellcodedateien eingeschlossen werden sollen. Der Wert "+ cookie +" wird verwendet, um Erlang-Knoten für die Kommunikation miteinander zu authentifizieren.

Schließen Sie die Datei.

Wir sind jetzt bereit, den Edeliver zu konfigurieren, müssen jedoch die Konfigurationsdatei manuell erstellen.

Wechseln Sie auf Ihrem lokalen Entwicklungscomputer in das Verzeichnis "+ myproject " und erstellen Sie ein neues Verzeichnis mit dem Namen " .deliver ". Öffnen Sie dann eine neue Datei unter " .deliver / config +" zum Bearbeiten.

cd ~/myproject
mkdir .deliver
nano .deliver/config

In dieser Datei geben wir die Details zu Build- und Produktionsservern an. Da wir sowohl für das Erstellen als auch für die Produktion denselben Server verwenden, sind Host und Benutzer in Build und Produktion identisch. Zusätzlich führen wir den Build im Verzeichnis "+ app_build " durch und platzieren die kompilierten Produktionsdateien im Verzeichnis " app_release +".

Kopieren Sie Folgendes in die Datei.

deliver/config
APP=""

BUILD_HOST=""
BUILD_USER=""
BUILD_AT="/home//app_build"

PRODUCTION_HOSTS=""
PRODUCTION_USER=""
DELIVER_TO="/home//app_release"

Als nächstes erstellen wir einen Symlink im Build-Ordner zu "+ prod.secret.exs ", der Datei, die wir in das " app_config " -Verzeichnis auf dem Produktionsserver übertragen haben: # step-5-% E2% 80% 94-das-projekt-für-die-verwendung-von-brennerei-und-edeliver-konfigurieren [schritt 5]. Dieser Symlink wird in einem _edeliver hook_ erstellt. Zu jedem Zeitpunkt im Erstellungs-, Phasen- und Bereitstellungsprozess wird ein bestimmter Hook von edeliver aufgerufen. Bei unserem Setup für die automatische Bereitstellung hören wir uns den Hook " pre_erlang_get_and_update_deps +" an, der aufgerufen wurde, bevor edeliver unsere Abhängigkeiten abruft und mit der Kompilierung beginnt.

Fügen Sie Folgendes an + .deliver / config + an.

deliver/config
pre_erlang_get_and_update_deps() {
 local _prod_secret_path="/home//app_config/prod.secret.exs"
 if [ "$TARGET_MIX_ENV" = "prod" ]; then
   __sync_remote "
     ln -sfn '$_prod_secret_path' '$BUILD_AT/config/prod.secret.exs'
   "
 fi
}

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

Da edeliver Git verwendet, um den Code vom letzten Festschreiben an den Buildserver weiterzuleiten, besteht der letzte Schritt vor der Bereitstellung darin, ein Git-Repository für unser Projekt zu erstellen.

Verwenden Sie im Verzeichnis "+ myproject " auf Ihrem lokalen Entwicklungscomputer den Befehl " git init +", um ein leeres Git-Repository zu erstellen.

cd ~/myproject
git init

Bevor wir unsere Dateien zum Git-Index hinzufügen, müssen wir das Verzeichnis, das unsere Release-Tarballs enthält, auch zur Datei + .gitignore + hinzufügen. Andernfalls würde das Git-Repository nach einigen Releases sehr groß werden.

echo ".deliver/releases/" >> .gitignore

Fügen Sie als Nächstes den vollständigen Satz von Dateien aus dem Projekt "+ myproject +" zum Git-Staging-Bereich hinzu, damit sie in das nächste Commit einbezogen werden.

git add .

Stellen Sie nun die Identität ein, die Git diesem Repository zuordnen soll. Auf diese Weise können Sie nachverfolgen, woher Änderungen an Ihrem Projekt stammen.

git config user.email ""
git config user.name ""

Übertragen Sie die Dateien abschließend mit der Option "+ -m +" in das Repository, um den Grund für die Übertragung zu beschreiben.

git commit -m "Setting up automated deployment"

Die Ausgabe wiederholt Ihre Festschreibungsnachricht und meldet dann die Anzahl der geänderten Dateien, die Anzahl der eingefügten Zeilen und die Namen der Dateien, die dem Repository hinzugefügt wurden.

Output[master (root-commit) e58b766] Setting up automated deployment
39 files changed, 2344 insertions(+)
create mode 100644 .deliver/config
...

Nachdem unser Projekt nun vollständig für Git and Distillery und edeliver konfiguriert ist, können wir es zum ersten Mal bereitstellen.

Schritt 7 - Bereitstellen des Projekts

Ein Vorteil dieses Bereitstellungsprozesses besteht darin, dass Sie fast alles auf dem lokalen Entwicklungscomputer ausführen und selten den Produktionsserver berühren müssen.

Lassen Sie uns jetzt alles aus myproject herausholen, indem Sie das Projekt "+ myproject +" auf den Produktionsserver übertragen.

Verwenden Sie zuerst "+ mix +" auf Ihrem lokalen Entwicklungscomputer, um ein Release des Projekts zu erstellen und es mit edeliver auf den Build-Server zu übertragen.

cd ~/myproject
mix edeliver build release

Die Ausgabe aktualisiert Sie in Echtzeit über jeden Schritt des Erstellungsprozesses und zeigt Ihnen, wenn alles wie erwartet funktioniert, an, dass die Erstellung erfolgreich war.

OutputBUILDING RELEASE OF MYPROJECT APP ON BUILD HOST

-----> Authorizing hosts
-----> Ensuring hosts are ready to accept git pushes
-----> Pushing new commits with git to:
-----> Resetting remote hosts to fc86f878d96...
-----> Cleaning generated files from last build
-----> Fetching / Updating dependencies
-----> Compiling sources
-----> Generating release
-----> Copying release 0.0.1 to local release store
-----> Copying myproject.tar.gz to release store

RELEASE BUILD OF MYPROJECT WAS SUCCESSFUL!

Wenn Ihr Build nicht erfolgreich war, gibt edeliver die Codezeile an, die ausgeführt werden sollte, als das Problem auftrat. Mithilfe dieser Informationen können Sie das Problem beheben.

Übertragen Sie die Freigabe nach Abschluss des Builds auf den Produktionsserver.

mix edeliver deploy release to production

Die Ausgabe aktualisiert Sie erneut in Echtzeit über jeden Schritt des Prozesses und informiert Sie, wenn alles funktioniert, über die Freigabe des Builds für die Produktion.

OutputDEPLOYING RELEASE OF MYPROJECT APP TO PRODUCTION HOSTS

-----> Authorizing hosts
-----> Uploading archive of release 0.0.1 from local release store
-----> Extracting archive myproject.0.1.tar.gz

DEPLOYED RELEASE TO PRODUCTION!

Wenn bei der Bereitstellung Probleme auftreten, überprüfen Sie die Ausgabe in Ihrem Terminal auf zusätzliche Informationen.

Starten Sie abschließend das Projekt "+ myproject +" auf dem Produktionsserver.

mix edeliver start production

In der Ausgabe wird dem Benutzer mitgeteilt, dass das Projekt als, der Host, auf dem es ausgeführt wird, und der Pfad zu dem Release, das auf dem Produktionsserver verwendet wird. Die Antwort lautet "+ START DONE! +".

OutputEDELIVER MYPROJECT WITH START COMMAND

-----> starting production servers

production node:

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

START DONE!

Testen Sie den Bereitstellungsprozess, indem Sie Ihren Browser auf "+ http: //: 4000 " zeigen. Sie sollten wieder die Standard-Homepage von Phoenix Framework sehen. Wenn Sie dies nicht tun, überprüfen Sie noch einmal, ob der Port " 4000 +" auf dem Produktionsserver geöffnet ist, und wenden Sie sich dann an das Terminal des lokalen Entwicklungscomputers, um weitere Informationen zu erhalten.

Nachdem wir den vollständigen Erstellungs- und Bereitstellungsprozess überprüft haben, gehen wir noch einen Schritt weiter und führen eine Code-Aktualisierung ohne Ausfallzeiten auf dem Produktionsserver durch.

Schritt 8 - Aktualisieren des Projekts ohne Produktionsausfall

Ein Merkmal unseres Erstellungs- und Bereitstellungsprozesses ist die Möglichkeit, den Code im laufenden Betrieb auszutauschen und das Projekt auf dem Produktionsserver ohne Ausfallzeiten zu aktualisieren. Nehmen wir einige Änderungen am Projekt vor, um dies auszuprobieren.

Öffnen Sie die Homepage-Datei des Projekts zur Bearbeitung.

nano ~/myproject/lib/myproject_web/templates/page/index.html.eex

Suchen Sie die folgende Zeile:

~ / myproject / web / templates / page / index.html.eex

...
<h2><%= gettext "Welcome to %{name}", name: "Phoenix!" %></h2>
...

Ersetzen Sie diese Zeile nun durch Folgendes:

<h2>Hello, World!</h2>

Speichern und schließen Sie die Datei.

Nachdem wir die Codebasis aktualisiert haben, müssen wir auch die Anwendungsversion erhöhen. Die Versionsnummer erleichtert das Nachverfolgen von Veröffentlichungen und gegebenenfalls das Zurücksetzen auf frühere Versionen.

Öffnen Sie "+ mix.exs +" auf Ihrem lokalen Entwicklungscomputer.

nano ~/myproject/mix.exs

Suchen Sie den folgenden Block:

mix.exs

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

Erhöhe die Version von + 0.0.1 + auf + 0.0.2 +.

mix.exs

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

Speichern und schließen Sie dann die Datei.

Jetzt müssen wir unsere Änderungen zu Git hinzufügen und festschreiben, damit edeliver weiß, dass sie auf den Build-Server übertragen werden sollen.

git add .
git commit -m "Changed welcome message"

Endlich sind wir bereit, unsere Änderungen im laufenden Betrieb auszutauschen. Dieses Mal haben wir einen einzigen Befehl, der den drei in Verbindung stehenden Befehlen entspricht, die wir im Link verwendet haben: # step-7-% E2% 80% 94-deploying-the-project [Step 7].

Erstellen, implementieren und starten Sie die Anwendung mit einem Befehl auf dem Produktionsserver.

mix edeliver upgrade production

Die Ausgabe führt uns erneut in Echtzeit durch jeden Schritt des Prozesses und endet bei Erfolg mit "+ UPGRADE DONE! +".

OutputEDELIVER MYPROJECT WITH UPGRADE COMMAND

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

UPGRADE DONE!

Um zu überprüfen, ob alles funktioniert hat, laden Sie + http: //: 4000 + in Ihrem Browser neu. Sie sollten die neue Nachricht sehen. Wenn dies nicht der Fall ist, verfolgen Sie die vorherigen Schritte erneut und überprüfen Sie Ihr Terminal auf zusätzliche Fehler- und Warnmeldungen.

Der Bereitstellungsprozess wurde jetzt auf einen einzigen Befehl reduziert, und wir nutzen auch eine der bekanntesten Funktionen von Erlang - den Code-Hot-Swap. Lassen Sie uns abschließend unsere Anwendung in der Produktion stärken, indem Sie sie hinter einen Nginx-Proxy stellen.

Schritt 9 - Einrichten eines Reverse-Proxys auf dem Produktionsserver

Obwohl wir unsere Anwendung direkt dem Internet zugänglich machen können, bietet ein Reverse-Proxy eine bessere Sicherheit. Zur Vereinfachung der Konfiguration, zur Unterstützung von SSL und zum Festlegen benutzerdefinierter HTTP-Antwortheader verwenden wir Nginx als Proxy.

Wenn Sie den https://www.digitalocean.com/community/tutorials/how-to-set-up-let-s-encrypt-with-nginx-server-blocks-on-ubuntu-16-04 Einstellungen gefolgt sind Lassen Sie uns unter den Voraussetzungen mit Nginx-Serverblöcken in Ubuntu 16.04 verschlüsseln. Sie sollten bereits einen separaten Nginx-Serverblock auf dem Produktionsserver nur für unser Projekt erstellt haben.

Öffnen Sie die Konfigurationsdatei dieses Serverblocks zum Bearbeiten.

sudo nano /etc/nginx/sites-available/

Zuerst müssen wir Nginx mitteilen, wo sich unser Phoenix-Projekt befindet und auf welchem ​​Port es lauscht. Da wir unser Projekt auf Port "+ 4000 +" lokal bereitstellen, teilen wir Nginx mit, dass sich unser Proxy-Endpunkt auf "+127.0.0.1: 4000 +" befindet.

Kopieren Sie den folgenden Code in die Konfigurationsdatei über dem Standard-Serverkonfigurationsblock.

/etc/nginx/sites-available/example.com

upstream phoenix {
   server 127.0.0.1:4000;
}

Suchen Sie nun in derselben Datei den folgenden Codeblock:

/etc/nginx/sites-available/example.com

   ...
       location / {
               # First attempt to serve request as file, then
               # as directory, then fall back to displaying a 404.
               try_files $uri $uri/ =404;
       }
   ...

Damit der Proxy funktioniert, müssen wir Nginx anweisen, alle Verbindungen zum Webserver an unser Phoenix-Projekt umzuleiten, einschließlich des Anforderungsheaders, der IP-Adresse des Servers, über den der Client weitergeleitet wurde, und der IP-Adresse des Clients selbst.

Wir werden Nginx auch so konfigurieren, dass eingehende Anfragen über WebSockets weitergeleitet werden, ein Protokoll für den Nachrichtenaustausch zwischen Webservern und Clients, mit dem das Upgrade durchgeführt wird Standard zustandslose HTTP-Verbindung zu einer dauerhaften.

Phoenix hat eine Funktion namens "Channels", die wir in diesem Lernprogramm nicht untersucht haben. Für Channels ist jedoch Unterstützung für WebSockets erforderlich. Ohne diese Konfiguration funktionieren Channels nicht, da WebSocket-Anforderungen nicht auf den Server gelangen.

Ersetzen Sie den vorherigen + location + Block durch den folgenden:

/etc/nginx/sites-available/example.com

 location / {
   allow all;

   # Proxy Headers
   proxy_http_version 1.1;
   proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
   proxy_set_header Host $http_host;
   proxy_set_header X-Cluster-Client-Ip $remote_addr;

   # WebSockets
   proxy_set_header Upgrade $http_upgrade;
   proxy_set_header Connection "upgrade";

   proxy_pass http://phoenix;
 }

Speichern und schließen Sie die Datei, um fortzufahren.

Überprüfen Sie nun die neue Nginx-Konfiguration.

sudo nginx -t

Nginx sollte melden, dass die Syntax in Ordnung ist und der Test erfolgreich war. Wenn nicht, befolgen Sie die Anweisungen auf dem Bildschirm, um das Problem zu beheben.

Starten Sie Nginx neu, um die Änderungen zu übernehmen.

sudo systemctl restart nginx

Aus Sicherheitsgründen sollten Sie den Zugriff auf Ihre Anwendung über HTTP an Port "+ 4000 +" nicht zulassen.

sudo ufw delete allow 4000

Überprüfen Sie dann den UFW-Status.

sudo ufw status

Die Firewall sollte zu diesem Zeitpunkt nur SSH- und Nginx-Zugriff zulassen.

OutputStatus: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
Nginx Full                 ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
Nginx Full (v6)            ALLOW       Anywhere (v6)

Testen Sie abschließend, ob alles funktioniert, indem Sie Ihren Browser auf "+ https: // +" zeigen.

Sie verfügen jetzt über einen vollautomatisierten Erstellungs- und Bereitstellungsprozess und einen Produktionsserver, der sowohl durch einen Reverse-Proxy als auch durch ein SSL-Zertifikat geschützt ist.

Fazit

Obwohl wir edeliver so eingerichtet haben, dass unser Phoenix-Projekt mit einem einzigen Befehl auf einem Produktionsserver erstellt und bereitgestellt werden kann, können Sie noch viel mehr tun.

Die meisten Produktionsanwendungen von Phoenix verwenden eine Datenbank. Unter https://www.digitalocean.com/community/tutorials/anwendungen-mit-mysql-auf-ubuntu-16-04-einstellen-von-elixir-Phoenix-Anwendungen mit MySQL auf Ubuntu 16.04] arbeiten Sie mit dieser Anwendung weiter, während Sie eine MySQL-Datenbank hinzufügen und der Produktion neue Funktionen bereitstellen.

Wenn Ihre Produktionsinfrastruktur aus einem Cluster von Phoenix-Knoten besteht, können Sie edeliver verwenden, um alle Knoten gleichzeitig bereitzustellen und Hot-Swapping durchzuführen.

Wenn Sie ein zuverlässigeres Setup wünschen, können Sie eine umfassende Staging-Infrastruktur erstellen und edeliver zum Verwalten des Staging- und Bereitstellungsprozesses verwenden.

Weitere Informationen zu diesen Themen oder zur allgemeinen Erweiterung Ihrer aktuellen Edeliver-Installation finden Sie unter official home on GitHub.

Related