Manejo de parámetros de configuraciones en Flask

▶

Una vez creada tu primera aplicación con Flask. Debes de conocer como emplear los archivos de configuración para establecer la base de datos, modo, etc. Los archivos de configuración en Flask nos permiten agregar parámetros globales a nuestro proyecto; habilitar el modo testing, debug, colocar la clave secreta de la app empleada por ejemplo para la encriptación de datos entre otros muchas configuraciones que puedes agregar en Flask.

Flask nos provee algunos mecanismos con los cuales podemos manejar parámetros de configuración de nuestro proyecto, por ejemplo ambiente, base de datos, conexiones a servicios de terceros, etc.

Estas configuraciones se hacen en archivos de configuración en Flask nos permiten agregar parámetros globales a nuestro proyecto; habilitar el modo testing, debug, colocar la clave secreta de la app empleada por ejemplo para la encriptación de datos entre otros muchas configuraciones que puedes agregar en Flask.

¿Qué son las configuraciones en Flask y para qué sirven?

Las configuraciones en Flask permiten definir parámetros globales del proyecto: activar el modo debug, conectar a una base de datos, gestionar claves secretas o definir el entorno de trabajo. En pocas palabras, le indican a la aplicación cómo comportarse en cada contexto.

La configuración en Flask es o una clase/subclase o simplemente un diccionario y puede ser modificada de manera programática y en tiempo de ejecución desde nuestro proyecto en Flask; por ejemplo, fíjate en las siguientes líneas de código en donde estamos cambiando programáticamente el modo debug a true, y lo hacemos mediante un arranque de configuración o simplemente un diccionario y de esta manera podemos emplear el objeto de config en Flask de manera programática.

Parámetros globales más comunes

Algunos de los ajustes más usados son:

app = Flask(__name__)
app.config['DEBUG'] = True
app.debug = True

Configurar correctamente una aplicación Flask es una de esas tareas que parecen simples… hasta que llega el momento de cambiar de entorno o desplegar en producción. En esta guía te cuento, desde mi experiencia desarrollando y enseñando Flask, cómo manejar todas las configuraciones: desde las más básicas hasta las avanzadas con clases, entornos y ajustes dinámicos.

Configuración en base a variables de entorno

Como hablamos en el artículo anterior, nosotros también contamos con configuraciones que podemos emplear como variables de entorno:

DEBUG = True
TESTING = True
SECRET_KEY = "clave_secreta"

Por ejemplo, para modificar el ambiente desde una variable de entorno:

export FLASK_ENV=development flask run

El parámetro DEBUG activa el modo desarrollador, TESTING permite ejecutar pruebas automatizadas y SECRET_KEY se usa para cifrar cookies y sesiones.

En mis cursos suelo explicar que una buena configuración equivale a evitar muchos errores en producción. Un DEBUG=True olvidado puede filtrar información sensible al usuario final.

Cómo Flask maneja internamente el objeto app.config

Flask usa un diccionario especial llamado app.config que almacena las configuraciones activas. Este objeto puede modificarse en tiempo de ejecución y acepta tanto variables propias como las definidas por extensiones (como SQLAlchemy o Flask-Mail).

Cómo Flask maneja internamente el objeto app.config

Flask usa un diccionario especial llamado app.config que almacena las configuraciones activas. Este objeto puede modificarse en tiempo de ejecución y acepta tanto variables propias como las definidas por extensiones (como SQLAlchemy o Flask-Mail).

Parámetros de Configuración basadas en clases u objetos

▶

Este viene siendo el enfoque más completo y organizado y por lo tanto es el recomendado que empleamos en nuestro curso; ya que, como vamos a ver, nos ofrece la posibilidad de emplear distintas configuraciones según el ambiente que nos encontremos, podemos realizar distintos parámetros de configuraciones en base a clases, lo cual es un mecanismo muy interesante que tenemos para tener configuraciones de todo tipo, y para distintos ambientes de desarrollo.

Simplemente creamos un archivo con cualquier nombre y extensión de .py y agregamos una clase; por ejemplo un archivo llamado configuration.py; por ejemplo, en nuestro curso de Flask, empleamos la siguiente configuración.

Este método es el más profesional y el que recomiendo en mis cursos. Permite organizar configuraciones por entorno (desarrollo, testing, producción) y mantener una estructura clara.

class BaseConfig:
   SECRET_KEY = "Key"
   DEBUG = True
   TESTING = False
class ProductionConfig(BaseConfig):
   DEBUG = False
class DevelopmentConfig(BaseConfig):
   DEBUG = True
   TESTING = True

Este es uno de los que uso en el curso y libro sobre Flask:

class BaseConfig(object):
   USER_APP_NAME = 'FlaskMalcen'
   USER_ENABLE_EMAIL = True
   'Base configuracion'
   SECRET_KEY = 'Key'
   DEBUG = True
   TESTING = False
   SQLALCHEMY_DATABASE_URI="mysql+pymysql://root:root@localhost:3306/pyalmacen2"
   RECAPTCHA_PUBLIC_KEY='6LffHtEUAAAAAI_KcKj6Au3R-bwhqRhPGe-WhHq_'
   RECAPTCHA_PRIVATE_KEY='6LffHtEUAAAAAJdHhV9e8yLOSB12rm8WW8CMxN7X'
   BABEL_TRANSLATION_DIRECTORIES='/***/flask_app/translations'
   #WTF_CSRF_TIME_LIMIT = 10
class ProductionConfig(BaseConfig):
   'Produccion configuracion'
   DEBUG = False
class DevelopmentConfig(BaseConfig):
   'Desarrollo configuracion'
   DEBUG = True
   TESTING = True
   SECRET_KEY = 'Desarrollo key'
   #MAIL_SUPPRESS_SEND = False
   MAIL_SERVER = "smtp.mailtrap.io"
   MAIL_PORT = 2525
   MAIL_USERNAME="xxx"
   MAIL_PASSWORD="xxx"
   #MAIL_DEFAULT_SENDER=('andres de DL',"andres@gmail.com")
   MAIL_USE_TLS=True
   MAIL_USE_SSL=False
   USER_EMAIL_SENDER_EMAIL="andres@gmail.com"
   CACHE_TYPE = "simple"

Luego, cargamos la clase según el entorno:

app.config.from_object('configuration.DevelopmentConfig')

Configuración basada en variables de entorno

Ideal para entornos en la nube o Docker. Puedes definir el entorno de Flask así:

$ export FLASK_ENV=development
$ flask run

O incluso usar .env con la extensión python-dotenv.

Configuración basada en clases y herencia entre entornos

La herencia entre clases permite definir una clase base con parámetros comunes y extenderla para cada ambiente. Con esto podemos heredarlo a otras clases que vendrán siendo los distintos ambientes o modos que queramos que tenga nuestra aplicación.

En mi caso, suelo usar este patrón:

class BaseConfig:
   SECRET_KEY = 'Key'
   SQLALCHEMY_DATABASE_URI = "mysql+pymysql://root:root@localhost:3306/pyalmacen2"
class DevelopmentConfig(BaseConfig):
   DEBUG = True
   TESTING = True
   MAIL_SERVER = "smtp.mailtrap.io"
class ProductionConfig(BaseConfig):
   DEBUG = False

Así puedo cambiar entre ambientes simplemente con:

main.py

from config import DevConfig 
***
app = Flask(__name__) 
app.config.from_object(DevConfig)
# app.config.from_object('configuration.ProductionConfig')
***

Consejo práctico: define tus variables sensibles (usuario, contraseña, claves API) en un archivo .env o en tu sistema de despliegue, nunca en el código.

Lo interesante de esto, es que nosotros podemos fácilmente emplear configuraciones comunes que son las que tenemos en nuestra clase llamada BaseConfig y podemos heredarlas a otras clases que son las que empleamos para indicar los distintos modos de nuestra aplicación y este es el que empleamos en el curso sobre Flask.

⚡ Configuración dinámica y ajustes en tiempo de ejecución

A veces, necesitamos que Flask se adapte dinámicamente a ciertos valores. Por ejemplo, configurar una carpeta de subida de archivos en función de la ruta actual:

import os
app.config['UPLOAD_FOLDER'] = os.path.realpath('.') + '/static/uploads'

Cuando probé este enfoque en proyectos reales, me permitió mantener rutas coherentes en distintos entornos sin duplicar configuraciones.

También puedes modificar cualquier parámetro en tiempo real:

app.config['CACHE_TYPE'] = 'simple'

Esto resulta muy útil para pruebas rápidas o ajustes temporales sin reiniciar el servidor.

Como puedes ver, esta es la versión más completa que puedes escoger al momento de desarrollar tus configuraciones el Flask, ya que podemos variar fácilmente entre un ambiente a otro, activando o desactivando ciertas configuraciones de manera automática con tan solo cambiar una línea de código.

Buenas prácticas y errores comunes al configurar Flask

• No dejes DEBUG=True en producción.
  Puede exponer información sensible del servidor.
• No incluyas claves secretas en el repositorio.
  Usa variables de entorno (os.environ) o archivos .env.
• Separa los entornos.
  Define configuraciones diferentes para desarrollo, testing y producción.
• Usa herencia de clases.
  Evita duplicar configuraciones y centraliza las comunes en una clase base.
• ⚙️ Centraliza todo en config.py.
  Facilita el mantenimiento y la portabilidad del proyecto.

❓ Preguntas frecuentes sobre configuraciones en Flask

¿Cuál es la mejor manera de manejar múltiples entornos en Flask?
Usar clases de configuración (BaseConfig, DevelopmentConfig, etc.) y cargarlas según el contexto.

¿Qué diferencia hay entre from_object y from_pyfile?
from_object carga una clase o módulo Python; from_pyfile lee un archivo .py específico. El primero es más flexible para grandes proyectos.

¿Cómo proteger la SECRET_KEY?
Almacénala en una variable de entorno o usa python-dotenv para cargarla desde un archivo .env.

¿Se pueden usar variables de entorno para configurar Flask?
Sí, y es lo más recomendable para producción.

Conclusión

Configurar Flask correctamente marca la diferencia entre una app frágil y una aplicación sólida y escalable.
Desde configuraciones simples con app.config hasta arquitecturas completas con clases y herencia, Flask te da toda la flexibilidad que necesitas.

En mi experiencia, el enfoque basado en clases es el que más beneficios ofrece: organización, seguridad y facilidad de mantenimiento.