Convertitore YAML in JSON

Cos'è 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"
// }

Funzionalità Principali

Esempi

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

Come Usarlo

1. 1

   Incolla il tuo YAML

   Inserisci o incolla i tuoi dati YAML nel campo di input qui sopra. Puoi anche cliccare su «Carica esempio» per provare un campione come un Kubernetes Deployment, un file Docker Compose o un Helm values.yaml.

2. 2

   Vedi l'output JSON in tempo reale

   Il JSON compare istantaneamente nel pannello di output. Regola le Opzioni (rientro 2 o 4 spazi) per soddisfare i requisiti dello strumento di destinazione.

3. 3

   Copia o scarica

   Clicca Copia per copiare il JSON negli appunti, o Scarica per salvarlo come file .json pronto per jq, chiamate API o qualsiasi strumento downstream.

Problemi YAML Comuni

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

Casi d'Uso Comuni

Analisi di manifest Kubernetes

Converti i manifest YAML Kubernetes in JSON per effettuare query con jq, inviare all'API REST Kubernetes, elaborare in data source Terraform o alimentare pipeline CI/CD che si aspettano JSON.

Docker Compose verso strumenti JavaScript

Analizza Docker Compose YAML in JSON per estrarre definizioni di servizi, nomi di immagini, mapping di porte e variabili d'ambiente per script di automazione, grafi di dipendenze o strumenti Node.js.

Integrazione API GitHub Actions

Converti i workflow YAML GitHub Actions in JSON per validare la struttura programmaticamente, estrarre definizioni di job e step, o integrarsi con API CI/CD che accettano specifiche di workflow JSON.

OpenAPI per la generazione di codice client

Molti generatori di codice (openapi-generator, swagger-codegen, oazapfts) accettano specifiche OpenAPI in entrambi i formati. Converti la tua specifica YAML in JSON quando uno strumento richiede specificamente input JSON o quando hai bisogno di ispezionarla con validatori JSON Schema.

Analisi dei values Helm

Converti il file values.yaml di Helm chart in JSON per generare report, confrontare values tra ambienti, alimentare strumenti di policy enforcement o elaborare con automazioni che si aspettano configurazione JSON.

Migrazione della configurazione verso strumenti JSON

Migra la configurazione dell'applicazione da YAML (comune negli strumenti di infrastruttura) a JSON per ambienti JavaScript, REST API, AWS AppConfig, Azure App Configuration o qualsiasi sistema che archivia la configurazione come JSON.

Dettagli Tecnici

Specifica YAML 1.2 tramite parseAllDocuments con merge:true

Il YAML viene analizzato usando la libreria eemeli/yaml (v2.8+, CVE-safe) tramite parseAllDocuments con { version: '1.2', merge: true }. Lo schema YAML 1.2 assicura che le stringhe semplici come yes e no vengano trattate come stringhe (non come booleani), rispettando la specifica YAML attuale. L'opzione merge: true espande completamente le chiavi merge delle ancore/alias (<<: *anchor) così l'output JSON contiene dati completi e de-referenziati. Il YAML multi-documento (separato da ---) restituisce il primo documento.

Espansione di ancore e alias tramite libreria

La libreria eemeli/yaml gestisce l'espansione di ancore (&nome) e alias (*nome) in modo sicuro, incluso il rilevamento dei riferimenti circolari. Tutti i blocchi di dati con alias — incluse le espansioni delle chiavi merge — vengono completamente inline nell'output JSON. Questa è la trasformazione corretta perché JSON non ha il concetto di riferimento o ancora. L'espansione sicura della libreria previene i loop infiniti da YAML malformato.

Basato su browser — nessun upload, nessun server

Tutta l'elaborazione avviene interamente nel motore JavaScript del browser. Nessun dato viene trasmesso in rete in nessun momento. Gli input più grandi di 200 KB passano automaticamente dalla modalità in tempo reale alla modalità manuale (richiedendo un clic esplicito su Converti) per mantenere il browser reattivo e prevenire il blocco del thread principale durante la serializzazione pesante.

Buone Pratiche

Usa la sintassi compatibile con YAML 1.2 per conversioni pulite

Scrivi il tuo YAML usando le convenzioni YAML 1.2 — metti esplicitamente tra virgolette i valori stringa yes, no, on, off, y e n (ad esempio enabled: 'yes') per evitare ambiguità. Questo strumento analizza con lo schema YAML 1.2 (quindi sono stringhe), ma gli strumenti più vecchi nella tua pipeline potrebbero usare YAML 1.1 (dove diventano booleani). Le virgolette esplicite nel YAML sorgente sono la pratica più sicura per tutti i parser.

Metti tra virgolette i numeri grandi in YAML per preservare la precisione

JavaScript non può rappresentare esattamente interi maggiori di 2^53 - 1 (9007199254740991). I campi Kubernetes come resourceVersion e uid sono int64 sul server e possono superare questo limite. Nel tuo sorgente YAML, metti tra virgolette questi valori (resourceVersion: '9007199254740993') così il parser li tratta come stringhe, che vengono poi preservate esattamente nell'output JSON come valori stringa.

Valida l'output JSON prima di usarlo nelle API

Dopo aver convertito YAML in JSON, valida il risultato prima di inviarlo a un'API, archiviarlo o elaborarlo programmaticamente. Usa il nostro Formattatore JSON per confermare che la struttura sia corretta. Questo è particolarmente importante per le chiamate API Kubernetes, le specifiche OpenAPI e qualsiasi payload validato con JSON Schema, dove un errore strutturale causa un rifiuto confuso a livello API piuttosto che al passaggio di conversione.

Separa il YAML multi-documento prima di convertire

Se il tuo file YAML contiene più documenti separati da --- e hai bisogno di tutti come JSON, dividi prima il file su --- e converti ogni documento singolarmente. Questo strumento prende solo il primo documento. Un approccio semplice: dividi su '\n---\n' nel tuo editor o con awk, poi incolla ogni sezione separatamente.

Usa jq per l'elaborazione JSON downstream

Una volta che hai JSON dal tuo YAML, jq è il modo più veloce per interrogarlo e trasformarlo dalla riga di comando. Combina questo strumento con jq: converti il tuo YAML online, incolla il JSON, poi usa jq '.spec.replicas' o jq '.services | keys' per estrarre esattamente ciò di cui hai bisogno. Per l'elaborazione in batch di molti file, usa direttamente il CLI yq con il flag -o json.

Domande Frequenti