Racks rolle i Ruby-økosystemet

Mens du arbejder med Ruby web frameworks er det almindeligt at tage ting for givet. Vi ved, at frameworket vil håndtere HTTP-anmodningerne og udføre middleware-logikken for os. Når vi bliver mere nysgerrige, begynder vi at spekulere på, hvad der er bag kulisserne, og det er her, vi begynder at høre om Rack.

Hvad er Rack?

Den projekt beskrives som "En modulær Ruby-webservergrænseflade". Rack er den grænseflade, der lader os skabe webapplikationer, der forener API'en for webservere, webframeworks og middleware.

Som beskrevet i ovenstående billede fungerer Rack som en mellemmand mellem vores webapplikation og applikationsserveren, den pakker HTTP-anmodningerne ind i det enkleste
måde som muligt.

Anvendelse af stativ

En Rack-applikation er et Ruby-objekt (ikke en klasse), der reagerer på opkald. Den tager præcis ét argument, nemlig miljø og returnerer et ikke-frossent Array af
præcis tre værdier:

• Den status,
• den overskrifter,

• og den krop.

  Du kan finde de detaljerede specifikationer for en Rack Application her.

kræver 'rack'

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

    [status, headers, body]
  slut
slut

Rack::Handler

Handlere forbinder webservere med Rack. Rack indeholder handlere til Thin, WEBrick, FastCGI, CGI, SCGI og LiteSpeed. Hver applikationsserver, der understøtter Rack, skal
giver en handler til at oprette forbindelsen (Puma har sin egen handler). Handlere aktiveres normalt ved at kalde MyHandler.run(myapp). En anden valgfri hash kan sendes for at inkludere serverspecifik konfiguration.

Brug af tynd applikationsserver

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

Standardfilen til at tilføje konfigurationen er config.ru og du kan udføre den ved hjælp af opsamling kommando i din konsol.

Rack Middleware

Rack giver os mulighed for at oprette middleware-applikationer (applikationer mellem vores primære webapplikation og applikationsserveren). Disse middleware-applikationer kædes sammen og afvikles sekventielt.

Rack Middleware skal implementere alle specifikationerne for en Anvendelse af stativ og opfylde følgende punkter:

• Det må være en klasse,
• har en initializer, der kun modtager én parameter (hovedprogrammet),
• og kalder den næste middleware eller applikation.

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

Rack i praksis

Nu hvor vi kender det grundlæggende, er vi klar til at oprette vores første Rack-applikation med Rack Middleware og køre den ved hjælp af Puma (Application Server).

Installer afhængighederne

Sørg for, at du har stativ ædelsten og Puma perle installeret.

gem install rack
gem installer puma

Opret konfigurationsfilen

Først skal vi oprette en fil, der hedder config.ru og denne fil vil gøre brug af
Rack::Builder DSL til at køre applikationen og tilføje middleware.

Tilføj rack-applikationen

Inden for config.ru fil, vil vi tilføje den simple Rack-applikation, vi definerede i
de foregående afsnit.

# config.ru

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

    [status, headers, body]
  slut
slut

Tilføj Rack Middleware

Her vil vi foretage en lille ændring af vores simple middleware, og nu vil den tilføje serversoftwaren til vores HTML-krop, når den er blevet udført.

# config.ru

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

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

    body << env['SERVER_SOFTWARE']

    [status, headers, body]
  end
slut

Kør applikationsserveren

Som et sidste skridt vil vi køre serveren og se vores applikation køre. Vores config.ru filen vil se ud som følger:

# config.ru

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

    [status, headers, body]
  slut
slut

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

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

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

    [status, headers, body]
  end
slut

Brug RackMiddleware
kør RackApp.new

I de sidste linjer specificerer vi middlewaren ved hjælp af brug og vi kører applikationen ved hjælp af løbe.Vi er klar til at eksekvere opsamling i vores konsol og se, at serveren kører. Vi kan tjekke den port, hvor vores applikation kører, og vi bør se noget i retning af dette, når vi har fået adgang til den:

Konklusioner

Nogle gange er det godt at gå tilbage til det grundlæggende og lære om indsigten i den teknologi, vi arbejder med. Learning Rack giver os et klart overblik over arkitekturen og afslører "magien" bag teknologien. Ruby web-frameworks.