¿Qué es Flask Python? Un breve tutorial sobre este mi­cro­fra­me­wo­rk

Flask es un framework web es­pe­cia­l­me­n­te ligero, pensado tanto para quienes dan sus primeros pasos con Python como para de­sa­rro­lla­do­res con ex­pe­rie­n­cia. Su filosofía se basa en centrarse en lo esencial y dejar el resto en manos de ex­te­n­sio­nes y bi­blio­te­cas externas que puedes in­co­r­po­rar según las ne­ce­si­da­des de tu proyecto.

Python y sus fra­me­wo­r­ks web

Python es uno de los lenguajes de pro­gra­ma­ción usados en Internet más populares del mundo. Su éxito se debe, en gran parte, a una filosofía que apuesta por un código claro, conciso y fácil de mantener. Esto reduce las fuentes de errores, agiliza el apre­n­di­za­je, es­pe­cia­l­me­n­te con la ayuda de un tutorial de Python, y hace que el de­sa­rro­llo sea más eficiente.

Creado en 1991 por Guido van Rossum, Python continúa evo­lu­cio­na­n­do gracias a una gran comunidad in­te­r­na­cio­nal, coor­di­na­da por la or­ga­ni­za­ción sin ánimo de lucro Python Software Fou­n­da­tion. El lenguaje es de código abierto, mu­l­ti­pla­ta­fo­r­ma y admite distintos pa­ra­di­g­mas de pro­gra­ma­ción, como el enfoque orientado a objetos o el funcional. También admite fu­n­cio­na­li­da­des como el logging y puede eje­cu­tar­se como un script CGI.

Para crear páginas web dinámicas y apli­ca­cio­nes online, Python cuenta con varios fra­me­wo­r­ks web que au­to­ma­ti­zan tareas re­pe­ti­ti­vas y pro­po­r­cio­nan es­tru­c­tu­ras ya pre­pa­ra­das. Gracias a ello, se evitan errores comunes y problemas típicos de Python, y los proyectos resultan más seguros y rápidos. Muchas funciones ha­bi­tua­les pueden in­te­grar­se di­re­c­ta­me­n­te sin necesidad de de­sa­rro­llar­las desde cero.

Uno de los fra­me­wo­r­ks web más populares del eco­si­s­te­ma Python es django CMS. Como solución full stack, ofrece un conjunto muy amplio de he­rra­mie­n­tas y fu­n­cio­na­li­da­des listas para usar. Esto lo hace potente y completo, pero también más rígido y es­tru­c­tu­ra­do. Como co­n­tra­pu­n­to, Flask se presenta como una al­te­r­na­ti­va mi­ni­ma­li­s­ta y flexible, ideal si prefieres construir tu apli­ca­ción pieza a pieza y mantener un control total sobre su ar­qui­te­c­tu­ra.

¿Qué es Flask?

Mientras que los fra­me­wo­r­ks full stack como Django ofrecen a los de­sa­rro­lla­do­res numerosas bi­blio­te­cas propias, Flask sigue un enfoque diferente. El framework web, pre­se­n­ta­do por el de­sa­rro­lla­dor austríaco Armin Ronacher en 2010, es de­li­be­ra­da­me­n­te mi­ni­ma­li­s­ta y evita cualquier fu­n­cio­na­li­dad que no sea esencial. Solo incluye el motor de pla­n­ti­llas Jinja y la bi­blio­te­ca “Werkzeug”. Flask omite por completo todas las funciones que ya están cubiertas por otras bi­blio­te­cas, pero permite in­te­grar­las fá­ci­l­me­n­te cuando se necesitan. Está bajo la licencia BSD, es gratuito y de código abierto. Como al­te­r­na­ti­va a Django y otros fra­me­wo­r­ks más completos, Flask logró atraer a una amplia comunidad en muy poco tiempo.

Co­n­fi­gu­rar Flask en Python y crear una apli­ca­ción web

Antes de poder co­n­fi­gu­rar Flask para Python, debes cumplir algunos re­qui­si­tos previos. Es necesario tener Python 3 instalado, así como un editor de texto o un entorno de de­sa­rro­llo integrado (IDE) y acceso a Internet. También resulta útil contar con co­no­ci­mie­n­tos básicos de Python, pro­gra­ma­ción, tipos de datos y bucles for. Flask es un buen punto de partida para aprender a crear apli­ca­cio­nes web. Configura el framework de la siguiente manera:

1. Crea un entorno virtual para separar el nuevo proyecto de tus otras bi­blio­te­cas o proyectos de Python. De lo contrario, podrían pro­du­ci­r­se co­n­fli­c­tos en tu sistema. El comando co­rre­s­po­n­die­n­te es:

$ python -m venv nuevoproyecto

2. Ahora instala Flask. Para ello, lo más re­co­me­n­da­ble es utilizar el gestor de paquetes pip. El comando adecuado es:

$ pip install flask

3. Para comprobar si la in­s­ta­la­ción se ha realizado co­rre­c­ta­me­n­te, utiliza este comando:

python -c "import flask; print(flask.__version__)"

4. A co­n­ti­nua­ción, puedes probar Flask y crear una apli­ca­ción base sencilla. Para ello, abre un archivo en tu di­re­c­to­rio. En este ejemplo lo llamamos inicio.py y lo abrimos con nano:

$ nano inicio.py

5. Escribe el siguiente código en ese archivo:

from flask import Flask
app = Flask(__name__)
@app.route("/")
def test():
    return "Hola, Flask"

6. Guarda y cierra el archivo.

7. Con la variable de entorno FLASK_APP indicas a Flask dónde se encuentra el archivo co­rre­s­po­n­die­n­te:

$ export FLASK_APP=inicio

8. Con FLASK_ENV ejecutas el archivo en modo de de­sa­rro­llo:

$ export FLASK_ENV=development

9. Ahora ejecuta la apli­ca­ción:

$ flask run

El resultado será algo similar a lo siguiente:

Output
- Sirviendo la app de Flask "inicio" (carga diferida)
- Entorno: desarrollo
- Modo debug: activado
- Ejecutándose en [Dirección IP]/ (Pulsa CTRL+C para salir)
- Reiniciando con stat
- ¡El depurador está activo!
- PIN del depurador [PIN]

Ventajas y de­s­ve­n­ta­jas de Flask

Existen buenas razones para utilizar Flask. Sin embargo, según el tipo de proyecto, algunos aspectos pueden resultar menos fa­vo­ra­bles. Por eso, merece la pena revisar con atención las ventajas y de­s­ve­n­ta­jas de este framework web.

Ventajas

✓ Alcance: es difícil encontrar un framework más ligero que Flask. Se instala en muy poco tiempo y puede uti­li­zar­se casi de inmediato. ✓ Fle­xi­bi­li­dad: la fle­xi­bi­li­dad es otro de sus puntos fuertes. Puedes resolver cada problema de forma in­di­vi­dual e integrar úni­ca­me­n­te las bi­blio­te­cas que realmente necesitas. Así es posible adaptar cada proyecto a tus re­qui­si­tos. ✓ Curva de apre­n­di­za­je: con un tutorial de Flask, los progresos llegan rápido. El framework está pensado para ser sencillo, pero permite trabajar también en proyectos más avanzados. Por ello, es una buena opción tanto para pri­n­ci­pia­n­tes como para pro­fe­sio­na­les. ✓ Código abierto: Flask es gratuito y de código abierto, por lo que puedes probarlo sin coste y comprobar si se adapta a tus ne­ce­si­da­des. ✓ Comunidad: Flask cuenta con una comunidad muy amplia que ofrece ayuda y consejos tanto a personas que empiezan como a de­sa­rro­lla­do­res ex­pe­ri­me­n­ta­dos. Las dudas y problemas suelen re­so­l­ve­r­se rá­pi­da­me­n­te.

De­s­ve­n­ta­jas

✗ Alcance: según el uso previsto, su carácter mi­ni­ma­li­s­ta también puede ser una de­s­ve­n­ta­ja. Muchas funciones deben in­te­grar­se aparte, mientras que otros fra­me­wo­r­ks ya las incluyen de serie. ✗ De­pe­n­de­n­cia de terceros: el uso de bi­blio­te­cas externas co­n­s­ti­tu­ye siempre una posible fuente de errores, y en Flask son im­pre­s­ci­n­di­bles. ✗ Re­s­po­n­sa­bi­li­dad: mientras que otros fra­me­wo­r­ks gestionan parte del ma­n­te­ni­mie­n­to de forma au­to­má­ti­ca, en Flask esa re­s­po­n­sa­bi­li­dad recae sobre los usuarios. Esto aporta mayor control, pero también implica más trabajo.

Ejemplo Hello-World: rutas, pla­n­ti­llas y API

Para conocer mejor el fu­n­cio­na­mie­n­to básico de Flask, a co­n­ti­nua­ción se presenta un pequeño ejemplo que ilustra los conceptos fu­n­da­me­n­ta­les del framework. Crearemos una apli­ca­ción web sencilla que muestra cómo funcionan juntos el en­ru­ta­mie­n­to, las pla­n­ti­llas y una API REST. El ejemplo consta de dos archivos:

• app.py: aquí se encuentra nuestro código en Python.
• templates/hello.html: este archivo es una plantilla Jinja2 para mostrar la página web de forma dinámica.

El archivo app.py se ve de la siguiente manera:

from flask import Flask, jsonify, render_template, request
app = Flask(__name__)
@app.route("/")
def home():
    return "Hello World!"
@app.route("/greet/<name>")
def greet(name):
    return render_template("hello.html", name=name)
@app.route("/api/square", methods=["GET"])
def square():
    number = request.args.get("number", default=0, type=int)
    result = number ** 2
    return jsonify({"number": number, "square": result})
if __name__ == "__main__":
    app.run(debug=True)

Este es el archivo hello.html, que funciona como plantilla:

<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<title>Saludo</title>
</head>
<body>
<h1>¡Hola, {{ name }}!</h1>
<p>Bienvenido a Flask con la plantilla Jinja2.</p>
</body>
</html>

Con @app.route definimos di­fe­re­n­tes puntos finales, es decir, URL que el servidor puede responder. La página de inicio (“/”) muestra si­m­ple­me­n­te el texto “Hello World!”. A través de una ruta dinámica (“/greet/<name>”), podemos mostrar un saludo personal. El nombre se toma de la URL y se pasa a nuestra plantilla Jinja2, que lo inserta en HTML (ver el código de templates/hello.html).

Además, de­mo­s­tra­mos cómo crear una pequeña API REST: En el punto final “/api/square”, puedes pasar un número como parámetro de la URL y la apli­ca­ción devolverá el cuadrado del número como respuesta JSON. Vemos así que Flask puede servir tanto a páginas web clásicas como a puntos finales de API. También es posible integrar co­n­te­ni­dos dinámicos en HTML mediante pla­n­ti­llas, sin necesidad de modificar la página ma­nua­l­me­n­te.

Ex­te­n­sio­nes de Flask

Dado que Flask es muy mi­ni­ma­li­s­ta, muchas funciones útiles, como la conexión a bases de datos, la au­te­n­ti­ca­ción o la va­li­da­ción de fo­r­mu­la­rios, no están in­te­gra­das. Para añadir estas ca­pa­ci­da­des se utilizan ex­te­n­sio­nes de Flask, de­sa­rro­lla­das y ma­n­te­ni­das por la comunidad. Pueden in­te­grar­se fá­ci­l­me­n­te en una apli­ca­ción y amplían co­n­si­de­ra­ble­me­n­te la fu­n­cio­na­li­dad sin modificar el framework. De este modo, los de­sa­rro­lla­do­res pueden elegir solo los co­m­po­ne­n­tes que realmente necesitan y construir su apli­ca­ción de forma modular. Las ex­te­n­sio­nes suelen seguir la misma es­tru­c­tu­ra que Flask y cuentan con una buena do­cu­me­n­ta­ción.

Ejemplos de ex­te­n­sio­nes im­po­r­ta­n­tes de Flask son:

• Flask-SQ­LA­l­che­my: una extensión para conectar con bases de datos. Integra el popular ORM SQ­LA­l­che­my en Flask y permite trabajar con bases de datos a través de clases de Python.
• Flask-WTF: esta extensión facilita la creación y va­li­da­ción de fo­r­mu­la­rios web. Incluye funciones de seguridad como pro­te­c­ción CSRF y si­m­pli­fi­ca el manejo de datos de usuario.
• Flask-Login: como indica su nombre, Flask-Login si­m­pli­fi­ca la gestión de usuarios y la au­te­n­ti­ca­ción. Se encarga del estado de inicio de sesión, las sesiones y la pro­te­c­ción de acceso para rutas es­pe­cí­fi­cas.
• Flask-Migrate: con Flask-Migrate puedes gestionar mi­gra­cio­nes de bases de datos que aplican au­to­má­ti­ca­me­n­te los cambios en su es­tru­c­tu­ra. Su uso es ideal junto con Flask-SQ­LA­l­che­my para ac­tua­li­za­cio­nes or­ga­ni­za­das.
• Flask-RESTful: esta extensión facilita la creación de API REST. Pro­po­r­cio­na recursos, rutas y métodos HTTP como GET, POST, PUT o DELETE de forma es­ta­n­da­ri­za­da.

Es­tru­c­tu­ra del proyecto y mejores prácticas

En proyectos con Flask, es re­co­me­n­da­ble definir desde el principio una or­ga­ni­za­ción clara y es­tru­c­tu­ra­da. Aunque té­c­ni­ca­me­n­te las apli­ca­cio­nes pequeñas pueden funcionar en un solo archivo, una es­tru­c­tu­ra ordenada facilita mucho el ma­n­te­ni­mie­n­to y la am­plia­ción de la apli­ca­ción.

En proyectos más grandes, suele crearse un di­re­c­to­rio templates para los archivos HTML, otro static para CSS, Ja­va­S­cri­pt e imágenes, así como carpetas como app o src para los módulos de Python. Dentro de la carpeta principal pueden añadirse su­b­ca­r­pe­tas para Blue­pri­nts, modelos, fo­r­mu­la­rios o uti­li­da­des, con el objetivo de separar las funciones de manera lógica. Los Blue­pri­nts permiten organizar los distintos co­m­po­ne­n­tes de la apli­ca­ción de forma modular, por ejemplo, un sistema de usuarios o un blog.

Las mejores prácticas también re­co­mie­n­dan proteger valores de co­n­fi­gu­ra­ción, como URL de bases de datos o claves secretas, en un archivo config.py separado o mediante variables de entorno. El registro continuo ayuda a detectar errores con an­te­la­ción y a co­m­pre­n­der mejor el co­m­po­r­ta­mie­n­to de la apli­ca­ción. Además, es aco­n­se­ja­ble utilizar entornos virtuales para gestionar las de­pe­n­de­n­cias de forma ordenada. El control de versiones con Git también es una práctica estándar.

Flask: seguridad y pruebas

La seguridad y las pruebas no son extras op­cio­na­les, sino partes fu­n­da­me­n­ta­les de una apli­ca­ción pro­fe­sio­nal en Flask. Por ello, no deberían faltar en ningún tutorial de Flask. Si desde el principio prestas atención al cifrado, la va­li­da­ción de entradas, las co­n­fi­gu­ra­cio­nes seguras y las pruebas au­to­ma­ti­za­das, podrás de­sa­rro­llar apli­ca­cio­nes web estables y seguras que se amplíen sin problemas en el futuro.

Seguridad en Flask

Debido a la es­tru­c­tu­ra mi­ni­ma­li­s­ta de Flask, la re­s­po­n­sa­bi­li­dad de la seguridad recae en los de­sa­rro­lla­do­res. Una pro­te­c­ción básica incluye el uso de pro­te­c­ción CSRF en los fo­r­mu­la­rios, es­pe­cia­l­me­n­te cuando hay entradas de usuario. Para ello, la extensión Flask-WTF pro­po­r­cio­na me­ca­ni­s­mos fiables.

Las co­n­tra­se­ñas nunca deben al­ma­ce­nar­se en texto claro, sino siempre cifradas o con hash. Para este fin, resultan adecuadas bi­blio­te­cas como werkzeug.security o bcrypt. También es esencial la va­li­da­ción de entradas para prevenir in­ye­c­cio­nes SQL, ataques XSS u otros tipos de ma­ni­pu­la­ción.

En las sesiones y cookies deben co­n­fi­gu­rar­se las flags HttpOnly y Secure para proteger los datos sensibles. Además, co­n­fi­gu­ra­cio­nes como URL de bases de datos o claves API deben ge­s­tio­nar­se mediante variables de entorno o archivos de co­n­fi­gu­ra­ción separados, y no di­re­c­ta­me­n­te en el código.

Pruebas en Flask

Como en cualquier apli­ca­ción, las pruebas en Flask son ese­n­cia­les para ga­ra­n­ti­zar la es­ta­bi­li­dad de la apli­ca­ción. Con las llamadas pruebas unitarias se verifican funciones in­di­vi­dua­les de forma aislada, mientras que las pruebas de in­te­gra­ción evalúan la in­ter­ac­ción entre varios co­m­po­ne­n­tes.

Flask ofrece un cliente de pruebas integrado, que permite simular so­li­ci­tu­des HTTP sin necesidad de iniciar realmente el servidor. Esto facilita comprobar de forma au­to­ma­ti­za­da rutas, pla­n­ti­llas y puntos finales de API. Es es­pe­cia­l­me­n­te im­po­r­ta­n­te escribir casos de prueba de manera regular, sobre todo cuando se añaden nuevas funciones, para evitar re­gre­sio­nes. Combinado con Co­n­ti­nuous In­te­gra­tion, este enfoque garantiza que la apli­ca­ción siga siendo fiable incluso cuando se producen cambios.