Ruby Academy · Lezione

Middleware e Rack

Lo stack Rack

Middleware e Rack è una lezione Ruby Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Ruby Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Ruby Academy include 4 lezioni in totale.

Che cos'è Rack?

Rack è l'interfaccia minima tra i server web Ruby e i framework. Sinatra, Rails e altri framework vengono tutti eseguiti su Rack.

Standardizza il modo in cui fluiscono richieste e risposte
Consente di riutilizzare i middleware
Un'app Rack è qualsiasi oggetto che risponde a call(env)

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

puts app.call({}).inspect

Il contratto Rack

Il metodo call di un'app Rack deve restituire un array di tre elementi:

Un intero di stato (ad esempio 200)
Un hash di intestazioni
Un corpo che risponde a each (di solito un array di stringhe)

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

L'hash env

L'argomento env è un hash che descrive la richiesta.

REQUEST_METHOD, ad esempio GET o POST
PATH_INFO, il percorso richiesto
QUERY_STRING, i parametri di query non elaborati

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

Che cos'è un middleware?

Il middleware avvolge un'app per aggiungere comportamenti prima o dopo che la richiesta la raggiunga.

Registrazione, autenticazione, compressione
Ogni middleware risponde a sua volta a call(env)
Chiama l'app successiva nella catena

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

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

Creazione di una classe middleware

Il middleware memorizza l'app avvolta e delega a essa nel metodo call.

Il costruttore riceve l'app interna
call può modificare env e poi inoltrare la richiesta
Può anche modificare la risposta durante il ritorno

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'

Lo stack dei middleware

I middleware formano uno stack. La richiesta scende fino all'app e la risposta risale.

I middleware esterni vengono eseguiti per primi all'andata
I middleware esterni vengono eseguiti per ultimi al ritorno

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

Utilizzo dei middleware in Sinatra

Aggiunga un middleware a un'app Sinatra con use.

use Rack::Logger
L'ordine delle chiamate a use definisce l'ordine dello stack

require 'sinatra'

use Rack::Logger

get '/' do
  'Logged request'
end

config.ru e rackup

Un file config.ru avvia un'app Rack con rackup o Puma.

run imposta l'app finale
use aggiunge i middleware prima di essa

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

Middleware integrati comuni

Rack include middleware utili.

Rack::CommonLogger registra le richieste
Rack::Deflater comprime con gzip
Rack::Static serve i file
Rack::Session::Cookie gestisce le sessioni

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

Modifica della risposta

Spesso il middleware aggiunge intestazioni alla risposta dopo l'esecuzione dell'app interna.

Acquisisca la tripla della risposta
Modifichi le intestazioni e poi la restituisca

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

Interruzione anticipata delle richieste

Il middleware può interrompere una richiesta senza chiamare l'app interna.

È utile per i controlli di autenticazione o i limiti di frequenza
Restituisca direttamente una tripla della risposta

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]

Controllo rapido

Verifichi la sua comprensione di Rack.

Riepilogo

Ha imparato a conoscere lo stack Rack:

Rack è l'interfaccia comune alla base dei framework web Ruby
Un'app Rack risponde a call(env) e restituisce [status, headers, body]
Il middleware avvolge un'app per aggiungere comportamenti trasversali
Utilizzi use in Sinatra o config.ru per comporre lo stack
Il middleware può modificare le risposte o interrompere anticipatamente le richieste

Domande Frequenti

La lezione «Middleware e Rack» è gratuita?

Sì — il testo completo di «Middleware e Rack» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Ruby Academy, passa a CoddyKit PRO. Il corso Ruby Academy include 4 lezioni in totale.

Cosa imparerò in «Middleware e Rack»?

Lo stack Rack Eserciti Ruby Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Ruby Academy?

Non è richiesta alcuna esperienza precedente. Ruby Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Middleware e Rack»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Ruby Academy?

Sì. Ogni lezione Ruby Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Ruby Academy