Racks rolle i Ruby-økosystemet

I arbeidet med Ruby webrammeverk er det vanlig å ta ting for gitt. Vi vet at rammeverket vil håndtere HTTP-forespørsler og utføre mellomvarelogikken for oss. Etter hvert som vi blir mer nysgjerrige, begynner vi å lure på hva som befinner seg bak kulissene, og det er her vi begynner å høre om Rack.

Hva er Rack?

Den prosjekt beskrives som "Et modulært Ruby-webservergrensesnitt". Rack er grensesnittet som lar oss lage webapplikasjoner som forener API-et for webservere, webrammeverk og mellomvare.

Som beskrevet i bildet ovenfor, fungerer Rack som en mellommann mellom webapplikasjonen vår og applikasjonsserveren, og pakker inn HTTP-forespørsler i den enkleste
mulig måte.

Stativapplikasjon

En Rack-applikasjon er et Ruby-objekt (ikke en klasse) som svarer på samtale. Den tar nøyaktig ett argument, nemlig miljø og returnerer et ikke-frossent Array av
nøyaktig tre verdier:

• Den status,
• den overskrifter,

• og kropp.

  Du finner en detaljert spesifikasjon av en Rack Application her.

krever 'rack'

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

    [status, headers, body]
  end
end

Rack::Handler

Håndterere kobler webservere til Rack. Rack inkluderer handlere for Thin, WEBrick, FastCGI, CGI, SCGI og LiteSpeed. Hver applikasjonsserver som støtter Rack, bør
tilbyr en håndterer for å opprette tilkoblingen (Puma har sin egen håndterer) Håndtererne aktiveres vanligvis ved å kalle MyHandler.run(myapp). En annen valgfri hash kan sendes for å inkludere serverspesifikk konfigurasjon.

Bruk av tynn applikasjonsserver

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

Standardfilen for å legge til konfigurasjonen er config.ru og du kan utføre den ved hjelp av rackup kommandoen i konsollen din.

Rack Middleware

Rack gjør det mulig å lage mellomvareapplikasjoner (applikasjoner mellom hovedwebapplikasjonen og applikasjonsserveren). Disse mellomvareapplikasjonene er lenket sammen og kjøres sekvensielt.

Rack Middleware må implementere alle spesifikasjonene til en Stativapplikasjon og oppfylle følgende punkter:

• Det må være en klasse,
• har en initialiser som bare mottar én parameter (hovedapplikasjonen),
• og kaller neste mellomvare eller applikasjon.

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

Rack i praksis

Nå som vi kan det grunnleggende, er vi klare til å lage vår første Rack-applikasjon med Rack Middleware og kjøre den ved hjelp av Puma (Application Server).

Installer avhengighetene

Sørg for at du har stativ edelstenen og puma perle installert.

gem install rack
gem install puma

Opprett konfigurasjonsfilen

Først må vi opprette en fil som heter config.ru og denne filen vil gjøre bruk av
Rack::Builder DSL for å kjøre applikasjonen og legge til mellomvaren.

Legg til Rack-applikasjonen

Innenfor config.ru filen, vil vi legge til den enkle Rack-applikasjonen vi definerte i
de foregående avsnittene.

# config.ru

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

    [status, headers, body]
  end
end

Legg til Rack Middleware

Her vil vi gjøre en liten endring i vår enkle mellomvare, og nå vil den legge til serverprogramvaren i HTML-kroppen etter at den er kjørt.

# 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

Kjør applikasjonsserveren

Som et siste trinn kjører vi serveren og ser at applikasjonen vår kjører. Vår config.ru filen vil se ut 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]
  end
end

klasse 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

bruk RackMiddleware
kjør RackApp.new

I de siste linjene spesifiserer vi mellomvaren ved hjelp av bruk og vi kjører applikasjonen ved hjelp av løp.Vi er klare til å gjennomføre rackup i konsollen vår og se at serveren kjører. Vi kan sjekke porten der applikasjonen vår kjører, og vi bør se noe sånt som dette etter å ha fått tilgang til den:

Konklusjoner

Noen ganger er det godt å gå tilbake til det grunnleggende og lære om innsikten i teknologien vi jobber med. Learning Rack gir oss en klar oversikt over arkitekturen og avslører "magien" bak Ruby webrammeverk.