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

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\activate en Windows
  • source venv/bin/activate en 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:

Salida del terminal durante la creación de un entorno virtual Python y la instalación de Flask.
Creando la base de una aplicación Python Flask en la terminal.

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:

Captura de pantalla de un navegador web que muestra la fase inicial de la aplicación Flask.
Los inicios de una aplicación Python Flask en un navegador web.

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:

Captura de pantalla de los resultados de la consulta en MySQL Workbench.
Resultados de la consulta de la tabla persons en MySQL Workbench.

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:

Captura de pantalla que muestra el contenido generado a partir de la base de datos.
Contenido generado por la base de datos en el navegador.

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.txt

El 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.1

No 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 gunicorn

Una 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.0

Para 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.wsgi

Esta 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
.env

Esto 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)

Captura de pantalla de la interfaz MyKinsta para configurar un entorno de construcción.
Elegir Buildpacks para configurar la imagen contenedora de la aplicación.

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:

Captura de pantalla de las entradas de registro del despliegue de una aplicación Python Flask.
Entradas de registro para el despliegue de tu aplicación Python Flask.

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:

Captura de pantalla del cuadro de diálogo para añadir una conexión de base de datos interna en MyKinsta.
Añadir una conexión interna a una aplicación después de crear una base de datos.

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.

Captura de pantalla del cuadro de diálogo para añadir variables de entorno para las credenciales de la base de datos.
Añadir variables de entorno para una conexión interna a tu base de datos.

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:

Captura de pantalla de un cuadro de diálogo de MyKinsta que muestra las variables de entorno pasadas desde la base de datos a una aplicación.
Variables de entorno de la base de datos pasadas a la aplicación Python Flask.

Ahora, incluso cuando reconstruyas tu aplicación tras futuras mejoras, los datos de conexión a la base de datos persistirán.

Captura de pantalla de la aplicación Python Flask en funcionamiento en la plataforma Kinsta.
La aplicación Python Flask se encuentra en la plataforma Kinsta.

¡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 Kinsta

Steve Bonisteel is a Technical Editor at Kinsta who began his writing career as a print journalist, chasing ambulances and fire trucks. He has been covering Internet-related technology since the late 1990s.