Guide étape par étape pour le déploiement de l'application Rails dans DigitalOcean !

Par Rajan Bhattarai - 9 months and 5 days ago / Oct 2019
Guide étape par étape pour le déploiement de l'application Rails dans DigitalOcean !

Publié initialement le : 2018-02-24. Mise à jour le : 2019-10-17.


Quand j'ai commencé à faire ma première application Ruby on rails, elle a très bien fonctionné sur l'environnement du développement local. L'idée était assez simple, l'application devait générer le CV pour l'utilisateur et lui permettre de le télécharger. Alors, je me suis dit, pourquoi ne pas déployer un serveur de production ?

Il existe des endroits où nous pouvons déployer gratuitement votre application "Ruby on rails", comme par exemple Heroku. Je vais parler de l'endroit où j'ai déployé ma première application : "DigitalOcean".

DigitalOcean

DigitalOcean est l'un des endroits préférés et bon marché pour déployer votre application de rails. Vous pouvez soit créer une VM et la configurer entièrement à partir de zéro, soit créer une machine spécialement pour l'objectif visé. Pour ce faire, je n'ai pas eu recours à un processus de grattage car je suis familier avec le processus d'installation des serveurs nginx et puma, j'ai donc choisi "One-Click-Apps". Le processus d'application en un clic vous permet de configurer instantanément. Les applications disponibles sont Ruby on Rails, Wordpress, Discourse, phpmyAdmin etc.

Processus de mise en place

1. Pour configurer votre VM, cliquez sur Ruby on Rails le 16.04.

2. La gouttelette standard, sera de 1 Go. 1vCPU, 25GB SSD qui coûtent 5$/mois, ce qui correspond à notre besoin.

3. Vous pouvez choisir n'importe quel centre de données le plus proche de votre lieu de résidence.

4. Configurez des options supplémentaires et configurez vos clés SSH.

5. Enfin, choisissez le nom de votre gouttelette et cliquez sur l'option de création.

Cela permettra enfin de créer la VM et de vous fournir l'adresse IP à partir de laquelle vous pourrez accéder à la VM en utilisant SSH.

Une fois la machine créée, on peut y accéder en utilisant les SSH.

Goto terminal et type ssh root@IP.

Cela nous amène directement à la machine et nous pouvons vérifier le rubis, les rails et d'autres choses nécessaires.

Veuillez vous assurer que vous pouvez configurer et installer les éléments suivants.

1. Configuration GIT

2. Configuration SSH

3. Configuration de Postgresql

4. Nginx

5. Mise à niveau du système

Dans ce cas, j'ai configuré mes clés SSH sur github. Vous pouvez également configurer cette fonction pour bitbucket.

Une fois les clés SSH configurées, clonez votre application sur la VM, pour vérifier si notre configuration fonctionne. Pour ce faire, vous pouvez

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

Il n'est pas nécessaire de conserver cette pension car nous utiliserons le capistrano pour notre clonage et à d'autres fins.

Notre véritable travail maintenant.

Une fois tout cela terminé, il est temps de mettre en place notre application. Nous allons utiliser le capistrano..

Ajoutez ceci à votre Gemfile.

1
2
3
4
5
6
7
8
9
    groupe Développement faire

    gemme capistrano,         exiger : faux
    gemme capistrano-rvm,     exiger : faux
    gemme les "capistrano-rails".,   exiger : faux
    gemme "capistrano-bundler"., exiger : faux
    gemme capistrano3-puma,   exiger : faux

    fin

Courir $ bundle install pour installer des pierres précieuses maintenant.

Cela fait

1. Crée le fichier Capfile dans le chemin racine du projet.

2. déployer.rb dans le répertoire config.

3. déployer le dossier dans le répertoire config.

Après l'installation de la gemme, il est temps de configurer capistrano. Exécutez la commande suivante pour configurer capistrano.

$ cap install

Remplacez le contenu du nouveau fichier capfile comme suit.

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 }

  

La tâche principale consiste maintenant à configurer le fichier deploy.rb qui fait la partie automatisation. Remplacer le déployer.rb avec ce qui suit.

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

Les principales parties à configurer ou à remplacer sont

1. IP du serveur - fourni par DigitalOcean

2. Port - 22

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

4. demande - nom de l'application

5. user - nom d'utilisateur dans la VM

Une fois tout cela terminé, il est temps de mettre en place notre nginx. Créez un fichier nginx.conf dans le répertoire de configuration et ajoutez le code suivant.

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;
}

N'oubliez pas que vous devez changer le nom d'utilisateur de deploy à votre nom d'utilisateur et votre nom d'application à ce que vous avez écrit dans le fichier deploy.rb.

Appuyez sur tous les changements dans le serveur git et lancez le déploiement en tant que

Déploiement d'une production de plafonds en dollars : début

Cela prendra du temps en fonction de votre application et de votre connexion internet. Une fois le processus terminé, connectez votre serveur web Puma au reverse proxy Nginx.

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

N'oubliez pas de remplacer le nom de l'application et le nom d'utilisateur dans les lignes ci-dessus.

Redémarrez le service nginx et Boom, notre application est prête. Allez avec votre adresse IP dans le navigateur et TADA c'est fait !

Ce tutoriel a été inspiré par le déploiement de votre application Ruby on rails en utilisant le serveur web nginx, puma dans DigitalOcean VM.




Rajan Bhattarai
Rajan Bhattarai
Ingénieur logiciel par métier. Développeur Full Stack Ruby on Rails. Blogger de DevOps et Blockchain.Tech. Demandes de renseignements et articles : hello@cdrrazan.com -Rb


commentaires alimentés par Disqus