Schritt-für-Schritt-Anleitung zum Einsatz der Rails-App in DigitalOcean!

Durch Rajan Bhattarai - 9 months and 5 days ago / Oct 2019
Schritt-für-Schritt-Anleitung zum Einsatz der Rails-App in DigitalOcean!

Ursprünglich veröffentlicht am: 2018-02-24. Aktualisiert am: 2019-10-17.


Als ich mit der Erstellung meiner ersten Ruby on Rails-App begann, funktionierte sie hervorragend in der lokalen Entwicklungsumgebung. Die Idee war einfach genug, die App würde den Lebenslauf für den Benutzer generieren und ihn auch herunterladen lassen. Also dachte ich, warum nicht auf dem Produktionsserver bereitstellen?

Es gibt Orte, an denen wir Ihre Ruby on Rails-App kostenlos zur Verfügung stellen können, wie zum Beispiel Heroku. Ich werde den Ort besprechen, an dem ich meine erste App installiert habe: "DigitalOcean".

DigitalOcean

DigitalOcean ist einer der beliebtesten und günstigsten Orte, um Ihre Rails-App zu implementieren. Sie können entweder eine VM erstellen und entweder komplett von Grund auf neu konfigurieren oder Sie können eine Maschine speziell für den gewünschten Zweck erstellen. Zu diesem Zweck habe ich keinen Scratch-Prozess durchlaufen, da ich mit dem Setup-Prozess für nginx- und puma-Server vertraut bin, also habe ich "One-Click-Apps" gewählt. Mit dem "One-Click-Apps"-Prozess können Sie sofort einrichten. Die verfügbaren Anwendungen sind Ruby on Rails, Wordpress, Discourse, phpmyAdmin usw.

Setup-Prozess

1. Um Ihre VM zu konfigurieren, klicken Sie am 16.04. auf Ruby on Rails.

2. Der Standardtropfen wird 1 GB betragen. 1vCPU, 25GB SSD, die 5 $/Monat kostet, was unserem Bedarf entspricht.

3. Sie können jedes Rechenzentrum wählen, das Ihrem Standort am nächsten liegt.

4. Richten Sie zusätzliche Optionen ein und richten Sie Ihre SSH-Schlüssel ein.

5. Wählen Sie schließlich einen Namen für Ihr Tröpfchen und klicken Sie auf die Erstellungsoption.

Dadurch wird schließlich die VM erstellt und Ihnen die IP-Adresse mitgeteilt, von der aus Sie über SSH zugreifen können.

Sobald der Rechner erstellt ist, können wir über SSH darauf zugreifen.

Gehe zu Terminal und Typ ssh-root@IP.

Das führt uns direkt zur Maschine, und wir können den Rubin, die Schienen und andere benötigte Dinge überprüfen.

Bitte stellen Sie sicher, dass Sie Folgendes konfigurieren und installieren können.

1. GIT-Konfiguration

2. SSH-Konfiguration

3. Postgresql-Konfiguration

4. Nginx

5. System-Upgrade

Für diesen Fall habe ich meine SSH-Schlüssel auf github konfiguriert. Sie können dies auch auf bitbucket konfigurieren.

Sobald die SSH-Schlüssel konfiguriert sind, klonen Sie Ihre Anwendung auf die VM, um zu überprüfen, ob unser Setup funktioniert. Sie können dies tun, indem Sie

$ git-Klon git@github.com:username/name-of-the-app.git

Es besteht keine Notwendigkeit, diesen Repo zu behalten, da wir Capistrano für unser Klonen und andere Zwecke verwenden werden.

Unsere eigentliche Arbeit jetzt.

Nachdem wir alles erledigt haben, ist es Zeit, unsere App einzurichten. Wir werden capistrano benutzen...

Fügen Sie dies zu Ihrer Edelsteindatei.

1
2
3
4
5
6
7
8
9
    Gruppe :Entwicklung tun

    Juwel 'Capistrano'.,         erfordern: falsch
    Juwel capistrano-rvm,     erfordern: falsch
    Juwel 'Capistrano-Schienen'.,   erfordern: falsch
    Juwel 'Capistrano-Bündler'., erfordern: falsch
    Juwel capistrano3-puma,   erfordern: falsch

    Ende

Führen Sie aus. $-Bündel installieren um jetzt Edelsteine zu installieren.

Dies tut

1. Erstellt Capfile im Stammpfad des Projekts.

2. entfalten.rb im Konfig-Verzeichnis.

3. deploy-Ordner im config-Verzeichnis.

Nachdem der Edelstein installiert ist, ist es nun an der Zeit, capistrano zu konfigurieren. Führen Sie den folgenden Befehl aus, um capistrano zu konfigurieren.

$ Kappe installieren

Ersetzen Sie den Inhalt der neu generierten Capdatei wie folgt.

1
2
3
4
5
6
7
8
9
10
11
12
13
    # Load DSL And Setup Up Stages
    Require 'Capistrano/Setup'
    Require 'Capistrano/Deploy'

    Require 'Capistrano/Rails'
    Require 'Capistrano/Bundler'
    Require 'Capistrano/Rvm'
    Require 'Capistrano/Puma'

    # Loads Custom Tasks From `Lib/Capistrano/Tasks' If You Have Any Defined.
    Dir.Glob('Lib/Capistrano/Tasks/*.Rake').Each { |R| Import R }

  

Jetzt besteht die Hauptaufgabe darin, die deploy.rb zu konfigurieren, die den Automatisierungsteil übernimmt. Ersetzen Sie die entfalten.rb mit folgendem.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
# Change these
server 'IP', port: 'port', roles: [:web, :app, :db], primary: true

set :repo_url,        'repo location'
set :application,     'app name'
set :user,            'user name in the VM'
set :puma_threads,    [4, 16]
set :puma_workers,    0

# Don't change these unless you know what you're doing
set :pty,             true
set :use_sudo,        false
set :stage,           :production
set :deploy_via,      :remote_cache
set :deploy_to,       "/home/#{fetch(:user)}/apps/#{fetch(:application)}"
set :puma_bind,       "unix://#{shared_path}/tmp/sockets/#{fetch(:application)}-puma.sock"
set :puma_state,      "#{shared_path}/tmp/pids/puma.state"
set :puma_pid,        "#{shared_path}/tmp/pids/puma.pid"
set :puma_access_log, "#{release_path}/log/puma.error.log"
set :puma_error_log,  "#{release_path}/log/puma.access.log"
set :ssh_options,     { forward_agent: true, user: fetch(:user), keys: %w(~/.ssh/id_rsa.pub) }
set :puma_preload_app, true
set :puma_worker_timeout, nil
set :puma_init_active_record, true  # Change to false when not using ActiveRecord

## Defaults:
# set :scm,           :git
# set :branch,        :master
# set :format,        :pretty
# set :log_level,     :debug
# set :keep_releases, 5

## Linked Files & Directories (Default None):
# set :linked_files, %w{config/database.yml}
# set :linked_dirs,  %w{bin log tmp/pids tmp/cache tmp/sockets vendor/bundle public/system}

namespace :puma do
  desc 'Create Directories for Puma Pids and Socket'
  task :make_dirs do
    on roles(:app) do
      execute "mkdir #{shared_path}/tmp/sockets -p"
      execute "mkdir #{shared_path}/tmp/pids -p"
    end
  end

  before :start, :make_dirs
end

namespace :deploy do
  desc "Make sure local git is in sync with remote."
  task :check_revision do
    on roles(:app) do
      unless `git rev-parse HEAD` == `git rev-parse origin/master`
        puts "WARNING: HEAD is not the same as origin/master"
        puts "Run `git push` to sync changes."
        exit
      end
    end
  end

  desc 'Initial Deploy'
  task :initial do
    on roles(:app) do
      before 'deploy:restart', 'puma:start'
      invoke 'deploy'
    end
  end

  desc 'Restart application'
  task :restart do
    on roles(:app), in: :sequence, wait: 5 do
      invoke 'puma:restart'
    end
  end

  before :starting,     :check_revision
  after  :finishing,    :compile_assets
  after  :finishing,    :cleanup
  after  :finishing,    :restart
end

# ps aux | grep puma    # Get puma pid
# kill -s SIGUSR2 pid   # Restart puma
# kill -s SIGTERM pid   # Stop puma

Die wichtigsten zu konfigurierenden oder zu ersetzenden Teile sind

1. Server-IP - zur Verfügung gestellt von DigitalOcean

2. Hafen - 22

3. repo_url – your github/bitbucket url{depends on what you setup earlier for SSH}

4. Anwendung - Name der Anwendung

5. Benutzer - Benutzername in der VM

Sobald all dies abgeschlossen ist, ist es an der Zeit, unsere nginx einzurichten. Erstellen Sie eine Datei nginx.conf im config-Verzeichnis und fügen Sie den folgenden Code hinzu.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
upstream puma {
  server unix:///home/deploy/apps/appname/shared/tmp/sockets/appname-puma.sock;
}

server {
  listen 80 default_server deferred;
  # server_name example.com;

  root /home/deploy/apps/appname/current/public;
  access_log /home/deploy/apps/appname/current/log/nginx.access.log;
  error_log /home/deploy/apps/appname/current/log/nginx.error.log info;

  location ^~ /assets/ {
    gzip_static on;
    expires max;
    add_header Cache-Control public;
  }

  try_files $uri/index.html $uri @puma;
  location @puma {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_redirect off;

    proxy_pass http://puma;
  }

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

Denken Sie daran, dass Sie den Benutzernamen von deploy in Ihren Benutzernamen und Appnamen ändern müssen, und zwar in das, was Sie in der deploy.rb geschrieben haben.

Übertragen Sie alle Änderungen auf den git-Server und führen Sie die Bereitstellung aus als

$ cap Produktion einsetzen:inital

Dies wird je nach Anwendung und Internetverbindung einige Zeit in Anspruch nehmen. Sobald der Vorgang abgeschlossen ist, verbinden Sie Ihren Puma-Webserver mit dem Reverse-Proxy von Nginx.

$ sudo rm /etc/nginx/sites-enabled/default
$ sudo ln -nfs "/home/deploy/apps/apps/appname/current/config/nginx.conf" "/etc/nginx/sites-enabled/appname"

Denken Sie wieder daran, den Namen der Anwendung und den Benutzernamen in den obigen Zeilen zu ersetzen.

Wir starten den nginx-Dienst wieder, und Boom, wir haben unsere App fertig. Gehen Sie mit Ihrer IP-Adresse in den Browser und TADA ist fertig!

Dieses Tutorial wurde inspiriert durch die Bereitstellung Ihrer Ruby on Rails-Anwendung mit nginx, dem Puma-Webserver in DigitalOcean VM.




Rajan Bhattarai
Rajan Bhattarai
Software-Ingenieur nach Werk. Full Stack Ruby on Rails-Entwickler. DevOps und Blockchain.Tech Blogger. Anfragen und Artikel: hello@cdrrazan.com -Rb


Kommentare powered by Disqus