Python es uno de los lenguajes de desarrollo más populares. Su sintaxis sencilla y sus bajas barreras de entrada lo convierten en un buen candidato para los programadores novatos que esperan hacerse un hueco en el panorama del desarrollo de software.
Una gran cantidad de frameworks y bibliotecas facilitan la puesta en marcha de una aplicación Python. Entre ellos están Django, FastAPI y Flask. El framework Flask atrae a los desarrolladores de Python porque permite crear prototipos y personalizarlos fácilmente.
Este artículo práctico muestra cómo desarrollar una sencilla aplicación Python conectada a una base de datos utilizando Flask.
Aplicaciones Python Más Fáciles con Flask
Desarrollado en 2010, Flask es muy adecuado para desarrollar aplicaciones web Python gracias a su facilidad de uso y flexibilidad. Su arquitectura simplificada se centra en proporcionar lo básico, al tiempo que facilita la inclusión de bibliotecas para la funcionalidad que necesites. Este enfoque hace que Flask sea ideal para muchos proyectos, desde aplicaciones sencillas hasta sistemas complejos.
Flask ofrece varias herramientas y funcionalidades para soportar el desarrollo de aplicaciones web, entre las que se incluyen:
- Bibliotecas y herramientas para gestionar peticiones y respuestas HTTP
- La capacidad de dirigir peticiones a funciones designadas
- Soporte para plantillas de renderizado
- Soporte para bases de datos
- Sistemas de autenticación y autorización
Cómo Crear tu Aplicación Python con Flask
Puedes explorar las ventajas de utilizar Flask para el desarrollo de aplicaciones web creando una aplicación web en Python utilizando Flask. A continuación, puedes crear y desplegar la aplicación utilizando el servicio de Alojamiento de Aplicaciones Web de Kinsta y conectarla a una Base de Datos Administrada en la plataforma Kinsta.
Requisitos previos de la aplicación Python con Flask
Para seguir este tutorial, necesitarás
- Python versión 3 o superior
- MySQL Workbench
- Los paquetes pip y virtualenv de Python instalados
- Un editor de código
- Una cuenta en Bitbucket, GitHub o GitLab para alojar tu repositorio Git
- Una cuenta MyKinsta (registro gratuito) para servir la aplicación
Instalación de Flask para Python
Ve a tu terminal (Linux o macOS) o Símbolo del Sistema (Windows). Empieza creando un directorio llamado flask_demo.
Cambia al nuevo directorio y crea un entorno virtual Python utilizando el comando python3 -m venv venv. En este caso, también utilizaremos venv como nombre para el directorio que soportará el entorno virtual.
Activa el entorno virtual utilizando uno de estos comandos:
venv\Scripts\activateen Windowssource venv/bin/activateen Linux o macOS
Ahora, instala Flask utilizando pip ejecutando pip install flask.
El trabajo realizado hasta ahora en tu terminal debería tener este aspecto:
Crear una Aplicación Base
A continuación, crea la aplicación base y revisa su funcionalidad mostrando contenido al navegador.
En el directorio flask_demo, crea un archivo llamado demo.py y añade el siguiente código:
from flask import Flask
app = Flask(__name__)
# Routes
@app.route('/')
def index():
return "Happy Coding!"
if __name__ == '__main__':
app.run(debug=True)Este código importa Flask desde el módulo flask y crea una instancia del mismo llamada app. A continuación, el código crea una ruta que devuelve el texto «Happy Coding!» (¡Feliz Programación!) cuando los usuarios visitan la aplicación en un navegador. Por último, ejecuta el servidor de desarrollo una vez que se inicia el script.
Inicia la aplicación ejecutando flask --app demo run en el terminal. La bandera --app especifica la ubicación de la aplicación que ejecutará — en este caso, el archivo demo.py.
Añadir Plantillas a tu Aplicación Python Flask
Añadir plantillas a tu aplicación reforzará tu contenido. Primero, crea un directorio llamado templates en la raíz de tu aplicación. A continuación, entra en el directorio templates y crea un archivo llamado index.html que contenga el siguiente código HTML:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>HomePage</title>
</head>
<body>
<h3>Flask Demo Application</h3>
<p>My name is John Doe - learning about Application Deployment!</p>
</body>
</html>En demo.py, importa render_template del módulo flask y renderiza la plantilla index.html en la función de la ruta de esta forma:
from flask import Flask, render_template
app = Flask(__name__)
# Routes
@app.route('/')
def index():
return render_template('index.html')
if __name__ == '__main__':
app.run(debug=True)A continuación, sirve tu aplicación ejecutando flask --app demo run en tu entorno local. Utiliza la dirección local indicada en el terminal para lanzar la aplicación en tu navegador. Deberías ver algo como esto:
Conectar Tu Aplicación Flask a una Base de Datos Local
Crearás una conexión a una base de datos local — MySQL — que almacene el contenido de la aplicación.
Para conectar tu aplicación Flask a MySQL, instala lo siguiente:
- flask_mysqldb, el conector MySQL para Flask, utilizando
pip install flask_mysqldb - Python-dotenv, para leer variables de entorno, utilizando
pip install python-dotenv - El conector MySQL de Python, utilizando
pip install mysql-connector-python - La dependencia MySQL, utilizando
pip install mysqlclient
Dirígete a MySQL Workbench para crear una base de datos. Asegúrate de añadir un usuario de base de datos con permisos para acceder a la base de datos y crear tablas.
Crea un archivo .env en el directorio raíz de tu aplicación para guardar los detalles de conexión a la base de datos. Añadirías las credenciales de tu usuario de base de datos y el nombre de la base de datos a esta plantilla:
DB_HOST="localhost"
DB_USER="your-db-user"
DB_PASSWORD="your-db-password"
DB_NAME="your-db-name"En un script demo.py revisado, ahora importaremos el conector MySQL y utilizaremos Python-dotenv para leer las claves de las variables de entorno en el archivo .env. Este nuevo script demo.py también comprueba la existencia de una tabla llamada persons en la base de datos y la creará y rellenará si no existe.
import os
from flask import Flask, render_template
from flask_mysqldb import MySQL
from dotenv import load_dotenv
load_dotenv()
app = Flask(__name__)
app.config['MYSQL_HOST'] = os.getenv("DB_HOST")
app.config['MYSQL_USER'] = os.getenv("DB_USER")
app.config['MYSQL_PASSWORD'] = os.getenv("DB_PASSWORD")
app.config['MYSQL_DB'] = os.getenv("DB_NAME")
mysql = MySQL(app)
@app.route('/')
def index():
cursor = mysql.connection.cursor()
cursor.execute("SHOW TABLES LIKE 'persons'")
result = cursor.fetchone()
if not result:
cursor.execute(''' CREATE TABLE persons (id INTEGER, firstname VARCHAR(20), lastname VARCHAR(20)) ''')
cursor.execute(''' INSERT INTO persons VALUES(1, 'John', 'Doe') ''')
cursor.execute(''' INSERT INTO persons VALUES(2, 'Milly', 'Winfrerey') ''')
mysql.connection.commit()
cursor.execute('SELECT * FROM persons')
entry = cursor.fetchall()
cursor.close()
return render_template('index.html', entry=entry)Después de instanciar Flask, el código anterior utiliza variables de entorno para capturar los atributos de la base de datos del archivo .env en la raíz de tu aplicación
A continuación, el código instancia MySQL y lo asocia a Flask. Crea un objeto cursor en la ruta index. A continuación, el código busca una tabla llamada persons en la base de datos. Si no la encuentra, la crea con los atributos id, firstname, y lastname e inserta dos filas de datos.
Las tres líneas siguientes ejecutan un comando SQL para seleccionar todas las filas de la tabla persons y obtener los resultados. El objeto cursor se cierra, y los resultados de la consulta se pasan como la variable de contexto entry para su representación con la plantilla.
Aquí tienes un archivo de plantilla index.html revisado que puede procesar los resultados de la consulta a la base de datos:
<!DOCTYPE html><html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>HomePage</title>
</head>
<body>
<h3>Flask Demo Application</h3>
{% for e in entry %}
<p>My name is {{e[1]}} {{e[2]}} - learning about Application Deployment!</p>
{% endfor %}
</body>
</html>Ejecuta la aplicación y, a continuación, vuelve a MySQL Workbench para comprobar los datos. Debería tener el siguiente aspecto:
Al consultar la tabla, se devuelven las dos entradas generadas por la aplicación. Tu aplicación muestra ahora en el navegador el siguiente contenido derivado de la base de datos:
Cómo Desplegar Tu Aplicación Python Flask en Kinsta
Ahora que tu aplicación está funcionando localmente, puedes hacerla visible al mundo alojándola en Kinsta. Puedes combinar los servicios de Alojamiento de Aplicaciones Web y Alojamiento de Bases de Datos Administradas de Kinsta para dar vida a esta aplicación (y a tus futuros esfuerzos) en la nube. Y puedes probar ambos de forma gratuita.
Preparar Tu Proyecto Python para el Despliegue
La plataforma de Alojamiento de Aplicaciones Web de Kinsta despliega tu código desde tu host Git favorito. Tu siguiente paso es configurar el entorno de tu aplicación para que admita esa vía y permitir que Kinsta despliegue tu aplicación con todas sus dependencias necesarias.
Empieza creando un nuevo directorio dentro de la raíz de tu proyecto flask_demo. Llamémoslo myapp. A continuación, mueve el directorio templates y el archivo demo.py a myapp.
Dentro del directorio myapp, crea un archivo wsgi.py con el siguiente contenido:
from myapp.demo import app as application
if __name__ == "__main__":
application.run(debug=True)El proceso de construcción en Kinsta también utilizará pip para generar tu aplicación. Puedes pasar una lista de las dependencias de tu aplicación a pip en la parte de producción utilizando un archivo requirements.txt en el directorio raíz del proyecto.
Mientras sigues trabajando en el entorno virtual venv y dentro del directorio raíz flask_demo, puedes generar un archivo requirements.txt específico para tu proyecto con el siguiente comando:
pip freeze > requirements.txtEl contenido del archivo de texto resultante tendrá el siguiente aspecto:
blinker==1.7.0
click==8.1.7
Flask==3.0.0
Flask-MySQLdb==2.0.0
itsdangerous==2.1.2
Jinja2==3.1.2
MarkupSafe==2.1.3
mysql-connector-python==8.2.0
mysqlclient==2.2.1
protobuf==4.21.12
python-dotenv==1.0.0
Werkzeug==3.0.1No enviarás el archivo .env con sus secretos de base de datos al servidor de producción. Como no necesitarás la biblioteca python-dotenv para leer .env en producción, puedes eliminar su referencia de requirements.txt y eliminar (o comentar) estas líneas en demo.py:
from dotenv import load_dotenv
load_dotenv()Añadir un Servidor HTTP WSGI Python al Proyecto
Algo que falta en los requisitos anteriores es una forma de servir la aplicación a través de HTTP en un entorno de producción. El servidor de desarrollo utilizado en tu máquina local no servirá. Para este proyecto, utilizarás el paquete Web Server Gateway Interface (WSGI) Gunicorn entre la aplicación y los servidores web Nginx de Kinsta.
Puedes añadir un requisito de Gunicorn a tu proyecto instalándolo en tu entorno virtual de la siguiente manera:
pip install gunicornUna vez instalado Gunicorn, utiliza pip para volver a generar requirements.txt.
Una alternativa a la instalación local de Gunicorn es editar requirements.txt y añadir simplemente una entrada como ésta:
gunicorn==21.2.0Para concluir el trabajo preliminar para el servidor WSGI, crea un archivo en el directorio raíz del proyecto llamado Procfile y añade la siguiente línea:
web: gunicorn myapp.wsgiEsta será la base del comando de inicio de tu aplicación en producción.
Prepara Tu Proyecto para Git
La estructura de directorios revisada está lista para su despliegue en Kinsta, pero no querrás que todos esos archivos vayan a producción. Crea un archivo .gitignore en la raíz del proyecto con un contenido como este
/venv
.envEsto evitará que los archivos del directorio venv y los secretos de la base de datos local en .env se suban a tu host Git.
Ahora puedes iniciar tu entorno Git local y enviar el código a tu servidor Git utilizando tus herramientas preferidas.
Desplegar Tu Aplicación Python Flask en Kinsta
Accede a tu panel MyKinsta y asegúrate de que has autorizado a Kinsta para acceder a tu proveedor de servicios Git. Sigue los pasos para añadir una aplicación, seleccionando el repositorio y la rama en el host Git donde Kinsta encontrará el código de este proyecto Flask.
Cuando configures el entorno de construcción, selecciona Utilizar Buildpacks para configurar la imagen del contenedor, pero deja el resto de ajustes en sus valores predeterminados. (No proporcionarás un comando de Inicio porque eso ya está definido en tu Procfile)
Después de revisar la información de facturación (¡todavía puedes empezar gratis!), haz clic en el botón Construir ahora y observa el progreso en el visor de registros:
Añadir una Base de Datos a tu Aplicación Python Flask
Kinsta tiene cuatro opciones de bases de datos administradas para satisfacer tus necesidades y los requisitos de tu aplicación: Redis, PostgreSQL, MariaDB y MySQL. Para este tutorial, nos hemos basado en el servicio de base de datos MySQL.
Sigue las instrucciones oficiales para añadir una base de datos, recordando seleccionar el mismo centro de datos que elegiste para tu aplicación Flask.
Tras crear la base de datos, selecciónala de la lista de tus servidores de bases de datos disponibles y desplázate hasta la sección Conexiones internas / Aplicaciones permitidas de la pestaña Visión general. Cuando pulses el botón Añadir conexión, el servicio de tu aplicación Flask en el mismo centro de datos estará disponible para seleccionarlo:
Haz clic en la casilla Añadir variables de entorno a la aplicación antes de crear la nueva conexión. Esto muestra las variables de entorno que llevarán los secretos de tu base de datos — todo ello gestionado de forma segura sin necesidad del archivo .env.
En la parte inferior del cuadro de diálogo anterior, las opciones Disponible durante el tiempo de ejecución y Disponible durante el proceso de construcción estarán activadas por defecto, y eso es exactamente lo que quieres.
Tras hacer clic finalmente en el botón Añadir conexión, las variables de entorno necesarias para el acceso a la base de datos se aplicarán a la Configuración de tu proyecto en el panel Aplicaciones de MyKinsta:
Ahora, incluso cuando reconstruyas tu aplicación tras futuras mejoras, los datos de conexión a la base de datos persistirán.
¡Enhorabuena! Acabas de crear una aplicación Python Flask y la has desplegado en la plataforma Kinsta.
Resumen
El framework personalizable de Flask hace que crear una aplicación Python sea mucho más sencillo. Utilizar Kinsta para desplegar una aplicación Flask facilita aún más las cosas, acelerando el desarrollo y despliegue de aplicaciones.
Aquí hemos aprendido a crear una aplicación sencilla conectada a una base de datos dentro de un entorno de desarrollo local y luego ponerla a disposición del resto del mundo en las plataformas de Alojamiento de Aplicaciones Web y Alojamiento de Bases de Datos de Kinsta.
Explora qué más puedes construir en nuestra plataforma navegando por nuestras Plantillas de Inicio Rápido.
Steve Bonisteel es un Editor Técnico de Kinsta que comenzó su carrera de redactor como periodista de prensa escrita, persiguiendo ambulancias y camiones de bomberos. Lleva tratando temas relacionados con la tecnología de Internet desde finales de la década de 1990.
Deja una respuesta