Rola Rack w ekosystemie Ruby

Podczas pracy z Ruby frameworki internetowe 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.

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.