0Pricing
Ruby Academy · Lección

Middleware y Rack

La pila de Rack

Middleware y Rack es una lección gratuita de Ruby Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Ruby Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Ruby Academy incluye 4 lecciones en total.

¿Qué es Rack?

Rack es la interfaz mínima entre los servidores web de Ruby y los frameworks. Sinatra, Rails y otros se ejecutan sobre Rack.

  • Estandariza el flujo de solicitudes y respuestas
  • Permite reutilizar middleware
  • Una aplicación Rack es cualquier objeto que responda a call(env)
app = lambda do |env|
  [200, { 'Content-Type' => 'text/plain' }, ['Hello Rack']]
end

puts app.call({}).inspect

El contrato de Rack

El call de una aplicación Rack debe devolver un array de tres elementos:

  • Un entero de estado (por ejemplo, 200)
  • Un hash de cabeceras
  • Un cuerpo que responda a each (normalmente, un array de cadenas)
status, headers, body = 200, { 'Content-Type' => 'text/html' }, ['<h1>Hi</h1>']
puts status
puts headers.inspect
body.each { |chunk| puts chunk }

El hash env

El argumento env es un hash que describe la solicitud.

  • REQUEST_METHOD, como GET o POST
  • PATH_INFO, la ruta solicitada
  • QUERY_STRING, los parámetros de consulta sin procesar
env = { 'REQUEST_METHOD' => 'GET', 'PATH_INFO' => '/home' }
puts "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"

¿Qué es el middleware?

El middleware envuelve una aplicación para añadir comportamiento antes o después de que la solicitud llegue a ella.

  • Registro, autenticación y compresión
  • Cada middleware también responde a call(env)
  • Llama a la siguiente aplicación de la cadena
class Logger
  def initialize(app)
    @app = app
  end

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

Crear una clase de middleware

El middleware almacena la aplicación envuelta y delega en ella dentro de call.

  • El constructor recibe la aplicación interna
  • call puede modificar env y después reenviar la solicitud
  • También puede modificar la respuesta al regresar
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'

La pila de middleware

El middleware forma una pila. La solicitud baja hasta la aplicación y la respuesta vuelve a subir.

  • El middleware exterior se ejecuta primero al entrar
  • El middleware exterior se ejecuta el último al salir
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

Usar middleware en Sinatra

Añada middleware a una aplicación Sinatra con use.

  • use Rack::Logger
  • El orden de las llamadas a use define el orden de la pila
require 'sinatra'

use Rack::Logger

get '/' do
  'Logged request'
end

config.ru y rackup

Un archivo config.ru pone en marcha una aplicación Rack con rackup o Puma.

  • run establece la aplicación final
  • use añade middleware antes de ella
# config.ru
require './app'
use Rack::CommonLogger
run Sinatra::Application

Middleware integrado habitual

Rack incluye middleware útiles.

  • Rack::CommonLogger, registros de solicitudes
  • Rack::Deflater, compresión gzip
  • Rack::Static, sirve archivos
  • Rack::Session::Cookie, sesiones
# In config.ru
# use Rack::Deflater
# use Rack::Static, urls: ['/assets'], root: 'public'
puts 'See comments for usage'

Modificar la respuesta

El middleware suele añadir cabeceras de respuesta después de que se ejecute la aplicación interna.

  • Capture la tupla de respuesta
  • Modifique las cabeceras y después devuélvala
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

Interrumpir solicitudes

El middleware puede detener una solicitud sin llamar a la aplicación interna.

  • Es útil para controles de autenticación o límites de velocidad
  • Devuelva directamente una tupla de respuesta
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]

Comprobación rápida

Compruebe sus conocimientos sobre Rack.

Resumen

Ha aprendido sobre la pila de Rack:

  • Rack es la interfaz común bajo los frameworks web de Ruby
  • Una aplicación Rack responde a call(env) y devuelve [status, headers, body]
  • El middleware envuelve una aplicación para añadir comportamiento transversal
  • Use use en Sinatra o config.ru para componer la pila
  • El middleware puede modificar respuestas o interrumpir solicitudes

Preguntas frecuentes

¿La lección «Middleware y Rack» es gratis?

Sí — el texto completo de «Middleware y Rack» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Ruby Academy, actualiza a CoddyKit PRO. El curso de Ruby Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Middleware y Rack»?

La pila de Rack Practicas Ruby Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Ruby Academy?

No se requiere experiencia previa. Ruby Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Middleware y Rack»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Ruby Academy?

Sí. Cada lección de Ruby Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Conceptos básicos de Sinatra
  2. Rutas y parámetros
  3. APIs JSON
  4. Middleware y Rack
← Volver a Ruby Academy