Ruby Academy · Lektion

Middleware och Rack

Rack-stacken.

Lektion 4 av 413 steg

Middleware och Rack är en gratis lektion i Ruby Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Ruby Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Ruby Academy innehåller totalt 4 lektioner.

Vad är Rack?

Rack är det minimala gränssnittet mellan Ruby-webbservrar och ramverk. Sinatra, Rails och andra körs alla med Rack.

Standardiserar hur begäranden och svar flödar
Möjliggör återanvändbar middleware
En Rack-app är allt som svarar på call(env)

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

puts app.call({}).inspect

Rack-kontraktet

En Rack-apps call måste returnera en array med tre element:

Status som heltal (t.ex. 200)
Headers som hash
Body som svarar på each (vanligen en array med strängar)

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

Hashen env

Argumentet env är en hash som beskriver begäran.

REQUEST_METHOD, till exempel GET eller POST
PATH_INFO, den efterfrågade sökvägen
QUERY_STRING, råa frågeparametrar

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

Vad är middleware?

Middleware omsluter en app för att lägga till funktionalitet före eller efter att begäran når den.

Loggning, autentisering och komprimering
Varje middleware svarar också på call(env)
Den anropar nästa app i kedjan

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

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

Bygga en middleware-klass

Middleware lagrar den omslutna appen och delegerar till den i call.

Konstruktorn tar emot den inre appen
call kan ändra env och sedan skicka begäran vidare
Den kan också ändra svaret på vägen tillbaka

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'

Middleware-stacken

Middleware bildar en stack. Begäran går ned till appen och svaret går tillbaka upp.

Den yttre middlewaren körs först på vägen in
Den yttre middlewaren körs sist på vägen ut

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

Använda middleware i Sinatra

Lägg till middleware i en Sinatra-app med use.

use Rack::Logger
Ordningen på use-anropen avgör stackens ordning

require 'sinatra'

use Rack::Logger

get '/' do
  'Logged request'
end

config.ru och rackup

En config.ru-fil startar en Rack-app med rackup eller Puma.

run anger den slutliga appen
use lägger till middleware före den

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

Vanlig inbyggd middleware

Rack levereras med användbar middleware.

Rack::CommonLogger loggar begäranden
Rack::Deflater komprimerar med gzip
Rack::Static levererar filer
Rack::Session::Cookie hanterar sessioner

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

Ändra svaret

Middleware lägger ofta till svarshuvuden efter att den inre appen har körts.

Fånga svars-trippeln
Ändra headers och returnera sedan trippeln

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

Avbryta begäranden i förtid

Middleware kan stoppa en begäran utan att anropa den inre appen.

Användbart för autentiseringskontroller eller hastighetsbegränsningar
Returnera en svars-trippel direkt

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]

Snabbkontroll

Kontrollera Era kunskaper om Rack.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt Er om Rack-stacken:

Rack är det gemensamma gränssnittet under Ruby-webbramverk
En Rack-app svarar på call(env) och returnerar [status, headers, body]
Middleware omsluter en app för att lägga till tvärgående funktionalitet
Använd use i Sinatra eller config.ru för att sätta samman stacken
Middleware kan ändra svar eller avbryta begäranden i förtid

Gratis att börja

Lär dig Ruby med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 29
Lektioner: 109

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Middleware och Rack” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Ruby Academy, inklusive ”Middleware och Rack”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Ruby Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Middleware och Rack”?

Rack-stacken. Ni övar på Ruby Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Ruby Academy?

Du behöver inga förkunskaper. Utbildningen i Ruby Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Middleware och Rack”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Ruby Academy-lektionen?

Ja. Varje Ruby Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Ruby Academy