TOC

Bereitstellen einer Rails-App mit Unicorn und Nginx unter Ubuntu 14.04

Einführung

Wenn Sie bereit sind, Ihre Ruby on Rails-Anwendung bereitzustellen, müssen Sie viele gültige Setups in Betracht ziehen. Dieses Tutorial hilft Ihnen bei der Bereitstellung der Produktionsumgebung Ihrer Ruby on Rails-Anwendung mit PostgreSQL als Datenbank unter Verwendung von Unicorn und Nginx unter Ubuntu 14.04.

Unicorn ist ein Anwendungsserver wie Passenger oder Puma Rails-Anwendung zur gleichzeitigen Verarbeitung von Anforderungen. Da Unicorn nicht für den direkten Zugriff durch Benutzer konzipiert ist, verwenden wir Nginx als Reverse-Proxy, der Anforderungen und Antworten zwischen Benutzern und Ihrer Rails-Anwendung puffert.

Voraussetzungen

In diesem Tutorial wird davon ausgegangen, dass auf dem Benutzer, der die Anwendung bereitstellt, ein Ubuntu 14.04-Server mit der folgenden Software installiert ist:

Wenn Sie das noch nicht eingerichtet haben, folgen Sie den oben verlinkten Tutorials. Wir gehen davon aus, dass Ihr Benutzer * deploy * heißt.

Außerdem wird in diesem Lernprogramm nicht erläutert, wie Sie Ihre Entwicklungs- oder Testumgebungen einrichten. Wenn Sie dabei Hilfe benötigen, folgen Sie dem Beispiel im PostgreSQL with Rails-Tutorial.

Rails-Anwendung erstellen

Idealerweise haben Sie bereits eine Rails-Anwendung, die Sie bereitstellen möchten. In diesem Fall können Sie diesen Abschnitt überspringen und die entsprechenden Ersetzungen vornehmen, während Sie den Anweisungen folgen. Wenn nicht, müssen Sie zunächst eine neue Rails-Anwendung erstellen, die PostgreSQL als Datenbank verwendet.

Dieser Befehl erstellt eine neue Rails-Anwendung mit dem Namen "appname", die PostgreSQL als Datenbank verwendet. Fühlen Sie sich frei, den hervorgehobenen "App-Namen" durch etwas anderes zu ersetzen:

rails new  -d postgresql

Dann wechseln Sie in das Anwendungsverzeichnis:

cd

Nehmen Sie sich einen Moment Zeit, um den PostgreSQL-Benutzer zu erstellen, der von der Produktionsumgebung Ihrer Rails-Anwendung verwendet wird.

Benutzer der Produktionsdatenbank erstellen

Benennen Sie den Benutzer der Produktionsdatenbank mit dem Namen Ihrer Anwendung, um die Sache zu vereinfachen. Wenn Ihre Anwendung beispielsweise "Anwendungsname" heißt, sollten Sie einen PostgreSQL-Benutzer wie folgt erstellen:

sudo -u postgres createuser -s

Wir möchten das Kennwort des Datenbankbenutzers festlegen. Geben Sie die PostgreSQL-Konsole folgendermaßen ein:

sudo -u postgres psql

Legen Sie dann das Kennwort für den Datenbankbenutzer "appname" wie folgt fest:

\password

Geben Sie Ihr gewünschtes Passwort ein und bestätigen Sie es.

Beenden Sie die PostgreSQL-Konsole mit folgendem Befehl:

\q

Jetzt können wir Ihre Anwendung mit den richtigen Datenbankverbindungsinformationen konfigurieren.

Datenbankverbindung konfigurieren

Stellen Sie sicher, dass Sie sich im Stammverzeichnis Ihrer Anwendung befinden (+ cd ~ / +).

Öffnen Sie die Datenbankkonfigurationsdatei Ihrer Anwendung in Ihrem bevorzugten Texteditor. Wir verwenden vi:

vi config/database.yml

Suchen Sie im Abschnitt "+ default +" nach der Zeile "pool: 5" und fügen Sie die folgende Zeile hinzu (falls sie noch nicht vorhanden ist):

 host: localhost

Wenn Sie zum Ende der Datei scrollen, werden Sie feststellen, dass im Abschnitt "+ production" Folgendes festgelegt ist:

 username:
 password: <%= ENV['_DATABASE_PASSWORD'] %>

Wenn Ihr Produktionsbenutzername nicht mit dem zuvor erstellten Datenbankbenutzer übereinstimmt, legen Sie ihn jetzt fest.

Beachten Sie, dass das Datenbankkennwort so konfiguriert ist, dass es von der Umgebungsvariablen "+ _DATABASE_PASSWORD +" gelesen werden kann. Es wird als bewährte Methode angesehen, Produktionskennwörter und -geheimnisse außerhalb Ihrer Anwendungscodebasis zu belassen, da sie leicht verfügbar gemacht werden können, wenn Sie ein verteiltes Versionskontrollsystem wie Git verwenden. Wir werden als nächstes darüber sprechen, wie die Datenbankauthentifizierung mit Umgebungsvariablen eingerichtet wird.

Installieren Sie das rbenv-vars Plugin

Bevor Sie eine Production Rails-Anwendung bereitstellen, sollten Sie den geheimen Produktionsschlüssel und das Datenbankkennwort mithilfe von Umgebungsvariablen festlegen. Eine einfache Möglichkeit, Umgebungsvariablen zu verwalten, mit denen Passwörter und Geheimnisse zur Laufzeit in unsere Anwendung geladen werden können, ist die Verwendung des Plugins * rbenv-vars *.

Um das Plugin rbenv-vars zu installieren, wechseln Sie einfach in das Verzeichnis + .rbenv / plugins + und klonen es von GitHub. Wenn beispielsweise rbenv in Ihrem Ausgangsverzeichnis installiert ist, führen Sie die folgenden Befehle aus:

cd ~/.rbenv/plugins
git clone https://github.com/sstephenson/rbenv-vars.git

Umgebungsvariablen festlegen

Nachdem das Plugin rbenv-vars installiert ist, richten wir die erforderlichen Umgebungsvariablen ein.

Generieren Sie zunächst den geheimen Schlüssel, mit dem die Integrität signierter Cookies überprüft wird:

cd ~/appname
rake secret

Kopieren Sie den generierten geheimen Schlüssel und öffnen Sie die Datei + .rbenv-vars + mit Ihrem bevorzugten Editor. Wir werden vi verwenden:

vi .rbenv-vars

Alle Umgebungsvariablen, die Sie hier festlegen, können von Ihrer Rails-Anwendung gelesen werden.

Stellen Sie zuerst die Variable + SECRET_KEY_BASE + so ein (ersetzen Sie den hervorgehobenen Text durch das Geheimnis, das Sie gerade erzeugt und kopiert haben):

SECRET_KEY_BASE=

Setzen Sie als nächstes die Variable "+ _DATABASE_PASSWORD +" wie folgt (ersetzen Sie das hervorgehobene "APPNAME" durch Ihren Anwendungsnamen und "prod_db_pass" durch Ihr Benutzerpasswort für die Produktionsdatenbank):

_DATABASE_PASSWORD=

Speichern und schließen.

Sie können mit dem Plugin rbenv-vars anzeigen, welche Umgebungsvariablen für Ihre Anwendung festgelegt sind, indem Sie den folgenden Befehl ausführen:

rbenv vars

Wenn Sie Ihr Geheim- oder Datenbankkennwort ändern, aktualisieren Sie Ihre + .rbenv-vars + - Datei. Achten Sie darauf, diese Datei geheim zu halten, und fügen Sie keine öffentlichen Code-Repositorys hinzu.

Produktionsdatenbank erstellen

Nachdem Ihre Anwendung für die Kommunikation mit Ihrer PostgreSQL-Datenbank konfiguriert wurde, erstellen wir die Produktionsdatenbank:

RAILS_ENV=production rake db:create

Controller generieren

Wenn Sie dem Beispiel folgen, werden wir eine Gerüststeuerung generieren, damit unsere Anwendung etwas zu sehen hat:

rails generate scaffold Task title:string note:text

Führen Sie nun diesen Befehl aus, um die Produktionsdatenbank zu aktualisieren:

RAILS_ENV=production rake db:migrate

Assets vorkompilieren

Zu diesem Zeitpunkt sollte die Anwendung funktionieren, aber Sie müssen ihre Assets vorkompilieren, damit alle Bilder, CSS und Skripte geladen werden. Führen Sie dazu den folgenden Befehl aus:

RAILS_ENV=production rake assets:precompile

Anwendung testen

Um zu testen, ob Ihre Anwendung funktioniert, können Sie die Produktionsumgebung ausführen und an die öffentliche IP-Adresse Ihres Servers binden (ersetzen Sie die öffentliche IP-Adresse Ihres Servers):

RAILS_ENV=production rails server --binding=

Besuchen Sie jetzt diese URL in einem Webbrowser:

http://:3000/tasks

Wenn es ordnungsgemäß funktioniert, sollte diese Seite angezeigt werden:

image: https://assets.digitalocean.com/articles/rails_unicorn/tasks.png [Aufgaben-Controller]

Kehren Sie zu Ihrem Rails-Server zurück und drücken Sie "+ Strg-c +", um die Anwendung zu stoppen.

Installieren Sie Unicorn

Jetzt können wir Unicorn installieren.

Eine einfache Möglichkeit, dies zu tun, besteht darin, es der "+ Gemfile +" -Anwendung Ihrer Anwendung hinzuzufügen. Öffnen Sie die Gem-Datei in Ihrem bevorzugten Editor (stellen Sie sicher, dass Sie sich im Stammverzeichnis Ihrer Anwendung befinden):

vi Gemfile

Fügen Sie am Ende der Datei den Unicorn-Edelstein mit der folgenden Zeile hinzu:

gem 'unicorn'

Speichern und schließen.

Führen Sie Bundler aus, um Unicorn und alle ausstehenden Abhängigkeiten zu installieren:

bundle

Unicorn ist jetzt installiert, aber wir müssen es konfigurieren.

Einhorn konfigurieren

Fügen wir unsere Unicorn-Konfiguration zu "+ config / unicorn.rb +" hinzu. Öffnen Sie die Datei in einem Texteditor:

vi config/unicorn.rb

Kopieren Sie diese Konfiguration und fügen Sie sie in die Datei ein:

# set path to application
app_dir = File.expand_path("../..", __FILE__)
shared_dir = "#{app_dir}/shared"
working_directory app_dir


# Set unicorn options
worker_processes 2
preload_app true
timeout 30

# Set up socket location
listen "#{shared_dir}/sockets/unicorn.sock", :backlog => 64

# Logging
stderr_path "#{shared_dir}/log/unicorn.stderr.log"
stdout_path "#{shared_dir}/log/unicorn.stdout.log"

# Set master PID location
pid "#{shared_dir}/pids/unicorn.pid"

Speichern und schließen. Dadurch wird Unicorn mit dem Speicherort Ihrer Anwendung und dem Speicherort der Sockets, Protokolle und PIDs konfiguriert. Sie können die Datei jederzeit ändern oder andere erforderliche Optionen hinzufügen.

Erstellen Sie nun die Verzeichnisse, auf die in der Konfigurationsdatei verwiesen wurde:

mkdir -p shared/pids shared/sockets shared/log

Erstellen Sie ein Unicorn Init Script

Erstellen wir ein Init-Skript, mit dem Unicorn einfach gestartet und gestoppt werden kann, und stellen Sie sicher, dass es beim Booten gestartet wird.

Erstellen Sie ein Skript und öffnen Sie es mit diesem Befehl zum Bearbeiten (ersetzen Sie den hervorgehobenen Teil durch Ihren Anwendungsnamen, wenn Sie dies wünschen):

sudo vi /etc/init.d/unicorn_

Kopieren Sie den folgenden Codeblock und fügen Sie ihn ein. Ersetzen Sie dabei "+ USER n" und "+ APP_NAME" (hervorgehoben) durch die entsprechenden Werte:

#!/bin/sh

### BEGIN INIT INFO
# Provides:          unicorn
# Required-Start:    $all
# Required-Stop:     $all
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: starts the unicorn app server
# Description:       starts unicorn using start-stop-daemon
### END INIT INFO

set -e

USAGE="Usage: $0 <start|stop|restart|upgrade|rotate|force-stop>"

# app settings
USER=""
APP_NAME=""
APP_ROOT="/home/$USER/$APP_NAME"
ENV="production"

# environment settings
PATH="/home/$USER/.rbenv/shims:/home/$USER/.rbenv/bin:$PATH"
CMD="cd $APP_ROOT && bundle exec unicorn -c config/unicorn.rb -E $ENV -D"
PID="$APP_ROOT/shared/pids/unicorn.pid"
OLD_PID="$PID.oldbin"

# make sure the app exists
cd $APP_ROOT || exit 1

sig () {
 test -s "$PID" && kill -$1 `cat $PID`
}

oldsig () {
 test -s $OLD_PID && kill -$1 `cat $OLD_PID`
}

case $1 in
 start)
   sig 0 && echo >&2 "Already running" && exit 0
   echo "Starting $APP_NAME"
   su - $USER -c "$CMD"
   ;;
 stop)
   echo "Stopping $APP_NAME"
   sig QUIT && exit 0
   echo >&2 "Not running"
   ;;
 force-stop)
   echo "Force stopping $APP_NAME"
   sig TERM && exit 0
   echo >&2 "Not running"
   ;;
 restart|reload|upgrade)
   sig USR2 && echo "reloaded $APP_NAME" && exit 0
   echo >&2 "Couldn't reload, starting '$CMD' instead"
   $CMD
   ;;
 rotate)
   sig USR1 && echo rotated logs OK && exit 0
   echo >&2 "Couldn't rotate logs" && exit 1
   ;;
 *)
   echo >&2 $USAGE
   exit 1
   ;;
esac

Speichern und schließen. Auf diese Weise können Sie "+ service unicorn_ +" verwenden, um Ihr Unicorn und Ihre Rails-Anwendung zu starten und zu stoppen.

Aktualisieren Sie die Berechtigungen des Skripts und aktivieren Sie Unicorn für den Start beim Booten:

sudo chmod 755 /etc/init.d/unicorn_appname
sudo update-rc.d unicorn_appname defaults

Beginnen wir jetzt:

sudo service unicorn_ start

Jetzt wird Ihre Rails-Anwendungsproduktionsumgebung unter Unicorn ausgeführt und überwacht den Socket "+ shared / sockets / unicorn.socks". Bevor Ihre Anwendung für einen externen Benutzer zugänglich ist, müssen Sie den Nginx-Reverse-Proxy einrichten.

Installieren und konfigurieren Sie Nginx

Installieren Sie Nginx mit apt-get:

sudo apt-get install nginx

Öffnen Sie nun den Standard-Serverblock mit einem Texteditor:

sudo vi /etc/nginx/sites-available/default

Ersetzen Sie den Inhalt der Datei durch den folgenden Codeblock. Achten Sie darauf, die hervorgehobenen Teile durch den entsprechenden Benutzernamen und Anwendungsnamen zu ersetzen:

upstream app {
   # Path to Unicorn SOCK file, as defined previously
   server unix:/home///shared/sockets/unicorn.sock fail_timeout=0;
}

server {
   listen 80;
   server_name localhost;

   root /home///public;

   try_files $uri/index.html $uri @app;

   location @app {
       proxy_pass http://app;
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header Host $http_host;
       proxy_redirect off;
   }

   error_page 500 502 503 504 /500.html;
   client_max_body_size 4G;
   keepalive_timeout 10;
}

Speichern und schließen. Dadurch wird Nginx als Reverse-Proxy konfiguriert, sodass HTTP-Anforderungen über einen Unix-Socket an den Unicorn-Anwendungsserver weitergeleitet werden. Sie können nach Belieben Änderungen vornehmen.

Starten Sie Nginx neu, damit die Änderungen wirksam werden:

sudo service nginx restart

Jetzt können Sie über die öffentliche IP-Adresse oder den vollqualifizierten Domänennamen Ihres Servers auf die Produktionsumgebung Ihrer Rails-Anwendung zugreifen. Besuchen Sie Ihren Anwendungsserver in einem Webbrowser, um auf den zuvor erstellten Aufgabencontroller zuzugreifen:

http:///tasks

Es sollte dieselbe Seite angezeigt werden, die Sie beim ersten Testen Ihrer Anwendung gesehen haben. Jetzt wird sie jedoch über Nginx und Unicorn bereitgestellt.

Fazit

Herzliche Glückwünsche! Sie haben die Produktionsumgebung Ihrer Ruby on Rails-Anwendung mit Nginx und Unicorn bereitgestellt.

Wenn Sie die Bereitstellung Ihrer Production Rails-Anwendungen verbessern möchten, lesen Sie unsere Tutorial-Reihe unter https://www.digitalocean.com/community/tutorial_series/how-to-use-capistrano-to-automate-deployments[How To Verwenden Sie Capistrano, um Bereitstellungen zu automatisieren. Die Serie basiert auf CentOS, sollte jedoch weiterhin bei der Automatisierung Ihrer Bereitstellungen hilfreich sein.

Related