Convertidor YAML a JSON

¿Qué es 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"
// }

Características principales

Ejemplos

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

Cómo usar

1. 1

   Pega tu YAML

   Introduce o pega tus datos YAML en el campo de entrada de arriba. También puedes hacer clic en 'Cargar ejemplo' para probar un ejemplo como un Deployment de Kubernetes, un archivo de Docker Compose o un values.yaml de Helm.

2. 2

   Observa la salida JSON en vivo

   El JSON aparece instantáneamente en el panel de salida. Ajusta las Opciones (sangría de 2 o 4 espacios) para cumplir los requisitos de tu herramienta de destino.

3. 3

   Copia o Descarga

   Haz clic en Copiar para llevar el JSON al portapapeles, o en Descargar para guardarlo como archivo .json listo para jq, llamadas a APIs o cualquier herramienta de procesamiento posterior.

Errores comunes de 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

Casos de uso comunes

Análisis de manifiestos de Kubernetes

Convierte manifiestos YAML de Kubernetes a JSON para consultarlos con jq, enviarlos a la API REST de Kubernetes, procesarlos en fuentes de datos de Terraform o alimentarlos en pipelines de CI/CD que esperan JSON.

Docker Compose para herramientas JavaScript

Analiza el YAML de Docker Compose a JSON para extraer definiciones de servicios, nombres de imágenes, mapeos de puertos y variables de entorno para usarlos en scripts de automatización, grafos de dependencias o herramientas Node.js.

Integración de APIs de GitHub Actions

Convierte el YAML de workflows de GitHub Actions a JSON para validar la estructura programáticamente, extraer definiciones de trabajos y pasos, o integrarlo con APIs de CI/CD que aceptan especificaciones de workflows en JSON.

OpenAPI para generación de código cliente

Muchos generadores de código (openapi-generator, swagger-codegen, oazapfts) aceptan especificaciones OpenAPI en cualquier formato. Convierte tu especificación YAML a JSON cuando una herramienta requiera específicamente entrada JSON o cuando necesites inspeccionarla con validadores de JSON Schema.

Análisis de valores de Helm

Convierte los values.yaml de charts Helm a JSON para generar informes, comparar valores entre entornos, alimentar herramientas de aplicación de políticas o procesar con automatización que espera configuración JSON.

Migración de configuración a herramientas basadas en JSON

Migra la configuración de aplicaciones de YAML (habitual en herramientas de infraestructura) a JSON para usar en entornos JavaScript, APIs REST, AWS AppConfig, Azure App Configuration o cualquier sistema que almacene la configuración como JSON.

Detalles técnicos

Especificación YAML 1.2 mediante parseAllDocuments con merge:true

El YAML se analiza usando la librería eemeli/yaml (v2.8+, segura frente a CVE) mediante parseAllDocuments con { version: '1.2', merge: true }. El esquema YAML 1.2 garantiza que las cadenas simples como yes y no se traten como cadenas (no como booleanos), coincidiendo con la especificación YAML actual. La opción merge: true expande completamente las claves de fusión de anclas/alias (<<: *ancla) para que la salida JSON contenga datos completos y desreferenciados. El YAML con múltiples documentos (separados por ---) devuelve el primer documento.

Expansión de anclas y alias mediante la librería

La librería eemeli/yaml gestiona la expansión de anclas (&nombre) y alias (*nombre) de forma segura, incluida la detección de referencias circulares. Todos los bloques de datos con alias — incluidas las expansiones de claves de fusión — se inlinean completamente en la salida JSON. Esta es la transformación correcta porque JSON no tiene concepto de referencia ni de ancla. La expansión segura de la librería evita los bucles infinitos de YAML malformado.

Basado en el navegador — Sin carga, Sin servidor

Todo el procesamiento ocurre completamente en el motor JavaScript de tu navegador. No se transmiten datos por la red en ningún momento. Las entradas mayores de 200 KB cambian automáticamente del modo en vivo al modo manual (requiriendo un clic explícito en Convertir) para mantener el navegador con capacidad de respuesta y evitar el bloqueo del hilo principal durante la serialización intensiva.

Buenas prácticas

Usa sintaxis compatible con YAML 1.2 para una conversión limpia

Crea tu YAML usando las convenciones de YAML 1.2 — entrecomilla explícitamente los valores de cadena yes, no, on, off, y y n (por ejemplo, enabled: 'yes') para evitar ambigüedades. Esta herramienta analiza con el esquema YAML 1.2 (por lo que son cadenas), pero las herramientas más antiguas de tu pipeline pueden usar YAML 1.1 (donde se convierten en booleanos). El entrecomillado explícito en el YAML fuente es la práctica más segura para todos los parsers.

Entrecomilla los números grandes en YAML para preservar la precisión

JavaScript no puede representar enteros mayores que 2^53 - 1 (9007199254740991) exactamente. Los campos de Kubernetes como resourceVersion y uid son int64 en el servidor y pueden superar este límite. En tu fuente YAML, entrecomilla estos valores (resourceVersion: '9007199254740993') para que el parser los trate como cadenas, que luego se preservan exactamente en la salida JSON como valores de cadena.

Valida la salida JSON antes de usarla en APIs

Después de convertir YAML a JSON, valida el resultado antes de enviarlo a una API, almacenarlo o procesarlo programáticamente. Usa nuestro Formateador JSON para confirmar que la estructura es correcta. Esto es especialmente importante para las llamadas a la API de Kubernetes, las especificaciones OpenAPI y cualquier carga útil validada con JSON Schema, donde un error estructural causa un rechazo confuso en la capa de API en lugar de en el paso de conversión.

Separa el YAML con múltiples documentos antes de convertir

Si tu archivo YAML contiene múltiples documentos separados por --- y necesitas todos ellos como JSON, divide el archivo en --- primero y convierte cada documento individualmente. Esta herramienta solo toma el primer documento. Un enfoque sencillo: divide en '\n---\n' en tu editor o con awk, luego pega cada sección por separado.

Usa jq para el procesamiento JSON posterior

Una vez que tienes JSON de tu YAML, jq es la forma más rápida de consultarlo y transformarlo desde la línea de comandos. Combina esta herramienta con jq: convierte tu YAML online, pega el JSON, luego usa jq '.spec.replicas' o jq '.services | keys' para extraer exactamente lo que necesitas. Para el procesamiento por lotes de muchos archivos, usa el CLI de yq con el indicador -o json directamente.

Preguntas frecuentes