Ruby Academy · Lektion

Middleware und Rack

Der Rack-Stack

Middleware und Rack ist eine kostenlose Ruby Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Ruby Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Ruby Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Rack?

Rack ist die minimale Schnittstelle zwischen Ruby-Webservern und Frameworks. Sinatra, Rails und andere Frameworks laufen alle auf Rack.

Standardisiert, wie Anfragen und Antworten verarbeitet werden
Ermöglicht wiederverwendbare Middleware
Eine Rack-App ist alles, was auf call(env) antwortet

app = lambda do |env|
  [200, { 'Content-Type' => 'text/plain' }, ['Hello Rack']]
end

puts app.call({}).inspect

Der Rack-Vertrag

Das call einer Rack-App muss ein Array mit drei Elementen zurückgeben:

Status-Integer, zum Beispiel 200
Header-Hash
Body, der auf each antwortet, normalerweise ein Array aus Strings

status, headers, body = 200, { 'Content-Type' => 'text/html' }, ['<h1>Hi</h1>']
puts status
puts headers.inspect
body.each { |chunk| puts chunk }

Der env-Hash

Das Argument env ist ein Hash, der die Anfrage beschreibt.

REQUEST_METHOD, etwa GET oder POST
PATH_INFO, der angeforderte Pfad
QUERY_STRING, die unverarbeiteten Query-Parameter

env = { 'REQUEST_METHOD' => 'GET', 'PATH_INFO' => '/home' }
puts "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"

Was ist Middleware?

Middleware umschließt eine App, um Verhalten hinzuzufügen, bevor die Anfrage die App erreicht oder nachdem sie sie verlassen hat.

Protokollierung, Authentifizierung, Komprimierung
Jede Middleware antwortet ebenfalls auf call(env)
Sie ruft die nächste App in der Kette auf

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

  def call(env)
    puts "Request: #{env['PATH_INFO']}"
    @app.call(env)
  end
end

Eine Middleware-Klasse erstellen

Middleware speichert die umschlossene App und delegiert in call an sie.

Der Konstruktor erhält die innere App
call kann env ändern und die Anfrage anschließend weiterleiten
Auf dem Rückweg kann die Middleware auch die Antwort verändern

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

  def call(env)
    status, headers, body = @app.call(env)
    new_body = body.map(&:upcase)
    [status, headers, new_body]
  end
end

puts 'Middleware defined'

Der Middleware-Stack

Middleware bildet einen Stack. Die Anfrage läuft nach unten zur App, die Antwort läuft wieder nach oben.

Äußere Middleware wird auf dem Hinweg zuerst ausgeführt
Äußere Middleware wird auf dem Rückweg zuletzt ausgeführt

inner = lambda { |env| [200, {}, ['core']] }

class Wrap
  def initialize(app); @app = app; end
  def call(env)
    s, h, b = @app.call(env)
    [s, h, b.map { |x| "[#{x}]" }]
  end
end

puts Wrap.new(inner).call({}).last.inspect

Middleware in Sinatra verwenden

Fügen Sie einer Sinatra-App mit use Middleware hinzu.

use Rack::Logger
Die Reihenfolge der use-Aufrufe legt die Reihenfolge im Stack fest

require 'sinatra'

use Rack::Logger

get '/' do
  'Logged request'
end

config.ru und rackup

Eine config.ru-Datei startet eine Rack-App mit rackup oder Puma.

run legt die endgültige App fest
use fügt davor Middleware hinzu

# config.ru
require './app'
use Rack::CommonLogger
run Sinatra::Application

Häufig verwendete integrierte Middleware

Rack wird mit nützlicher Middleware ausgeliefert.

Rack::CommonLogger protokolliert Anfragen
Rack::Deflater komprimiert mit gzip
Rack::Static liefert Dateien aus
Rack::Session::Cookie verwaltet Sitzungen

# In config.ru
# use Rack::Deflater
# use Rack::Static, urls: ['/assets'], root: 'public'
puts 'See comments for usage'

Die Antwort verändern

Middleware fügt häufig Antwort-Header hinzu, nachdem die innere App ausgeführt wurde.

Erfassen Sie das Antwort-Tupel
Verändern Sie die Header und geben Sie das Tupel anschließend zurück

class AddHeader
  def initialize(app); @app = app; end
  def call(env)
    status, headers, body = @app.call(env)
    headers['X-Powered-By'] = 'Ruby'
    [status, headers, body]
  end
end

app = AddHeader.new(lambda { |e| [200, {}, ['ok']] })
puts app.call({})[1].inspect

Anfragen vorzeitig beenden

Middleware kann eine Anfrage anhalten, ohne die innere App aufzurufen.

Nützlich für Authentifizierungsprüfungen oder Ratenbegrenzungen
Geben Sie direkt ein Antwort-Tupel zurück

class Auth
  def initialize(app); @app = app; end
  def call(env)
    return [401, {}, ['Unauthorized']] unless env['token']
    @app.call(env)
  end
end

app = Auth.new(lambda { |e| [200, {}, ['ok']] })
puts app.call({})[0]

Schnelltest

Überprüfen Sie Ihr Verständnis von Rack.

Zusammenfassung

Sie haben den Rack-Stack kennengelernt:

Rack ist die gemeinsame Schnittstelle unterhalb von Ruby-Webframeworks
Eine Rack-App antwortet auf call(env) und gibt [status, headers, body] zurück
Middleware umschließt eine App, um querschnittliche Funktionalität hinzuzufügen
Verwenden Sie use in Sinatra oder config.ru, um den Stack zusammenzusetzen
Middleware kann Antworten verändern oder Anfragen vorzeitig beenden

Häufig gestellte Fragen

Ist die Lektion „Middleware und Rack“ kostenlos?

Ja — der vollständige Text von „Middleware und Rack“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Ruby Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Ruby Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Middleware und Rack“?

Der Rack-Stack Du übst Ruby Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Ruby Academy zu starten?

Keine Vorkenntnisse erforderlich. Ruby Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Middleware und Rack“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Ruby Academy-Lektion Code schreiben und ausführen?

Ja. Jede Ruby Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Ruby Academy