Cómo convertir YAML a JSON [Python, PowerShell, Go]

Tutoriales
Go PowerShell Python

Muchas herramientas modernas, especialmente en la gestión de configuraciones y en los espacios de Infraestructura como Código (IaC), utilizan archivos JSON o YAML para almacenar datos de configuración. Si necesitas convertir datos de formato YAML a JSON, entonces este artículo es para ti.

En este artículo, aprenderás varias formas de convertir datos de YAML a JSON, incluyendo scripts en Python, PowerShell y Go.

Relacionado:PowerShell vs. Python: Una Batalla para las Edades

Requisitos previos

Si deseas seguir los ejemplos en este tutorial, asegúrate de tener

  • A code editor. This article will use Visual Studio Code version 1.55.1. Feel free to use any code editor you want.

Relacionado:Lo Que Necesitas Saber sobre Visual Studio Code: Un Tutorial

  • Para empezar a convertir YAML a JSON, necesitas un contenido YAML de ejemplo. Copia el siguiente contenido en un archivo nuevo llamado sistemas-operativos.yml. Guarda el archivo YAML en tu directorio de trabajo. 
operating-systems.yml
Windows 10: 100
Windows Server 2019: 50
Windows Server 2022: 1
MacOS: 3
CentOS: 75
Photon: 12

Usando Python para Convertir YAML a JSON

Python es un excelente lenguaje para automatización. ¿Pero sabías que puedes extender las capacidades de Python y usarlo para convertir documentos de YAML a JSON? Y solo necesitas realizar unos pocos pasos para empezar a convertir YAML a JSON en poco tiempo.

El ejemplo en esta sección requiere que hayas instalado Python 3.9 y PIP (la última versión al momento de escribir esto es 21.0.1).

Agregar Soporte YAML a Python

Python no tiene soporte incorporado para YAML. Esto significa que Python no puede leer ni interpretar documentos YAML de forma predeterminada. Para agregar soporte YAML a Python, primero debes instalar el módulo PyYAML.

Para instalar el módulo PyYAML, deberás ejecutar el comando pip, que es el instalador de paquetes para Python. Para hacerlo, sigue estos pasos.

Primero, abre tu intérprete de comandos preferido, como el símbolo del sistema o PowerShell. El comando pip debería funcionar en cualquiera de ellos. Este ejemplo utiliza PowerShell.

A continuación, ejecuta el siguiente comando en PowerShell. Este comando instala el módulo PyYAML.

pip install pyyaml

Como puedes ver en la captura de pantalla a continuación, pip instaló la última versión de PyYAML (5.4.1 al momento de escribir esto).

Installing the PyYAML module

Creando el Script de Conversión

Ahora que has instalado el módulo necesario (PyYAML), estás listo para escribir tu script de conversión. Para crear el script de Python que convierte YAML a JSON, sigue estos pasos.

1. Abre tu editor de código y crea un nuevo archivo llamado convertir-os.py en tu directorio de trabajo. Este archivo es tu script.

2. Copia el código a continuación y pégalo en tu archivo en blanco convert-os.py. Este script leerá el contenido YAML de operating-systems.yml, lo convertirá al formato JSON y escribirá la salida JSON en el archivo python_operating-systems.json. 

## convert-os.py
## Importa los módulos para manejar JSON y YAML
import yaml
import json

## Crea una variable para almacenar los datos a importar
os_list = {}

## Lee el archivo YAML
with open("c:\temp\operating-systems.yml") as infile:
     # Convierte el YAML en la variable definida anteriormente os_list = yaml.load(infile, Loader=yaml.FullLoader)     # Imprime la lista en la consola print(os_list)
 Open a file to write the JSON output. The 'w' makes the file writable
 with open("c:\temp\python_operating-systems.json", 'w') as outfile:
     # Convierte el JSON, estableciendo "indent" para que el archivo sea más legible json.dump(os_list, outfile, indent=4) print("Archivo JSON escrito.")

3. Guarda el script convert-os.py.

Ejecución del Script de Conversión

Después de crear el script de conversión, es hora de ponerlo a prueba. Para ejecutar el script de Python que convierte YAML a JSON, sigue estos pasos:

1. Abre una ventana de terminal. Este artículo utiliza PowerShell, pero el símbolo del sistema (CMD) también funcionaría igual de bien.

2. Copia el siguiente comando, pégalo en PowerShell y presiona Enter. Este comando ejecuta el programa ejecutable de Python para invocar el script convertir-os.py que creaste en la sección anterior. 

python c:\temp\convert-os.py

Después de ejecutar el comando, deberías ver una salida similar a la imagen a continuación. Como puedes observar, el comando muestra la salida JSON en la pantalla y guarda la misma salida en el archivo c:\temp\python_operating-systems.json.

Running the YAML to JSON conversion script using Python

3. Por último, abre el archivo JSON llamado python_operating-systems.json que el script Python convertir-os.py debería haber creado. En este ejemplo, para abrir el archivo en Notepad, ejecuta el siguiente comando en PowerShell. 

notepad C:\temp\python_operating-systems.json
Viewing the python_operating-systems.json file in notepad

Usando PowerShell para Convertir YAML a JSON

PowerShell es capaz de modificar archivos de texto y convertir objetos a varios formatos, incluido JSON. Dado que PowerShell es extensible, puedes utilizar PowerShell para convertir archivos YAML a formato JSON con el módulo adecuado.

Añadiendo Soporte YAML a PowerShell

PowerShell tiene soporte incorporado para manejar contenido JSON, pero no para YAML. Afortunadamente, hay un módulo que extiende PowerShell para admitir archivos YAML. Este módulo se llama PowerShell-yaml, y la última versión hasta la fecha de esta escritura es la 0.4.2. Sigue estos pasos para instalar el módulo.

1. En tu computadora, abre una sesión de PowerShell.

2. Copia el comando a continuación, pégalo en PowerShell y presiona Enter. Este comando utiliza el cmdlet Install-Module para instalar el módulo PowerShell-yaml. 

Install-Module PowerShell-yaml

3. Después de instalar el módulo, dos nuevos cmdlets estarán disponibles en PowerShell como parte del módulo PowerShell-yaml. Estos nuevos cmdlets son:

ConvertFrom-Yaml – el cmdlet para convertir datos YAML a una tabla hash.

ConvertTo-Yaml – el cmdlet para convertir objetos de tabla hash a datos YAML.

Para confirmar que ambos cmdlets están disponibles en PowerShell, ejecuta el siguiente comando en PowerShell. 

Get-Command -Module PowerShell-yaml

Como puedes ver a continuación, el cmdlet Get-Command enumeró los cmdlets del módulo PowerShell-yaml.

Getting the PowerShell-yaml cmdlets

Escritura del Script de Conversión

Para crear el script de conversión de YAML a JSON en PowerShell, sigue estas instrucciones.

1. Abre tu editor de código y crea un nuevo archivo llamado convertir-os.ps1 en tu directorio de trabajo.

2. Copia el código a continuación y pégalo en el archivo en blanco convert-os.ps1. El fragmento de código siguiente lee el archivo operating-systems.yml y lo convierte a JSON. Una vez en formato JSON, guarda el JSON en el archivo PowerShell_operating-systems.json. 

#convert-os.ps1
 #Lee el archivo YAML usando Get-Content y convierte los datos a un hashtable usando ConvertFrom-Yaml. La variable $os_list almacena el objeto hashtable.
 $os_list = (Get-Content -Path "C:\temp\operating-systems.yml" | ConvertFrom-Yaml)
 #Convierte el objeto hashtable en la variable $os_list al formato JSON usando ConvertTo-Json. Una vez en JSON, guarda el archivo en C:\temp\PowerShell_operating-systems.json usando Set-Content.
 Set-Content -Path "C:\temp\PowerShell_operating-systems.json" -Value ($os_list | ConvertTo-Json)

Relacionado:Get-Content: Leyendo Archivos de Texto como un Experto en PowerShell

Relacionado:Set-Content: La Manera de PowerShell de Escribir en un Archivo

3. Guarda el archivo convert-os.ps1.

Ejecutando el Script de Conversión

Ahora que has creado tu script de conversión, el siguiente paso es ejecutarlo para convertir YAML a JSON. Para ejecutar el script de conversión en PowerShell, sigue estos pasos.

  1. Abre una ventana de PowerShell si aún no tienes una abierta.

2. Copia el comando a continuación, pégalo en PowerShell y presiona Enter. Este comando invoca el script convert-os.ps1 que has creado en la sección anterior. 

c:\temp\convert-os.ps1

3. Después de ejecutar el script, abre el archivo de salida JSON C:\temp\PowerShell_operating-systems.json que el script convert-os.ps1 creó en el paso anterior. Para hacerlo, ejecuta el siguiente comando en PowerShell para abrir el archivo PowerShell_operating-systems.json en el bloc de notas. 

notepad C:\temp\PowerShell_operating-systems.json
Viewing the content of the PowerShell_operating-systems.json file

Usando Go para Convertir YAML a JSON

Python y PowerShell son ambos lenguajes de alto nivel. Ser de alto nivel facilita la escritura de scripts pero también quita un poco de control. Por otro lado, Go es un lenguaje de bajo nivel, lo que hace más compleja la importación de datos YAML.

El ejemplo en esta sección utilizará Go. La última versión hasta la fecha de escritura es go1.16.3. Si aún no tienes Go, consulta la página de descarga e instalación para instalarlo en tu computadora.

Añadiendo Soporte YAML a Go

Al igual que PowerShell y Python, el soporte JSON es parte de las bibliotecas principales de Go, pero YAML no lo es. Para agregar soporte YAML en Go, debes instalar primero el paquete YAML.v3 utilizando el comando go get . Para instalar el paquete YAML.v3:

Primero, en tu computadora, abre la terminal que desees utilizar, como el símbolo del sistema o PowerShell. Este ejemplo utiliza PowerShell.

A continuación, copie el comando a continuación y ejecútelo en PowerShell. Este comando descargará e instalará el paquete gopkg.in/yaml.v3.

go get gopkg.in/yaml.v3
Installing the yaml.v3 package in Go

Escribir el Script de Conversión

Para crear el script de conversión de YAML a JSON en Go, siga estas instrucciones.

1. Abra su editor de código y cree un nuevo archivo llamado convert-os.go en su directorio de trabajo.

2. Copie el código a continuación y péguelo en el archivo en blanco convert-os.go. El código importa los paquetes necesarios, define algunas estructuras de memoria, importa el archivo YAML y lo convierte a JSON antes de escribirlo en un archivo JSON llamado c:\temp\go_operating-systems.json.

// Esto indica a go qué función cargar.
 package main
 // Importar paquetes:
 import (
  // Módulo JSON
     "encoding/json"
  // Para escribir la salida en la pantalla
     "fmt"
  // Para leer y escribir archivos
     "io/ioutil"
 // Módulo YAML
     "gopkg.in/yaml.v3"
 )
 // Definir dos "Structs", que son estructuras de datos en memoria, y coinciden
 // con la forma de los archivos YAML y JSON.
 type operatingSystems struct {
     Windows10         int yaml:"Windows 10"
     WindowsServer2019 int yaml:"Windows Server 2019"
     WindowsServer2022 int yaml:"Windows Server 2022"
     MacOS             int yaml:"MacOS"
     CentOS            int yaml:"CentOS"
     Photon            int yaml:"Photon"
 }
 type operatingSystemsjson struct {
     Windows10         int json:"Windows 10"
     WindowsServer2019 int json:"Windows Server 2019"
     WindowsServer2022 int json:"Windows Server 2022"
     MacOS             int json:"MacOS"
     CentOS            int json:"CentOS"
     Photon            int json:"Photon"
 }
 func main() {
   // Informar al usuario que el proceso ha comenzado
     fmt.Println("Parsing YAML file")
 // Definir la ruta al archivo de entrada
 var fileName string = "c:\temp\operating-systems.yml"
 // Cargar el YAML desde el archivo. Go requiere manejo de errores para este paso.
 yamlFile, err := ioutil.ReadFile(fileName)
     if err != nil {
         fmt.Printf("Error reading YAML file: %s\n", err)
         return
     }
 // Extraer el YAML en tu Struct
     var oses operatingSystems
     yaml.Unmarshal(yamlFile, &oses)
 // Crear el Struct JSON, utilizando los datos del Struct YAML
 var osesjson = operatingSystemsjson{
         Windows10:         oses.Windows10,
         WindowsServer2019: oses.WindowsServer2019,
         WindowsServer2022: oses.WindowsServer2022,
         MacOS:             oses.MacOS,
         CentOS:            oses.CentOS,
         Photon:            oses.Photon,
     }
 // Crear una cadena para la salida en formato JSON.
 jsonOutput, err := json.Marshal(osesjson)
 // Imprimir el resultado en la pantalla. Nota que %+v significa que 
   // se imprimirá el nombre de la variable con los datos. Es por eso que
   // no hay espacios en los nombres de las claves de salida.
     fmt.Printf("Result: %+v\n", osesjson)
 // Escribir el archivo JSON
 err = ioutil.WriteFile("c:\temp\Go_operating-systems.json", jsonOutput, 0644)
 }

3. Guarda el archivo convert-os.go.

Ejecución del Script de Conversión

La ejecución de scripts Go utiliza el comando go run seguido del nombre del script. Para ejecutar el script de conversión de YAML a JSON en Go, sigue estos pasos.

1. En tu computadora, abre la terminal que desees utilizar. En Windows, el comando go funcionará tanto en el símbolo del sistema como en PowerShell. Este ejemplo utiliza PowerShell para ejecutar go.

2. Una vez en PowerShell, copia el siguiente comando y ejecútalo en PowerShell. Este comando invocará el comando go run para ejecutar el script c:\temp\convert-os.go. 

go run c:\temp\convert-os.go
Running Convert-os Go script.

3. Después de ejecutar el script, abre el archivo de salida C:\temp\Go_operating-systems.json que el script convert-os.go creó en el paso anterior. Este ejemplo abre el archivo Go_operating-systems.json en el Bloc de notas.

Viewing the Go_operating-systems.json in notepad

Conclusión

En este artículo, has aprendido cómo convertir datos y archivos YAML a JSON utilizando scripts en Python, PowerShell y Go. Ahora que has aprendido diferentes formas de convertir YAML a JSON, ¿cuál crees que utilizarás más?

Source:
https://adamtheautomator.com/yaml-to-json/