Conversor YAML para JSON

O 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"
// }

Recursos Principais

Exemplos

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

Como Usar

1. 1

   Cole seu YAML

   Insira ou cole seus dados YAML no campo de entrada acima. Você também pode clicar em «Carregar exemplo» para experimentar uma amostra como um Deployment do Kubernetes, um arquivo Docker Compose ou um values.yaml do Helm.

2. 2

   Veja a saída JSON ao vivo

   O JSON aparece instantaneamente no painel de saída. Ajuste as Opções (indentação de 2 ou 4 espaços) para corresponder aos requisitos da sua ferramenta de destino.

3. 3

   Copie ou Baixe

   Clique em Copiar para pegar o JSON para a área de transferência, ou em Baixar para salvá-lo como arquivo .json pronto para jq, chamadas de API ou qualquer outra ferramenta downstream.

Armadilhas Comuns do 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 Comuns

Análise de Manifestos do Kubernetes

Converta manifestos YAML do Kubernetes para JSON para consultar com jq, enviar para a API REST do Kubernetes, processar em fontes de dados do Terraform ou integrar em pipelines de CI/CD que esperam JSON.

Docker Compose para Ferramentas JavaScript

Analise o YAML do Docker Compose para JSON para extrair definições de serviço, nomes de imagem, mapeamentos de porta e variáveis de ambiente para uso em scripts de automação, grafos de dependência ou ferramentas Node.js.

Integração com API do GitHub Actions

Converta o YAML de workflows do GitHub Actions para JSON para validar a estrutura programaticamente, extrair definições de jobs e steps ou integrar com APIs de CI/CD que aceitam especificações de workflow em JSON.

OpenAPI para Geração de Código Cliente

Muitos geradores de código (openapi-generator, swagger-codegen, oazapfts) aceitam especificações OpenAPI em qualquer formato. Converta sua especificação YAML para JSON quando uma ferramenta especificamente exigir entrada JSON ou quando precisar inspecioná-la com validadores JSON Schema.

Análise de Valores Helm

Converta o values.yaml de charts Helm para JSON para gerar relatórios, comparar valores entre ambientes, integrar com ferramentas de aplicação de políticas ou processar com automação que espera configuração JSON.

Migração de Config para Ferramentas Baseadas em JSON

Migre configurações de aplicação de YAML (comum em ferramentas de infraestrutura) para JSON para uso em ambientes JavaScript, APIs REST, AWS AppConfig, Azure App Configuration ou qualquer sistema que armazena configuração como JSON.

Detalhes Técnicos

Especificação YAML 1.2 via parseAllDocuments com merge:true

O YAML é analisado usando a biblioteca eemeli/yaml (v2.8+, segura contra CVEs) via parseAllDocuments com { version: '1.2', merge: true }. O esquema YAML 1.2 garante que strings simples como yes e no sejam tratadas como strings (não booleanos), correspondendo à especificação atual do YAML. A opção merge: true expande completamente as chaves de mesclagem de âncoras/aliases (<<: *anchor) para que a saída JSON contenha dados completos e desreferenciados. YAML com múltiplos documentos (separados por ---) retorna o primeiro documento.

Expansão de Âncoras e Aliases via Biblioteca

A biblioteca eemeli/yaml trata a expansão de âncoras (&nome) e aliases (*nome) com segurança, incluindo detecção de referências circulares. Todos os blocos de dados com alias — incluindo expansões de chave de mesclagem — são totalmente incorporados na saída JSON. Esta é a transformação correta porque o JSON não tem conceito de referência ou âncora. A expansão segura da biblioteca previne loops infinitos causados por YAML malformado.

Baseado no Navegador — Sem Upload, Sem Servidor

Todo o processamento acontece inteiramente no motor JavaScript do seu navegador. Nenhum dado é transmitido pela rede em nenhum momento. Entradas maiores que 200KB mudam automaticamente do modo ao vivo para o modo manual (exigindo um clique explícito em Converter) para manter o navegador responsivo e evitar o bloqueio da thread principal durante a serialização pesada.

Melhores Práticas

Use Sintaxe Compatível com YAML 1.2 para Conversão Limpa

Crie seu YAML usando convenções YAML 1.2 — coloque aspas explicitamente em valores de string yes, no, on, off, y e n (por exemplo, enabled: 'yes') para evitar ambiguidade. Esta ferramenta analisa com o esquema YAML 1.2 (então estes são strings), mas ferramentas mais antigas no seu pipeline podem usar YAML 1.1 (onde se tornam booleanos). Aspas explícitas no YAML fonte são a prática mais segura em todos os parsers.

Coloque Aspas em Números Grandes no YAML para Preservar Precisão

O JavaScript não pode representar inteiros maiores que 2^53 - 1 (9007199254740991) exatamente. Campos do Kubernetes como resourceVersion e uid são int64 no servidor e podem exceder esse limite. Na sua fonte YAML, coloque aspas nesses valores (resourceVersion: '9007199254740993') para que o parser os trate como strings, que são então preservadas exatamente na saída JSON como valores de string.

Valide a Saída JSON Antes de Usar em APIs

Após converter YAML para JSON, valide o resultado antes de enviá-lo a uma API, armazená-lo ou processá-lo programaticamente. Use nosso Formatador JSON para confirmar que a estrutura está correta. Isso é especialmente importante para chamadas de API do Kubernetes, especificações OpenAPI e qualquer payload validado por JSON Schema, onde um erro estrutural causa uma rejeição confusa na camada de API em vez de na etapa de conversão.

Separe YAML com Múltiplos Documentos Antes de Converter

Se o seu arquivo YAML contém múltiplos documentos separados por --- e você precisa de todos eles como JSON, divida o arquivo em --- primeiro e converta cada documento individualmente. Esta ferramenta toma apenas o primeiro documento. Uma abordagem simples: divida em '\n---\n' no seu editor ou com awk, depois cole cada seção separadamente.

Use jq para Processamento JSON Downstream

Depois de ter JSON do seu YAML, jq é a forma mais rápida de consultar e transformá-lo na linha de comando. Combine esta ferramenta com jq: converta seu YAML online, cole o JSON, depois use jq '.spec.replicas' ou jq '.services | keys' para extrair exatamente o que precisa. Para processamento em lote de muitos arquivos, use a CLI yq com o flag -o json diretamente.

Perguntas Frequentes