Konwerter YAML na JSON

Czym jest 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"
// }

Kluczowe funkcje

Przykłady

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

Jak używać

1. 1

   Wklej dane YAML

   Wprowadź lub wklej dane YAML do pola wejściowego powyżej. Możesz też kliknąć «Wczytaj przykład», aby wypróbować próbkę, np. Kubernetes Deployment, plik Docker Compose lub Helm values.yaml.

2. 2

   Zobacz wynik JSON na żywo

   JSON pojawia się natychmiast w panelu wyjściowym. Dostosuj Opcje (wcięcie 2 lub 4 spacje), aby spełnić wymagania docelowego narzędzia.

3. 3

   Kopiuj lub pobierz

   Kliknij Kopiuj, aby przenieść JSON do schowka, lub Pobierz, aby zapisać go jako plik .json gotowy do użycia z jq, wywołań API lub dowolnych narzędzi downstream.

Typowe problemy z 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

Typowe zastosowania

Analiza manifestów Kubernetes

Konwersja manifestów YAML Kubernetes do JSON w celu zapytań przez jq, wysyłania do REST API Kubernetes, przetwarzania w źródłach danych Terraform lub przekazywania do potoków CI/CD oczekujących JSON.

Docker Compose do narzędzi JavaScript

Parsowanie YAML Docker Compose do JSON w celu wyodrębnienia definicji usług, nazw obrazów, przyporządkowań portów i zmiennych środowiskowych do użycia w skryptach automatyzacji, grafach zależności lub narzędziach Node.js.

Integracja API GitHub Actions

Konwersja YAML przepływów pracy GitHub Actions do JSON w celu programowej walidacji struktury, wyodrębnienia definicji zadań i kroków lub integracji z API CI/CD przyjmującymi specyfikacje przepływów pracy w JSON.

OpenAPI do generowania kodu klienta

Wiele generatorów kodu (openapi-generator, swagger-codegen, oazapfts) przyjmuje specyfikacje OpenAPI w obu formatach. Konwertuj specyfikację YAML do JSON, gdy narzędzie wymaga konkretnie JSON lub gdy chcesz ją sprawdzić walidatorami JSON Schema.

Analiza Helm values

Konwersja pliku values.yaml Helm chart do JSON w celu generowania raportów, porównywania wartości między środowiskami, przekazywania do narzędzi egzekwowania polityk lub przetwarzania przez automatyzację oczekującą konfiguracji JSON.

Migracja konfiguracji do narzędzi opartych na JSON

Migracja konfiguracji aplikacji z YAML (typowego w narzędziach infrastrukturalnych) do JSON do użytku w środowiskach JavaScript, REST API, AWS AppConfig, Azure App Configuration lub dowolnym systemie przechowującym konfiguracje jako JSON.

Szczegóły techniczne

Specyfikacja YAML 1.2 przez parseAllDocuments z merge:true

YAML jest parsowany przy użyciu biblioteki eemeli/yaml (v2.8+, bezpieczna pod kątem CVE) przez parseAllDocuments z opcjami { version: '1.2', merge: true }. Schemat YAML 1.2 zapewnia, że ciągi gołe takie jak yes i no są traktowane jako ciągi znaków (nie wartości logiczne), zgodnie z aktualną specyfikacją YAML. Opcja merge: true w pełni rozwija klucze scalające kotwic/aliasów (<<: *anchor), dzięki czemu wynikowy JSON zawiera pełne, rozwinięte dane. Wielodokumentowy YAML (rozdzielony ---) zwraca pierwszy dokument.

Rozwijanie kotwic i aliasów przez bibliotekę

Biblioteka eemeli/yaml obsługuje rozwijanie kotwic (&name) i aliasów (*name) bezpiecznie, łącznie z wykrywaniem cyklicznych referencji. Wszystkie aliasowane bloki danych — łącznie z rozwinięciami kluczy scalających — są w pełni wbudowane w wynikowym JSON. Jest to prawidłowa transformacja, bo JSON nie ma koncepcji referencji ani kotwicy. Bezpieczne rozwijanie przez bibliotekę zapobiega nieskończonym pętlom z nieprawidłowo zbudowanego YAML.

W przeglądarce — bez przesyłania, bez serwera

Całe przetwarzanie odbywa się wyłącznie w silniku JavaScript przeglądarki. Żadne dane nie są przesyłane przez sieć w żadnym momencie. Dane wejściowe większe niż 200 KB automatycznie przełączają się z trybu na żywo na tryb ręczny (wymagający jawnego kliknięcia przycisku Konwertuj), aby utrzymać responsywność przeglądarki i zapobiec blokowaniu głównego wątku podczas intensywnej serializacji.

Dobre praktyki

Używaj składni zgodnej z YAML 1.2 dla czystej konwersji

Pisz YAML używając konwencji YAML 1.2 — jawnie ujmuj wartości ciągów yes, no, on, off, y i n w cudzysłowy (np. enabled: 'yes'), by uniknąć niejednoznaczności. Narzędzie parsuje ze schematem YAML 1.2 (więc są to ciągi znaków), ale starsze narzędzia w łańcuchu mogą używać YAML 1.1 (gdzie stają się wartościami logicznymi). Jawne cytowanie w źródłowym YAML jest najsłuszniejszą praktyką dla wszystkich parserów.

Ujmuj duże liczby w cudzysłowy w YAML, aby zachować precyzję

JavaScript nie może precyzyjnie reprezentować liczb całkowitych większych niż 2^53 - 1 (9007199254740991). Pola Kubernetes, jak resourceVersion i uid, są int64 po stronie serwera i mogą przekraczać ten limit. W źródłowym YAML ujmuj te wartości w cudzysłowy (resourceVersion: '9007199254740993'), aby parser traktował je jako ciągi znaków zachowane dokładnie w wynikowym JSON.

Waliduj wynikowy JSON przed użyciem w API

Po konwersji YAML do JSON zwaliduj wynik przed wysłaniem do API, przechowywaniem lub programowym przetwarzaniem. Użyj naszego formatowania JSON, aby potwierdzić poprawność struktury. Jest to szczególnie ważne dla wywołań API Kubernetes, specyfikacji OpenAPI i wszelkich ładunków walidowanych przez JSON Schema, gdzie błąd struktury powoduje mylącą odmowę na poziomie API, a nie na etapie konwersji.

Oddzielaj wielodokumentowy YAML przed konwersją

Jeśli plik YAML zawiera wiele dokumentów rozdzielonych --- i potrzebujesz wszystkich jako JSON, najpierw podziel plik na --- i konwertuj każdy dokument osobno. Narzędzie bierze tylko pierwszy dokument. Proste podejście: podziel na '\n---\n' w edytorze lub przy użyciu awk, a następnie wklejaj każdą sekcję osobno.

Używaj jq do przetwarzania JSON downstream

Gdy masz już JSON z YAML, jq jest najszybszym sposobem zapytania i transformacji go z wiersza poleceń. Połącz narzędzie z jq: konwertuj YAML online, wklej JSON, a następnie użyj jq '.spec.replicas' lub jq '.services | keys', aby wyodrębnić dokładnie to, czego potrzebujesz. Dla przetwarzania wsadowego wielu plików użyj bezpośrednio yq CLI z flagą -o json.

Najczęściej zadawane pytania