El papel de Rack en el ecosistema Ruby

Mientras trabajaba con Marcos web Ruby es habitual dar las cosas por sentadas. Sabemos que el framework gestionará las peticiones HTTP y ejecutará la lógica del middleware por nosotros. A medida que nos volvemos más curiosos empezamos a preguntarnos qué hay entre bastidores, ahí es donde empezamos a oír hablar de Rack.

¿Qué es la estantería?

En proyecto se describe como "Una interfaz modular Ruby para servidores web". Rack es la interfaz que nos permite crear aplicaciones web unificando la API para servidores web, frameworks web y middleware.

Como se describe en la imagen anterior, Rack actúa como intermediario entre nuestra Aplicación Web y el Servidor de Aplicaciones, envuelve las peticiones HTTP en el más simple
manera posible.

Aplicación en bastidor

Una aplicación Rack es un objeto Ruby (no una clase) que responde a llame a. Toma exactamente un argumento, el medio ambiente y devuelve un array no congelado de
exactamente tres valores:

• En estado,
• el cabeceras,

• y el cuerpo.

  Encontrará las especificaciones detalladas de una aplicación Rack aquí.

require 'rack

clase RackApp
  def call(env)
        estado = 200
        headers = { 'Content-Type' => 'text/html' }
        body = ['<h1>Mi aplicación Rack<h1>']

    [status, headers, body]
  end
fin

Rack::Manejador

Los manejadores conectan servidores web con Rack. Rack incluye Handlers para Thin, WEBrick,FastCGI, CGI, SCGI y LiteSpeed. Cada servidor de aplicaciones compatible con Rack debe
proporcionan un manejador para crear la conexión (Puma tiene su propio manejador).Los manejadores normalmente se activan llamando a MyHandler.run(myapp). Se puede pasar un segundo hash opcional para incluir la configuración específica del servidor.

Uso del servidor de aplicaciones Thin

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

El archivo por defecto para añadir la configuración es config.ru y puede ejecutarlo utilizando rackup en su consola.

Middleware de bastidor

Rack nos permite crear aplicaciones middleware (aplicaciones entre nuestra aplicación web principal y el servidor de aplicaciones). Estas aplicaciones middleware se encadenan y ejecutan secuencialmente.

Rack Middleware debe implementar todas las especificaciones de un Aplicación en bastidor y cumplir los siguientes puntos:

• Debe ser una clase,
• tienen un inicializador que sólo recibe un parámetro (la aplicación principal),
• y llamar al siguiente middleware o a la aplicación.

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

Del bastidor a la práctica

Ahora que sabemos lo básico, estamos listos para crear nuestra primera Aplicación Rack con Rack Middleware y ejecutarla usando Puma (Servidor de Aplicaciones).

Instalar las dependencias

Asegúrese de tener la estante gema y el puma gema instalada.

gem install rack
gem install puma

Crear el archivo de configuración

En primer lugar, tenemos que crear un archivo llamado config.ru y este archivo hará uso de
el DSL Rack::Builder para ejecutar la aplicación y añadir el middleware.

Añadir la aplicación Rack

Dentro del config.ru añadiremos la aplicación Rack sencilla que definimos en
las secciones anteriores.

# config.ru

clase RackApp
  def call(env)
    estado = 200
    headers = { 'Content-Type' => 'text/html' }
    body = ['<h1>Mi aplicación Rack<h1>']

    [status, headers, body]
  end
fin

Añadir el middleware Rack

Aquí haremos una pequeña modificación a nuestro simple middleware y ahora añadirá el software del servidor a nuestro cuerpo HTML después de ser ejecutado.

# config.ru

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

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

    body << env['SERVIDOR_SOFTWARE']

    [estado, cabeceras, cuerpo]
  end
end

Ejecutar el servidor de aplicaciones

Como último paso, ejecutaremos el servidor y veremos nuestra aplicación funcionando. Nuestro config.ru tendrá el siguiente aspecto:

# config.ru

clase RackApp
  def call(env)
    estado = 200
    headers = { 'Content-Type' => 'text/html' }
    body = ['<h1>Mi aplicación Rack<h1>']

    [status, headers, body]
  end
fin

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

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

    cuerpo <&lt; env[&#039;SERVIDOR_SOFTWARE&#039;]

    [estado, cabeceras, cuerpo]
  end
end

use RackMiddleware
ejecutar RackApp.new

En las últimas líneas, especificamos el middleware utilizando utilice y ejecutamos la aplicación utilizando correr.Estamos listos para ejecutar rackup en nuestra consola y veremos el servidor ejecutándose. Podemos comprobar el puerto donde se está ejecutando nuestra aplicación y deberíamos ver algo como esto después de acceder a él:

Conclusiones

A veces es bueno volver a lo básico y conocer los entresijos de la tecnología con la que trabajamos. Aprender Rack nos da una visión clara de la arquitectura y nos revela la "magia" que hay detrás de la Marcos Web Ruby.