Ruby Academy · Lekcja

Middleware i Rack

Stos Rack

Middleware i Rack to bezpłatna lekcja Ruby Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Ruby Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Ruby Academy zawiera 4 lekcji w sumie.

Czym jest Rack

Rack to minimalny interfejs między serwerami WWW Ruby a frameworkami. Sinatra, Rails i inne rozwiązania działają na Rack.

Standaryzuje sposób przepływu żądań i odpowiedzi
Umożliwia ponowne używanie middleware
Aplikacją Rack jest wszystko, co odpowiada na call(env)

app = lambda do |env|
  [200, { 'Content-Type' => 'text/plain' }, ['Hello Rack']]
end

puts app.call({}).inspect

Kontrakt Rack

Metoda call aplikacji Rack musi zwracać tablicę złożoną z trzech elementów:

Całkowitoliczbowy status (np. 200)
Hash nagłówków
Treść implementująca each (zwykle tablica ciągów znaków)

status, headers, body = 200, { 'Content-Type' => 'text/html' }, ['<h1>Hi</h1>']
puts status
puts headers.inspect
body.each { |chunk| puts chunk }

Hash env

Argument env jest hashem opisującym żądanie.

REQUEST_METHOD, na przykład GET lub POST
PATH_INFO, czyli żądana ścieżka
QUERY_STRING, czyli surowe parametry zapytania

env = { 'REQUEST_METHOD' => 'GET', 'PATH_INFO' => '/home' }
puts "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"

Czym jest middleware

Middleware opakowuje aplikację, aby dodać działanie wykonywane przed dotarciem żądania do aplikacji lub po nim.

Logowanie, uwierzytelnianie i kompresja
Każdy middleware również odpowiada na call(env)
Wywołuje następną aplikację w łańcuchu

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

  def call(env)
    puts "Request: #{env['PATH_INFO']}"
    @app.call(env)
  end
end

Budowanie klasy middleware

Middleware przechowuje opakowaną aplikację i przekazuje do niej wywołanie w call.

Konstruktor otrzymuje wewnętrzną aplikację
call może zmodyfikować env, a następnie przekazać żądanie dalej
Może również zmodyfikować odpowiedź podczas jej powrotu

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

  def call(env)
    status, headers, body = @app.call(env)
    new_body = body.map(&:upcase)
    [status, headers, new_body]
  end
end

puts 'Middleware defined'

Stos middleware

Middleware tworzy stos. Żądanie przepływa w dół do aplikacji, a odpowiedź wraca w górę.

Zewnętrzny middleware wykonuje się jako pierwszy podczas obsługi żądania
Zewnętrzny middleware wykonuje się jako ostatni podczas zwracania odpowiedzi

inner = lambda { |env| [200, {}, ['core']] }

class Wrap
  def initialize(app); @app = app; end
  def call(env)
    s, h, b = @app.call(env)
    [s, h, b.map { |x| "[#{x}]" }]
  end
end

puts Wrap.new(inner).call({}).last.inspect

Używanie middleware w Sinatra

Dodaj middleware do aplikacji Sinatra za pomocą use.

use Rack::Logger
Kolejność wywołań use określa kolejność elementów stosu

require 'sinatra'

use Rack::Logger

get '/' do
  'Logged request'
end

config.ru i rackup

Plik config.ru uruchamia aplikację Rack za pomocą rackup lub Puma.

run ustawia końcową aplikację
use dodaje przed nią middleware

# config.ru
require './app'
use Rack::CommonLogger
run Sinatra::Application

Typowe wbudowane middleware

Rack zawiera przydatne middleware.

Rack::CommonLogger — logi żądań
Rack::Deflater — kompresja gzip
Rack::Static — serwowanie plików
Rack::Session::Cookie — sesje

# In config.ru
# use Rack::Deflater
# use Rack::Static, urls: ['/assets'], root: 'public'
puts 'See comments for usage'

Modyfikowanie odpowiedzi

Middleware często dodaje nagłówki odpowiedzi po wykonaniu wewnętrznej aplikacji.

Przechwyć trójkę elementów odpowiedzi
Zmień nagłówki, a następnie ją zwróć

class AddHeader
  def initialize(app); @app = app; end
  def call(env)
    status, headers, body = @app.call(env)
    headers['X-Powered-By'] = 'Ruby'
    [status, headers, body]
  end
end

app = AddHeader.new(lambda { |e| [200, {}, ['ok']] })
puts app.call({})[1].inspect

Przerywanie obsługi żądań

Middleware może zatrzymać żądanie bez wywoływania wewnętrznej aplikacji.

Przydaje się w przypadku bramek uwierzytelniania lub limitów liczby żądań
Zwróć bezpośrednio trójkę elementów odpowiedzi

class Auth
  def initialize(app); @app = app; end
  def call(env)
    return [401, {}, ['Unauthorized']] unless env['token']
    @app.call(env)
  end
end

app = Auth.new(lambda { |e| [200, {}, ['ok']] })
puts app.call({})[0]

Szybkie sprawdzenie

Proszę sprawdzić znajomość Rack.

Podsumowanie

Nauczyli się Państwo korzystać ze stosu Rack:

Rack to wspólny interfejs znajdujący się pod frameworkami WWW Ruby
Aplikacja Rack odpowiada na call(env) i zwraca [status, headers, body]
Middleware opakowuje aplikację, aby dodać przekrojowe działanie
Użyj use w Sinatra lub config.ru, aby skomponować stos
Middleware może modyfikować odpowiedzi lub przerywać obsługę żądań

Często zadawane pytania

Czy lekcja „Middleware i Rack” jest bezpłatna?

Tak — pełny tekst „Middleware i Rack” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Ruby Academy, przejdź na CoddyKit PRO. Kurs Ruby Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Middleware i Rack”?

Stos Rack Ćwiczysz Ruby Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Ruby Academy?

Nie wymagamy żadnego doświadczenia. Ruby Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Middleware i Rack”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Ruby Academy?

Tak. Każda lekcja Ruby Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Ruby Academy