Rola Rack w ekosystemie Ruby

Podczas pracy z Struktury internetowe Ruby często przyjmujemy pewne rzeczy za pewnik. Wiemy, że framework obsłuży żądania HTTP i wykona dla nas logikę oprogramowania pośredniczącego. Gdy stajemy się bardziej ciekawi, zaczynamy zastanawiać się, co kryje się za kulisami, zaczynamy słyszeć o Rack.

Co to jest Rack?

The projekt jest opisywany jako "modułowy interfejs serwera WWW Ruby". Rack to interfejs, który pozwala nam tworzyć aplikacje internetowe ujednolicające API dla serwerów internetowych, frameworków internetowych i oprogramowania pośredniczącego.

Jak opisano na powyższym obrazku, Rack działa jako pośrednik między naszą aplikacją internetową a serwerem aplikacji, opakowując żądania HTTP w najprostszy sposób.
sposób.

Zastosowanie stojaka

Aplikacja Rack jest obiektem Ruby (nie klasą), który reaguje na połączenie. Przyjmuje dokładnie jeden argument, wartość środowisko i zwraca niezamrożoną tablicę
dokładnie trzy wartości:

• The status,
• w nagłówki,

• i ciało.

  Szczegółową specyfikację aplikacji Rack można znaleźć pod adresem tutaj.

require 'rack'

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

    [status, headers, body]
  end
end

Rack::Handler

Handlers łączą serwery internetowe z Rack. Rack zawiera Handlers dla Thin, WEBrick, FastCGI, CGI, SCGI i LiteSpeed. Każdy serwer aplikacji obsługujący Rack powinien
udostępniają handler do tworzenia połączenia (Puma ma własny handler). Handlery są zwykle aktywowane przez wywołanie MyHandler.run(myapp). Drugi opcjonalny hash może zostać przekazany w celu dołączenia konfiguracji specyficznej dla serwera.

Korzystanie z serwera aplikacji Thin

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

Domyślnym plikiem do dodania konfiguracji jest config.ru i można go wykonać przy użyciu rackup w konsoli.

Rack Middleware

Rack pozwala nam tworzyć aplikacje pośredniczące (aplikacje między naszą główną aplikacją internetową a serwerem aplikacji). Te aplikacje pośredniczące są łączone w łańcuchy i wykonywane sekwencyjnie.

Rack Middleware musi implementować wszystkie specyfikacje Zastosowanie stojaka i spełniają następujące punkty:

• To musi być klasa,
• mają inicjalizator, który otrzymuje tylko jeden parametr (główną aplikację),
• i wywołać kolejne oprogramowanie pośredniczące lub aplikację.

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

Rack w praktyce

Teraz, gdy znamy już podstawy, jesteśmy gotowi stworzyć naszą pierwszą aplikację Rack z Rack Middleware i uruchomić ją za pomocą Pumy (serwera aplikacji).

Zainstaluj zależności

Upewnij się, że masz stojak klejnot i puma zainstalowany klejnot.

gem install rack
gem install puma

Tworzenie pliku konfiguracyjnego

Najpierw musimy utworzyć plik o nazwie config.ru i ten plik będzie korzystał z
Rack::Builder DSL, aby uruchomić aplikację i dodać oprogramowanie pośredniczące.

Dodaj aplikację Rack

W ramach config.ru dodamy prostą aplikację Rack, którą zdefiniowaliśmy w pliku
poprzednie sekcje.

# config.ru

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

    [status, headers, body]
  end
end

Dodaj oprogramowanie Rack Middleware

W tym miejscu dokonamy niewielkiej modyfikacji naszego prostego oprogramowania pośredniczącego, które po wykonaniu doda oprogramowanie serwera do treści HTML.

# config.ru

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

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

    body << env['SERVER_SOFTWARE']

    [status, headers, body]
  end
end

Uruchomienie serwera aplikacji

Na koniec uruchomimy serwer i zobaczymy, jak działa nasza aplikacja. Nasz config.ru będzie wyglądał następująco:

# config.ru

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

    [status, headers, body]
  end
end

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

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

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

    [status, headers, body]
  end
end

use RackMiddleware
run RackApp.new

W ostatnich linijkach określamy oprogramowanie pośredniczące za pomocą użycie i uruchamiamy aplikację przy użyciu bieg.Jesteśmy gotowi do realizacji rackup w naszej konsoli i zobaczymy uruchomiony serwer. Możemy sprawdzić port, na którym działa nasza aplikacja i powinniśmy zobaczyć coś takiego po uzyskaniu do niego dostępu:

Wnioski

Czasami dobrze jest wrócić do podstaw i poznać wgląd w technologię, z którą pracujemy. Nauka Rack daje nam jasny przegląd architektury i ujawnia "magię" stojącą za technologią. Ruby Web Frameworks.