# Rendre une configuration Pkl

Évaluez directement un fichier `.pkl` ou `.pcf` et envoyez son rendu sur stdout. Utilisez-le
pour générer la configuration d'une application, alimenter des outils de déploiement ou inspecter une configuration
avant de la committer. Aucun projet Elide n'est requis.

## Générer du JSON ou du YAML

Partez de `config.pkl` :

```pkl
service = "api"
port = 8080
```

Choisissez le format que lit votre application et redirigez le résultat vers un fichier :

```shell
elide --format=json config.pkl > config.json
elide --format=yaml config.pkl > config.yaml
```

La sortie JSON contient `service` et `port` avec les mêmes valeurs et types. La commande explicite `run` fonctionne
aussi :

```shell
elide run --format json config.pkl
```

Les entrées `.pkl` et `.pcf` acceptent les mêmes options. Par exemple, convertissez une configuration PCF existante en
JSON :

```shell
elide --format=json config.pcf > config.json
```

## Choisir un format de sortie

| Option | Sortie | Usage typique |
| --- | --- | --- |
| `--format=json` | JSON | Réglages d'application et outils qui lisent du JSON |
| `--format=yaml` | YAML | Configuration de déploiement |
| `--format=pcf` | Pkl Configuration Format | Inspecter la configuration évaluée en notation Pkl |
| Sans `--format` | La sortie configurée du module ; PCF par défaut | Respecter la définition de sortie propre au module |

La sortie TOML n'est pas prise en charge. Un format non pris en charge échoue avec le code de sortie `2`.

## Partager une configuration entre fichiers

Les imports relatifs sont résolus depuis le fichier d'entrée : une configuration peut donc réutiliser des valeurs par
défaut voisines même lorsqu'elle est invoquée depuis un autre répertoire. Par exemple, placez `defaults.pkl` et
`config.pkl` ensemble sous `config/` :

```pkl
// defaults.pkl
port = 8080
```

```pkl
// config.pkl
import "defaults.pkl"

service = "api"
port = defaults.port
```

Depuis la racine du dépôt, rendez la configuration avec :

```shell
elide --format=json config/config.pkl
```

## Utiliser la sortie dans les scripts et la CI

Stdout ne contient que le document rendu ; les diagnostics et les erreurs d'évaluation vont sur stderr. Aucune option
`--quiet` n'est nécessaire pour les redirections ou les pipelines. Par exemple, avec `jq` installé, inspectez une
propriété :

```shell
elide --format=json config.pkl | jq '.port'
```

Le manifeste du projet se rend de la même façon, ce qui montre sa configuration entièrement évaluée, valeurs par défaut
comprises :

```shell
elide --format=json elide.pkl | jq '.dependencies'
```

Un échec d'évaluation sort avec le code `1` et n'écrit aucun contenu rendu sur stdout. Pour mettre à jour un fichier de
façon atomique, utilisez `--out` plutôt qu'une redirection du shell :

```shell
elide --format=json --out config.json config.pkl
```

`--out config.json` écrit un fichier temporaire dans le répertoire de destination et ne remplace `config.json` de façon
atomique qu'une fois l'évaluation et l'écriture réussies. Les échecs laissent le fichier existant inchangé et sortent
avec un code non nul. Le répertoire de destination doit exister et permettre le remplacement atomique. Les chemins
relatifs sont résolus depuis votre répertoire de travail.

Utilisez `--out -` pour choisir explicitement stdout :

```shell
elide --format=json --out - config.pkl
```

Le rendu de documents refuse `--sandbox` et `--limit` ; ces contrôles d'exécution ne s'appliquent pas à cette commande.
Pour toutes les options de la commande, voir la [référence de la CLI](/docs/cli-references). Pour lire un README ou un
runbook dans le même terminal, voir [Markdown dans le terminal](/docs/terminal-markdown).