> For the complete documentation index, see [llms.txt](https://docs.realmjoin.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.realmjoin.com/fr/dev-reference/runbook-output-data.md).

# Données de sortie du runbook

Affichez les résultats des runbooks sous forme de tableaux triables et filtrables dans le portail RealmJoin, et écrivez des runbooks qui émettent des objets structurés.

## Aperçu

**Données de sortie** est l’équivalent structuré de l’ **Console** onglet sur une page de tâche runbook. La console conserve le flux texte brut, ligne par ligne, d’une exécution ; Données de sortie affiche les objets émis par la même exécution sous forme de tableaux. Les longues valeurs comme les GUID s’affichent en entier au lieu d’être tronquées à `…` par le formateur de console PowerShell, et les grands ensembles de résultats restent lisibles au lieu d’être renvoyés à la ligne.

Caractéristiques principales :

* **Aucune configuration, aucune permission supplémentaire** — l’onglet est disponible pour chaque runbook qui émet des objets. Rien n’a besoin d’être activé, et les personnes autorisées à lancer un runbook ne sont pas affectées.
* **Des objets au lieu de texte préformaté** — les tableaux sont construits à partir de ce que le runbook écrit dans le flux de sortie. Un runbook qui préformate ses résultats avec `Format-Table` ne produit aucune Données de sortie.
* **Tableaux interactifs** — chaque tableau peut être trié, filtré, paginé et exporté vers Excel ou CSV indépendamment des autres.
* **Les données imbriquées restent inspectables** — les objets et tableaux contenus dans une cellule sont extensibles au lieu d’être aplatis en une seule chaîne illisible.
* **L’onglet Console reste inchangé** — la sortie texte complète reste disponible et peut être copiée, ce qui est généralement ce dont a besoin un ticket de service ou ITIL.

## Démarrage rapide

Le runbook minimal viable émet un objet marqueur avec le nom du tableau, puis les données :

```powershell
[PSCustomObject]@{ RjTableTitle = 'Non-compliant devices' }
Write-Output $nonCompliantDevices
```

Cela produit un tableau intitulé **Appareils non conformes** dans l’onglet Données de sortie — une ligne par appareil, une colonne par propriété — ainsi qu’une ligne récapitulative compacte dans l’onglet Console qui y mène.

## Lecture des Données de sortie dans le portail

Ouvrez une tâche depuis [journaux de runbook](https://docs.realmjoin.com/fr/automatisation/runbooks/runbook-logs.md) et basculez vers l’ **Données de sortie** onglet. Voir [Détails du job de runbook](https://docs.realmjoin.com/fr/automatisation/runbooks/runbook-logs/runbook-job-details.md) pour les autres onglets de cette page.

### Tableaux et navigation

Chaque ensemble d’objets émis par un runbook devient un tableau. Un tableau comporte :

* **Un titre** — soit le nom défini par le runbook (voir [Nommer un tableau](#naming-a-table)) ou le nom de secours `Tableau 1`, `Tableau 2` et ainsi de suite.
* **Une entrée dans la barre latérale** — chaque tableau est listé à gauche ; cliquer sur un titre y accède.
* **Un compteur de lignes** — `12 / 340 lignes` indique combien de lignes correspondent au filtre actuel parmi le total du tableau.

### Filtre

Le **Filtrer…** la zone au-dessus d’un tableau ne conserve que les lignes qui contiennent le texte saisi. Le filtre est une recherche de sous-chaîne insensible à la casse sur toutes les colonnes de ce tableau. Chaque tableau se filtre indépendamment.

### Tri

Cliquer sur l’en-tête d’une colonne trie selon cette colonne ; cliquer à nouveau inverse le sens. Une flèche (`▲` / `▼`) marque la colonne active. Le tri tient compte du type :

| Contenu de la colonne | Ordre de tri                         |
| --------------------- | ------------------------------------ |
| Nombres               | Numérique — `2` avant `10`.          |
| Dates                 | Chronologique.                       |
| Tout le reste         | Alphabétique, insensible à la casse. |

Les cellules vides sont triées en premier.

### Pagination

Les tableaux sont paginés par 50 lignes, avec un sélecteur de pages sous le tableau. Le filtre et le tri s’appliquent toujours à l’ensemble du tableau, pas seulement à la page affichée.

### Objets et listes imbriqués

Une cellule contenant un objet ou un tableau imbriqué n’est pas aplatie en texte illisible :

* La cellule affiche un chevron (`▸`). Cliquer dessus développe cet objet ou ce tableau en ligne sous la ligne.
* L’en-tête de colonne comporte une flèche d’extension. Cliquer dessus développe toute la colonne dans son propre tableau : la valeur imbriquée de chaque ligne parente est éclatée en lignes, et une colonne de référence renvoie au numéro de la ligne parente. Le nouveau tableau est ajouté en bas de la page et dans la barre latérale, et peut être filtré, trié et exporté comme n’importe quel autre.

### Export

Chaque tableau dispose de ses propres **Exporter vers Excel** (`.xlsx`) et **Exporter vers CSV** boutons. Les exportations respectent le filtre actif — seules les lignes correspondantes sont écrites — et utilisent le titre du tableau comme nom de fichier. L’export Excel utilise aussi le titre comme nom de feuille et échoue pour les titres de plus de 31 caractères, voir [Nommer un tableau](#naming-a-table).

L’export depuis le portail couvre le cas ponctuel. Pour les fichiers de rapport qu’un runbook est censé livrer lui-même — en pièce jointe d’un e-mail ou via un lien de téléchargement — créez-les plutôt dans le runbook, avec [Export-RjRbXlsx](https://docs.realmjoin.com/fr/dev-reference/report-functions/export-rjrbxlsx.md) et les assistants de livraison.

## Onglet Console

Lorsqu’une tâche a émis des tableaux, l’ **Console** onglet affiche par défaut une vue compressée. Les tableaux sont rendus à la manière de PowerShell mais tronqués, afin que les lignes d’état restent lisibles et qu’un runbook ayant émis des centaines d’objets n’inonde pas la page. À la place de chaque tableau, la console affiche un encadré récapitulatif :

```plaintext
╭─ Tableau ────────────────────────────────────────────╮
│ <nom du tableau> · <nombre de lignes> lignes         │
╰───────────────────────────── → « Données de sortie » ──╯
```

Les tableaux émis à la suite immédiate partagent un seul encadré :

```plaintext
╭─ Tableau ────────────────────────────────────────────╮
│ Appareils               · 3123 lignes               │
│ Identifiants d’application · 42 lignes               │
│ Exemple d’export volumineux · 987654 lignes         │
╰───────────────────────────── → « Données de sortie » ──╯
```

`→ « Données de sortie »` est un lien et bascule vers le tableau correspondant.

Deux boutons contrôlent l’affichage :

* **Afficher la sortie complète** — bascule vers le texte complet, non tronqué.
* **Afficher les tableaux compressés** — revenir à l’affichage précédent.

**Copier dans le presse-papiers** copie toujours la sortie brute complète, quel que soit l’affichage.

## Émission de Données de sortie depuis un runbook

L’onglet est construit à partir des objets émis par un runbook. Des tableaux propres exigent donc que le runbook écrive des objets plutôt que de les préformater en texte.

### Émettez des objets, pas du texte formaté

> **Ne faites jamais passer la sortie dans `Format-Table` ou `Format-List`.** Ces cmdlets émettent des enregistrements du moteur de formatage, pas des données. Le portail les détecte et les masque, et affiche un indice indiquant que la sortie a été mal formatée. Il en va de même partout où PowerShell met automatiquement un résultat en forme parce qu’il a été écrit dans l’hôte au lieu du flux de sortie.

`Format-*` cmdlets ne contrôlent que l’ *affichage*. Ce à quoi ils servaient a un équivalent en données que Données de sortie peut rendre — le choix des colonnes, en particulier, est ce que `Select-Object` fait :

| Au lieu de                           | Utilisez                             |
| ------------------------------------ | ------------------------------------ |
| `$devices \| Format-Table Name, Id`  | `$devices \| Select-Object Name, Id` |
| `$devices \| Format-Table -AutoSize` | `Write-Output $devices`              |
| `$devices \| Format-List`            | `Write-Output $devices`              |

`Select-Object Name, Id` produit la même sélection de colonnes que `Format-Table Name, Id` aurait affichée — mais il émet des objets, donc les colonnes survivent dans l’onglet Données de sortie au lieu d’être supprimées comme enregistrements de formatage :

```powershell
# Bien — vrais objets, colonnes choisies avec Select-Object
$devices | Select-Object Name, Id, OperatingSystem, LastSeen

# Mauvais — enregistrements de formatage, masqués dans Données de sortie
$devices | Format-Table Name, Id, OperatingSystem, LastSeen
```

Les propriétés sélectionnées sont exactement les colonnes du tableau résultant : `Nom`, `Id`, `OperatingSystem` et `LastSeen`, une ligne par appareil.

### Comment les objets deviennent des tableaux

| Émis                                              | Rendu comme                                                                                                     |
| ------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| Un objet                                          | Une ligne — ses propriétés deviennent les colonnes.                                                             |
| Objets consécutifs avec les mêmes propriétés      | Un tableau.                                                                                                     |
| Un objet avec un ensemble de propriétés différent | Un nouveau tableau commence.                                                                                    |
| Une seule valeur simple (chaîne, nombre)          | Une ligne de texte dans la console, pas un tableau.                                                             |
| Une ligne commençant par `##` suivi d’un espace   | Un en-tête dans la vue Console.                                                                                 |
| Un objet ou tableau imbriqué                      | JSON dans la cellule, extensible dans la grille — voir [Objets et listes imbriqués](#nested-objects-and-lists). |

### Nommer un tableau

Par défaut, les tableaux sont nommés `Tableau 1`, `Tableau 2` et ainsi de suite. Pour donner un nom parlant à un tableau, le runbook émet un objet marqueur juste avant les données. Le marqueur est un objet à une seule propriété dont l’unique propriété est `RjTableTitle`:

```powershell
[PSCustomObject]@{ RjTableTitle = 'Non-compliant devices' }
Write-Output $nonCompliantDevices
```

Le tableau suivant est alors intitulé **Appareils non conformes** — dans l’en-tête, dans la barre latérale et dans le nom du fichier d’export.

* Le marqueur lui-même est **consommé**. Il n’apparaît ni comme ligne ni comme ligne de console.
* Le nom de la propriété est **insensible à la casse** — `RjTableTitle`, `rjtabletitle` et toute autre casse fonctionne.
* Une **vide** le titre est ignoré, donc un marqueur vide ne peut pas effacer un nom existant.
* Le nom s’applique au **prochain** tableau émis, même si des lignes d’état apparaissent entre-temps.

Répéter ce schéma permet de nommer plusieurs tableaux dans une même exécution :

```powershell
[PSCustomObject]@{ RjTableTitle = 'Compliant devices' }
Write-Output $compliant

[PSCustomObject]@{ RjTableTitle = 'Non-compliant devices' }
Write-Output $nonCompliant
```

{% hint style="warning" %}
**Conservez des titres de tableau d’au plus 31 caractères.** **Exporter vers Excel** utilise le titre du tableau comme nom de feuille, et Excel n’accepte que des noms de 1 à 31 caractères ne contenant aucun de `\ / ? * [ ] :` et ne commençant ni ne se terminant par une apostrophe. Un titre plus long comme `Utilisateurs désactivés avec une boîte aux lettres partagée` (36 caractères) fait échouer l’export avec *"Une erreur s’est produite lors du chargement des données : sheetName 'Disabled users with a shared mailbox' est invalide - le nombre de caractères DOIT être supérieur ou égal à 1 et inférieur ou égal à 31"*.

La limite inclut les valeurs insérées à l’exécution, comme un nom de groupe ou une date. Choisissez des titres courts et explicites, et lorsque le runbook écrit aussi un fichier Excel avec [Export-RjRbXlsx](https://docs.realmjoin.com/fr/dev-reference/report-functions/export-rjrbxlsx.md#worksheet-names), utilisez le même nom pour le tableau et la feuille correspondante.
{% endhint %}

## Comportement et limites

### Tâches archivées

Données de sortie n’est disponible que pour les exécutions en direct. Une tâche archivée affiche *"Les données structurées ne peuvent pas être récupérées depuis une exécution archivée."* — ces résultats doivent être lus dans l’onglet Console. Voir [journaux de runbook](https://docs.realmjoin.com/fr/automatisation/runbooks/runbook-logs.md) pour la distinction entre journaux de tâches récents et archivés.

### Runbooks sans sortie structurée

*"Aucune donnée de sortie structurée de ce runbook."* signifie qu’aucune sortie de forme tabulaire n’a été émise. Si une icône d’information accompagne le message, le runbook a envoyé des enregistrements de formatage PowerShell au lieu de données — voir [Émettez des objets, pas du texte formaté](#emit-objects-not-formatted-text).

### Valeurs uniques

Un runbook qui émet une seule valeur simple — une chaîne d’état, un compteur — conserve cette valeur comme ligne de texte dans l’onglet Console. Seuls les objets deviennent des tableaux, donc les messages de progression et d’état ne se transforment pas chacun en un tableau d’une ligne.

## Voir aussi

* [Détails du job de runbook](https://docs.realmjoin.com/fr/automatisation/runbooks/runbook-logs/runbook-job-details.md) — la page de tâche qui héberge les onglets Console et Données de sortie.
* [Export-RjRbXlsx](https://docs.realmjoin.com/fr/dev-reference/report-functions/export-rjrbxlsx.md) — écrivez les mêmes objets dans un classeur Excel mis en forme pour une diffusion en dehors du portail.
* [Send-RjRbReportEmail](https://docs.realmjoin.com/fr/dev-reference/report-functions/send-rjrbreportemail.md) — envoyez les résultats du rapport aux administrateurs par e-mail.
* [Interaction avec les runbooks](https://docs.realmjoin.com/fr/dev-reference/interacting-with-runbooks.md) — lisez la sortie des tâches par programmation via l’API RealmJoin.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.realmjoin.com/fr/dev-reference/runbook-output-data.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
