> 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 d’une page de travail de runbook. La console conserve le flux brut de texte ligne par ligne d’une exécution ; Output Data affiche sous forme de tableaux les objets émis par cette même exécution. Les valeurs longues telles que les GUID sont affichées en entier au lieu d’être tronquées à `…` par le formateur de console PowerShell, et les jeux de résultats larges restent lisibles au lieu d’être renvoyés à la ligne.

Caractéristiques principales:

* **Aucune configuration, aucun droit 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 à démarrer un runbook ne sont pas affectées.
* **Des objets plutôt que du 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 aucun Output Data.
* **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 à l’intérieur d’une cellule peuvent être développés au lieu d’être aplatis en une seule chaîne illisible.
* **L’onglet Console ne change pas** — la sortie textuelle complète reste disponible et peut être copiée, ce dont un ticket service ou ITIL a généralement besoin.

## Démarrage rapide

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

```powershell
[PSCustomObject]@{ RjTableTitle = 'Périphériques non conformes' }
Write-Output $nonCompliantDevices
```

Cela produit un tableau intitulé **Périphériques non conformes** dans l’onglet Output Data — une ligne par appareil, une colonne par propriété — ainsi qu’une ligne récapitulative compacte dans l’onglet Console qui y renvoie.

## Lecture d’Output Data dans le portail

Ouvrez un travail depuis [journaux Runbook](/fr/automatisation/runbooks/runbook-logs.md) et passez à l’ **Données de sortie** onglet. Voir [Détails de la tâche de runbook](/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 repli `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 permet d’y accéder.
* **Un compteur de lignes** — `12 / 340 lignes` indique combien de lignes correspondent au filtre actuel sur 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 correspondance de sous-chaîne, sans distinction de casse, sur toutes les colonnes de ce tableau. Chaque tableau se filtre indépendamment.

### Tri

Cliquer sur un en-tête de colonne trie selon cette colonne ; cliquer à nouveau inverse l’ordre. 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, sans distinction de 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 directement sous la ligne.
* L’en-tête de colonne comporte une flèche d’extension. Cliquer dessus développe toute la colonne en son propre tableau : chaque valeur imbriquée de ligne parente est déployée en lignes, et une colonne de référence renvoie au numéro de ligne parent. 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 exports respectent le filtre actif — seules les lignes correspondantes sont écrites — et utilisent le titre du tableau comme nom de fichier. L’export vers 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 ad hoc. Pour les fichiers de rapport qu’un runbook est censé livrer lui-même — en pièce jointe à un e-mail ou via un lien de téléchargement — générez-les plutôt dans le runbook, avec [Export-RjRbXlsx](/fr/dev-reference/report-functions/export-rjrbxlsx.md) et les aides à la livraison.

## Onglet Console

Lorsqu’un travail 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 ne noie pas la page. À la place de chaque tableau, la console affiche un encadré récapitulatif :

```plaintext
╭─ Table ────────────────────────────────────────────╮
│ <nom du tableau> · <nombre de lignes> lignes                    │
╰───────────────────────────── → onglet « Output Data » ──╯
```

Les tableaux émis à la suite immédiate partagent un même encadré :

```plaintext
╭─ Table ────────────────────────────────────────────╮
│ Appareils                 · 3123 lignes                │
│ Identifiants d’application · 42 lignes                  │
│ Échantillon d’export volumineux     · 987654 lignes              │
╰───────────────────────────── → onglet « Output Data » ──╯
```

`→ onglet « Output Data »` est un lien et bascule vers le tableau correspondant.

Deux boutons contrôlent l’affichage :

* **Afficher la sortie complète** — passer au texte complet, non tronqué.
* **Afficher les tableaux compressés** — revenir en arrière.

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

## Émettre Output Data 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.

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

> **Ne jamais envoyer la sortie via `Format-Table` ou `Format-List`.** Ces cmdlets émettent des enregistrements du moteur de mise en forme, pas des données. Le portail les détecte et les masque, et affiche une indication que la sortie était mal mise en forme. 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 plutôt que dans le flux de sortie.

`Format-*` cmdlets ne contrôlent que l’ *affichage*. Ce à quoi elles servaient a un équivalent en données qu’Output Data peut afficher — la sélection de 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 sont conservées dans l’onglet Output Data au lieu d’être supprimées comme enregistrements de mise en forme :

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

# Mal — enregistrements de mise en forme, masqués dans Output Data
$devices | Format-Table Name, Id, OperatingSystem, LastSeen
```

Les propriétés sélectionnées sont exactement les colonnes du tableau obtenu : `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.                                                               |
| Des objets successifs 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 `##` suivie d’une espace | Un en-tête dans la vue console.                                                                                   |
| Un objet ou tableau imbriqué                      | JSON dans la cellule, développable dans la grille — voir [Objets et listes imbriqués](#nested-objects-and-lists). |

### Nommer un tableau

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

```powershell
[PSCustomObject]@{ RjTableTitle = 'Périphériques non conformes' }
Write-Output $nonCompliantDevices
```

Le tableau suivant est alors intitulé **Périphériques 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 propriété est **insensible à la casse** — `RjTableTitle`, `rjtabletitle` et n’importe quelle autre casse fonctionne.
* Un **vide** titre est ignoré, donc un marqueur vide ne peut pas effacer un nom existant.
* Le nom s’applique au **suivant** tableau émis, même lorsque des lignes d’état apparaissent entre-temps.

Répéter ce motif nomme plusieurs tableaux dans une même exécution :

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

[PSCustomObject]@{ RjTableTitle = 'Périphériques non conformes' }
Write-Output $nonCompliant
```

{% hint style="warning" %}
**Limitez les titres de tableau à 31 caractères maximum.** **Exporter vers Excel** utilise le titre du tableau comme nom de feuille, et Excel n’accepte que des noms de 1 à 31 caractères qui ne contiennent aucun des `\\ / ? * [ ] :` et ne commencent ni ne se terminent 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 'Utilisateurs désactivés avec une boîte aux lettres partagée' 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 parlants, et lorsque le runbook écrit aussi un fichier Excel avec [Export-RjRbXlsx](/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

### Travaux archivés

Output Data n’est disponible que pour les exécutions en direct. Un travail archivé affiche *« Les données structurées ne peuvent pas être récupérées à partir d’une exécution archivée. »* — ces résultats doivent être lus dans l’onglet Console. Voir [journaux Runbook](/fr/automatisation/runbooks/runbook-logs.md) pour la distinction entre les journaux de travaux récents et archivés.

### Runbooks sans sortie structurée

*« Aucune donnée de sortie structurée provenant de ce runbook. »* signifie qu’aucune donnée de forme tabulaire n’a été émise. Si une icône d’information accompagne le message, le runbook a envoyé des enregistrements de mise en forme PowerShell au lieu de données — voir [Émettre 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 tableau d’une ligne.

## Voir aussi

* [Détails de la tâche de runbook](/fr/automatisation/runbooks/runbook-logs/runbook-job-details.md) — la page de travail qui héberge les onglets Console et Output Data.
* [Export-RjRbXlsx](/fr/dev-reference/report-functions/export-rjrbxlsx.md) — écrivez les mêmes objets dans un classeur Excel mis en forme pour une livraison hors du portail.
* [Send-RjRbReportEmail](/fr/dev-reference/report-functions/send-rjrbreportemail.md) — livrez les résultats du rapport aux administrateurs par e-mail.
* [Interaction avec les runbooks](/fr/dev-reference/interacting-with-runbooks.md) — lisez la sortie des travaux 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.
