Serialización de Datos: JSON, XML y YAML

En el mundo de la automatización de redes y el desarrollo de software moderno, entender cómo se mueven los datos entre aplicaciones es fundamental. Este proceso se conoce como Serialización de Datos. En este post, desglosaremos qué es y analizaremos los tres lenguajes de serialización más importantes: JSON, XML y YAML.

1. ¿Qué es la Serialización de Datos?

La serialización de datos es el proceso de convertir datos (que residen en la memoria de un programa) en un formato o estructura estandarizada que pueda ser:

1. Almacenada (por ejemplo, en un archivo en disco).
2. Transmitida (a través de una red).

El objetivo final es que estos datos puedan ser reconstruidos (deserializados) más tarde, a menudo por una aplicación diferente.

¿Por qué la necesitamos?

Las aplicaciones internamente almacenan sus variables de formas muy distintas (binario, punteros de memoria, etc.). Para que una aplicación “A” (ej. un Cliente REST) se comunique con una aplicación “B” (ej. un Servidor REST o un Controlador de Red), necesitan un lenguaje común.

🧐 La serialización permite representar variables con texto.

El flujo de trabajo típico es:

1. Origen: Una app tiene variables internas (ej. interface_name, status, ip_address).
2. Serialización: La app convierte esas variables a un formato estándar (como JSON).
3. Red: Los datos viajan como texto a través de la red.
4. Destino: La app receptora recibe el texto y lo convierte (deserializa) a su propio formato nativo para procesarlo.

2. JSON (JavaScript Object Notation)

JSON es, hoy en día, el rey de la serialización de datos en la web y en las APIs modernas (especialmente REST APIs).

• Definición: Es un estándar abierto de formato de archivo y de intercambio de datos que utiliza texto legible por humanos (human-readable) para almacenar y transmitir objetos de datos.
• Origen: Derivado de JavaScript, pero es independiente del lenguaje. La mayoría de los lenguajes de programación modernos (Python, Java, C++, Go) pueden generar y leer JSON nativamente.
• Espacios en blanco: En JSON, el espacio en blanco (espacios, tabulaciones, saltos de línea) es insignificante. Esto significa que un archivo JSON puede estar todo en una sola línea o indentado para facilitar la lectura, y la computadora lo interpretará igual.

2.1 Tipos de Datos en JSON

JSON soporta tipos de datos específicos.

Tipos Primitivos:

• String (Cadena): Texto entre comillas dobles ("ejemplo").
• Number (Número): Enteros o decimales (ej. 100).
• Boolean: true o false.
• Null: Representa un valor vacío (null).

Tipos Estructurados:

• Object (Objeto): Colección de pares clave-valor.
• Array (Arreglo/Lista): Colección ordenada de valores.

2.2 Estructura: El Objeto (Object)

Un objeto es una lista desordenada de pares clave-valor (key-value pairs).

• Se delimitan con llaves curvas { }.
• La clave (key) siempre debe ser un string (entre comillas dobles).
• La clave y el valor se separan por dos puntos :.
• Si hay múltiples pares, se separan por comas ,.

Ejemplo de Objeto:

{
  "interface_name": "FastEthernet0/1",
  "status": "up",
  "ip_address": "192.168.10.1",
  "netmask": "255.255.255.0",
  "speed": 1000,
  "is_up": true
}

✨ Como el espacio en blanco no importa, el ejemplo anterior es idéntico a escribirlo así:

{"interface_name":"FastEthernet0/1","status":"up" ... }

2.3 Estructura: El Arreglo (Array)

Un array es una serie o lista ordenada de valores.

• Se delimitan con corchetes [ ].
• Los valores se separan por comas ,.
• No utilizan pares clave-valor dentro de la lista, solo valores.
• Los valores dentro de un array no tienen que ser del mismo tipo (puedes mezclar strings con números, aunque no es lo habitual en datos estructurados).

Ejemplo de Arrays:

{
  "interfaces": [
    "GigabitEthernet1/1",
    "GigabitEthernet1/2",
    "GigabitEthernet1/3"
  ],
  "speed": [
    100,
    1000,
  ],
  "adds":[
    "up",
    true,
    500
  ]
}

Ejemplo Complejo (Anidado)

En el mundo real (como al hacer un show ip interface brief y recibirlo en JSON), verás objetos dentro de arrays, o arrays dentro de objetos:

{
"ip_interfaces":[
  {
    "interface": "FastEthernet0/1",
    "ip_address": "unassigned",
    "ok": "YES",
    "method": "manual",
    "status": "up",
    "protocol": "up"
  },
  {
    "interface": "FastEthernet0/2",
    "ip_address": "unassigned",
    "ok": "YES",
    "method": "manual",
    "status": "up",
    "protocol": "up"
  },
  {
    "interface": "FastEthernet0/3",
    "ip_address": "unassigned",
    "ok": "YES",
    "method": "manual",
    "status": "up",
    "protocol": "up"
  },
  {
    "interface": "FastEthernet0/4",
    "ip_address": "unassigned",
    "ok": "YES",
    "method": "manual",
    "status": "up",
    "protocol": "up"
  }
]
}

3. XML (Extensible Markup Language)

XML fue desarrollado originalmente como un lenguaje de marcado (similar a HTML), pero evolucionó para ser usado como un lenguaje de serialización de datos de propósito general.

• Legibilidad: Generalmente se considera menos legible para los humanos que JSON debido a su verbosidad (mucho texto repetido).
• Espacios en blanco: Al igual que en JSON, el espacio en blanco es insignificante para la estructura de los datos.
• Uso: Fue muy popular en el pasado y es la base de SOAP (un protocolo anterior a REST). Hoy en día, muchas REST APIs prefieren JSON, pero XML sigue presente en sistemas legacy y configuraciones de red específicas. Sintaxis.

XML utiliza etiquetas (tags) de apertura y cierre, similar a HTML.

Formato: <clave>valor</clave>

Ejemplo comparativo (mismos datos que el JSON anterior):

<ip_interfaces>
    <interface>
        <name>FastEthernet0/1</name>
        <ip_address>unassigned</ip_address>
        <ok>YES</ok>
        <method>manual</method>
        <status>up</status>
        <protocol>up</protocol>
    </interface>
    <interface>
        <name>FastEthernet0/2</name>
        <ip_address>unassigned</ip_address>
        <ok>YES</ok>
        <method>manual</method>
        <status>up</status>
        <protocol>up</protocol>
    </interface>
    <interface>
        <name>FastEthernet0/3</name>
        <ip_address>unassigned</ip_address>
        <ok>YES</ok>
        <method>manual</method>
        <status>up</status>
        <protocol>up</protocol>
    </interface>
    <interface>
        <name>FastEthernet0/4</name>
        <ip_address>unassigned</ip_address>
        <ok>YES</ok>
        <method>manual</method>
        <status>up</status>
        <protocol>up</protocol>
    </interface>
</ip_interfaces>

XML requiere escribir el nombre de la variable dos veces (apertura y cierre) para cada dato, lo que aumenta el tamaño del archivo y la complejidad visual.

4. YAML (YAML Ain’t Markup Language)

YAML tiene un enfoque diferente. Originalmente significaba “Yet Another Markup Language”, pero se cambió el nombre para enfatizar que su propósito es la serialización de datos, no el marcado de documentos.

• Legibilidad: Es considerado muy legible para los humanos. Es el más limpio de los tres.
• Uso: Es el estándar de facto para herramientas de automatización de redes como Ansible.
• Espacios en blanco: Aquí está la gran diferencia. En YAML, el espacio en blanco es SIGNIFICATIVO.
• La indentación define la estructura y jerarquía de los datos.
• No se usan llaves {} ni corchetes [] para la estructura básica (aunque los soporta como un superconjunto de JSON), se usa indentación.

Sintaxis Básica

• Inicio: Los archivos YAML suelen comenzar con tres guiones --- para indicar el inicio del documento.
• Pares Clave-Valor: Se representan como clave: valor.
• Listas: Se indican utilizando un guion - seguido de un espacio.
• Indentación: Es vital. Los elementos anidados deben estar indentados (usualmente 2 espacios) a la derecha del elemento padre.

Ejemplo comparativo (mismos datos en YAML):

---
ip_interfaces:
  - interface: "FastEthernet0/1"
    ip_address: "unassigned"
    ok: "YES"
    method: "manual"
    status: "up"
    protocol: "up"

  - interface: "FastEthernet0/2"
    ip_address: "unassigned"
    ok: "YES"
    method: "manual"
    status: "up"
    protocol: "up"

  - interface: "FastEthernet0/3"
    ip_address: "unassigned"
    ok: "YES"
    method: "manual"
    status: "up"
    protocol: "up"

  - interface: "FastEthernet0/4"
    ip_address: "unassigned"
    ok: "YES"
    method: "manual"
    status: "up"
    protocol: "up"

Notas importantes sobre YAML

• Es mucho más limpio visualmente porque no tiene comillas (usualmente), ni llaves, ni etiquetas de cierre.
• El error más común al trabajar con YAML es una indentación incorrecta. Si alineas mal un dato, cambia su significado o rompe el archivo.

5. Resumen Comparativo

🧐 Aprender a leer y escribir estos formatos (especialmente JSON y YAML) es una habilidad obligatoria para cualquier ingeniero de redes que quiera incursionar en la automatización (DevNet).