Racks roll i Rubys ekosystem

Under arbetet med Ruby webbramverk är det vanligt att ta saker för givna. Vi vet att ramverket kommer att hantera HTTP-förfrågningarna och utföra middleware-logiken åt oss. När vi blir mer nyfikna börjar vi undra vad som finns bakom kulisserna, och det är där vi börjar höra talas om Rack.

Vad är Rack?

Den projekt beskrivs som "Ett modulärt Ruby-webbservergränssnitt". Rack är gränssnittet som låter oss skapa webbapplikationer som förenar API för webbservrar, webbramverk och middleware.

Som beskrivs i bilden ovan fungerar Rack som en mellanhand mellan vår webbapplikation och applikationsservern, och kapslar in HTTP-förfrågningarna i den enklaste
sätt som möjligt.

Rack-applikation

En Rack-applikation är ett Ruby-objekt (inte en klass) som svarar på samtal. Det tar exakt ett argument, det miljö och returnerar en icke-frusen Array av
exakt tre värden:

• Den status,
• den rubriker,

• och kropp.

  Du kan hitta den detaljerade specifikationen för en Rack Application här.

kräver "rack

klass RackApp
  def call(env)
        status = 200
        headers = { 'Content-Type' => 'text/html' }
        body = ['<h1>Min Rack-app<h1>']

    [status, rubriker, text]
  slut
slut

Rack::Hanterare

Hanterare kopplar samman webbservrar med Rack. Rack innehåller hanterare för Thin, WEBrick, FastCGI, CGI, SCGI och LiteSpeed. Varje applikationsserver som stöder Rack bör
tillhandahålla en hanterare för att skapa anslutningen (Puma har sin egen hanterare).Hanterare aktiveras vanligtvis genom att anropa MyHandler.run(myapp). En andra valfri hash kan skickas för att inkludera serverspecifik konfiguration.

Använda Thin Application Server

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

Standardfilen för att lägga till konfigurationen är config.ru och du kan köra den med hjälp av rackup kommandot i din konsol.

Rack Middleware

Rack gör det möjligt för oss att skapa middleware-applikationer (applikationer mellan vår huvudsakliga webbapplikation och applikationsservern). Dessa middleware-applikationer kedjas ihop och körs sekventiellt.

Rack Middleware måste implementera alla specifikationer för en Rack-applikation och uppfylla följande punkter:

• Det måste vara en klass,
• har en initialiserare som bara tar emot en parameter (huvudapplikationen),
• och anropa nästa mellanprogram eller applikation.

klass RackMiddleware
def initialize(app)
@app = app
slut
def anrop(env)
@app.call(env)
end
slut

Rack till praktik

Nu när vi har lärt oss grunderna är vi redo att skapa vår första Rack Application med Rack Middleware och köra den med Puma (Application Server).

Installera beroendena

Se till att du har rack ädelsten och puma gem installerad.

gem installera rack
gem installera puma

Skapa konfigurationsfilen

Först måste vi skapa en fil som heter config.ru och denna fil kommer att använda sig av
Rack::Builder DSL för att köra programmet och lägga till middleware.

Lägg till Rack-applikationen

Inom config.ru filen lägger vi till den enkla Rack Application som vi definierade i
de föregående avsnitten.

# config.ru

klass RackApp
  def call(env)
    status = 200
    headers = { 'Content-Type' => 'text/html' }
    body = ['<h1>Min Rack-app<h1>']

    [status, rubriker, text]
  slut
slut

Lägg till Rack Middleware

Här kommer vi att göra en liten ändring av vår enkla middleware och nu kommer den att lägga till serverprogramvaran i vår HTML-kropp efter att ha exekverats.

# config.ru

klass RackMiddleware
  def initialize(app)
    @app = app
  slut

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

    body << env['SERVER_SOFTWARE']

    [status, rubriker, body]
  slut
slut

Kör applikationsservern

Som ett sista steg kommer vi att köra servern och se att vår applikation körs. Vår config.ru filen kommer att se ut på följande sätt:

# config.ru

klass RackApp
  def call(env)
    status = 200
    headers = { 'Content-Type' => 'text/html' }
    body = ['<h1>Min Rack-app<h1>']

    [status, rubriker, text]
  slut
slut

klass RackMiddleware
  def initialize(app)
    @app = app
  slut

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

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

    [status, rubriker, text]
  slut
slut

Använd RackMiddleware
kör RackApp.new

I de sista raderna specificerar vi mellanvaran med hjälp av användning och vi kör applikationen med hjälp av kör.Vi är redo att verkställa rackup i vår konsol och se att servern körs. Vi kan kontrollera porten där vår applikation körs och vi bör se något liknande efter att ha kommit åt den:

Slutsatser

Ibland är det bra att gå tillbaka till grunderna och lära sig om insikterna i den teknik vi arbetar med. Learning Rack ger oss en tydlig överblick över arkitekturen och avslöjar "magin" bakom Ruby webbramverk.