Sidekiq und Redis einer Ruby-on-Rails-Anwendung hinzufügen

Einführung

Bei der Entwicklung einer Ruby-on-Rails-Anwendung stellen Sie möglicherweise fest, dass Sie Anwendungsaufgaben haben, die asynchron ausgeführt werden sollten. Die Verarbeitung von Daten, das Versenden von Batch-E-Mails oder die Interaktion mit externen APIs sind Beispiele für Arbeiten, die asynchron mit Hintergrundjobs durchgeführt werden können. Die Verwendung von Hintergrundjobs kann die Leistung Ihrer Anwendung verbessern, indem möglicherweise zeitintensive Aufgaben in eine Hintergrundverarbeitungs-Warteschlange ausgelagert werden, wodurch der ursprüngliche Anfrage-/Antwort-Zyklus entlastet wird.

Sidekiq ist eines der am häufigsten verwendeten Hintergrundjob-Frameworks, das Sie in einer Rails-Anwendung implementieren können. Es wird von Redis unterstützt, einem In-Memory-Schlüsselwertspeicher, der für seine Flexibilität und Leistung bekannt ist. Sidekiq verwendet Redis als Aufgabenmanagementspeicher, um pro Sekunde Tausende von Aufgaben zu verarbeiten.

In diesem Tutorial fügen Sie Redis und Sidekiq zu einer bestehenden Rails-Anwendung hinzu. Sie werden einen Satz von Sidekiq Worker-Klassen und -Verfahren erstellen, um Folgendes zu bewältigen:

• Einen Batch-Upload von Informationen über bedrohte Haie in die Anwendungsdatenbank aus einer CSV-Datei im Projekt-Repository.
• Die Entfernung dieser Daten.

Wenn Sie fertig sind, haben Sie eine Demo-Anwendung, die Workers und Jobs verwendet, um Aufgaben asynchron zu verarbeiten. Dieses Tutorial ist ein guter Startpunkt, damit Sie später Worker und Jobs zu Ihrer eigenen Anwendung hinzufügen können.

Voraussetzungen

Um dieser Anleitung zu folgen, benötigen Sie:

• Einen lokalen Rechner oder einen Entwicklungsserver, auf dem Ubuntu 18.04. ausgeführt wird. Ihr Entwicklungsrechner sollte über einen non-root user mit Administratorberechtigungen und eine mit ufw konfigurierte Firewall verfügen. Anleitungen zur Einrichtung finden Sie in unserem Tutorial Ersteinrichtung des Servers unter Ubuntu 18.04.
• Auf Ihrem lokalen Rechner oder dem Entwicklungsserver installiertes Node.js und npm. Dieses Tutorial verwendet Node.js Version 10.17.0 und npm Version 6.11.3. Eine Anleitung zur Installation von Node.js und npm unter Ubuntu 18.04 finden Sie im Abschnitt „Installation unter Verwendung eines PPA“ in “Installieren von Node.js unter Ubuntu 18.04”.
• Den auf Ihrem lokalen Rechner oder dem Entwicklungsserver installierten Paketmanager Yarn. Sie können den Installationsanweisungen in der offiziellen Dokumentation folgen.
• Auf Ihrem lokalen Rechner oder dem Entwicklungsserver gemäß den Schritten 1-4 von “Installieren von Ruby-on-Rails mit rbenv unter Ubuntu 18.04” installiertes Ruby, rbenv und Rails. Dieses Tutorial verwendet Ruby 2,5.1, rbenv 1.1.2 und Rails 5.2.3.
• Nach dem Schritt 1 von „Erstellen einer Ruby-on-Rails-Anwendung“ installiertes SQLite. Dieses Tutorial verwendet SQLite 3 3.22.0.
• Nach den Schritten 1–3 von „Installieren und Sichern von Redis unter Ubuntu 18.04.“ installiertes Redis. Dieses Tutorial verwendet Redis 4.0.9.

Schritt 1 – Klonen des Projekts und Installieren von Abhängigkeiten

Unser erster Schritt besteht darin, das Repository rails-bootstrap aus dem DigitalOcean Community GitHub-Konto zu klonen. Dieses Repository enthält den Code aus dem Setup, das in „Hinzufügen von Sidekiq und Redis zu einer Ruby-on-Rails-Anwendung“ beschrieben wird. Dort wird erklärt, wie Bootstrap zu einem bestehenden Rails 5-Projekt hinzugefügt wird.

Klonen Sie das Repository in ein Verzeichnis namens rails-sidekiq:

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

Navigieren Sie zum Verzeichnis rails-sidekiq:

cd rails-sidekiq

Um mit dem Code arbeiten zu können, müssen Sie zunächst die Abhängigkeiten des Projekts installieren, die in seiner Gemfile aufgelistet sind. Um mit Sidekiq und Redis arbeiten zu können, müssen Sie dem Projekt auch das Gem sidekiq hinzufügen.

Öffnen Sie das Gemfile des Projekts zur Bearbeitung mit nano oder Ihrem bevorzugten Editor:

nano Gemfile

Fügen Sie das Gem an beliebiger Stelle in die Abhängigkeiten des Hauptprojekts ein (oberhalb der Entwicklungsabhängigkeiten):

. . .
# 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
. . .

Speichern und schließen Sie die Datei, wenn Sie mit dem Hinzufügen des Gems fertig sind.

Verwenden Sie den folgenden Befehl, um die Gems zu installieren:

bundle install

Sie werden in der Ausgabe sehen, dass das Gem redis auch als Erfordernis für sidekiq installiert ist.

Als Nächstes installieren Sie Ihre Yarn-Abhängigkeiten. Da dieses Rails 5-Projekt modifiziert wurde, um Assets mit webpack bereitzustellen, werden seine JavaScript-Abhängigkeiten nun von Yarn verwaltet. Das bedeutet es ist notwendig, die in der Datei package.json des Projekts aufgeführten Abhängigkeiten zu installieren und zu verifizieren.

Führen Sie yarn install aus, um diese Abhängigkeiten zu installieren:

yarn install

Führen Sie als Nächstes Ihre Datenbankmigration durch:

rails db:migrate

Sobald Ihre Migrationen abgeschlossen sind, können Sie die Anwendung testen, um sicherzustellen, dass sie wie erwartet funktioniert. Starten Sie Ihren Server im Kontext Ihres lokalen Bundles mit dem folgenden Befehl, wenn Sie lokal arbeiten:

bundle exec rails s

Wenn Sie auf einem Entwicklungsserver arbeiten, können Sie die Anwendung starten mit:

bundle exec rails s --binding=your_server_ip

Navigieren Sie zu localhost:3000 oder http://your_server_ip:3000. Sie sehen die folgende Startseite:

Um einen neuen Hai zu erstellen, klicken Sie auf die Schaltfläche Get Shark Info, die Sie zu der Route sharks/index führt:

Um zu verifizieren, dass die Anwendung funktioniert, können wir ihr einige Demo-Informationen anhängen. Klicken Sie auf New Shark. Dank der Authentifizierungseinstellungen des Projekts werden Sie zur Eingabe des Benutzernamens (sammy) und Passworts (shark) aufgefordert.

Geben Sie auf der Seite New Shark unter Name „Great White“ und unter Facts „Scary“ ein:

Klicken Sie auf die Schaltfläche Create Shark, um den Shark zu erstellen. Sobald Sie sehen, dass Ihr Hai erstellt wurde, können Sie den Server mit STRG+C beenden.

Sie haben nun die notwendigen Abhängigkeiten für Ihr Projekt installiert und seine Funktionalität getestet. Als Nächstes können Sie einige Änderungen der Rails-Anwendung vornehmen, um mit Ihren Ressourcen für bedrohte Haie zu arbeiten.

Schritt 2 — Generieren eines Controllers für Ressourcen für bedrohte Haie

Um mit unseren Ressourcen für bedrohte Haie zu arbeiten, fügen wir der Anwendung ein neues Modell und einen Controller hinzu, der steuert, wie den Benutzern Informationen über bedrohte Haie präsentiert werden. Unser ultimatives Ziel ist, den Benutzern das Hochladen einer großen Menge von Informationen über bedrohte Haie zu ermöglichen, ohne die Gesamtfunktionalität unserer Anwendung zu blockieren, und diese Informationen zu löschen, wenn sie sie nicht mehr benötigen.

Erstellen wir zunächst ein Modell Endangered für unsere bedrohten Haie. Wir werden ein Zeichenfolgenfeld für den Hainamen in unsere Datenbanktabelle aufnehmen und ein weiteres Zeichenfolgenfeld für die Kategorien der International Union for the Conservation of Nature (IUCN), die den Grad der Gefährdung der einzelnen Haie bestimmen.

Letztendlich entspricht unsere Modellstruktur den Spalten in der CSV-Datei, die wir zur Erstellung unseres Batch-Uploads verwenden werden. Diese Datei befindet sich im Verzeichnis db und Sie können ihren Inhalt mit dem folgenden Befehl überprüfen:

cat db/sharks.csv

Die Datei enthält eine Liste von 73 bedrohten Haien und ihren IUCN-Status – vu für gefährdet, en für bedroht und cr für vom Aussterben bedroht.

Unser Modell Endangered wird mit diesen Daten übereinstimmen, sodass wir neue Instanzen Endangered aus dieser CSV-Datei erstellen können. Erstellen Sie das Modell mit dem folgenden Befehl:

rails generate model Endangered name:string iucn:string

Erstellen Sie als Nächstes einen Controller Endangered mit einer Aktion index:

rails generate controller endangered index

Dadurch erhalten wir einen Ausgangspunkt, um die Funktionalität unserer Anwendung auszubauen, obwohl wir auch benutzerdefinierte Methoden zu der Controller-Datei hinzufügen müssen, die Rails für uns generiert hat.

Öffnen Sie nun diese Datei:

nano app/controllers/endangered_controller.rb

Rails hat uns ein Grundgerüst zur Verfügung gestellt, das wir nun ausfüllen können.

Zunächst müssen wir bestimmen, welche Routen wir für die Arbeit mit unseren Daten benötigen. Dank dem Befehl generate controller haben wir eine Methode index, mit der wir beginnen können. Diese wird mit einer Ansicht index korrelieren, in der wir den Benutzern die Möglichkeit bieten werden, bedrohte Haie hochzuladen.

Wir werden aber auch Fälle bearbeiten wollen, in denen Benutzer die Haie möglicherweise bereits hochgeladen haben. In diesem Fall benötigen sie keine Upload-Option. Wir werden irgendwie beurteilen müssen, wie viele Instanzen der Klasse Endangered bereits existieren, da mehr als eine darauf hinweist, dass der Batch-Upload bereits stattgefunden hat.

Beginnen wir mit der Erstellung einer Methode private set_endangered, die jede Instanz unserer Klasse Endangered aus der Datenbank abrufen wird. Fügen Sie den folgenden Code zur Datei hinzu:

class EndangeredController < ApplicationController
  before_action :set_endangered, only: [:index, :data]

  def index
  end

  private

    def set_endangered
      @endangered = Endangered.all
    end

end

Beachten Sie, dass der Filter before_action sicherstellt, dass der Wert von @endangered nur für die Routen index und data festgelegt ist. Dort verarbeiten wir die Daten über bedrohte Haie.

Fügen Sie als Nächstes den folgenden Code zu der Methode index hinzu, um den richtigen Pfad für Benutzer zu bestimmen, die diesen Teil der Anwendung besuchen:

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
. . .

Wenn mehr als 0 Instanzen unserer Klasse Endangered vorhanden sind, leiten wird die Benutzer auf die Route data um, wo sie Informationen über die von ihnen erstellten Haie einsehen können. Andernfalls sehen sie die Ansicht index.

Fügen Sie als Nächstes unter die Methode index eine Methode data hinzu, die mit der Ansicht data korreliert:

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

  def data
  end
. . .

Als Nächstes fügen wir eine Methode hinzu, um den Daten-Upload selbst zu verarbeiten. Wir nennen diese Methode upload und sie wird eine Sidekiq Worker-Klasse und -methode aufrufen, um den Daten-Upload aus der CSV-Datei durchzuführen. Im nächsten Schritt erstellen wir die Definition für diese Worker-Klasse, AddEndangeredWorker.

Für den Moment fügen Sie den folgenden Code zu der Datei hinzu, um den Sidekiq Worker aufzurufen, der den Upload ausführt:

. . .
  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
. . .

Durch den Aufruf der Methode perform_async in der Klasse AddEndangeredWorker mit der CSV-Datei als Argument, stellt dieser Code sicher, dass die Haidaten und der Upload-Job an Redis übergeben werden. Die Sidekiq Workers, die wir einrichten werden, überwachen die Job-Warteschlange und reagieren, wenn neue Jobs entstehen.

Nach dem Aufruf von perform_async leitet unsere Methode upload zu dem Pfad data um, wo Benutzer die hochgeladenen Haie einsehen können.

Als Nächstes fügen wir eine Methode destroy zur Zerstörung der Daten hinzu. Fügen Sie den folgenden Code unter die Methode upload hinzu:

. . .
  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
. . .

Wie unsere Methode upload beinhaltet unsere Methode destroy einen Aufruf perform_async der Klasse RemoveEndangeredWorker – den anderen Sidekiq Worker, den wir erstellen werden. Nach dem Aufruf dieser Methode leitet sie die Benutzer zu dem Stammanwendungspfad um.

Die fertige Datei sieht ungefähr so aus:

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

Wenn die Bearbeitung abgeschlossen wurde, speichern und schließen Sie die Datei.

Als letzten Schritt zur Verfestigung der Routen unserer Anwendung werden wir den Code config/routes.rb der Datei, in der sich unsere Routendeklarationen befinden, ändern.

Öffnen Sie nun diese Datei:

nano config/routes.rb

Die Datei sieht derzeit wie folgt aus:

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

Wir müssen die Datei aktualisieren, um die in unserem Controller definierten Routen aufzunehmen: data, upload und destroy. Unsere Route data wird mit einer GET-Anforderung zum Abrufen der Haifischdaten übereinstimmen, während unsere Routen upload und destroy den POST-Anforderungen zugeordnet werden, die diese Daten hochladen und zerstören.

Fügen Sie den folgenden Code zu der Datei hinzu, um diese Routen zu definieren:

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

Wenn die Bearbeitung abgeschlossen wurde, speichern und schließen Sie die Datei.

Nachdem Sie Ihr Modell Endangered und Ihre Controller eingerichtet haben, können Sie nun mit der Definition Ihrer Sidekiq Worker-Klassen fortfahren.

Schritt 3 – Definieren von Sidekiq Workers

Wir haben die Methode perform_async für unsere Sidekiq Worker in unserem Controller aufgerufen, aber wir müssen noch die Worker selbst erstellen.

Erstellen Sie zunächst ein Verzeichnis workers für die Worker:

mkdir app/workers

Öffnen Sie eine Datei für den Worker AddEndangeredWorker:

nano app/workers/add_endangered_worker.rb

Wir fügen in dieser Datei Code ein, der uns die Arbeit mit den Daten in unserer CSV-Datei ermöglicht. Zunächst fügen wir der Datei Code hinzu, der die Klasse erstellt, die Ruby-CSV-Bibliothek einbezieht und sicherstellt, dass diese Klasse als Sidekiq Worker funktioniert:

class AddEndangeredWorker
  require 'csv'
  include Sidekiq::Worker
  sidekiq_options retry: false

end

Wir fügen auch die Option retry: false ein, um sicherzustellen, dass Sidekiq den Upload im Falle eines Fehlschlags nicht erneut versucht.

Fügen Sie als Nächstes den Code für die Funktion perform hinzu:

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

Die Methode perform empfängt Argumente von der im Controller definierten Methode perform_async. Daher ist es wichtig, dass die Argumentwerte abgeglichen sind. Hier übergeben wir in csv_file, die in dem Controller definierte Variable und verwenden die Methode foreach aus der CSV-Bibliothek, um die Werte in der Datei zu lesen. Das Setzen von headers: true für diese Schleife stellt sicher, dass die erste Zeile der Datei als eine Zeile von Headers behandelt wird.

Der Block liest dann die Werte von der Datei in die Spalten, die wir für unser Modell Endangered festgelegt haben: name und iucn. Durch Ausführung dieser Schleife werden für jeden der Einträge in unserer CSV-Datei Instanzen Endangered erstellt.

Wenn Sie die Bearbeitung abgeschlossen haben, speichern und schließen Sie die Datei.

Als Nächstes erstellen wir einen Worker, der sich um das Löschen dieser Daten kümmert. Öffnen Sie eine Datei für die Klasse RemoveEndangeredWorker:

nano app/workers/remove_endangered_worker.rb

Fügen Sie den Code zur Definition der Klasse hinzu und stellen Sie sicher, dass sie die CSV-Bibliothek verwendet und als Sidekiq Worker funktioniert:

class RemoveEndangeredWorker
  include Sidekiq::Worker
  sidekiq_options retry: false

end

Fügen Sie als Nächstes eine Methode perform hinzu, um die Zerstörung der Daten von bedrohten Haien zu handhaben:

class RemoveEndangeredWorker
  include Sidekiq::Worker
  sidekiq_options retry: false

  def perform
    Endangered.destroy_all
  end

end

Die Methode perform ruft destroy_all in der Klasse Endangered auf, wodurch alle Instanzen der Klasse aus der Datenbank entfernt werden.

Wenn die Bearbeitung abgeschlossen wurde, speichern und schließen Sie die Datei.

Nachdem Sie Ihre Worker eingerichtet haben, können Sie mit der Erstellung eines Layouts für Ihre Ansichten endangered und von Vorlagen für Ihre Ansichten index und data fortfahren, sodass Benutzer bedrohte Haie hochladen und ansehen können.

Schritt 4 – Hinzufügen von Layouts und Ansichtsvorlagen

Damit Benutzer in den Genuss ihrer Informationen über bedrohte Haie kommen, müssen wir uns mit zwei Dingen befassen: dem Layout für die in unserem Controller endangered definierten Ansichten und mit den Ansichtsvorlagen für die Ansichten index und data.

Unsere Anwendung verwendet derzeit ein anwendungsweites Layout, das sich unter app/views/layouts/application.html.erb befindet, eine Navigations-Partiale und ein Layout für die Ansichten sharks. Das Anwendungslayout prüft, ob ein Inhaltsblock vorhanden ist, der das Laden verschiedener Layouts ermöglicht, je nachdem, mit welchem Teil der Anwendung sich unsere Benutzer beschäftigen: für die Seite home index sehen sie ein Layout und für alle Ansichten über individuelle Haie ein anderes.

Wir können das Layout sharks für unsere Ansichten endangered neu verwenden, da dieses Format auch für die Darstellung von Haidaten in großen Mengen funktioniert.

Kopieren Sie die Layoutdatei sharks, um ein Layout für endangered zu erstellen:

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

Als Nächstes werden wir an der Erstellung von Ansichtenvorlagen für unsere Ansichten index und data arbeiten.

Öffnen Sie zuerst die Vorlage index:

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

Löschen Sie den Boilerplate-Code und fügen Sie stattdessen den folgenden Code hinzu, der den Benutzern einige allgemeine Informationen über die bedrohten Kategorien gibt und ihnen die Möglichkeit bietet, Informationen über bedrohte Haie hochzuladen:

<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" %>

Ein form_tag macht den Daten-Upload möglich, indem eine Post-Aktion auf den endangered_upload_path verweist – die Route, die wir für unsere Uploads definiert haben.  Eine Submit-Schaltfläche, die mit dem submit_tag erstellt wurde, fordert die Benutzer zum "Import Endangered Sharks" (Importieren bedrohter Haie) auf.

Zusätzlich zu diesem Code haben wir einige allgemeine Informationen über ICUN-Codes eingefügt, damit die Benutzer die Daten, die sie sehen werden, interpretieren können.

Wenn die Bearbeitung abgeschlossen wurde, speichern und schließen Sie die Datei.

Öffnen Sie als Nächstes eine Datei für die Ansicht data:

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

Fügen Sie den folgenden Code hinzu, der eine Tabelle mit den Daten der bedrohten Haie hinzufügt:

<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" %>

Dieser Code enthält noch einmal die ICUN-Statuscodes und eine Bootstrap-Tabelle für die ausgegebenen Daten. Indem wir unsere Variable @endangered durchschleifen, geben wir den Namen und den ICUN-Status jedes Hais in die Tabelle aus.

Unterhalb der Tabelle haben wir einen weiteren Satz von form_tags und submit_tags, die auf den Pfad destroy verweisen, indem Benutzern die Option zum "Delete Endangered Sharks" (Löschen bedrohter Haie) angeboten wird.

Wenn die Bearbeitung abgeschlossen wurde, speichern und schließen Sie die Datei.

Die letzte Änderung, die wir für unsere Ansichten vornehmen, wird in der Ansicht index vorgenommen, die mit unserem Controller home verknüpft ist. Sie erinnern sich vielleicht daran, dass diese Ansicht als das Stammverzeichnis der Anwendung in config/routes.rb festgelegt ist.

Öffnen Sie diese Datei zur Bearbeitung:

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

Finden Sie die Spalte in der Zeile, die besagt Sharks are ancient (Haie sind uralt):

. . .
        <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>

Fügen Sie den folgenden Code zur Datei hinzu:

. . .
        <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>

Wir haben einen Handlungsaufruf für Benutzer aufgenommen, um mehr über bedrohte Haie zu erfahren, indem wir zuerst eine starke Botschaft weitergeben und dann einen Helfer button_to hinzufügen, der eine GET-Anfrage an die Route endangered index sendet und Benutzern Zugriff auf diesen Teil der Anwendung gewährt. Von dort aus können sie Informationen über bedrohte Haie hochladen und anzeigen.

Wenn die Bearbeitung abgeschlossen wurde, speichern und schließen Sie die Datei.

Nachdem Sie nun Ihren Code eingegeben haben, können Sie die Anwendung starten und einige Haie hochladen!

Schritt 5 – Starten von Sidekiq und Testen der Anwendung

Bevor wir die Anwendung starten, müssen wir Migrationen in unserer Datenbank durchführen und Sidekiq starten, um unsere Worker zu aktivieren. Redis sollte bereits auf dem Server ausgeführt werden, aber wir können das überprüfen, um sicherzugehen. Sobald all diese Dinge eingerichtet sind, sind wir bereit, die Anwendung zu testen.

Überprüfen Sie zunächst, ob Redis ausgeführt wird:

systemctl status redis

Sie sollten eine Ausgabe wie die folgende sehen:

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

Führen Sie als Nächstes Ihre Datenbankmigration durch:

rails db:migrate

Sie können nun Sidekiq im Kontext Ihres aktuellen Projekt-Bundles starten, indem Sie den Befehl bundle exec sidekiq verwenden:

bundle exec sidekiq

Sie werden eine ähnliche Ausgabe wie diese sehen, die anzeigt, dass Sidekiq zur Bearbeitung von Jobs bereit ist:

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

Öffnen Sie ein zweites Terminalfenster, navigieren Sie zum Verzeichnis rails-sidekiq und starten Sie Ihren Anwendungsserver.

Wenn Sie die Anwendung lokal ausführen, verwenden Sie den folgenden Befehl:

bundle exec rails s

Wenn Sie mit einem Entwicklungsserver arbeiten, führen Sie den folgenden Befehl aus:

bundle exec rails s --binding=your_server_ip

Navigieren Sie im Browser zu localhost:3000 oder http://your_server_ip:3000. Sie sehen die folgende Startseite:

Klicken Sie auf die Which Sharks Are in Danger? Schaltfläche. Da Sie keine gefährdeten Sharks hochgeladen haben, wird Ihnen die Ansicht des gefährdeten Index gezeigt:

Klicken Sie auf Import Endangered Sharks, um die gefährdeten Sharks zu importieren. Eine Statusmeldung teilt Ihnen mit, dass die Sharks importiert wurden:

Sie sehen auch den Beginn des Imports. Aktualisieren Sie die Seite, um die gesamte Tabelle zu sehen:

Dank Sidekiq ist unser umfangreiches Batch-Upload der gefährdeten Sharks gelungen, ohne den Browser zu blockieren oder die Funktionsweise anderer Anwendungen zu beeinträchtigen.

Klicken Sie auf die Schaltfläche Home unten auf der Seite, die Sie zur Hauptseite der Anwendung zurückbringen wird:

Klicken Sie hier erneut auf Which Sharks Are in Danger? . Damit gelangen Sie nun direkt zu der Ansicht data, da Sie die Haie bereits hochgeladen haben.

Um die Löschfunktionalität zu testen, klicken Sie auf die Schaltfläche Delete Endangered Sharks unterhalb der Tabelle. Sie sollten nun erneut zu der Hauptseite der Anwendung umgeleitet werden. Wenn Sie ein letztes Mal auf Which Sharks Are in Danger? klicken, gelangen Sie zu der Ansicht index zurück, in der Sie die Option haben, die Haie erneut hochzuladen:

Ihre Anwendung wird nun mit Sidekiq Workers ausgeführt, die zur Bearbeitung von Jobs bereit sind und sicherstellen, dass die Benutzer eine gute Erfahrung mit Ihrer Anwendung haben.

Zusammenfassung

Sie haben nun eine funktionierende Rails-Anwendung mit aktiviertem Sidekiq, die es Ihnen ermöglicht, kostspielige Operationen in eine von Sidekiq verwaltete und von Redis unterstützte Job-Warteschlange auszulagern. Dadurch können Sie die Geschwindigkeit und Funktionalität Ihrer Website im Laufe der Entwicklung verbessern.

Wenn Sie mehr über Sidekiq erfahren möchten, sind die Docs ein guter Ausgangspunkt.

Weitere Informationen über Redis finden Sie in unserer Bibliothek der Redis Ressourcen. Sie können auch mehr über die Ausführung eines verwalteten Redis-Clusters auf DigitalOcean erfahren, indem Sie sich die Produktdokumentation ansehen.