Ruby Academy · Aula

Middleware e Rack

A pilha do Rack.

Middleware e Rack é uma aula grátis de Ruby Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Ruby Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Ruby Academy inclui 4 aulas no total.

O que é Rack?

Rack é a interface mínima entre servidores web Ruby e estruturas de desenvolvimento. Sinatra, Rails e outras estruturas são executadas no Rack.

Padroniza o fluxo de requisições e respostas
Permite middleware reutilizável
Um aplicativo Rack é qualquer objeto que responda a call(env)

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

puts app.call({}).inspect

O Contrato do Rack

O call de um aplicativo Rack deve retornar uma matriz de três elementos:

Inteiro de status (por exemplo, 200)
Hash de cabeçalhos
Corpo que responda a each (geralmente uma matriz de cadeias de caracteres)

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

O Hash env

O argumento env é um hash que descreve a requisição.

REQUEST_METHOD, como GET ou POST
PATH_INFO, o caminho solicitado
QUERY_STRING, os parâmetros brutos da consulta

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

O que é Middleware?

Middleware envolve um aplicativo para adicionar comportamento antes ou depois que a requisição chega até ele.

Registro, autenticação e compactação
Cada middleware também responde a call(env)
Ele chama o próximo aplicativo na cadeia

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

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

Criando uma Classe de Middleware

O middleware armazena o aplicativo envolvido e delega a ele em call.

O construtor recebe o aplicativo interno
call pode modificar env e depois encaminhar a requisição
Ele também pode alterar a resposta no caminho de volta

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'

A Pilha de Middleware

O middleware forma uma pilha. A requisição desce até o aplicativo, e a resposta sobe de volta.

O middleware externo é executado primeiro na entrada
O middleware externo é executado por último na saída

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

Usando Middleware no Sinatra

Adicione middleware a um aplicativo Sinatra com use.

use Rack::Logger
A ordem das chamadas de use define a ordem da pilha

require 'sinatra'

use Rack::Logger

get '/' do
  'Logged request'
end

config.ru e rackup

Um arquivo config.ru inicializa um aplicativo Rack com rackup ou Puma.

run define o aplicativo final
use adiciona middleware antes dele

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

Middleware Integrado Comum

O Rack vem com middleware úteis.

Rack::CommonLogger registra requisições
Rack::Deflater compacta com gzip
Rack::Static serve arquivos
Rack::Session::Cookie gerencia sessões

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

Modificando a Resposta

O middleware geralmente adiciona cabeçalhos de resposta depois que o aplicativo interno é executado.

Capture a tupla de resposta
Altere os cabeçalhos e depois retorne a tupla

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

Interrompendo Requisições Antecipadamente

O middleware pode interromper uma requisição sem chamar o aplicativo interno.

Isso é útil para barreiras de autenticação ou limites de taxa
Retorne uma tupla de resposta diretamente

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]

Verificação rápida

Verifique sua compreensão sobre Rack.

Recapitulação

Você aprendeu sobre a pilha do Rack:

Rack é a interface comum subjacente às estruturas web Ruby
Um aplicativo Rack responde a call(env) e retorna [status, headers, body]
O middleware envolve um aplicativo para adicionar comportamento transversal
Use use no Sinatra ou config.ru para compor a pilha
O middleware pode modificar respostas ou interromper requisições antecipadamente

Perguntas Frequentes

A aula “Middleware e Rack” é grátis?

Sim — o texto completo de “Middleware e Rack” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Ruby Academy, atualize para CoddyKit PRO. O curso de Ruby Academy inclui 4 aulas no total.

O que vou aprender em “Middleware e Rack”?

A pilha do Rack. Você pratica Ruby Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Ruby Academy?

Nenhuma experiência prévia é necessária. Ruby Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Middleware e Rack”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Ruby Academy?

Sim. Cada aula de Ruby Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Ruby Academy