Il ruolo di Rack nell'ecosistema Ruby

Mentre si lavora con Framework web Ruby è comune dare le cose per scontate. Sappiamo che il framework gestirà le richieste HTTP ed eseguirà la logica del middleware per noi. Quando diventiamo più curiosi, iniziamo a chiederci cosa c'è dietro le quinte, ed è qui che iniziamo a sentire parlare di Rack.

Che cos'è il Rack?

Il progetto è descritto come "Un'interfaccia modulare per server web in Ruby". Rack è l'interfaccia che ci permette di creare applicazioni web unificando le API per server web, framework web e middleware.

Come descritto nell'immagine precedente, Rack funge da intermediario tra la nostra applicazione Web e l'Application Server, avvolgendo le richieste HTTP nel più semplice
modo possibile.

Applicazione a rack

Un'applicazione Rack è un oggetto Ruby (non una classe) che risponde a chiamata. Richiede esattamente un argomento, il parametro ambiente e restituisce una matrice non congelata di
esattamente tre valori:

• Il stato,
• il intestazioni,

• e il corpo.

  È possibile trovare le specifiche dettagliate di un'applicazione Rack qui.

richiedere 'rack'

classe RackApp
  def call(env)
        stato = 200
        headers = { 'Content-Type' => 'text/html' }
        body = ['<h1>L'applicazione My Rack<h1>']

    [stato, intestazioni, corpo]
  fine
fine

Rack::Handler

I gestori collegano i server Web con Rack. Rack include gestori per Thin, WEBrick, FastCGI, CGI, SCGI e LiteSpeed. Ogni server applicativo che supporta Rack deve
forniscono un gestore per creare la connessione (Puma ha un proprio gestore).I gestori di solito vengono attivati chiamando MyHandler.run(myapp). È possibile passare un secondo hash opzionale per includere la configurazione specifica del server.

Utilizzo di Thin application server

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

Il file predefinito per aggiungere la configurazione è config.ru e si può eseguire utilizzando rackup nella console.

Middleware per rack

Rack ci permette di creare applicazioni middleware (applicazioni tra la nostra applicazione web principale e l'application server). Queste applicazioni middleware sono concatenate ed eseguite in sequenza.

Il Rack Middleware deve implementare tutte le specifiche di un Applicazione a rack e soddisfare i seguenti punti:

• Deve essere una classe,
• hanno un inizializzatore che riceve un solo parametro (l'applicazione principale),
• e chiamare il middleware successivo o l'applicazione.

classe RackMiddleware
def initialize(app)
@app = app
fine
def call(env)
@app.call(env)
fine
fine

Rack in pratica

Ora che conosciamo le basi, siamo pronti a creare la nostra prima applicazione Rack con Rack Middleware e a eseguirla con Puma (Application Server).

Installare le dipendenze

Assicuratevi di avere il scaffale e la gemma puma gemma installata.

gemma installare rack
gemma installare puma

Creare il file di configurazione

Per prima cosa, dobbiamo creare un file chiamato config.ru e questo file farà uso di
il DSL Rack::Builder per eseguire l'applicazione e aggiungere il middleware.

Aggiungere l'applicazione Rack

All'interno del config.ru aggiungeremo la semplice applicazione Rack definita in
le sezioni precedenti.

# config.ru

classe RackApp
  def call(env)
    stato = 200
    headers = { 'Content-Type' => 'text/html' }
    body = ['<h1>L'applicazione My Rack<h1>']

    [stato, intestazioni, corpo]
  fine
fine

Aggiungere il middleware Rack

Qui apporteremo una piccola modifica al nostro semplice middleware e ora aggiungerà il software del server al nostro corpo HTML dopo l'esecuzione.

# config.ru

classe RackMiddleware
  def initialize(app)
    @app = app
  fine

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

    body << env['SERVER_SOFTWARE']

    [status, header, body]
  fine
fine

Eseguire il server delle applicazioni

Come ultimo passo, eseguiamo il server e vediamo la nostra applicazione in funzione. Il nostro config.ru Il file avrà il seguente aspetto:

# config.ru

classe RackApp
  def call(env)
    stato = 200
    headers = { 'Content-Type' => 'text/html' }
    body = ['<h1>L'applicazione My Rack<h1>']

    [status, header, body]
  fine
fine

classe RackMiddleware
  def initialize(app)
    @app = app
  fine

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

    corpo <&lt; env[&#039;SERVER_SOFTWARE&#039;]

    [status, header, body]
  fine
fine

utilizzare RackMiddleware
eseguire RackApp.new

Nelle ultime righe, si specifica il middleware usando utilizzo ed eseguiamo l'applicazione utilizzando correre.Siamo pronti ad eseguire rackup nella nostra console e vedremo il server in esecuzione. Possiamo controllare la porta su cui è in esecuzione la nostra applicazione e dovremmo vedere qualcosa di simile dopo l'accesso:

Conclusioni

A volte è bene tornare alle basi e conoscere le intuizioni della tecnologia con cui lavoriamo. Imparare Rack ci dà una chiara visione d'insieme dell'architettura e ci svela la "magia" che si cela dietro la tecnologia. Quadri web Ruby.