Servidores

Los archivos de configuración tienen una amplia gama de aplicaciones utilizadas principalmente por los sistemas operativos para personalizar un entorno. Para los programadores o desarrolladores, la configuración de parámetros iniciales para el software sin codificar datos en el programa es uno de los casos de uso más frecuentes. Le permite modificar dicha configuración sin acceder al código fuente del programa.

En otras palabras, se le puede indicar al software que vaya a un archivo de configuración para obtener la información precisa que necesita para aquellas variables que pueden variar con el tiempo, como direcciones IP, nombres de host, nombres de usuario, contraseñas y nombres de bases de datos.

Escribir un archivo separado con código Python es la forma más sencilla de crear archivos de configuración. Puede darle un nombre como base de datosconfig.py. Luego, para evitar cargarlo involuntariamente, puede agregar la línea *<nombre de archivo> a su archivo .gitignore .

Formato del archivo de configuración

YAML, JSON, TOML e INI son los formatos populares y estandarizados de archivos de configuración.

La mayoría de los programas en python y bibliotecas aceptan fácilmente YAML e INI. INI tiene solo 1 nivel jerárquico, por lo que es la solución más simple. INI, por otro lado, no tiene tipos de datos; todo está codificado como una cadena.

Extensiones de archivos

Las extensiones de extensión dan al usuario y al sistema una pista sobre el contenido de un archivo. Los extremos razonables del archivo de configuración incluidos son:

• La extensión config.py es para los archivos de Python.
• La extensión .yaml / .yml es para si la configuración se realiza en formato YAML.
• La extensión .json es para los archivos de configuración escritos en formato JSON.
• El archivo de extensión .ini es un archivo particular que almacena datos de configuración en un formato sencillo y preestablecido.
• .CFG o Varios programas utilizan un archivo de configuración con la extensión » CONFIG » para almacenar configuraciones exclusivas de su software. Mientras que algunos archivos de configuración se guardan como archivos de texto sin formato, otros pueden estar en un formato específico del programa.
• Extensión ~/.[nombre de mi aplicación] En los sistemas Linux, la convención de nomenclatura para los archivos de configuración es «RC». RC es «común» y es un antiguo sistema informático.

Crear un archivo de configuración en Python

Configparser.py es un módulo de Python que simplifica la escritura, lectura y modificación de archivos .ini .

Para instalar este módulo, debe abrir su símbolo del sistema y escribir el comando dado:

pip install configparser

El objetivo principal de Configureparser es leer y escribir archivos .ini, aunque también acepta diccionarios y objetos de archivos iterables como entradas. Cada archivo .ini se divide en partes que incluyen varios pares clave-valor.

Analicemos cómo crear un archivo de configuración en Python. Siguiendo los pasos que se indican a continuación, podemos crear un archivo de configuración:

• Primero, importe el módulo configparser.
• Cree un objeto de configparser.ConfigParser() guárdelo en una variable.
• Cree secciones según las necesidades utilizando el método .add_section(«section_name»).
• Agregue pares clave-valor a la sección, usando el método .set(«sección»,»clave»,»valor»).
• Para guardar la configuración:
  con abrir (ruta/»nombre_de_archivo.ini», «w») como nombre de archivo:
  config object.write(fileName)

Comprendamos cómo crear un archivo de configuración en Python tomando un ejemplo a continuación:

# Code goes from here
# importing config parser
import configparser


# creating object of configparser
config = config parser.ConfigParser()


# creating a section
config.add_section("database")


# adding key-value pairs
config.set("database", "host", "local host")
config.set("database", "admin", "local admin")
config.set("database", "password", "qwerty@123")
config.set("database", "port no", "2253")
config.set("database", "database", "SQL")
config.set("database", "version", "1.1.0")


# creating another section
config.add_section("user")


# adding key-value pairs
config.set("user", "name", "test_name")
config.set("user", "e-mail", "test@example.com")
config.set("user", "id", "4759422")




with open("database.ini", 'w') as example:
   config.write(example)

En el ejemplo anterior, para crear un archivo de configuración INI, necesitamos importar configparser.

Primero, hemos creado un objeto de analizador de configuración utilizando el método config parser.ConfigParser(). Para hacer secciones en el archivo INI, usamos el método .add_section («nombre de la sección»).

Para completar los valores en la sección tenemos el método .set(). Se necesitan 3 parámetros: el primero es el nombre de la sección, el segundo es el nombre de la clave o la opción y el tercero es el valor.

Después de archivar secciones, necesitamos crear un archivo de .ini. Para crear un archivo, usamos “with open()(). En estos corchetes, damos el nombre del archivo para que cree un archivo en el mismo directorio. Para escribir valor, usaremos el método .write().

Leer el archivo de configuración

Hemos aprendido cómo construir y actualizar el archivo de configuración en Python. Ahora que se ha creado, en nuestra clase principal, leamos los valores del archivo de configuración. La parte más fácil y clara viene a continuación.

Cada configuración se mantiene como una cadena porque Configureparser no intenta adivinar los tipos de datos en el archivo de configuración. Sin embargo, ofrece algunas formas de cambiar el tipo de datos de una cadena al apropiado. El tipo más interesante es el booleano, ya que puede distinguir entre valores booleanos como «sí» y «no», «encendido» y «apagado», «verdadero» y «falso», y «1» y «0».

También podría leer desde un objeto de archivo iterable, un diccionario o una cadena usando read_dict(), read_string() o read_file ().

Comprendamos cómo leer archivos de configuración en Python tomando un ejemplo dado

abajo:

# Code goes from here
# importing config parser
import configparser

# creating the object of configparser
config_data = configparser.ConfigParser()

# reading data
config_data.read("database.ini")

# app configuration data
database = config_data["database"]

# admin data
user = config_data["user"]

print("database data")
for database_data in database:
   print(f"{database_data} = {database.get(database_data)}")

print("\nuser data")
for user_data in user:
   print(f"{user_data} = {user.get(user_data)}")

En el ejemplo anterior, tenemos un archivo de configuración » example.ini «. Intentemos leerlo. Para leer un archivo INI, necesitamos importar el módulo configparser.py. Ahora creamos un objeto de analizador de configuración usando el método config parser.ConfigParser() . En este momento, este objeto no tiene ningún dato. Podemos leer un archivo externo usando .read.

Tenemos 2 secciones en el archivo ini. Una es la sección de la base de datos y otra es la sección del usuario. Almacenemos estas secciones en diferentes nombres de variables como base de datos y usuarios.

Ahora, al usar for loop, iteramos en estas secciones e imprimimos estos valores para verificar si obtenemos lo que queremos.

Implementar una conexión hacia MySQL, PostegreSQL y Oracle DB.

Vamos a crear un archivo config.py que lea el archivo .ini creado mediante la función def config() que devolverá los parámetros de conexión en una variable «db»:

from configparser import ConfigParser


def config(filename='database.ini', section='postgresql'):
    # create a parser
    parser = ConfigParser()
    # read config file
    parser.read(filename)

    # get section, default to postgresql
    db = {}
    if parser.has_section(section):
        params = parser.items(section)
        for param in params:
            db[param[0]] = param[1]
    else:
        raise Exception('Section {0} not found in the {1} file'.format(section, filename))

    return db

Importaremos esta función desde el archivo creado config.py en el código de Python que utilizaremos para conectarnos a la base de datos a través de psycopg2, en este caso a PostgreSQL, al que podremos llamar connect.py:

import psycopg2
from config import config

def connect():
    """ Connect to the PostgreSQL database server """
    conn = None
    try:
        # read connection parameters
        params = config()

        # connect to the PostgreSQL server
        print('Connecting to the PostgreSQL database...')
        conn = psycopg2.connect(**params)
		
        # create a cursor
        cur = conn.cursor()
        
	# execute a statement
        print('PostgreSQL database version:')
        cur.execute('SELECT version()')

        # display the PostgreSQL database server version
        db_version = cur.fetchone()
        print(db_version)
       
	# close the communication with the PostgreSQL
        cur.close()
    except (Exception, psycopg2.DatabaseError) as error:
        print(error)
    finally:
        if conn is not None:
            conn.close()
            print('Database connection closed.')


if __name__ == '__main__':
    connect()

Al correr guardará los valores devueltos en db en la variable params la cual se utilizará para generar la conexión. El script nos devolverá el estado de conexión con éxito, la versión de PostgreSQL instalada y el sistema operativo sobre el cual corre.

A partir de aquí ya puedes realizar tus consultas SQL a través del cursor «cur».

Importante recordar que una vez realizadas las consultas requeridas debes cerrar el cursos y la conexión a la base de datos a través de .close() para ambos casos.

Si quieres conectar a una base de datos MySQL podrás utilizar los mismos archivos creados database.ini y connect.py, utilizando en este caso el conector mysql.connector el cual deberás instalar en tu equipo o servidor:

pip install mysql-connector

import mysql.connector
from config_mysql import config

def connect():
    """ Connect to the MySQL database server """
    conn = None
    try:
        # read connection parameters
        params = config()

        # connect to the MySQL server
        print('Connecting to the MySQL database...')
        conn = mysql.connector.connect(**params)
		
        # create a cursor
        cur = conn.cursor()
        
	# execute a statement
        print('MySQL database version:')
        cur.execute('SELECT VERSION()')

        # display the MySQL database server version
        db_version = cur.fetchone()
        print(db_version)
       
	# close the communication with the MySQL
        cur.close()
    except (Exception, mysql.connector.Error) as error:
        print(error)
    finally:
        if conn is not None:
            conn.close()
            print('Database connection closed.')


if __name__ == '__main__':
    connect()

Finalmente si vas a conectarte a una base de datos de Oracle deberas instalar y utilizar el conector oracledb y hacer la importación en el script de Python:

pip install oracledb

En este caso te recomiendo seguir este tutorial de Oracle para conectar con sus bases de datos a través de Python.