> ## Documentation Index
> Fetch the complete documentation index at: https://docs.appsignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Tutoriels

> Tutoriels Ruby et Rails sur l'installation d'AppSignal, Solid Queue, les jobs en arrière-plan, le débogage, les strong parameters, l'authentification et les fonctionnalités récentes de Rails.

Ces tutoriels ont été produits à l'origine par [GoRails](https://gorails.com/), avec du nouveau contenu rédigé spécifiquement pour les clients AppSignal.

Regardez les vidéos, lisez les guides écrits, ou confiez ces pages à votre agent.

Les [guides](/guides) expliquent comment utiliser AppSignal. Pour une application Rails, commencez par [AppSignal pour Ruby](/ruby) et son [intégration Rails](/ruby/integrations/rails). Ces tutoriels expliquent les outils Ruby et Rails qui produisent les données qu'AppSignal surveille.

<h2 id="meet-chris-oliver">
  Découvrir Chris Oliver
</h2>

GoRails est la bibliothèque de contenu que Chris Oliver publie depuis 2014.

<Frame caption="Chris Oliver, fondateur de GoRails">
  <img src="https://mintcdn.com/appsignal-715f5a51/7bmJ0R9GDWouayDR/assets/images/tutorials/chris-oliver.jpg?fit=max&auto=format&n=7bmJ0R9GDWouayDR&q=85&s=d33a5f49918a508d9fa87bcce7775e5e" alt="Portrait de Chris Oliver" width="400" height="400" data-path="assets/images/tutorials/chris-oliver.jpg" />
</Frame>

En parallèle de GoRails, Chris développe [Jumpstart Pro](https://jumpstartrails.com), un modèle de SaaS Rails, et [Hatchbox](https://hatchbox.io), une plateforme de déploiement qui a géré plus de deux millions de déploiements depuis 2016. Il coanime également le podcast Remote Ruby.

Son travail open source se trouve dans l'arbre de dépendances de nombreuses applications Rails. [`noticed`](https://github.com/excid3/noticed) gère les notifications, [`madmin`](https://github.com/excid3/madmin) les interfaces d'administration, et [`receipts`](https://github.com/excid3/receipts) la facturation, parmi [le reste de ses dépôts](https://github.com/excid3).

C'est cette combinaison qui rend le contenu proposé ici digne d'être republié. Les leçons viennent de quelqu'un qui fait tourner des applications Rails en production, rencontre le problème en premier, puis l'explique.

<h2 id="appsignal-expert-context-store">
  AppSignal Expert Context Store
</h2>

AppSignal propose des fonctionnalités Intelligence fondées sur un context store d'au moins quatre sources de signal.

| Source                                         | Ce qu'elle apporte                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Votre télémétrie                               | [Métriques](/metrics/dashboards), [logs](/logging) et [traces](/performance-tracing) de vos applications et des services qu'elles appellent, [métriques d'hôte et d'infrastructure](/metrics/host-metrics), et [la façon dont les utilisateurs finaux vivent tout cela](/browser-monitoring). Ce qui se passe dans votre stack, en ce moment.                                                                                                                                        |
| Notre documentation                            | Référence AppSignal validée et bonnes pratiques.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Connaissance d'expert                          | Comment fonctionnent ces frameworks d'application et de service, transmise par des praticiens à l'expertise reconnue, présentée dans des tutoriels comme ceux-ci.                                                                                                                                                                                                                                                                                                                    |
| La base de connaissances de votre organisation | Votre inventaire d'applications et d'infrastructure, ainsi que l'[ownership](/ruby/integrations/ownership) et la [structure d'équipe](/organization/team/teams) qui lui sont associées. Les notes du [Logbook](/anomaly-detection) sur les incidents, et les tickets [Jira](/application/integrations/jira), [GitHub](/application/integrations/github) et [Linear](/application/integrations/linear) qu'elles deviennent. Qui possède quoi, et ce qui a déjà été décidé à ce sujet. |

<h3 id="the-intelligence-features">
  Les fonctionnalités Intelligence
</h3>

* **[Intelligence dashboards](/metrics/magic-dashboards).** Les dashboards se construisent d'eux-mêmes à partir des intégrations qu'AppSignal détecte, si bien qu'une nouvelle installation de Solid Queue ou de Sidekiq arrive avec les graphiques qui comptent déjà en place.
* **[Time Detective](/trace-page).** Reconstitue à quoi ressemblait votre application au moment d'une trace, afin qu'une requête lente puisse être lue à la lumière de l'état dans lequel elle s'est réellement exécutée.
* **[AppSignal MCP](/mcp-server) et la [CLI](/cli).** Placez un agent devant tout cela, dans votre éditeur ou votre terminal, pour poser des questions sur vos propres données avec vos propres mots.

Le principe est le même pour chacune d'elles : AppSignal enrichit et interprète votre télémétrie au lieu de se contenter de la stocker.

<h3 id="these-tutorials-as-expert-context">
  Ces tutoriels comme contexte d'expert
</h3>

La connaissance d'expert est le seul signal qu'AppSignal ne peut pas produire par lui-même. La documentation et la télémétrie, c'est à nous de les écrire, et votre base de connaissances s'accumule au fil du travail de votre équipe.

La connaissance d'expert, non. Savoir comment Solid Queue se comporte sous charge, ou lequel de `step` et `next` vous voulez à un point d'arrêt, ne découle pas du simple fait d'avoir instrumenté le framework. Elle vient de personnes qui ont fait tourner ces outils en production et passé des années à les expliquer à d'autres développeurs. La faire entrer dans un context store suppose de travailler avec elles.

C'est pourquoi ces tutoriels sont réalisés avec GoRails. Ce qui est documenté ici, c'est ce que Chris et son équipe enseignent, publié sous les mêmes URL, dans le même corpus, que tout ce que les fonctionnalités Intelligence d'AppSignal lisent par ailleurs.

Une même page sert les deux publics :

* **Les humains.** Une vidéo, puis un guide écrit avec les commandes et le code dans l'ordre.
* **Les agents.** Chaque page est aussi servie en Markdown brut à son URL avec une extension `.md`, et répertoriée dans [`llms.txt`](https://docs.appsignal.com/llms.txt). Les propres agents Intelligence d'AppSignal la lisent, tout comme n'importe quel agent que vous construisez vous-même et pointez vers cette documentation.

<h2 id="the-tutorials">
  Les tutoriels
</h2>

<CardGroup cols={2}>
  <Card title="Installer AppSignal" icon="signal" href="/tutorials/ruby/install-appsignal">
    Installez AppSignal dans Rails et examinez les données d'une application déployée.
  </Card>

  <Card title="Solid Queue" icon="database" href="/tutorials/ruby/solid-queue">
    Faites tourner Active Job sur votre base de données existante, sans Redis.
  </Card>

  <Card title="Mission Control Jobs" icon="table-list" href="/tutorials/ruby/mission-control-jobs">
    Montez un tableau de bord de jobs à l'intérieur de votre propre application.
  </Card>

  <Card title="Regrouper des jobs en arrière-plan" icon="layer-group" href="/tutorials/ruby/batching-background-jobs">
    Exécutez des jobs en parallèle et agissez une fois qu'ils sont tous terminés.
  </Card>

  <Card title="Déboguer avec la gem debug" icon="bug" href="/tutorials/ruby/debugging-with-the-debug-gem">
    Points d'arrêt, exécution pas à pas, et parcours de la pile depuis la console.
  </Card>

  <Card title="Params expect" icon="shield-check" href="/tutorials/ruby/params-expect">
    Autorisez et exigez des paramètres en une étape avec Rails 8.
  </Card>

  <Card title="Paramètres avec valeurs par défaut" icon="sliders" href="/tutorials/ruby/parameters-with-defaults">
    Fournissez des valeurs de repli pour les paramètres que le navigateur peut omettre.
  </Card>

  <Card title="Impersonation" icon="user-secret" href="/tutorials/ruby/impersonation">
    Ajoutez l'impersonation d'utilisateur au générateur d'authentification de Rails 8.
  </Card>

  <Card title="CI locale" icon="terminal" href="/tutorials/ruby/local-ci">
    Exécutez votre suite de CI en local et validez des pull requests GitHub.
  </Card>

  <Card title="Rendu Markdown" icon="file-lines" href="/tutorials/ruby/markdown-renderer">
    Répondez avec `text/markdown` grâce au type MIME de Rails 8.1.
  </Card>
</CardGroup>