Le rôle de Rack dans l'écosystème Ruby

En travaillant avec Rubis web cadres il est courant de prendre les choses pour acquises. Nous savons que le cadre traitera les requêtes HTTP et exécutera la logique de l'intergiciel pour nous. Plus nous sommes curieux, plus nous nous demandons ce qui se passe en coulisses, et c'est là que nous commençons à entendre parler de Rack.

Qu'est-ce que Rack ?

Les projet est décrit comme "une interface modulaire de serveur web Ruby". Rack est l'interface qui nous permet de créer des applications web en unifiant l'API pour les serveurs web, les frameworks web et les middleware.

Comme décrit dans l'image ci-dessus, Rack agit comme un intermédiaire entre notre application Web et le serveur d'application, il enveloppe les requêtes HTTP dans le plus simple des systèmes d'information.
de la manière la plus efficace possible.

Application en rack

Une application Rack est un objet Ruby (et non une classe) qui répond à une demande de appel. Elle prend exactement un argument, le l'environnement et renvoie un tableau non gelé de
exactement trois valeurs :

• Les statut,
• les en-têtes,

• et le corps.

  Vous pouvez trouver la spécification détaillée d'une application Rack ici.

nécessite 'rack'

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

    [status, headers, body]
  end
fin

Rack::Handler

Les gestionnaires connectent les serveurs web à Rack. Rack comprend des gestionnaires pour Thin, WEBrick, FastCGI, CGI, SCGI et LiteSpeed. Chaque serveur d'application qui prend en charge Rack doit
fournissent un gestionnaire pour créer la connexion (Puma a son propre gestionnaire). Les gestionnaires sont généralement activés en appelant la commande MyHandler.run(myapp). Une deuxième option hachage peut être transmis pour inclure une configuration spécifique au serveur.

Utilisation du serveur d'application Thin

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

Le fichier par défaut pour ajouter la configuration est config.ru et vous pouvez l'exécuter en utilisant rackup dans votre console.

Logiciel médiateur pour rack

Rack nous permet de créer des applications intermédiaires (applications entre notre application web principale et le serveur d'application). Ces applications intermédiaires sont enchaînées et exécutées de manière séquentielle.

L'intergiciel de rack doit mettre en œuvre toutes les spécifications d'un Application en rack et répondre aux points suivants :

• Il doit s'agir d'une classe,
• ont un initialisateur qui ne reçoit qu'un seul paramètre (l'application principale),
• et appeler l'intergiciel suivant ou l'application.

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

Rack en pratique

Maintenant que nous connaissons les bases, nous sommes prêts à créer notre première application Rack avec Rack Middleware et à l'exécuter à l'aide de Puma (Application Server).

Installer les dépendances

Assurez-vous d'avoir le support et le puma gem installé.

gem install rack
gem install puma

Créer le fichier de configuration

Tout d'abord, nous devons créer un fichier appelé config.ru et ce fichier utilisera
le DSL Rack::Builder pour exécuter l'application et ajouter l'intergiciel.

Ajouter l'application Rack

Dans le cadre de la config.ru nous ajouterons l'application Rack simple que nous avons définie dans le fichier
les sections précédentes.

# config.ru

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

    [status, headers, body]
  end
fin

Ajouter l'intergiciel Rack

Nous allons ici apporter une petite modification à notre intergiciel simple, qui ajoutera désormais le logiciel serveur à notre corps HTML après son exécution.

# config.ru

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

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

    body << env['SERVER_SOFTWARE']

    [status, headers, body]
  end
fin

Exécuter le serveur d'application

Pour terminer, nous allons lancer le serveur et voir notre application fonctionner. Notre config.ru se présentera comme suit :

# config.ru

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

    [status, headers, body]
  end
fin

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

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

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

    [status, headers, body]
  end
fin

utiliser RackMiddleware
exécuter RackApp.new

Dans les dernières lignes, nous spécifions l'intergiciel à l'aide de utiliser et nous exécutons l'application en utilisant courir.Nous sommes prêts à exécuter rackup dans notre console et voir le serveur fonctionner. Nous pouvons vérifier le port sur lequel tourne notre application et nous devrions voir quelque chose comme ceci après y avoir accédé :

Conclusions

Il est parfois bon de revenir aux bases et d'apprendre à mieux connaître la technologie avec laquelle nous travaillons. L'apprentissage de Rack nous donne une vue d'ensemble claire de l'architecture et révèle la "magie" qui se cache derrière la technologie. Cadres Web Ruby.