Introduction

Lors du développement d'une application Ruby on Rails, il se peut que certaines tâches d'application doivent être exécutées de manière asynchrone. Le traitement des données, l'envoi d'e-mails par lots ou l'interaction avec des API externes sont autant d'exemples de travaux qui peuvent être effectués de manière asynchrone avec des travaux en arrière-plan. L'utilisation de travaux en arrière-plan peut améliorer les performances de votre application en déchargeant des tâches potentiellement longues dans une file d'attente de traitement en arrière-plan, libérant ainsi le cycle original de requête/réponse.

Sidekiq est l'un des frameworks de travail en arrière-plan les plus utilisés que vous pouvez implémenter dans une application Rails. Il est soutenu par Redis, un magasin clé-valeur en mémoire connu pour sa flexibilité et ses performances. Sidekiq utilise Redis comme un magasin de gestion de travaux pour traiter des milliers de travaux par seconde.

Dans ce tutoriel, vous allez ajouter Redis et Sidekiq à une application Rails existante. Vous allez créer un ensemble de classes de travailleurs Sidekiq et de méthodes à manipuler :

  • Un téléchargement par lots d'informations sur les requins menacés dans la base de données de l'application à partir d'un fichier CSV dans le référentiel du projet.
  • La suppression de ces données.

Lorsque vous aurez terminé, vous aurez une application de démonstration qui utilise les travailleurs et les travaux pour traiter les tâches de manière asynchrone. Ce sera une bonne base pour vous permettre d'ajouter des travailleurs et des travaux à votre propre application, en utilisant ce tutoriel comme point de départ.

Conditions préalables

Pour suivre ce tutoriel, vous aurez besoin de :

Étape 1 - Clonage du projet et installation des dépendances

Notre première étape consistera à cloner le référentiel rails-bootstrap à partir du compte GitHub de DigitalOcean Community. Ce référentiel comprend le code de la configuration décrite dans le tutoriel Comment ajouter Bootstrap à une application Ruby on Rails, qui explique comment ajouter Bootstrap à un projet Rails 5 existant.

Clonez le référentiel dans un répertoire appelé rails-sidekiq :

  • git clone https://github.com/do-community/rails-bootstrap.git rails-sidekiq

Naviguez vers le répertoire rails-sidekiq :

  • cd rails-sidekiq

Pour travailler avec le code, vous devrez d'abord installer les dépendances du projet, qui sont listées dans son Gemfile. Vous devrez également ajouter le gem sidekiq au projet pour travailler avec Sidekiq et Redis.

Ouvrez le Gemfile du projet pour le modifier en utilisant nano ou votre éditeur préféré :

  • nano Gemfile

Ajoutez le gem n'importe où dans les dépendances principales du projet (au-dessus des dépendances de développement) :

~/rails-sidekiq/Gemfile
. . .
# Reduces boot times through caching; required in config/boot.rb
gem 'bootsnap', '>= 1.1.0', require: false
gem 'sidekiq', '~>6.0.0'

group :development, :test do
. . .

Enregistrez et fermez le fichier lorsque vous avez terminé d'ajouter le gem.

Utilisez la commande suivante pour installer les gems :

  • bundle install

Vous verrez dans la sortie que le gem redis est également installé, cela étant exigé pour sidekiq.

Ensuite, vous allez installer vos dépendances Yarn. Étant donné que ce projet Rails 5 a été modifié pour servir des ressources avec webpack, ses dépendances JavaScript sont maintenant gérées par Yarn. Cela signifie qu'il est nécessaire d'installer et de vérifier les dépendances listées dans le fichier package.json.

Exécutez yarn install pour installer ces dépendances :

  • yarn install

Ensuite, exécutez vos migrations de base de données :

  • rails db:migrate

Une fois vos migrations terminées, vous pouvez tester l'application pour vous assurer qu'elle fonctionne comme prévu. Démarrez votre serveur dans le contexte de votre bundle local avec la commande suivante si vous travaillez localement :

  • bundle exec rails s

Si vous travaillez sur un serveur de développement, vous pouvez démarrer l'application avec :

  • bundle exec rails s --binding=your_server_ip

Naviguez vers localhost:3000 ou http://your_server_ip:3000. Vous verrez la page d'accueil suivante :

Page d'accueil de l'application

Pour créer un requin, cliquez sur le bouton Get Shark Info (Obtenir des informations sur les requins), qui vous amènera à la route sharks/index :

Route sharks/index

Pour vérifier que l'application fonctionne, nous pouvons y ajouter quelques informations de démonstration. Cliquez sur New Shark (Nouveau Requin). Un nom d'utilisateur (sammy) et un mot de passe (shark) vous seront demandés, grâce aux paramètres d'authentification du projet.

Dans la page New Shark (Nouveau Requin), entrez « Great White » (Grand Blanc) dans le champ Name (Nom) et « Scary » (Effrayant) dans le champ Facts (Faits) :

Créer un requin

Cliquez sur le bouton Create Shark (Créer le requin) pour créer le requin. Une fois que vous voyez que votre requin a été créé, vous pouvez tuer le serveur avec CTRL+C.

Vous avez désormais installé les dépendances nécessaires pour votre projet et testé sa fonctionnalité. Ensuite, vous pouvez apporter quelques modifications à l'application Rails pour travailler avec vos ressources concernant les requins menacés.

Étape 2 - Génération d'un contrôleur pour les ressources concernant les requins menacés

Pour travailler avec nos ressources sur les requins menacés, nous allons ajouter un nouveau modèle à l'application ainsi qu'un contrôleur qui contrôlera la manière dont les informations sur les requins menacés sont présentées aux utilisateurs. Notre objectif ultime est de permettre aux utilisateurs de télécharger vers le serveur un grand nombre d'informations sur les requins menacés sans bloquer la fonctionnalité générale de notre application, et de supprimer ces informations lorsqu'ils n'en ont plus besoin.

D'abord, créons un modèle Endangered (Menacés) pour nos requins menacés. Nous allons inclure un champ de chaîne dans notre table de base de données pour le nom du requin, et un autre champ de chaîne pour les catégories de l’Union internationale pour la conservation de la nature (UICN) qui déterminent le degré de risque pour chaque requin.

En fin de compte, la structure de notre modèle correspondra aux colonnes du fichier CSV que nous utiliserons pour créer notre téléchargement par lots. Ce fichier est situé dans le répertoire db, et vous pouvez vérifier son contenu avec la commande suivante :

  • cat db/sharks.csv

Le fichier contient une liste de 73 requins en voie de disparition et leurs statuts : vu pour vulnérables, en pour menacés et cr pour en voie de disparition.

Notre modèle Endangered sera en corrélation avec ces données, ce qui nous permettra de créer de nouvelles instances Endangered à partir de ce fichier CSV. Créez le modèle avec la commande suivante :

  • rails generate model Endangered name:string iucn:string

Ensuite, générez un contrôleur Endangered avec une action index :

  • rails generate controller endangered index

Cela nous donnera un point de départ pour développer les fonctionnalités de notre application, mais nous devrons également ajouter des méthodes personnalisées au fichier de contrôleur que Rails a généré pour nous.

Maintenant, ouvrez ce fichier :

  • nano app/controllers/endangered_controller.rb

Rails nous a fourni un schéma de base que nous pouvons commencer à remplir.

Tout d'abord, nous devons déterminer les routes nécessaires pour travailler avec nos données. Grâce à la commande generate controller, nous disposons d'une méthode index pour commencer. Cela correspondra à une vue index, où nous présenterons aux utilisateurs la possibilité de télécharger vers le serveur des requins menacés.

Toutefois, nous voudrons également traiter les cas où les utilisateurs ont déjà téléchargé les requins et n'ont donc pas besoin d'une option de téléchargement. Nous devrons d'une manière ou d'une autre évaluer combien d'instances de la classe Endangered existent déjà, puisque plus d'une instance indique que le téléchargement par lots a déjà eu lieu.

Commençons par créer une méthode set_endangered private qui récupérera chaque instance de notre classe Endangered dans la base de données. Ajoutez le code suivant au fichier :

~/rails-sidekiq/app/controllers/endangered_controller.rb
class EndangeredController < ApplicationController
  before_action :set_endangered, only: [:index, :data]

  def index
  end

  private

    def set_endangered
      @endangered = Endangered.all
    end

end

Notez que le filtre before_action fera en sorte que la valeur de @endangered ne soit définie que pour les routes index et data, qui seront les endroits où nous traiterons les données sur les requins menacés.

Ensuite, ajoutez le code suivant à la méthode index afin de déterminer le chemin correct pour les utilisateurs qui visitent cette partie de l'application :

~/rails-sidekiq/app/controllers/endangered_controller.rb
class EndangeredController < ApplicationController
  before_action :set_endangered, only: [:index, :data]

  def index          
    if @endangered.length > 0
      redirect_to endangered_data_path
    else
      render 'index'
    end
  end
. . .

S'il y a plus de 0 instance de notre classe Endangered, nous redirigerons les utilisateurs vers la route data, où ils pourront consulter des informations sur les requins qu'ils ont créés. Sinon, ils verront la vue index.

Ensuite, sous la méthode index, ajoutez une méthode data, qui correspondra à une vue data :

~/rails-sidekiq/app/controllers/endangered_controller.rb
. . .
  def index          
    if @endangered.length > 0
      redirect_to endangered_data_path
    else
      render 'index'
    end
  end

  def data
  end
. . .

Ensuite, nous ajouterons une méthode pour gérer le téléchargement des données lui-même. Nous appellerons cette méthode upload, et elle fera appel à une classe de travailleurs Sidekiq et à une méthode pour effectuer le téléchargement des données à partir du fichier CSV. Nous allons créer la définition de cette classe de travailleurs, AddEndangeredWorker, dans la prochaine étape.

Pour l'instant, ajoutez le code suivant au fichier pour appeler le travailleur Sidekiq afin d'effectuer le téléchargement :

~/rails-sidekiq/app/controllers/endangered_controller.rb
. . .
  def data
  end

  def upload
    csv_file = File.join Rails.root, 'db', 'sharks.csv'   
    AddEndangeredWorker.perform_async(csv_file)
    redirect_to endangered_data_path, notice: 'Endangered sharks have been uploaded!'
  end
. . .

En appelant la méthode perform_async sur la classe AddEndangeredWorker et en utilisant le fichier CSV comme argument, ce code garantit que les données du requin et le travail de téléchargement sont transmis à Redis. Les travailleurs de Sidekiq que nous mettrons en place surveilleront la file d'attente des travaux et réagiront lorsque de nouveaux travaux se présenteront.

Après avoir appelé perform_async, notre méthode upload redirige vers le chemin data, où les utilisateurs pourront voir les requins téléchargés.

Ensuite, nous ajouterons une méthode destroy pour détruire les données. Ajoutez le code suivant sous la méthode upload :

~/rails-sidekiq/app/controllers/endangered_controller.rb
. . .
  def upload
    csv_file = File.join Rails.root, 'db', 'sharks.csv'   
    AddEndangeredWorker.perform_async(csv_file)
    redirect_to endangered_data_path, notice: 'Endangered sharks have been uploaded!'
  end

  def destroy
    RemoveEndangeredWorker.perform_async
    redirect_to root_path
  end
. . .

Comme notre méthode upload, notre méthode destroy comprend un appel à perform_async sur une classe RemoveEndangeredWorker - l'autre travailleur Sidekiq que nous allons créer. Après avoir appelé cette méthode, elle redirige les utilisateurs vers le chemin root de l'application.

Le fichier terminé ressemblera à ceci :

~/rails-sidekiq/app/controllers/endangered_controller.rb
class EndangeredController < ApplicationController
  before_action :set_endangered, only: [:index, :data]

  def index          
    if @endangered.length > 0
      redirect_to endangered_data_path
    else
      render 'index'
    end
  end

  def data
  end

  def upload
    csv_file = File.join Rails.root, 'db', 'sharks.csv'   
    AddEndangeredWorker.perform_async(csv_file)
    redirect_to endangered_data_path, notice: 'Endangered sharks have been uploaded!'
  end

  def destroy
    RemoveEndangeredWorker.perform_async
    redirect_to root_path
  end

  private

    def set_endangered
      @endangered = Endangered.all
    end

end

Enregistrez et fermez le fichier lorsque vous avez terminé de le modifier.

Pour terminer la consolidation des routes de notre application, nous allons modifier le code dans config/routes.rb, le fichier où se trouvent nos déclarations de routes.

Maintenant, ouvrez ce fichier :

  • nano config/routes.rb

Actuellement, le fichier ressemble à ceci :

~/rails-sidekiq/config/routes.rb
Rails.application.routes.draw do
  get 'endangered/index'
  get 'home/index'
  resources :sharks do
          resources :posts
  end
  root 'home#index'
  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
end

Nous devrons mettre à jour le fichier pour inclure les routes que nous avons définies dans notre contrôleur : data, upload et destroy. Notre route data correspondra à une requête GET pour récupérer les données sur les requins, tandis que nos itinéraires upload et destroy redirigeront vers des requêtes POST qui téléchargeront et détruiront ces données.

Ajoutez le code suivant au fichier pour définir ces routes :

~/rails-sidekiq/config/routes.rb
Rails.application.routes.draw do
  get 'endangered/index'
  get 'endangered/data', to: 'endangered#data'
  post 'endangered/upload', to: 'endangered#upload'
  post 'endangered/destroy', to: 'endangered#destroy'
  get 'home/index'
  resources :sharks do
          resources :posts
  end
  root 'home#index'
  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
end

Enregistrez et fermez le fichier lorsque vous avez terminé de le modifier.

Maintenant que vous avez mis en place votre modèle Endangered et votre contrôleur, vous pouvez passer à l'étape de définition des classes de travailleurs Sidekiq.

Étape 3 - Définition des travailleurs Sidekiq

Nous avons appelé des méthodes perform_async sur nos travailleurs Sidekiq dans notre contrôleur, mais nous devons encore créer les travailleurs eux-mêmes.

Tout d'abord, créez un répertoire workers pour les travailleurs :

  • mkdir app/workers

Ouvrez un fichier pour le travailleur AddEndangeredWorker :

  • nano app/workers/add_endangered_worker.rb

Dans ce fichier, nous ajouterons un code qui nous permettra de travailler avec les données dans notre fichier CSV. Premièrement, ajoutez du code au fichier qui créera la classe, incluez la bibliothèque CSV Ruby et assurez-vous que cette classe fonctionne comme un travailleur Sidekiq :

~/rails-sidekiq/app/workers/add_endangered_worker.rb
class AddEndangeredWorker
  require 'csv'
  include Sidekiq::Worker
  sidekiq_options retry: false

end

Nous incluons également l'option retry: false pour nous assurer que Sidekiq ne réessaie pas de relancer le téléchargement si celui-ci échoue.

Ensuite, ajoutez le code pour la fonction perform :

~/rails-sidekiq/app/workers/add_endangered_worker.rb
class AddEndangeredWorker
  require 'csv'
  include Sidekiq::Worker
  sidekiq_options retry: false

  def perform(csv_file)
    CSV.foreach(csv_file, headers: true) do |shark|
    Endangered.create(name: shark[0], iucn: shark[1])
  end
 end

end

La méthode perform reçoit des arguments de la méthode perform_async définie dans le contrôleur, il est donc important que les valeurs d'argument correspondent. Ici, nous transmettons csv_file, la variable que nous avons définie dans le contrôleur, et nous utilisons la méthode foreach à partir de la bibliothèque CSV pour lire les valeurs dans le fichier. Définir headers:true pour cette boucle vous garantit que la première ligne du fichier sera traitée comme une ligne d'en-têtes.

Le bloc lit ensuite les valeurs du fichier dans les colonnes que nous avons définies pour notre modèle Endangered : name et iucn. Exécuter cette boucle créera des instances Endangered pour chacune des entrées dans notre fichier CSV.

Une fois que vous avez terminé de le modifier, enregistrez et fermez le fichier.

Ensuite, nous allons créer un travailleur pour gérer la suppression de ces données. Ouvrez un fichier pour la classe RemoveEndangeredWorker :

  • nano app/workers/remove_endangered_worker.rb

Ajoutez le code pour définir la classe, et pour vous assurer qu'il utilise la bibliothèque CSV et fonctionne comme un travailler Sidekiq :

~/rails-sidekiq/app/workers/remove_endangered_worker.rb
class RemoveEndangeredWorker
  include Sidekiq::Worker
  sidekiq_options retry: false

end

Ensuite, ajoutez une méthode perform pour gérer la destruction des données sur les requins menacés :

~/rails-sidekiq/app/workers/remove_endangered_worker.rb
class RemoveEndangeredWorker
  include Sidekiq::Worker
  sidekiq_options retry: false

  def perform
    Endangered.destroy_all
  end

end

La méthode perform appelle destroy_all sur la classe Endangered, elle supprimera toutes les instances de cette classe de la base de données.

Enregistrez et fermez le fichier lorsque vous avez terminé de le modifier.

Une fois vos travailleurs en place, vous pouvez passer à la création d'une mise en page pour vos vues endangered, et de modèles pour vos vues index et data, afin que les utilisateurs puissent télécharger et visualiser les requins menacés.

Étape 4 - Ajout de mises en page et de modèles de vues

Pour que les utilisateurs puissent profiter de leurs informations sur les requins menacés, nous devrons nous occuper de deux choses : la présentation des vues définies dans notre contrôleur endangered, et les modèles de vue pour les vues index et data.

Actuellement, notre application utilise une mise en page pour l'ensemble de l'application, située à l'adresse app/views/layouts/application.html.erb, un fichier partiel pour la navigation et une mise en page pour les vues sharks. La mise en page de l'application vérifie la présence d'un bloc de contenu, ce qui nous permet de charger différentes mises en page en fonction de la partie de l'application à laquelle notre utilisateur s'intéresse : pour la page home index, il verra une mise en page, et pour toute vue relative à un requin en particulier, il en verra une autre.

Nous pouvons réadapter la mise en page sharks à nos vues endangered, car ce format permettra également de présenter les données sur les requins en vrac.

Copiez le fichier de configuration sharks pour créer une mise en page endangered :

  • cp app/views/layouts/sharks.html.erb app/views/layouts/endangered.html.erb

Ensuite, nous allons travailler à créer les modèles de vue pour nos vues index et data.

Ouvrez le modèle index en premier :

  • nano app/views/endangered/index.html.erb

Supprimez le code standard et ajoutez à la place le code suivant, qui donnera aux utilisateurs des informations générales sur les catégories menacées et leur offrira la possibilité de télécharger des informations sur les requins menacés :

~/rails-sidekiq/app/views/endangered/index.html.erb
<p id="notice"><%= notice %></p>

<h1>Endangered Sharks</h1>

<p>International Union for Conservation of Nature (ICUN) statuses: <b>vu:</b> Vulnerable, <b>en:</b> Endangered, <b>cr:</b> Critically Endangered </p>

<br>

  <%= form_tag endangered_upload_path do %>
  <%= submit_tag "Import Endangered Sharks" %>
  <% end %>

  <br>

<%= link_to 'New Shark', new_shark_path, :class => "btn btn-primary btn-sm" %> <%= link_to 'Home', home_index_path, :class => "btn btn-primary btn-sm" %>

Un form_tag rend possible le téléchargement de données en pointant une action post sur endangered_upload_path – la route que nous avons définie pour nos téléchargements. Un bouton créé avec submit_tag invite les utilisateurs à "Import Endangered Sharks" (Importer les requins menacés).

En plus de ce code, nous avons inclus quelques informations générales sur les codes ICUN, afin que les utilisateurs puissent interpréter les données qu'ils verront.

Enregistrez et fermez le fichier lorsque vous avez terminé de le modifier.

Ensuite, ouvrez un fichier pour la vue data :

  • nano app/views/endangered/data.html.erb

Ajoutez le code suivant, qui ajoutera un tableau avec les données sur les requins menacés :

~/rails-sidekiq/app/views/endangered/data.html.erb
<p id="notice"><%= notice %></p>

<h1>Endangered Sharks</h1>

<p>International Union for Conservation of Nature (ICUN) statuses: <b>vu:</b> Vulnerable, <b>en:</b> Endangered, <b>cr:</b> Critically Endangered </p>

<div class="table-responsive">
<table class="table table-striped table-dark">
  <thead>
    <tr>
      <th>Name</th>
      <th>IUCN Status</th>
      <th colspan="3"></th>
    </tr>
  </thead>

  <tbody>
    <% @endangered.each do |shark| %>
      <tr>
        <td><%= shark.name %></td>
        <td><%= shark.iucn %></td>
      </tr>
    <% end %>
  </tbody>
</table>
</div>

<br>

  <%= form_tag endangered_destroy_path do %>
  <%= submit_tag "Delete Endangered Sharks" %>
  <% end %>

  <br>

<%= link_to 'New Shark', new_shark_path, :class => "btn btn-primary btn-sm" %> <%= link_to 'Home', home_index_path, :class => "btn btn-primary btn-sm" %>

Ce code comprend les codes de statut ICUN, une fois de plus, et un tableau Bootstrap pour les données produites. En bouclant notre variable @endangered, nous affichons le nom et le statut ICUN de chaque requin dans le tableau.

Sous le tableau, nous avons un autre ensemble de form_tags et de submit_tags, qui s'affichent sur le chemin destroy en offrant aux utilisateurs la possibilité de "Delete Endangered Sharks" (Supprimer les requins menacés).

Enregistrez et fermez le fichier lorsque vous avez terminé de le modifier.

La dernière modification que nous apporterons à nos vues sera dans la vue index associée à notre contrôleur home. Vous vous souvenez peut-être que cette vue est définie comme la racine de l'application dans le fichier config/routes.rb.

Ouvrez ce fichier pour le modifier :

  • nano app/views/home/index.html.erb

Trouvez la colonne dans la ligne qui indique Sharks are ancient (les requins sont anciens) :

~/rails-sidekiq/app/views/home/index.html.erb
. . .
        <div class="col-lg-6">
            <h3>Sharks are ancient</h3>
            <p>There is evidence to suggest that sharks lived up to 400 million years ago.
            </p>
        </div>
    </div>
</div>

Ajoutez le code suivant au fichier :

~/rails-sidekiq/app/views/home/index.html.erb
. . .
        <div class="col-lg-6">
            <h3>Sharks are ancient and SOME are in danger</h3>
            <p>There is evidence to suggest that sharks lived up to 400 million years ago. Without our help, some could disappear soon.</p>
            <p><%= button_to 'Which Sharks Are in Danger?', endangered_index_path, :method => :get,  :class => "btn btn-primary btn-sm"%>
            </p>
        </div>
    </div>
</div>

Nous avons inclus un appel à l'action pour que les utilisateurs en apprennent davantage sur les requins menacés, en partageant d'abord un message fort, puis en ajoutant un assistant button_to qui soumet une requête GET à notre route endangered index, donnant aux utilisateurs l'accès à cette partie de l'application. À partir de là, ils pourront télécharger et visualiser les informations sur les requins menacés.

Enregistrez et fermez le fichier lorsque vous avez terminé de le modifier.

Avec votre code en place, vous êtes prêt à démarrer l'application et à télécharger quelques requins vers le serveur !

Étape 5 - Démarrage de Sidekiq et test de l'application

Avant de démarrer l'application, nous devrons gérer les migrations sur notre base de données et démarrer Sidekiq pour activer nos travailleurs. Redis devrait déjà être en marche sur le serveur, mais nous pouvons vérifier pour en être sûr. Avec tout cela, nous serons prêts à tester l'application.

D'abord, vérifiez que Redis fonctionne :

  • systemctl status redis

Vous devriez voir une sortie similaire à la suivante :

Output
● redis-server.service - Advanced key-value store Loaded: loaded (/lib/systemd/system/redis-server.service; enabled; vendor preset: enabled) Active: active (running) since Tue 2019-11-12 20:37:13 UTC; 1 weeks 0 days ago

Ensuite, exécutez vos migrations de base de données :

  • rails db:migrate

Vous pouvez maintenant démarrer Sidekiq dans le contexte de notre bundle de projet actuel en utilisant la commande bundle exec sidekiq :

  • bundle exec sidekiq

Vous verrez une sortie comme ceci, vous indiquant que Sidekiq est prêt à traiter les travaux :

Output
m, `$b .ss, $$: .,d$ `$$P,d$P' .,md$P"' ,$$$$$b/md$$$P^' .d$$$$$$/$$$P' $$^' `"/$$$' ____ _ _ _ _ $: ,$$: / ___|(_) __| | ___| | _(_) __ _ `b :$$ \___ \| |/ _` |/ _ \ |/ / |/ _` | $$: ___) | | (_| | __/ <| | (_| | $$ |____/|_|\__,_|\___|_|\_\_|\__, | .d$$ |_| 2019-11-19T21:43:00.540Z pid=17621 tid=gpiqiesdl INFO: Running in ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-linux] 2019-11-19T21:43:00.540Z pid=17621 tid=gpiqiesdl INFO: See LICENSE and the LGPL-3.0 for licensing details. 2019-11-19T21:43:00.540Z pid=17621 tid=gpiqiesdl INFO: Upgrade to Sidekiq Pro for more features and support: http://sidekiq.org 2019-11-19T21:43:00.540Z pid=17621 tid=gpiqiesdl INFO: Booting Sidekiq 6.0.3 with redis options {:id=>"Sidekiq-server-PID-17621", :url=>nil} 2019-11-19T21:43:00.543Z pid=17621 tid=gpiqiesdl INFO: Starting processing, hit Ctrl-C to stop

Ouvrez une deuxième fenêtre de terminal, naviguez vers le répertoire rails-sidekiq, et démarrez votre serveur d'application.

Si vous exécutez l'application localement, utilisez la commande suivante :

  • bundle exec rails s

Si vous travaillez avec un serveur de développement, exécutez ce qui suit :

  • bundle exec rails s --binding=your_server_ip

Naviguez vers localhost:3000 ou http://your_server_ip:3000 dans le navigateur. Vous verrez la page d'accueil suivante :

Accueil Sidekiq App

Cliquez sur le bouton Which Sharks Are in Danger?​​​​​​ (Quels sont les requins menacés ?) . Comme vous n'avez pas téléchargé de requin menacé, cela vous amènera à la vue endangered index :

Vue Endangered Index

Cliquez sur Import Endangered Sharks​​​ (​​Importer des requins menacés) pour importer les requins. Vous verrez un message vous indiquant que les requins ont été importés :

Commencer l'importation

Vous verrez également le début de l'importation. Rafraîchissez votre page pour voir le tableau complet :

Rafraîchir le tableau

Grâce à Sidekiq, notre important téléchargement par lots de requins menacés a réussi sans verrouiller le navigateur ni interférer avec les autres fonctionnalités de l'application.

Cliquez sur le bouton Home (Accueil) en bas de la page, ce qui vous ramènera à la page principale de l'application :

Accueil Sidekiq App

De là, cliquez à nouveau sur Which Sharks Are in Danger? . Cela vous amènera maintenant directement à la vue data, puisque vous avez déjà téléchargé les requins.

Pour tester la fonctionnalité de suppression, cliquez sur le bouton Delete Endangered Sharks (Supprimer les requins menacés) sous le tableau. Vous devriez être redirigé vers la page d'accueil de l'application une fois encore. Cliquez sur Which Sharks Are in Danger?​​​​​ une dernière fois vous renverra à la vue index, où vous aurez la possibilité de télécharger à nouveau des requins :

Vue Endangered Index

Votre application fonctionne maintenant avec les travailleurs Sidekiq en place, qui sont prêts à traiter les travaux et à s'assurer que les utilisateurs ont une bonne expérience en travaillant avec votre application.

Conclusion

Vous disposez désormais d'une application Rails fonctionnelle avec Sidekiq activé, ce qui vous permettra de décharger des opérations coûteuses dans une file d'attente de travail gérée par Sidekiq et soutenue par Redis. Cela vous permettra d'améliorer la vitesse et la fonctionnalité de votre site au fur et à mesure de son développement.

Si vous souhaitez en savoir plus sur Sidekiq, les documents sont un bon point de départ.

Pour en savoir plus sur Redis, consultez notre bibliothèque de ressources Redis. Vous pouvez également en savoir plus sur le fonctionnement d'un cluster Redis géré sur DigitalOcean en consultant la documentation du produit.

0 Comments

Creative Commons License