Die Rolle von Rack im Ruby-Ökosystem

Bei der Arbeit mit Ruby-Web-Frameworks ist es üblich, Dinge für selbstverständlich zu halten. Wir wissen, dass das Framework die HTTP-Anfragen bearbeiten und die Middleware-Logik für uns ausführen wird. Je neugieriger wir werden, desto mehr fragen wir uns, was sich hinter den Kulissen verbirgt, und da fangen wir an, von Rack zu hören.

Was ist Rack?

Die Projekt wird als "eine modulare Ruby-Webserver-Schnittstelle" beschrieben. Rack ist die Schnittstelle, mit der wir Webanwendungen erstellen können, die die API für Webserver, Web-Frameworks und Middleware vereinen.

Wie in der obigen Abbildung beschrieben, fungiert Rack als Vermittler zwischen unserer Webanwendung und dem Anwendungsserver, es verpackt die HTTP-Anfragen in die einfachste
Weise möglich.

Rack-Anwendung

Eine Rack-Anwendung ist ein Ruby-Objekt (keine Klasse), das auf aufrufen. Sie benötigt genau ein Argument, die Umwelt und gibt ein nicht-gefrorenes Array von
genau drei Werte:

• Die Status,
• die Kopfzeilen,

• und die Körper.

  Die detaillierte Spezifikation einer Rack-Anwendung finden Sie hier.

erfordern 'Rack'

class RackApp
  def call(env)
        status = 200
        headers = { 'Content-Type' => 'text/html' }
        body = ['<h1>Meine Rack-App<h1>']

    [status, headers, body]
  end
end

Gestell::Handler

Handler verbinden Webserver mit Rack. Rack enthält Handler für Thin, WEBrick, FastCGI, CGI, SCGI und LiteSpeed. Jeder Anwendungsserver, der Rack unterstützt, sollte
einen Handler zur Verfügung stellen, der die Verbindung herstellt (Puma hat einen eigenen Handler).Handler werden normalerweise durch den Aufruf MyHandler.run(myapp). Ein zweiter optionaler Hash kann übergeben werden, um die serverspezifische Konfiguration aufzunehmen.

Thin Application Server verwenden

Rack::Handler::Thin.run(app)

Die Standarddatei zum Hinzufügen der Konfiguration lautet config.ru und Sie können sie ausführen mit . Befehl in Ihrer Konsole.

Rack-Middleware

Mit Rack können wir Middleware-Anwendungen erstellen (Anwendungen zwischen unserer Haupt-Webanwendung und dem Anwendungsserver). Diese Middleware-Anwendungen werden miteinander verkettet und nacheinander ausgeführt.

Rack Middleware muss alle Spezifikationen eines Rack-Anwendung und die folgenden Punkte erfüllen:

• Es muss eine Klasse sein,
• haben einen Initialisierer, der nur einen Parameter erhält (die Hauptanwendung),
• und rufen die nächste Middleware oder die Anwendung auf.

class RackMiddleware
def initialize(app)
@app = app
end
def call(env)
@app.call(env)
end
end

Rack in der Praxis

Nachdem wir nun die Grundlagen kennen, sind wir bereit, unsere erste Rack-Anwendung mit Rack Middleware zu erstellen und sie mit Puma (Application Server) auszuführen.

Installieren Sie die Abhängigkeiten

Stellen Sie sicher, dass Sie die Gestell Edelstein und der puma gem installiert.

gem install rack
gem install puma

Erstellen Sie die Konfigurationsdatei

Zuerst müssen wir eine Datei namens config.ru und diese Datei verwendet die
die Rack::Builder DSL, um die Anwendung auszuführen und die Middleware hinzuzufügen.

Hinzufügen der Rack-Anwendung

Innerhalb der config.ru Datei fügen wir die einfache Rack-Anwendung hinzu, die wir in
die vorherigen Abschnitte.

# config.ru

Klasse RackApp
  def call(env)
    status = 200
    headers = { 'Content-Type' => 'text/html' }
    body = ['<h1>Meine Rack-App<h1>']

    [status, headers, body]
  end
end

Hinzufügen der Rack-Middleware

Hier werden wir eine kleine Änderung an unserer einfachen Middleware vornehmen, so dass sie nach der Ausführung die Serversoftware zu unserem HTML-Body hinzufügt.

# config.ru

class RackMiddleware
  def initialize(app)
    @app = app
  end

  def call(env)
    status, headers, body = @app.call(env)

    body << env['SERVER_SOFTWARE']

    [status, kopfzeilen, body]
  end
end

Starten Sie den Anwendungsserver

Als letzten Schritt werden wir den Server starten und sehen, wie unsere Anwendung läuft. Unser config.ru Datei wird wie folgt aussehen:

# config.ru

Klasse RackApp
  def call(env)
    status = 200
    headers = { 'Content-Type' => 'text/html' }
    body = ['<h1>Meine Rack-App<h1>']

    [status, headers, body]
  end
end

class RackMiddleware
  def initialize(app)
    @app = app
  end

  def call(env)
    status, headers, body = @app.call(env)

    body <&lt; env[&#039;SERVER_SOFTWARE&#039;]

    [status, headers, body]
  end
end

RackMiddleware verwenden
RackApp.new ausführen

In den letzten Zeilen spezifizieren wir die Middleware mit verwenden. und wir führen die Anwendung mit laufen.Wir sind bereit zur Ausführung . in unserer Konsole und sehen, dass der Server läuft. Wir können den Port, an dem unsere Anwendung läuft, überprüfen und sollten nach dem Zugriff auf die Anwendung etwas wie dieses sehen:

Schlussfolgerungen

Manchmal ist es gut, zu den Grundlagen zurückzukehren und mehr über die Technologie zu erfahren, mit der wir arbeiten. Learning Rack gibt uns einen klaren Überblick über die Architektur und enthüllt die "Magie" hinter dem Ruby Web Frameworks.