Il ruolo di Rack nell'ecosistema Ruby

Mentre si lavora con Rubino strutture web it’s common to take things for granted. We know the framework will handle the HTTP requests and execute the middleware logic for us. As we get more curious we start wondering what is behind the scenes, there’s where we start hearing about 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.