Convertisseur YAML vers JSON

Qu'est-ce que JSON ?

// Convert YAML to JSON in Node.js using the eemeli/yaml library
import { parseAllDocuments } from 'yaml';

const yamlString = `apiVersion: apps/v1
kind: Deployment`;

// parseAllDocuments handles multi-document YAML (--- separator)
// version: '1.2' ensures yes/no are strings, not booleans
// merge: true expands anchor/alias merge keys (<<: *anchor)
const docs = parseAllDocuments(yamlString, { version: '1.2', merge: true });

// Take the first document (skip additional --- blocks)
const json = JSON.stringify(docs[0].toJSON(), null, 2);

console.log(json);
// {
//   "apiVersion": "apps/v1",
//   "kind": "Deployment"
// }

Fonctionnalités clés

Exemples

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  namespace: production
  labels:
    app: my-app
    version: 1.0.0
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-app
          image: my-app:1.0.0
          ports:
            - containerPort: 8080
          resources:
            requests:
              memory: 64Mi
              cpu: 250m
            limits:
              memory: 128Mi
              cpu: 500m

version: '3.9'
services:
  web:
    image: nginx:1.25-alpine
    ports:
      - '80:80'
      - '443:443'
    environment:
      NGINX_HOST: example.com
      NGINX_PORT: '80'
    depends_on:
      - db
    restart: unless-stopped
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - pgdata:/var/lib/postgresql/data
volumes:
  pgdata: {}

name: CI
on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: pnpm
      - name: Install dependencies
        run: pnpm install --frozen-lockfile
      - name: Run tests
        run: pnpm test

openapi: 3.0.3
info:
  title: User API
  version: 1.0.0
  description: Manage application users
paths:
  /users:
    get:
      summary: List users
      operationId: listUsers
      parameters:
        - name: limit
          in: query
          schema:
            type: integer
            default: 20
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/User'
  /users/{id}:
    get:
      summary: Get user
      operationId: getUser
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Success
components:
  schemas:
    User:
      type: object
      properties:
        id:
          type: string
        name:
          type: string
        email:
          type: string
          format: email

replicaCount: 3
image:
  repository: my-app
  tag: 1.0.0
  pullPolicy: IfNotPresent
service:
  type: ClusterIP
  port: 80
ingress:
  enabled: true
  className: nginx
  hosts:
    - host: my-app.example.com
      paths:
        - path: /
          pathType: Prefix
resources:
  requests:
    memory: 64Mi
    cpu: 250m
  limits:
    memory: 128Mi
    cpu: 500m
autoscaling:
  enabled: false
  minReplicas: 1
  maxReplicas: 10
  targetCPUUtilizationPercentage: 80

- name: Configure web servers
  hosts: webservers
  become: true
  vars:
    http_port: 80
    max_clients: 200
  tasks:
    - name: Ensure nginx is installed
      ansible.builtin.package:
        name: nginx
        state: present
    - name: Start nginx service
      ansible.builtin.service:
        name: nginx
        state: started
        enabled: true
    - name: Copy nginx config
      ansible.builtin.template:
        src: nginx.conf.j2
        dest: /etc/nginx/nginx.conf
        owner: root
        group: root
        mode: '0644'
      notify:
        - Restart nginx
  handlers:
    - name: Restart nginx
      ansible.builtin.service:
        name: nginx
        state: restarted

Comment utiliser

1. 1

   Collez votre YAML

   Entrez ou collez vos données YAML dans le champ de saisie ci-dessus. Vous pouvez aussi cliquer sur « Charger un exemple » pour essayer un exemple comme un déploiement Kubernetes, un fichier Docker Compose ou un Helm values.yaml.

2. 2

   Consultez la sortie JSON en direct

   Le JSON apparaît instantanément dans le panneau de sortie. Ajustez les Options (indentation 2 ou 4 espaces) pour correspondre aux exigences de votre outil cible.

3. 3

   Copiez ou téléchargez

   Cliquez sur Copier pour récupérer le JSON dans votre presse-papiers, ou sur Télécharger pour le sauvegarder en fichier .json prêt pour jq, les appels API ou tout outil en aval.

Pièges courants YAML

services:
	web:
		image: nginx:1.25-alpine

services:
  web:
    image: nginx:1.25-alpine

metadata:
  name: my-app
   namespace: production

metadata:
  name: my-app
  namespace: production

url: http://example.com:8080/api
tag: #latest

url: 'http://example.com:8080/api'
tag: '#latest'

# Circular anchor (rare but possible)
base: &base
  parent: *base

# Use explicit fields instead of circular references
base:
  parent: null

# Only the first document is converted
apiVersion: v1
kind: ConfigMap
---
apiVersion: v1
kind: Secret

# Convert each document separately
apiVersion: v1
kind: ConfigMap

# This comment will be lost
replicas: 3 # scale this up for production

replicas: 3
_comment: scale this up for production

Cas d'utilisation courants

Analyse de manifestes Kubernetes

Convertissez les manifestes YAML Kubernetes en JSON pour les interroger avec jq, les envoyer à l'API REST Kubernetes, les traiter dans des sources de données Terraform ou les alimenter dans des pipelines CI/CD attendant du JSON.

Docker Compose vers outils JavaScript

Analysez le YAML Docker Compose en JSON pour extraire les définitions de services, les noms d'images, les mappages de ports et les variables d'environnement pour une utilisation dans des scripts d'automatisation, des graphes de dépendances ou des outils Node.js.

Intégration API GitHub Actions

Convertissez les workflows GitHub Actions YAML en JSON pour valider la structure programmatiquement, extraire les définitions de jobs et d'étapes, ou intégrer avec des API CI/CD qui acceptent des spécifications de workflows JSON.

OpenAPI vers génération de code client

De nombreux générateurs de code (openapi-generator, swagger-codegen, oazapfts) acceptent les spécifications OpenAPI dans les deux formats. Convertissez votre spec YAML en JSON lorsqu'un outil nécessite spécifiquement une entrée JSON ou lorsque vous avez besoin de l'inspecter avec des validateurs JSON Schema.

Analyse des valeurs Helm

Convertissez les valeurs Helm chart values.yaml en JSON pour générer des rapports, comparer les valeurs entre environnements, alimenter des outils d'application de politiques ou traiter avec une automatisation attendant une configuration JSON.

Migration de configuration vers des outils JSON

Migrez la configuration d'application de YAML (courant dans les outils d'infrastructure) vers JSON pour une utilisation dans des environnements JavaScript, des API REST, AWS AppConfig, Azure App Configuration ou tout système stockant la configuration en JSON.

Détails techniques

Spec YAML 1.2 via parseAllDocuments avec merge:true

Le YAML est analysé avec la bibliothèque eemeli/yaml (v2.8+, sécurisée CVE) via parseAllDocuments avec { version: '1.2', merge: true }. Le schéma YAML 1.2 garantit que les chaînes brutes comme yes et no sont traitées comme des chaînes (pas des booléens), correspondant à la spécification YAML actuelle. L'option merge: true développe complètement les clés de fusion ancre/alias (<<: *anchor) pour que la sortie JSON contienne des données complètes et déréférencées. Le YAML multi-document (séparé par ---) retourne le premier document.

Expansion des ancres et alias via bibliothèque

La bibliothèque eemeli/yaml gère l'expansion des ancres (&name) et alias (*name) en toute sécurité, incluant la détection de références circulaires. Tous les blocs de données aliasés — incluant les expansions de clés de fusion — sont entièrement intégrés dans la sortie JSON. C'est la transformation correcte car JSON n'a pas de concept de référence ou d'ancre. L'expansion sûre de la bibliothèque prévient les boucles infinies dues à un YAML malformé.

Basé sur le navigateur — Pas de téléchargement, pas de serveur

Tout le traitement se passe entièrement dans le moteur JavaScript de votre navigateur. Aucune donnée n'est transmise sur le réseau à aucun moment. Les entrées supérieures à 200 Ko passent automatiquement du mode en direct au mode manuel (nécessitant un clic explicite sur Convertir) pour maintenir la réactivité du navigateur et éviter le blocage du thread principal lors d'une sérialisation intensive.

Bonnes pratiques

Utilisez la syntaxe compatible YAML 1.2 pour une conversion propre

Rédigez votre YAML avec les conventions YAML 1.2 — mettez explicitement entre guillemets les valeurs de chaîne yes, no, on, off, y et n (par ex. enabled: 'yes') pour éviter l'ambiguïté. Cet outil analyse avec le schéma YAML 1.2 (donc ce sont des chaînes), mais les anciens outils de votre pipeline peuvent utiliser YAML 1.1 (où ils deviennent des booléens). Les guillemets explicites dans le YAML source est la pratique la plus sûre pour tous les analyseurs.

Mettez les grands nombres entre guillemets en YAML pour préserver la précision

JavaScript ne peut pas représenter exactement les entiers supérieurs à 2^53 - 1 (9007199254740991). Les champs Kubernetes comme resourceVersion et uid sont des int64 côté serveur et peuvent dépasser cette limite. Dans votre source YAML, mettez ces valeurs entre guillemets (resourceVersion: '9007199254740993') pour que l'analyseur les traite comme des chaînes, préservées exactement dans la sortie JSON sous forme de valeurs de chaîne.

Validez la sortie JSON avant de l'utiliser dans des API

Après avoir converti YAML vers JSON, validez le résultat avant de l'envoyer à une API, de le stocker ou de le traiter programmatiquement. Utilisez notre Formateur JSON pour confirmer que la structure est correcte. C'est particulièrement important pour les appels à l'API Kubernetes, les spécifications OpenAPI et tout payload validé par JSON Schema, où une erreur structurelle cause un rejet déroutant au niveau de l'API plutôt qu'à l'étape de conversion.

Séparez le YAML multi-document avant de convertir

Si votre fichier YAML contient plusieurs documents séparés par --- et que vous avez besoin de tous en JSON, divisez d'abord le fichier sur --- et convertissez chaque document individuellement. Cet outil ne prend que le premier document. Une approche simple : divisez sur '\n---\n' dans votre éditeur ou avec awk, puis collez chaque section séparément.

Utilisez jq pour le traitement JSON en aval

Une fois que vous avez du JSON depuis votre YAML, jq est le moyen le plus rapide de l'interroger et de le transformer en ligne de commande. Combinez cet outil avec jq : convertissez votre YAML en ligne, collez le JSON, puis utilisez jq '.spec.replicas' ou jq '.services | keys' pour extraire exactement ce dont vous avez besoin. Pour le traitement en lot de nombreux fichiers, utilisez directement le CLI yq avec le flag -o json.

Questions fréquentes