O papel do Rack no ecossistema Ruby

Ao trabalhar com Rubi estruturas web é comum tomarmos as coisas como garantidas. Sabemos que a estrutura irá lidar com as solicitações HTTP e executar a lógica do middleware para nós. À medida que ficamos mais curiosos, começamos a perguntar-nos o que está por detrás dos bastidores, e é aí que começamos a ouvir falar de Rack.

O que é o Rack?

O projeto é descrito como "Uma interface modular de servidor web Ruby". Rack é a interface que nos permite criar aplicações Web unificando a API para servidores Web, estruturas Web e middleware.

Tal como descrito na imagem acima, o Rack actua como intermediário entre a nossa aplicação Web e o servidor de aplicações, envolvendo os pedidos HTTP na forma mais simples de
forma possível.

Aplicação em bastidor

Uma aplicação Rack é um objeto Ruby (não uma classe) que responde a chamada. Recebe exatamente um argumento, o ambiente e devolve uma matriz não congelada de
exatamente três valores:

• O estatuto,
• a cabeçalhos,

• e o corpo.

  Pode encontrar a especificação pormenorizada de uma aplicação em bastidor aqui.

requerer 'rack'

classe RackApp
  def call(env)
        status = 200
        headers = { 'Content-Type' => 'text/html' }
        body = ['<h1>A minha aplicação Rack<h1>']

    [status, cabeçalhos, corpo]
  fim
fim

Rack::Manipulador

Os manipuladores ligam os servidores Web ao Rack. O Rack inclui manipuladores para Thin, WEBrick, FastCGI, CGI, SCGI e LiteSpeed. Cada servidor de aplicações que suporta o Rack deve
fornecem um manipulador para criar a ligação (o Puma tem o seu próprio manipulador). Os manipuladores são normalmente activados chamando MyHandler.run(myapp). Pode ser passado um segundo hash opcional para incluir a configuração específica do servidor.

Utilizar o servidor de aplicações Thin

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

O ficheiro predefinido para adicionar a configuração é config.ru e pode executá-lo utilizando rackup na sua consola.

Middleware de bastidor

O Rack permite-nos criar aplicações de middleware (aplicações entre a nossa aplicação Web principal e o servidor de aplicações). Estas aplicações de middleware são encadeadas e executadas sequencialmente.

O Rack Middleware deve implementar todas as especificações de um Aplicação em bastidor e satisfazer os seguintes pontos:

• Deve ser uma aula,
• têm um inicializador que recebe apenas um parâmetro (a aplicação principal),
• e chamar o middleware seguinte ou a aplicação.

classe RackMiddleware
def initialize(app)
@app = app
fim
def call(env)
@app.call(env)
fim
fim

Rack na prática

Agora que sabemos o básico, estamos prontos para criar a nossa primeira aplicação Rack com Rack Middleware e executá-la usando o Puma (Servidor de aplicações).

Instalar as dependências

Certifique-se de que tem o estante gema e o puma gem instalada.

gem install rack
gem install puma

Criar o ficheiro de configuração

Primeiro, temos de criar um ficheiro chamado config.ru e este ficheiro utilizará
o Rack::Builder DSL para executar a aplicação e adicionar o middleware.

Adicionar a aplicação Rack

No âmbito do config.ru vamos adicionar a aplicação Rack simples que definimos em
as secções anteriores.

# config.ru

classe RackApp
  def call(env)
    status = 200
    headers = { 'Content-Type' => 'text/html' }
    body = ['<h1>A minha aplicação Rack<h1>']

    [status, cabeçalhos, corpo]
  fim
fim

Adicionar o middleware de bastidor

Aqui vamos fazer uma pequena modificação no nosso middleware simples e agora ele vai adicionar o software do servidor ao nosso corpo HTML depois de ser executado.

# config.ru

classe RackMiddleware
  def initialize(app)
    @app = app
  fim

  def call(env)
    status, cabeçalhos, corpo = @app.call(env)

    body << env['SERVER_SOFTWARE']

    [status, headers, body]
  end
fim

Executar o servidor de aplicações

Como último passo, vamos executar o servidor e ver a nossa aplicação a funcionar. A nossa config.ru terá o seguinte aspeto:

# config.ru

classe RackApp
  def call(env)
    status = 200
    headers = { 'Content-Type' => 'text/html' }
    body = ['<h1>A minha aplicação Rack<h1>']

    [status, cabeçalhos, corpo]
  fim
fim

classe RackMiddleware
  def initialize(app)
    @app = app
  fim

  def call(env)
    status, cabeçalhos, corpo = @app.call(env)

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

    [status, cabeçalhos, corpo]
  end
fim

utilizar RackMiddleware
executar RackApp.new

Nas últimas linhas, especificamos o middleware utilizando utilização e executamos a aplicação utilizando correr.Estamos prontos para executar rackup na nossa consola e ver o servidor a funcionar. Podemos verificar a porta onde a nossa aplicação está a ser executada e devemos ver algo como isto depois de aceder à mesma:

Conclusões

Por vezes é bom voltar ao básico e aprender sobre os conhecimentos da tecnologia com que trabalhamos. Aprender Rack dá-nos uma visão clara da arquitetura e revela a "magia" por detrás da Estruturas Web Ruby.