De rol van Rack in het Ruby-ecosysteem

Tijdens het werken met Ruby webraamwerken is het gebruikelijk om dingen als vanzelfsprekend aan te nemen. We weten dat het framework de HTTP-verzoeken afhandelt en de middleware-logica voor ons uitvoert. Naarmate we nieuwsgieriger worden, beginnen we ons af te vragen wat er zich achter de schermen afspeelt en dat is waar we over Rack beginnen te horen.

Wat is Rack?

De project wordt beschreven als "Een modulaire Ruby webserverinterface". Rack is de interface waarmee we webapplicaties kunnen maken die de API voor webservers, webframeworks en middleware verenigen.

Zoals beschreven in de bovenstaande afbeelding, fungeert Rack als tussenpersoon tussen onze webapplicatie en de applicatieserver, het verpakt de HTTP-verzoeken in de eenvoudigste
manier mogelijk.

Rek Toepassing

Een Rack-applicatie is een Ruby-object (geen klasse) dat reageert op bel. Het neemt precies één argument, de omgeving en retourneert een niet-bevroren array van
precies drie waarden:

• De status,
• de kopteksten,

• en de lichaam.

  U vindt de gedetailleerde specificatie van een Rack Application hier.

vereisen 'rek'

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

    [status, headers, body].
  einde
einde

Rack::Handler

Handlers verbinden webservers met Rack. Rack bevat Handlers voor Thin, WEBrick, FastCGI, CGI, SCGI en LiteSpeed. Elke applicatieserver die Rack ondersteunt moet
bieden een handler om de verbinding te maken (Puma heeft zijn eigen handler).Handlers worden meestal geactiveerd door het aanroepen van MyHandler.run(myapp). Een tweede optionele hash kan worden doorgegeven om server-specifieke configuratie op te nemen.

Thin-toepassingsserver gebruiken

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

Het standaardbestand om de configuratie toe te voegen is config.ru en u kunt het uitvoeren met rackup commando in de console.

Rack middleware

Met Rack kunnen we middleware-applicaties maken (applicaties tussen onze hoofdwebapplicatie en de applicatieserver). Deze middleware-applicaties worden aan elkaar gekoppeld en sequentieel uitgevoerd.

Rack Middleware moet alle specificaties van een Rek Toepassing en voldoen aan de volgende punten:

• Het moet een klas zijn,
• hebben een initializer die slechts één parameter ontvangt (de hoofdtoepassing),
• en de volgende middleware of applicatie aanroepen.

klasse RackMiddleware
def initialiseer(app)
@app = app
einde
def aanroep(env)
@app.call(env)
einde
einde

Rack in de praktijk

Nu we de basis kennen, zijn we klaar om onze eerste Rack-applicatie met Rack Middleware te maken en uit te voeren met Puma (applicatieserver).

De afhankelijkheden installeren

Zorg ervoor dat je de rek edelsteen en de puma gem geïnstalleerd.

gem install rack
gem installeren puma

Het configuratiebestand maken

Eerst moeten we een bestand maken met de naam config.ru en dit bestand zal gebruik maken van
de Rack::Builder DSL om de toepassing uit te voeren en de middleware toe te voegen.

De Rack-toepassing toevoegen

Binnen de config.ru bestand voegen we de eenvoudige Rack applicatie toe die we gedefinieerd hebben in
de vorige secties.

# config.ru

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

    [status, headers, body].
  einde
einde

De Rack Middleware toevoegen

Hier maken we een kleine aanpassing aan onze eenvoudige middleware en nu zal het de serversoftware toevoegen aan onze HTML body nadat het is uitgevoerd.

# config.ru

klasse RackMiddleware
  def initialiseer(app)
    @app = app
  einde

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

    body << env['SERVER_SOFTWARE'].

    [status, headers, body]
  einde
einde

De applicatieserver starten

Als laatste stap laten we de server draaien en zien we onze applicatie draaien. Onze config.ru bestand er als volgt uit:

# config.ru

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

    [status, headers, body].
  einde
einde

klasse RackMiddleware
  def initialiseer(app)
    @app = app
  einde

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

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

    [status, headers, body].
  einde
einde

gebruik RackMiddleware
uitvoeren RackApp.new

In de laatste regels specificeren we de middleware met behulp van gebruik en we voeren de toepassing uit met rennen.We zijn klaar om uit te voeren rackup in onze console en zien dat de server draait. We kunnen de poort controleren waarop onze applicatie draait en we zouden iets als dit moeten zien na het openen:

Conclusies

Soms is het goed om terug te gaan naar de basis en te leren over de inzichten in de technologie waar we mee werken. Het leren van Rack geeft ons een duidelijk overzicht van de architectuur en onthult de "magie" achter de Ruby webraamwerken.