Ruby Academy · Leçon

Intergiciel et Rack

La pile Rack

Intergiciel et Rack est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Ruby Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Ruby Academy comprend 4 leçons au total.

Qu’est-ce que Rack ?

Rack est l’interface minimale entre les serveurs web Ruby et les cadres logiciels. Sinatra, Rails et d’autres s’exécutent tous sur Rack.

Uniformise la circulation des requêtes et des réponses
Permet de réutiliser les intergiciels
Une application Rack est toute application qui répond à call(env)

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

puts app.call({}).inspect

Le contrat Rack

La méthode call d’une application Rack doit renvoyer un tableau à trois éléments :

Statut entier (par ex. 200)
En-têtes hachage
Corps qui répond à each (généralement un tableau de chaînes)

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

Le hachage env

L’argument env est un hachage qui décrit la requête.

REQUEST_METHOD comme GET ou POST
PATH_INFO le chemin demandé
QUERY_STRING les paramètres de requête bruts

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

Qu’est-ce qu’un intergiciel ?

Un intergiciel enveloppe une application pour ajouter un comportement avant ou après que la requête l’atteigne.

Journalisation, authentification, compression
Chaque intergiciel répond également à call(env)
Il appelle l’application suivante de la chaîne

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

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

Construire une classe d’intergiciel

L’intergiciel conserve l’application enveloppée et lui délègue l’exécution dans call.

Le constructeur reçoit l’application interne
call peut modifier env, puis transmettre la requête
Il peut également modifier la réponse sur le chemin du retour

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'

La pile d’intergiciels

Les intergiciels forment une pile. La requête descend jusqu’à l’application, puis la réponse remonte.

L’intergiciel externe s’exécute en premier à l’aller
L’intergiciel externe s’exécute en dernier au retour

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

Utiliser des intergiciels dans Sinatra

Ajoutez un intergiciel à une application Sinatra avec use.

use Rack::Logger
L’ordre des appels à use définit l’ordre de la pile

require 'sinatra'

use Rack::Logger

get '/' do
  'Logged request'
end

config.ru et rackup

Un config.ru démarre une application Rack avec rackup ou Puma.

run définit l’application finale
use ajoute un intergiciel avant celle-ci

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

Intergiciels intégrés courants

Rack fournit des intergiciels utiles.

Rack::CommonLogger journaux des requêtes
Rack::Deflater compression gzip
Rack::Static sert des fichiers
Rack::Session::Cookie sessions

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

Modifier la réponse

Un intergiciel ajoute souvent des en-têtes de réponse après l’exécution de l’application interne.

Récupérez le triplet de réponse
Modifiez les en-têtes, puis renvoyez-le

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

Interrompre rapidement les requêtes

Un intergiciel peut interrompre une requête sans appeler l’application interne.

Utile pour les contrôles d’authentification ou les limites de débit
Renvoyez directement un triplet de réponse

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]

Vérification rapide

Vérifiez votre compréhension de Rack.

Récapitulatif

Vous avez découvert la pile Rack :

Rack est l’interface commune sous-jacente aux cadres logiciels web Ruby
Une application Rack répond à call(env) et renvoie [status, headers, body]
Un intergiciel enveloppe une application pour ajouter un comportement transversal
Utilisez use dans Sinatra ou config.ru pour composer la pile
Un intergiciel peut modifier les réponses ou interrompre rapidement les requêtes

Questions Fréquemment Posées

La leçon « Intergiciel et Rack » est-elle gratuite ?

Oui — le texte complet de « Intergiciel et Rack » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Ruby Academy, passe à CoddyKit PRO. Le cours Ruby Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Intergiciel et Rack » ?

La pile Rack Tu pratiques Ruby Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Ruby Academy ?

Aucune expérience préalable n'est requise. Ruby Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Intergiciel et Rack » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Ruby Academy ?

Oui. Chaque leçon Ruby Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Ruby Academy