Introducción
JSON (JavaScript Object Notation) es un formato ligero de intercambio de datos que se utiliza ampliamente en archivos de configuración y en la comunicación con API.
Aunque las herramientas del shell procesan bien el texto plano, los formatos estructurados como JSON suelen ser más fáciles y seguros de manipular en Python mediante sus bibliotecas integradas.
En este laboratorio actuará como desarrollador y deberá actualizar la configuración de una aplicación. Creará un archivo de configuración JSON, escribirá un script de Python para cargarlo, modificará un ajuste y guardará los cambios en un archivo nuevo.
Crear datos de ejemplo
En este paso creará un archivo de configuración JSON de ejemplo. Este archivo simula un archivo de ajustes habitual de una aplicación de software e incluye claves para el nombre de la aplicación, la versión, el modo de depuración y los límites de conexión.
Primero, asegúrese de encontrarse en el directorio de trabajo correcto:
JSON es uno de los formatos de datos estructurados más comunes en las operaciones modernas, ya que las API, las herramientas de nube y muchos sistemas de configuración lo utilizan. Aprender a leerlo y modificarlo de forma segura es mucho más útil que tratarlo como texto plano.
cd ~/project
Ahora, cree un archivo llamado config.json con un editor de texto como nano.
nano config.json
Pegue el siguiente contenido en el archivo. Este objeto JSON contiene un valor booleano (false), un entero (100) y cadenas de texto.
{
"appName": "SuperApp",
"version": "1.0.0",
"debug": false,
"maxConnections": 100
}
Para guardar el archivo y salir de nano:
Para guardar y salir de nano, presione Ctrl + O para escribir los cambios y, después, Enter para confirmar el nombre del archivo. A continuación, presione Ctrl + X para salir del editor.
Puede verificar el contenido del archivo con el comando cat:
cat config.json
Debería ver el contenido JSON impreso en el terminal.
Leer JSON
En este paso escribirá un script de Python para leer el archivo config.json. El módulo json de Python convierte los datos JSON en un diccionario de Python.
Aquí Python ofrece una ventaja clara frente a los scripts de shell básicos. En lugar de buscar texto con expresiones regulares y confiar en que la estructura siga siendo sencilla, Python puede analizar el archivo según las reglas de JSON y proporcionarle tipos de datos reales con los que trabajar.
Piense en json.load() como si estuviera «desempaquetando» una caja de envío. Toma el texto almacenado en el archivo (la caja) y lo convierte en un diccionario de Python (el contenido), que puede utilizar y modificar fácilmente en el código.
Cree un script de Python nuevo llamado parse_json.py:
nano parse_json.py
Añada el siguiente código al archivo. Este script importa el módulo json, abre el archivo de configuración y carga los datos.
import json
## Open the JSON file
with open('config.json', 'r') as file:
## Load the data into a Python dictionary
data = json.load(file)
## Print the data to verify it was loaded correctly
print("Current Configuration:")
print(data)
print(f"Type of data: {type(data)}")
Guarde el archivo y salga de nano (Ctrl+O, Enter, Ctrl+X).
Ahora, ejecute el script para ver la salida:
python3 parse_json.py
Debería ver el diccionario impreso en la consola, lo que confirma que Python ha analizado correctamente el archivo JSON.
Modificar datos
En este paso modificará los datos cargados dentro del script de Python. Como json.load() convierte los datos en un diccionario estándar de Python, puede modificar los valores igual que en cualquier otro diccionario.
Observe la conversión de tipos que ocurre aquí. Los valores JSON true y false se convierten en True y False en Python. Los números siguen siendo valores numéricos en lugar de convertirse en cadenas de texto sin formato. Esto hace que las comparaciones y los cálculos posteriores sean mucho más seguros.
Abra parse_json.py de nuevo para editarlo:
nano parse_json.py
Modifique el script para cambiar el valor de la clave debug de False (que corresponde a false en JSON) a True. Añada la lógica de modificación después de cargar los datos y antes de imprimirlos.
Actualice el código para que quede así:
import json
with open('config.json', 'r') as file:
data = json.load(file)
print("Original Debug Status:", data['debug'])
## Modify the value
data['debug'] = True
print("Updated Debug Status:", data['debug'])
Guarde el archivo y salga de nano.
Ejecute el script de nuevo para verificar el cambio en memoria:
python3 parse_json.py
Debería ver que el estado original es False y el estado actualizado es True. Tenga en cuenta que, por ahora, este cambio solo existe en la memoria del programa de Python y todavía no se ha guardado en un archivo.
Guardar cambios
En este paso guardará el diccionario modificado en un archivo JSON nuevo. Para ello utilizará la función json.dump().
Este ciclo de lectura, modificación y escritura es un patrón de automatización muy habitual. El script carga datos estructurados, cambia únicamente los campos previstos y vuelve a escribir un JSON válido. Esto resulta mucho más fiable que editar línea por línea cuando la estructura del archivo se vuelve más compleja.
Piense en json.dump() como si estuviera «empaquetando» la caja. Toma el diccionario de Python (los elementos) y lo convierte de nuevo al formato de texto (la caja sellada) para almacenarlo en un archivo. Es una buena práctica guardar el resultado en un archivo nuevo, por ejemplo, new_config.json, para evitar sobrescribir la configuración original durante las pruebas.
Abra parse_json.py una última vez:
nano parse_json.py
Añada el código que escribirá el diccionario data en un archivo llamado new_config.json. Utilizará el parámetro indent=4 para que el archivo de salida sea legible para las personas (con formato embellecido).
El script final debería quedar así:
import json
## 1. Read the original file
with open('config.json', 'r') as file:
data = json.load(file)
## 2. Modify the data
data['debug'] = True
## 3. Write to a new file
with open('new_config.json', 'w') as file:
json.dump(data, file, indent=4)
print("Configuration updated and saved to new_config.json")
Guarde el archivo y salga de nano.
Ejecute el script para realizar la operación de lectura, modificación y escritura:
python3 parse_json.py
Si la operación se realiza correctamente, el script imprimirá el mensaje de confirmación.
Verificar el resultado
En este paso verificará que se haya creado el archivo de configuración nuevo y que contenga el valor actualizado.
La verificación es especialmente importante con los archivos estructurados, porque un script puede ejecutarse correctamente desde el punto de vista sintáctico y aun así generar contenido lógico incorrecto. Leer de nuevo la salida permite confirmar tanto la creación del archivo como la corrección del cambio de datos.
Enumere los archivos del directorio para confirmar que existe new_config.json:
ls -l
Ahora, muestre el contenido del archivo nuevo:
cat new_config.json
Debería ver una salida similar a esta:
{
"appName": "SuperApp",
"version": "1.0.0",
"debug": true,
"maxConnections": 100
}
Observe que "debug" ahora tiene el valor true.
También puede comparar los archivos original y nuevo mediante el comando diff para ver exactamente qué cambió:
diff config.json new_config.json
La salida resaltará la diferencia entre las líneas de debug.
Resumen
En este laboratorio ha aprendido a trabajar correctamente con datos JSON mediante Python. Primero creó un archivo de configuración JSON sin procesar y, después, escribió un script de Python para analizar ese archivo y convertirlo en un diccionario. Modificó los datos mediante código y guardó la estructura actualizada en un archivo JSON nuevo.
Este flujo de trabajo —leer, modificar y escribir— es un patrón fundamental en la automatización y en los scripts de DevOps. Aunque Bash es excelente para ejecutar comandos, la capacidad de Python para gestionar datos estructurados como JSON lo convierte en una herramienta eficaz para administrar configuraciones complejas y datos de API.
